diff --git a/admin/site/config.json b/admin/site/config.json
--- a/admin/site/config.json
+++ b/admin/site/config.json
@@ -1,62 +1,63 @@
{
"baseURL": "/",
"languageCode": "en-gb",
"title": "Archive of Formal Proofs",
"theme": "afp",
"publishDir": "..",
"taxonomies": {
"author": "authors",
"topic": "topics",
"dependency": "dependencies"
},
"params": {
"description": "A collection of proof libraries, examples, and larger scientific developments, mechanically checked in the theorem prover Isabelle.",
"images": [
"/images/afp.png"
],
"title": "Archive of Formal Proofs",
"mainSections": ["entries"],
"afpUrls": {
"releases": "https://www.isa-afp.org/release",
"html": "https://www.isa-afp.org/browser_info/current/AFP",
"htmlDevel": "https://devel.isa-afp.org/browser_info/current/AFP"
},
"submissionUrl": "https://ci.isabelle.systems/afp-submission"
},
"markup": {
"goldmark": {
"renderer": {
"unsafe": true
}
}
},
"menu": {
"main": [
{
"name": "Topics",
"url": "/topics/",
"weight": 2
}
]
},
"outputs": {
"home": ["html", "rss", "json"],
"taxonomyTerm": ["html", "json"]
},
"related": {
"includeNewer": true,
"indices": [
{
"name": "topic",
"weight": 10
},
{
"name": "keywords",
"weight": 100
}
],
"threshold": 80,
"toLower": true
},
- "relativeURLs": true
+ "relativeURLs": true,
+ "ignoreFiles": [ "entries\/Example-Submission" ]
}
\ No newline at end of file
diff --git a/metadata/README.md b/metadata/README.md
--- a/metadata/README.md
+++ b/metadata/README.md
@@ -1,228 +1,228 @@
Metadata format
===============
We're using the [TOML](https://toml.io/en/v1.0.0) format for metadata files. The data model is
defined in Isabelle/Scala, so larger changes can also be done in a programmatic way.
`entries/.toml`
---------------------
Storage for entry metadata. Format:
```toml
title = ""
date = --
topics = ["//...", "/..."]
abstract = """
"""
license = ""
note = ""
[authors]
[contributors]
[notify]
[history]
[extra]
[related]
```
Optional:
- ```toml
- sitegen_ignore =
+ statistics_ignore =
```
- in `[authors]` and `[contributors]`:
```toml
[authors.]
homepage = ""
email = ""
```
- in `[notify]`:
```toml
= ""
```
- in `[history]`:
```toml
-- = ""
```
- in `[extra]`:
```toml
extra- = ": "
```
- in `[related]`:
```toml
dois = [ "", ... ]
pubs = [ "", ... ]
```
[Example](/metadata/entries/Presburger-Automata.toml)
Details:
- **name**:
The toml file name (`` in this terminology) must correspond to the folder name
in `thys` directory. This short name is used as entry identifier during the whole process.
- **date**:
The date is the submission date of the entry.
- **topics**:
Currently, only three levels of topics and subtopics are allowed, but you may specify as many
topics as you wish. If multiple topics are specified, the entry will appear under each of them.
The topic must also appear in the `topics` file (see below).
- **license**:
Allowed values for the license are "bsd" and "lgpl".
- **authors**:
Authors and affiliations must appear in the `authors` file (see below). For each author, you may
provide an affiliation as homepage and/or email.
- **contributors**:
Sometimes existing entries get significant contributions from other authors. These authors can be
listed on a 'contributors' line. A separate change-history entry should indicate what these people
have contributed.
- **extra**:
If you want to have some additional text fields below the 'Abstract' column, you can use
the `extra` facility, where `` denotes an identifier (most cases 0, 1, ...) unique for each
entry. The particular
`` has no impact on output and is solely used for disambiguating multiple extra fields.
Example:
```toml
extra-0 = "Warning: Untested..."
```
- **related**:
A Place for references related to this article, e.g., print publications. DOIs are preferred and
stored by name only (e.g., `10.1000/182`). If there is none, use a formatted citation (html tags
are allowed).
`topics.toml`
-------------
Each topic and its subtopics must go into there. Format:
```toml
["First level topic"]
["First level topic".classification]
["First level topic"."Second level topic"]
["First level topic"."Second level topic".classification]
["First level topic"."Second level topic"."Third level topic"]
["First level topic"."Second level topic"."Third level topic".classification]
["First level topic"."Another second level topic"]
["First level topic"."Another second level topic".classification]
```
Topics without space may omit quotes. Only three levels of indentation are supported currently.
Optional:
- in `[<...>.classification]`:
- AMS:
```toml
ams.id = ""
ams.hierarchy = [
"",
]
```
- ACM:
```toml
acm.id = ""
acm.desc = ""
```
Details:
- **classification**:
A corresponding topic for each AMS and ACM subject classification can be put here.
- AMS:
Data comes from [MSC2020 database](https://mathscinet.ams.org/mathscinet/msc/msc2020.html). IDs
are used without `-XX` or `xx`. In the hierarchy, descriptions are stored for each level (text
in `{...}` is omitted), top level first.
- ACM:
Data comes from [2012 ACM CCS](https://dl.acm.org/ccs), and the fields can be directly copied
from the xml output.
`authors.toml`
--------------
Name, alphanumeric short name, and affiliations for each author. Format:
```toml
[]
name = ""
[.emails]
[.homepages]
```
Optional:
- in `[]`:
```toml
orcid = ""
```
- in `[.emails]`:
```toml
[.emails.]
user = [
]
host = [
]
```
- in `[.homepages]`:
```toml
= ""
```
Example:
```toml
[huch]
name = "Fabian Huch"
orcid = "0000-0002-9418-1580"
[huch.emails]
[huch.emails.huch_email]
user = [
"huch",
]
host = [
"in",
"tum",
"de",
]
[huch.homepages]
huch_homepage = "https://home.in.tum.de/~huch"
```
Details:
- **shortname**:
Author shortnames are derived from last name and characters from the first name until unique,
e.g. `haslbeck` and `haslbeckm`. Homepage and email ids are usually of form `_email` (
or `_homepage`) and are incremented for multiples, e.g. `haslbeckm_email1`.
- **orcid**:
Orcid id, identifier only.
- **parts**:
User and host are represented as lists of parts split by dots.
`releases.toml`
---------------
Contains all releases. The youngest release is always ignored, so don't forget to add old releases
when a new Isabelle version is released. Format:
```toml
[name]
-- =
```
diff --git a/metadata/entries/Example-Submission.toml b/metadata/entries/Example-Submission.toml
--- a/metadata/entries/Example-Submission.toml
+++ b/metadata/entries/Example-Submission.toml
@@ -1,35 +1,34 @@
title = "Example Submission"
date = 2004-02-25
topics = [
"Mathematics/Analysis",
"Mathematics/Number theory",
]
abstract = """
This is an example submission to the Archive of Formal Proofs. It shows
submission requirements and explains the structure of a simple typical
submission.
Note that you can use HTML tags 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
-submission guidelines before using this.
"""
+submission guidelines before using this.
"""
license = "bsd"
note = ""
-sitegen_ignore = true
+statistics_ignore = true
[authors]
[authors.klein]
homepage = "klein_homepage"
[contributors]
[notify]
klein = "klein_email"
[history]
[extra]
-extra-no-index = "no-index: true"
[related]
diff --git a/tools/afp_site_gen.scala b/tools/afp_site_gen.scala
--- a/tools/afp_site_gen.scala
+++ b/tools/afp_site_gen.scala
@@ -1,461 +1,457 @@
/* Author: Fabian Huch, TU Muenchen
Generation and compilation of SSG project for the AFP website.
*/
package afp
import isabelle.*
import afp.Metadata.{Affiliation, Author, ACM, AMS, Classification, DOI, Email, Entry, Formatted, Homepage, Reference, Release, Topic, Unaffiliated}
object AFP_Site_Gen {
/* cache */
class Cache(layout: Hugo.Layout) {
private val doi_cache = Path.basic("dois.json")
private var dois: Map[String, String] = {
val file = layout.cache_dir + doi_cache
if (file.file.exists) {
val content = File.read(file)
val json =
try { isabelle.JSON.parse(content) }
catch { case ERROR(msg) => error("Could not parse " + file.toString + ": " + msg) }
JSON.to_dois(json)
} else Map.empty
}
def resolve_doi(doi: DOI): String = {
dois.get(doi.identifier) match {
case Some(value) => value
case None =>
val res = doi.formatted()
dois += (doi.identifier -> res)
layout.write_cache(doi_cache, JSON.from_dois(dois))
res
}
}
}
/* json */
object JSON {
type T = isabelle.JSON.T
object Object {
type T = isabelle.JSON.Object.T
def apply(entries: isabelle.JSON.Object.Entry*): T = isabelle.JSON.Object.apply(entries: _*)
}
def opt(k: String, v: String): Object.T = if (v.isEmpty) Object() else Object(k -> v)
def opt(k: String, v: Option[T]): Object.T = v.map(v => Object(k -> v)).getOrElse(Object())
def opt[A <: Iterable[_]](k: String, vals: A): Object.T =
if (vals.isEmpty) Object() else Object(k -> vals)
def from_dois(dois: Map[String, String]): Object.T = dois
def to_dois(dois: T): Map[String, String] = dois match {
case m: Map[_, _] if m.keySet.forall(_.isInstanceOf[String]) &&
m.values.forall(_.isInstanceOf[String]) =>
m.asInstanceOf[Map[String, String]]
case _ => error("Could not read dois")
}
def from_email(email: Email): Object.T =
Object(
"user" -> email.user.split('.').toList,
"host" -> email.host.split('.').toList)
def from_authors(authors: List[Author]): Object.T =
authors.map(author =>
author.id -> (Object(
"name" -> author.name,
"emails" -> author.emails.map(from_email),
"homepages" -> author.homepages.map(_.url.toString)) ++
opt("orcid", author.orcid.map(orcid => Object(
"id" -> orcid.identifier,
"url" -> orcid.url.toString))))).toMap
def from_classification(classification: Classification): Object.T =
Object(
"desc" -> classification.desc,
"url" -> classification.url.toString,
"type" -> (classification match {
case _: ACM => "ACM"
case _: AMS => "AMS"
}))
def from_topics(topics: List[Topic]): Object.T =
Object(topics.map(topic =>
topic.name -> (
opt("classification", topic.classification.map(from_classification)) ++
opt("topics", from_topics(topic.sub_topics)))): _*)
def from_affiliations(affiliations: List[Affiliation]): Object.T = {
Utils.group_sorted(affiliations, (a: Affiliation) => a.author).view.mapValues(
{ author_affiliations =>
val homepage = author_affiliations.collectFirst { case homepage: Homepage => homepage }
val email = author_affiliations.collectFirst { case email: Email => email }
Object() ++
opt("homepage", homepage.map(_.url.toString)) ++
opt("email", email.map(from_email))
}).toMap
}
def from_change_history(entry: (Metadata.Date, String)): Object.T =
Object(
"date" -> entry._1.toString,
"value" -> entry._2)
def from_release(release: Release): Object.T =
Object(
"date" -> release.date.toString,
"isabelle" -> release.isabelle)
def from_related(related: Reference, cache: Cache): T =
related match {
case d: DOI =>
val href = d.url.toString
cache.resolve_doi(d).replace(href, "" + href + " ")
case Formatted(text) => text
}
def from_entry(entry: Entry, cache: Cache): Object.T = (
Object(
"title" -> entry.title,
"authors" -> entry.authors.map(_.author).distinct,
"affiliations" -> from_affiliations(entry.authors ++ entry.contributors),
"date" -> entry.date.toString,
"topics" -> entry.topics.map(_.id),
"abstract" -> entry.`abstract`,
"license" -> entry.license.name) ++
opt("contributors", entry.contributors.map(_.author).distinct) ++
opt("releases", entry.releases.sortBy(_.isabelle).reverse.map(from_release)) ++
opt("note", entry.note) ++
opt("history", entry.change_history.toList.sortBy(_._1).reverse.map(from_change_history)) ++
opt("extra", entry.extra) ++
opt("related", entry.related.map(from_related(_, cache))))
def from_keywords(keywords: List[String]): T =
keywords.sorted.map(keyword => Object("keyword" -> keyword))
}
/* stats */
def afp_stats(deps: Sessions.Deps, structure: AFP_Structure, entries: List[Entry]): JSON.T = {
def round(int: Int): Int = Math.round(int.toFloat / 100) * 100
def nodes(entry: Entry): List[Document.Node.Name] =
structure.entry_sessions(entry.name)
.flatMap(session => deps(session.name).proper_session_theories)
val theorem_commands = List("theorem", "lemma", "corollary", "proposition", "schematic_goal")
var entry_lines = Map.empty[Entry, Int]
var entry_lemmas = Map.empty[Entry, Int]
for {
entry <- entries
node <- nodes(entry)
lines = split_lines(File.read(node.path)).map(_.trim)
} {
entry_lines += entry -> (entry_lines.getOrElse(entry, 0) + lines.count(_.nonEmpty))
entry_lemmas += entry -> (entry_lemmas.getOrElse(entry, 0) +
lines.count(line => theorem_commands.exists(line.startsWith)))
}
val first_year = entries.flatMap(_.releases).map(_.date.getYear).min
def years(upto: Int): List[Int] = Range.inclusive(first_year, upto).toList
val current_year = Date.now().rep.getYear
val all_years = years(current_year)
// per Isabelle release year
val by_year = entries.groupBy(_.date.getYear)
val size_by_year = by_year.view.mapValues(_.length).toMap
val loc_by_year = by_year.view.mapValues(_.map(entry_lines).sum).toMap
val authors_by_year = by_year.view.mapValues(_.flatMap(_.authors).map(_.author)).toMap
val num_lemmas = entries.map(entry_lemmas).sum
val num_lines = entries.map(entry_lines).sum
// accumulated
def total_articles(year: Int): Int =
years(year).map(size_by_year.getOrElse(_, 0)).sum
def total_loc(year: Int): Int =
round(years(year).map(loc_by_year.getOrElse(_, 0)).sum)
def total_authors(year: Int): Int =
years(year).flatMap(authors_by_year.getOrElse(_, Nil)).distinct.length
def fresh_authors(year: Int): Int =
total_authors(year) - total_authors(year - 1)
val sorted = entries.sortBy(_.date)
def map_repetitions(elems: List[String], to: String): List[String] =
elems.foldLeft(("", List.empty[String])) {
case((last, acc), s) => (s, acc :+ (if (last == s) to else s))
}._2
isabelle.JSON.Object(
"years" -> all_years,
"num_lemmas" -> num_lemmas,
"num_loc" -> num_lines,
"articles_year" -> all_years.map(total_articles),
"loc_years" -> all_years.map(total_loc),
"author_years" -> all_years.map(fresh_authors),
"author_years_cumulative" -> all_years.map(total_authors),
"loc_articles" -> sorted.map(entry_lines),
"all_articles" -> sorted.map(_.name),
"article_years_unique" -> map_repetitions(sorted.map(_.date.getYear.toString), ""))
}
/* site generation */
def afp_site_gen(
layout: Hugo.Layout,
status_file: Option[Path],
afp_structure: AFP_Structure,
clean: Boolean = false,
progress: Progress = new Progress()
): Unit = {
/* clean old */
if (clean) {
progress.echo("Cleaning up generated files...")
layout.clean()
}
/* add topics */
progress.echo("Preparing topics...")
val topics = afp_structure.load_topics
val topics_by_id =
Utils.grouped_sorted(topics.flatMap(_.all_topics), (t: Metadata.Topic) => t.id)
layout.write_data(Path.basic("topics.json"), JSON.from_topics(topics))
/* add licenses */
progress.echo("Preparing licenses...")
val licenses_by_id = Utils.grouped_sorted(afp_structure.load_licenses,
(l: Metadata.License) => l.id)
/* add releases */
progress.echo("Preparing releases...")
val releases_by_entry = afp_structure.load_releases.groupBy(_.entry)
/* prepare authors and entries */
progress.echo("Preparing authors...")
val full_authors = afp_structure.load_authors
val authors_by_id = Utils.grouped_sorted(full_authors, (a: Metadata.Author) => a.id)
var seen_affiliations: List[Affiliation] = Nil
val entries = afp_structure.entries.flatMap { name =>
val entry = afp_structure.load_entry(name, authors_by_id, topics_by_id, licenses_by_id,
releases_by_entry)
- if (entry.sitegen_ignore) None
- else {
- seen_affiliations = seen_affiliations :++ entry.authors ++ entry.contributors
- Some(entry)
- }
+ seen_affiliations = seen_affiliations :++ entry.authors ++ entry.contributors
+ Some(entry)
}
val authors = Utils.group_sorted(seen_affiliations.distinct, (a: Affiliation) => a.author).map {
case (id, affiliations) =>
val seen_emails = affiliations.collect { case e: Email => e }
val seen_homepages = affiliations.collect { case h: Homepage => h }
authors_by_id(id).copy(emails = seen_emails, homepages = seen_homepages)
}
layout.write_data(Path.basic("authors.json"), JSON.from_authors(authors.toList))
/* extract keywords */
progress.echo("Extracting keywords...")
var seen_keywords = Set.empty[String]
- val entry_keywords = entries.map { entry =>
+ val entry_keywords = entries.filterNot(_.statistics_ignore).map { entry =>
val scored_keywords = Rake.extract_keywords(entry.`abstract`)
seen_keywords ++= scored_keywords.map(_._1)
entry.name -> scored_keywords.map(_._1)
}.toMap
seen_keywords =
seen_keywords.filter(k => !k.endsWith("s") || !seen_keywords.contains(k.stripSuffix("s")))
layout.write_static(Path.make(List("data", "keywords.json")),
JSON.from_keywords(seen_keywords.toList))
def get_keywords(name: Metadata.Entry.Name): List[String] =
- entry_keywords(name).filter(seen_keywords.contains).take(8)
+ entry_keywords.getOrElse(name, Nil).filter(seen_keywords.contains).take(8)
/* add entries and theory listings */
progress.echo("Preparing entries...")
val sessions_structure = afp_structure.sessions_structure
val sessions_deps = Sessions.deps(sessions_structure)
val cache = new Cache(layout)
entries.foreach { entry =>
val deps =
for {
session <- afp_structure.entry_sessions(entry.name)
dep <- sessions_structure.imports_graph.imm_preds(session.name)
if session.name != dep && sessions_structure(dep).groups.contains("AFP")
} yield dep
val theories = afp_structure.entry_sessions(entry.name).map { session =>
val base = sessions_deps(session.name)
val theories = base.proper_session_theories.map(_.theory_base_name)
val session_json = isabelle.JSON.Object(
"title" -> session.name,
"entry" -> entry.name,
"url" -> ("/theories/" + session.name.toLowerCase),
"theories" -> theories)
layout.write_content(Path.make(List("theories", session.name + ".md")), session_json)
isabelle.JSON.Object("session" -> session.name, "theories" -> theories)
}
val entry_json = JSON.from_entry(entry, cache) ++ isabelle.JSON.Object(
"dependencies" -> deps.distinct,
"sessions" -> theories,
"url" -> ("/entries/" + entry.name + ".html"),
"keywords" -> get_keywords(entry.name))
layout.write_content(Path.make(List("entries", entry.name + ".md")), entry_json)
}
/* add statistics */
progress.echo("Preparing statistics...")
- val statistics_json = afp_stats(sessions_deps, afp_structure, entries)
+ val statistics_json =
+ afp_stats(sessions_deps, afp_structure, entries.filterNot(_.statistics_ignore))
layout.write_data(Path.basic("statistics.json"), statistics_json)
/* project */
progress.echo("Preparing project files")
layout.copy_project()
/* status */
status_file match {
case Some(status_file) =>
progress.echo("Preparing devel version...")
val status_json = isabelle.JSON.parse(File.read(status_file))
layout.write_data(Path.basic("status.json"), status_json)
case None =>
}
progress.echo("Finished sitegen preparation.")
}
/* build site */
def afp_build_site(
out_dir: Path, layout: Hugo.Layout,
do_watch: Boolean = false,
clean: Boolean = false,
progress: Progress = new Progress()
): Unit = {
if (clean) {
progress.echo("Cleaning output dir...")
Hugo.clean(out_dir)
}
if (do_watch) {
- Hugo.watch(layout, out_dir, progress).check
+ Hugo.watch(layout, out_dir, progress)
} else {
progress.echo("Building site...")
-
- Hugo.build(layout, out_dir).check
-
+ Hugo.build(layout, out_dir)
progress.echo("Build in " + (out_dir + Path.basic("index.html")).absolute.implode)
}
}
/* tool wrapper */
val isabelle_tool = Isabelle_Tool("afp_site_gen", "generates afp website source",
Scala_Project.here,
{ args =>
var base_dir = Path.explode("$AFP_BASE")
var status_file: Option[Path] = None
var hugo_dir = base_dir + Path.make(List("web", "hugo"))
var out_dir: Path = base_dir + Path.make(List("web", "out"))
var build_only = false
var devel_mode = false
var fresh = false
val getopts = Getopts("""
Usage: isabelle afp_site_gen [OPTIONS]
Options are:
-B DIR afp base dir (default """" + base_dir.implode + """")
-D FILE build status file for devel version
-H DIR generated hugo project dir (default """" + hugo_dir.implode + """")
-O DIR output dir for build (default """ + out_dir.implode + """)
-b build only
-d devel mode (overrides hugo dir, builds site in watch mode)
-f fresh build: clean up existing hugo and build directories
Generates the AFP website source. HTML files of entries are dynamically loaded.
Providing a status file will build the development version of the archive.
Site will be built from generated source if output dir is specified.
""",
"B:" -> (arg => base_dir = Path.explode(arg)),
"D:" -> (arg => status_file = Some(Path.explode(arg))),
"H:" -> (arg => hugo_dir = Path.explode(arg)),
"O:" -> (arg => out_dir = Path.explode(arg)),
"b" -> (_ => build_only = true),
"d" -> (_ => devel_mode = true),
"f" -> (_ => fresh = true))
getopts(args)
status_file.foreach(path =>
if (!path.is_file || !path.file.exists()) error("Invalid status file: " + path))
if (devel_mode) hugo_dir = base_dir + Path.make(List("admin", "site"))
val afp_structure = AFP_Structure(base_dir)
val layout = Hugo.Layout(hugo_dir)
val progress = new Console_Progress()
if (!build_only) {
progress.echo("Preparing site generation in " + hugo_dir.implode)
afp_site_gen(layout = layout, status_file = status_file, afp_structure = afp_structure,
clean = fresh, progress = progress)
}
afp_build_site(out_dir = out_dir, layout = layout, do_watch = devel_mode,
clean = fresh, progress = progress)
})
}
\ No newline at end of file
diff --git a/tools/hugo.scala b/tools/hugo.scala
--- a/tools/hugo.scala
+++ b/tools/hugo.scala
@@ -1,107 +1,116 @@
/* Author: Fabian Huch, TU Muenchen
AFP Hugo wrapper and project layout.
*/
package afp
import isabelle.*
object Hugo {
val hugo_home = Isabelle_System.getenv("ISABELLE_HUGO")
val hugo_static = Path.explode("$AFP_BASE") + Path.make(List("admin", "site"))
class Layout private(private[Hugo] val src_dir: Path) {
private def write(file: Path, content: String): Unit = {
val path = src_dir + file
if (!path.dir.file.exists()) path.dir.file.mkdirs()
File.write(path, content)
}
val data_dir = src_dir + Path.basic("data")
private def format(json: JSON.T): String = {
json match {
case elems: List[_] => elems.map(format).mkString("[", ",\n", "]")
case JSON.Object(m) => m.map { case (k,v) => format(k) + ": " + format(v) }.mkString("{", ",\n", "}")
case _ => isabelle.JSON.Format(json)
}
}
def write_data(file: Path, content: JSON.T): Unit =
write(Path.basic("data") + file, format(content))
val content_dir = src_dir + Path.basic("content")
def write_content(file: Path, content: JSON.T): Unit =
write(Path.basic("content") + file, format(content))
val static_dir = src_dir + Path.basic("static")
def write_static(file: Path, content: JSON.T): Unit =
write(Path.basic("static") + file, format(content))
private val generated_dirs = List(
List("content", "entries"),
List("content", "theories"),
List("data"),
List("resources"),
List("static")).map(Path.make)
val cache_dir = src_dir + Path.basic("cache")
def write_cache(file: Path, content: JSON.T): Unit =
write(Path.basic("cache") + file, format(content))
/* Static project files */
private val project_files = List(
List("content", "webapp"),
List("content", "_index.md"),
List("content", "about.md"),
List("content", "submission.md"),
List("content", "download.md"),
List("content", "help.md"),
List("content", "search.md"),
List("content", "statistics.md"),
List("content", "submission.md"),
List("themes"),
List("config.json")).map(Path.make)
private val is_static_src = hugo_static.canonical.absolute == src_dir.canonical.absolute
def copy_project(): Unit = {
if (!is_static_src) project_files.foreach(file =>
Isabelle_System.copy_dir(hugo_static + file, src_dir + file))
}
def clean(): Unit = {
generated_dirs.foreach(file => Isabelle_System.rm_tree(src_dir + file))
if (!is_static_src) project_files.foreach(file => Isabelle_System.rm_tree(src_dir + file))
}
}
object Layout {
def apply(src_dir: Path = Path.explode("$AFP_BASE") + Path.make(List("web", "hugo"))): Layout =
new Layout(src_dir.canonical)
}
private lazy val exec =
Path.explode(proper_string(hugo_home).getOrElse(error("No hugo component found"))) + Path.basic("hugo")
- def build(layout: Layout, out_dir: Path): Process_Result = {
- Isabelle_System.bash(
- exec.implode + " -s " + quote(layout.src_dir.implode) + " -d " + quote(out_dir.canonical.implode))
+ private def source_specifier(layout: Layout, out_dir: Path): String =
+ " -s " + quote(layout.src_dir.implode) + " -d " + quote(out_dir.canonical.implode)
+
+ private def build_example(layout: Layout, out_dir: Path): Unit = {
+ val env = Isabelle_System.settings(List("HUGO_IGNOREFILES" -> "[]"))
+ Isabelle_System.bash(exec.implode + source_specifier(layout, out_dir: Path), env = env).check
}
- def watch(layout: Layout, out_dir: Path, progress: Progress = new Progress()): Process_Result = {
+ def build(layout: Layout, out_dir: Path): Unit = {
+ build_example(layout, out_dir)
+ Isabelle_System.bash(exec.implode + source_specifier(layout, out_dir)).check
+ }
+
+ def watch(layout: Layout, out_dir: Path, progress: Progress = new Progress()): Unit = {
+ build_example(layout, out_dir)
Isabelle_System.bash(
- exec.implode + " server -s " + quote(layout.src_dir.implode) + " -d " + quote(out_dir.canonical.implode),
+ exec.implode + " server " + source_specifier(layout, out_dir),
progress_stdout = progress.echo(_),
- progress_stderr = progress.echo_warning(_))
+ progress_stderr = progress.echo_warning(_)).check
}
def clean(out_dir: Path): Unit =
File.read_dir(out_dir).foreach(file => Isabelle_System.rm_tree(out_dir + Path.basic(file)))
}
\ No newline at end of file
diff --git a/tools/metadata.scala b/tools/metadata.scala
--- a/tools/metadata.scala
+++ b/tools/metadata.scala
@@ -1,420 +1,420 @@
/* Author: Fabian Huch, TU Muenchen
AFP metadata model and TOML serialization.
*/
package afp
import isabelle.*
import java.time.LocalDate
import java.net.{URI, URL}
object Metadata {
/* affiliations */
sealed trait Affiliation {
def author: Author.ID
}
case class Unaffiliated(override val author: Author.ID)
extends Affiliation
case class Email(override val author: Author.ID, id: Email.ID, address: String)
extends Affiliation {
private val Address = "([^@]+)@(.+)".r
val (user, host) = address match {
case Address(user, host) => (user, host)
case _ => error("Invalid address: " + address)
}
}
object Email {
type ID = String
def apply(author: Author.ID, id: Email.ID, user: String, host: String): Email =
Email(author, id, user + "@" + host)
}
case class Homepage(override val author: Author.ID, id: Homepage.ID, url: URL)
extends Affiliation
object Homepage {
type ID = String
}
/* authors */
case class Orcid(identifier: String) {
require(
"^([0-9]{4})-([0-9]{4})-([0-9]{4})-([0-9]{3}[0-9X])$".r.matches(identifier),
"Invalid format for orcid: " + quote(identifier))
def url: URL = new URL("https", "orcid.org", "/" + identifier)
}
case class Author(
id: Author.ID,
name: String,
emails: List[Email] = Nil,
homepages: List[Homepage] = Nil,
orcid: Option[Orcid] = None
)
object Author {
type ID = String
}
/* topics */
sealed trait Classification {
def desc: String
def url: URL
}
case class ACM(id: String, override val desc: String) extends Classification {
val url = new URL("https", "dl.acm.org", "/topic/ccs2012/" + id)
}
case class AMS(id: String, hierarchy: List[String]) extends Classification {
val code: String = id.length match {
case 2 => id + "-XX"
case 3 => id + "xx"
case 5 => id
case _ => error("Invalid ams id:" + id)
}
override val desc: String = hierarchy.mkString(" / ")
override val url: URL =
new URL("https", "mathscinet.ams.org", "/mathscinet/msc/msc2020.html?t=" + code)
}
case class Topic(
id: Topic.ID,
name: String,
classification: List[Classification] = Nil,
sub_topics: List[Topic] = Nil
) {
def all_topics: List[Topic] = this :: sub_topics.flatMap(_.all_topics)
}
object Topic {
type ID = String
}
/* releases */
type Date = LocalDate
object Isabelle {
type Version = String
}
case class Release(entry: Entry.Name, date: Date, isabelle: Isabelle.Version)
/* license */
case class License(id: License.ID, name: String)
object License {
type ID = String
}
/* references */
sealed trait Reference
case class DOI(identifier: String) extends Reference {
require("^10.([1-9][0-9]{3,})/(.+)".r.matches(identifier),
"invalid format for DOI: " + quote(identifier))
def uri: URI = new URI("doi:" + identifier)
def url: URL = new URL("https", "doi.org", "/" + identifier)
def formatted(style: String = "apa"): String =
Utils.fetch_text(url, Map("Accept" -> ("text/x-bibliography; style=" + style)))
}
case class Formatted(rep: String) extends Reference
/* misc */
type Change_History = Map[Date, String]
type Extra = Map[String, String]
/* entry */
case class Entry(
name: Entry.Name,
title: String,
authors: List[Affiliation],
date: Date,
topics: List[Topic],
`abstract`: String,
notifies: List[Email],
license: License,
note: String,
contributors: List[Affiliation] = Nil,
change_history: Change_History = Map.empty,
extra: Extra = Map.empty,
releases: List[Release] = Nil,
- sitegen_ignore: Boolean = false,
+ statistics_ignore: Boolean = false,
related: List[Reference] = Nil)
object Entry {
type Name = String
}
/* toml */
private def by_id[A](elems: Map[String, A], id: String): A =
elems.getOrElse(id, error("Elem " + quote(id) + " not found in " + commas_quote(elems.keys)))
object TOML {
import isabelle.TOML.{Array, Boolean, Key, Local_Date, String, Table}
/* affils */
def from_email(email: Email): Table =
Table(
"user" -> Array(email.user.split('.').map(String(_))),
"host" -> Array(email.host.split('.').map(String(_))))
def to_email(author_id: Author.ID, email_id: Email.ID, email: Table): Email = {
val user = email.array("user").string.values.map(_.rep)
val host = email.array("host").string.values.map(_.rep)
Email(author_id, email_id, user.mkString("."), host.mkString("."))
}
/* author */
def from_author(author: Author): Table =
Table(
"name" -> String(author.name),
"emails" -> Table(author.emails.map(e => e.id -> from_email(e))),
"homepages" -> Table(author.homepages.map(h => h.id -> String(h.url.toString)))) ++
author.orcid.map(orcid => Table("orcid" -> String(orcid.identifier))).getOrElse(Table())
def to_author(author_id: Author.ID, author: Table): Author = {
val emails = author.table("emails").table.values.map {
case (id, email) => to_email(author_id, id, email)
}
val homepages = author.table("homepages").string.values.map {
case (id, url) => Homepage(author = author_id, id = id, url = new URL(url.rep))
}
val orcid = author.string.get("orcid").map(_.rep).map(Orcid(_))
Author(
id = author_id,
name = author.string("name").rep,
orcid = orcid,
emails = emails,
homepages = homepages)
}
def from_authors(authors: List[Author]): Table =
Table(authors.map(author => author.id -> from_author(author)))
def to_authors(authors: Table): List[Author] = authors.table.values.map(to_author)
/* topics */
def from_acm(acm: ACM): Table =
Table("id" -> String(acm.id), "desc" -> String(acm.desc))
def to_acm(acm: Table): ACM =
ACM(acm.string("id").rep, acm.string("desc").rep)
def from_ams(ams: AMS): Table =
Table("id" -> String(ams.id), "hierarchy" -> Array(ams.hierarchy.map(String(_))))
def to_ams(ams: Table): AMS =
AMS(ams.string("id").rep, ams.array("hierarchy").string.values.map(_.rep))
def from_classifications(classifications: List[Classification]): Table =
Table(classifications.map {
case acm: ACM => "acm" -> from_acm(acm)
case ams: AMS => "ams" -> from_ams(ams)
})
def to_classifications(classifications: Table): List[Classification] =
classifications.table.values.map {
case ("ams", ams) => to_ams(ams)
case ("acm", acm) => to_acm(acm)
case (c, _) => error("Unknown topic classification: " + quote(c))
}
def from_topics(root_topics: List[Topic]): Table =
Table(root_topics.map(t => t.name -> (
Table("classification" -> from_classifications(t.classification)) ++
from_topics(t.sub_topics))))
def to_topics(root_topics: Table): List[Topic] = {
def to_topics_rec(topics: List[(Key, Table)], root: Topic.ID): List[Topic] = {
topics.map {
case (name, data) =>
val id = (if (root.nonEmpty) root + "/" else "") + name
val classifications = to_classifications(data.table("classification"))
val sub_topics = data.table.values.filterNot(_._1 == "classification")
Topic(id, name, classifications, to_topics_rec(sub_topics, id))
}
}
to_topics_rec(root_topics.table.values, "")
}
/* releases */
def from_releases(releases: List[Release]): Table =
Table(Utils.group_sorted(releases, (r: Release) => r.entry).view.mapValues { entry_releases =>
Table(entry_releases.map(r => r.date.toString -> String(r.isabelle)))
}.toList)
def to_releases(map: Table): List[Release] =
map.table.values.flatMap {
case (entry, releases) => releases.string.values.map {
case (date, version) =>
Release(entry = entry, date = LocalDate.parse(date), isabelle = version.rep)
}
}
/* affiliation */
def from_affiliations(affiliations: List[Affiliation]): Table =
Table(Utils.group_sorted(affiliations, (a: Affiliation) => a.author).view.mapValues(vs =>
Table(vs.collect {
case Email(_, id, _) => "email" -> String(id)
case Homepage(_, id, _) => "homepage" -> String(id)
})).toList)
def to_affiliations(affiliations: Table, authors: Map[Author.ID, Author]): List[Affiliation] = {
def to_affiliation(affiliation: (Key, String), author: Author): Affiliation = {
affiliation match {
case ("email", id) => author.emails.find(_.id == id.rep) getOrElse
error("Email not found: " + quote(id.rep))
case ("homepage", id) => author.homepages.find(_.id == id.rep) getOrElse
error("Homepage not found: " + quote(id.rep))
case e => error("Unknown affiliation type: " + e)
}
}
affiliations.table.values.flatMap {
case (id, author_affiliations) =>
val author = by_id(authors, id)
if (author_affiliations.is_empty) List(Unaffiliated(author.id))
else author_affiliations.string.values.map(to_affiliation(_, author))
}
}
def from_emails(emails: List[Email]): Table =
Table(emails.map(email => email.author -> String(email.id)))
def to_emails(emails: Table, authors: Map[Author.ID, Author]): List[Email] =
emails.string.values.map {
case (author, id) => by_id(authors, author).emails.find(_.id == id.rep) getOrElse
error("Email not found: " + quote(id.rep))
}
/* license */
def from_licenses(licenses: List[License]): Table =
Table(licenses.map(license => license.id -> Table("name" -> String(license.name))))
def to_licenses(licenses: Table): List[License] = {
licenses.table.values.map {
case (id, license) => License(id, license.string("name").rep)
}
}
def to_license(license: String, licenses: Map[License.ID, License]): License =
licenses.getOrElse(license.rep, error("No such license: " + quote(license.rep)))
/* history */
def from_change_history(change_history: Change_History): Table =
Table(change_history.map { case (date, str) => date.toString -> String(str) })
def to_change_history(change_history: Table): Change_History =
change_history.string.values.map {
case (date, entry) => LocalDate.parse(date) -> entry.rep
}.toMap
/* references */
def from_related(references: List[Reference]): Table = {
val dois = references.collect { case d: DOI => d }
val formatted = references.collect { case f: Formatted => f }
Table(
"dois" -> Array(dois.map(_.identifier).map(String(_))),
"pubs" -> Array(formatted.map(_.rep).map(String(_))))
}
def to_related(references: Table): List[Reference] = {
val dois = references.array.get("dois").toList.flatMap(_.string.values.map(_.rep))
val pubs = references.array.get("pubs").toList.flatMap(_.string.values.map(_.rep))
dois.map(DOI(_)) ++ pubs.map(Formatted(_))
}
/* entry */
def from_entry(entry: Entry): Table = {
Table(
"title" -> String(entry.title),
"authors" -> from_affiliations(entry.authors),
"contributors" -> from_affiliations(entry.contributors),
"date" -> Local_Date(entry.date),
"topics" -> Array(entry.topics.map(_.id).map(String(_))),
"abstract" -> String(entry.`abstract`),
"notify" -> from_emails(entry.notifies),
"license" -> String(entry.license.id),
"note" -> String(entry.note),
"history" -> from_change_history(entry.change_history),
"extra" -> Table(entry.extra.view.mapValues(String(_)).toList),
"related" -> from_related(entry.related)) ++
- (if (entry.sitegen_ignore) Table("sitegen_ignore" -> Boolean(true)) else Table())
+ (if (entry.statistics_ignore) Table("statistics_ignore" -> Boolean(true)) else Table())
}
def to_entry(
name: Entry.Name,
entry: Table,
authors: Map[Author.ID, Author],
topics: Map[Topic.ID, Topic],
licenses: Map[License.ID, License],
releases: List[Release]
): Entry =
Entry(
name = name,
title = entry.string("title").rep,
authors = to_affiliations(entry.table("authors"), authors),
date = entry.local_date("date").rep,
topics = entry.array("topics").string.values.map(_.rep).map(by_id(topics, _)),
`abstract` = entry.string("abstract").rep,
notifies = to_emails(entry.table("notify"), authors),
license = to_license(entry.string("license"), licenses),
note = entry.string("note").rep,
contributors = to_affiliations(entry.table("contributors"), authors),
change_history = to_change_history(entry.table("history")),
extra = entry.table("extra").string.values.map((k, v) => (k, v.rep)).toMap,
releases = releases,
- sitegen_ignore = entry.boolean.get("sitegen_ignore").map(_.rep).getOrElse(false),
+ statistics_ignore = entry.boolean.get("statistics_ignore").map(_.rep).getOrElse(false),
related = to_related(entry.table("related")))
}
}
diff --git a/tools/migration/afp_migrate_metadata.scala b/tools/migration/afp_migrate_metadata.scala
--- a/tools/migration/afp_migrate_metadata.scala
+++ b/tools/migration/afp_migrate_metadata.scala
@@ -1,599 +1,599 @@
package afp.migration
import isabelle._
import afp._
import afp.Metadata.{TOML => _, _}
import scala.collection.BufferedIterator
import java.io.BufferedReader
import java.text.Normalizer
import java.time.LocalDate
import java.net.URL
import org.jline.utils.InputStreamReader
object AFP_Migrate_Metadata {
class Context(
names_mapping: Map[String, String],
email_names: Map[String, String],
dates_mapping: Map[String, String]
) {
/* mappings */
def transform_name(name: String): String =
names_mapping.getOrElse(name, name)
def parse_date(date: String): Metadata.Date =
LocalDate.parse(dates_mapping.getOrElse(date, date))
def name(address: String): String =
email_names.getOrElse(address, error("No name for address " + address))
/* seen */
private var _seen_authors = Set.empty[Author.ID]
private var _seen_emails = Set.empty[Email.ID]
private var _seen_homepages = Set.empty[Homepage.ID]
private var _seen_licenses = Map.empty[License.ID, License]
private var _seen_author_names = Map.empty[String, Author]
def seen_authors: Set[Author.ID] = _seen_authors
def seen_emails: Set[Email.ID] = _seen_emails
def seen_homepages: Set[Homepage.ID] = _seen_homepages
def author(name: String): Option[Author] = _seen_author_names.get(name)
def authors: List[Author] = _seen_author_names.values.toList
def licenses: List[License] = _seen_licenses.values.toList
def update_author(author: Author): Unit = {
_seen_authors += author.id
_seen_author_names = _seen_author_names.updated(author.name, author)
}
def email(author: Author.ID): Email.ID = {
val id = unique_id(author + "_email", this.seen_emails)
_seen_emails += id
id
}
def homepage(homepage: Homepage.ID): Homepage.ID = {
val id = unique_id(homepage + "_homepage", this.seen_homepages)
_seen_homepages += id
id
}
def license(license_str: String): License = {
val license = License(license_str.toLowerCase, license_str)
_seen_licenses += license.id -> license
license
}
}
private def is_email(url: String) = url.contains("@")
private def as_ascii(str: String) = {
var res: String = str
List("ö" -> "oe", "ü" -> "ue", "ä" -> "ae", "ß" -> "ss").foreach {
case (c, rep) => res = res.replace(c, rep)
}
res = Normalizer.normalize(res, Normalizer.Form.NFD).replaceAll("[^\\x00-\\x7F]", "")
if (res.exists(_ > 127)) error("Contained non convertible non-ascii character: " + str)
res
}
def unique_id(prefix: String, ids: Set[String]): String = {
if (!ids.contains(prefix)) prefix
else {
var num = 1
while (ids.contains(prefix + num)) { num += 1 }
prefix + num
}
}
def private_dom(full_dom: String): String = {
val stream = getClass.getClassLoader.getResourceAsStream("public_suffix_list.dat")
val reader = new BufferedReader(new InputStreamReader(stream))
val public_suffixes = File.read_lines(reader, _ => ()).filterNot(_.startsWith("//"))
val stripped = public_suffixes.map(full_dom.stripSuffix(_)).minBy(_.length)
if (stripped.endsWith(".")) stripped.dropRight(1) else stripped
}
def make_author_id(name: String, context: Context): String = {
val normalized = as_ascii(name)
val Suffix = """^.*?([a-zA-Z]*)$""".r
val suffix = normalized match {
case Suffix(suffix) => suffix
case _ => ""
}
val Prefix = """^([a-zA-Z]*).*$""".r
val prefix = normalized.stripSuffix(suffix) match {
case Prefix(prefix) => prefix
case _ => ""
}
var ident = suffix.toLowerCase
for {
c <- prefix.toLowerCase
} {
if (context.seen_authors.contains(ident)) {
ident += c.toString
} else return ident
}
unique_id(ident, context.seen_authors)
}
def author_urls(name_urls: String, context: Context): (String, List[String]) = {
val name = AFP.trim_mail(name_urls)
val urls_string = name_urls.stripPrefix(name).trim
val transformed = context.transform_name(name)
if (urls_string == "<>") {
(transformed, List(""))
} else {
(transformed, urls_string.split(Array('<', '>')).toList.filterNot(_.isBlank))
}
}
def add_email(author: Author, address: String, context: Context): (Author, Email) = {
val email = Email(author = author.id, id = context.email(author.id), address = address)
val update_author = author.copy(emails = author.emails :+ email)
context.update_author(update_author)
(update_author, email)
}
def get_affiliations(name_url: String, context: Context): List[Affiliation] = {
val (name, urls) = author_urls(name_url, context)
val author = context.author(name).getOrElse(error("Author not found: " + name))
urls.map { url =>
if (is_email(url)) {
val address = url.stripPrefix("mailto:")
author.emails.find(_.address == address) getOrElse
error("Email not found: " + (author, address))
}
else if (url.isEmpty) {
Unaffiliated(author.id)
}
else {
author.homepages.find(_.url.toString == url) getOrElse
error("Url not found for: " + (author, url))
}
}
}
def get_email_affiliation(address: String, context: Context, progress: Progress): Email = {
context.authors.flatMap(_.emails).find(_.address == address) match {
case Some(email) => email
case None =>
val name = context.name(address)
val author = context.author(name) match {
case Some(author) => author
case None =>
progress.echo_warning("New author: " + name)
Author(make_author_id(name, context), name, Nil, Nil)
}
add_email(author, address, context)._2
}
}
def update_author(name_urls: String, context: Context): Unit = {
val (name, urls) = author_urls(name_urls, context)
var author = context.author(name) match {
case Some(author) => author
case None => Author(make_author_id(name, context), name, Nil, Nil)
}
urls.foreach { url =>
if (is_email(url)) {
val address = url.stripPrefix("mailto:")
if (!author.emails.exists(_.address == address)) {
author = add_email(author, address, context)._1
}
}
else if (url.nonEmpty && !author.homepages.exists(_.url.toString == url)) {
val homepage = Homepage(author = author.id, id = context.homepage(author.id), url = new URL(url))
author = author.copy(homepages = author.homepages :+ homepage)
}
}
context.update_author(author)
}
def map_entry(
entry: AFP.Entry,
releases: Map[Entry.Name, List[Release]],
topics: Map[Topic.ID, Topic],
- sitegen_ignore: Boolean,
+ statistics_ignore: Boolean,
context: Context,
progress: Progress
): Entry = {
val author_affiliations = entry.authors.flatMap(get_affiliations(_, context))
val contributor_affiliations = entry.contributors.flatMap(get_affiliations(_, context))
val notify_emails = entry.get_strings("notify").map(get_email_affiliation(_, context, progress))
val change_history = parse_change_history(entry.get_string("extra-history"), context)
val extra = entry.metadata.filter { case (k, _) => k.startsWith("extra-") && k != "extra-history" }
Entry(
name = entry.name,
title = entry.title,
authors = author_affiliations,
date = LocalDate.from(entry.date.rep),
topics = entry.topics.map(topics),
`abstract` = entry.`abstract`,
notifies = notify_emails,
contributors = contributor_affiliations,
license = context.license(entry.license),
note = entry.get_string("note"),
change_history = change_history,
extra = extra.toMap,
releases = releases.getOrElse(entry.name, Nil),
- sitegen_ignore = sitegen_ignore
+ statistics_ignore = statistics_ignore
)
}
def parse_change_history(history: String, context: Context): Change_History = {
val matches = """\[(\d{4}-\d{2}-\d{2})]:([^\[]+)""".r.findAllMatchIn(history.stripPrefix("Change history:"))
matches.toList.map(_.subgroups match {
case date :: content :: Nil => context.parse_date(date) -> content.trim
case _ => error("Could not parse change history: " + quote(history))
}).toMap
}
def parse_topics(lines: List[String]): List[Topic] = {
val lines_iterator: BufferedIterator[String] = lines.filterNot(_.isBlank).iterator.buffered
def get_indent(line: String) = line.takeWhile(_.isWhitespace).length
def parse_level(level: Int, root: Option[Topic.ID]): List[Topic] = {
val name = lines_iterator.next().trim
val id = root.map(_ + "/").getOrElse("") + name
val (sub_topics, next_topics) = lines_iterator.headOption match {
case Some(next) if get_indent(next) == level + 2 =>
val sub = parse_level(level + 2, Some(id))
val next = lines_iterator.headOption match {
case Some(next1) if get_indent(next1) == level => parse_level(level, root)
case _ => Nil
}
(sub, next)
case Some(next) if get_indent(next) == level =>
(Nil, parse_level(level, root))
case _ => (Nil, Nil)
}
Topic(id = id, name = name, sub_topics = sub_topics) :: next_topics
}
parse_level(0, None)
}
def parse_releases(
releases: List[String],
isabelle_releases: List[String],
all_entries: List[Entry.Name],
context: Context
): List[Release] = {
val Isa_Release = """(.+) = (.+)""".r
val release_dates = isabelle_releases.filterNot(_.isBlank).map {
case Isa_Release(isabelle_version, date) => context.parse_date(date) -> isabelle_version
case line => error("Could not parse: " + quote(line))
}
def to_release(entry: Entry.Name, release_date: LocalDate): Release =
Release(entry, release_date, release_dates.findLast { case (date, _) => date.isBefore(release_date) }.get._2)
val Entry_Release = """afp-([a-zA-Z0-9_+-]+)-(\d{4}-\d{2}-\d{2})\.tar\.gz""".r
val entry_releases = Utils.group_sorted(
releases.filterNot(_.isBlank).map {
case Entry_Release(entry, date_string) =>
val date = context.parse_date(date_string)
entry -> to_release(entry, date)
case line => error("Could not parse: " + quote(line))
}, (e: (Entry.Name, Release)) => e._1)
all_entries.flatMap(e => entry_releases.getOrElse(e, Nil).map(_._2))
}
def migrate_metadata(
base_dir: Path,
overwrite: Boolean,
context: Context,
options: Options = Options.init(),
progress: Progress = new Progress()
): Unit = {
val metadata = AFP.init(options, base_dir)
val metadata_dir = base_dir + Path.basic("metadata")
def read(file: Path): String =
File.read(metadata_dir + file)
def write(toml: TOML.Table, file: Path) = {
val path = metadata_dir + file
if (!overwrite && path.file.exists) error("File already exists: " + path.file_name)
else path.dir.file.mkdirs()
File.write(path, TOML.Format(toml))
}
/* topics */
progress.echo("Parsing topics...")
val root_topics = parse_topics(split_lines(read(Path.basic("topics"))))
val topic_map = root_topics.flatMap(_.all_topics).map(topic => topic.id -> topic).toMap
write(Metadata.TOML.from_topics(root_topics), Path.basic("topics.toml"))
/* releases */
progress.echo("Parsing releases...")
val releases = parse_releases(
split_lines(read(Path.basic("releases"))),
split_lines(read(Path.basic("release-dates"))),
metadata.entries.map(_.name), context)
val releases_map = releases.groupBy(_.entry)
write(Metadata.TOML.from_releases(releases), Path.basic("releases.toml"))
/* collect authors (without notify affiliations) */
progress.echo("Collecting authors...")
for {
entry <- metadata.entries
name_url <- entry.authors ++ entry.contributors
} update_author(name_url, context)
/* entries */
progress.echo("Parsing entries...")
for (entry_metadata <- metadata.entries) {
val ignore_file = base_dir + Path.make(List("thys", entry_metadata.name, ".sitegen-ignore"))
- val sitegen_ignore = ignore_file.file.exists
+ val statistics_ignore = ignore_file.file.exists
- val entry = map_entry(entry_metadata, releases_map, topic_map, sitegen_ignore, context, progress)
+ val entry = map_entry(entry_metadata, releases_map, topic_map, statistics_ignore, context, progress)
write(Metadata.TOML.from_entry(entry), Path.make(List("entries", entry.name + ".toml")))
}
/* licenses */
write(Metadata.TOML.from_licenses(context.licenses), Path.basic("licenses.toml"))
/* authors */
write(Metadata.TOML.from_authors(context.authors), Path.basic("authors.toml"))
}
val isabelle_tool =
Isabelle_Tool("afp_migrate_metadata", "migrates old sitegen metadata to new format",
Scala_Project.here,
{ args =>
var base_dir = Path.explode("$AFP_BASE")
var names = List(
"Lawrence C Paulson" -> "Lawrence C. Paulson",
"Lawrence Paulson" -> "Lawrence C. Paulson",
"Florian Kammueller" -> "Florian Kammüller",
"Jasmin Blanchette" -> "Jasmin Christian Blanchette",
"Ognjen Maric" -> "Ognjen Marić",
"Maximilian P.L. Haslbeck" -> "Maximilian P. L. Haslbeck",
"Maximilian Haslbeck" -> "Max W. Haslbeck",
"Sebastiaan Joosten" -> "Sebastiaan J. C. Joosten",
"Jacques Fleuriot" -> "Jacques D. Fleuriot",
"Jose Manuel Rodriguez Caballero" -> "José Manuel Rodríguez Caballero")
var emails = List(
"a.bentkamp@vu.nl" -> "Alexander Bentkamp",
"a.popescu@mdx.ac.uk" -> "Andrei Popescu",
"a.popescu@sheffield.ac.uk" -> "Andrei Popescu",
"afp@liftm.de" -> "Julius Michaelis",
"ahfrom@dtu.dk" -> "Asta Halkjær From",
"ak2110@cam.ac.uk" -> "Angeliki Koutsoukou-Argyraki",
"akihisayamada@nii.ac.jp" -> "Akihisa Yamada",
"aleje@dtu.dk" -> "Alexander Birch Jensen",
"alexander.katovsky@cantab.net" -> "Alexander Katovsky",
"alexander.maletzky@risc-software.at" -> "Alexander Maletzky",
"alexander.maletzky@risc.jku.at" -> "Alexander Maletzky",
"andreas.lochbihler@digitalasset.com" -> "Andreas Lochbihler",
"andreasvhess@gmail.com" -> "Andreas V. Hess",
"andschl@dtu.dk" -> "Anders Schlichtkrull",
"apdb3@cam.ac.uk" -> "Anthony Bordg",
"avigad@cmu.edu" -> "Jeremy Avigad",
"ballarin@in.tum.de" -> "Clemens Ballarin",
"bdd@liftm.de" -> "Julius Michaelis",
"benedikt1999@freenet.de" -> "Benedikt Stock",
"benblumson@gmail.com" -> "Ben Blumson",
"berghofe@in.tum.de" -> "Stefan Berghofer",
"bjbohrer@gmail.com" -> "Brandon Bohrer",
"boehmes@in.tum.de" -> "Sascha Böhme",
"brianh@cs.pdx.edu" -> "Brian Huffman",
"brunnerj@in.tum.de" -> "Julian Brunner",
"bzhan@ios.ac.cn" -> "Bohua Zhan",
"c.benzmueller@fu-berlin.de" -> "Christoph Benzmüller",
"c.benzmueller@gmail.com" -> "Christoph Benzmüller",
"caw77@cam.ac.uk" -> "Conrad Watt",
"cezary.kaliszyk@uibk.ac.at" -> "Cezary Kaliszyk",
"christian.sternagel@uibk.ac.at" -> "Christian Sternagel",
"christian.urban@kcl.ac.uk" -> "Christian Urban",
"cle47@cam.ac.uk" -> "Chelsea Edmonds",
"coglio@kestrel.edu" -> "Alessandro Coglio",
"corey.lewis@data61.csiro.au" -> "Corey Lewis",
"d1623001@s.konan-u.ac.jp" -> "Fumiya Iwama",
"danijela@matf.bg.ac.rs" -> "Danijela Simić",
"denis.lohner@kit.edu" -> "Denis Lohner",
"denis.nikif@gmail.com" -> "Denis Nikiforov",
"diego.marmsoler@tum.de" -> "Diego Marmsoler",
"diekmann@net.in.tum.de" -> "Cornelius Diekmann",
"dubut@nii.ac.jp" -> "Jérémy Dubut",
"eminkarayel@google.com" -> "Emin Karayel",
"f.smola@sms.ed.ac.uk" -> "Filip Smola",
"fadouaghourabi@gmail.com" -> "Fadoua Ghourabi",
"fimmler@andrew.cmu.edu" -> "Fabian Immler",
"fimmler@cs.cmu.edu" -> "Fabian Immler",
"fkjac@dtu.dk" -> "Frederik Krogsdal Jacobsen",
"florian.haftmann@informatik.tu-muenchen.de" -> "Florian Haftmann",
"florian.kammuller@gmail.com" -> "Florian Kammüller",
"friedrich.kurz@tum.de" -> "Friedrich Kurz",
"ftuong@lri.fr" -> "Frédéric Tuong",
"g.struth@dcs.shef.ac.uk" -> "Georg Struth",
"ggrov@inf.ed.ac.uk" -> "Gudmund Grov",
"giamp@dmi.unict.it" -> "Giampaolo Bella",
"giuliano@losa.fr" -> "Giuliano Losa",
"Harald.Zankl@uibk.ac.at" -> "Harald Zankl",
"haslbecm@in.tum.de" -> "Max W. Haslbeck",
"haslbema@in.tum.de" -> "Maximilian P. L. Haslbeck",
"heimesl@student.ethz.ch" -> "Lukas Heimes",
"hetzl@logic.at" -> "Stefan Hetzl",
"hirata.m.ac@m.titech.ac.jp" -> "Michikazu Hirata",
"holub@karlin.mff.cuni.cz" -> "Štěpán Holub",
"Ian.Hayes@itee.uq.edu.au" -> "Ian J. Hayes",
"isabelleopenflow@liftm.de" -> "Julius Michaelis",
"Jacques.Fleuriot@ed.ac.uk" -> "Jacques D. Fleuriot",
"jason.jaskolka@carleton.ca" -> "Jason Jaskolka",
"jdf@ed.ac.uk" -> "Jacques D. Fleuriot",
"jeremy.sylvestre@ualberta.ca" -> "Jeremy Sylvestre",
"jesus-maria.aransay@unirioja.es" -> "Jesús Aransay",
"jonas.bayer999@gmail.com" -> "Jonas Bayer",
"jonjulian23@gmail.com" -> "Jonathan Julian Huerta y Munive",
"jose.divason@unirioja.es" -> "Jose Divasón",
"jose.divasonm@unirioja.es" -> "Jose Divasón",
"joseph-thommes@gmx.de" -> "Joseph Thommes",
"jovi@dtu.dk" -> "Jørgen Villadsen",
"jsiek@indiana.edu" -> "Jeremy Siek",
"jsylvest@ualberta.ca" -> "Jeremy Sylvestre",
"julian.nagele@uibk.ac.at" -> "Julian Nagele",
"julian.parsert@uibk.ac.at" -> "Julian Parsert",
"kevin.kappelmann@tum.de" -> "Kevin Kappelmann",
"kkz@mit.edu" -> "Karen Zee",
"kleing@unsw.edu.au" -> "Gerwin Klein",
"krauss@in.tum.de" -> "Alexander Krauss",
"kreuzerk@in.tum.de" -> "Katharina Kreuzer",
"lars@hupel.info" -> "Lars Hupel",
"lcp@cl.cam.ac.uk" -> "Lawrence C. Paulson",
"lennart.beringer@ifi.lmu.de" -> "Lennart Beringer",
"liwenda1990@hotmail.com" -> "Wenda Li",
"m.raszyk@gmail.com" -> "Martin Raszyk",
"mail@andreas-lochbihler.de" -> "Andreas Lochbihler",
"mail@michael-herzberg.de" -> "Michael Herzberg",
"maintainafpppt@liftm.de" -> "Julius Michaelis",
"maksym.bortin@nicta.com.au" -> "Maksym Bortin",
"manuel.eberl@tum.de" -> "Manuel Eberl",
"marco.david@hotmail.de" -> "Marco David",
"martin.desharnais@unibw.de" -> "Martin Desharnais",
"mathias.fleury@jku.at" -> "Mathias Fleury",
"matthias.brun@inf.ethz.ch" -> "Matthias Brun",
"max.haslbeck@gmx.de" -> "Max W. Haslbeck",
"maximilian.haslbeck@uibk.ac.at" -> "Max W. Haslbeck",
"me@eminkarayel.de" -> "Emin Karayel",
"MichaelNedzelsky@yandex.ru" -> "Michael Nedzelsky",
"miguel.pagano@unc.edu.ar" -> "Miguel Pagano",
"mihailsmilehins@gmail.com" -> "Mihails Milehins",
"minamide@is.titech.ac.jp" -> "Yasuhiko Minamide",
"mnacho.echenim@univ-grenoble-alpes.fr" -> "Mnacho Echenim",
"mnfrd.krbr@gmail.com" -> "Manfred Kerber",
"mohammad.abdulaziz8@gmail.com" -> "Mohammad Abdulaziz",
"mohammad.abdulaziz@in.tum.de" -> "Mohammad Abdulaziz",
"mr644@cam.ac.uk" -> "Michael Rawson",
"mrtnrau@googlemail.com" -> "Martin Rau",
"nanjiang@whu.edu.cn" -> "Nan Jiang",
"Nicolas.Peltier@imag.fr" -> "Nicolas Peltier",
"nipkow@in.tum.de" -> "Tobias Nipkow",
"noschinl@gmail.com" -> "Lars Noschinski",
"pagano@famaf.unc.edu.ar" -> "Miguel Pagano",
"pc@cs.st-andrews.ac.uk" -> "Peter Chapman",
"peter.lammich@uni-muenster.de" -> "Peter Lammich",
"peter@hoefner-online.de" -> "Peter Höfner",
"psterraf@unc.edu.ar" -> "Pedro Sánchez Terraf",
"ralph.bottesch@uibk.ac.at" -> "Ralph Bottesch",
"reza.sefidgar@inf.ethz.ch" -> "S. Reza Sefidgar",
"richter@informatik.rwth-aachen.de" -> "Stefan Richter",
"roelofoosterhuis@gmail.com" -> "Roelof Oosterhuis",
"rok@strnisa.com" -> "Rok Strniša",
"rosskops@in.tum.de" -> "Simon Roßkopf",
"s.griebel@tum.de" -> "Simon Griebel",
"s.j.c.joosten@utwente.nl" -> "Sebastiaan J. C. Joosten",
"samo@dtu.dk" -> "Sebastian Mödersheim",
"schirmer@in.tum.de" -> "Norbert Schirmer",
"sidney.amani@data61.csiro.au" -> "Sidney Amani",
"sjcjoosten@gmail.com" -> "Sebastiaan J. C. Joosten",
"stepan.starosta@fit.cvut.cz" -> "Štěpán Starosta",
"Stephan.Merz@loria.fr" -> "Stephan Merz",
"sterraf@famaf.unc.edu.ar" -> "Pedro Sánchez Terraf",
"stourret@mpi-inf.mpg.de" -> "Sophie Tourret",
"stvienna@gmail.com" -> "Stephan Adelsberger",
"susannahej@gmail.com" -> "Susannah Mansky",
"tdardini@student.ethz.ch" -> "Thibault Dardinier",
"thibault.dardinier@inf.ethz.ch" -> "Thibault Dardinier",
"tim@tbrk.org" -> "Timothy Bourke",
"toby.murray@unimelb.edu.au" -> "Toby Murray",
"traytel@di.ku.dk" -> "Dmitriy Traytel",
"traytel@in.tum.de" -> "Dmitriy Traytel",
"traytel@inf.ethz.ch" -> "Dmitriy Traytel",
"tsato@c.titech.ac.jp" -> "Tetsuya Sato",
"uuomul@yahoo.com" -> "Andrei Popescu",
"walter.guttman@canterbury.ac.nz" -> "Walter Guttmann",
"walter.guttmann@canterbury.ac.nz" -> "Walter Guttmann",
"wimmers@in.tum.de" -> "Simon Wimmer",
"wl302@cam.ac.uk" -> "Wenda Li",
"yongkiat@cs.cmu.edu" -> "Yong Kiam Tan",
"Yutaka.Nagashima@data61.csiro.au" -> "Yutaka Nagashima")
var dates = List(
"2020-14-04" -> "2020-04-14",
"2020-15-04" -> "2020-04-15")
var overwrite = false
val getopts = Getopts("""
Usage: isabelle afp_migrate_metadata [OPTIONS]
Options are:
-B DIR afp base dir (default "$AFP_BASE")
-n FROM,TO names to convert (default:
""" + names.mkString("\n ") +
""")
-e EMAIL,AUTHOR emails to associate (default:
""" + emails.mkString("\n ") +
""")
-d FROM,TO date strings to convert (default:
""" + dates.mkString("\n ") +
""")
-f overwrite existing
Migrates old sitegen metadata to new format.
""",
"B:" -> (arg => base_dir = Path.explode(arg)),
"n:" -> (arg => names ::= arg.splitAt(arg.indexOf(","))),
"e:" -> (arg => emails ::= arg.splitAt(arg.indexOf(","))),
"d:" -> (arg => dates ::= arg.splitAt(arg.indexOf(","))),
"f" -> (_ => overwrite = true)
)
getopts(args)
val progress = new Console_Progress()
val context = new Context(names.toMap, emails.toMap, dates.toMap)
val options = Options.init()
migrate_metadata(
base_dir = base_dir,
context = context,
overwrite = overwrite,
options = options,
progress = progress)
}
)
}
\ No newline at end of file
diff --git a/web/index.xml b/web/index.xml
--- a/web/index.xml
+++ b/web/index.xml
@@ -1,13835 +1,13844 @@
Archive of Formal Proofs
/
Recent content on Archive of Formal Proofs
Hugo -- gohugo.io
en-gb
Tue, 11 Jul 2023 00:00:00 +0000
-
Gray Codes for Arbitrary Numeral Systems
/entries/Gray_Codes.html
Tue, 11 Jul 2023 00:00:00 +0000
/entries/Gray_Codes.html
-
Executable Randomized Algorithms
/entries/Executable_Randomized_Algorithms.html
Mon, 19 Jun 2023 00:00:00 +0000
/entries/Executable_Randomized_Algorithms.html
-
DCR Syntax and Execution Equivalent Markings
/entries/DCR-ExecutionEquivalence.html
Fri, 16 Jun 2023 00:00:00 +0000
/entries/DCR-ExecutionEquivalence.html
-
Zeckendorf’s Theorem
/entries/Zeckendorf.html
Mon, 12 Jun 2023 00:00:00 +0000
/entries/Zeckendorf.html
-
Cryptographic Standards
/entries/Crypto_Standards.html
Tue, 06 Jun 2023 00:00:00 +0000
/entries/Crypto_Standards.html
-
A Verified Efficient Implementation of the Weighted Path Order
/entries/Efficient_Weighted_Path_Order.html
Thu, 01 Jun 2023 00:00:00 +0000
/entries/Efficient_Weighted_Path_Order.html
-
Formalizing Results on Directed Sets
/entries/Directed_Sets.html
Wed, 24 May 2023 00:00:00 +0000
/entries/Directed_Sets.html
-
Inner Structure, Determinism and Modal Algebra of Multirelations
/entries/Multirelations_Heterogeneous.html
Mon, 22 May 2023 00:00:00 +0000
/entries/Multirelations_Heterogeneous.html
-
Tree Enumeration
/entries/Tree_Enumeration.html
Tue, 09 May 2023 00:00:00 +0000
/entries/Tree_Enumeration.html
-
MLSS Decision Procedure
/entries/MLSS_Decision_Proc.html
Fri, 05 May 2023 00:00:00 +0000
/entries/MLSS_Decision_Proc.html
-
Three Squares Theorem
/entries/Three_Squares.html
Wed, 03 May 2023 00:00:00 +0000
/entries/Three_Squares.html
-
The Halting Problem is Soluble in Malament-Hogarth Spacetimes
/entries/MHComputation.html
Sat, 29 Apr 2023 00:00:00 +0000
/entries/MHComputation.html
-
The Schwartz-Zippel Lemma
/entries/Schwartz_Zippel.html
Thu, 27 Apr 2023 00:00:00 +0000
/entries/Schwartz_Zippel.html
-
A Formalization of the SCL(FOL) Calculus: Simple Clause Learning for First-Order Logic
/entries/Simple_Clause_Learning.html
Thu, 20 Apr 2023 00:00:00 +0000
/entries/Simple_Clause_Learning.html
-
The CHSH inequality: Tsirelson's upper-bound and other results
/entries/TsirelsonBound.html
Tue, 18 Apr 2023 00:00:00 +0000
/entries/TsirelsonBound.html
-
Distributed Distinct Elements
/entries/Distributed_Distinct_Elements.html
Mon, 03 Apr 2023 00:00:00 +0000
/entries/Distributed_Distinct_Elements.html
-
Formalization of Hyper Hoare Logic: A Logic to (Dis-)Prove Program Hyperproperties
/entries/HyperHoareLogic.html
Mon, 03 Apr 2023 00:00:00 +0000
/entries/HyperHoareLogic.html
-
Positional Notation for Natural Numbers in an Arbitrary Base
/entries/DigitsInBase.html
Mon, 03 Apr 2023 00:00:00 +0000
/entries/DigitsInBase.html
-
Formalization of CommCSL: A Relational Concurrent Separation Logic for Proving Information Flow Security in Concurrent Programs
/entries/CommCSL.html
Wed, 15 Mar 2023 00:00:00 +0000
/entries/CommCSL.html
-
No Faster-Than-Light Observers (GenRel)
/entries/No_FTL_observers_Gen_Rel.html
Sun, 05 Mar 2023 00:00:00 +0000
/entries/No_FTL_observers_Gen_Rel.html
-
Expander Graphs
/entries/Expander_Graphs.html
Fri, 03 Mar 2023 00:00:00 +0000
/entries/Expander_Graphs.html
-
Renaming-Enriched Sets (Rensets) and Renaming-Based Recursion
/entries/Rensets.html
Tue, 28 Feb 2023 00:00:00 +0000
/entries/Rensets.html
-
A Sound and Complete Calculus for Probability Inequalities
/entries/Probability_Inequality_Completeness.html
Mon, 20 Feb 2023 00:00:00 +0000
/entries/Probability_Inequality_Completeness.html
-
Group Law of Edwards Elliptic Curves
/entries/Edwards_Elliptic_Curves_Group.html
Thu, 16 Feb 2023 00:00:00 +0000
/entries/Edwards_Elliptic_Curves_Group.html
-
Hardness of Lattice Problems
/entries/CVP_Hardness.html
Thu, 02 Feb 2023 00:00:00 +0000
/entries/CVP_Hardness.html
-
ABY3 Multiplication and Array Shuffling
/entries/ABY3_Protocols.html
Fri, 27 Jan 2023 00:00:00 +0000
/entries/ABY3_Protocols.html
-
Given Clause Loops
/entries/Given_Clause_Loops.html
Wed, 25 Jan 2023 00:00:00 +0000
/entries/Given_Clause_Loops.html
-
Suppes' Theorem For Probability Logic
/entries/Suppes_Theorem.html
Sun, 22 Jan 2023 00:00:00 +0000
/entries/Suppes_Theorem.html
-
A Hoare Logic for Diverging Programs
/entries/HoareForDivergence.html
Fri, 20 Jan 2023 00:00:00 +0000
/entries/HoareForDivergence.html
-
Strict Omega Categories
/entries/StrictOmegaCategories.html
Sat, 14 Jan 2023 00:00:00 +0000
/entries/StrictOmegaCategories.html
-
Synthetic Completeness
/entries/Synthetic_Completeness.html
Mon, 09 Jan 2023 00:00:00 +0000
/entries/Synthetic_Completeness.html
-
The Cook-Levin theorem
/entries/Cook_Levin.html
Sun, 08 Jan 2023 00:00:00 +0000
/entries/Cook_Levin.html
-
Binary codes that do not preserve primitivity
/entries/Binary_Code_Imprimitive.html
Tue, 03 Jan 2023 00:00:00 +0000
/entries/Binary_Code_Imprimitive.html
-
Intersection of two monoids generated by two element codes
/entries/Two_Generated_Word_Monoids_Intersection.html
Tue, 03 Jan 2023 00:00:00 +0000
/entries/Two_Generated_Word_Monoids_Intersection.html
-
A First Complete Algorithm for Real Quantifier Elimination in Isabelle/HOL
/entries/Quantifier_Elimination_Hybrid.html
Thu, 15 Dec 2022 00:00:00 +0000
/entries/Quantifier_Elimination_Hybrid.html
-
Class-based Classical Propositional Logic
/entries/Propositional_Logic_Class.html
Thu, 15 Dec 2022 00:00:00 +0000
/entries/Propositional_Logic_Class.html
-
Birkhoff's Representation Theorem For Finite Distributive Lattices
/entries/Birkhoff_Finite_Distributive_Lattices.html
Tue, 06 Dec 2022 00:00:00 +0000
/entries/Birkhoff_Finite_Distributive_Lattices.html
-
Automation of Boolos' Curious Inference in Isabelle/HOL
/entries/Boolos_Curious_Inference_Automated.html
Mon, 05 Dec 2022 00:00:00 +0000
/entries/Boolos_Curious_Inference_Automated.html
-
A Verified Translation of Multitape Turing Machines into Singletape Turing Machines
/entries/Multitape_To_Singletape_TM.html
Wed, 30 Nov 2022 00:00:00 +0000
/entries/Multitape_To_Singletape_TM.html
-
Abstract Object Theory
/entries/AOT.html
Mon, 28 Nov 2022 00:00:00 +0000
/entries/AOT.html
-
A Formal CHERI-C Memory Model
/entries/CHERI-C_Memory_Model.html
Fri, 25 Nov 2022 00:00:00 +0000
/entries/CHERI-C_Memory_Model.html
-
Sauer-Shelah Lemma
/entries/Sauer_Shelah_Lemma.html
Thu, 24 Nov 2022 00:00:00 +0000
/entries/Sauer_Shelah_Lemma.html
-
Kneser's Theorem and the Cauchy–Davenport Theorem
/entries/Kneser_Cauchy_Davenport.html
Mon, 21 Nov 2022 00:00:00 +0000
/entries/Kneser_Cauchy_Davenport.html
-
Turán's Graph Theorem
/entries/Turans_Graph_Theorem.html
Mon, 14 Nov 2022 00:00:00 +0000
/entries/Turans_Graph_Theorem.html
-
Combinatorial Enumeration Algorithms
/entries/Combinatorial_Enumeration_Algorithms.html
Fri, 11 Nov 2022 00:00:00 +0000
/entries/Combinatorial_Enumeration_Algorithms.html
-
The Balog–Szemerédi–Gowers Theorem
/entries/Balog_Szemeredi_Gowers.html
Fri, 11 Nov 2022 00:00:00 +0000
/entries/Balog_Szemeredi_Gowers.html
-
The Incompatibility of Strategy-Proofness and Representation in Party-Approval Multi-Winner Elections
/entries/PAPP_Impossibility.html
Thu, 10 Nov 2022 00:00:00 +0000
/entries/PAPP_Impossibility.html
-
Verification of Query Optimization Algorithms
/entries/Query_Optimization.html
Tue, 04 Oct 2022 00:00:00 +0000
/entries/Query_Optimization.html
-
Maximum Segment Sum
/entries/Maximum_Segment_Sum.html
Thu, 29 Sep 2022 00:00:00 +0000
/entries/Maximum_Segment_Sum.html
-
Undirected Graph Theory
/entries/Undirected_Graph_Theory.html
Thu, 29 Sep 2022 00:00:00 +0000
/entries/Undirected_Graph_Theory.html
-
Making Arbitrary Relational Calculus Queries Safe-Range
/entries/Safe_Range_RC.html
Wed, 28 Sep 2022 00:00:00 +0000
/entries/Safe_Range_RC.html
-
Stalnaker's Epistemic Logic
/entries/Stalnaker_Logic.html
Fri, 23 Sep 2022 00:00:00 +0000
/entries/Stalnaker_Logic.html
-
p-adic Fields and p-adic Semialgebraic Sets
/entries/Padic_Field.html
Thu, 22 Sep 2022 00:00:00 +0000
/entries/Padic_Field.html
-
Risk-Free Lending
/entries/Risk_Free_Lending.html
Sun, 18 Sep 2022 00:00:00 +0000
/entries/Risk_Free_Lending.html
-
Soundness and Completeness of Implicational Logic
/entries/Implicational_Logic.html
Tue, 13 Sep 2022 00:00:00 +0000
/entries/Implicational_Logic.html
-
CRYSTALS-Kyber
/entries/CRYSTALS-Kyber.html
Thu, 08 Sep 2022 00:00:00 +0000
/entries/CRYSTALS-Kyber.html
-
Unbounded Separation Logic
/entries/Separation_Logic_Unbounded.html
Mon, 05 Sep 2022 00:00:00 +0000
/entries/Separation_Logic_Unbounded.html
-
Khovanskii's Theorem
/entries/Khovanskii_Theorem.html
Fri, 02 Sep 2022 00:00:00 +0000
/entries/Khovanskii_Theorem.html
-
The Hales–Jewett Theorem
/entries/Hales_Jewett.html
Fri, 02 Sep 2022 00:00:00 +0000
/entries/Hales_Jewett.html
-
Number Theoretic Transform
/entries/Number_Theoretic_Transform.html
Thu, 18 Aug 2022 00:00:00 +0000
/entries/Number_Theoretic_Transform.html
-
Correctness of a Set-based Algorithm for Computing Strongly Connected Components of a Graph
/entries/SCC_Bloemen_Sequential.html
Wed, 17 Aug 2022 00:00:00 +0000
/entries/SCC_Bloemen_Sequential.html
-
From THE BOOK: Two Squares via Involutions
/entries/Involutions2Squares.html
Mon, 15 Aug 2022 00:00:00 +0000
/entries/Involutions2Squares.html
-
Verified Complete Test Strategies for Finite State Machines
/entries/FSM_Tests.html
Tue, 09 Aug 2022 00:00:00 +0000
/entries/FSM_Tests.html
-
Nano JSON: Working with JSON formatted data in Isabelle/HOL and Isabelle/ML
/entries/Nano_JSON.html
Fri, 29 Jul 2022 00:00:00 +0000
/entries/Nano_JSON.html
-
Isabelle/Solidity: A deep Embedding of Solidity in Isabelle/HOL
/entries/Solidity.html
Mon, 18 Jul 2022 00:00:00 +0000
/entries/Solidity.html
-
Simultaneous diagonalization of pairwise commuting Hermitian matrices
/entries/Commuting_Hermitian.html
Mon, 18 Jul 2022 00:00:00 +0000
/entries/Commuting_Hermitian.html
-
Pólya’s Proof of the Weighted Arithmetic–Geometric Mean Inequality
/entries/Weighted_Arithmetic_Geometric_Mean.html
Mon, 11 Jul 2022 00:00:00 +0000
/entries/Weighted_Arithmetic_Geometric_Mean.html
-
A Reuse-Based Multi-Stage Compiler Verification for Language IMP
/entries/IMP_Compiler_Reuse.html
Sun, 10 Jul 2022 00:00:00 +0000
/entries/IMP_Compiler_Reuse.html
-
Real-Time Double-Ended Queue
/entries/Real_Time_Deque.html
Thu, 23 Jun 2022 00:00:00 +0000
/entries/Real_Time_Deque.html
-
Boolos's Curious Inference in Isabelle/HOL
/entries/Boolos_Curious_Inference.html
Mon, 20 Jun 2022 00:00:00 +0000
/entries/Boolos_Curious_Inference.html
-
Finite Fields
/entries/Finite_Fields.html
Wed, 08 Jun 2022 00:00:00 +0000
/entries/Finite_Fields.html
-
IsaNet: Formalization of a Verification Framework for Secure Data Plane Protocols
/entries/IsaNet.html
Wed, 08 Jun 2022 00:00:00 +0000
/entries/IsaNet.html
-
Diophantine Equations and the DPRM Theorem
/entries/DPRM_Theorem.html
Mon, 06 Jun 2022 00:00:00 +0000
/entries/DPRM_Theorem.html
-
Reducing Rewrite Properties to Properties on Ground Terms
/entries/Rewrite_Properties_Reduction.html
Thu, 02 Jun 2022 00:00:00 +0000
/entries/Rewrite_Properties_Reduction.html
-
A Restricted Definition of the Magic Wand to Soundly Combine Fractions of a Wand
/entries/Combinable_Wands.html
Mon, 30 May 2022 00:00:00 +0000
/entries/Combinable_Wands.html
-
The Plünnecke-Ruzsa Inequality
/entries/Pluennecke_Ruzsa_Inequality.html
Thu, 26 May 2022 00:00:00 +0000
/entries/Pluennecke_Ruzsa_Inequality.html
-
Formalization of a Framework for the Sound Automation of Magic Wands
/entries/Package_logic.html
Wed, 18 May 2022 00:00:00 +0000
/entries/Package_logic.html
-
Clique is not solvable by monotone circuits of polynomial size
/entries/Clique_and_Monotone_Circuits.html
Sun, 08 May 2022 00:00:00 +0000
/entries/Clique_and_Monotone_Circuits.html
-
Fisher's Inequality: Linear Algebraic Proof Techniques for Combinatorics
/entries/Fishers_Inequality.html
Thu, 21 Apr 2022 00:00:00 +0000
/entries/Fishers_Inequality.html
-
Digit Expansions
/entries/Digit_Expansions.html
Wed, 20 Apr 2022 00:00:00 +0000
/entries/Digit_Expansions.html
-
The Generalized Multiset Ordering is NP-Complete
/entries/Multiset_Ordering_NPC.html
Wed, 20 Apr 2022 00:00:00 +0000
/entries/Multiset_Ordering_NPC.html
-
The Sophomore's Dream
/entries/Sophomores_Dream.html
Sun, 10 Apr 2022 00:00:00 +0000
/entries/Sophomores_Dream.html
-
A Combinator Library for Prefix-Free Codes
/entries/Prefix_Free_Code_Combinators.html
Fri, 08 Apr 2022 00:00:00 +0000
/entries/Prefix_Free_Code_Combinators.html
-
Formalization of Randomized Approximation Algorithms for Frequency Moments
/entries/Frequency_Moments.html
Fri, 08 Apr 2022 00:00:00 +0000
/entries/Frequency_Moments.html
-
Constructing the Reals as Dedekind Cuts of Rationals
/entries/Dedekind_Real.html
Thu, 24 Mar 2022 00:00:00 +0000
/entries/Dedekind_Real.html
-
Ackermann's Function Is Not Primitive Recursive
/entries/Ackermanns_not_PR.html
Wed, 23 Mar 2022 00:00:00 +0000
/entries/Ackermanns_not_PR.html
-
A Naive Prover for First-Order Logic
/entries/FOL_Seq_Calc3.html
Tue, 22 Mar 2022 00:00:00 +0000
/entries/FOL_Seq_Calc3.html
-
A Proof from THE BOOK: The Partial Fraction Expansion of the Cotangent
/entries/Cotangent_PFD_Formula.html
Tue, 15 Mar 2022 00:00:00 +0000
/entries/Cotangent_PFD_Formula.html
-
The Independence of the Continuum Hypothesis in Isabelle/ZF
/entries/Independence_CH.html
Sun, 06 Mar 2022 00:00:00 +0000
/entries/Independence_CH.html
-
Transitive Models of Fragments of ZFC
/entries/Transitive_Models.html
Thu, 03 Mar 2022 00:00:00 +0000
/entries/Transitive_Models.html
-
Residuated Transition Systems
/entries/ResiduatedTransitionSystem.html
Mon, 28 Feb 2022 00:00:00 +0000
/entries/ResiduatedTransitionSystem.html
-
Universal Hash Families
/entries/Universal_Hash_Families.html
Sun, 20 Feb 2022 00:00:00 +0000
/entries/Universal_Hash_Families.html
-
Wetzel's Problem and the Continuum Hypothesis
/entries/Wetzels_Problem.html
Fri, 18 Feb 2022 00:00:00 +0000
/entries/Wetzels_Problem.html
-
First-Order Query Evaluation
/entries/Eval_FO.html
Tue, 15 Feb 2022 00:00:00 +0000
/entries/Eval_FO.html
-
Multi-Head Monitoring of Metric Dynamic Logic
/entries/VYDRA_MDL.html
Sun, 13 Feb 2022 00:00:00 +0000
/entries/VYDRA_MDL.html
-
Enumeration of Equivalence Relations
/entries/Equivalence_Relation_Enumeration.html
Fri, 04 Feb 2022 00:00:00 +0000
/entries/Equivalence_Relation_Enumeration.html
-
Duality of Linear Programming
/entries/LP_Duality.html
Thu, 03 Feb 2022 00:00:00 +0000
/entries/LP_Duality.html
-
Quasi-Borel Spaces
/entries/Quasi_Borel_Spaces.html
Thu, 03 Feb 2022 00:00:00 +0000
/entries/Quasi_Borel_Spaces.html
-
First-Order Theory of Rewriting
/entries/FO_Theory_Rewriting.html
Wed, 02 Feb 2022 00:00:00 +0000
/entries/FO_Theory_Rewriting.html
-
A Sequent Calculus Prover for First-Order Logic with Functions
/entries/FOL_Seq_Calc2.html
Mon, 31 Jan 2022 00:00:00 +0000
/entries/FOL_Seq_Calc2.html
-
Young's Inequality for Increasing Functions
/entries/Youngs_Inequality.html
Mon, 31 Jan 2022 00:00:00 +0000
/entries/Youngs_Inequality.html
-
Interpolation Polynomials (in HOL-Algebra)
/entries/Interpolation_Polynomials_HOL_Algebra.html
Sat, 29 Jan 2022 00:00:00 +0000
/entries/Interpolation_Polynomials_HOL_Algebra.html
-
Median Method
/entries/Median_Method.html
Tue, 25 Jan 2022 00:00:00 +0000
/entries/Median_Method.html
-
Actuarial Mathematics
/entries/Actuarial_Mathematics.html
Sun, 23 Jan 2022 00:00:00 +0000
/entries/Actuarial_Mathematics.html
-
Irrational numbers from THE BOOK
/entries/Irrationals_From_THEBOOK.html
Sat, 08 Jan 2022 00:00:00 +0000
/entries/Irrationals_From_THEBOOK.html
-
Knight's Tour Revisited Revisited
/entries/Knights_Tour.html
Tue, 04 Jan 2022 00:00:00 +0000
/entries/Knights_Tour.html
-
Hyperdual Numbers and Forward Differentiation
/entries/Hyperdual.html
Fri, 31 Dec 2021 00:00:00 +0000
/entries/Hyperdual.html
-
Gale-Shapley Algorithm
/entries/Gale_Shapley.html
Wed, 29 Dec 2021 00:00:00 +0000
/entries/Gale_Shapley.html
-
Roth's Theorem on Arithmetic Progressions
/entries/Roth_Arithmetic_Progressions.html
Tue, 28 Dec 2021 00:00:00 +0000
/entries/Roth_Arithmetic_Progressions.html
-
Markov Decision Processes with Rewards
/entries/MDP-Rewards.html
Thu, 16 Dec 2021 00:00:00 +0000
/entries/MDP-Rewards.html
-
Verified Algorithms for Solving Markov Decision Processes
/entries/MDP-Algorithms.html
Thu, 16 Dec 2021 00:00:00 +0000
/entries/MDP-Algorithms.html
-
Regular Tree Relations
/entries/Regular_Tree_Relations.html
Wed, 15 Dec 2021 00:00:00 +0000
/entries/Regular_Tree_Relations.html
-
Simplicial Complexes and Boolean functions
/entries/Simplicial_complexes_and_boolean_functions.html
Mon, 29 Nov 2021 00:00:00 +0000
/entries/Simplicial_complexes_and_boolean_functions.html
-
van Emde Boas Trees
/entries/Van_Emde_Boas_Trees.html
Tue, 23 Nov 2021 00:00:00 +0000
/entries/Van_Emde_Boas_Trees.html
-
Foundation of geometry in planes, and some complements: Excluding the parallel axioms
/entries/Foundation_of_geometry.html
Mon, 22 Nov 2021 00:00:00 +0000
/entries/Foundation_of_geometry.html
-
The Hahn and Jordan Decomposition Theorems
/entries/Hahn_Jordan_Decomposition.html
Fri, 19 Nov 2021 00:00:00 +0000
/entries/Hahn_Jordan_Decomposition.html
-
Automating Public Announcement Logic and the Wise Men Puzzle in Isabelle/HOL
/entries/PAL.html
Mon, 08 Nov 2021 00:00:00 +0000
/entries/PAL.html
-
Exploring Simplified Variants of Gödel’s Ontological Argument in Isabelle/HOL
/entries/SimplifiedOntologicalArgument.html
Mon, 08 Nov 2021 00:00:00 +0000
/entries/SimplifiedOntologicalArgument.html
-
Factorization of Polynomials with Algebraic Coefficients
/entries/Factor_Algebraic_Polynomial.html
Mon, 08 Nov 2021 00:00:00 +0000
/entries/Factor_Algebraic_Polynomial.html
-
Real Exponents as the Limits of Sequences of Rational Exponents
/entries/Real_Power.html
Mon, 08 Nov 2021 00:00:00 +0000
/entries/Real_Power.html
-
Szemerédi's Regularity Lemma
/entries/Szemeredi_Regularity.html
Fri, 05 Nov 2021 00:00:00 +0000
/entries/Szemeredi_Regularity.html
-
Quantum and Classical Registers
/entries/Registers.html
Thu, 28 Oct 2021 00:00:00 +0000
/entries/Registers.html
-
Belief Revision Theory
/entries/Belief_Revision.html
Tue, 19 Oct 2021 00:00:00 +0000
/entries/Belief_Revision.html
-
X86 instruction semantics and basic block symbolic execution
/entries/X86_Semantics.html
Wed, 13 Oct 2021 00:00:00 +0000
/entries/X86_Semantics.html
-
Algebras for Iteration, Infinite Executions and Correctness of Sequential Computations
/entries/Correctness_Algebras.html
Tue, 12 Oct 2021 00:00:00 +0000
/entries/Correctness_Algebras.html
-
Verified Quadratic Virtual Substitution for Real Arithmetic
/entries/Virtual_Substitution.html
Sat, 02 Oct 2021 00:00:00 +0000
/entries/Virtual_Substitution.html
-
Soundness and Completeness of an Axiomatic System for First-Order Logic
/entries/FOL_Axiomatic.html
Fri, 24 Sep 2021 00:00:00 +0000
/entries/FOL_Axiomatic.html
-
Complex Bounded Operators
/entries/Complex_Bounded_Operators.html
Sat, 18 Sep 2021 00:00:00 +0000
/entries/Complex_Bounded_Operators.html
-
A Formalization of Weighted Path Orders and Recursive Path Orders
/entries/Weighted_Path_Order.html
Thu, 16 Sep 2021 00:00:00 +0000
/entries/Weighted_Path_Order.html
-
Category Theory for ZFC in HOL I: Foundations: Design Patterns, Set Theory, Digraphs, Semicategories
/entries/CZH_Foundations.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/CZH_Foundations.html
-
Category Theory for ZFC in HOL II: Elementary Theory of 1-Categories
/entries/CZH_Elementary_Categories.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/CZH_Elementary_Categories.html
-
Category Theory for ZFC in HOL III: Universal Constructions
/entries/CZH_Universal_Constructions.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/CZH_Universal_Constructions.html
-
Conditional Simplification
/entries/Conditional_Simplification.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/Conditional_Simplification.html
-
Conditional Transfer Rule
/entries/Conditional_Transfer_Rule.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/Conditional_Transfer_Rule.html
-
Extension of Types-To-Sets
/entries/Types_To_Sets_Extension.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/Types_To_Sets_Extension.html
-
IDE: Introduction, Destruction, Elimination
/entries/Intro_Dest_Elim.html
Mon, 06 Sep 2021 00:00:00 +0000
/entries/Intro_Dest_Elim.html
-
A data flow analysis algorithm for computing dominators
/entries/Dominance_CHK.html
Sun, 05 Sep 2021 00:00:00 +0000
/entries/Dominance_CHK.html
-
Solving Cubic and Quartic Equations
/entries/Cubic_Quartic_Equations.html
Fri, 03 Sep 2021 00:00:00 +0000
/entries/Cubic_Quartic_Equations.html
-
Logging-independent Message Anonymity in the Relational Method
/entries/Logging_Independent_Anonymity.html
Thu, 26 Aug 2021 00:00:00 +0000
/entries/Logging_Independent_Anonymity.html
-
The Theorem of Three Circles
/entries/Three_Circles.html
Sat, 21 Aug 2021 00:00:00 +0000
/entries/Three_Circles.html
-
CoCon: A Confidentiality-Verified Conference Management System
/entries/CoCon.html
Mon, 16 Aug 2021 00:00:00 +0000
/entries/CoCon.html
-
Compositional BD Security
/entries/BD_Security_Compositional.html
Mon, 16 Aug 2021 00:00:00 +0000
/entries/BD_Security_Compositional.html
-
CoSMed: A confidentiality-verified social media platform
/entries/CoSMed.html
Mon, 16 Aug 2021 00:00:00 +0000
/entries/CoSMed.html
-
CoSMeDis: A confidentiality-verified distributed social media platform
/entries/CoSMeDis.html
Mon, 16 Aug 2021 00:00:00 +0000
/entries/CoSMeDis.html
-
Fresh identifiers
/entries/Fresh_Identifiers.html
Mon, 16 Aug 2021 00:00:00 +0000
/entries/Fresh_Identifiers.html
-
Combinatorial Design Theory
/entries/Design_Theory.html
Fri, 13 Aug 2021 00:00:00 +0000
/entries/Design_Theory.html
-
Relational Forests
/entries/Relational_Forests.html
Tue, 03 Aug 2021 00:00:00 +0000
/entries/Relational_Forests.html
-
Schutz' Independent Axioms for Minkowski Spacetime
/entries/Schutz_Spacetime.html
Tue, 27 Jul 2021 00:00:00 +0000
/entries/Schutz_Spacetime.html
-
Finitely Generated Abelian Groups
/entries/Finitely_Generated_Abelian_Groups.html
Wed, 07 Jul 2021 00:00:00 +0000
/entries/Finitely_Generated_Abelian_Groups.html
-
SpecCheck - Specification-Based Testing for Isabelle/ML
/entries/SpecCheck.html
Thu, 01 Jul 2021 00:00:00 +0000
/entries/SpecCheck.html
-
Van der Waerden's Theorem
/entries/Van_der_Waerden.html
Tue, 22 Jun 2021 00:00:00 +0000
/entries/Van_der_Waerden.html
-
MiniSail - A kernel language for the ISA specification language SAIL
/entries/MiniSail.html
Fri, 18 Jun 2021 00:00:00 +0000
/entries/MiniSail.html
-
Public Announcement Logic
/entries/Public_Announcement_Logic.html
Thu, 17 Jun 2021 00:00:00 +0000
/entries/Public_Announcement_Logic.html
-
A Shorter Compiler Correctness Proof for Language IMP
/entries/IMP_Compiler.html
Fri, 04 Jun 2021 00:00:00 +0000
/entries/IMP_Compiler.html
-
Combinatorics on Words Basics
/entries/Combinatorics_Words.html
Mon, 24 May 2021 00:00:00 +0000
/entries/Combinatorics_Words.html
-
Graph Lemma
/entries/Combinatorics_Words_Graph_Lemma.html
Mon, 24 May 2021 00:00:00 +0000
/entries/Combinatorics_Words_Graph_Lemma.html
-
Lyndon words
/entries/Combinatorics_Words_Lyndon.html
Mon, 24 May 2021 00:00:00 +0000
/entries/Combinatorics_Words_Lyndon.html
-
Regression Test Selection
/entries/Regression_Test_Selection.html
Fri, 30 Apr 2021 00:00:00 +0000
/entries/Regression_Test_Selection.html
-
Isabelle's Metalogic: Formalization and Proof Checker
/entries/Metalogic_ProofChecker.html
Tue, 27 Apr 2021 00:00:00 +0000
/entries/Metalogic_ProofChecker.html
-
Lifting the Exponent
/entries/Lifting_the_Exponent.html
Tue, 27 Apr 2021 00:00:00 +0000
/entries/Lifting_the_Exponent.html
-
The BKR Decision Procedure for Univariate Real Arithmetic
/entries/BenOr_Kozen_Reif.html
Sat, 24 Apr 2021 00:00:00 +0000
/entries/BenOr_Kozen_Reif.html
-
Gale-Stewart Games
/entries/GaleStewart_Games.html
Fri, 23 Apr 2021 00:00:00 +0000
/entries/GaleStewart_Games.html
-
Formalization of Timely Dataflow's Progress Tracking Protocol
/entries/Progress_Tracking.html
Tue, 13 Apr 2021 00:00:00 +0000
/entries/Progress_Tracking.html
-
Information Flow Control via Dependency Tracking
/entries/IFC_Tracking.html
Thu, 01 Apr 2021 00:00:00 +0000
/entries/IFC_Tracking.html
-
Grothendieck's Schemes in Algebraic Geometry
/entries/Grothendieck_Schemes.html
Mon, 29 Mar 2021 00:00:00 +0000
/entries/Grothendieck_Schemes.html
-
Hensel's Lemma for the p-adic Integers
/entries/Padic_Ints.html
Tue, 23 Mar 2021 00:00:00 +0000
/entries/Padic_Ints.html
-
Constructive Cryptography in HOL: the Communication Modeling Aspect
/entries/Constructive_Cryptography_CM.html
Wed, 17 Mar 2021 00:00:00 +0000
/entries/Constructive_Cryptography_CM.html
-
Two algorithms based on modular arithmetic: lattice basis reduction and Hermite normal form computation
/entries/Modular_arithmetic_LLL_and_HNF_algorithms.html
Fri, 12 Mar 2021 00:00:00 +0000
/entries/Modular_arithmetic_LLL_and_HNF_algorithms.html
-
Quantum projective measurements and the CHSH inequality
/entries/Projective_Measurements.html
Wed, 03 Mar 2021 00:00:00 +0000
/entries/Projective_Measurements.html
-
The Hermite–Lindemann–Weierstraß Transcendence Theorem
/entries/Hermite_Lindemann.html
Wed, 03 Mar 2021 00:00:00 +0000
/entries/Hermite_Lindemann.html
-
Mereology
/entries/Mereology.html
Mon, 01 Mar 2021 00:00:00 +0000
/entries/Mereology.html
-
The Sunflower Lemma of Erdős and Rado
/entries/Sunflowers.html
Thu, 25 Feb 2021 00:00:00 +0000
/entries/Sunflowers.html
-
A Verified Imperative Implementation of B-Trees
/entries/BTree.html
Wed, 24 Feb 2021 00:00:00 +0000
/entries/BTree.html
-
Formal Puiseux Series
/entries/Formal_Puiseux_Series.html
Wed, 17 Feb 2021 00:00:00 +0000
/entries/Formal_Puiseux_Series.html
-
The Laws of Large Numbers
/entries/Laws_of_Large_Numbers.html
Wed, 10 Feb 2021 00:00:00 +0000
/entries/Laws_of_Large_Numbers.html
-
Tarski's Parallel Postulate implies the 5th Postulate of Euclid, the Postulate of Playfair and the original Parallel Postulate of Euclid
/entries/IsaGeoCoq.html
Sun, 31 Jan 2021 00:00:00 +0000
/entries/IsaGeoCoq.html
-
Solution to the xkcd Blue Eyes puzzle
/entries/Blue_Eyes.html
Sat, 30 Jan 2021 00:00:00 +0000
/entries/Blue_Eyes.html
-
Hood-Melville Queue
/entries/Hood_Melville_Queue.html
Mon, 18 Jan 2021 00:00:00 +0000
/entries/Hood_Melville_Queue.html
-
JinjaDCI: a Java semantics with dynamic class initialization
/entries/JinjaDCI.html
Mon, 11 Jan 2021 00:00:00 +0000
/entries/JinjaDCI.html
-
Cofinality and the Delta System Lemma
/entries/Delta_System_Lemma.html
Sun, 27 Dec 2020 00:00:00 +0000
/entries/Delta_System_Lemma.html
-
Topological semantics for paraconsistent and paracomplete logics
/entries/Topological_Semantics.html
Thu, 17 Dec 2020 00:00:00 +0000
/entries/Topological_Semantics.html
-
Relational Minimum Spanning Tree Algorithms
/entries/Relational_Minimum_Spanning_Trees.html
Tue, 08 Dec 2020 00:00:00 +0000
/entries/Relational_Minimum_Spanning_Trees.html
-
Inline Caching and Unboxing Optimization for Interpreters
/entries/Interpreter_Optimizations.html
Mon, 07 Dec 2020 00:00:00 +0000
/entries/Interpreter_Optimizations.html
-
The Relational Method with Message Anonymity for the Verification of Cryptographic Protocols
/entries/Relational_Method.html
Sat, 05 Dec 2020 00:00:00 +0000
/entries/Relational_Method.html
-
Isabelle Marries Dirac: a Library for Quantum Computation and Quantum Information
/entries/Isabelle_Marries_Dirac.html
Sun, 22 Nov 2020 00:00:00 +0000
/entries/Isabelle_Marries_Dirac.html
-
The HOL-CSP Refinement Toolkit
/entries/CSP_RefTK.html
Thu, 19 Nov 2020 00:00:00 +0000
/entries/CSP_RefTK.html
-
AI Planning Languages Semantics
/entries/AI_Planning_Languages_Semantics.html
Thu, 29 Oct 2020 00:00:00 +0000
/entries/AI_Planning_Languages_Semantics.html
-
Verified SAT-Based AI Planning
/entries/Verified_SAT_Based_AI_Planning.html
Thu, 29 Oct 2020 00:00:00 +0000
/entries/Verified_SAT_Based_AI_Planning.html
-
A Sound Type System for Physical Quantities, Units, and Measurements
/entries/Physical_Quantities.html
Tue, 20 Oct 2020 00:00:00 +0000
/entries/Physical_Quantities.html
-
Finite Map Extras
/entries/Finite-Map-Extras.html
Mon, 12 Oct 2020 00:00:00 +0000
/entries/Finite-Map-Extras.html
-
A Formal Model of the Document Object Model with Shadow Roots
/entries/Shadow_DOM.html
Mon, 28 Sep 2020 00:00:00 +0000
/entries/Shadow_DOM.html
-
A Formal Model of the Safely Composable Document Object Model with Shadow Roots
/entries/Shadow_SC_DOM.html
Mon, 28 Sep 2020 00:00:00 +0000
/entries/Shadow_SC_DOM.html
-
A Formalization of Safely Composable Web Components
/entries/SC_DOM_Components.html
Mon, 28 Sep 2020 00:00:00 +0000
/entries/SC_DOM_Components.html
-
A Formalization of Web Components
/entries/DOM_Components.html
Mon, 28 Sep 2020 00:00:00 +0000
/entries/DOM_Components.html
-
The Safely Composable DOM
/entries/Core_SC_DOM.html
Mon, 28 Sep 2020 00:00:00 +0000
/entries/Core_SC_DOM.html
-
An Abstract Formalization of Gödel's Incompleteness Theorems
/entries/Goedel_Incompleteness.html
Wed, 16 Sep 2020 00:00:00 +0000
/entries/Goedel_Incompleteness.html
-
From Abstract to Concrete Gödel's Incompleteness Theorems—Part I
/entries/Goedel_HFSet_Semantic.html
Wed, 16 Sep 2020 00:00:00 +0000
/entries/Goedel_HFSet_Semantic.html
-
From Abstract to Concrete Gödel's Incompleteness Theorems—Part II
/entries/Goedel_HFSet_Semanticless.html
Wed, 16 Sep 2020 00:00:00 +0000
/entries/Goedel_HFSet_Semanticless.html
-
Robinson Arithmetic
/entries/Robinson_Arithmetic.html
Wed, 16 Sep 2020 00:00:00 +0000
/entries/Robinson_Arithmetic.html
-
Syntax-Independent Logic Infrastructure
/entries/Syntax_Independent_Logic.html
Wed, 16 Sep 2020 00:00:00 +0000
/entries/Syntax_Independent_Logic.html
-
A Formal Model of Extended Finite State Machines
/entries/Extended_Finite_State_Machines.html
Mon, 07 Sep 2020 00:00:00 +0000
/entries/Extended_Finite_State_Machines.html
-
Inference of Extended Finite State Machines
/entries/Extended_Finite_State_Machine_Inference.html
Mon, 07 Sep 2020 00:00:00 +0000
/entries/Extended_Finite_State_Machine_Inference.html
-
Practical Algebraic Calculus Checker
/entries/PAC_Checker.html
Mon, 31 Aug 2020 00:00:00 +0000
/entries/PAC_Checker.html
-
Some classical results in inductive inference of recursive functions
/entries/Inductive_Inference.html
Mon, 31 Aug 2020 00:00:00 +0000
/entries/Inductive_Inference.html
-
Relational Disjoint-Set Forests
/entries/Relational_Disjoint_Set_Forests.html
Wed, 26 Aug 2020 00:00:00 +0000
/entries/Relational_Disjoint_Set_Forests.html
-
Extensions to the Comprehensive Framework for Saturation Theorem Proving
/entries/Saturation_Framework_Extensions.html
Tue, 25 Aug 2020 00:00:00 +0000
/entries/Saturation_Framework_Extensions.html
-
Putting the `K' into Bird's derivation of Knuth-Morris-Pratt string matching
/entries/BirdKMP.html
Tue, 25 Aug 2020 00:00:00 +0000
/entries/BirdKMP.html
-
Amicable Numbers
/entries/Amicable_Numbers.html
Tue, 04 Aug 2020 00:00:00 +0000
/entries/Amicable_Numbers.html
-
Ordinal Partitions
/entries/Ordinal_Partitions.html
Mon, 03 Aug 2020 00:00:00 +0000
/entries/Ordinal_Partitions.html
-
A Formal Proof of The Chandy--Lamport Distributed Snapshot Algorithm
/entries/Chandy_Lamport.html
Tue, 21 Jul 2020 00:00:00 +0000
/entries/Chandy_Lamport.html
-
Relational Characterisations of Paths
/entries/Relational_Paths.html
Mon, 13 Jul 2020 00:00:00 +0000
/entries/Relational_Paths.html
-
A Formally Verified Checker of the Safe Distance Traffic Rules for Autonomous Vehicles
/entries/Safe_Distance.html
Mon, 01 Jun 2020 00:00:00 +0000
/entries/Safe_Distance.html
-
A verified algorithm for computing the Smith normal form of a matrix
/entries/Smith_Normal_Form.html
Sat, 23 May 2020 00:00:00 +0000
/entries/Smith_Normal_Form.html
-
The Nash-Williams Partition Theorem
/entries/Nash_Williams.html
Sat, 16 May 2020 00:00:00 +0000
/entries/Nash_Williams.html
-
A Formalization of Knuth–Bendix Orders
/entries/Knuth_Bendix_Order.html
Wed, 13 May 2020 00:00:00 +0000
/entries/Knuth_Bendix_Order.html
-
Irrationality Criteria for Series by Erdős and Straus
/entries/Irrational_Series_Erdos_Straus.html
Tue, 12 May 2020 00:00:00 +0000
/entries/Irrational_Series_Erdos_Straus.html
-
Recursion Theorem in ZF
/entries/Recursion-Addition.html
Mon, 11 May 2020 00:00:00 +0000
/entries/Recursion-Addition.html
-
An Efficient Normalisation Procedure for Linear Temporal Logic: Isabelle/HOL Formalisation
/entries/LTL_Normal_Form.html
Fri, 08 May 2020 00:00:00 +0000
/entries/LTL_Normal_Form.html
-
Formalization of Forcing in Isabelle/ZF
/entries/Forcing.html
Wed, 06 May 2020 00:00:00 +0000
/entries/Forcing.html
-
Banach-Steinhaus Theorem
/entries/Banach_Steinhaus.html
Sat, 02 May 2020 00:00:00 +0000
/entries/Banach_Steinhaus.html
-
Attack Trees in Isabelle for GDPR compliance of IoT healthcare systems
/entries/Attack_Trees.html
Mon, 27 Apr 2020 00:00:00 +0000
/entries/Attack_Trees.html
-
Gaussian Integers
/entries/Gaussian_Integers.html
Fri, 24 Apr 2020 00:00:00 +0000
/entries/Gaussian_Integers.html
-
Power Sum Polynomials
/entries/Power_Sum_Polynomials.html
Fri, 24 Apr 2020 00:00:00 +0000
/entries/Power_Sum_Polynomials.html
-
The Lambert W Function on the Reals
/entries/Lambert_W.html
Fri, 24 Apr 2020 00:00:00 +0000
/entries/Lambert_W.html
-
Matrices for ODEs
/entries/Matrices_for_ODEs.html
Sun, 19 Apr 2020 00:00:00 +0000
/entries/Matrices_for_ODEs.html
-
Authenticated Data Structures As Functors
/entries/ADS_Functor.html
Thu, 16 Apr 2020 00:00:00 +0000
/entries/ADS_Functor.html
-
Formalization of an Algorithm for Greedily Computing Associative Aggregations on Sliding Windows
/entries/Sliding_Window_Algorithm.html
Fri, 10 Apr 2020 00:00:00 +0000
/entries/Sliding_Window_Algorithm.html
-
A Comprehensive Framework for Saturation Theorem Proving
/entries/Saturation_Framework.html
Thu, 09 Apr 2020 00:00:00 +0000
/entries/Saturation_Framework.html
-
Formalization of an Optimized Monitoring Algorithm for Metric First-Order Dynamic Logic with Aggregations
/entries/MFODL_Monitor_Optimized.html
Thu, 09 Apr 2020 00:00:00 +0000
/entries/MFODL_Monitor_Optimized.html
-
Automated Stateful Protocol Verification
/entries/Automated_Stateful_Protocol_Verification.html
Wed, 08 Apr 2020 00:00:00 +0000
/entries/Automated_Stateful_Protocol_Verification.html
-
Stateful Protocol Composition and Typing
/entries/Stateful_Protocol_Composition_and_Typing.html
Wed, 08 Apr 2020 00:00:00 +0000
/entries/Stateful_Protocol_Composition_and_Typing.html
-
Lucas's Theorem
/entries/Lucas_Theorem.html
Tue, 07 Apr 2020 00:00:00 +0000
/entries/Lucas_Theorem.html
-
Strong Eventual Consistency of the Collaborative Editing Framework WOOT
/entries/WOOT_Strong_Eventual_Consistency.html
Wed, 25 Mar 2020 00:00:00 +0000
/entries/WOOT_Strong_Eventual_Consistency.html
-
Furstenberg's topology and his proof of the infinitude of primes
/entries/Furstenberg_Topology.html
Sun, 22 Mar 2020 00:00:00 +0000
/entries/Furstenberg_Topology.html
-
An Under-Approximate Relational Logic
/entries/Relational-Incorrectness-Logic.html
Thu, 12 Mar 2020 00:00:00 +0000
/entries/Relational-Incorrectness-Logic.html
-
Hello World
/entries/Hello_World.html
Sat, 07 Mar 2020 00:00:00 +0000
/entries/Hello_World.html
-
Implementing the Goodstein Function in λ-Calculus
/entries/Goodstein_Lambda.html
Fri, 21 Feb 2020 00:00:00 +0000
/entries/Goodstein_Lambda.html
-
A Generic Framework for Verified Compilers
/entries/VeriComp.html
Mon, 10 Feb 2020 00:00:00 +0000
/entries/VeriComp.html
-
Arithmetic progressions and relative primes
/entries/Arith_Prog_Rel_Primes.html
Sat, 01 Feb 2020 00:00:00 +0000
/entries/Arith_Prog_Rel_Primes.html
-
A Hierarchy of Algebras for Boolean Subsets
/entries/Subset_Boolean_Algebras.html
Fri, 31 Jan 2020 00:00:00 +0000
/entries/Subset_Boolean_Algebras.html
-
Mersenne primes and the Lucas–Lehmer test
/entries/Mersenne_Primes.html
Fri, 17 Jan 2020 00:00:00 +0000
/entries/Mersenne_Primes.html
-
Verified Approximation Algorithms
/entries/Approximation_Algorithms.html
Thu, 16 Jan 2020 00:00:00 +0000
/entries/Approximation_Algorithms.html
-
Closest Pair of Points Algorithms
/entries/Closest_Pair_Points.html
Mon, 13 Jan 2020 00:00:00 +0000
/entries/Closest_Pair_Points.html
-
Skip Lists
/entries/Skip_Lists.html
Thu, 09 Jan 2020 00:00:00 +0000
/entries/Skip_Lists.html
-
Bicategories
/entries/Bicategory.html
Mon, 06 Jan 2020 00:00:00 +0000
/entries/Bicategory.html
-
The Irrationality of ζ(3)
/entries/Zeta_3_Irrational.html
Fri, 27 Dec 2019 00:00:00 +0000
/entries/Zeta_3_Irrational.html
-
Formalizing a Seligman-Style Tableau System for Hybrid Logic
/entries/Hybrid_Logic.html
Fri, 20 Dec 2019 00:00:00 +0000
/entries/Hybrid_Logic.html
-
The Poincaré-Bendixson Theorem
/entries/Poincare_Bendixson.html
Wed, 18 Dec 2019 00:00:00 +0000
/entries/Poincare_Bendixson.html
-
Complex Geometry
/entries/Complex_Geometry.html
Mon, 16 Dec 2019 00:00:00 +0000
/entries/Complex_Geometry.html
-
Poincaré Disc Model
/entries/Poincare_Disc.html
Mon, 16 Dec 2019 00:00:00 +0000
/entries/Poincare_Disc.html
-
Gauss Sums and the Pólya–Vinogradov Inequality
/entries/Gauss_Sums.html
Tue, 10 Dec 2019 00:00:00 +0000
/entries/Gauss_Sums.html
-
An Efficient Generalization of Counting Sort for Large, possibly Infinite Key Ranges
/entries/Generalized_Counting_Sort.html
Wed, 04 Dec 2019 00:00:00 +0000
/entries/Generalized_Counting_Sort.html
-
Interval Arithmetic on 32-bit Words
/entries/Interval_Arithmetic_Word32.html
Wed, 27 Nov 2019 00:00:00 +0000
/entries/Interval_Arithmetic_Word32.html
-
Zermelo Fraenkel Set Theory in Higher-Order Logic
/entries/ZFC_in_HOL.html
Thu, 24 Oct 2019 00:00:00 +0000
/entries/ZFC_in_HOL.html
-
Isabelle/C
/entries/Isabelle_C.html
Tue, 22 Oct 2019 00:00:00 +0000
/entries/Isabelle_C.html
-
VerifyThis 2019 -- Polished Isabelle Solutions
/entries/VerifyThis2019.html
Wed, 16 Oct 2019 00:00:00 +0000
/entries/VerifyThis2019.html
-
Aristotle's Assertoric Syllogistic
/entries/Aristotles_Assertoric_Syllogistic.html
Tue, 08 Oct 2019 00:00:00 +0000
/entries/Aristotles_Assertoric_Syllogistic.html
-
Sigma Protocols and Commitment Schemes
/entries/Sigma_Commit_Crypto.html
Mon, 07 Oct 2019 00:00:00 +0000
/entries/Sigma_Commit_Crypto.html
-
Clean - An Abstract Imperative Programming Language and its Theory
/entries/Clean.html
Fri, 04 Oct 2019 00:00:00 +0000
/entries/Clean.html
-
Formalization of Multiway-Join Algorithms
/entries/Generic_Join.html
Mon, 16 Sep 2019 00:00:00 +0000
/entries/Generic_Join.html
-
Verification Components for Hybrid Systems
/entries/Hybrid_Systems_VCs.html
Tue, 10 Sep 2019 00:00:00 +0000
/entries/Hybrid_Systems_VCs.html
-
Fourier Series
/entries/Fourier.html
Fri, 06 Sep 2019 00:00:00 +0000
/entries/Fourier.html
-
A Case Study in Basic Algebra
/entries/Jacobson_Basic_Algebra.html
Fri, 30 Aug 2019 00:00:00 +0000
/entries/Jacobson_Basic_Algebra.html
-
Formalisation of an Adaptive State Counting Algorithm
/entries/Adaptive_State_Counting.html
Fri, 16 Aug 2019 00:00:00 +0000
/entries/Adaptive_State_Counting.html
-
Laplace Transform
/entries/Laplace_Transform.html
Wed, 14 Aug 2019 00:00:00 +0000
/entries/Laplace_Transform.html
-
Communicating Concurrent Kleene Algebra for Distributed Systems Specification
/entries/C2KA_DistributedSystems.html
Tue, 06 Aug 2019 00:00:00 +0000
/entries/C2KA_DistributedSystems.html
-
Linear Programming
/entries/Linear_Programming.html
Tue, 06 Aug 2019 00:00:00 +0000
/entries/Linear_Programming.html
-
Selected Problems from the International Mathematical Olympiad 2019
/entries/IMO2019.html
Mon, 05 Aug 2019 00:00:00 +0000
/entries/IMO2019.html
-
Stellar Quorum Systems
/entries/Stellar_Quorums.html
Thu, 01 Aug 2019 00:00:00 +0000
/entries/Stellar_Quorums.html
-
A Formal Development of a Polychronous Polytimed Coordination Language
/entries/TESL_Language.html
Tue, 30 Jul 2019 00:00:00 +0000
/entries/TESL_Language.html
-
Order Extension and Szpilrajn's Extension Theorem
/entries/Szpilrajn.html
Sat, 27 Jul 2019 00:00:00 +0000
/entries/Szpilrajn.html
-
A Sequent Calculus for First-Order Logic
/entries/FOL_Seq_Calc1.html
Thu, 18 Jul 2019 00:00:00 +0000
/entries/FOL_Seq_Calc1.html
-
A Verified Code Generator from Isabelle/HOL to CakeML
/entries/CakeML_Codegen.html
Mon, 08 Jul 2019 00:00:00 +0000
/entries/CakeML_Codegen.html
-
Formalization of a Monitoring Algorithm for Metric First-Order Temporal Logic
/entries/MFOTL_Monitor.html
Thu, 04 Jul 2019 00:00:00 +0000
/entries/MFOTL_Monitor.html
-
Complete Non-Orders and Fixed Points
/entries/Complete_Non_Orders.html
Thu, 27 Jun 2019 00:00:00 +0000
/entries/Complete_Non_Orders.html
-
Priority Search Trees
/entries/Priority_Search_Trees.html
Tue, 25 Jun 2019 00:00:00 +0000
/entries/Priority_Search_Trees.html
-
Purely Functional, Simple, and Efficient Implementation of Prim and Dijkstra
/entries/Prim_Dijkstra_Simple.html
Tue, 25 Jun 2019 00:00:00 +0000
/entries/Prim_Dijkstra_Simple.html
-
Linear Inequalities
/entries/Linear_Inequalities.html
Fri, 21 Jun 2019 00:00:00 +0000
/entries/Linear_Inequalities.html
-
Hilbert's Nullstellensatz
/entries/Nullstellensatz.html
Sun, 16 Jun 2019 00:00:00 +0000
/entries/Nullstellensatz.html
-
Gröbner Bases, Macaulay Matrices and Dubé's Degree Bounds
/entries/Groebner_Macaulay.html
Sat, 15 Jun 2019 00:00:00 +0000
/entries/Groebner_Macaulay.html
-
Binary Heaps for IMP2
/entries/IMP2_Binary_Heap.html
Thu, 13 Jun 2019 00:00:00 +0000
/entries/IMP2_Binary_Heap.html
-
Differential Game Logic
/entries/Differential_Game_Logic.html
Mon, 03 Jun 2019 00:00:00 +0000
/entries/Differential_Game_Logic.html
-
Multidimensional Binary Search Trees
/entries/KD_Tree.html
Thu, 30 May 2019 00:00:00 +0000
/entries/KD_Tree.html
-
Formalization of Generic Authenticated Data Structures
/entries/LambdaAuth.html
Tue, 14 May 2019 00:00:00 +0000
/entries/LambdaAuth.html
-
Multi-Party Computation
/entries/Multi_Party_Computation.html
Thu, 09 May 2019 00:00:00 +0000
/entries/Multi_Party_Computation.html
-
HOL-CSP Version 2.0
/entries/HOL-CSP.html
Fri, 26 Apr 2019 00:00:00 +0000
/entries/HOL-CSP.html
-
A Compositional and Unified Translation of LTL into ω-Automata
/entries/LTL_Master_Theorem.html
Tue, 16 Apr 2019 00:00:00 +0000
/entries/LTL_Master_Theorem.html
-
A General Theory of Syntax with Bindings
/entries/Binding_Syntax_Theory.html
Sat, 06 Apr 2019 00:00:00 +0000
/entries/Binding_Syntax_Theory.html
-
The Transcendence of Certain Infinite Series
/entries/Transcendence_Series_Hancl_Rucki.html
Wed, 27 Mar 2019 00:00:00 +0000
/entries/Transcendence_Series_Hancl_Rucki.html
-
Quantum Hoare Logic
/entries/QHLProver.html
Sun, 24 Mar 2019 00:00:00 +0000
/entries/QHLProver.html
-
Safe OCL
/entries/Safe_OCL.html
Sat, 09 Mar 2019 00:00:00 +0000
/entries/Safe_OCL.html
-
Elementary Facts About the Distribution of Primes
/entries/Prime_Distribution_Elementary.html
Thu, 21 Feb 2019 00:00:00 +0000
/entries/Prime_Distribution_Elementary.html
-
Kruskal's Algorithm for Minimum Spanning Forest
/entries/Kruskal.html
Thu, 14 Feb 2019 00:00:00 +0000
/entries/Kruskal.html
-
Probabilistic Primality Testing
/entries/Probabilistic_Prime_Tests.html
Mon, 11 Feb 2019 00:00:00 +0000
/entries/Probabilistic_Prime_Tests.html
-
Universal Turing Machine
/entries/Universal_Turing_Machine.html
Fri, 08 Feb 2019 00:00:00 +0000
/entries/Universal_Turing_Machine.html
-
Isabelle/UTP: Mechanised Theory Engineering for Unifying Theories of Programming
/entries/UTP.html
Fri, 01 Feb 2019 00:00:00 +0000
/entries/UTP.html
-
The Inversions of a List
/entries/List_Inversions.html
Fri, 01 Feb 2019 00:00:00 +0000
/entries/List_Inversions.html
-
Farkas' Lemma and Motzkin's Transposition Theorem
/entries/Farkas.html
Thu, 17 Jan 2019 00:00:00 +0000
/entries/Farkas.html
-
An Algebra for Higher-Order Terms
/entries/Higher_Order_Terms.html
Tue, 15 Jan 2019 00:00:00 +0000
/entries/Higher_Order_Terms.html
-
IMP2 – Simple Program Verification in Isabelle/HOL
/entries/IMP2.html
Tue, 15 Jan 2019 00:00:00 +0000
/entries/IMP2.html
-
A Reduction Theorem for Store Buffers
/entries/Store_Buffer_Reduction.html
Mon, 07 Jan 2019 00:00:00 +0000
/entries/Store_Buffer_Reduction.html
-
A Formal Model of the Document Object Model
/entries/Core_DOM.html
Wed, 26 Dec 2018 00:00:00 +0000
/entries/Core_DOM.html
-
Formalization of Concurrent Revisions
/entries/Concurrent_Revisions.html
Tue, 25 Dec 2018 00:00:00 +0000
/entries/Concurrent_Revisions.html
-
Verifying Imperative Programs using Auto2
/entries/Auto2_Imperative_HOL.html
Fri, 21 Dec 2018 00:00:00 +0000
/entries/Auto2_Imperative_HOL.html
-
Constructive Cryptography in HOL
/entries/Constructive_Cryptography.html
Mon, 17 Dec 2018 00:00:00 +0000
/entries/Constructive_Cryptography.html
-
Properties of Orderings and Lattices
/entries/Order_Lattice_Props.html
Tue, 11 Dec 2018 00:00:00 +0000
/entries/Order_Lattice_Props.html
-
Quantales
/entries/Quantales.html
Tue, 11 Dec 2018 00:00:00 +0000
/entries/Quantales.html
-
Transformer Semantics
/entries/Transformer_Semantics.html
Tue, 11 Dec 2018 00:00:00 +0000
/entries/Transformer_Semantics.html
-
A Verified Functional Implementation of Bachmair and Ganzinger's Ordered Resolution Prover
/entries/Functional_Ordered_Resolution_Prover.html
Fri, 23 Nov 2018 00:00:00 +0000
/entries/Functional_Ordered_Resolution_Prover.html
-
Graph Saturation
/entries/Graph_Saturation.html
Fri, 23 Nov 2018 00:00:00 +0000
/entries/Graph_Saturation.html
-
Auto2 Prover
/entries/Auto2_HOL.html
Tue, 20 Nov 2018 00:00:00 +0000
/entries/Auto2_HOL.html
-
Matroids
/entries/Matroids.html
Fri, 16 Nov 2018 00:00:00 +0000
/entries/Matroids.html
-
Deriving generic class instances for datatypes
/entries/Generic_Deriving.html
Tue, 06 Nov 2018 00:00:00 +0000
/entries/Generic_Deriving.html
-
Formalisation and Evaluation of Alan Gewirth's Proof for the Principle of Generic Consistency in Isabelle/HOL
/entries/GewirthPGCProof.html
Tue, 30 Oct 2018 00:00:00 +0000
/entries/GewirthPGCProof.html
-
Epistemic Logic: Completeness of Modal Logics
/entries/Epistemic_Logic.html
Mon, 29 Oct 2018 00:00:00 +0000
/entries/Epistemic_Logic.html
-
Smooth Manifolds
/entries/Smooth_Manifolds.html
Mon, 22 Oct 2018 00:00:00 +0000
/entries/Smooth_Manifolds.html
-
Formalization of the Embedding Path Order for Lambda-Free Higher-Order Terms
/entries/Lambda_Free_EPO.html
Fri, 19 Oct 2018 00:00:00 +0000
/entries/Lambda_Free_EPO.html
-
Randomised Binary Search Trees
/entries/Randomised_BSTs.html
Fri, 19 Oct 2018 00:00:00 +0000
/entries/Randomised_BSTs.html
-
Upper Bounding Diameters of State Spaces of Factored Transition Systems
/entries/Factored_Transition_System_Bounding.html
Fri, 12 Oct 2018 00:00:00 +0000
/entries/Factored_Transition_System_Bounding.html
-
The Transcendence of π
/entries/Pi_Transcendental.html
Fri, 28 Sep 2018 00:00:00 +0000
/entries/Pi_Transcendental.html
-
Symmetric Polynomials
/entries/Symmetric_Polynomials.html
Tue, 25 Sep 2018 00:00:00 +0000
/entries/Symmetric_Polynomials.html
-
Signature-Based Gröbner Basis Algorithms
/entries/Signature_Groebner.html
Thu, 20 Sep 2018 00:00:00 +0000
/entries/Signature_Groebner.html
-
The Prime Number Theorem
/entries/Prime_Number_Theorem.html
Wed, 19 Sep 2018 00:00:00 +0000
/entries/Prime_Number_Theorem.html
-
Aggregation Algebras
/entries/Aggregation_Algebras.html
Sat, 15 Sep 2018 00:00:00 +0000
/entries/Aggregation_Algebras.html
-
Octonions
/entries/Octonions.html
Fri, 14 Sep 2018 00:00:00 +0000
/entries/Octonions.html
-
Quaternions
/entries/Quaternions.html
Wed, 05 Sep 2018 00:00:00 +0000
/entries/Quaternions.html
-
The Budan–Fourier Theorem and Counting Real Roots with Multiplicity
/entries/Budan_Fourier.html
Sun, 02 Sep 2018 00:00:00 +0000
/entries/Budan_Fourier.html
-
An Incremental Simplex Algorithm with Unsatisfiable Core Generation
/entries/Simplex.html
Fri, 24 Aug 2018 00:00:00 +0000
/entries/Simplex.html
-
Minsky Machines
/entries/Minsky_Machines.html
Tue, 14 Aug 2018 00:00:00 +0000
/entries/Minsky_Machines.html
-
Pricing in discrete financial models
/entries/DiscretePricing.html
Mon, 16 Jul 2018 00:00:00 +0000
/entries/DiscretePricing.html
-
Von-Neumann-Morgenstern Utility Theorem
/entries/Neumann_Morgenstern_Utility.html
Wed, 04 Jul 2018 00:00:00 +0000
/entries/Neumann_Morgenstern_Utility.html
-
Pell's Equation
/entries/Pell.html
Sat, 23 Jun 2018 00:00:00 +0000
/entries/Pell.html
-
Projective Geometry
/entries/Projective_Geometry.html
Thu, 14 Jun 2018 00:00:00 +0000
/entries/Projective_Geometry.html
-
The Localization of a Commutative Ring
/entries/Localization_Ring.html
Thu, 14 Jun 2018 00:00:00 +0000
/entries/Localization_Ring.html
-
Partial Order Reduction
/entries/Partial_Order_Reduction.html
Tue, 05 Jun 2018 00:00:00 +0000
/entries/Partial_Order_Reduction.html
-
Optimal Binary Search Trees
/entries/Optimal_BST.html
Sun, 27 May 2018 00:00:00 +0000
/entries/Optimal_BST.html
-
Hidden Markov Models
/entries/Hidden_Markov_Models.html
Fri, 25 May 2018 00:00:00 +0000
/entries/Hidden_Markov_Models.html
-
Probabilistic Timed Automata
/entries/Probabilistic_Timed_Automata.html
Thu, 24 May 2018 00:00:00 +0000
/entries/Probabilistic_Timed_Automata.html
-
Axiom Systems for Category Theory in Free Logic
/entries/AxiomaticCategoryTheory.html
Wed, 23 May 2018 00:00:00 +0000
/entries/AxiomaticCategoryTheory.html
-
Irrational Rapidly Convergent Series
/entries/Irrationality_J_Hancl.html
Wed, 23 May 2018 00:00:00 +0000
/entries/Irrationality_J_Hancl.html
-
Monadification, Memoization and Dynamic Programming
/entries/Monad_Memo_DP.html
Tue, 22 May 2018 00:00:00 +0000
/entries/Monad_Memo_DP.html
-
OpSets: Sequential Specifications for Replicated Datatypes
/entries/OpSets.html
Thu, 10 May 2018 00:00:00 +0000
/entries/OpSets.html
-
An Isabelle/HOL Formalization of the Modular Assembly Kit for Security Properties
/entries/Modular_Assembly_Kit_Security.html
Mon, 07 May 2018 00:00:00 +0000
/entries/Modular_Assembly_Kit_Security.html
-
WebAssembly
/entries/WebAssembly.html
Sun, 29 Apr 2018 00:00:00 +0000
/entries/WebAssembly.html
-
VerifyThis 2018 - Polished Isabelle Solutions
/entries/VerifyThis2018.html
Fri, 27 Apr 2018 00:00:00 +0000
/entries/VerifyThis2018.html
-
Bounded Natural Functors with Covariance and Contravariance
/entries/BNF_CC.html
Tue, 24 Apr 2018 00:00:00 +0000
/entries/BNF_CC.html
-
The Incompatibility of Fishburn-Strategyproofness and Pareto-Efficiency
/entries/Fishburn_Impossibility.html
Thu, 22 Mar 2018 00:00:00 +0000
/entries/Fishburn_Impossibility.html
-
Weight-Balanced Trees
/entries/Weight_Balanced_Trees.html
Tue, 13 Mar 2018 00:00:00 +0000
/entries/Weight_Balanced_Trees.html
-
CakeML
/entries/CakeML.html
Mon, 12 Mar 2018 00:00:00 +0000
/entries/CakeML.html
-
A Theory of Architectural Design Patterns
/entries/Architectural_Design_Patterns.html
Thu, 01 Mar 2018 00:00:00 +0000
/entries/Architectural_Design_Patterns.html
-
Hoare Logics for Time Bounds
/entries/Hoare_Time.html
Mon, 26 Feb 2018 00:00:00 +0000
/entries/Hoare_Time.html
-
A verified factorization algorithm for integer polynomials with polynomial complexity
/entries/LLL_Factorization.html
Tue, 06 Feb 2018 00:00:00 +0000
/entries/LLL_Factorization.html
-
First-Order Terms
/entries/First_Order_Terms.html
Tue, 06 Feb 2018 00:00:00 +0000
/entries/First_Order_Terms.html
-
The Error Function
/entries/Error_Function.html
Tue, 06 Feb 2018 00:00:00 +0000
/entries/Error_Function.html
-
Treaps
/entries/Treaps.html
Tue, 06 Feb 2018 00:00:00 +0000
/entries/Treaps.html
-
A verified LLL algorithm
/entries/LLL_Basis_Reduction.html
Fri, 02 Feb 2018 00:00:00 +0000
/entries/LLL_Basis_Reduction.html
-
Formalization of Bachmair and Ganzinger's Ordered Resolution Prover
/entries/Ordered_Resolution_Prover.html
Thu, 18 Jan 2018 00:00:00 +0000
/entries/Ordered_Resolution_Prover.html
-
Gromov Hyperbolicity
/entries/Gromov_Hyperbolicity.html
Tue, 16 Jan 2018 00:00:00 +0000
/entries/Gromov_Hyperbolicity.html
-
An Isabelle/HOL formalisation of Green's Theorem
/entries/Green.html
Thu, 11 Jan 2018 00:00:00 +0000
/entries/Green.html
-
Taylor Models
/entries/Taylor_Models.html
Mon, 08 Jan 2018 00:00:00 +0000
/entries/Taylor_Models.html
-
The Falling Factorial of a Sum
/entries/Falling_Factorial_Sum.html
Fri, 22 Dec 2017 00:00:00 +0000
/entries/Falling_Factorial_Sum.html
-
Dirichlet L-Functions and Dirichlet's Theorem
/entries/Dirichlet_L.html
Thu, 21 Dec 2017 00:00:00 +0000
/entries/Dirichlet_L.html
-
The Mason–Stothers Theorem
/entries/Mason_Stothers.html
Thu, 21 Dec 2017 00:00:00 +0000
/entries/Mason_Stothers.html
-
The Median-of-Medians Selection Algorithm
/entries/Median_Of_Medians_Selection.html
Thu, 21 Dec 2017 00:00:00 +0000
/entries/Median_Of_Medians_Selection.html
-
Operations on Bounded Natural Functors
/entries/BNF_Operations.html
Tue, 19 Dec 2017 00:00:00 +0000
/entries/BNF_Operations.html
-
The string search algorithm by Knuth, Morris and Pratt
/entries/Knuth_Morris_Pratt.html
Mon, 18 Dec 2017 00:00:00 +0000
/entries/Knuth_Morris_Pratt.html
-
Stochastic Matrices and the Perron-Frobenius Theorem
/entries/Stochastic_Matrices.html
Wed, 22 Nov 2017 00:00:00 +0000
/entries/Stochastic_Matrices.html
-
The IMAP CmRDT
/entries/IMAP-CRDT.html
Thu, 09 Nov 2017 00:00:00 +0000
/entries/IMAP-CRDT.html
-
Hybrid Multi-Lane Spatial Logic
/entries/Hybrid_Multi_Lane_Spatial_Logic.html
Mon, 06 Nov 2017 00:00:00 +0000
/entries/Hybrid_Multi_Lane_Spatial_Logic.html
-
The Kuratowski Closure-Complement Theorem
/entries/Kuratowski_Closure_Complement.html
Thu, 26 Oct 2017 00:00:00 +0000
/entries/Kuratowski_Closure_Complement.html
-
Büchi Complementation
/entries/Buchi_Complementation.html
Thu, 19 Oct 2017 00:00:00 +0000
/entries/Buchi_Complementation.html
-
Transition Systems and Automata
/entries/Transition_Systems_and_Automata.html
Thu, 19 Oct 2017 00:00:00 +0000
/entries/Transition_Systems_and_Automata.html
-
Count the Number of Complex Roots
/entries/Count_Complex_Roots.html
Tue, 17 Oct 2017 00:00:00 +0000
/entries/Count_Complex_Roots.html
-
Evaluate Winding Numbers through Cauchy Indices
/entries/Winding_Number_Eval.html
Tue, 17 Oct 2017 00:00:00 +0000
/entries/Winding_Number_Eval.html
-
Homogeneous Linear Diophantine Equations
/entries/Diophantine_Eqns_Lin_Hom.html
Sat, 14 Oct 2017 00:00:00 +0000
/entries/Diophantine_Eqns_Lin_Hom.html
-
Dirichlet Series
/entries/Dirichlet_Series.html
Thu, 12 Oct 2017 00:00:00 +0000
/entries/Dirichlet_Series.html
-
Linear Recurrences
/entries/Linear_Recurrences.html
Thu, 12 Oct 2017 00:00:00 +0000
/entries/Linear_Recurrences.html
-
The Hurwitz and Riemann ζ Functions
/entries/Zeta_Function.html
Thu, 12 Oct 2017 00:00:00 +0000
/entries/Zeta_Function.html
-
Computer-assisted Reconstruction and Assessment of E. J. Lowe's Modal Ontological Argument
/entries/Lowe_Ontological_Argument.html
Thu, 21 Sep 2017 00:00:00 +0000
/entries/Lowe_Ontological_Argument.html
-
Representation and Partial Automation of the Principia Logico-Metaphysica in Isabelle/HOL
/entries/PLM.html
Sun, 17 Sep 2017 00:00:00 +0000
/entries/PLM.html
-
Anselm's God in Isabelle/HOL
/entries/AnselmGod.html
Wed, 06 Sep 2017 00:00:00 +0000
/entries/AnselmGod.html
-
Microeconomics and the First Welfare Theorem
/entries/First_Welfare_Theorem.html
Fri, 01 Sep 2017 00:00:00 +0000
/entries/First_Welfare_Theorem.html
-
Orbit-Stabiliser Theorem with Application to Rotational Symmetries
/entries/Orbit_Stabiliser.html
Sun, 20 Aug 2017 00:00:00 +0000
/entries/Orbit_Stabiliser.html
-
Root-Balanced Tree
/entries/Root_Balanced_Tree.html
Sun, 20 Aug 2017 00:00:00 +0000
/entries/Root_Balanced_Tree.html
-
The LambdaMu-calculus
/entries/LambdaMu.html
Wed, 16 Aug 2017 00:00:00 +0000
/entries/LambdaMu.html
-
Stewart's Theorem and Apollonius' Theorem
/entries/Stewart_Apollonius.html
Mon, 31 Jul 2017 00:00:00 +0000
/entries/Stewart_Apollonius.html
-
Dynamic Architectures
/entries/DynamicArchitectures.html
Fri, 28 Jul 2017 00:00:00 +0000
/entries/DynamicArchitectures.html
-
Declarative Semantics for Functional Languages
/entries/Decl_Sem_Fun_PL.html
Fri, 21 Jul 2017 00:00:00 +0000
/entries/Decl_Sem_Fun_PL.html
-
HOLCF-Prelude
/entries/HOLCF-Prelude.html
Sat, 15 Jul 2017 00:00:00 +0000
/entries/HOLCF-Prelude.html
-
Minkowski's Theorem
/entries/Minkowskis_Theorem.html
Thu, 13 Jul 2017 00:00:00 +0000
/entries/Minkowskis_Theorem.html
-
Verified Metatheory and Type Inference for a Name-Carrying Simply-Typed Lambda Calculus
/entries/Name_Carrying_Type_Inference.html
Sun, 09 Jul 2017 00:00:00 +0000
/entries/Name_Carrying_Type_Inference.html
-
A framework for establishing Strong Eventual Consistency for Conflict-free Replicated Datatypes
/entries/CRDT.html
Fri, 07 Jul 2017 00:00:00 +0000
/entries/CRDT.html
-
Stone-Kleene Relation Algebras
/entries/Stone_Kleene_Relation_Algebras.html
Thu, 06 Jul 2017 00:00:00 +0000
/entries/Stone_Kleene_Relation_Algebras.html
-
Propositional Proof Systems
/entries/Propositional_Proof_Systems.html
Wed, 21 Jun 2017 00:00:00 +0000
/entries/Propositional_Proof_Systems.html
-
Partial Semigroups and Convolution Algebras
/entries/PSemigroupsConvolution.html
Tue, 13 Jun 2017 00:00:00 +0000
/entries/PSemigroupsConvolution.html
-
Buffon's Needle Problem
/entries/Buffons_Needle.html
Tue, 06 Jun 2017 00:00:00 +0000
/entries/Buffons_Needle.html
-
Flow Networks and the Min-Cut-Max-Flow Theorem
/entries/Flow_Networks.html
Thu, 01 Jun 2017 00:00:00 +0000
/entries/Flow_Networks.html
-
Formalizing Push-Relabel Algorithms
/entries/Prpu_Maxflow.html
Thu, 01 Jun 2017 00:00:00 +0000
/entries/Prpu_Maxflow.html
-
Optics
/entries/Optics.html
Thu, 25 May 2017 00:00:00 +0000
/entries/Optics.html
-
Developing Security Protocols by Refinement
/entries/Security_Protocol_Refinement.html
Wed, 24 May 2017 00:00:00 +0000
/entries/Security_Protocol_Refinement.html
-
Dictionary Construction
/entries/Dict_Construction.html
Wed, 24 May 2017 00:00:00 +0000
/entries/Dict_Construction.html
-
The Floyd-Warshall Algorithm for Shortest Paths
/entries/Floyd_Warshall.html
Mon, 08 May 2017 00:00:00 +0000
/entries/Floyd_Warshall.html
-
CryptHOL
/entries/CryptHOL.html
Fri, 05 May 2017 00:00:00 +0000
/entries/CryptHOL.html
-
Effect polymorphism in higher-order logic
/entries/Monomorphic_Monad.html
Fri, 05 May 2017 00:00:00 +0000
/entries/Monomorphic_Monad.html
-
Game-based cryptography in HOL
/entries/Game_Based_Crypto.html
Fri, 05 May 2017 00:00:00 +0000
/entries/Game_Based_Crypto.html
-
Monad normalisation
/entries/Monad_Normalisation.html
Fri, 05 May 2017 00:00:00 +0000
/entries/Monad_Normalisation.html
-
Probabilistic while loop
/entries/Probabilistic_While.html
Fri, 05 May 2017 00:00:00 +0000
/entries/Probabilistic_While.html
-
Monoidal Categories
/entries/MonoidalCategory.html
Thu, 04 May 2017 00:00:00 +0000
/entries/MonoidalCategory.html
-
Types, Tableaus and Gödel’s God in Isabelle/HOL
/entries/Types_Tableaus_and_Goedels_God.html
Mon, 01 May 2017 00:00:00 +0000
/entries/Types_Tableaus_and_Goedels_God.html
-
Local Lexing
/entries/LocalLexing.html
Fri, 28 Apr 2017 00:00:00 +0000
/entries/LocalLexing.html
-
Constructor Functions
/entries/Constructor_Funs.html
Wed, 19 Apr 2017 00:00:00 +0000
/entries/Constructor_Funs.html
-
Lazifying case constants
/entries/Lazy_Case.html
Tue, 18 Apr 2017 00:00:00 +0000
/entries/Lazy_Case.html
-
Subresultants
/entries/Subresultants.html
Thu, 06 Apr 2017 00:00:00 +0000
/entries/Subresultants.html
-
Expected Shape of Random Binary Search Trees
/entries/Random_BSTs.html
Tue, 04 Apr 2017 00:00:00 +0000
/entries/Random_BSTs.html
-
Lower bound on comparison-based sorting algorithms
/entries/Comparison_Sort_Lower_Bound.html
Wed, 15 Mar 2017 00:00:00 +0000
/entries/Comparison_Sort_Lower_Bound.html
-
The number of comparisons in QuickSort
/entries/Quick_Sort_Cost.html
Wed, 15 Mar 2017 00:00:00 +0000
/entries/Quick_Sort_Cost.html
-
The Euler–MacLaurin Formula
/entries/Euler_MacLaurin.html
Fri, 10 Mar 2017 00:00:00 +0000
/entries/Euler_MacLaurin.html
-
The Group Law for Elliptic Curves
/entries/Elliptic_Curves_Group_Law.html
Tue, 28 Feb 2017 00:00:00 +0000
/entries/Elliptic_Curves_Group_Law.html
-
Menger's Theorem
/entries/Menger.html
Sun, 26 Feb 2017 00:00:00 +0000
/entries/Menger.html
-
Differential Dynamic Logic
/entries/Differential_Dynamic_Logic.html
Mon, 13 Feb 2017 00:00:00 +0000
/entries/Differential_Dynamic_Logic.html
-
Abstract Soundness
/entries/Abstract_Soundness.html
Fri, 10 Feb 2017 00:00:00 +0000
/entries/Abstract_Soundness.html
-
Stone Relation Algebras
/entries/Stone_Relation_Algebras.html
Tue, 07 Feb 2017 00:00:00 +0000
/entries/Stone_Relation_Algebras.html
-
Refining Authenticated Key Agreement with Strong Adversaries
/entries/Key_Agreement_Strong_Adversaries.html
Tue, 31 Jan 2017 00:00:00 +0000
/entries/Key_Agreement_Strong_Adversaries.html
-
Bernoulli Numbers
/entries/Bernoulli.html
Tue, 24 Jan 2017 00:00:00 +0000
/entries/Bernoulli.html
-
Bertrand's postulate
/entries/Bertrands_Postulate.html
Tue, 17 Jan 2017 00:00:00 +0000
/entries/Bertrands_Postulate.html
-
Minimal Static Single Assignment Form
/entries/Minimal_SSA.html
Tue, 17 Jan 2017 00:00:00 +0000
/entries/Minimal_SSA.html
-
The Transcendence of e
/entries/E_Transcendental.html
Thu, 12 Jan 2017 00:00:00 +0000
/entries/E_Transcendental.html
-
Formal Network Models and Their Application to Firewall Policies
/entries/UPF_Firewall.html
Sun, 08 Jan 2017 00:00:00 +0000
/entries/UPF_Firewall.html
-
Verification of a Diffie-Hellman Password-based Authentication Protocol by Extending the Inductive Method
/entries/Password_Authentication_Protocol.html
Tue, 03 Jan 2017 00:00:00 +0000
/entries/Password_Authentication_Protocol.html
-
First-Order Logic According to Harrison
/entries/FOL_Harrison.html
Sun, 01 Jan 2017 00:00:00 +0000
/entries/FOL_Harrison.html
-
Concurrent Refinement Algebra and Rely Quotients
/entries/Concurrent_Ref_Alg.html
Fri, 30 Dec 2016 00:00:00 +0000
/entries/Concurrent_Ref_Alg.html
-
The Twelvefold Way
/entries/Twelvefold_Way.html
Thu, 29 Dec 2016 00:00:00 +0000
/entries/Twelvefold_Way.html
-
Proof Strategy Language
/entries/Proof_Strategy_Language.html
Tue, 20 Dec 2016 00:00:00 +0000
/entries/Proof_Strategy_Language.html
-
Paraconsistency
/entries/Paraconsistency.html
Wed, 07 Dec 2016 00:00:00 +0000
/entries/Paraconsistency.html
-
COMPLX: A Verification Framework for Concurrent Imperative Programs
/entries/Complx.html
Tue, 29 Nov 2016 00:00:00 +0000
/entries/Complx.html
-
Abstract Interpretation of Annotated Commands
/entries/Abs_Int_ITP2012.html
Wed, 23 Nov 2016 00:00:00 +0000
/entries/Abs_Int_ITP2012.html
-
Separata: Isabelle tactics for Separation Algebra
/entries/Separata.html
Wed, 16 Nov 2016 00:00:00 +0000
/entries/Separata.html
-
Formalization of Knuth–Bendix Orders for Lambda-Free Higher-Order Terms
/entries/Lambda_Free_KBOs.html
Sat, 12 Nov 2016 00:00:00 +0000
/entries/Lambda_Free_KBOs.html
-
Formalization of Nested Multisets, Hereditary Multisets, and Syntactic Ordinals
/entries/Nested_Multisets_Ordinals.html
Sat, 12 Nov 2016 00:00:00 +0000
/entries/Nested_Multisets_Ordinals.html
-
Expressiveness of Deep Learning
/entries/Deep_Learning.html
Thu, 10 Nov 2016 00:00:00 +0000
/entries/Deep_Learning.html
-
Modal Logics for Nominal Transition Systems
/entries/Modal_Logics_for_NTS.html
Tue, 25 Oct 2016 00:00:00 +0000
/entries/Modal_Logics_for_NTS.html
-
Stable Matching
/entries/Stable_Matching.html
Mon, 24 Oct 2016 00:00:00 +0000
/entries/Stable_Matching.html
-
LOFT — Verified Migration of Linux Firewalls to SDN
/entries/LOFT.html
Fri, 21 Oct 2016 00:00:00 +0000
/entries/LOFT.html
-
A formal model for the SPARCv8 ISA and a proof of non-interference for the LEON3 processor
/entries/SPARCv8.html
Wed, 19 Oct 2016 00:00:00 +0000
/entries/SPARCv8.html
-
Source Coding Theorem
/entries/Source_Coding_Theorem.html
Wed, 19 Oct 2016 00:00:00 +0000
/entries/Source_Coding_Theorem.html
-
The Factorization Algorithm of Berlekamp and Zassenhaus
/entries/Berlekamp_Zassenhaus.html
Fri, 14 Oct 2016 00:00:00 +0000
/entries/Berlekamp_Zassenhaus.html
-
Intersecting Chords Theorem
/entries/Chord_Segments.html
Tue, 11 Oct 2016 00:00:00 +0000
/entries/Chord_Segments.html
-
Lp spaces
/entries/Lp.html
Wed, 05 Oct 2016 00:00:00 +0000
/entries/Lp.html
-
Fisher–Yates shuffle
/entries/Fisher_Yates.html
Fri, 30 Sep 2016 00:00:00 +0000
/entries/Fisher_Yates.html
-
Allen's Interval Calculus
/entries/Allen_Calculus.html
Thu, 29 Sep 2016 00:00:00 +0000
/entries/Allen_Calculus.html
-
Formalization of Recursive Path Orders for Lambda-Free Higher-Order Terms
/entries/Lambda_Free_RPOs.html
Fri, 23 Sep 2016 00:00:00 +0000
/entries/Lambda_Free_RPOs.html
-
Iptables Semantics
/entries/Iptables_Semantics.html
Fri, 09 Sep 2016 00:00:00 +0000
/entries/Iptables_Semantics.html
-
A Variant of the Superposition Calculus
/entries/SuperCalc.html
Tue, 06 Sep 2016 00:00:00 +0000
/entries/SuperCalc.html
-
Stone Algebras
/entries/Stone_Algebras.html
Tue, 06 Sep 2016 00:00:00 +0000
/entries/Stone_Algebras.html
-
Stirling's formula
/entries/Stirling_Formula.html
Thu, 01 Sep 2016 00:00:00 +0000
/entries/Stirling_Formula.html
-
Routing
/entries/Routing.html
Wed, 31 Aug 2016 00:00:00 +0000
/entries/Routing.html
-
Simple Firewall
/entries/Simple_Firewall.html
Wed, 24 Aug 2016 00:00:00 +0000
/entries/Simple_Firewall.html
-
Infeasible Paths Elimination by Symbolic Execution Techniques: Proof of Correctness and Preservation of Paths
/entries/InfPathElimination.html
Thu, 18 Aug 2016 00:00:00 +0000
/entries/InfPathElimination.html
-
Formalizing the Edmonds-Karp Algorithm
/entries/EdmondsKarp_Maxflow.html
Fri, 12 Aug 2016 00:00:00 +0000
/entries/EdmondsKarp_Maxflow.html
-
The Imperative Refinement Framework
/entries/Refine_Imperative_HOL.html
Mon, 08 Aug 2016 00:00:00 +0000
/entries/Refine_Imperative_HOL.html
-
Ptolemy's Theorem
/entries/Ptolemys_Theorem.html
Sun, 07 Aug 2016 00:00:00 +0000
/entries/Ptolemys_Theorem.html
-
Surprise Paradox
/entries/Surprise_Paradox.html
Sun, 17 Jul 2016 00:00:00 +0000
/entries/Surprise_Paradox.html
-
Pairing Heap
/entries/Pairing_Heap.html
Thu, 14 Jul 2016 00:00:00 +0000
/entries/Pairing_Heap.html
-
A Framework for Verifying Depth-First Search Algorithms
/entries/DFS_Framework.html
Tue, 05 Jul 2016 00:00:00 +0000
/entries/DFS_Framework.html
-
Chamber Complexes, Coxeter Systems, and Buildings
/entries/Buildings.html
Fri, 01 Jul 2016 00:00:00 +0000
/entries/Buildings.html
-
The Resolution Calculus for First-Order Logic
/entries/Resolution_FOL.html
Thu, 30 Jun 2016 00:00:00 +0000
/entries/Resolution_FOL.html
-
The Z Property
/entries/Rewriting_Z.html
Thu, 30 Jun 2016 00:00:00 +0000
/entries/Rewriting_Z.html
-
Compositional Security-Preserving Refinement for Concurrent Imperative Programs
/entries/Dependent_SIFUM_Refinement.html
Tue, 28 Jun 2016 00:00:00 +0000
/entries/Dependent_SIFUM_Refinement.html
-
IP Addresses
/entries/IP_Addresses.html
Tue, 28 Jun 2016 00:00:00 +0000
/entries/IP_Addresses.html
-
Cardinality of Multisets
/entries/Card_Multisets.html
Sun, 26 Jun 2016 00:00:00 +0000
/entries/Card_Multisets.html
-
Category Theory with Adjunctions and Limits
/entries/Category3.html
Sun, 26 Jun 2016 00:00:00 +0000
/entries/Category3.html
-
A Dependent Security Type System for Concurrent Imperative Programs
/entries/Dependent_SIFUM_Type_Systems.html
Sat, 25 Jun 2016 00:00:00 +0000
/entries/Dependent_SIFUM_Type_Systems.html
-
Catalan Numbers
/entries/Catalan_Numbers.html
Tue, 21 Jun 2016 00:00:00 +0000
/entries/Catalan_Numbers.html
-
Program Construction and Verification Components Based on Kleene Algebra
/entries/Algebraic_VCs.html
Sat, 18 Jun 2016 00:00:00 +0000
/entries/Algebraic_VCs.html
-
Conservation of CSP Noninterference Security under Concurrent Composition
/entries/Noninterference_Concurrent_Composition.html
Mon, 13 Jun 2016 00:00:00 +0000
/entries/Noninterference_Concurrent_Composition.html
-
Finite Machine Word Library
/entries/Word_Lib.html
Thu, 09 Jun 2016 00:00:00 +0000
/entries/Word_Lib.html
-
Tree Decomposition
/entries/Tree_Decomposition.html
Tue, 31 May 2016 00:00:00 +0000
/entries/Tree_Decomposition.html
-
Cardinality of Equivalence Relations
/entries/Card_Equiv_Relations.html
Tue, 24 May 2016 00:00:00 +0000
/entries/Card_Equiv_Relations.html
-
POSIX Lexing with Derivatives of Regular Expressions
/entries/Posix-Lexing.html
Tue, 24 May 2016 00:00:00 +0000
/entries/Posix-Lexing.html
-
Perron-Frobenius Theorem for Spectral Radius Analysis
/entries/Perron_Frobenius.html
Fri, 20 May 2016 00:00:00 +0000
/entries/Perron_Frobenius.html
-
The meta theory of the Incredible Proof Machine
/entries/Incredible_Proof_Machine.html
Fri, 20 May 2016 00:00:00 +0000
/entries/Incredible_Proof_Machine.html
-
A Constructive Proof for FLP
/entries/FLP.html
Wed, 18 May 2016 00:00:00 +0000
/entries/FLP.html
-
A Formal Proof of the Max-Flow Min-Cut Theorem for Countable Networks
/entries/MFMC_Countable.html
Mon, 09 May 2016 00:00:00 +0000
/entries/MFMC_Countable.html
-
Randomised Social Choice Theory
/entries/Randomised_Social_Choice.html
Thu, 05 May 2016 00:00:00 +0000
/entries/Randomised_Social_Choice.html
-
Spivey's Generalized Recurrence for Bell Numbers
/entries/Bell_Numbers_Spivey.html
Wed, 04 May 2016 00:00:00 +0000
/entries/Bell_Numbers_Spivey.html
-
The Incompatibility of SD-Efficiency and SD-Strategy-Proofness
/entries/SDS_Impossibility.html
Wed, 04 May 2016 00:00:00 +0000
/entries/SDS_Impossibility.html
-
Gröbner Bases Theory
/entries/Groebner_Bases.html
Mon, 02 May 2016 00:00:00 +0000
/entries/Groebner_Bases.html
-
No Faster-Than-Light Observers
/entries/No_FTL_observers.html
Thu, 28 Apr 2016 00:00:00 +0000
/entries/No_FTL_observers.html
-
A formalisation of the Cocke-Younger-Kasami algorithm
/entries/CYK.html
Wed, 27 Apr 2016 00:00:00 +0000
/entries/CYK.html
-
Algorithms for Reduced Ordered Binary Decision Diagrams
/entries/ROBDD.html
Wed, 27 Apr 2016 00:00:00 +0000
/entries/ROBDD.html
-
Conservation of CSP Noninterference Security under Sequential Composition
/entries/Noninterference_Sequential_Composition.html
Tue, 26 Apr 2016 00:00:00 +0000
/entries/Noninterference_Sequential_Composition.html
-
Kleene Algebras with Domain
/entries/KAD.html
Tue, 12 Apr 2016 00:00:00 +0000
/entries/KAD.html
-
Propositional Resolution and Prime Implicates Generation
/entries/PropResPI.html
Fri, 11 Mar 2016 00:00:00 +0000
/entries/PropResPI.html
-
The Cartan Fixed Point Theorems
/entries/Cartan_FP.html
Tue, 08 Mar 2016 00:00:00 +0000
/entries/Cartan_FP.html
-
Timed Automata
/entries/Timed_Automata.html
Tue, 08 Mar 2016 00:00:00 +0000
/entries/Timed_Automata.html
-
Linear Temporal Logic
/entries/LTL.html
Tue, 01 Mar 2016 00:00:00 +0000
/entries/LTL.html
-
Analysis of List Update Algorithms
/entries/List_Update.html
Wed, 17 Feb 2016 00:00:00 +0000
/entries/List_Update.html
-
Verified Construction of Static Single Assignment Form
/entries/Formal_SSA.html
Fri, 05 Feb 2016 00:00:00 +0000
/entries/Formal_SSA.html
-
Polynomial Factorization
/entries/Polynomial_Factorization.html
Fri, 29 Jan 2016 00:00:00 +0000
/entries/Polynomial_Factorization.html
-
Polynomial Interpolation
/entries/Polynomial_Interpolation.html
Fri, 29 Jan 2016 00:00:00 +0000
/entries/Polynomial_Interpolation.html
-
Knot Theory
/entries/Knot_Theory.html
Wed, 20 Jan 2016 00:00:00 +0000
/entries/Knot_Theory.html
-
Tensor Product of Matrices
/entries/Matrix_Tensor.html
Mon, 18 Jan 2016 00:00:00 +0000
/entries/Matrix_Tensor.html
-
Cardinality of Number Partitions
/entries/Card_Number_Partitions.html
Thu, 14 Jan 2016 00:00:00 +0000
/entries/Card_Number_Partitions.html
-
Basic Geometric Properties of Triangles
/entries/Triangle.html
Mon, 28 Dec 2015 00:00:00 +0000
/entries/Triangle.html
-
Descartes' Rule of Signs
/entries/Descartes_Sign_Rule.html
Mon, 28 Dec 2015 00:00:00 +0000
/entries/Descartes_Sign_Rule.html
-
Liouville numbers
/entries/Liouville_Numbers.html
Mon, 28 Dec 2015 00:00:00 +0000
/entries/Liouville_Numbers.html
-
The Divergence of the Prime Harmonic Series
/entries/Prime_Harmonic_Series.html
Mon, 28 Dec 2015 00:00:00 +0000
/entries/Prime_Harmonic_Series.html
-
Algebraic Numbers in Isabelle/HOL
/entries/Algebraic_Numbers.html
Tue, 22 Dec 2015 00:00:00 +0000
/entries/Algebraic_Numbers.html
-
Applicative Lifting
/entries/Applicative_Lifting.html
Tue, 22 Dec 2015 00:00:00 +0000
/entries/Applicative_Lifting.html
-
The Stern-Brocot Tree
/entries/Stern_Brocot.html
Tue, 22 Dec 2015 00:00:00 +0000
/entries/Stern_Brocot.html
-
Cardinality of Set Partitions
/entries/Card_Partitions.html
Sat, 12 Dec 2015 00:00:00 +0000
/entries/Card_Partitions.html
-
Latin Square
/entries/Latin_Square.html
Wed, 02 Dec 2015 00:00:00 +0000
/entries/Latin_Square.html
-
Ergodic Theory
/entries/Ergodic_Theory.html
Tue, 01 Dec 2015 00:00:00 +0000
/entries/Ergodic_Theory.html
-
Euler's Partition Theorem
/entries/Euler_Partition.html
Thu, 19 Nov 2015 00:00:00 +0000
/entries/Euler_Partition.html
-
The Tortoise and Hare Algorithm
/entries/TortoiseHare.html
Wed, 18 Nov 2015 00:00:00 +0000
/entries/TortoiseHare.html
-
Planarity Certificates
/entries/Planarity_Certificates.html
Wed, 11 Nov 2015 00:00:00 +0000
/entries/Planarity_Certificates.html
-
Positional Determinacy of Parity Games
/entries/Parity_Game.html
Mon, 02 Nov 2015 00:00:00 +0000
/entries/Parity_Game.html
-
A Meta-Model for the Isabelle API
/entries/Isabelle_Meta_Model.html
Wed, 16 Sep 2015 00:00:00 +0000
/entries/Isabelle_Meta_Model.html
-
Converting Linear Temporal Logic to Deterministic (Generalized) Rabin Automata
/entries/LTL_to_DRA.html
Fri, 04 Sep 2015 00:00:00 +0000
/entries/LTL_to_DRA.html
-
Matrices, Jordan Normal Forms, and Spectral Radius Theory
/entries/Jordan_Normal_Form.html
Fri, 21 Aug 2015 00:00:00 +0000
/entries/Jordan_Normal_Form.html
-
Decreasing Diagrams II
/entries/Decreasing-Diagrams-II.html
Thu, 20 Aug 2015 00:00:00 +0000
/entries/Decreasing-Diagrams-II.html
-
The Inductive Unwinding Theorem for CSP Noninterference Security
/entries/Noninterference_Inductive_Unwinding.html
Tue, 18 Aug 2015 00:00:00 +0000
/entries/Noninterference_Inductive_Unwinding.html
-
Representations of Finite Groups
/entries/Rep_Fin_Groups.html
Wed, 12 Aug 2015 00:00:00 +0000
/entries/Rep_Fin_Groups.html
-
Analysing and Comparing Encodability Criteria for Process Calculi
/entries/Encodability_Process_Calculi.html
Mon, 10 Aug 2015 00:00:00 +0000
/entries/Encodability_Process_Calculi.html
-
Generating Cases from Labeled Subgoals
/entries/Case_Labeling.html
Tue, 21 Jul 2015 00:00:00 +0000
/entries/Case_Labeling.html
-
Landau Symbols
/entries/Landau_Symbols.html
Tue, 14 Jul 2015 00:00:00 +0000
/entries/Landau_Symbols.html
-
The Akra-Bazzi theorem and the Master theorem
/entries/Akra_Bazzi.html
Tue, 14 Jul 2015 00:00:00 +0000
/entries/Akra_Bazzi.html
-
Hermite Normal Form
/entries/Hermite.html
Tue, 07 Jul 2015 00:00:00 +0000
/entries/Hermite.html
-
Derangements Formula
/entries/Derangements.html
Sat, 27 Jun 2015 00:00:00 +0000
/entries/Derangements.html
-
Binary Multirelations
/entries/Multirelations.html
Thu, 11 Jun 2015 00:00:00 +0000
/entries/Multirelations.html
-
Reasoning about Lists via List Interleaving
/entries/List_Interleaving.html
Thu, 11 Jun 2015 00:00:00 +0000
/entries/List_Interleaving.html
-
The Generic Unwinding Theorem for CSP Noninterference Security
/entries/Noninterference_Generic_Unwinding.html
Thu, 11 Jun 2015 00:00:00 +0000
/entries/Noninterference_Generic_Unwinding.html
-
The Ipurge Unwinding Theorem for CSP Noninterference Security
/entries/Noninterference_Ipurge_Unwinding.html
Thu, 11 Jun 2015 00:00:00 +0000
/entries/Noninterference_Ipurge_Unwinding.html
-
Parameterized Dynamic Tables
/entries/Dynamic_Tables.html
Sun, 07 Jun 2015 00:00:00 +0000
/entries/Dynamic_Tables.html
-
Derivatives of Logical Formulas
/entries/Formula_Derivatives.html
Thu, 28 May 2015 00:00:00 +0000
/entries/Formula_Derivatives.html
-
A Zoo of Probabilistic Systems
/entries/Probabilistic_System_Zoo.html
Wed, 27 May 2015 00:00:00 +0000
/entries/Probabilistic_System_Zoo.html
-
VCG - Combinatorial Vickrey-Clarke-Groves Auctions
/entries/Vickrey_Clarke_Groves.html
Thu, 30 Apr 2015 00:00:00 +0000
/entries/Vickrey_Clarke_Groves.html
-
Residuated Lattices
/entries/Residuated_Lattices.html
Wed, 15 Apr 2015 00:00:00 +0000
/entries/Residuated_Lattices.html
-
Concurrent IMP
/entries/ConcurrentIMP.html
Mon, 13 Apr 2015 00:00:00 +0000
/entries/ConcurrentIMP.html
-
Relaxing Safely: Verified On-the-Fly Garbage Collection for x86-TSO
/entries/ConcurrentGC.html
Mon, 13 Apr 2015 00:00:00 +0000
/entries/ConcurrentGC.html
-
Trie
/entries/Trie.html
Mon, 30 Mar 2015 00:00:00 +0000
/entries/Trie.html
-
Consensus Refined
/entries/Consensus_Refined.html
Wed, 18 Mar 2015 00:00:00 +0000
/entries/Consensus_Refined.html
-
Deriving class instances for datatypes
/entries/Deriving.html
Wed, 11 Mar 2015 00:00:00 +0000
/entries/Deriving.html
-
The Safety of Call Arity
/entries/Call_Arity.html
Fri, 20 Feb 2015 00:00:00 +0000
/entries/Call_Arity.html
-
Echelon Form
/entries/Echelon_Form.html
Thu, 12 Feb 2015 00:00:00 +0000
/entries/Echelon_Form.html
-
QR Decomposition
/entries/QR_Decomposition.html
Thu, 12 Feb 2015 00:00:00 +0000
/entries/QR_Decomposition.html
-
Finite Automata in Hereditarily Finite Set Theory
/entries/Finite_Automata_HF.html
Thu, 05 Feb 2015 00:00:00 +0000
/entries/Finite_Automata_HF.html
-
Verification of the UpDown Scheme
/entries/UpDown_Scheme.html
Wed, 28 Jan 2015 00:00:00 +0000
/entries/UpDown_Scheme.html
-
The Unified Policy Framework (UPF)
/entries/UPF.html
Fri, 28 Nov 2014 00:00:00 +0000
/entries/UPF.html
-
Loop freedom of the (untimed) AODV routing protocol
/entries/AODV.html
Thu, 23 Oct 2014 00:00:00 +0000
/entries/AODV.html
-
Lifting Definition Option
/entries/Lifting_Definition_Option.html
Mon, 13 Oct 2014 00:00:00 +0000
/entries/Lifting_Definition_Option.html
-
Stream Fusion in HOL with Code Generation
/entries/Stream_Fusion_Code.html
Fri, 10 Oct 2014 00:00:00 +0000
/entries/Stream_Fusion_Code.html
-
A Verified Compiler for Probability Density Functions
/entries/Density_Compiler.html
Thu, 09 Oct 2014 00:00:00 +0000
/entries/Density_Compiler.html
-
Formalization of Refinement Calculus for Reactive Systems
/entries/RefinementReactive.html
Wed, 08 Oct 2014 00:00:00 +0000
/entries/RefinementReactive.html
-
Certification Monads
/entries/Certification_Monads.html
Fri, 03 Oct 2014 00:00:00 +0000
/entries/Certification_Monads.html
-
XML
/entries/XML.html
Fri, 03 Oct 2014 00:00:00 +0000
/entries/XML.html
-
Imperative Insertion Sort
/entries/Imperative_Insertion_Sort.html
Thu, 25 Sep 2014 00:00:00 +0000
/entries/Imperative_Insertion_Sort.html
-
The Sturm–Tarski Theorem
/entries/Sturm_Tarski.html
Fri, 19 Sep 2014 00:00:00 +0000
/entries/Sturm_Tarski.html
-
The Cayley-Hamilton Theorem
/entries/Cayley_Hamilton.html
Mon, 15 Sep 2014 00:00:00 +0000
/entries/Cayley_Hamilton.html
-
The Jordan-Hölder Theorem
/entries/Jordan_Hoelder.html
Tue, 09 Sep 2014 00:00:00 +0000
/entries/Jordan_Hoelder.html
-
Priority Queues Based on Braun Trees
/entries/Priority_Queue_Braun.html
Thu, 04 Sep 2014 00:00:00 +0000
/entries/Priority_Queue_Braun.html
-
Gauss-Jordan Algorithm and Its Applications
/entries/Gauss_Jordan.html
Wed, 03 Sep 2014 00:00:00 +0000
/entries/Gauss_Jordan.html
-
Real-Valued Special Functions: Upper and Lower Bounds
/entries/Special_Function_Bounds.html
Fri, 29 Aug 2014 00:00:00 +0000
/entries/Special_Function_Bounds.html
-
Vector Spaces
/entries/VectorSpace.html
Fri, 29 Aug 2014 00:00:00 +0000
/entries/VectorSpace.html
-
Skew Heap
/entries/Skew_Heap.html
Wed, 13 Aug 2014 00:00:00 +0000
/entries/Skew_Heap.html
-
Splay Tree
/entries/Splay_Tree.html
Tue, 12 Aug 2014 00:00:00 +0000
/entries/Splay_Tree.html
-
Haskell's Show Class in Isabelle/HOL
/entries/Show.html
Tue, 29 Jul 2014 00:00:00 +0000
/entries/Show.html
-
Formal Specification of a Generic Separation Kernel
/entries/CISC-Kernel.html
Fri, 18 Jul 2014 00:00:00 +0000
/entries/CISC-Kernel.html
-
pGCL for Isabelle
/entries/pGCL.html
Sun, 13 Jul 2014 00:00:00 +0000
/entries/pGCL.html
-
Amortized Complexity Verified
/entries/Amortized_Complexity.html
Mon, 07 Jul 2014 00:00:00 +0000
/entries/Amortized_Complexity.html
-
Network Security Policy Verification
/entries/Network_Security_Policy_Verification.html
Fri, 04 Jul 2014 00:00:00 +0000
/entries/Network_Security_Policy_Verification.html
-
Pop-Refinement
/entries/Pop_Refinement.html
Thu, 03 Jul 2014 00:00:00 +0000
/entries/Pop_Refinement.html
-
Decision Procedures for MSO on Words Based on Derivatives of Regular Expressions
/entries/MSO_Regex_Equivalence.html
Thu, 12 Jun 2014 00:00:00 +0000
/entries/MSO_Regex_Equivalence.html
-
Boolean Expression Checkers
/entries/Boolean_Expression_Checkers.html
Sun, 08 Jun 2014 00:00:00 +0000
/entries/Boolean_Expression_Checkers.html
-
A Fully Verified Executable LTL Model Checker
/entries/CAVA_LTL_Modelchecker.html
Wed, 28 May 2014 00:00:00 +0000
/entries/CAVA_LTL_Modelchecker.html
-
Converting Linear-Time Temporal Logic to Generalized Büchi Automata
/entries/LTL_to_GBA.html
Wed, 28 May 2014 00:00:00 +0000
/entries/LTL_to_GBA.html
-
Promela Formalization
/entries/Promela.html
Wed, 28 May 2014 00:00:00 +0000
/entries/Promela.html
-
The CAVA Automata Library
/entries/CAVA_Automata.html
Wed, 28 May 2014 00:00:00 +0000
/entries/CAVA_Automata.html
-
Verified Efficient Implementation of Gabow's Strongly Connected Components Algorithm
/entries/Gabow_SCC.html
Wed, 28 May 2014 00:00:00 +0000
/entries/Gabow_SCC.html
-
Noninterference Security in Communicating Sequential Processes
/entries/Noninterference_CSP.html
Fri, 23 May 2014 00:00:00 +0000
/entries/Noninterference_CSP.html
-
Transitive closure according to Roy-Floyd-Warshall
/entries/Roy_Floyd_Warshall.html
Fri, 23 May 2014 00:00:00 +0000
/entries/Roy_Floyd_Warshall.html
-
Regular Algebras
/entries/Regular_Algebras.html
Wed, 21 May 2014 00:00:00 +0000
/entries/Regular_Algebras.html
-
Formalisation and Analysis of Component Dependencies
/entries/ComponentDependencies.html
Mon, 28 Apr 2014 00:00:00 +0000
/entries/ComponentDependencies.html
-
A Formalization of Assumptions and Guarantees for Compositional Noninterference
/entries/SIFUM_Type_Systems.html
Wed, 23 Apr 2014 00:00:00 +0000
/entries/SIFUM_Type_Systems.html
-
A Formalization of Declassification with WHAT-and-WHERE-Security
/entries/WHATandWHERE_Security.html
Wed, 23 Apr 2014 00:00:00 +0000
/entries/WHATandWHERE_Security.html
-
A Formalization of Strong Security
/entries/Strong_Security.html
Wed, 23 Apr 2014 00:00:00 +0000
/entries/Strong_Security.html
-
Bounded-Deducibility Security
/entries/Bounded_Deducibility_Security.html
Tue, 22 Apr 2014 00:00:00 +0000
/entries/Bounded_Deducibility_Security.html
-
A shallow embedding of HyperCTL*
/entries/HyperCTL.html
Wed, 16 Apr 2014 00:00:00 +0000
/entries/HyperCTL.html
-
Abstract Completeness
/entries/Abstract_Completeness.html
Wed, 16 Apr 2014 00:00:00 +0000
/entries/Abstract_Completeness.html
-
Discrete Summation
/entries/Discrete_Summation.html
Sun, 13 Apr 2014 00:00:00 +0000
/entries/Discrete_Summation.html
-
Syntax and semantics of a GPU kernel programming language
/entries/GPU_Kernel_PL.html
Thu, 03 Apr 2014 00:00:00 +0000
/entries/GPU_Kernel_PL.html
-
Probabilistic Noninterference
/entries/Probabilistic_Noninterference.html
Tue, 11 Mar 2014 00:00:00 +0000
/entries/Probabilistic_Noninterference.html
-
Mechanization of the Algebra for Wireless Networks (AWN)
/entries/AWN.html
Sat, 08 Mar 2014 00:00:00 +0000
/entries/AWN.html
-
Mutually Recursive Partial Functions
/entries/Partial_Function_MR.html
Tue, 18 Feb 2014 00:00:00 +0000
/entries/Partial_Function_MR.html
-
Properties of Random Graphs -- Subgraph Containment
/entries/Random_Graph_Subgraph_Threshold.html
Thu, 13 Feb 2014 00:00:00 +0000
/entries/Random_Graph_Subgraph_Threshold.html
-
Verification of Selection and Heap Sort Using Locales
/entries/Selection_Heap_Sort.html
Tue, 11 Feb 2014 00:00:00 +0000
/entries/Selection_Heap_Sort.html
-
Affine Arithmetic
/entries/Affine_Arithmetic.html
Fri, 07 Feb 2014 00:00:00 +0000
/entries/Affine_Arithmetic.html
-
Implementing field extensions of the form Q[sqrt(b)]
/entries/Real_Impl.html
Thu, 06 Feb 2014 00:00:00 +0000
/entries/Real_Impl.html
-
Unified Decision Procedures for Regular Expression Equivalence
/entries/Regex_Equivalence.html
Thu, 30 Jan 2014 00:00:00 +0000
/entries/Regex_Equivalence.html
-
Secondary Sylow Theorems
/entries/Secondary_Sylow.html
Tue, 28 Jan 2014 00:00:00 +0000
/entries/Secondary_Sylow.html
-
Relation Algebra
/entries/Relation_Algebra.html
Sat, 25 Jan 2014 00:00:00 +0000
/entries/Relation_Algebra.html
-
Kleene Algebra with Tests and Demonic Refinement Algebras
/entries/KAT_and_DRA.html
Thu, 23 Jan 2014 00:00:00 +0000
/entries/KAT_and_DRA.html
-
Featherweight OCL: A Proposal for a Machine-Checked Formal Semantics for OCL 2.5
/entries/Featherweight_OCL.html
Thu, 16 Jan 2014 00:00:00 +0000
/entries/Featherweight_OCL.html
-
Compositional Properties of Crypto-Based Components
/entries/CryptoBasedCompositionalProperties.html
Sat, 11 Jan 2014 00:00:00 +0000
/entries/CryptoBasedCompositionalProperties.html
-
Sturm's Theorem
/entries/Sturm_Sequences.html
Sat, 11 Jan 2014 00:00:00 +0000
/entries/Sturm_Sequences.html
-
A General Method for the Proof of Theorems on Tail-recursive Functions
/entries/Tail_Recursive_Functions.html
Sun, 01 Dec 2013 00:00:00 +0000
/entries/Tail_Recursive_Functions.html
-
Gödel's Incompleteness Theorems
/entries/Incompleteness.html
Sun, 17 Nov 2013 00:00:00 +0000
/entries/Incompleteness.html
-
The Hereditarily Finite Sets
/entries/HereditarilyFinite.html
Sun, 17 Nov 2013 00:00:00 +0000
/entries/HereditarilyFinite.html
-
A Codatatype of Formal Languages
/entries/Coinductive_Languages.html
Fri, 15 Nov 2013 00:00:00 +0000
/entries/Coinductive_Languages.html
-
Stream Processing Components: Isabelle/HOL Formalisation and Case Studies
/entries/FocusStreamsCaseStudies.html
Thu, 14 Nov 2013 00:00:00 +0000
/entries/FocusStreamsCaseStudies.html
-
Gödel's God in Isabelle/HOL
/entries/GoedelGod.html
Tue, 12 Nov 2013 00:00:00 +0000
/entries/GoedelGod.html
-
Decreasing Diagrams
/entries/Decreasing-Diagrams.html
Fri, 01 Nov 2013 00:00:00 +0000
/entries/Decreasing-Diagrams.html
-
Automatic Data Refinement
/entries/Automatic_Refinement.html
Wed, 02 Oct 2013 00:00:00 +0000
/entries/Automatic_Refinement.html
-
Native Word
/entries/Native_Word.html
Tue, 17 Sep 2013 00:00:00 +0000
/entries/Native_Word.html
-
A Formal Model of IEEE Floating Point Arithmetic
/entries/IEEE_Floating_Point.html
Sat, 27 Jul 2013 00:00:00 +0000
/entries/IEEE_Floating_Point.html
-
Lehmer's Theorem
/entries/Lehmer.html
Mon, 22 Jul 2013 00:00:00 +0000
/entries/Lehmer.html
-
Pratt's Primality Certificates
/entries/Pratt_Certificate.html
Mon, 22 Jul 2013 00:00:00 +0000
/entries/Pratt_Certificate.html
-
The Königsberg Bridge Problem and the Friendship Theorem
/entries/Koenigsberg_Friendship.html
Fri, 19 Jul 2013 00:00:00 +0000
/entries/Koenigsberg_Friendship.html
-
Sound and Complete Sort Encodings for First-Order Logic
/entries/Sort_Encodings.html
Thu, 27 Jun 2013 00:00:00 +0000
/entries/Sort_Encodings.html
-
An Axiomatic Characterization of the Single-Source Shortest Path Problem
/entries/ShortestPath.html
Wed, 22 May 2013 00:00:00 +0000
/entries/ShortestPath.html
-
Graph Theory
/entries/Graph_Theory.html
Sun, 28 Apr 2013 00:00:00 +0000
/entries/Graph_Theory.html
-
Light-weight Containers
/entries/Containers.html
Mon, 15 Apr 2013 00:00:00 +0000
/entries/Containers.html
-
Nominal 2
/entries/Nominal2.html
Thu, 21 Feb 2013 00:00:00 +0000
/entries/Nominal2.html
-
The Correctness of Launchbury's Natural Semantics for Lazy Evaluation
/entries/Launchbury.html
Thu, 31 Jan 2013 00:00:00 +0000
/entries/Launchbury.html
-
Ribbon Proofs
/entries/Ribbon_Proofs.html
Sat, 19 Jan 2013 00:00:00 +0000
/entries/Ribbon_Proofs.html
-
Rank-Nullity Theorem in Linear Algebra
/entries/Rank_Nullity_Theorem.html
Wed, 16 Jan 2013 00:00:00 +0000
/entries/Rank_Nullity_Theorem.html
-
Kleene Algebra
/entries/Kleene_Algebra.html
Tue, 15 Jan 2013 00:00:00 +0000
/entries/Kleene_Algebra.html
-
Computing N-th Roots using the Babylonian Method
/entries/Sqrt_Babylonian.html
Thu, 03 Jan 2013 00:00:00 +0000
/entries/Sqrt_Babylonian.html
-
A Separation Logic Framework for Imperative HOL
/entries/Separation_Logic_Imperative_HOL.html
Wed, 14 Nov 2012 00:00:00 +0000
/entries/Separation_Logic_Imperative_HOL.html
-
Open Induction
/entries/Open_Induction.html
Fri, 02 Nov 2012 00:00:00 +0000
/entries/Open_Induction.html
-
The independence of Tarski's Euclidean axiom
/entries/Tarskis_Geometry.html
Tue, 30 Oct 2012 00:00:00 +0000
/entries/Tarskis_Geometry.html
-
Bondy's Theorem
/entries/Bondy.html
Sat, 27 Oct 2012 00:00:00 +0000
/entries/Bondy.html
-
Possibilistic Noninterference
/entries/Possibilistic_Noninterference.html
Mon, 10 Sep 2012 00:00:00 +0000
/entries/Possibilistic_Noninterference.html
-
Generating linear orders for datatypes
/entries/Datatype_Order_Generator.html
Tue, 07 Aug 2012 00:00:00 +0000
/entries/Datatype_Order_Generator.html
-
Proving the Impossibility of Trisecting an Angle and Doubling the Cube
/entries/Impossible_Geometry.html
Sun, 05 Aug 2012 00:00:00 +0000
/entries/Impossible_Geometry.html
-
Verifying Fault-Tolerant Distributed Algorithms in the Heard-Of Model
/entries/Heard_Of.html
Fri, 27 Jul 2012 00:00:00 +0000
/entries/Heard_Of.html
-
Logical Relations for PCF
/entries/PCF.html
Sun, 01 Jul 2012 00:00:00 +0000
/entries/PCF.html
-
Type Constructor Classes and Monad Transformers
/entries/Tycon.html
Tue, 26 Jun 2012 00:00:00 +0000
/entries/Tycon.html
-
CCS in nominal logic
/entries/CCS.html
Tue, 29 May 2012 00:00:00 +0000
/entries/CCS.html
-
Psi-calculi in Isabelle
/entries/Psi_Calculi.html
Tue, 29 May 2012 00:00:00 +0000
/entries/Psi_Calculi.html
-
The pi-calculus in nominal logic
/entries/Pi_Calculus.html
Tue, 29 May 2012 00:00:00 +0000
/entries/Pi_Calculus.html
-
Isabelle/Circus
/entries/Circus.html
Sun, 27 May 2012 00:00:00 +0000
/entries/Circus.html
-
Separation Algebra
/entries/Separation_Algebra.html
Fri, 11 May 2012 00:00:00 +0000
/entries/Separation_Algebra.html
-
Stuttering Equivalence
/entries/Stuttering_Equivalence.html
Mon, 07 May 2012 00:00:00 +0000
/entries/Stuttering_Equivalence.html
-
Inductive Study of Confidentiality
/entries/Inductive_Confidentiality.html
Wed, 02 May 2012 00:00:00 +0000
/entries/Inductive_Confidentiality.html
-
Ordinary Differential Equations
/entries/Ordinary_Differential_Equations.html
Thu, 26 Apr 2012 00:00:00 +0000
/entries/Ordinary_Differential_Equations.html
-
Well-Quasi-Orders
/entries/Well_Quasi_Orders.html
Fri, 13 Apr 2012 00:00:00 +0000
/entries/Well_Quasi_Orders.html
-
Abortable Linearizable Modules
/entries/Abortable_Linearizable_Modules.html
Thu, 01 Mar 2012 00:00:00 +0000
/entries/Abortable_Linearizable_Modules.html
-
Executable Transitive Closures
/entries/Transitive-Closure-II.html
Wed, 29 Feb 2012 00:00:00 +0000
/entries/Transitive-Closure-II.html
-
A Probabilistic Proof of the Girth-Chromatic Number Theorem
/entries/Girth_Chromatic.html
Mon, 06 Feb 2012 00:00:00 +0000
/entries/Girth_Chromatic.html
-
Dijkstra's Shortest Path Algorithm
/entries/Dijkstra_Shortest_Path.html
Mon, 30 Jan 2012 00:00:00 +0000
/entries/Dijkstra_Shortest_Path.html
-
Refinement for Monadic Programs
/entries/Refine_Monadic.html
Mon, 30 Jan 2012 00:00:00 +0000
/entries/Refine_Monadic.html
-
Markov Models
/entries/Markov_Models.html
Tue, 03 Jan 2012 00:00:00 +0000
/entries/Markov_Models.html
-
A Definitional Encoding of TLA* in Isabelle/HOL
/entries/TLA.html
Sat, 19 Nov 2011 00:00:00 +0000
/entries/TLA.html
-
Efficient Mergesort
/entries/Efficient-Mergesort.html
Wed, 09 Nov 2011 00:00:00 +0000
/entries/Efficient-Mergesort.html
-
Algebra of Monotonic Boolean Transformers
/entries/MonoBoolTranAlgebra.html
Thu, 22 Sep 2011 00:00:00 +0000
/entries/MonoBoolTranAlgebra.html
-
Lattice Properties
/entries/LatticeProperties.html
Thu, 22 Sep 2011 00:00:00 +0000
/entries/LatticeProperties.html
-
Pseudo Hoops
/entries/PseudoHoops.html
Thu, 22 Sep 2011 00:00:00 +0000
/entries/PseudoHoops.html
-
The Myhill-Nerode Theorem Based on Regular Expressions
/entries/Myhill-Nerode.html
Fri, 26 Aug 2011 00:00:00 +0000
/entries/Myhill-Nerode.html
-
Gauss-Jordan Elimination for Matrices Represented as Functions
/entries/Gauss-Jordan-Elim-Fun.html
Fri, 19 Aug 2011 00:00:00 +0000
/entries/Gauss-Jordan-Elim-Fun.html
-
Maximum Cardinality Matching
/entries/Max-Card-Matching.html
Thu, 21 Jul 2011 00:00:00 +0000
/entries/Max-Card-Matching.html
-
Knowledge-based programs
/entries/KBPs.html
Tue, 17 May 2011 00:00:00 +0000
/entries/KBPs.html
-
The General Triangle Is Unique
/entries/General-Triangle.html
Fri, 01 Apr 2011 00:00:00 +0000
/entries/General-Triangle.html
-
Executable Transitive Closures of Finite Relations
/entries/Transitive-Closure.html
Mon, 14 Mar 2011 00:00:00 +0000
/entries/Transitive-Closure.html
-
AutoFocus Stream Processing for Single-Clocking and Multi-Clocking Semantics
/entries/AutoFocus-Stream.html
Wed, 23 Feb 2011 00:00:00 +0000
/entries/AutoFocus-Stream.html
-
Infinite Lists
/entries/List-Infinite.html
Wed, 23 Feb 2011 00:00:00 +0000
/entries/List-Infinite.html
-
Interval Temporal Logic on Natural Numbers
/entries/Nat-Interval-Logic.html
Wed, 23 Feb 2011 00:00:00 +0000
/entries/Nat-Interval-Logic.html
-
Lightweight Java
/entries/LightweightJava.html
Mon, 07 Feb 2011 00:00:00 +0000
/entries/LightweightJava.html
-
RIPEMD-160
/entries/RIPEMD-160-SPARK.html
Mon, 10 Jan 2011 00:00:00 +0000
/entries/RIPEMD-160-SPARK.html
-
Lower Semicontinuous Functions
/entries/Lower_Semicontinuous.html
Sat, 08 Jan 2011 00:00:00 +0000
/entries/Lower_Semicontinuous.html
-
Hall's Marriage Theorem
/entries/Marriage.html
Fri, 17 Dec 2010 00:00:00 +0000
/entries/Marriage.html
-
Shivers' Control Flow Analysis
/entries/Shivers-CFA.html
Tue, 16 Nov 2010 00:00:00 +0000
/entries/Shivers-CFA.html
-
Binomial Heaps and Skew Binomial Heaps
/entries/Binomial-Heaps.html
Thu, 28 Oct 2010 00:00:00 +0000
/entries/Binomial-Heaps.html
-
Finger Trees
/entries/Finger-Trees.html
Thu, 28 Oct 2010 00:00:00 +0000
/entries/Finger-Trees.html
-
Functional Binomial Queues
/entries/Binomial-Queues.html
Thu, 28 Oct 2010 00:00:00 +0000
/entries/Binomial-Queues.html
-
Strong Normalization of Moggis's Computational Metalanguage
/entries/Lam-ml-Normalization.html
Sun, 29 Aug 2010 00:00:00 +0000
/entries/Lam-ml-Normalization.html
-
Executable Multivariate Polynomials
/entries/Polynomials.html
Tue, 10 Aug 2010 00:00:00 +0000
/entries/Polynomials.html
-
Formalizing Statecharts using Hierarchical Automata
/entries/Statecharts.html
Sun, 08 Aug 2010 00:00:00 +0000
/entries/Statecharts.html
-
Free Groups
/entries/Free-Groups.html
Thu, 24 Jun 2010 00:00:00 +0000
/entries/Free-Groups.html
-
Category Theory
/entries/Category2.html
Sun, 20 Jun 2010 00:00:00 +0000
/entries/Category2.html
-
Executable Matrix Operations on Matrices of Arbitrary Dimensions
/entries/Matrix.html
Thu, 17 Jun 2010 00:00:00 +0000
/entries/Matrix.html
-
Abstract Rewriting
/entries/Abstract-Rewriting.html
Mon, 14 Jun 2010 00:00:00 +0000
/entries/Abstract-Rewriting.html
-
Semantics and Data Refinement of Invariant Based Programs
/entries/DataRefinementIBP.html
Fri, 28 May 2010 00:00:00 +0000
/entries/DataRefinementIBP.html
-
Verification of the Deutsch-Schorr-Waite Graph Marking Algorithm using Data Refinement
/entries/GraphMarkingIBP.html
Fri, 28 May 2010 00:00:00 +0000
/entries/GraphMarkingIBP.html
-
A Complete Proof of the Robbins Conjecture
/entries/Robbins-Conjecture.html
Sat, 22 May 2010 00:00:00 +0000
/entries/Robbins-Conjecture.html
-
Regular Sets and Expressions
/entries/Regular-Sets.html
Wed, 12 May 2010 00:00:00 +0000
/entries/Regular-Sets.html
-
Locally Nameless Sigma Calculus
/entries/Locally-Nameless-Sigma.html
Fri, 30 Apr 2010 00:00:00 +0000
/entries/Locally-Nameless-Sigma.html
-
Free Boolean Algebra
/entries/Free-Boolean-Algebra.html
Mon, 29 Mar 2010 00:00:00 +0000
/entries/Free-Boolean-Algebra.html
-
Information Flow Noninterference via Slicing
/entries/InformationFlowSlicing.html
Tue, 23 Mar 2010 00:00:00 +0000
/entries/InformationFlowSlicing.html
-
Inter-Procedural Information Flow Noninterference via Slicing
/entries/InformationFlowSlicing_Inter.html
Tue, 23 Mar 2010 00:00:00 +0000
/entries/InformationFlowSlicing_Inter.html
-
List Index
/entries/List-Index.html
Sat, 20 Feb 2010 00:00:00 +0000
/entries/List-Index.html
-
Coinductive
/entries/Coinductive.html
Fri, 12 Feb 2010 00:00:00 +0000
/entries/Coinductive.html
-
A Fast SAT Solver for Isabelle in Standard ML
/entries/DPT-SAT-Solver.html
Wed, 09 Dec 2009 00:00:00 +0000
/entries/DPT-SAT-Solver.html
-
Formalizing the Logic-Automaton Connection
/entries/Presburger-Automata.html
Thu, 03 Dec 2009 00:00:00 +0000
/entries/Presburger-Automata.html
-
Collections Framework
/entries/Collections.html
Wed, 25 Nov 2009 00:00:00 +0000
/entries/Collections.html
-
Tree Automata
/entries/Tree-Automata.html
Wed, 25 Nov 2009 00:00:00 +0000
/entries/Tree-Automata.html
-
Perfect Number Theorem
/entries/Perfect-Number-Thm.html
Sun, 22 Nov 2009 00:00:00 +0000
/entries/Perfect-Number-Thm.html
-
Backing up Slicing: Verifying the Interprocedural Two-Phase Horwitz-Reps-Binkley Slicer
/entries/HRB-Slicing.html
Fri, 13 Nov 2009 00:00:00 +0000
/entries/HRB-Slicing.html
-
The Worker/Wrapper Transformation
/entries/WorkerWrapper.html
Fri, 30 Oct 2009 00:00:00 +0000
/entries/WorkerWrapper.html
-
Ordinals and Cardinals
/entries/Ordinals_and_Cardinals.html
Tue, 01 Sep 2009 00:00:00 +0000
/entries/Ordinals_and_Cardinals.html
-
Invertibility in Sequent Calculi
/entries/SequentInvertibility.html
Fri, 28 Aug 2009 00:00:00 +0000
/entries/SequentInvertibility.html
-
An Example of a Cofinitary Group in Isabelle/HOL
/entries/CofGroups.html
Tue, 04 Aug 2009 00:00:00 +0000
/entries/CofGroups.html
-
Code Generation for Functions as Data
/entries/FinFun.html
Wed, 06 May 2009 00:00:00 +0000
/entries/FinFun.html
-
Stream Fusion
/entries/Stream-Fusion.html
Wed, 29 Apr 2009 00:00:00 +0000
/entries/Stream-Fusion.html
-
A Bytecode Logic for JML and Types
/entries/BytecodeLogicJmlTypes.html
Fri, 12 Dec 2008 00:00:00 +0000
/entries/BytecodeLogicJmlTypes.html
-
Secure information flow and program logics
/entries/SIFPL.html
Mon, 10 Nov 2008 00:00:00 +0000
/entries/SIFPL.html
-
Some classical results in Social Choice Theory
/entries/SenSocialChoice.html
Sun, 09 Nov 2008 00:00:00 +0000
/entries/SenSocialChoice.html
-
Fun With Tilings
/entries/FunWithTilings.html
Fri, 07 Nov 2008 00:00:00 +0000
/entries/FunWithTilings.html
-
The Textbook Proof of Huffman's Algorithm
/entries/Huffman.html
Wed, 15 Oct 2008 00:00:00 +0000
/entries/Huffman.html
-
Towards Certified Slicing
/entries/Slicing.html
Tue, 16 Sep 2008 00:00:00 +0000
/entries/Slicing.html
-
A Correctness Proof for the Volpano/Smith Security Typing System
/entries/VolpanoSmith.html
Tue, 02 Sep 2008 00:00:00 +0000
/entries/VolpanoSmith.html
-
Arrow and Gibbard-Satterthwaite
/entries/ArrowImpossibilityGS.html
Mon, 01 Sep 2008 00:00:00 +0000
/entries/ArrowImpossibilityGS.html
-
Fun With Functions
/entries/FunWithFunctions.html
Tue, 26 Aug 2008 00:00:00 +0000
/entries/FunWithFunctions.html
-
Formal Verification of Modern SAT Solvers
/entries/SATSolverVerification.html
Wed, 23 Jul 2008 00:00:00 +0000
/entries/SATSolverVerification.html
-
Recursion Theory I
/entries/Recursion-Theory-I.html
Sat, 05 Apr 2008 00:00:00 +0000
/entries/Recursion-Theory-I.html
-
A Sequential Imperative Programming Language Syntax, Semantics, Hoare Logics and Verification Environment
/entries/Simpl.html
Fri, 29 Feb 2008 00:00:00 +0000
/entries/Simpl.html
-
BDD Normalisation
/entries/BDD.html
Fri, 29 Feb 2008 00:00:00 +0000
/entries/BDD.html
-
Normalization by Evaluation
/entries/NormByEval.html
Mon, 18 Feb 2008 00:00:00 +0000
/entries/NormByEval.html
-
Quantifier Elimination for Linear Arithmetic
/entries/LinearQuantifierElim.html
Fri, 11 Jan 2008 00:00:00 +0000
/entries/LinearQuantifierElim.html
-
Formalization of Conflict Analysis of Programs with Procedures, Thread Creation, and Monitors
/entries/Program-Conflict-Analysis.html
Fri, 14 Dec 2007 00:00:00 +0000
/entries/Program-Conflict-Analysis.html
-
Jinja with Threads
/entries/JinjaThreads.html
Mon, 03 Dec 2007 00:00:00 +0000
/entries/JinjaThreads.html
-
Much Ado About Two
/entries/MuchAdoAboutTwo.html
Tue, 06 Nov 2007 00:00:00 +0000
/entries/MuchAdoAboutTwo.html
-
Fermat's Last Theorem for Exponents 3 and 4 and the Parametrisation of Pythagorean Triples
/entries/Fermat3_4.html
Sun, 12 Aug 2007 00:00:00 +0000
/entries/Fermat3_4.html
-
Sums of Two and Four Squares
/entries/SumSquares.html
Sun, 12 Aug 2007 00:00:00 +0000
/entries/SumSquares.html
-
Fundamental Properties of Valuation Theory and Hensel's Lemma
/entries/Valuation.html
Wed, 08 Aug 2007 00:00:00 +0000
/entries/Valuation.html
-
First-Order Logic According to Fitting
/entries/FOL-Fitting.html
Thu, 02 Aug 2007 00:00:00 +0000
/entries/FOL-Fitting.html
-
POPLmark Challenge Via de Bruijn Indices
/entries/POPLmark-deBruijn.html
Thu, 02 Aug 2007 00:00:00 +0000
/entries/POPLmark-deBruijn.html
-
Hotel Key Card System
/entries/HotelKeyCards.html
Sat, 09 Sep 2006 00:00:00 +0000
/entries/HotelKeyCards.html
-
Abstract Hoare Logics
/entries/Abstract-Hoare-Logics.html
Tue, 08 Aug 2006 00:00:00 +0000
/entries/Abstract-Hoare-Logics.html
-
Flyspeck I: Tame Graphs
/entries/Flyspeck-Tame.html
Mon, 22 May 2006 00:00:00 +0000
/entries/Flyspeck-Tame.html
-
CoreC++
/entries/CoreC++.html
Mon, 15 May 2006 00:00:00 +0000
/entries/CoreC++.html
-
A Theory of Featherweight Java in Isabelle/HOL
/entries/FeatherweightJava.html
Fri, 31 Mar 2006 00:00:00 +0000
/entries/FeatherweightJava.html
-
Instances of Schneider's generalized protocol of clock synchronization
/entries/ClockSynchInst.html
Wed, 15 Mar 2006 00:00:00 +0000
/entries/ClockSynchInst.html
-
Cauchy's Mean Theorem and the Cauchy-Schwarz Inequality
/entries/Cauchy.html
Tue, 14 Mar 2006 00:00:00 +0000
/entries/Cauchy.html
-
Countable Ordinals
/entries/Ordinal.html
Fri, 11 Nov 2005 00:00:00 +0000
/entries/Ordinal.html
-
Fast Fourier Transform
/entries/FFT.html
Wed, 12 Oct 2005 00:00:00 +0000
/entries/FFT.html
-
Formalization of a Generalized Protocol for Clock Synchronization
/entries/GenClock.html
Fri, 24 Jun 2005 00:00:00 +0000
/entries/GenClock.html
-
Proving the Correctness of Disk Paxos
/entries/DiskPaxos.html
Wed, 22 Jun 2005 00:00:00 +0000
/entries/DiskPaxos.html
-
Jive Data and Store Model
/entries/JiveDataStoreModel.html
Mon, 20 Jun 2005 00:00:00 +0000
/entries/JiveDataStoreModel.html
-
Jinja is not Java
/entries/Jinja.html
Wed, 01 Jun 2005 00:00:00 +0000
/entries/Jinja.html
-
SHA1, RSA, PSS and more
/entries/RSAPSS.html
Mon, 02 May 2005 00:00:00 +0000
/entries/RSAPSS.html
-
Category Theory to Yoneda's Lemma
/entries/Category.html
Thu, 21 Apr 2005 00:00:00 +0000
/entries/Category.html
-
File Refinement
/entries/FileRefinement.html
Thu, 09 Dec 2004 00:00:00 +0000
/entries/FileRefinement.html
-
Integration theory and random variables
/entries/Integration.html
Fri, 19 Nov 2004 00:00:00 +0000
/entries/Integration.html
-
A Mechanically Verified, Efficient, Sound and Complete Theorem Prover For First Order Logic
/entries/Verified-Prover.html
Tue, 28 Sep 2004 00:00:00 +0000
/entries/Verified-Prover.html
-
Completeness theorem
/entries/Completeness.html
Mon, 20 Sep 2004 00:00:00 +0000
/entries/Completeness.html
-
Ramsey's theorem, infinitary version
/entries/Ramsey-Infinite.html
Mon, 20 Sep 2004 00:00:00 +0000
/entries/Ramsey-Infinite.html
-
Compiling Exceptions Correctly
/entries/Compiling-Exceptions-Correctly.html
Fri, 09 Jul 2004 00:00:00 +0000
/entries/Compiling-Exceptions-Correctly.html
-
Depth First Search
/entries/Depth-First-Search.html
Thu, 24 Jun 2004 00:00:00 +0000
/entries/Depth-First-Search.html
-
Groups, Rings and Modules
/entries/Group-Ring-Module.html
Tue, 18 May 2004 00:00:00 +0000
/entries/Group-Ring-Module.html
-
Lazy Lists II
/entries/Lazy-Lists-II.html
Mon, 26 Apr 2004 00:00:00 +0000
/entries/Lazy-Lists-II.html
-
Topology
/entries/Topology.html
Mon, 26 Apr 2004 00:00:00 +0000
/entries/Topology.html
-
Binary Search Trees
/entries/BinarySearchTree.html
Mon, 05 Apr 2004 00:00:00 +0000
/entries/BinarySearchTree.html
-
Functional Automata
/entries/Functional-Automata.html
Tue, 30 Mar 2004 00:00:00 +0000
/entries/Functional-Automata.html
-
AVL Trees
/entries/AVL-Trees.html
Fri, 19 Mar 2004 00:00:00 +0000
/entries/AVL-Trees.html
-
Mini ML
/entries/MiniML.html
Fri, 19 Mar 2004 00:00:00 +0000
/entries/MiniML.html
-
Abortable_Linearizable_Modules
/theories/abortable_linearizable_modules/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abortable_linearizable_modules/
-
Abs_Int_ITP2012
/theories/abs_int_itp2012/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abs_int_itp2012/
-
Abstract-Hoare-Logics
/theories/abstract-hoare-logics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract-hoare-logics/
-
Abstract-Rewriting
/theories/abstract-rewriting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract-rewriting/
-
Abstract_Completeness
/theories/abstract_completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract_completeness/
-
Abstract_Soundness
/theories/abstract_soundness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract_soundness/
-
ABY3_Protocols
/theories/aby3_protocols/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aby3_protocols/
-
Ackermanns_not_PR
/theories/ackermanns_not_pr/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ackermanns_not_pr/
-
Actuarial_Mathematics
/theories/actuarial_mathematics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/actuarial_mathematics/
-
Adaptive_State_Counting
/theories/adaptive_state_counting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/adaptive_state_counting/
-
ADS_Functor
/theories/ads_functor/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ads_functor/
-
Affine_Arithmetic
/theories/affine_arithmetic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/affine_arithmetic/
-
Aggregation_Algebras
/theories/aggregation_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aggregation_algebras/
-
AI_Planning_Languages_Semantics
/theories/ai_planning_languages_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ai_planning_languages_semantics/
-
Akra_Bazzi
/theories/akra_bazzi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/akra_bazzi/
-
Algebraic_Numbers
/theories/algebraic_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/algebraic_numbers/
-
Algebraic_VCs
/theories/algebraic_vcs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/algebraic_vcs/
-
Allen_Calculus
/theories/allen_calculus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/allen_calculus/
-
Amicable_Numbers
/theories/amicable_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/amicable_numbers/
-
Amortized_Complexity
/theories/amortized_complexity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/amortized_complexity/
-
AnselmGod
/theories/anselmgod/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/anselmgod/
-
AODV
/theories/aodv/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aodv/
-
AOT
/theories/aot/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aot/
-
Applicative_Lifting
/theories/applicative_lifting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/applicative_lifting/
-
Approximation_Algorithms
/theories/approximation_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/approximation_algorithms/
-
Architectural_Design_Patterns
/theories/architectural_design_patterns/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/architectural_design_patterns/
-
Aristotles_Assertoric_Syllogistic
/theories/aristotles_assertoric_syllogistic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aristotles_assertoric_syllogistic/
-
Arith_Prog_Rel_Primes
/theories/arith_prog_rel_primes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/arith_prog_rel_primes/
-
ArrowImpossibilityGS
/theories/arrowimpossibilitygs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/arrowimpossibilitygs/
-
Attack_Trees
/theories/attack_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/attack_trees/
-
Auto2_HOL
/theories/auto2_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/auto2_hol/
-
Auto2_Imperative_HOL
/theories/auto2_imperative_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/auto2_imperative_hol/
-
AutoFocus-Stream
/theories/autofocus-stream/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/autofocus-stream/
-
Automated_Stateful_Protocol_Verification
/theories/automated_stateful_protocol_verification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/automated_stateful_protocol_verification/
-
Automatic_Refinement
/theories/automatic_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/automatic_refinement/
-
AVL-Trees
/theories/avl-trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/avl-trees/
-
AWN
/theories/awn/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/awn/
-
AxiomaticCategoryTheory
/theories/axiomaticcategorytheory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/axiomaticcategorytheory/
-
Balog_Szemeredi_Gowers
/theories/balog_szemeredi_gowers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/balog_szemeredi_gowers/
-
Banach_Steinhaus
/theories/banach_steinhaus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/banach_steinhaus/
-
BD_Security_Compositional
/theories/bd_security_compositional/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bd_security_compositional/
-
BDD
/theories/bdd/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bdd/
-
Belief_Revision
/theories/belief_revision/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/belief_revision/
-
Bell_Numbers_Spivey
/theories/bell_numbers_spivey/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bell_numbers_spivey/
-
BenOr_Kozen_Reif
/theories/benor_kozen_reif/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/benor_kozen_reif/
-
Berlekamp_Zassenhaus
/theories/berlekamp_zassenhaus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/berlekamp_zassenhaus/
-
Bernoulli
/theories/bernoulli/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bernoulli/
-
Bertrands_Postulate
/theories/bertrands_postulate/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bertrands_postulate/
-
Bicategory
/theories/bicategory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bicategory/
-
Binary_Code_Imprimitive
/theories/binary_code_imprimitive/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binary_code_imprimitive/
-
BinarySearchTree
/theories/binarysearchtree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binarysearchtree/
-
Binding_Syntax_Theory
/theories/binding_syntax_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binding_syntax_theory/
-
Binomial-Heaps
/theories/binomial-heaps/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binomial-heaps/
-
Binomial-Queues
/theories/binomial-queues/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binomial-queues/
-
BirdKMP
/theories/birdkmp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/birdkmp/
-
Birkhoff_Finite_Distributive_Lattices
/theories/birkhoff_finite_distributive_lattices/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/birkhoff_finite_distributive_lattices/
-
Blue_Eyes
/theories/blue_eyes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/blue_eyes/
-
BNF_CC
/theories/bnf_cc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bnf_cc/
-
BNF_Operations
/theories/bnf_operations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bnf_operations/
-
Bondy
/theories/bondy/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bondy/
-
Boolean_Expression_Checkers
/theories/boolean_expression_checkers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/boolean_expression_checkers/
-
Boolos_Curious_Inference
/theories/boolos_curious_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/boolos_curious_inference/
-
Boolos_Curious_Inference_Automated
/theories/boolos_curious_inference_automated/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/boolos_curious_inference_automated/
-
Bounded_Deducibility_Security
/theories/bounded_deducibility_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bounded_deducibility_security/
-
BTree
/theories/btree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/btree/
-
Buchi_Complementation
/theories/buchi_complementation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/buchi_complementation/
-
Budan_Fourier
/theories/budan_fourier/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/budan_fourier/
-
Buffons_Needle
/theories/buffons_needle/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/buffons_needle/
-
Buildings
/theories/buildings/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/buildings/
-
BytecodeLogicJmlTypes
/theories/bytecodelogicjmltypes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bytecodelogicjmltypes/
-
C2KA_DistributedSystems
/theories/c2ka_distributedsystems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/c2ka_distributedsystems/
-
CakeML
/theories/cakeml/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cakeml/
-
CakeML_Codegen
/theories/cakeml_codegen/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cakeml_codegen/
-
Call_Arity
/theories/call_arity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/call_arity/
-
Card_Equiv_Relations
/theories/card_equiv_relations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_equiv_relations/
-
Card_Multisets
/theories/card_multisets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_multisets/
-
Card_Number_Partitions
/theories/card_number_partitions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_number_partitions/
-
Card_Partitions
/theories/card_partitions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_partitions/
-
Cartan_FP
/theories/cartan_fp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cartan_fp/
-
Case_Labeling
/theories/case_labeling/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/case_labeling/
-
Catalan_Numbers
/theories/catalan_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/catalan_numbers/
-
Category
/theories/category/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/category/
-
Category2
/theories/category2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/category2/
-
Category3
/theories/category3/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/category3/
-
Cauchy
/theories/cauchy/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cauchy/
-
CAVA_Automata
/theories/cava_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_automata/
-
CAVA_Base
/theories/cava_base/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_base/
-
CAVA_LTL_Modelchecker
/theories/cava_ltl_modelchecker/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_ltl_modelchecker/
-
CAVA_Setup
/theories/cava_setup/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_setup/
-
Cayley_Hamilton
/theories/cayley_hamilton/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cayley_hamilton/
-
CCS
/theories/ccs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ccs/
-
Certification_Monads
/theories/certification_monads/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/certification_monads/
-
Chandy_Lamport
/theories/chandy_lamport/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/chandy_lamport/
-
CHERI-C_Memory_Model
/theories/cheri-c_memory_model/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cheri-c_memory_model/
-
Chord_Segments
/theories/chord_segments/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/chord_segments/
-
Circus
/theories/circus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/circus/
-
CISC-Kernel
/theories/cisc-kernel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cisc-kernel/
-
Clean
/theories/clean/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/clean/
-
Clique_and_Monotone_Circuits
/theories/clique_and_monotone_circuits/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/clique_and_monotone_circuits/
-
ClockSynchInst
/theories/clocksynchinst/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/clocksynchinst/
-
Closest_Pair_Points
/theories/closest_pair_points/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/closest_pair_points/
-
CoCon
/theories/cocon/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cocon/
-
CofGroups
/theories/cofgroups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cofgroups/
-
Coinductive
/theories/coinductive/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/coinductive/
-
Coinductive_Languages
/theories/coinductive_languages/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/coinductive_languages/
-
Collections
/theories/collections/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/collections/
-
Collections_Examples
/theories/collections_examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/collections_examples/
-
Combinable_Wands
/theories/combinable_wands/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinable_wands/
-
Combinatorial_Enumeration_Algorithms
/theories/combinatorial_enumeration_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorial_enumeration_algorithms/
-
Combinatorics_Words
/theories/combinatorics_words/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorics_words/
-
Combinatorics_Words_Graph_Lemma
/theories/combinatorics_words_graph_lemma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorics_words_graph_lemma/
-
Combinatorics_Words_Lyndon
/theories/combinatorics_words_lyndon/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorics_words_lyndon/
-
CommCSL
/theories/commcsl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/commcsl/
-
Commuting_Hermitian
/theories/commuting_hermitian/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/commuting_hermitian/
-
Comparison_Sort_Lower_Bound
/theories/comparison_sort_lower_bound/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/comparison_sort_lower_bound/
-
Compiling-Exceptions-Correctly
/theories/compiling-exceptions-correctly/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/compiling-exceptions-correctly/
-
Complete_Non_Orders
/theories/complete_non_orders/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complete_non_orders/
-
Completeness
/theories/completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/completeness/
-
Complex_Bounded_Operators
/theories/complex_bounded_operators/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complex_bounded_operators/
-
Complex_Bounded_Operators_Dependencies
/theories/complex_bounded_operators_dependencies/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complex_bounded_operators_dependencies/
-
Complex_Geometry
/theories/complex_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complex_geometry/
-
Complx
/theories/complx/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complx/
-
ComponentDependencies
/theories/componentdependencies/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/componentdependencies/
-
Concurrent_Ref_Alg
/theories/concurrent_ref_alg/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrent_ref_alg/
-
Concurrent_Revisions
/theories/concurrent_revisions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrent_revisions/
-
ConcurrentGC
/theories/concurrentgc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrentgc/
-
ConcurrentIMP
/theories/concurrentimp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrentimp/
-
Conditional_Simplification
/theories/conditional_simplification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/conditional_simplification/
-
Conditional_Transfer_Rule
/theories/conditional_transfer_rule/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/conditional_transfer_rule/
-
Consensus_Refined
/theories/consensus_refined/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/consensus_refined/
-
Constructive_Cryptography
/theories/constructive_cryptography/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/constructive_cryptography/
-
Constructive_Cryptography_CM
/theories/constructive_cryptography_cm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/constructive_cryptography_cm/
-
Constructor_Funs
/theories/constructor_funs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/constructor_funs/
-
Containers
/theories/containers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/containers/
-
Containers-Benchmarks
/theories/containers-benchmarks/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/containers-benchmarks/
-
Cook_Levin
/theories/cook_levin/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cook_levin/
-
Core_DOM
/theories/core_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/core_dom/
-
Core_SC_DOM
/theories/core_sc_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/core_sc_dom/
-
CoreC++
/theories/corec++/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/corec++/
-
Correctness_Algebras
/theories/correctness_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/correctness_algebras/
-
CoSMed
/theories/cosmed/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cosmed/
-
CoSMeDis
/theories/cosmedis/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cosmedis/
-
Cotangent_PFD_Formula
/theories/cotangent_pfd_formula/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cotangent_pfd_formula/
-
Count_Complex_Roots
/theories/count_complex_roots/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/count_complex_roots/
-
CRDT
/theories/crdt/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crdt/
-
CryptHOL
/theories/crypthol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crypthol/
-
Crypto_Standards
/theories/crypto_standards/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crypto_standards/
-
CryptoBasedCompositionalProperties
/theories/cryptobasedcompositionalproperties/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cryptobasedcompositionalproperties/
-
CRYSTALS-Kyber
/theories/crystals-kyber/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crystals-kyber/
-
CSP_RefTK
/theories/csp_reftk/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/csp_reftk/
-
Cubic_Quartic_Equations
/theories/cubic_quartic_equations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cubic_quartic_equations/
-
CVP_Hardness
/theories/cvp_hardness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cvp_hardness/
-
CYK
/theories/cyk/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cyk/
-
CZH_Elementary_Categories
/theories/czh_elementary_categories/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/czh_elementary_categories/
-
CZH_Foundations
/theories/czh_foundations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/czh_foundations/
-
CZH_Universal_Constructions
/theories/czh_universal_constructions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/czh_universal_constructions/
-
DataRefinementIBP
/theories/datarefinementibp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/datarefinementibp/
-
Datatype_Order_Generator
/theories/datatype_order_generator/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/datatype_order_generator/
-
DCR-ExecutionEquivalence
/theories/dcr-executionequivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dcr-executionequivalence/
-
Decl_Sem_Fun_PL
/theories/decl_sem_fun_pl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/decl_sem_fun_pl/
-
Decreasing-Diagrams
/theories/decreasing-diagrams/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/decreasing-diagrams/
-
Decreasing-Diagrams-II
/theories/decreasing-diagrams-ii/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/decreasing-diagrams-ii/
-
Dedekind_Real
/theories/dedekind_real/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dedekind_real/
-
Deep_Learning
/theories/deep_learning/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/deep_learning/
-
Delta_System_Lemma
/theories/delta_system_lemma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/delta_system_lemma/
-
Density_Compiler
/theories/density_compiler/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/density_compiler/
-
Dependent_SIFUM_Refinement
/theories/dependent_sifum_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dependent_sifum_refinement/
-
Dependent_SIFUM_Type_Systems
/theories/dependent_sifum_type_systems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dependent_sifum_type_systems/
-
Depth-First-Search
/theories/depth-first-search/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/depth-first-search/
-
Derangements
/theories/derangements/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/derangements/
-
Deriving
/theories/deriving/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/deriving/
-
Descartes_Sign_Rule
/theories/descartes_sign_rule/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/descartes_sign_rule/
-
Design_Theory
/theories/design_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/design_theory/
-
DFS_Framework
/theories/dfs_framework/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dfs_framework/
-
Dict_Construction
/theories/dict_construction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dict_construction/
-
Differential_Dynamic_Logic
/theories/differential_dynamic_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/differential_dynamic_logic/
-
Differential_Game_Logic
/theories/differential_game_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/differential_game_logic/
-
Digit_Expansions
/theories/digit_expansions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/digit_expansions/
-
DigitsInBase
/theories/digitsinbase/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/digitsinbase/
-
Dijkstra_Shortest_Path
/theories/dijkstra_shortest_path/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dijkstra_shortest_path/
-
Diophantine_Eqns_Lin_Hom
/theories/diophantine_eqns_lin_hom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/diophantine_eqns_lin_hom/
-
Directed_Sets
/theories/directed_sets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/directed_sets/
-
Dirichlet_L
/theories/dirichlet_l/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dirichlet_l/
-
Dirichlet_Series
/theories/dirichlet_series/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dirichlet_series/
-
Discrete_Summation
/theories/discrete_summation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/discrete_summation/
-
DiscretePricing
/theories/discretepricing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/discretepricing/
-
DiskPaxos
/theories/diskpaxos/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/diskpaxos/
-
Distributed_Distinct_Elements
/theories/distributed_distinct_elements/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/distributed_distinct_elements/
-
DOM_Components
/theories/dom_components/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dom_components/
-
Dominance_CHK
/theories/dominance_chk/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dominance_chk/
-
DPRM_Theorem
/theories/dprm_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dprm_theorem/
-
DPT-SAT-Solver
/theories/dpt-sat-solver/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dpt-sat-solver/
-
Dynamic_Tables
/theories/dynamic_tables/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dynamic_tables/
-
DynamicArchitectures
/theories/dynamicarchitectures/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dynamicarchitectures/
-
E_Transcendental
/theories/e_transcendental/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/e_transcendental/
-
Echelon_Form
/theories/echelon_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/echelon_form/
-
EdmondsKarp_Maxflow
/theories/edmondskarp_maxflow/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/edmondskarp_maxflow/
-
Edwards_Elliptic_Curves_Group
/theories/edwards_elliptic_curves_group/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/edwards_elliptic_curves_group/
-
Efficient-Mergesort
/theories/efficient-mergesort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/efficient-mergesort/
-
Efficient_Weighted_Path_Order
/theories/efficient_weighted_path_order/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/efficient_weighted_path_order/
-
Elliptic_Curves_Group_Law
/theories/elliptic_curves_group_law/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/elliptic_curves_group_law/
-
Encodability_Process_Calculi
/theories/encodability_process_calculi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/encodability_process_calculi/
-
Epistemic_Logic
/theories/epistemic_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/epistemic_logic/
-
Equivalence_Relation_Enumeration
/theories/equivalence_relation_enumeration/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/equivalence_relation_enumeration/
-
Ergodic_Theory
/theories/ergodic_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ergodic_theory/
-
Error_Function
/theories/error_function/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/error_function/
-
Euler_MacLaurin
/theories/euler_maclaurin/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/euler_maclaurin/
-
Euler_Partition
/theories/euler_partition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/euler_partition/
-
Eval_FO
/theories/eval_fo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/eval_fo/
-
+
Example-Submission
+ /theories/example-submission/
+ Mon, 01 Jan 0001 00:00:00 +0000
+
+ /theories/example-submission/
+
+
+
+ -
Executable_Randomized_Algorithms
/theories/executable_randomized_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/executable_randomized_algorithms/
-
Expander_Graphs
/theories/expander_graphs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/expander_graphs/
-
Extended_Finite_State_Machine_Inference
/theories/extended_finite_state_machine_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/extended_finite_state_machine_inference/
-
Extended_Finite_State_Machines
/theories/extended_finite_state_machines/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/extended_finite_state_machines/
-
Factor_Algebraic_Polynomial
/theories/factor_algebraic_polynomial/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/factor_algebraic_polynomial/
-
Factored_Transition_System_Bounding
/theories/factored_transition_system_bounding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/factored_transition_system_bounding/
-
Falling_Factorial_Sum
/theories/falling_factorial_sum/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/falling_factorial_sum/
-
Farkas
/theories/farkas/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/farkas/
-
Featherweight_OCL
/theories/featherweight_ocl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/featherweight_ocl/
-
FeatherweightJava
/theories/featherweightjava/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/featherweightjava/
-
Fermat3_4
/theories/fermat3_4/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fermat3_4/
-
FFT
/theories/fft/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fft/
-
FileRefinement
/theories/filerefinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/filerefinement/
-
FinFun
/theories/finfun/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finfun/
-
Finger-Trees
/theories/finger-trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finger-trees/
-
Finite-Map-Extras
/theories/finite-map-extras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finite-map-extras/
-
Finite_Automata_HF
/theories/finite_automata_hf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finite_automata_hf/
-
Finite_Fields
/theories/finite_fields/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finite_fields/
-
Finitely_Generated_Abelian_Groups
/theories/finitely_generated_abelian_groups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finitely_generated_abelian_groups/
-
First_Order_Terms
/theories/first_order_terms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/first_order_terms/
-
First_Welfare_Theorem
/theories/first_welfare_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/first_welfare_theorem/
-
Fishburn_Impossibility
/theories/fishburn_impossibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fishburn_impossibility/
-
Fisher_Yates
/theories/fisher_yates/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fisher_yates/
-
Fishers_Inequality
/theories/fishers_inequality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fishers_inequality/
-
Flow_Networks
/theories/flow_networks/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flow_networks/
-
Floyd_Warshall
/theories/floyd_warshall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/floyd_warshall/
-
FLP
/theories/flp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flp/
-
Flyspeck-Tame
/theories/flyspeck-tame/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flyspeck-tame/
-
Flyspeck-Tame-Computation
/theories/flyspeck-tame-computation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flyspeck-tame-computation/
-
FO_Theory_Rewriting
/theories/fo_theory_rewriting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fo_theory_rewriting/
-
FocusStreamsCaseStudies
/theories/focusstreamscasestudies/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/focusstreamscasestudies/
-
FOL-Fitting
/theories/fol-fitting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol-fitting/
-
FOL_Axiomatic
/theories/fol_axiomatic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_axiomatic/
-
FOL_Harrison
/theories/fol_harrison/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_harrison/
-
FOL_Seq_Calc1
/theories/fol_seq_calc1/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_seq_calc1/
-
FOL_Seq_Calc2
/theories/fol_seq_calc2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_seq_calc2/
-
FOL_Seq_Calc3
/theories/fol_seq_calc3/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_seq_calc3/
-
Forcing
/theories/forcing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/forcing/
-
Formal_Puiseux_Series
/theories/formal_puiseux_series/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formal_puiseux_series/
-
Formal_SSA
/theories/formal_ssa/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formal_ssa/
-
Formula_Derivatives
/theories/formula_derivatives/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formula_derivatives/
-
Formula_Derivatives-Examples
/theories/formula_derivatives-examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formula_derivatives-examples/
-
Foundation_of_geometry
/theories/foundation_of_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/foundation_of_geometry/
-
Fourier
/theories/fourier/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fourier/
-
Free-Boolean-Algebra
/theories/free-boolean-algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/free-boolean-algebra/
-
Free-Groups
/theories/free-groups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/free-groups/
-
Frequency_Moments
/theories/frequency_moments/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/frequency_moments/
-
Fresh_Identifiers
/theories/fresh_identifiers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fresh_identifiers/
-
FSM_Tests
/theories/fsm_tests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fsm_tests/
-
Functional-Automata
/theories/functional-automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/functional-automata/
-
Functional_Ordered_Resolution_Prover
/theories/functional_ordered_resolution_prover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/functional_ordered_resolution_prover/
-
FunWithFunctions
/theories/funwithfunctions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/funwithfunctions/
-
FunWithTilings
/theories/funwithtilings/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/funwithtilings/
-
Furstenberg_Topology
/theories/furstenberg_topology/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/furstenberg_topology/
-
Gabow_SCC
/theories/gabow_scc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gabow_scc/
-
Gale_Shapley
/theories/gale_shapley/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gale_shapley/
-
GaleStewart_Games
/theories/galestewart_games/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/galestewart_games/
-
Game_Based_Crypto
/theories/game_based_crypto/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/game_based_crypto/
-
Gauss-Jordan-Elim-Fun
/theories/gauss-jordan-elim-fun/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gauss-jordan-elim-fun/
-
Gauss_Jordan
/theories/gauss_jordan/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gauss_jordan/
-
Gauss_Sums
/theories/gauss_sums/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gauss_sums/
-
Gaussian_Integers
/theories/gaussian_integers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gaussian_integers/
-
GenClock
/theories/genclock/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/genclock/
-
General-Triangle
/theories/general-triangle/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/general-triangle/
-
Generalized_Counting_Sort
/theories/generalized_counting_sort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/generalized_counting_sort/
-
Generic_Deriving
/theories/generic_deriving/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/generic_deriving/
-
Generic_Join
/theories/generic_join/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/generic_join/
-
GewirthPGCProof
/theories/gewirthpgcproof/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gewirthpgcproof/
-
Girth_Chromatic
/theories/girth_chromatic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/girth_chromatic/
-
Given_Clause_Loops
/theories/given_clause_loops/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/given_clause_loops/
-
Goedel_HFSet_Semantic
/theories/goedel_hfset_semantic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedel_hfset_semantic/
-
Goedel_HFSet_Semanticless
/theories/goedel_hfset_semanticless/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedel_hfset_semanticless/
-
Goedel_Incompleteness
/theories/goedel_incompleteness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedel_incompleteness/
-
GoedelGod
/theories/goedelgod/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedelgod/
-
Goodstein_Lambda
/theories/goodstein_lambda/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goodstein_lambda/
-
GPU_Kernel_PL
/theories/gpu_kernel_pl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gpu_kernel_pl/
-
Graph_Saturation
/theories/graph_saturation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/graph_saturation/
-
Graph_Theory
/theories/graph_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/graph_theory/
-
GraphMarkingIBP
/theories/graphmarkingibp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/graphmarkingibp/
-
Gray_Codes
/theories/gray_codes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gray_codes/
-
Green
/theories/green/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/green/
-
Groebner_Bases
/theories/groebner_bases/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/groebner_bases/
-
Groebner_Macaulay
/theories/groebner_macaulay/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/groebner_macaulay/
-
Gromov_Hyperbolicity
/theories/gromov_hyperbolicity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gromov_hyperbolicity/
-
Grothendieck_Schemes
/theories/grothendieck_schemes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/grothendieck_schemes/
-
Group-Ring-Module
/theories/group-ring-module/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/group-ring-module/
-
Hahn_Jordan_Decomposition
/theories/hahn_jordan_decomposition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hahn_jordan_decomposition/
-
Hales_Jewett
/theories/hales_jewett/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hales_jewett/
-
Heard_Of
/theories/heard_of/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/heard_of/
-
Hello_World
/theories/hello_world/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hello_world/
-
HereditarilyFinite
/theories/hereditarilyfinite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hereditarilyfinite/
-
Hermite
/theories/hermite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hermite/
-
Hermite_Lindemann
/theories/hermite_lindemann/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hermite_lindemann/
-
Hidden_Markov_Models
/theories/hidden_markov_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hidden_markov_models/
-
Higher_Order_Terms
/theories/higher_order_terms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/higher_order_terms/
-
Hoare_Time
/theories/hoare_time/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hoare_time/
-
HoareForDivergence
/theories/hoarefordivergence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hoarefordivergence/
-
HOL-CSP
/theories/hol-csp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-csp/
-
HOL-ODE-ARCH-COMP
/theories/hol-ode-arch-comp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-ode-arch-comp/
-
HOL-ODE-Examples
/theories/hol-ode-examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-ode-examples/
-
HOL-ODE-Numerics
/theories/hol-ode-numerics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-ode-numerics/
-
HOLCF-Prelude
/theories/holcf-prelude/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/holcf-prelude/
-
Hood_Melville_Queue
/theories/hood_melville_queue/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hood_melville_queue/
-
HotelKeyCards
/theories/hotelkeycards/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hotelkeycards/
-
HRB-Slicing
/theories/hrb-slicing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hrb-slicing/
-
Huffman
/theories/huffman/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/huffman/
-
Hybrid_Logic
/theories/hybrid_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hybrid_logic/
-
Hybrid_Multi_Lane_Spatial_Logic
/theories/hybrid_multi_lane_spatial_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hybrid_multi_lane_spatial_logic/
-
Hybrid_Systems_VCs
/theories/hybrid_systems_vcs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hybrid_systems_vcs/
-
HyperCTL
/theories/hyperctl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hyperctl/
-
Hyperdual
/theories/hyperdual/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hyperdual/
-
HyperHoareLogic
/theories/hyperhoarelogic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hyperhoarelogic/
-
IEEE_Floating_Point
/theories/ieee_floating_point/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ieee_floating_point/
-
IFC_Tracking
/theories/ifc_tracking/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ifc_tracking/
-
IMAP-CRDT
/theories/imap-crdt/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imap-crdt/
-
IMO2019
/theories/imo2019/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imo2019/
-
IMP2
/theories/imp2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp2/
-
IMP2_Binary_Heap
/theories/imp2_binary_heap/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp2_binary_heap/
-
IMP_Compiler
/theories/imp_compiler/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp_compiler/
-
IMP_Compiler_Reuse
/theories/imp_compiler_reuse/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp_compiler_reuse/
-
Imperative_Insertion_Sort
/theories/imperative_insertion_sort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imperative_insertion_sort/
-
Implicational_Logic
/theories/implicational_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/implicational_logic/
-
Impossible_Geometry
/theories/impossible_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/impossible_geometry/
-
Incompleteness
/theories/incompleteness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/incompleteness/
-
Incredible_Proof_Machine
/theories/incredible_proof_machine/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/incredible_proof_machine/
-
Independence_CH
/theories/independence_ch/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/independence_ch/
-
Inductive_Confidentiality
/theories/inductive_confidentiality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/inductive_confidentiality/
-
Inductive_Inference
/theories/inductive_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/inductive_inference/
-
InformationFlowSlicing
/theories/informationflowslicing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/informationflowslicing/
-
InformationFlowSlicing_Inter
/theories/informationflowslicing_inter/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/informationflowslicing_inter/
-
InfPathElimination
/theories/infpathelimination/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/infpathelimination/
-
Integration
/theories/integration/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/integration/
-
Interpolation_Polynomials_HOL_Algebra
/theories/interpolation_polynomials_hol_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/interpolation_polynomials_hol_algebra/
-
Interpreter_Optimizations
/theories/interpreter_optimizations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/interpreter_optimizations/
-
Interval_Arithmetic_Word32
/theories/interval_arithmetic_word32/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/interval_arithmetic_word32/
-
Intro_Dest_Elim
/theories/intro_dest_elim/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/intro_dest_elim/
-
Involutions2Squares
/theories/involutions2squares/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/involutions2squares/
-
IP_Addresses
/theories/ip_addresses/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ip_addresses/
-
Iptables_Semantics
/theories/iptables_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/iptables_semantics/
-
Iptables_Semantics_Examples
/theories/iptables_semantics_examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/iptables_semantics_examples/
-
Iptables_Semantics_Examples_Big
/theories/iptables_semantics_examples_big/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/iptables_semantics_examples_big/
-
Irrational_Series_Erdos_Straus
/theories/irrational_series_erdos_straus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/irrational_series_erdos_straus/
-
Irrationality_J_Hancl
/theories/irrationality_j_hancl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/irrationality_j_hancl/
-
Irrationals_From_THEBOOK
/theories/irrationals_from_thebook/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/irrationals_from_thebook/
-
Isabelle_C
/theories/isabelle_c/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isabelle_c/
-
Isabelle_Marries_Dirac
/theories/isabelle_marries_dirac/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isabelle_marries_dirac/
-
Isabelle_Meta_Model
/theories/isabelle_meta_model/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isabelle_meta_model/
-
IsaGeoCoq
/theories/isageocoq/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isageocoq/
-
IsaNet
/theories/isanet/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isanet/
-
Jacobson_Basic_Algebra
/theories/jacobson_basic_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jacobson_basic_algebra/
-
Jinja
/theories/jinja/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jinja/
-
JinjaDCI
/theories/jinjadci/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jinjadci/
-
JinjaThreads
/theories/jinjathreads/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jinjathreads/
-
JiveDataStoreModel
/theories/jivedatastoremodel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jivedatastoremodel/
-
Jordan_Hoelder
/theories/jordan_hoelder/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jordan_hoelder/
-
Jordan_Normal_Form
/theories/jordan_normal_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jordan_normal_form/
-
KAD
/theories/kad/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kad/
-
KAT_and_DRA
/theories/kat_and_dra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kat_and_dra/
-
KBPs
/theories/kbps/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kbps/
-
KD_Tree
/theories/kd_tree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kd_tree/
-
Key_Agreement_Strong_Adversaries
/theories/key_agreement_strong_adversaries/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/key_agreement_strong_adversaries/
-
Khovanskii_Theorem
/theories/khovanskii_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/khovanskii_theorem/
-
Kleene_Algebra
/theories/kleene_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kleene_algebra/
-
Kneser_Cauchy_Davenport
/theories/kneser_cauchy_davenport/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kneser_cauchy_davenport/
-
Knights_Tour
/theories/knights_tour/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knights_tour/
-
Knot_Theory
/theories/knot_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knot_theory/
-
Knuth_Bendix_Order
/theories/knuth_bendix_order/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knuth_bendix_order/
-
Knuth_Morris_Pratt
/theories/knuth_morris_pratt/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knuth_morris_pratt/
-
Koenigsberg_Friendship
/theories/koenigsberg_friendship/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/koenigsberg_friendship/
-
Kruskal
/theories/kruskal/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kruskal/
-
Kuratowski_Closure_Complement
/theories/kuratowski_closure_complement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kuratowski_closure_complement/
-
Lam-ml-Normalization
/theories/lam-ml-normalization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lam-ml-normalization/
-
Lambda_Free_EPO
/theories/lambda_free_epo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambda_free_epo/
-
Lambda_Free_KBOs
/theories/lambda_free_kbos/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambda_free_kbos/
-
Lambda_Free_RPOs
/theories/lambda_free_rpos/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambda_free_rpos/
-
LambdaAuth
/theories/lambdaauth/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambdaauth/
-
LambdaMu
/theories/lambdamu/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambdamu/
-
Lambert_W
/theories/lambert_w/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambert_w/
-
Landau_Symbols
/theories/landau_symbols/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/landau_symbols/
-
Laplace_Transform
/theories/laplace_transform/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/laplace_transform/
-
Latin_Square
/theories/latin_square/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/latin_square/
-
LatticeProperties
/theories/latticeproperties/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/latticeproperties/
-
Launchbury
/theories/launchbury/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/launchbury/
-
Laws_of_Large_Numbers
/theories/laws_of_large_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/laws_of_large_numbers/
-
Lazy-Lists-II
/theories/lazy-lists-ii/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lazy-lists-ii/
-
Lazy_Case
/theories/lazy_case/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lazy_case/
-
Lehmer
/theories/lehmer/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lehmer/
-
LEM
/theories/lem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lem/
-
Lifting_Definition_Option
/theories/lifting_definition_option/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lifting_definition_option/
-
Lifting_the_Exponent
/theories/lifting_the_exponent/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lifting_the_exponent/
-
LightweightJava
/theories/lightweightjava/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lightweightjava/
-
Linear_Inequalities
/theories/linear_inequalities/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_inequalities/
-
Linear_Programming
/theories/linear_programming/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_programming/
-
Linear_Recurrences
/theories/linear_recurrences/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_recurrences/
-
Linear_Recurrences_Solver
/theories/linear_recurrences_solver/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_recurrences_solver/
-
LinearQuantifierElim
/theories/linearquantifierelim/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linearquantifierelim/
-
Liouville_Numbers
/theories/liouville_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/liouville_numbers/
-
List-Index
/theories/list-index/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list-index/
-
List-Infinite
/theories/list-infinite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list-infinite/
-
List_Interleaving
/theories/list_interleaving/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list_interleaving/
-
List_Inversions
/theories/list_inversions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list_inversions/
-
List_Update
/theories/list_update/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list_update/
-
LLL_Basis_Reduction
/theories/lll_basis_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lll_basis_reduction/
-
LLL_Factorization
/theories/lll_factorization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lll_factorization/
-
Localization_Ring
/theories/localization_ring/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/localization_ring/
-
LocalLexing
/theories/locallexing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/locallexing/
-
Locally-Nameless-Sigma
/theories/locally-nameless-sigma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/locally-nameless-sigma/
-
LOFT
/theories/loft/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/loft/
-
Logging_Independent_Anonymity
/theories/logging_independent_anonymity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/logging_independent_anonymity/
-
Lorenz_Approximation
/theories/lorenz_approximation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lorenz_approximation/
-
Lorenz_C0
/theories/lorenz_c0/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lorenz_c0/
-
Lorenz_C1
/theories/lorenz_c1/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lorenz_c1/
-
Lowe_Ontological_Argument
/theories/lowe_ontological_argument/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lowe_ontological_argument/
-
Lower_Semicontinuous
/theories/lower_semicontinuous/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lower_semicontinuous/
-
Lp
/theories/lp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lp/
-
LP_Duality
/theories/lp_duality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lp_duality/
-
LTL
/theories/ltl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl/
-
LTL_Master_Theorem
/theories/ltl_master_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_master_theorem/
-
LTL_Normal_Form
/theories/ltl_normal_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_normal_form/
-
LTL_to_DRA
/theories/ltl_to_dra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_to_dra/
-
LTL_to_GBA
/theories/ltl_to_gba/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_to_gba/
-
Lucas_Theorem
/theories/lucas_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lucas_theorem/
-
Markov_Models
/theories/markov_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/markov_models/
-
Marriage
/theories/marriage/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/marriage/
-
Mason_Stothers
/theories/mason_stothers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mason_stothers/
-
Matrices_for_ODEs
/theories/matrices_for_odes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matrices_for_odes/
-
Matrix
/theories/matrix/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matrix/
-
Matrix_Tensor
/theories/matrix_tensor/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matrix_tensor/
-
Matroids
/theories/matroids/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matroids/
-
Max-Card-Matching
/theories/max-card-matching/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/max-card-matching/
-
Maximum_Segment_Sum
/theories/maximum_segment_sum/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/maximum_segment_sum/
-
MDP-Algorithms
/theories/mdp-algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mdp-algorithms/
-
MDP-Rewards
/theories/mdp-rewards/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mdp-rewards/
-
Median_Method
/theories/median_method/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/median_method/
-
Median_Of_Medians_Selection
/theories/median_of_medians_selection/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/median_of_medians_selection/
-
Menger
/theories/menger/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/menger/
-
Mereology
/theories/mereology/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mereology/
-
Mersenne_Primes
/theories/mersenne_primes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mersenne_primes/
-
Metalogic_ProofChecker
/theories/metalogic_proofchecker/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/metalogic_proofchecker/
-
MFMC_Countable
/theories/mfmc_countable/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mfmc_countable/
-
MFODL_Monitor_Optimized
/theories/mfodl_monitor_optimized/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mfodl_monitor_optimized/
-
MFOTL_Monitor
/theories/mfotl_monitor/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mfotl_monitor/
-
MHComputation
/theories/mhcomputation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mhcomputation/
-
Minimal_SSA
/theories/minimal_ssa/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minimal_ssa/
-
MiniML
/theories/miniml/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/miniml/
-
MiniSail
/theories/minisail/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minisail/
-
Minkowskis_Theorem
/theories/minkowskis_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minkowskis_theorem/
-
Minsky_Machines
/theories/minsky_machines/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minsky_machines/
-
MLSS_Decision_Proc
/theories/mlss_decision_proc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mlss_decision_proc/
-
Modal_Logics_for_NTS
/theories/modal_logics_for_nts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/modal_logics_for_nts/
-
Modular_arithmetic_LLL_and_HNF_algorithms
/theories/modular_arithmetic_lll_and_hnf_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/modular_arithmetic_lll_and_hnf_algorithms/
-
Modular_Assembly_Kit_Security
/theories/modular_assembly_kit_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/modular_assembly_kit_security/
-
Monad_Memo_DP
/theories/monad_memo_dp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monad_memo_dp/
-
Monad_Normalisation
/theories/monad_normalisation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monad_normalisation/
-
MonoBoolTranAlgebra
/theories/monobooltranalgebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monobooltranalgebra/
-
MonoidalCategory
/theories/monoidalcategory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monoidalcategory/
-
Monomorphic_Monad
/theories/monomorphic_monad/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monomorphic_monad/
-
MSO_Regex_Equivalence
/theories/mso_regex_equivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mso_regex_equivalence/
-
MuchAdoAboutTwo
/theories/muchadoabouttwo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/muchadoabouttwo/
-
Multi_Party_Computation
/theories/multi_party_computation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multi_party_computation/
-
Multirelations
/theories/multirelations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multirelations/
-
Multirelations_Heterogeneous
/theories/multirelations_heterogeneous/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multirelations_heterogeneous/
-
Multiset_Ordering_NPC
/theories/multiset_ordering_npc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multiset_ordering_npc/
-
Multitape_To_Singletape_TM
/theories/multitape_to_singletape_tm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multitape_to_singletape_tm/
-
Myhill-Nerode
/theories/myhill-nerode/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/myhill-nerode/
-
Name_Carrying_Type_Inference
/theories/name_carrying_type_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/name_carrying_type_inference/
-
Nano_JSON
/theories/nano_json/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nano_json/
-
Nash_Williams
/theories/nash_williams/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nash_williams/
-
Nat-Interval-Logic
/theories/nat-interval-logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nat-interval-logic/
-
Native_Word
/theories/native_word/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/native_word/
-
Nested_Multisets_Ordinals
/theories/nested_multisets_ordinals/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nested_multisets_ordinals/
-
Network_Security_Policy_Verification
/theories/network_security_policy_verification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/network_security_policy_verification/
-
Neumann_Morgenstern_Utility
/theories/neumann_morgenstern_utility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/neumann_morgenstern_utility/
-
No_FTL_observers
/theories/no_ftl_observers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/no_ftl_observers/
-
No_FTL_observers_Gen_Rel
/theories/no_ftl_observers_gen_rel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/no_ftl_observers_gen_rel/
-
Nominal2
/theories/nominal2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nominal2/
-
Noninterference_Concurrent_Composition
/theories/noninterference_concurrent_composition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_concurrent_composition/
-
Noninterference_CSP
/theories/noninterference_csp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_csp/
-
Noninterference_Generic_Unwinding
/theories/noninterference_generic_unwinding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_generic_unwinding/
-
Noninterference_Inductive_Unwinding
/theories/noninterference_inductive_unwinding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_inductive_unwinding/
-
Noninterference_Ipurge_Unwinding
/theories/noninterference_ipurge_unwinding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_ipurge_unwinding/
-
Noninterference_Sequential_Composition
/theories/noninterference_sequential_composition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_sequential_composition/
-
NormByEval
/theories/normbyeval/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/normbyeval/
-
Nullstellensatz
/theories/nullstellensatz/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nullstellensatz/
-
Number_Theoretic_Transform
/theories/number_theoretic_transform/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/number_theoretic_transform/
-
Octonions
/theories/octonions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/octonions/
-
Old_Datatype_Show
/theories/old_datatype_show/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/old_datatype_show/
-
Open_Induction
/theories/open_induction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/open_induction/
-
OpSets
/theories/opsets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/opsets/
-
Optics
/theories/optics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/optics/
-
Optimal_BST
/theories/optimal_bst/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/optimal_bst/
-
Orbit_Stabiliser
/theories/orbit_stabiliser/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/orbit_stabiliser/
-
Order_Lattice_Props
/theories/order_lattice_props/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/order_lattice_props/
-
Ordered_Resolution_Prover
/theories/ordered_resolution_prover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordered_resolution_prover/
-
Ordinal
/theories/ordinal/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinal/
-
Ordinal_Partitions
/theories/ordinal_partitions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinal_partitions/
-
Ordinals_and_Cardinals
/theories/ordinals_and_cardinals/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinals_and_cardinals/
-
Ordinary_Differential_Equations
/theories/ordinary_differential_equations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinary_differential_equations/
-
PAC_Checker
/theories/pac_checker/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pac_checker/
-
Package_logic
/theories/package_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/package_logic/
-
Padic_Field
/theories/padic_field/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/padic_field/
-
Padic_Ints
/theories/padic_ints/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/padic_ints/
-
Pairing_Heap
/theories/pairing_heap/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pairing_heap/
-
PAL
/theories/pal/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pal/
-
PAPP_Impossibility
/theories/papp_impossibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/papp_impossibility/
-
Paraconsistency
/theories/paraconsistency/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/paraconsistency/
-
Parity_Game
/theories/parity_game/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/parity_game/
-
Partial_Function_MR
/theories/partial_function_mr/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/partial_function_mr/
-
Partial_Order_Reduction
/theories/partial_order_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/partial_order_reduction/
-
Password_Authentication_Protocol
/theories/password_authentication_protocol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/password_authentication_protocol/
-
PCF
/theories/pcf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pcf/
-
Pell
/theories/pell/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pell/
-
Perfect-Number-Thm
/theories/perfect-number-thm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/perfect-number-thm/
-
Perron_Frobenius
/theories/perron_frobenius/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/perron_frobenius/
-
pGCL
/theories/pgcl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pgcl/
-
Physical_Quantities
/theories/physical_quantities/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/physical_quantities/
-
Pi_Calculus
/theories/pi_calculus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pi_calculus/
-
Pi_Transcendental
/theories/pi_transcendental/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pi_transcendental/
-
Planarity_Certificates
/theories/planarity_certificates/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/planarity_certificates/
-
PLM
/theories/plm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/plm/
-
Pluennecke_Ruzsa_Inequality
/theories/pluennecke_ruzsa_inequality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pluennecke_ruzsa_inequality/
-
Poincare_Bendixson
/theories/poincare_bendixson/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/poincare_bendixson/
-
Poincare_Disc
/theories/poincare_disc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/poincare_disc/
-
Polynomial_Factorization
/theories/polynomial_factorization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/polynomial_factorization/
-
Polynomial_Interpolation
/theories/polynomial_interpolation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/polynomial_interpolation/
-
Polynomials
/theories/polynomials/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/polynomials/
-
Pop_Refinement
/theories/pop_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pop_refinement/
-
POPLmark-deBruijn
/theories/poplmark-debruijn/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/poplmark-debruijn/
-
Posix-Lexing
/theories/posix-lexing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/posix-lexing/
-
Possibilistic_Noninterference
/theories/possibilistic_noninterference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/possibilistic_noninterference/
-
Power_Sum_Polynomials
/theories/power_sum_polynomials/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/power_sum_polynomials/
-
Pratt_Certificate
/theories/pratt_certificate/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pratt_certificate/
-
Prefix_Free_Code_Combinators
/theories/prefix_free_code_combinators/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prefix_free_code_combinators/
-
Presburger-Automata
/theories/presburger-automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/presburger-automata/
-
Prim_Dijkstra_Simple
/theories/prim_dijkstra_simple/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prim_dijkstra_simple/
-
Prime_Distribution_Elementary
/theories/prime_distribution_elementary/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prime_distribution_elementary/
-
Prime_Harmonic_Series
/theories/prime_harmonic_series/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prime_harmonic_series/
-
Prime_Number_Theorem
/theories/prime_number_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prime_number_theorem/
-
Priority_Queue_Braun
/theories/priority_queue_braun/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/priority_queue_braun/
-
Priority_Search_Trees
/theories/priority_search_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/priority_search_trees/
-
Probabilistic_Noninterference
/theories/probabilistic_noninterference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_noninterference/
-
Probabilistic_Prime_Tests
/theories/probabilistic_prime_tests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_prime_tests/
-
Probabilistic_System_Zoo
/theories/probabilistic_system_zoo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_system_zoo/
-
Probabilistic_Timed_Automata
/theories/probabilistic_timed_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_timed_automata/
-
Probabilistic_While
/theories/probabilistic_while/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_while/
-
Probability_Inequality_Completeness
/theories/probability_inequality_completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probability_inequality_completeness/
-
Program-Conflict-Analysis
/theories/program-conflict-analysis/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/program-conflict-analysis/
-
Progress_Tracking
/theories/progress_tracking/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/progress_tracking/
-
Projective_Geometry
/theories/projective_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/projective_geometry/
-
Projective_Measurements
/theories/projective_measurements/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/projective_measurements/
-
Promela
/theories/promela/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/promela/
-
Proof_Strategy_Language
/theories/proof_strategy_language/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/proof_strategy_language/
-
Propositional_Logic_Class
/theories/propositional_logic_class/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/propositional_logic_class/
-
Propositional_Proof_Systems
/theories/propositional_proof_systems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/propositional_proof_systems/
-
PropResPI
/theories/proprespi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/proprespi/
-
Prpu_Maxflow
/theories/prpu_maxflow/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prpu_maxflow/
-
PSemigroupsConvolution
/theories/psemigroupsconvolution/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/psemigroupsconvolution/
-
PseudoHoops
/theories/pseudohoops/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pseudohoops/
-
Psi_Calculi
/theories/psi_calculi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/psi_calculi/
-
Ptolemys_Theorem
/theories/ptolemys_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ptolemys_theorem/
-
Public_Announcement_Logic
/theories/public_announcement_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/public_announcement_logic/
-
QHLProver
/theories/qhlprover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/qhlprover/
-
QR_Decomposition
/theories/qr_decomposition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/qr_decomposition/
-
Quantales
/theories/quantales/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quantales/
-
Quantifier_Elimination_Hybrid
/theories/quantifier_elimination_hybrid/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quantifier_elimination_hybrid/
-
Quasi_Borel_Spaces
/theories/quasi_borel_spaces/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quasi_borel_spaces/
-
Quaternions
/theories/quaternions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quaternions/
-
Query_Optimization
/theories/query_optimization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/query_optimization/
-
Quick_Sort_Cost
/theories/quick_sort_cost/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quick_sort_cost/
-
Ramsey-Infinite
/theories/ramsey-infinite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ramsey-infinite/
-
Random_BSTs
/theories/random_bsts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/random_bsts/
-
Random_Graph_Subgraph_Threshold
/theories/random_graph_subgraph_threshold/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/random_graph_subgraph_threshold/
-
Randomised_BSTs
/theories/randomised_bsts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/randomised_bsts/
-
Randomised_Social_Choice
/theories/randomised_social_choice/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/randomised_social_choice/
-
Rank_Nullity_Theorem
/theories/rank_nullity_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rank_nullity_theorem/
-
Real_Impl
/theories/real_impl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/real_impl/
-
Real_Power
/theories/real_power/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/real_power/
-
Real_Time_Deque
/theories/real_time_deque/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/real_time_deque/
-
Recursion-Addition
/theories/recursion-addition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/recursion-addition/
-
Recursion-Theory-I
/theories/recursion-theory-i/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/recursion-theory-i/
-
Refine_Imperative_HOL
/theories/refine_imperative_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/refine_imperative_hol/
-
Refine_Monadic
/theories/refine_monadic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/refine_monadic/
-
RefinementReactive
/theories/refinementreactive/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/refinementreactive/
-
Regex_Equivalence
/theories/regex_equivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regex_equivalence/
-
Registers
/theories/registers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/registers/
-
Regression_Test_Selection
/theories/regression_test_selection/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regression_test_selection/
-
Regular-Sets
/theories/regular-sets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regular-sets/
-
Regular_Algebras
/theories/regular_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regular_algebras/
-
Regular_Tree_Relations
/theories/regular_tree_relations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regular_tree_relations/
-
Relation_Algebra
/theories/relation_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relation_algebra/
-
Relational-Incorrectness-Logic
/theories/relational-incorrectness-logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational-incorrectness-logic/
-
Relational_Disjoint_Set_Forests
/theories/relational_disjoint_set_forests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_disjoint_set_forests/
-
Relational_Forests
/theories/relational_forests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_forests/
-
Relational_Method
/theories/relational_method/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_method/
-
Relational_Minimum_Spanning_Trees
/theories/relational_minimum_spanning_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_minimum_spanning_trees/
-
Relational_Paths
/theories/relational_paths/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_paths/
-
Rensets
/theories/rensets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rensets/
-
Rep_Fin_Groups
/theories/rep_fin_groups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rep_fin_groups/
-
Residuated_Lattices
/theories/residuated_lattices/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/residuated_lattices/
-
ResiduatedTransitionSystem
/theories/residuatedtransitionsystem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/residuatedtransitionsystem/
-
Resolution_FOL
/theories/resolution_fol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/resolution_fol/
-
Rewrite_Properties_Reduction
/theories/rewrite_properties_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rewrite_properties_reduction/
-
Rewriting_Z
/theories/rewriting_z/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rewriting_z/
-
Ribbon_Proofs
/theories/ribbon_proofs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ribbon_proofs/
-
RIPEMD-160-SPARK
/theories/ripemd-160-spark/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ripemd-160-spark/
-
Risk_Free_Lending
/theories/risk_free_lending/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/risk_free_lending/
-
Robbins-Conjecture
/theories/robbins-conjecture/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/robbins-conjecture/
-
ROBDD
/theories/robdd/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/robdd/
-
Robinson_Arithmetic
/theories/robinson_arithmetic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/robinson_arithmetic/
-
Root_Balanced_Tree
/theories/root_balanced_tree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/root_balanced_tree/
-
Roth_Arithmetic_Progressions
/theories/roth_arithmetic_progressions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/roth_arithmetic_progressions/
-
Routing
/theories/routing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/routing/
-
Roy_Floyd_Warshall
/theories/roy_floyd_warshall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/roy_floyd_warshall/
-
RSAPSS
/theories/rsapss/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rsapss/
-
Safe_Distance
/theories/safe_distance/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/safe_distance/
-
Safe_OCL
/theories/safe_ocl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/safe_ocl/
-
Safe_Range_RC
/theories/safe_range_rc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/safe_range_rc/
-
SATSolverVerification
/theories/satsolververification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/satsolververification/
-
Saturation_Framework
/theories/saturation_framework/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/saturation_framework/
-
Saturation_Framework_Extensions
/theories/saturation_framework_extensions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/saturation_framework_extensions/
-
Sauer_Shelah_Lemma
/theories/sauer_shelah_lemma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sauer_shelah_lemma/
-
SC_DOM_Components
/theories/sc_dom_components/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sc_dom_components/
-
SCC_Bloemen_Sequential
/theories/scc_bloemen_sequential/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/scc_bloemen_sequential/
-
Schutz_Spacetime
/theories/schutz_spacetime/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/schutz_spacetime/
-
Schwartz_Zippel
/theories/schwartz_zippel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/schwartz_zippel/
-
SDS_Impossibility
/theories/sds_impossibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sds_impossibility/
-
Secondary_Sylow
/theories/secondary_sylow/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/secondary_sylow/
-
Security_Protocol_Refinement
/theories/security_protocol_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/security_protocol_refinement/
-
Selection_Heap_Sort
/theories/selection_heap_sort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/selection_heap_sort/
-
SenSocialChoice
/theories/sensocialchoice/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sensocialchoice/
-
Separata
/theories/separata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separata/
-
Separation_Algebra
/theories/separation_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separation_algebra/
-
Separation_Logic_Imperative_HOL
/theories/separation_logic_imperative_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separation_logic_imperative_hol/
-
Separation_Logic_Unbounded
/theories/separation_logic_unbounded/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separation_logic_unbounded/
-
Sepref_Basic
/theories/sepref_basic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sepref_basic/
-
Sepref_IICF
/theories/sepref_iicf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sepref_iicf/
-
Sepref_Prereq
/theories/sepref_prereq/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sepref_prereq/
-
SequentInvertibility
/theories/sequentinvertibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sequentinvertibility/
-
Shadow_DOM
/theories/shadow_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shadow_dom/
-
Shadow_SC_DOM
/theories/shadow_sc_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shadow_sc_dom/
-
Shivers-CFA
/theories/shivers-cfa/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shivers-cfa/
-
ShortestPath
/theories/shortestpath/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shortestpath/
-
Show
/theories/show/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/show/
-
SIFPL
/theories/sifpl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sifpl/
-
SIFUM_Type_Systems
/theories/sifum_type_systems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sifum_type_systems/
-
Sigma_Commit_Crypto
/theories/sigma_commit_crypto/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sigma_commit_crypto/
-
Signature_Groebner
/theories/signature_groebner/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/signature_groebner/
-
Simpl
/theories/simpl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simpl/
-
Simple_Clause_Learning
/theories/simple_clause_learning/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simple_clause_learning/
-
Simple_Firewall
/theories/simple_firewall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simple_firewall/
-
Simplex
/theories/simplex/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simplex/
-
Simplicial_complexes_and_boolean_functions
/theories/simplicial_complexes_and_boolean_functions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simplicial_complexes_and_boolean_functions/
-
SimplifiedOntologicalArgument
/theories/simplifiedontologicalargument/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simplifiedontologicalargument/
-
Skew_Heap
/theories/skew_heap/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/skew_heap/
-
Skip_Lists
/theories/skip_lists/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/skip_lists/
-
Slicing
/theories/slicing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/slicing/
-
Sliding_Window_Algorithm
/theories/sliding_window_algorithm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sliding_window_algorithm/
-
SM
/theories/sm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sm/
-
SM_Base
/theories/sm_base/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sm_base/
-
Smith_Normal_Form
/theories/smith_normal_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/smith_normal_form/
-
Smooth_Manifolds
/theories/smooth_manifolds/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/smooth_manifolds/
-
Solidity
/theories/solidity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/solidity/
-
Sophomores_Dream
/theories/sophomores_dream/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sophomores_dream/
-
Sort_Encodings
/theories/sort_encodings/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sort_encodings/
-
Source_Coding_Theorem
/theories/source_coding_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/source_coding_theorem/
-
SPARCv8
/theories/sparcv8/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sparcv8/
-
SpecCheck
/theories/speccheck/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/speccheck/
-
Special_Function_Bounds
/theories/special_function_bounds/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/special_function_bounds/
-
Splay_Tree
/theories/splay_tree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/splay_tree/
-
Sqrt_Babylonian
/theories/sqrt_babylonian/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sqrt_babylonian/
-
Stable_Matching
/theories/stable_matching/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stable_matching/
-
Stalnaker_Logic
/theories/stalnaker_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stalnaker_logic/
-
Statecharts
/theories/statecharts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/statecharts/
-
Stateful_Protocol_Composition_and_Typing
/theories/stateful_protocol_composition_and_typing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stateful_protocol_composition_and_typing/
-
Stellar_Quorums
/theories/stellar_quorums/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stellar_quorums/
-
Stern_Brocot
/theories/stern_brocot/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stern_brocot/
-
Stewart_Apollonius
/theories/stewart_apollonius/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stewart_apollonius/
-
Stirling_Formula
/theories/stirling_formula/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stirling_formula/
-
Stochastic_Matrices
/theories/stochastic_matrices/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stochastic_matrices/
-
Stone_Algebras
/theories/stone_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stone_algebras/
-
Stone_Kleene_Relation_Algebras
/theories/stone_kleene_relation_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stone_kleene_relation_algebras/
-
Stone_Relation_Algebras
/theories/stone_relation_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stone_relation_algebras/
-
Store_Buffer_Reduction
/theories/store_buffer_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/store_buffer_reduction/
-
Stream-Fusion
/theories/stream-fusion/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stream-fusion/
-
Stream_Fusion_Code
/theories/stream_fusion_code/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stream_fusion_code/
-
StrictOmegaCategories
/theories/strictomegacategories/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/strictomegacategories/
-
Strong_Security
/theories/strong_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/strong_security/
-
Sturm_Sequences
/theories/sturm_sequences/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sturm_sequences/
-
Sturm_Tarski
/theories/sturm_tarski/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sturm_tarski/
-
Stuttering_Equivalence
/theories/stuttering_equivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stuttering_equivalence/
-
Subresultants
/theories/subresultants/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/subresultants/
-
Subset_Boolean_Algebras
/theories/subset_boolean_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/subset_boolean_algebras/
-
SumSquares
/theories/sumsquares/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sumsquares/
-
Sunflowers
/theories/sunflowers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sunflowers/
-
SuperCalc
/theories/supercalc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/supercalc/
-
Suppes_Theorem
/theories/suppes_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/suppes_theorem/
-
Surprise_Paradox
/theories/surprise_paradox/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/surprise_paradox/
-
Symmetric_Polynomials
/theories/symmetric_polynomials/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/symmetric_polynomials/
-
Syntax_Independent_Logic
/theories/syntax_independent_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/syntax_independent_logic/
-
Synthetic_Completeness
/theories/synthetic_completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/synthetic_completeness/
-
Szemeredi_Regularity
/theories/szemeredi_regularity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/szemeredi_regularity/
-
Szpilrajn
/theories/szpilrajn/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/szpilrajn/
-
Tail_Recursive_Functions
/theories/tail_recursive_functions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tail_recursive_functions/
-
Tarskis_Geometry
/theories/tarskis_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tarskis_geometry/
-
Taylor_Models
/theories/taylor_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/taylor_models/
-
TESL_Language
/theories/tesl_language/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tesl_language/
-
Three_Circles
/theories/three_circles/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/three_circles/
-
Three_Squares
/theories/three_squares/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/three_squares/
-
Timed_Automata
/theories/timed_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/timed_automata/
-
TLA
/theories/tla/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tla/
-
Topological_Semantics
/theories/topological_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/topological_semantics/
-
Topology
/theories/topology/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/topology/
-
TortoiseHare
/theories/tortoisehare/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tortoisehare/
-
Transcendence_Series_Hancl_Rucki
/theories/transcendence_series_hancl_rucki/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transcendence_series_hancl_rucki/
-
Transformer_Semantics
/theories/transformer_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transformer_semantics/
-
Transition_Systems_and_Automata
/theories/transition_systems_and_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transition_systems_and_automata/
-
Transitive-Closure
/theories/transitive-closure/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transitive-closure/
-
Transitive-Closure-II
/theories/transitive-closure-ii/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transitive-closure-ii/
-
Transitive_Models
/theories/transitive_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transitive_models/
-
Treaps
/theories/treaps/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/treaps/
-
Tree-Automata
/theories/tree-automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tree-automata/
-
Tree_Decomposition
/theories/tree_decomposition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tree_decomposition/
-
Tree_Enumeration
/theories/tree_enumeration/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tree_enumeration/
-
Triangle
/theories/triangle/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/triangle/
-
Trie
/theories/trie/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/trie/
-
TsirelsonBound
/theories/tsirelsonbound/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tsirelsonbound/
-
Turans_Graph_Theorem
/theories/turans_graph_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/turans_graph_theorem/
-
Twelvefold_Way
/theories/twelvefold_way/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/twelvefold_way/
-
Two_Generated_Word_Monoids_Intersection
/theories/two_generated_word_monoids_intersection/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/two_generated_word_monoids_intersection/
-
Tycon
/theories/tycon/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tycon/
-
Types_Tableaus_and_Goedels_God
/theories/types_tableaus_and_goedels_god/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/types_tableaus_and_goedels_god/
-
Types_To_Sets_Extension
/theories/types_to_sets_extension/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/types_to_sets_extension/
-
Undirected_Graph_Theory
/theories/undirected_graph_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/undirected_graph_theory/
-
Universal_Hash_Families
/theories/universal_hash_families/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/universal_hash_families/
-
Universal_Turing_Machine
/theories/universal_turing_machine/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/universal_turing_machine/
-
UpDown_Scheme
/theories/updown_scheme/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/updown_scheme/
-
UPF
/theories/upf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/upf/
-
UPF_Firewall
/theories/upf_firewall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/upf_firewall/
-
UTP
/theories/utp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/utp/
-
UTP-Toolkit
/theories/utp-toolkit/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/utp-toolkit/
-
Valuation
/theories/valuation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/valuation/
-
Van_der_Waerden
/theories/van_der_waerden/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/van_der_waerden/
-
Van_Emde_Boas_Trees
/theories/van_emde_boas_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/van_emde_boas_trees/
-
VectorSpace
/theories/vectorspace/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vectorspace/
-
VeriComp
/theories/vericomp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vericomp/
-
Verified-Prover
/theories/verified-prover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verified-prover/
-
Verified_SAT_Based_AI_Planning
/theories/verified_sat_based_ai_planning/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verified_sat_based_ai_planning/
-
VerifyThis2018
/theories/verifythis2018/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verifythis2018/
-
VerifyThis2019
/theories/verifythis2019/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verifythis2019/
-
Vickrey_Clarke_Groves
/theories/vickrey_clarke_groves/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vickrey_clarke_groves/
-
Virtual_Substitution
/theories/virtual_substitution/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/virtual_substitution/
-
VolpanoSmith
/theories/volpanosmith/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/volpanosmith/
-
VYDRA_MDL
/theories/vydra_mdl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vydra_mdl/
-
WebAssembly
/theories/webassembly/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/webassembly/
-
Weight_Balanced_Trees
/theories/weight_balanced_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/weight_balanced_trees/
-
Weighted_Arithmetic_Geometric_Mean
/theories/weighted_arithmetic_geometric_mean/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/weighted_arithmetic_geometric_mean/
-
Weighted_Path_Order
/theories/weighted_path_order/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/weighted_path_order/
-
Well_Quasi_Orders
/theories/well_quasi_orders/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/well_quasi_orders/
-
Wetzels_Problem
/theories/wetzels_problem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/wetzels_problem/
-
WHATandWHERE_Security
/theories/whatandwhere_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/whatandwhere_security/
-
Winding_Number_Eval
/theories/winding_number_eval/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/winding_number_eval/
-
WOOT_Strong_Eventual_Consistency
/theories/woot_strong_eventual_consistency/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/woot_strong_eventual_consistency/
-
Word_Lib
/theories/word_lib/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/word_lib/
-
WorkerWrapper
/theories/workerwrapper/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/workerwrapper/
-
X86_Semantics
/theories/x86_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/x86_semantics/
-
XML
/theories/xml/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/xml/
-
Youngs_Inequality
/theories/youngs_inequality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/youngs_inequality/
-
Zeckendorf
/theories/zeckendorf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zeckendorf/
-
Zeta_3_Irrational
/theories/zeta_3_irrational/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zeta_3_irrational/
-
Zeta_Function
/theories/zeta_function/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zeta_function/
-
ZFC_in_HOL
/theories/zfc_in_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zfc_in_hol/
diff --git a/web/sitemap.xml b/web/sitemap.xml
--- a/web/sitemap.xml
+++ b/web/sitemap.xml
@@ -1,6303 +1,6305 @@
/
2023-07-11T00:00:00+00:00
/authors/
2023-07-11T00:00:00+00:00
/topics/computer-science/
2023-07-11T00:00:00+00:00
/entries/
2023-07-11T00:00:00+00:00
/entries/Gray_Codes.html
2023-07-11T00:00:00+00:00
/topics/mathematics/
2023-07-11T00:00:00+00:00
/authors/spitz/
2023-07-11T00:00:00+00:00
/topics/
2023-07-11T00:00:00+00:00
/dependencies/
2023-06-19T00:00:00+00:00
/authors/eberl/
2023-06-19T00:00:00+00:00
/entries/Executable_Randomized_Algorithms.html
2023-06-19T00:00:00+00:00
/authors/karayel/
2023-06-19T00:00:00+00:00
/dependencies/probabilistic_while/
2023-06-19T00:00:00+00:00
/dependencies/zeta_function/
2023-06-19T00:00:00+00:00
/authors/christfort/
2023-06-16T00:00:00+00:00
/entries/DCR-ExecutionEquivalence.html
2023-06-16T00:00:00+00:00
/authors/debois/
2023-06-16T00:00:00+00:00
/authors/dalvit/
2023-06-12T00:00:00+00:00
/entries/Zeckendorf.html
2023-06-12T00:00:00+00:00
/entries/Crypto_Standards.html
2023-06-06T00:00:00+00:00
/dependencies/elliptic_curves_group_law/
2023-06-06T00:00:00+00:00
/authors/whitley/
2023-06-06T00:00:00+00:00
/entries/Efficient_Weighted_Path_Order.html
2023-06-01T00:00:00+00:00
/topics/logic/
2023-06-01T00:00:00+00:00
/authors/thiemann/
2023-06-01T00:00:00+00:00
/dependencies/weighted_path_order/
2023-06-01T00:00:00+00:00
/authors/wenninger/
2023-06-01T00:00:00+00:00
/dependencies/complete_non_orders/
2023-05-24T00:00:00+00:00
/authors/dubut/
2023-05-24T00:00:00+00:00
/entries/Directed_Sets.html
2023-05-24T00:00:00+00:00
/authors/yamada/
2023-05-24T00:00:00+00:00
/authors/guttmann/
2023-05-22T00:00:00+00:00
/entries/Multirelations_Heterogeneous.html
2023-05-22T00:00:00+00:00
/authors/struth/
2023-05-22T00:00:00+00:00
/authors/cremer/
2023-05-09T00:00:00+00:00
/entries/Tree_Enumeration.html
2023-05-09T00:00:00+00:00
/dependencies/undirected_graph_theory/
2023-05-09T00:00:00+00:00
/dependencies/fresh_identifiers/
2023-05-05T00:00:00+00:00
/dependencies/graph_theory/
2023-05-05T00:00:00+00:00
/dependencies/hereditarilyfinite/
2023-05-05T00:00:00+00:00
/dependencies/list-index/
2023-05-05T00:00:00+00:00
/entries/MLSS_Decision_Proc.html
2023-05-05T00:00:00+00:00
/authors/stevens/
2023-05-05T00:00:00+00:00
/authors/chevalier/
2023-05-03T00:00:00+00:00
/authors/danilkin/
2023-05-03T00:00:00+00:00
/dependencies/dirichlet_l/
2023-05-03T00:00:00+00:00
/entries/Three_Squares.html
2023-05-03T00:00:00+00:00
/authors/stannett/
2023-04-29T00:00:00+00:00
/entries/MHComputation.html
2023-04-29T00:00:00+00:00
/dependencies/factor_algebraic_polynomial/
2023-04-27T00:00:00+00:00
/dependencies/jordan_normal_form/
2023-04-27T00:00:00+00:00
/authors/kim/
2023-04-27T00:00:00+00:00
/dependencies/skip_lists/
2023-04-27T00:00:00+00:00
/authors/tan/
2023-04-27T00:00:00+00:00
/entries/Schwartz_Zippel.html
2023-04-27T00:00:00+00:00
/entries/Simple_Clause_Learning.html
2023-04-20T00:00:00+00:00
/authors/desharnais/
2023-04-20T00:00:00+00:00
/dependencies/first_order_terms/
2023-04-20T00:00:00+00:00
/dependencies/functional_ordered_resolution_prover/
2023-04-20T00:00:00+00:00
/dependencies/ordered_resolution_prover/
2023-04-20T00:00:00+00:00
/dependencies/saturation_framework/
2023-04-20T00:00:00+00:00
/dependencies/saturation_framework_extensions/
2023-04-20T00:00:00+00:00
/dependencies/commuting_hermitian/
2023-04-18T00:00:00+00:00
/authors/echenim/
2023-04-18T00:00:00+00:00
/authors/mhalla/
2023-04-18T00:00:00+00:00
/authors/mori/
2023-04-18T00:00:00+00:00
/entries/TsirelsonBound.html
2023-04-18T00:00:00+00:00
/authors/dardinier/
2023-04-03T00:00:00+00:00
/dependencies/discrete_summation/
2023-04-03T00:00:00+00:00
/entries/Distributed_Distinct_Elements.html
2023-04-03T00:00:00+00:00
/dependencies/expander_graphs/
2023-04-03T00:00:00+00:00
/entries/HyperHoareLogic.html
2023-04-03T00:00:00+00:00
/entries/DigitsInBase.html
2023-04-03T00:00:00+00:00
/authors/staats/
2023-04-03T00:00:00+00:00
/dependencies/stirling_formula/
2023-04-03T00:00:00+00:00
/entries/CommCSL.html
2023-03-15T00:00:00+00:00
/authors/andreka/
2023-03-05T00:00:00+00:00
/authors/higgins/
2023-03-05T00:00:00+00:00
/authors/madarasz/
2023-03-05T00:00:00+00:00
/authors/nemeti/
2023-03-05T00:00:00+00:00
/entries/No_FTL_observers_Gen_Rel.html
2023-03-05T00:00:00+00:00
/authors/szekely/
2023-03-05T00:00:00+00:00
/entries/Expander_Graphs.html
2023-03-03T00:00:00+00:00
/dependencies/frequency_moments/
2023-03-03T00:00:00+00:00
/dependencies/perron_frobenius/
2023-03-03T00:00:00+00:00
/dependencies/weighted_arithmetic_geometric_mean/
2023-03-03T00:00:00+00:00
/authors/popescu/
2023-02-28T00:00:00+00:00
/entries/Rensets.html
2023-02-28T00:00:00+00:00
/entries/Probability_Inequality_Completeness.html
2023-02-20T00:00:00+00:00
/authors/doty/
2023-02-20T00:00:00+00:00
/dependencies/suppes_theorem/
2023-02-20T00:00:00+00:00
/entries/Edwards_Elliptic_Curves_Group.html
2023-02-16T00:00:00+00:00
/authors/raya/
2023-02-16T00:00:00+00:00
/dependencies/benor_kozen_reif/
2023-02-02T00:00:00+00:00
/dependencies/berlekamp_zassenhaus/
2023-02-02T00:00:00+00:00
/entries/CVP_Hardness.html
2023-02-02T00:00:00+00:00
/authors/kreuzer/
2023-02-02T00:00:00+00:00
/dependencies/lll_basis_reduction/
2023-02-02T00:00:00+00:00
/entries/ABY3_Protocols.html
2023-01-27T00:00:00+00:00
/dependencies/crypthol/
2023-01-27T00:00:00+00:00
/authors/hu/
2023-01-27T00:00:00+00:00
/authors/blanchette/
2023-01-25T00:00:00+00:00
/entries/Given_Clause_Loops.html
2023-01-25T00:00:00+00:00
/authors/qiu/
2023-01-25T00:00:00+00:00
/authors/tourret/
2023-01-25T00:00:00+00:00
/dependencies/propositional_logic_class/
2023-01-22T00:00:00+00:00
/entries/Suppes_Theorem.html
2023-01-22T00:00:00+00:00
/entries/HoareForDivergence.html
2023-01-20T00:00:00+00:00
/dependencies/coinductive/
2023-01-20T00:00:00+00:00
/authors/myreen/
2023-01-20T00:00:00+00:00
/authors/pohjola/
2023-01-20T00:00:00+00:00
/authors/tanaka/
2023-01-20T00:00:00+00:00
/authors/bordg/
2023-01-14T00:00:00+00:00
/authors/mateo/
2023-01-14T00:00:00+00:00
/entries/StrictOmegaCategories.html
2023-01-14T00:00:00+00:00
/authors/from/
2023-01-09T00:00:00+00:00
/entries/Synthetic_Completeness.html
2023-01-09T00:00:00+00:00
/authors/balbach/
2023-01-08T00:00:00+00:00
/entries/Cook_Levin.html
2023-01-08T00:00:00+00:00
/entries/Binary_Code_Imprimitive.html
2023-01-03T00:00:00+00:00
/dependencies/combinatorics_words/
2023-01-03T00:00:00+00:00
/dependencies/combinatorics_words_graph_lemma/
2023-01-03T00:00:00+00:00
/authors/holub/
2023-01-03T00:00:00+00:00
/entries/Two_Generated_Word_Monoids_Intersection.html
2023-01-03T00:00:00+00:00
/authors/raska/
2023-01-03T00:00:00+00:00
/authors/starosta/
2023-01-03T00:00:00+00:00
/entries/Quantifier_Elimination_Hybrid.html
2022-12-15T00:00:00+00:00
/dependencies/algebraic_numbers/
2022-12-15T00:00:00+00:00
/entries/Propositional_Logic_Class.html
2022-12-15T00:00:00+00:00
/authors/cordwell/
2022-12-15T00:00:00+00:00
/dependencies/datatype_order_generator/
2022-12-15T00:00:00+00:00
/dependencies/descartes_sign_rule/
2022-12-15T00:00:00+00:00
/authors/platzer/
2022-12-15T00:00:00+00:00
/dependencies/polynomial_interpolation/
2022-12-15T00:00:00+00:00
/dependencies/virtual_substitution/
2022-12-15T00:00:00+00:00
/entries/Birkhoff_Finite_Distributive_Lattices.html
2022-12-06T00:00:00+00:00
/entries/Boolos_Curious_Inference_Automated.html
2022-12-05T00:00:00+00:00
/authors/benzmueller/
2022-12-05T00:00:00+00:00
/authors/fuenmayor/
2022-12-05T00:00:00+00:00
/authors/steen/
2022-12-05T00:00:00+00:00
/authors/sutcliffe/
2022-12-05T00:00:00+00:00
/topics/tools/
2022-12-05T00:00:00+00:00
/entries/Multitape_To_Singletape_TM.html
2022-11-30T00:00:00+00:00
/entries/AOT.html
2022-11-28T00:00:00+00:00
/authors/kirchner/
2022-11-28T00:00:00+00:00
/entries/CHERI-C_Memory_Model.html
2022-11-25T00:00:00+00:00
/dependencies/containers/
2022-11-25T00:00:00+00:00
/authors/park/
2022-11-25T00:00:00+00:00
/dependencies/separation_algebra/
2022-11-25T00:00:00+00:00
/dependencies/word_lib/
2022-11-25T00:00:00+00:00
/authors/keskin/
2022-11-24T00:00:00+00:00
/entries/Sauer_Shelah_Lemma.html
2022-11-24T00:00:00+00:00
/authors/argyraki/
2022-11-21T00:00:00+00:00
/authors/baksys/
2022-11-21T00:00:00+00:00
/dependencies/jacobson_basic_algebra/
2022-11-21T00:00:00+00:00
/entries/Kneser_Cauchy_Davenport.html
2022-11-21T00:00:00+00:00
/dependencies/pluennecke_ruzsa_inequality/
2022-11-21T00:00:00+00:00
/dependencies/girth_chromatic/
2022-11-14T00:00:00+00:00
/authors/lauermann/
2022-11-14T00:00:00+00:00
/dependencies/random_graph_subgraph_threshold/
2022-11-14T00:00:00+00:00
/entries/Turans_Graph_Theorem.html
2022-11-14T00:00:00+00:00
/dependencies/card_number_partitions/
2022-11-11T00:00:00+00:00
/entries/Combinatorial_Enumeration_Algorithms.html
2022-11-11T00:00:00+00:00
/authors/edmonds/
2022-11-11T00:00:00+00:00
/dependencies/falling_factorial_sum/
2022-11-11T00:00:00+00:00
/authors/hofmeier/
2022-11-11T00:00:00+00:00
/entries/Balog_Szemeredi_Gowers.html
2022-11-11T00:00:00+00:00
/authors/delemazure/
2022-11-10T00:00:00+00:00
/authors/demeulemeester/
2022-11-10T00:00:00+00:00
/authors/israel/
2022-11-10T00:00:00+00:00
/authors/lederer/
2022-11-10T00:00:00+00:00
/dependencies/randomised_social_choice/
2022-11-10T00:00:00+00:00
/entries/PAPP_Impossibility.html
2022-11-10T00:00:00+00:00
/authors/stoeckl/
2022-10-04T00:00:00+00:00
/entries/Query_Optimization.html
2022-10-04T00:00:00+00:00
/dependencies/design_theory/
2022-09-29T00:00:00+00:00
/entries/Maximum_Segment_Sum.html
2022-09-29T00:00:00+00:00
/entries/Undirected_Graph_Theory.html
2022-09-29T00:00:00+00:00
/dependencies/collections/
2022-09-28T00:00:00+00:00
/dependencies/deriving/
2022-09-28T00:00:00+00:00
/entries/Safe_Range_RC.html
2022-09-28T00:00:00+00:00
/authors/raszyk/
2022-09-28T00:00:00+00:00
/authors/traytel/
2022-09-28T00:00:00+00:00
/dependencies/epistemic_logic/
2022-09-23T00:00:00+00:00
/authors/guzman/
2022-09-23T00:00:00+00:00
/entries/Stalnaker_Logic.html
2022-09-23T00:00:00+00:00
/authors/crighton/
2022-09-22T00:00:00+00:00
/dependencies/localization_ring/
2022-09-22T00:00:00+00:00
/entries/Padic_Field.html
2022-09-22T00:00:00+00:00
/dependencies/padic_ints/
2022-09-22T00:00:00+00:00
/entries/Risk_Free_Lending.html
2022-09-18T00:00:00+00:00
/entries/Implicational_Logic.html
2022-09-13T00:00:00+00:00
/authors/villadsen/
2022-09-13T00:00:00+00:00
/entries/CRYSTALS-Kyber.html
2022-09-08T00:00:00+00:00
/dependencies/number_theoretic_transform/
2022-09-08T00:00:00+00:00
/entries/Separation_Logic_Unbounded.html
2022-09-05T00:00:00+00:00
/dependencies/bernoulli/
2022-09-02T00:00:00+00:00
/entries/Khovanskii_Theorem.html
2022-09-02T00:00:00+00:00
/authors/paulson/
2022-09-02T00:00:00+00:00
/authors/sulejmani/
2022-09-02T00:00:00+00:00
/entries/Hales_Jewett.html
2022-09-02T00:00:00+00:00
/authors/ammer/
2022-08-18T00:00:00+00:00
/entries/Number_Theoretic_Transform.html
2022-08-18T00:00:00+00:00
/entries/SCC_Bloemen_Sequential.html
2022-08-17T00:00:00+00:00
/authors/merz/
2022-08-17T00:00:00+00:00
/authors/trelat/
2022-08-17T00:00:00+00:00
/authors/bortin/
2022-08-15T00:00:00+00:00
/entries/Involutions2Squares.html
2022-08-15T00:00:00+00:00
/dependencies/native_word/
2022-08-09T00:00:00+00:00
/authors/sachtleben/
2022-08-09T00:00:00+00:00
/entries/FSM_Tests.html
2022-08-09T00:00:00+00:00
/authors/brucker/
2022-07-29T00:00:00+00:00
/entries/Nano_JSON.html
2022-07-29T00:00:00+00:00
/dependencies/finite-map-extras/
2022-07-18T00:00:00+00:00
/entries/Solidity.html
2022-07-18T00:00:00+00:00
/authors/marmsoler/
2022-07-18T00:00:00+00:00
/dependencies/projective_measurements/
2022-07-18T00:00:00+00:00
/entries/Commuting_Hermitian.html
2022-07-18T00:00:00+00:00
/entries/Weighted_Arithmetic_Geometric_Mean.html
2022-07-11T00:00:00+00:00
/entries/IMP_Compiler_Reuse.html
2022-07-10T00:00:00+00:00
/authors/noce/
2022-07-10T00:00:00+00:00
/authors/nipkow/
2022-06-23T00:00:00+00:00
/entries/Real_Time_Deque.html
2022-06-23T00:00:00+00:00
/authors/toth/
2022-06-23T00:00:00+00:00
/entries/Boolos_Curious_Inference.html
2022-06-20T00:00:00+00:00
/authors/ketland/
2022-06-20T00:00:00+00:00
/dependencies/dirichlet_series/
2022-06-08T00:00:00+00:00
/entries/Finite_Fields.html
2022-06-08T00:00:00+00:00
/entries/IsaNet.html
2022-06-08T00:00:00+00:00
/authors/klenze/
2022-06-08T00:00:00+00:00
/authors/sprenger/
2022-06-08T00:00:00+00:00
/authors/bayer/
2022-06-06T00:00:00+00:00
/authors/david/
2022-06-06T00:00:00+00:00
/dependencies/digit_expansions/
2022-06-06T00:00:00+00:00
/entries/DPRM_Theorem.html
2022-06-06T00:00:00+00:00
/dependencies/lucas_theorem/
2022-06-06T00:00:00+00:00
/authors/matiyasevich/
2022-06-06T00:00:00+00:00
/authors/pal/
2022-06-06T00:00:00+00:00
/authors/schleicher/
2022-06-06T00:00:00+00:00
/authors/stock/
2022-06-06T00:00:00+00:00
/authors/lochmann/
2022-06-02T00:00:00+00:00
/entries/Rewrite_Properties_Reduction.html
2022-06-02T00:00:00+00:00
/dependencies/regular_tree_relations/
2022-06-02T00:00:00+00:00
/entries/Combinable_Wands.html
2022-05-30T00:00:00+00:00
/dependencies/package_logic/
2022-05-30T00:00:00+00:00
/entries/Pluennecke_Ruzsa_Inequality.html
2022-05-26T00:00:00+00:00
/entries/Package_logic.html
2022-05-18T00:00:00+00:00
/entries/Clique_and_Monotone_Circuits.html
2022-05-08T00:00:00+00:00
/dependencies/sunflowers/
2022-05-08T00:00:00+00:00
/entries/Fishers_Inequality.html
2022-04-21T00:00:00+00:00
/dependencies/groebner_bases/
2022-04-21T00:00:00+00:00
/dependencies/polynomial_factorization/
2022-04-21T00:00:00+00:00
/entries/Digit_Expansions.html
2022-04-20T00:00:00+00:00
/authors/schmidinger/
2022-04-20T00:00:00+00:00
/entries/Multiset_Ordering_NPC.html
2022-04-20T00:00:00+00:00
/entries/Sophomores_Dream.html
2022-04-10T00:00:00+00:00
/entries/Prefix_Free_Code_Combinators.html
2022-04-08T00:00:00+00:00
/dependencies/bertrands_postulate/
2022-04-08T00:00:00+00:00
/dependencies/equivalence_relation_enumeration/
2022-04-08T00:00:00+00:00
/entries/Frequency_Moments.html
2022-04-08T00:00:00+00:00
/dependencies/interpolation_polynomials_hol_algebra/
2022-04-08T00:00:00+00:00
/dependencies/lp/
2022-04-08T00:00:00+00:00
/dependencies/median_method/
2022-04-08T00:00:00+00:00
/dependencies/prefix_free_code_combinators/
2022-04-08T00:00:00+00:00
/dependencies/universal_hash_families/
2022-04-08T00:00:00+00:00
/entries/Dedekind_Real.html
2022-03-24T00:00:00+00:00
/authors/fleuriot/
2022-03-24T00:00:00+00:00
/entries/Ackermanns_not_PR.html
2022-03-23T00:00:00+00:00
/entries/FOL_Seq_Calc3.html
2022-03-22T00:00:00+00:00
/dependencies/abstract_completeness/
2022-03-22T00:00:00+00:00
/dependencies/abstract_soundness/
2022-03-22T00:00:00+00:00
/entries/Cotangent_PFD_Formula.html
2022-03-15T00:00:00+00:00
/authors/gunther/
2022-03-06T00:00:00+00:00
/authors/pagano/
2022-03-06T00:00:00+00:00
/authors/steinberg/
2022-03-06T00:00:00+00:00
/authors/terraf/
2022-03-06T00:00:00+00:00
/entries/Independence_CH.html
2022-03-06T00:00:00+00:00
/dependencies/transitive_models/
2022-03-06T00:00:00+00:00
/dependencies/delta_system_lemma/
2022-03-03T00:00:00+00:00
/entries/Transitive_Models.html
2022-03-03T00:00:00+00:00
/entries/ResiduatedTransitionSystem.html
2022-02-28T00:00:00+00:00
/authors/stark/
2022-02-28T00:00:00+00:00
/dependencies/finite_fields/
2022-02-20T00:00:00+00:00
/entries/Universal_Hash_Families.html
2022-02-20T00:00:00+00:00
/entries/Wetzels_Problem.html
2022-02-18T00:00:00+00:00
/dependencies/zfc_in_hol/
2022-02-18T00:00:00+00:00
/entries/Eval_FO.html
2022-02-15T00:00:00+00:00
/entries/VYDRA_MDL.html
2022-02-13T00:00:00+00:00
/dependencies/card_equiv_relations/
2022-02-04T00:00:00+00:00
/entries/Equivalence_Relation_Enumeration.html
2022-02-04T00:00:00+00:00
/entries/LP_Duality.html
2022-02-03T00:00:00+00:00
/authors/hirata/
2022-02-03T00:00:00+00:00
/dependencies/linear_inequalities/
2022-02-03T00:00:00+00:00
/authors/minamide/
2022-02-03T00:00:00+00:00
/entries/Quasi_Borel_Spaces.html
2022-02-03T00:00:00+00:00
/authors/sato/
2022-02-03T00:00:00+00:00
/authors/felgenhauer/
2022-02-02T00:00:00+00:00
/entries/FO_Theory_Rewriting.html
2022-02-02T00:00:00+00:00
/dependencies/fol-fitting/
2022-02-02T00:00:00+00:00
/entries/FOL_Seq_Calc2.html
2022-01-31T00:00:00+00:00
/dependencies/fol_seq_calc1/
2022-01-31T00:00:00+00:00
/authors/jacobsen/
2022-01-31T00:00:00+00:00
/entries/Youngs_Inequality.html
2022-01-31T00:00:00+00:00
/entries/Interpolation_Polynomials_HOL_Algebra.html
2022-01-29T00:00:00+00:00
/entries/Median_Method.html
2022-01-25T00:00:00+00:00
/entries/Actuarial_Mathematics.html
2022-01-23T00:00:00+00:00
/authors/ito/
2022-01-23T00:00:00+00:00
/entries/Irrationals_From_THEBOOK.html
2022-01-08T00:00:00+00:00
/entries/Knights_Tour.html
2022-01-04T00:00:00+00:00
/authors/koller/
2022-01-04T00:00:00+00:00
/entries/Hyperdual.html
2021-12-31T00:00:00+00:00
/authors/smola/
2021-12-31T00:00:00+00:00
/entries/Gale_Shapley.html
2021-12-29T00:00:00+00:00
/dependencies/ergodic_theory/
2021-12-28T00:00:00+00:00
/entries/Roth_Arithmetic_Progressions.html
2021-12-28T00:00:00+00:00
/dependencies/szemeredi_regularity/
2021-12-28T00:00:00+00:00
/authors/abdulaziz/
2021-12-16T00:00:00+00:00
/dependencies/gauss_jordan/
2021-12-16T00:00:00+00:00
/entries/MDP-Rewards.html
2021-12-16T00:00:00+00:00
/dependencies/mdp-rewards/
2021-12-16T00:00:00+00:00
/authors/schaeffeler/
2021-12-16T00:00:00+00:00
/entries/MDP-Algorithms.html
2021-12-16T00:00:00+00:00
/dependencies/knuth_bendix_order/
2021-12-15T00:00:00+00:00
/entries/Regular_Tree_Relations.html
2021-12-15T00:00:00+00:00
/authors/sternagel/
2021-12-15T00:00:00+00:00
/authors/sternagelt/
2021-12-15T00:00:00+00:00
/authors/aransay/
2021-11-29T00:00:00+00:00
/authors/campo/
2021-11-29T00:00:00+00:00
/authors/michaelis/
2021-11-29T00:00:00+00:00
/dependencies/robdd/
2021-11-29T00:00:00+00:00
/dependencies/sepref_prereq/
2021-11-29T00:00:00+00:00
/entries/Simplicial_complexes_and_boolean_functions.html
2021-11-29T00:00:00+00:00
/dependencies/automatic_refinement/
2021-11-23T00:00:00+00:00
/authors/lammich/
2021-11-23T00:00:00+00:00
/entries/Van_Emde_Boas_Trees.html
2021-11-23T00:00:00+00:00
/entries/Foundation_of_geometry.html
2021-11-22T00:00:00+00:00
/authors/iwama/
2021-11-22T00:00:00+00:00
/authors/cousin/
2021-11-19T00:00:00+00:00
/authors/guiol/
2021-11-19T00:00:00+00:00
/entries/Hahn_Jordan_Decomposition.html
2021-11-19T00:00:00+00:00
/entries/PAL.html
2021-11-08T00:00:00+00:00
/entries/SimplifiedOntologicalArgument.html
2021-11-08T00:00:00+00:00
/entries/Factor_Algebraic_Polynomial.html
2021-11-08T00:00:00+00:00
/dependencies/hermite_lindemann/
2021-11-08T00:00:00+00:00
/dependencies/polynomials/
2021-11-08T00:00:00+00:00
/entries/Real_Power.html
2021-11-08T00:00:00+00:00
/authors/reiche/
2021-11-08T00:00:00+00:00
/entries/Szemeredi_Regularity.html
2021-11-05T00:00:00+00:00
/dependencies/complex_bounded_operators/
2021-10-28T00:00:00+00:00
/entries/Registers.html
2021-10-28T00:00:00+00:00
/authors/unruh/
2021-10-28T00:00:00+00:00
/entries/Belief_Revision.html
2021-10-19T00:00:00+00:00
/authors/boulanger/
2021-10-19T00:00:00+00:00
/authors/fouillard/
2021-10-19T00:00:00+00:00
/authors/sabouret/
2021-10-19T00:00:00+00:00
/authors/taha/
2021-10-19T00:00:00+00:00
/authors/bharadwaj/
2021-10-13T00:00:00+00:00
/authors/bockenek/
2021-10-13T00:00:00+00:00
/authors/ravindran/
2021-10-13T00:00:00+00:00
/authors/roessle/
2021-10-13T00:00:00+00:00
/authors/verbeek/
2021-10-13T00:00:00+00:00
/authors/weerwag/
2021-10-13T00:00:00+00:00
/entries/X86_Semantics.html
2021-10-13T00:00:00+00:00
/entries/Correctness_Algebras.html
2021-10-12T00:00:00+00:00
/dependencies/monobooltranalgebra/
2021-10-12T00:00:00+00:00
/dependencies/stone_kleene_relation_algebras/
2021-10-12T00:00:00+00:00
/dependencies/subset_boolean_algebras/
2021-10-12T00:00:00+00:00
/authors/mitsch/
2021-10-02T00:00:00+00:00
/authors/scharager/
2021-10-02T00:00:00+00:00
/entries/Virtual_Substitution.html
2021-10-02T00:00:00+00:00
/entries/FOL_Axiomatic.html
2021-09-24T00:00:00+00:00
/dependencies/banach_steinhaus/
2021-09-18T00:00:00+00:00
/authors/caballero/
2021-09-18T00:00:00+00:00
/entries/Complex_Bounded_Operators.html
2021-09-18T00:00:00+00:00
/dependencies/complex_bounded_operators_dependencies/
2021-09-18T00:00:00+00:00
/dependencies/real_impl/
2021-09-18T00:00:00+00:00
/entries/Weighted_Path_Order.html
2021-09-16T00:00:00+00:00
/entries/CZH_Foundations.html
2021-09-06T00:00:00+00:00
/entries/CZH_Elementary_Categories.html
2021-09-06T00:00:00+00:00
/entries/CZH_Universal_Constructions.html
2021-09-06T00:00:00+00:00
/entries/Conditional_Simplification.html
2021-09-06T00:00:00+00:00
/entries/Conditional_Transfer_Rule.html
2021-09-06T00:00:00+00:00
/dependencies/conditional_simplification/
2021-09-06T00:00:00+00:00
/dependencies/conditional_transfer_rule/
2021-09-06T00:00:00+00:00
/dependencies/czh_elementary_categories/
2021-09-06T00:00:00+00:00
/dependencies/czh_foundations/
2021-09-06T00:00:00+00:00
/entries/Types_To_Sets_Extension.html
2021-09-06T00:00:00+00:00
/entries/Intro_Dest_Elim.html
2021-09-06T00:00:00+00:00
/dependencies/intro_dest_elim/
2021-09-06T00:00:00+00:00
/authors/milehins/
2021-09-06T00:00:00+00:00
/dependencies/speccheck/
2021-09-06T00:00:00+00:00
/entries/Dominance_CHK.html
2021-09-05T00:00:00+00:00
/authors/jiang/
2021-09-05T00:00:00+00:00
/dependencies/jinja/
2021-09-05T00:00:00+00:00
/dependencies/complex_geometry/
2021-09-03T00:00:00+00:00
/entries/Cubic_Quartic_Equations.html
2021-09-03T00:00:00+00:00
/entries/Logging_Independent_Anonymity.html
2021-08-26T00:00:00+00:00
/dependencies/budan_fourier/
2021-08-21T00:00:00+00:00
/authors/li/
2021-08-21T00:00:00+00:00
/entries/Three_Circles.html
2021-08-21T00:00:00+00:00
/authors/thomson/
2021-08-21T00:00:00+00:00
/authors/bauereiss/
2021-08-16T00:00:00+00:00
/dependencies/bd_security_compositional/
2021-08-16T00:00:00+00:00
/dependencies/bounded_deducibility_security/
2021-08-16T00:00:00+00:00
/entries/CoCon.html
2021-08-16T00:00:00+00:00
/entries/BD_Security_Compositional.html
2021-08-16T00:00:00+00:00
/entries/CoSMed.html
2021-08-16T00:00:00+00:00
/entries/CoSMeDis.html
2021-08-16T00:00:00+00:00
/entries/Fresh_Identifiers.html
2021-08-16T00:00:00+00:00
/dependencies/card_partitions/
2021-08-13T00:00:00+00:00
/entries/Design_Theory.html
2021-08-13T00:00:00+00:00
/dependencies/nested_multisets_ordinals/
2021-08-13T00:00:00+00:00
/entries/Relational_Forests.html
2021-08-03T00:00:00+00:00
/authors/palmer/
2021-07-27T00:00:00+00:00
/authors/schmoetten/
2021-07-27T00:00:00+00:00
/entries/Schutz_Spacetime.html
2021-07-27T00:00:00+00:00
/entries/Finitely_Generated_Abelian_Groups.html
2021-07-07T00:00:00+00:00
/authors/thommes/
2021-07-07T00:00:00+00:00
/authors/bulwahn/
2021-07-01T00:00:00+00:00
/authors/kappelmann/
2021-07-01T00:00:00+00:00
/entries/SpecCheck.html
2021-07-01T00:00:00+00:00
/authors/willenbrink/
2021-07-01T00:00:00+00:00
/entries/Van_der_Waerden.html
2021-06-22T00:00:00+00:00
/entries/MiniSail.html
2021-06-18T00:00:00+00:00
/dependencies/nominal2/
2021-06-18T00:00:00+00:00
/dependencies/show/
2021-06-18T00:00:00+00:00
/authors/wassell/
2021-06-18T00:00:00+00:00
/entries/Public_Announcement_Logic.html
2021-06-17T00:00:00+00:00
/entries/IMP_Compiler.html
2021-06-04T00:00:00+00:00
/entries/Combinatorics_Words.html
2021-05-24T00:00:00+00:00
/entries/Combinatorics_Words_Graph_Lemma.html
2021-05-24T00:00:00+00:00
/entries/Combinatorics_Words_Lyndon.html
2021-05-24T00:00:00+00:00
/dependencies/szpilrajn/
2021-05-24T00:00:00+00:00
/dependencies/jinjadci/
2021-04-30T00:00:00+00:00
/authors/mansky/
2021-04-30T00:00:00+00:00
/entries/Regression_Test_Selection.html
2021-04-30T00:00:00+00:00
/entries/Metalogic_ProofChecker.html
2021-04-27T00:00:00+00:00
/authors/kadzioka/
2021-04-27T00:00:00+00:00
/entries/Lifting_the_Exponent.html
2021-04-27T00:00:00+00:00
/authors/rosskopf/
2021-04-27T00:00:00+00:00
/dependencies/sturm_tarski/
2021-04-24T00:00:00+00:00
/entries/BenOr_Kozen_Reif.html
2021-04-24T00:00:00+00:00
/entries/GaleStewart_Games.html
2021-04-23T00:00:00+00:00
/authors/joosten/
2021-04-23T00:00:00+00:00
/dependencies/parity_game/
2021-04-23T00:00:00+00:00
/authors/brun/
2021-04-13T00:00:00+00:00
/authors/decova/
2021-04-13T00:00:00+00:00
/entries/Progress_Tracking.html
2021-04-13T00:00:00+00:00
/authors/lattuada/
2021-04-13T00:00:00+00:00
/entries/IFC_Tracking.html
2021-04-01T00:00:00+00:00
/authors/nordhoff/
2021-04-01T00:00:00+00:00
/entries/Grothendieck_Schemes.html
2021-03-29T00:00:00+00:00
/entries/Padic_Ints.html
2021-03-23T00:00:00+00:00
/entries/Constructive_Cryptography_CM.html
2021-03-17T00:00:00+00:00
/dependencies/constructive_cryptography/
2021-03-17T00:00:00+00:00
/dependencies/game_based_crypto/
2021-03-17T00:00:00+00:00
/authors/lochbihler/
2021-03-17T00:00:00+00:00
/authors/sefidgar/
2021-03-17T00:00:00+00:00
/dependencies/sigma_commit_crypto/
2021-03-17T00:00:00+00:00
/authors/bottesch/
2021-03-12T00:00:00+00:00
/authors/divason/
2021-03-12T00:00:00+00:00
/dependencies/hermite/
2021-03-12T00:00:00+00:00
/dependencies/smith_normal_form/
2021-03-12T00:00:00+00:00
/entries/Modular_arithmetic_LLL_and_HNF_algorithms.html
2021-03-12T00:00:00+00:00
/dependencies/isabelle_marries_dirac/
2021-03-03T00:00:00+00:00
/dependencies/pi_transcendental/
2021-03-03T00:00:00+00:00
/dependencies/power_sum_polynomials/
2021-03-03T00:00:00+00:00
/dependencies/qhlprover/
2021-03-03T00:00:00+00:00
/entries/Projective_Measurements.html
2021-03-03T00:00:00+00:00
/entries/Hermite_Lindemann.html
2021-03-03T00:00:00+00:00
/authors/blumson/
2021-03-01T00:00:00+00:00
/entries/Mereology.html
2021-03-01T00:00:00+00:00
/entries/Sunflowers.html
2021-02-25T00:00:00+00:00
/entries/BTree.html
2021-02-24T00:00:00+00:00
/authors/muendler/
2021-02-24T00:00:00+00:00
/dependencies/refine_imperative_hol/
2021-02-24T00:00:00+00:00
/entries/Formal_Puiseux_Series.html
2021-02-17T00:00:00+00:00
/entries/Laws_of_Large_Numbers.html
2021-02-10T00:00:00+00:00
/authors/coghetto/
2021-01-31T00:00:00+00:00
/entries/IsaGeoCoq.html
2021-01-31T00:00:00+00:00
/entries/Blue_Eyes.html
2021-01-30T00:00:00+00:00
/entries/Hood_Melville_Queue.html
2021-01-18T00:00:00+00:00
/authors/londono/
2021-01-18T00:00:00+00:00
/entries/JinjaDCI.html
2021-01-11T00:00:00+00:00
/entries/Delta_System_Lemma.html
2020-12-27T00:00:00+00:00
/entries/Topological_Semantics.html
2020-12-17T00:00:00+00:00
/authors/brien/
2020-12-08T00:00:00+00:00
/entries/Relational_Minimum_Spanning_Trees.html
2020-12-08T00:00:00+00:00
/dependencies/relational_disjoint_set_forests/
2020-12-08T00:00:00+00:00
/entries/Interpreter_Optimizations.html
2020-12-07T00:00:00+00:00
/dependencies/vericomp/
2020-12-07T00:00:00+00:00
/entries/Relational_Method.html
2020-12-05T00:00:00+00:00
/authors/he/
2020-11-22T00:00:00+00:00
/entries/Isabelle_Marries_Dirac.html
2020-11-22T00:00:00+00:00
/authors/lachnitt/
2020-11-22T00:00:00+00:00
/dependencies/matrix_tensor/
2020-11-22T00:00:00+00:00
/dependencies/vectorspace/
2020-11-22T00:00:00+00:00
/dependencies/hol-csp/
2020-11-19T00:00:00+00:00
/entries/CSP_RefTK.html
2020-11-19T00:00:00+00:00
/authors/wolff/
2020-11-19T00:00:00+00:00
/authors/ye/
2020-11-19T00:00:00+00:00
/entries/AI_Planning_Languages_Semantics.html
2020-10-29T00:00:00+00:00
/dependencies/ai_planning_languages_semantics/
2020-10-29T00:00:00+00:00
/dependencies/certification_monads/
2020-10-29T00:00:00+00:00
/authors/kurz/
2020-10-29T00:00:00+00:00
/dependencies/propositional_proof_systems/
2020-10-29T00:00:00+00:00
/entries/Verified_SAT_Based_AI_Planning.html
2020-10-29T00:00:00+00:00
/entries/Physical_Quantities.html
2020-10-20T00:00:00+00:00
/authors/fosters/
2020-10-20T00:00:00+00:00
/authors/diaz/
2020-10-12T00:00:00+00:00
/entries/Finite-Map-Extras.html
2020-10-12T00:00:00+00:00
/entries/Shadow_DOM.html
2020-09-28T00:00:00+00:00
/entries/Shadow_SC_DOM.html
2020-09-28T00:00:00+00:00
/entries/SC_DOM_Components.html
2020-09-28T00:00:00+00:00
/entries/DOM_Components.html
2020-09-28T00:00:00+00:00
/dependencies/core_dom/
2020-09-28T00:00:00+00:00
/dependencies/core_sc_dom/
2020-09-28T00:00:00+00:00
/authors/herzberg/
2020-09-28T00:00:00+00:00
/dependencies/shadow_dom/
2020-09-28T00:00:00+00:00
/dependencies/shadow_sc_dom/
2020-09-28T00:00:00+00:00
/entries/Core_SC_DOM.html
2020-09-28T00:00:00+00:00
/entries/Goedel_Incompleteness.html
2020-09-16T00:00:00+00:00
/entries/Goedel_HFSet_Semantic.html
2020-09-16T00:00:00+00:00
/entries/Goedel_HFSet_Semanticless.html
2020-09-16T00:00:00+00:00
/dependencies/goedel_incompleteness/
2020-09-16T00:00:00+00:00
/dependencies/incompleteness/
2020-09-16T00:00:00+00:00
/entries/Robinson_Arithmetic.html
2020-09-16T00:00:00+00:00
/entries/Syntax_Independent_Logic.html
2020-09-16T00:00:00+00:00
/dependencies/syntax_independent_logic/
2020-09-16T00:00:00+00:00
/entries/Extended_Finite_State_Machines.html
2020-09-07T00:00:00+00:00
/authors/derrick/
2020-09-07T00:00:00+00:00
/dependencies/extended_finite_state_machines/
2020-09-07T00:00:00+00:00
/dependencies/finfun/
2020-09-07T00:00:00+00:00
/authors/foster/
2020-09-07T00:00:00+00:00
/entries/Extended_Finite_State_Machine_Inference.html
2020-09-07T00:00:00+00:00
/authors/taylor/
2020-09-07T00:00:00+00:00
/authors/fleury/
2020-08-31T00:00:00+00:00
/authors/kaufmann/
2020-08-31T00:00:00+00:00
/entries/PAC_Checker.html
2020-08-31T00:00:00+00:00
/dependencies/sepref_iicf/
2020-08-31T00:00:00+00:00
/entries/Inductive_Inference.html
2020-08-31T00:00:00+00:00
/dependencies/aggregation_algebras/
2020-08-26T00:00:00+00:00
/entries/Relational_Disjoint_Set_Forests.html
2020-08-26T00:00:00+00:00
/entries/Saturation_Framework_Extensions.html
2020-08-25T00:00:00+00:00
/authors/gammie/
2020-08-25T00:00:00+00:00
/dependencies/holcf-prelude/
2020-08-25T00:00:00+00:00
/entries/BirdKMP.html
2020-08-25T00:00:00+00:00
/dependencies/well_quasi_orders/
2020-08-25T00:00:00+00:00
/entries/Amicable_Numbers.html
2020-08-04T00:00:00+00:00
/dependencies/pratt_certificate/
2020-08-04T00:00:00+00:00
/dependencies/nash_williams/
2020-08-03T00:00:00+00:00
/entries/Ordinal_Partitions.html
2020-08-03T00:00:00+00:00
/entries/Chandy_Lamport.html
2020-07-21T00:00:00+00:00
/authors/fiedler/
2020-07-21T00:00:00+00:00
/authors/hoefner/
2020-07-13T00:00:00+00:00
/dependencies/relation_algebra/
2020-07-13T00:00:00+00:00
/entries/Relational_Paths.html
2020-07-13T00:00:00+00:00
/entries/Safe_Distance.html
2020-06-01T00:00:00+00:00
/authors/immler/
2020-06-01T00:00:00+00:00
/authors/rizaldi/
2020-06-01T00:00:00+00:00
/dependencies/sturm_sequences/
2020-06-01T00:00:00+00:00
/entries/Smith_Normal_Form.html
2020-05-23T00:00:00+00:00
/entries/Nash_Williams.html
2020-05-16T00:00:00+00:00
/entries/Knuth_Bendix_Order.html
2020-05-13T00:00:00+00:00
/dependencies/matrix/
2020-05-13T00:00:00+00:00
/entries/Irrational_Series_Erdos_Straus.html
2020-05-12T00:00:00+00:00
/dependencies/prime_distribution_elementary/
2020-05-12T00:00:00+00:00
/authors/dunaev/
2020-05-11T00:00:00+00:00
/entries/Recursion-Addition.html
2020-05-11T00:00:00+00:00
/entries/LTL_Normal_Form.html
2020-05-08T00:00:00+00:00
/dependencies/ltl/
2020-05-08T00:00:00+00:00
/dependencies/ltl_master_theorem/
2020-05-08T00:00:00+00:00
/authors/sickert/
2020-05-08T00:00:00+00:00
/entries/Forcing.html
2020-05-06T00:00:00+00:00
/entries/Banach_Steinhaus.html
2020-05-02T00:00:00+00:00
/entries/Attack_Trees.html
2020-04-27T00:00:00+00:00
/authors/kammueller/
2020-04-27T00:00:00+00:00
/entries/Gaussian_Integers.html
2020-04-24T00:00:00+00:00
/entries/Power_Sum_Polynomials.html
2020-04-24T00:00:00+00:00
/dependencies/symmetric_polynomials/
2020-04-24T00:00:00+00:00
/entries/Lambert_W.html
2020-04-24T00:00:00+00:00
/dependencies/hybrid_systems_vcs/
2020-04-19T00:00:00+00:00
/entries/Matrices_for_ODEs.html
2020-04-19T00:00:00+00:00
/authors/munive/
2020-04-19T00:00:00+00:00
/entries/ADS_Functor.html
2020-04-16T00:00:00+00:00
/authors/maric/
2020-04-16T00:00:00+00:00
/entries/Sliding_Window_Algorithm.html
2020-04-10T00:00:00+00:00
/authors/heimes/
2020-04-10T00:00:00+00:00
/authors/schneider/
2020-04-10T00:00:00+00:00
/entries/Saturation_Framework.html
2020-04-09T00:00:00+00:00
/entries/MFODL_Monitor_Optimized.html
2020-04-09T00:00:00+00:00
/dependencies/generic_join/
2020-04-09T00:00:00+00:00
/dependencies/ieee_floating_point/
2020-04-09T00:00:00+00:00
/dependencies/lambda_free_rpos/
2020-04-09T00:00:00+00:00
/dependencies/mfotl_monitor/
2020-04-09T00:00:00+00:00
/entries/Automated_Stateful_Protocol_Verification.html
2020-04-08T00:00:00+00:00
/authors/hess/
2020-04-08T00:00:00+00:00
/authors/moedersheim/
2020-04-08T00:00:00+00:00
/authors/schlichtkrull/
2020-04-08T00:00:00+00:00
/entries/Stateful_Protocol_Composition_and_Typing.html
2020-04-08T00:00:00+00:00
/dependencies/stateful_protocol_composition_and_typing/
2020-04-08T00:00:00+00:00
/entries/Lucas_Theorem.html
2020-04-07T00:00:00+00:00
/authors/gonzalez/
2020-03-25T00:00:00+00:00
/entries/WOOT_Strong_Eventual_Consistency.html
2020-03-25T00:00:00+00:00
/entries/Furstenberg_Topology.html
2020-03-22T00:00:00+00:00
/entries/Relational-Incorrectness-Logic.html
2020-03-12T00:00:00+00:00
/authors/murray/
2020-03-12T00:00:00+00:00
/authors/diekmann/
2020-03-07T00:00:00+00:00
/entries/Hello_World.html
2020-03-07T00:00:00+00:00
/authors/hupel/
2020-03-07T00:00:00+00:00
/entries/Goodstein_Lambda.html
2020-02-21T00:00:00+00:00
/entries/VeriComp.html
2020-02-10T00:00:00+00:00
/entries/Arith_Prog_Rel_Primes.html
2020-02-01T00:00:00+00:00
/entries/Subset_Boolean_Algebras.html
2020-01-31T00:00:00+00:00
/authors/moeller/
2020-01-31T00:00:00+00:00
/dependencies/stone_algebras/
2020-01-31T00:00:00+00:00
/entries/Mersenne_Primes.html
2020-01-17T00:00:00+00:00
/dependencies/pell/
2020-01-17T00:00:00+00:00
/dependencies/probabilistic_prime_tests/
2020-01-17T00:00:00+00:00
/authors/essmann/
2020-01-16T00:00:00+00:00
/authors/robillard/
2020-01-16T00:00:00+00:00
/entries/Approximation_Algorithms.html
2020-01-16T00:00:00+00:00
/dependencies/akra_bazzi/
2020-01-13T00:00:00+00:00
/entries/Closest_Pair_Points.html
2020-01-13T00:00:00+00:00
/authors/rau/
2020-01-13T00:00:00+00:00
/dependencies/root_balanced_tree/
2020-01-13T00:00:00+00:00
/authors/haslbeck/
2020-01-09T00:00:00+00:00
/dependencies/monad_normalisation/
2020-01-09T00:00:00+00:00
/entries/Skip_Lists.html
2020-01-09T00:00:00+00:00
/entries/Bicategory.html
2020-01-06T00:00:00+00:00
/dependencies/monoidalcategory/
2020-01-06T00:00:00+00:00
/dependencies/e_transcendental/
2019-12-27T00:00:00+00:00
/dependencies/prime_number_theorem/
2019-12-27T00:00:00+00:00
/entries/Zeta_3_Irrational.html
2019-12-27T00:00:00+00:00
/entries/Hybrid_Logic.html
2019-12-20T00:00:00+00:00
/dependencies/hol-ode-numerics/
2019-12-18T00:00:00+00:00
/entries/Poincare_Bendixson.html
2019-12-18T00:00:00+00:00
/authors/boutry/
2019-12-16T00:00:00+00:00
/entries/Complex_Geometry.html
2019-12-16T00:00:00+00:00
/authors/maricf/
2019-12-16T00:00:00+00:00
/entries/Poincare_Disc.html
2019-12-16T00:00:00+00:00
/authors/simic/
2019-12-16T00:00:00+00:00
/entries/Gauss_Sums.html
2019-12-10T00:00:00+00:00
/entries/Generalized_Counting_Sort.html
2019-12-04T00:00:00+00:00
/authors/bohrer/
2019-11-27T00:00:00+00:00
/entries/Interval_Arithmetic_Word32.html
2019-11-27T00:00:00+00:00
/entries/ZFC_in_HOL.html
2019-10-24T00:00:00+00:00
/entries/Isabelle_C.html
2019-10-22T00:00:00+00:00
/authors/tuong/
2019-10-22T00:00:00+00:00
/entries/VerifyThis2019.html
2019-10-16T00:00:00+00:00
/authors/wimmer/
2019-10-16T00:00:00+00:00
/entries/Aristotles_Assertoric_Syllogistic.html
2019-10-08T00:00:00+00:00
/authors/butler/
2019-10-07T00:00:00+00:00
/entries/Sigma_Commit_Crypto.html
2019-10-07T00:00:00+00:00
/entries/Clean.html
2019-10-04T00:00:00+00:00
/entries/Generic_Join.html
2019-09-16T00:00:00+00:00
/dependencies/kad/
2019-09-10T00:00:00+00:00
/dependencies/kat_and_dra/
2019-09-10T00:00:00+00:00
/dependencies/ordinary_differential_equations/
2019-09-10T00:00:00+00:00
/dependencies/transformer_semantics/
2019-09-10T00:00:00+00:00
/entries/Hybrid_Systems_VCs.html
2019-09-10T00:00:00+00:00
/entries/Fourier.html
2019-09-06T00:00:00+00:00
/entries/Jacobson_Basic_Algebra.html
2019-08-30T00:00:00+00:00
/authors/ballarin/
2019-08-30T00:00:00+00:00
/entries/Adaptive_State_Counting.html
2019-08-16T00:00:00+00:00
/dependencies/transition_systems_and_automata/
2019-08-16T00:00:00+00:00
/entries/Laplace_Transform.html
2019-08-14T00:00:00+00:00
/authors/buyse/
2019-08-06T00:00:00+00:00
/entries/C2KA_DistributedSystems.html
2019-08-06T00:00:00+00:00
/dependencies/farkas/
2019-08-06T00:00:00+00:00
/authors/jaskolka/
2019-08-06T00:00:00+00:00
/authors/kaliszyk/
2019-08-06T00:00:00+00:00
/entries/Linear_Programming.html
2019-08-06T00:00:00+00:00
/authors/parsert/
2019-08-06T00:00:00+00:00
/entries/IMO2019.html
2019-08-05T00:00:00+00:00
/authors/losa/
2019-08-01T00:00:00+00:00
/entries/Stellar_Quorums.html
2019-08-01T00:00:00+00:00
/entries/TESL_Language.html
2019-07-30T00:00:00+00:00
/authors/van/
2019-07-30T00:00:00+00:00
/entries/Szpilrajn.html
2019-07-27T00:00:00+00:00
/authors/zeller/
2019-07-27T00:00:00+00:00
/entries/FOL_Seq_Calc1.html
2019-07-18T00:00:00+00:00
/entries/CakeML_Codegen.html
2019-07-08T00:00:00+00:00
/dependencies/cakeml/
2019-07-08T00:00:00+00:00
/dependencies/constructor_funs/
2019-07-08T00:00:00+00:00
/dependencies/dict_construction/
2019-07-08T00:00:00+00:00
/dependencies/higher_order_terms/
2019-07-08T00:00:00+00:00
/dependencies/huffman/
2019-07-08T00:00:00+00:00
/dependencies/pairing_heap/
2019-07-08T00:00:00+00:00
/entries/MFOTL_Monitor.html
2019-07-04T00:00:00+00:00
/entries/Complete_Non_Orders.html
2019-06-27T00:00:00+00:00
/entries/Priority_Search_Trees.html
2019-06-25T00:00:00+00:00
/dependencies/priority_search_trees/
2019-06-25T00:00:00+00:00
/entries/Prim_Dijkstra_Simple.html
2019-06-25T00:00:00+00:00
/entries/Linear_Inequalities.html
2019-06-21T00:00:00+00:00
/authors/reynaud/
2019-06-21T00:00:00+00:00
/entries/Nullstellensatz.html
2019-06-16T00:00:00+00:00
/authors/maletzky/
2019-06-16T00:00:00+00:00
/entries/Groebner_Macaulay.html
2019-06-15T00:00:00+00:00
/entries/IMP2_Binary_Heap.html
2019-06-13T00:00:00+00:00
/authors/griebel/
2019-06-13T00:00:00+00:00
/dependencies/imp2/
2019-06-13T00:00:00+00:00
/entries/Differential_Game_Logic.html
2019-06-03T00:00:00+00:00
/dependencies/median_of_medians_selection/
2019-05-30T00:00:00+00:00
/entries/KD_Tree.html
2019-05-30T00:00:00+00:00
/entries/LambdaAuth.html
2019-05-14T00:00:00+00:00
/authors/aspinall/
2019-05-09T00:00:00+00:00
/entries/Multi_Party_Computation.html
2019-05-09T00:00:00+00:00
/entries/HOL-CSP.html
2019-04-26T00:00:00+00:00
/entries/LTL_Master_Theorem.html
2019-04-16T00:00:00+00:00
/authors/seidl/
2019-04-16T00:00:00+00:00
/entries/Binding_Syntax_Theory.html
2019-04-06T00:00:00+00:00
/authors/gheri/
2019-04-06T00:00:00+00:00
/entries/Transcendence_Series_Hancl_Rucki.html
2019-03-27T00:00:00+00:00
/dependencies/deep_learning/
2019-03-24T00:00:00+00:00
/authors/liu/
2019-03-24T00:00:00+00:00
/authors/liut/
2019-03-24T00:00:00+00:00
/authors/liy/
2019-03-24T00:00:00+00:00
/entries/QHLProver.html
2019-03-24T00:00:00+00:00
/authors/wang/
2019-03-24T00:00:00+00:00
/authors/ying/
2019-03-24T00:00:00+00:00
/authors/yingm/
2019-03-24T00:00:00+00:00
/authors/zhan/
2019-03-24T00:00:00+00:00
/authors/zhann/
2019-03-24T00:00:00+00:00
/authors/nikiforov/
2019-03-09T00:00:00+00:00
/entries/Safe_OCL.html
2019-03-09T00:00:00+00:00
/entries/Prime_Distribution_Elementary.html
2019-02-21T00:00:00+00:00
/authors/biendarra/
2019-02-14T00:00:00+00:00
/authors/haslbeckm/
2019-02-14T00:00:00+00:00
/entries/Kruskal.html
2019-02-14T00:00:00+00:00
/dependencies/matroids/
2019-02-14T00:00:00+00:00
/dependencies/refine_monadic/
2019-02-14T00:00:00+00:00
/entries/Probabilistic_Prime_Tests.html
2019-02-11T00:00:00+00:00
/authors/stuewe/
2019-02-11T00:00:00+00:00
/authors/regensburger/
2019-02-08T00:00:00+00:00
/entries/Universal_Turing_Machine.html
2019-02-08T00:00:00+00:00
/authors/urban/
2019-02-08T00:00:00+00:00
/authors/xu/
2019-02-08T00:00:00+00:00
/authors/zhangx/
2019-02-08T00:00:00+00:00
/entries/UTP.html
2019-02-01T00:00:00+00:00
/authors/nemouchi/
2019-02-01T00:00:00+00:00
/dependencies/optics/
2019-02-01T00:00:00+00:00
/authors/ribeiro/
2019-02-01T00:00:00+00:00
/entries/List_Inversions.html
2019-02-01T00:00:00+00:00
/dependencies/utp-toolkit/
2019-02-01T00:00:00+00:00
/authors/zeyda/
2019-02-01T00:00:00+00:00
/entries/Farkas.html
2019-01-17T00:00:00+00:00
/dependencies/simplex/
2019-01-17T00:00:00+00:00
/entries/Higher_Order_Terms.html
2019-01-15T00:00:00+00:00
/entries/IMP2.html
2019-01-15T00:00:00+00:00
/entries/Store_Buffer_Reduction.html
2019-01-07T00:00:00+00:00
/authors/cohen/
2019-01-07T00:00:00+00:00
/authors/schirmer/
2019-01-07T00:00:00+00:00
/entries/Core_DOM.html
2018-12-26T00:00:00+00:00
/entries/Concurrent_Revisions.html
2018-12-25T00:00:00+00:00
/authors/overbeek/
2018-12-25T00:00:00+00:00
/dependencies/auto2_hol/
2018-12-21T00:00:00+00:00
/entries/Auto2_Imperative_HOL.html
2018-12-21T00:00:00+00:00
/entries/Constructive_Cryptography.html
2018-12-17T00:00:00+00:00
/dependencies/kleene_algebra/
2018-12-11T00:00:00+00:00
/dependencies/order_lattice_props/
2018-12-11T00:00:00+00:00
/entries/Order_Lattice_Props.html
2018-12-11T00:00:00+00:00
/dependencies/quantales/
2018-12-11T00:00:00+00:00
/entries/Quantales.html
2018-12-11T00:00:00+00:00
/entries/Transformer_Semantics.html
2018-12-11T00:00:00+00:00
/entries/Functional_Ordered_Resolution_Prover.html
2018-11-23T00:00:00+00:00
/entries/Graph_Saturation.html
2018-11-23T00:00:00+00:00
/dependencies/open_induction/
2018-11-23T00:00:00+00:00
/entries/Auto2_HOL.html
2018-11-20T00:00:00+00:00
/authors/keinholz/
2018-11-16T00:00:00+00:00
/entries/Matroids.html
2018-11-16T00:00:00+00:00
/entries/Generic_Deriving.html
2018-11-06T00:00:00+00:00
/authors/raedle/
2018-11-06T00:00:00+00:00
/entries/GewirthPGCProof.html
2018-10-30T00:00:00+00:00
/entries/Epistemic_Logic.html
2018-10-29T00:00:00+00:00
/entries/Smooth_Manifolds.html
2018-10-22T00:00:00+00:00
/authors/bentkamp/
2018-10-19T00:00:00+00:00
/entries/Lambda_Free_EPO.html
2018-10-19T00:00:00+00:00
/dependencies/random_bsts/
2018-10-19T00:00:00+00:00
/entries/Randomised_BSTs.html
2018-10-19T00:00:00+00:00
/entries/Factored_Transition_System_Bounding.html
2018-10-12T00:00:00+00:00
/entries/Pi_Transcendental.html
2018-09-28T00:00:00+00:00
/entries/Symmetric_Polynomials.html
2018-09-25T00:00:00+00:00
/entries/Signature_Groebner.html
2018-09-20T00:00:00+00:00
/entries/Prime_Number_Theorem.html
2018-09-19T00:00:00+00:00
/entries/Aggregation_Algebras.html
2018-09-15T00:00:00+00:00
/entries/Octonions.html
2018-09-14T00:00:00+00:00
/entries/Quaternions.html
2018-09-05T00:00:00+00:00
/entries/Budan_Fourier.html
2018-09-02T00:00:00+00:00
/entries/Simplex.html
2018-08-24T00:00:00+00:00
/authors/spasic/
2018-08-24T00:00:00+00:00
/dependencies/abstract-rewriting/
2018-08-14T00:00:00+00:00
/entries/Minsky_Machines.html
2018-08-14T00:00:00+00:00
/dependencies/recursion-theory-i/
2018-08-14T00:00:00+00:00
/entries/DiscretePricing.html
2018-07-16T00:00:00+00:00
/dependencies/first_welfare_theorem/
2018-07-04T00:00:00+00:00
/entries/Neumann_Morgenstern_Utility.html
2018-07-04T00:00:00+00:00
/entries/Pell.html
2018-06-23T00:00:00+00:00
/entries/Projective_Geometry.html
2018-06-14T00:00:00+00:00
/entries/Localization_Ring.html
2018-06-14T00:00:00+00:00
/authors/brunner/
2018-06-05T00:00:00+00:00
/entries/Partial_Order_Reduction.html
2018-06-05T00:00:00+00:00
/dependencies/stuttering_equivalence/
2018-06-05T00:00:00+00:00
/dependencies/monad_memo_dp/
2018-05-27T00:00:00+00:00
/entries/Optimal_BST.html
2018-05-27T00:00:00+00:00
/authors/somogyi/
2018-05-27T00:00:00+00:00
/entries/Hidden_Markov_Models.html
2018-05-25T00:00:00+00:00
/dependencies/markov_models/
2018-05-25T00:00:00+00:00
/authors/hoelzl/
2018-05-24T00:00:00+00:00
/entries/Probabilistic_Timed_Automata.html
2018-05-24T00:00:00+00:00
/dependencies/timed_automata/
2018-05-24T00:00:00+00:00
/entries/AxiomaticCategoryTheory.html
2018-05-23T00:00:00+00:00
/entries/Irrationality_J_Hancl.html
2018-05-23T00:00:00+00:00
/authors/scott/
2018-05-23T00:00:00+00:00
/entries/Monad_Memo_DP.html
2018-05-22T00:00:00+00:00
/authors/beresford/
2018-05-10T00:00:00+00:00
/authors/gomes/
2018-05-10T00:00:00+00:00
/authors/kleppmann/
2018-05-10T00:00:00+00:00
/authors/mulligan/
2018-05-10T00:00:00+00:00
/entries/OpSets.html
2018-05-10T00:00:00+00:00
/entries/Modular_Assembly_Kit_Security.html
2018-05-07T00:00:00+00:00
/authors/bracevac/
2018-05-07T00:00:00+00:00
/authors/gay/
2018-05-07T00:00:00+00:00
/authors/grewe/
2018-05-07T00:00:00+00:00
/authors/mantel/
2018-05-07T00:00:00+00:00
/authors/sudbrock/
2018-05-07T00:00:00+00:00
/authors/tasch/
2018-05-07T00:00:00+00:00
/authors/watt/
2018-04-29T00:00:00+00:00
/entries/WebAssembly.html
2018-04-29T00:00:00+00:00
/entries/VerifyThis2018.html
2018-04-27T00:00:00+00:00
/entries/BNF_CC.html
2018-04-24T00:00:00+00:00
/authors/brandt/
2018-03-22T00:00:00+00:00
/authors/saile/
2018-03-22T00:00:00+00:00
/authors/stricker/
2018-03-22T00:00:00+00:00
/entries/Fishburn_Impossibility.html
2018-03-22T00:00:00+00:00
/authors/dirix/
2018-03-13T00:00:00+00:00
/entries/Weight_Balanced_Trees.html
2018-03-13T00:00:00+00:00
/entries/CakeML.html
2018-03-12T00:00:00+00:00
/dependencies/lem/
2018-03-12T00:00:00+00:00
/authors/zhang/
2018-03-12T00:00:00+00:00
/entries/Architectural_Design_Patterns.html
2018-03-01T00:00:00+00:00
/dependencies/dynamicarchitectures/
2018-03-01T00:00:00+00:00
/entries/Hoare_Time.html
2018-02-26T00:00:00+00:00
/entries/LLL_Factorization.html
2018-02-06T00:00:00+00:00
/dependencies/comparison_sort_lower_bound/
2018-02-06T00:00:00+00:00
/entries/First_Order_Terms.html
2018-02-06T00:00:00+00:00
/dependencies/landau_symbols/
2018-02-06T00:00:00+00:00
/entries/Error_Function.html
2018-02-06T00:00:00+00:00
/entries/Treaps.html
2018-02-06T00:00:00+00:00
/entries/LLL_Basis_Reduction.html
2018-02-02T00:00:00+00:00
/entries/Ordered_Resolution_Prover.html
2018-01-18T00:00:00+00:00
/authors/waldmann/
2018-01-18T00:00:00+00:00
/authors/gouezel/
2018-01-16T00:00:00+00:00
/entries/Gromov_Hyperbolicity.html
2018-01-16T00:00:00+00:00
/entries/Green.html
2018-01-11T00:00:00+00:00
/dependencies/affine_arithmetic/
2018-01-08T00:00:00+00:00
/entries/Taylor_Models.html
2018-01-08T00:00:00+00:00
/authors/traut/
2018-01-08T00:00:00+00:00
/entries/Falling_Factorial_Sum.html
2017-12-22T00:00:00+00:00
/entries/Dirichlet_L.html
2017-12-21T00:00:00+00:00
/dependencies/finitely_generated_abelian_groups/
2017-12-21T00:00:00+00:00
/entries/Mason_Stothers.html
2017-12-21T00:00:00+00:00
/entries/Median_Of_Medians_Selection.html
2017-12-21T00:00:00+00:00
/entries/BNF_Operations.html
2017-12-19T00:00:00+00:00
/authors/hellauer/
2017-12-18T00:00:00+00:00
/entries/Knuth_Morris_Pratt.html
2017-12-18T00:00:00+00:00
/entries/Stochastic_Matrices.html
2017-11-22T00:00:00+00:00
/dependencies/crdt/
2017-11-09T00:00:00+00:00
/authors/jungnickel/
2017-11-09T00:00:00+00:00
/authors/loibl/
2017-11-09T00:00:00+00:00
/authors/oldenburg/
2017-11-09T00:00:00+00:00
/entries/IMAP-CRDT.html
2017-11-09T00:00:00+00:00
/entries/Hybrid_Multi_Lane_Spatial_Logic.html
2017-11-06T00:00:00+00:00
/authors/linker/
2017-11-06T00:00:00+00:00
/authors/gioiosa/
2017-10-26T00:00:00+00:00
/entries/Kuratowski_Closure_Complement.html
2017-10-26T00:00:00+00:00
/entries/Buchi_Complementation.html
2017-10-19T00:00:00+00:00
/dependencies/dfs_framework/
2017-10-19T00:00:00+00:00
/dependencies/gabow_scc/
2017-10-19T00:00:00+00:00
/entries/Transition_Systems_and_Automata.html
2017-10-19T00:00:00+00:00
/entries/Count_Complex_Roots.html
2017-10-17T00:00:00+00:00
/entries/Winding_Number_Eval.html
2017-10-17T00:00:00+00:00
/dependencies/winding_number_eval/
2017-10-17T00:00:00+00:00
/entries/Diophantine_Eqns_Lin_Hom.html
2017-10-14T00:00:00+00:00
/authors/messner/
2017-10-14T00:00:00+00:00
/authors/schoepf/
2017-10-14T00:00:00+00:00
/dependencies/count_complex_roots/
2017-10-12T00:00:00+00:00
/entries/Dirichlet_Series.html
2017-10-12T00:00:00+00:00
/dependencies/euler_maclaurin/
2017-10-12T00:00:00+00:00
/entries/Linear_Recurrences.html
2017-10-12T00:00:00+00:00
/dependencies/linear_recurrences/
2017-10-12T00:00:00+00:00
/entries/Zeta_Function.html
2017-10-12T00:00:00+00:00
/entries/Lowe_Ontological_Argument.html
2017-09-21T00:00:00+00:00
/entries/PLM.html
2017-09-17T00:00:00+00:00
/entries/AnselmGod.html
2017-09-06T00:00:00+00:00
/entries/First_Welfare_Theorem.html
2017-09-01T00:00:00+00:00
/dependencies/amortized_complexity/
2017-08-20T00:00:00+00:00
/entries/Orbit_Stabiliser.html
2017-08-20T00:00:00+00:00
/entries/Root_Balanced_Tree.html
2017-08-20T00:00:00+00:00
/authors/matache/
2017-08-16T00:00:00+00:00
/entries/LambdaMu.html
2017-08-16T00:00:00+00:00
/entries/Stewart_Apollonius.html
2017-07-31T00:00:00+00:00
/dependencies/triangle/
2017-07-31T00:00:00+00:00
/entries/DynamicArchitectures.html
2017-07-28T00:00:00+00:00
/entries/Decl_Sem_Fun_PL.html
2017-07-21T00:00:00+00:00
/authors/siek/
2017-07-21T00:00:00+00:00
/authors/breitner/
2017-07-15T00:00:00+00:00
/entries/HOLCF-Prelude.html
2017-07-15T00:00:00+00:00
/authors/huffman/
2017-07-15T00:00:00+00:00
/authors/mitchell/
2017-07-15T00:00:00+00:00
/entries/Minkowskis_Theorem.html
2017-07-13T00:00:00+00:00
/authors/rawson/
2017-07-09T00:00:00+00:00
/entries/Name_Carrying_Type_Inference.html
2017-07-09T00:00:00+00:00
/entries/CRDT.html
2017-07-07T00:00:00+00:00
/entries/Stone_Kleene_Relation_Algebras.html
2017-07-06T00:00:00+00:00
/dependencies/stone_relation_algebras/
2017-07-06T00:00:00+00:00
/entries/Propositional_Proof_Systems.html
2017-06-21T00:00:00+00:00
/authors/dongol/
2017-06-13T00:00:00+00:00
/authors/hayes/
2017-06-13T00:00:00+00:00
/entries/PSemigroupsConvolution.html
2017-06-13T00:00:00+00:00
/entries/Buffons_Needle.html
2017-06-06T00:00:00+00:00
/dependencies/cava_automata/
2017-06-01T00:00:00+00:00
/entries/Flow_Networks.html
2017-06-01T00:00:00+00:00
/dependencies/flow_networks/
2017-06-01T00:00:00+00:00
/entries/Prpu_Maxflow.html
2017-06-01T00:00:00+00:00
/dependencies/program-conflict-analysis/
2017-06-01T00:00:00+00:00
/authors/laursen/
2017-05-25T00:00:00+00:00
/entries/Optics.html
2017-05-25T00:00:00+00:00
/entries/Security_Protocol_Refinement.html
2017-05-24T00:00:00+00:00
/entries/Dict_Construction.html
2017-05-24T00:00:00+00:00
/dependencies/lazy_case/
2017-05-24T00:00:00+00:00
/authors/somaini/
2017-05-24T00:00:00+00:00
/entries/Floyd_Warshall.html
2017-05-08T00:00:00+00:00
/dependencies/applicative_lifting/
2017-05-05T00:00:00+00:00
/authors/bhatt/
2017-05-05T00:00:00+00:00
/entries/CryptHOL.html
2017-05-05T00:00:00+00:00
/entries/Monomorphic_Monad.html
2017-05-05T00:00:00+00:00
/entries/Game_Based_Crypto.html
2017-05-05T00:00:00+00:00
/dependencies/mfmc_countable/
2017-05-05T00:00:00+00:00
/entries/Monad_Normalisation.html
2017-05-05T00:00:00+00:00
/dependencies/monomorphic_monad/
2017-05-05T00:00:00+00:00
/entries/Probabilistic_While.html
2017-05-05T00:00:00+00:00
/dependencies/category3/
2017-05-04T00:00:00+00:00
/entries/MonoidalCategory.html
2017-05-04T00:00:00+00:00
/entries/Types_Tableaus_and_Goedels_God.html
2017-05-01T00:00:00+00:00
/entries/LocalLexing.html
2017-04-28T00:00:00+00:00
/authors/obua/
2017-04-28T00:00:00+00:00
/entries/Constructor_Funs.html
2017-04-19T00:00:00+00:00
/entries/Lazy_Case.html
2017-04-18T00:00:00+00:00
/entries/Subresultants.html
2017-04-06T00:00:00+00:00
/entries/Random_BSTs.html
2017-04-04T00:00:00+00:00
/dependencies/quick_sort_cost/
2017-04-04T00:00:00+00:00
/entries/Comparison_Sort_Lower_Bound.html
2017-03-15T00:00:00+00:00
/dependencies/regular-sets/
2017-03-15T00:00:00+00:00
/entries/Quick_Sort_Cost.html
2017-03-15T00:00:00+00:00
/entries/Euler_MacLaurin.html
2017-03-10T00:00:00+00:00
/authors/berghofer/
2017-02-28T00:00:00+00:00
/entries/Elliptic_Curves_Group_Law.html
2017-02-28T00:00:00+00:00
/authors/dittmann/
2017-02-26T00:00:00+00:00
/entries/Menger.html
2017-02-26T00:00:00+00:00
/entries/Differential_Dynamic_Logic.html
2017-02-13T00:00:00+00:00
/entries/Abstract_Soundness.html
2017-02-10T00:00:00+00:00
/entries/Stone_Relation_Algebras.html
2017-02-07T00:00:00+00:00
/authors/lallemand/
2017-01-31T00:00:00+00:00
/entries/Key_Agreement_Strong_Adversaries.html
2017-01-31T00:00:00+00:00
/entries/Bernoulli.html
2017-01-24T00:00:00+00:00
/entries/Bertrands_Postulate.html
2017-01-17T00:00:00+00:00
/dependencies/formal_ssa/
2017-01-17T00:00:00+00:00
/authors/lohner/
2017-01-17T00:00:00+00:00
/entries/Minimal_SSA.html
2017-01-17T00:00:00+00:00
/authors/wagner/
2017-01-17T00:00:00+00:00
/entries/E_Transcendental.html
2017-01-12T00:00:00+00:00
/authors/bruegger/
2017-01-08T00:00:00+00:00
/entries/UPF_Firewall.html
2017-01-08T00:00:00+00:00
/dependencies/upf/
2017-01-08T00:00:00+00:00
/entries/Password_Authentication_Protocol.html
2017-01-03T00:00:00+00:00
/entries/FOL_Harrison.html
2017-01-01T00:00:00+00:00
/authors/jensen/
2017-01-01T00:00:00+00:00
/entries/Concurrent_Ref_Alg.html
2016-12-30T00:00:00+00:00
/authors/fell/
2016-12-30T00:00:00+00:00
/authors/velykis/
2016-12-30T00:00:00+00:00
/dependencies/bell_numbers_spivey/
2016-12-29T00:00:00+00:00
/dependencies/card_multisets/
2016-12-29T00:00:00+00:00
/entries/Twelvefold_Way.html
2016-12-29T00:00:00+00:00
/authors/nagashima/
2016-12-20T00:00:00+00:00
/entries/Proof_Strategy_Language.html
2016-12-20T00:00:00+00:00
/entries/Paraconsistency.html
2016-12-07T00:00:00+00:00
/authors/amani/
2016-11-29T00:00:00+00:00
/authors/andronick/
2016-11-29T00:00:00+00:00
/entries/Complx.html
2016-11-29T00:00:00+00:00
/authors/lewis/
2016-11-29T00:00:00+00:00
/authors/rizkallah/
2016-11-29T00:00:00+00:00
/authors/tuongj/
2016-11-29T00:00:00+00:00
/entries/Abs_Int_ITP2012.html
2016-11-23T00:00:00+00:00
/authors/clouston/
2016-11-16T00:00:00+00:00
/authors/gore/
2016-11-16T00:00:00+00:00
/authors/hou/
2016-11-16T00:00:00+00:00
/authors/sanan/
2016-11-16T00:00:00+00:00
/entries/Separata.html
2016-11-16T00:00:00+00:00
/authors/tiu/
2016-11-16T00:00:00+00:00
/authors/becker/
2016-11-12T00:00:00+00:00
/entries/Lambda_Free_KBOs.html
2016-11-12T00:00:00+00:00
/entries/Nested_Multisets_Ordinals.html
2016-11-12T00:00:00+00:00
/dependencies/ordinal/
2016-11-12T00:00:00+00:00
/authors/wand/
2016-11-12T00:00:00+00:00
/entries/Deep_Learning.html
2016-11-10T00:00:00+00:00
/authors/borgstroem/
2016-10-25T00:00:00+00:00
/authors/eriksson/
2016-10-25T00:00:00+00:00
/authors/gutkovas/
2016-10-25T00:00:00+00:00
/entries/Modal_Logics_for_NTS.html
2016-10-25T00:00:00+00:00
/authors/parrow/
2016-10-25T00:00:00+00:00
/authors/weber/
2016-10-25T00:00:00+00:00
/entries/Stable_Matching.html
2016-10-24T00:00:00+00:00
/dependencies/iptables_semantics/
2016-10-21T00:00:00+00:00
/entries/LOFT.html
2016-10-21T00:00:00+00:00
/entries/SPARCv8.html
2016-10-19T00:00:00+00:00
/authors/hibon/
2016-10-19T00:00:00+00:00
/authors/liuy/
2016-10-19T00:00:00+00:00
/entries/Source_Coding_Theorem.html
2016-10-19T00:00:00+00:00
/dependencies/efficient-mergesort/
2016-10-14T00:00:00+00:00
/dependencies/subresultants/
2016-10-14T00:00:00+00:00
/entries/Berlekamp_Zassenhaus.html
2016-10-14T00:00:00+00:00
/entries/Chord_Segments.html
2016-10-11T00:00:00+00:00
/entries/Lp.html
2016-10-05T00:00:00+00:00
/entries/Fisher_Yates.html
2016-09-30T00:00:00+00:00
/entries/Allen_Calculus.html
2016-09-29T00:00:00+00:00
/authors/ghourabi/
2016-09-29T00:00:00+00:00
/entries/Lambda_Free_RPOs.html
2016-09-23T00:00:00+00:00
/entries/Iptables_Semantics.html
2016-09-09T00:00:00+00:00
/dependencies/iptables_semantics_examples/
2016-09-09T00:00:00+00:00
/dependencies/routing/
2016-09-09T00:00:00+00:00
/entries/SuperCalc.html
2016-09-06T00:00:00+00:00
/authors/peltier/
2016-09-06T00:00:00+00:00
/entries/Stone_Algebras.html
2016-09-06T00:00:00+00:00
/entries/Stirling_Formula.html
2016-09-01T00:00:00+00:00
/entries/Routing.html
2016-08-31T00:00:00+00:00
/dependencies/simple_firewall/
2016-08-31T00:00:00+00:00
/dependencies/ip_addresses/
2016-08-24T00:00:00+00:00
/entries/Simple_Firewall.html
2016-08-24T00:00:00+00:00
/authors/aissat/
2016-08-18T00:00:00+00:00
/entries/InfPathElimination.html
2016-08-18T00:00:00+00:00
/authors/voisin/
2016-08-18T00:00:00+00:00
/entries/EdmondsKarp_Maxflow.html
2016-08-12T00:00:00+00:00
/dependencies/collections_examples/
2016-08-08T00:00:00+00:00
/dependencies/dijkstra_shortest_path/
2016-08-08T00:00:00+00:00
/dependencies/separation_logic_imperative_hol/
2016-08-08T00:00:00+00:00
/dependencies/sepref_basic/
2016-08-08T00:00:00+00:00
/entries/Refine_Imperative_HOL.html
2016-08-08T00:00:00+00:00
/entries/Ptolemys_Theorem.html
2016-08-07T00:00:00+00:00
/entries/Surprise_Paradox.html
2016-07-17T00:00:00+00:00
/authors/brinkop/
2016-07-14T00:00:00+00:00
/entries/Pairing_Heap.html
2016-07-14T00:00:00+00:00
/entries/DFS_Framework.html
2016-07-05T00:00:00+00:00
/authors/neumann/
2016-07-05T00:00:00+00:00
/entries/Buildings.html
2016-07-01T00:00:00+00:00
/authors/sylvestre/
2016-07-01T00:00:00+00:00
/authors/nagele/
2016-06-30T00:00:00+00:00
/authors/oostrom/
2016-06-30T00:00:00+00:00
/entries/Resolution_FOL.html
2016-06-30T00:00:00+00:00
/entries/Rewriting_Z.html
2016-06-30T00:00:00+00:00
/entries/Dependent_SIFUM_Refinement.html
2016-06-28T00:00:00+00:00
/dependencies/dependent_sifum_type_systems/
2016-06-28T00:00:00+00:00
/entries/IP_Addresses.html
2016-06-28T00:00:00+00:00
/authors/pierzchalski/
2016-06-28T00:00:00+00:00
/authors/sison/
2016-06-28T00:00:00+00:00
/entries/Card_Multisets.html
2016-06-26T00:00:00+00:00
/entries/Category3.html
2016-06-26T00:00:00+00:00
/entries/Dependent_SIFUM_Type_Systems.html
2016-06-25T00:00:00+00:00
/entries/Catalan_Numbers.html
2016-06-21T00:00:00+00:00
/entries/Algebraic_VCs.html
2016-06-18T00:00:00+00:00
/entries/Noninterference_Concurrent_Composition.html
2016-06-13T00:00:00+00:00
/dependencies/noninterference_sequential_composition/
2016-06-13T00:00:00+00:00
/authors/beeren/
2016-06-09T00:00:00+00:00
/authors/fernandez/
2016-06-09T00:00:00+00:00
/entries/Word_Lib.html
2016-06-09T00:00:00+00:00
/authors/gao/
2016-06-09T00:00:00+00:00
/authors/klein/
2016-06-09T00:00:00+00:00
/authors/kolanski/
2016-06-09T00:00:00+00:00
/authors/lim/
2016-06-09T00:00:00+00:00
/authors/matichuk/
2016-06-09T00:00:00+00:00
/authors/sewell/
2016-06-09T00:00:00+00:00
/entries/Tree_Decomposition.html
2016-05-31T00:00:00+00:00
/authors/ausaf/
2016-05-24T00:00:00+00:00
/entries/Card_Equiv_Relations.html
2016-05-24T00:00:00+00:00
/authors/dyckhoff/
2016-05-24T00:00:00+00:00
/entries/Posix-Lexing.html
2016-05-24T00:00:00+00:00
/authors/kuncar/
2016-05-20T00:00:00+00:00
/entries/Perron_Frobenius.html
2016-05-20T00:00:00+00:00
/dependencies/rank_nullity_theorem/
2016-05-20T00:00:00+00:00
/entries/Incredible_Proof_Machine.html
2016-05-20T00:00:00+00:00
/entries/FLP.html
2016-05-18T00:00:00+00:00
/authors/bisping/
2016-05-18T00:00:00+00:00
/authors/brodmann/
2016-05-18T00:00:00+00:00
/authors/nestmann/
2016-05-18T00:00:00+00:00
/authors/peters/
2016-05-18T00:00:00+00:00
/authors/rickmann/
2016-05-18T00:00:00+00:00
/authors/seidler/
2016-05-18T00:00:00+00:00
/authors/stueber/
2016-05-18T00:00:00+00:00
/authors/weidner/
2016-05-18T00:00:00+00:00
/entries/MFMC_Countable.html
2016-05-09T00:00:00+00:00
/dependencies/edmondskarp_maxflow/
2016-05-09T00:00:00+00:00
/entries/Randomised_Social_Choice.html
2016-05-05T00:00:00+00:00
/entries/Bell_Numbers_Spivey.html
2016-05-04T00:00:00+00:00
/entries/SDS_Impossibility.html
2016-05-04T00:00:00+00:00
/entries/Groebner_Bases.html
2016-05-02T00:00:00+00:00
/entries/No_FTL_observers.html
2016-04-28T00:00:00+00:00
/entries/CYK.html
2016-04-27T00:00:00+00:00
/entries/ROBDD.html
2016-04-27T00:00:00+00:00
/entries/Noninterference_Sequential_Composition.html
2016-04-26T00:00:00+00:00
/dependencies/noninterference_ipurge_unwinding/
2016-04-26T00:00:00+00:00
/entries/KAD.html
2016-04-12T00:00:00+00:00
/entries/PropResPI.html
2016-03-11T00:00:00+00:00
/entries/Cartan_FP.html
2016-03-08T00:00:00+00:00
/entries/Timed_Automata.html
2016-03-08T00:00:00+00:00
/dependencies/boolean_expression_checkers/
2016-03-01T00:00:00+00:00
/entries/LTL.html
2016-03-01T00:00:00+00:00
/entries/List_Update.html
2016-02-17T00:00:00+00:00
/dependencies/slicing/
2016-02-05T00:00:00+00:00
/authors/ullrich/
2016-02-05T00:00:00+00:00
/entries/Formal_SSA.html
2016-02-05T00:00:00+00:00
/dependencies/partial_function_mr/
2016-01-29T00:00:00+00:00
/entries/Polynomial_Factorization.html
2016-01-29T00:00:00+00:00
/entries/Polynomial_Interpolation.html
2016-01-29T00:00:00+00:00
/dependencies/sqrt_babylonian/
2016-01-29T00:00:00+00:00
/entries/Knot_Theory.html
2016-01-20T00:00:00+00:00
/authors/prathamesh/
2016-01-20T00:00:00+00:00
/entries/Matrix_Tensor.html
2016-01-18T00:00:00+00:00
/entries/Card_Number_Partitions.html
2016-01-14T00:00:00+00:00
/entries/Triangle.html
2015-12-28T00:00:00+00:00
/entries/Descartes_Sign_Rule.html
2015-12-28T00:00:00+00:00
/entries/Liouville_Numbers.html
2015-12-28T00:00:00+00:00
/entries/Prime_Harmonic_Series.html
2015-12-28T00:00:00+00:00
/entries/Algebraic_Numbers.html
2015-12-22T00:00:00+00:00
/entries/Applicative_Lifting.html
2015-12-22T00:00:00+00:00
/entries/Stern_Brocot.html
2015-12-22T00:00:00+00:00
/entries/Card_Partitions.html
2015-12-12T00:00:00+00:00
/entries/Latin_Square.html
2015-12-02T00:00:00+00:00
/dependencies/marriage/
2015-12-02T00:00:00+00:00
/entries/Ergodic_Theory.html
2015-12-01T00:00:00+00:00
/entries/Euler_Partition.html
2015-11-19T00:00:00+00:00
/entries/TortoiseHare.html
2015-11-18T00:00:00+00:00
/dependencies/case_labeling/
2015-11-11T00:00:00+00:00
/authors/noschinski/
2015-11-11T00:00:00+00:00
/entries/Planarity_Certificates.html
2015-11-11T00:00:00+00:00
/dependencies/simpl/
2015-11-11T00:00:00+00:00
/dependencies/transitive-closure/
2015-11-11T00:00:00+00:00
/entries/Parity_Game.html
2015-11-02T00:00:00+00:00
/entries/Isabelle_Meta_Model.html
2015-09-16T00:00:00+00:00
/entries/LTL_to_DRA.html
2015-09-04T00:00:00+00:00
/dependencies/kbps/
2015-09-04T00:00:00+00:00
/entries/Jordan_Normal_Form.html
2015-08-21T00:00:00+00:00
/entries/Decreasing-Diagrams-II.html
2015-08-20T00:00:00+00:00
/entries/Noninterference_Inductive_Unwinding.html
2015-08-18T00:00:00+00:00
/entries/Rep_Fin_Groups.html
2015-08-12T00:00:00+00:00
/entries/Encodability_Process_Calculi.html
2015-08-10T00:00:00+00:00
/authors/glabbeek/
2015-08-10T00:00:00+00:00
/entries/Case_Labeling.html
2015-07-21T00:00:00+00:00
/entries/Landau_Symbols.html
2015-07-14T00:00:00+00:00
/entries/Akra_Bazzi.html
2015-07-14T00:00:00+00:00
/dependencies/echelon_form/
2015-07-07T00:00:00+00:00
/entries/Hermite.html
2015-07-07T00:00:00+00:00
/entries/Derangements.html
2015-06-27T00:00:00+00:00
/entries/Multirelations.html
2015-06-11T00:00:00+00:00
/authors/furusawa/
2015-06-11T00:00:00+00:00
/dependencies/list_interleaving/
2015-06-11T00:00:00+00:00
/dependencies/noninterference_csp/
2015-06-11T00:00:00+00:00
/entries/List_Interleaving.html
2015-06-11T00:00:00+00:00
/entries/Noninterference_Generic_Unwinding.html
2015-06-11T00:00:00+00:00
/entries/Noninterference_Ipurge_Unwinding.html
2015-06-11T00:00:00+00:00
/entries/Dynamic_Tables.html
2015-06-07T00:00:00+00:00
/dependencies/coinductive_languages/
2015-05-28T00:00:00+00:00
/entries/Formula_Derivatives.html
2015-05-28T00:00:00+00:00
/dependencies/formula_derivatives/
2015-05-28T00:00:00+00:00
/entries/Probabilistic_System_Zoo.html
2015-05-27T00:00:00+00:00
/authors/caminati/
2015-04-30T00:00:00+00:00
/authors/kerber/
2015-04-30T00:00:00+00:00
/authors/lange/
2015-04-30T00:00:00+00:00
/authors/rowat/
2015-04-30T00:00:00+00:00
/entries/Vickrey_Clarke_Groves.html
2015-04-30T00:00:00+00:00
/entries/Residuated_Lattices.html
2015-04-15T00:00:00+00:00
/entries/ConcurrentIMP.html
2015-04-13T00:00:00+00:00
/dependencies/concurrentimp/
2015-04-13T00:00:00+00:00
/authors/engelhardt/
2015-04-13T00:00:00+00:00
/authors/hosking/
2015-04-13T00:00:00+00:00
/entries/ConcurrentGC.html
2015-04-13T00:00:00+00:00
/entries/Trie.html
2015-03-30T00:00:00+00:00
/entries/Consensus_Refined.html
2015-03-18T00:00:00+00:00
/dependencies/heard_of/
2015-03-18T00:00:00+00:00
/entries/Deriving.html
2015-03-11T00:00:00+00:00
/dependencies/launchbury/
2015-02-20T00:00:00+00:00
/entries/Call_Arity.html
2015-02-20T00:00:00+00:00
/dependencies/cayley_hamilton/
2015-02-12T00:00:00+00:00
/entries/Echelon_Form.html
2015-02-12T00:00:00+00:00
/entries/QR_Decomposition.html
2015-02-12T00:00:00+00:00
/entries/Finite_Automata_HF.html
2015-02-05T00:00:00+00:00
/entries/UpDown_Scheme.html
2015-01-28T00:00:00+00:00
/entries/UPF.html
2014-11-28T00:00:00+00:00
/dependencies/awn/
2014-10-23T00:00:00+00:00
/authors/bourke/
2014-10-23T00:00:00+00:00
/entries/AODV.html
2014-10-23T00:00:00+00:00
/entries/Lifting_Definition_Option.html
2014-10-13T00:00:00+00:00
/authors/maximova/
2014-10-10T00:00:00+00:00
/entries/Stream_Fusion_Code.html
2014-10-10T00:00:00+00:00
/entries/Density_Compiler.html
2014-10-09T00:00:00+00:00
/entries/RefinementReactive.html
2014-10-08T00:00:00+00:00
/authors/preoteasa/
2014-10-08T00:00:00+00:00
/entries/Certification_Monads.html
2014-10-03T00:00:00+00:00
/entries/XML.html
2014-10-03T00:00:00+00:00
/entries/Imperative_Insertion_Sort.html
2014-09-25T00:00:00+00:00
/entries/Sturm_Tarski.html
2014-09-19T00:00:00+00:00
/authors/adelsberger/
2014-09-15T00:00:00+00:00
/authors/hetzl/
2014-09-15T00:00:00+00:00
/authors/pollak/
2014-09-15T00:00:00+00:00
/entries/Cayley_Hamilton.html
2014-09-15T00:00:00+00:00
/authors/raumer/
2014-09-09T00:00:00+00:00
/dependencies/secondary_sylow/
2014-09-09T00:00:00+00:00
/entries/Jordan_Hoelder.html
2014-09-09T00:00:00+00:00
/entries/Priority_Queue_Braun.html
2014-09-04T00:00:00+00:00
/entries/Gauss_Jordan.html
2014-09-03T00:00:00+00:00
/authors/lee/
2014-08-29T00:00:00+00:00
/entries/Special_Function_Bounds.html
2014-08-29T00:00:00+00:00
/entries/VectorSpace.html
2014-08-29T00:00:00+00:00
/entries/Skew_Heap.html
2014-08-13T00:00:00+00:00
/entries/Splay_Tree.html
2014-08-12T00:00:00+00:00
/entries/Show.html
2014-07-29T00:00:00+00:00
/authors/blasum/
2014-07-18T00:00:00+00:00
/authors/feliachi/
2014-07-18T00:00:00+00:00
/entries/CISC-Kernel.html
2014-07-18T00:00:00+00:00
/authors/havle/
2014-07-18T00:00:00+00:00
/authors/langenstein/
2014-07-18T00:00:00+00:00
/authors/schmaltz/
2014-07-18T00:00:00+00:00
/authors/stephan/
2014-07-18T00:00:00+00:00
/authors/tverdyshev/
2014-07-18T00:00:00+00:00
/authors/cock/
2014-07-13T00:00:00+00:00
/entries/pGCL.html
2014-07-13T00:00:00+00:00
/entries/Amortized_Complexity.html
2014-07-07T00:00:00+00:00
/dependencies/skew_heap/
2014-07-07T00:00:00+00:00
/dependencies/splay_tree/
2014-07-07T00:00:00+00:00
/entries/Network_Security_Policy_Verification.html
2014-07-04T00:00:00+00:00
/authors/coglio/
2014-07-03T00:00:00+00:00
/entries/Pop_Refinement.html
2014-07-03T00:00:00+00:00
/entries/MSO_Regex_Equivalence.html
2014-06-12T00:00:00+00:00
/entries/Boolean_Expression_Checkers.html
2014-06-08T00:00:00+00:00
/entries/CAVA_LTL_Modelchecker.html
2014-05-28T00:00:00+00:00
/dependencies/cava_base/
2014-05-28T00:00:00+00:00
/dependencies/cava_setup/
2014-05-28T00:00:00+00:00
/entries/LTL_to_GBA.html
2014-05-28T00:00:00+00:00
/authors/esparza/
2014-05-28T00:00:00+00:00
/dependencies/ltl_to_gba/
2014-05-28T00:00:00+00:00
/dependencies/partial_order_reduction/
2014-05-28T00:00:00+00:00
/dependencies/promela/
2014-05-28T00:00:00+00:00
/entries/Promela.html
2014-05-28T00:00:00+00:00
/authors/schimpf/
2014-05-28T00:00:00+00:00
/dependencies/sm/
2014-05-28T00:00:00+00:00
/dependencies/sm_base/
2014-05-28T00:00:00+00:00
/authors/smaus/
2014-05-28T00:00:00+00:00
/entries/CAVA_Automata.html
2014-05-28T00:00:00+00:00
/entries/Gabow_SCC.html
2014-05-28T00:00:00+00:00
/entries/Noninterference_CSP.html
2014-05-23T00:00:00+00:00
/entries/Roy_Floyd_Warshall.html
2014-05-23T00:00:00+00:00
/authors/wenzel/
2014-05-23T00:00:00+00:00
/entries/Regular_Algebras.html
2014-05-21T00:00:00+00:00
/entries/ComponentDependencies.html
2014-04-28T00:00:00+00:00
/authors/spichkova/
2014-04-28T00:00:00+00:00
/entries/SIFUM_Type_Systems.html
2014-04-23T00:00:00+00:00
/entries/WHATandWHERE_Security.html
2014-04-23T00:00:00+00:00
/entries/Strong_Security.html
2014-04-23T00:00:00+00:00
/authors/lux/
2014-04-23T00:00:00+00:00
/authors/sauer/
2014-04-23T00:00:00+00:00
/authors/schoepe/
2014-04-23T00:00:00+00:00
/dependencies/strong_security/
2014-04-23T00:00:00+00:00
/entries/Bounded_Deducibility_Security.html
2014-04-22T00:00:00+00:00
/entries/HyperCTL.html
2014-04-16T00:00:00+00:00
/entries/Abstract_Completeness.html
2014-04-16T00:00:00+00:00
/authors/rabe/
2014-04-16T00:00:00+00:00
/entries/Discrete_Summation.html
2014-04-13T00:00:00+00:00
/authors/haftmann/
2014-04-13T00:00:00+00:00
/entries/GPU_Kernel_PL.html
2014-04-03T00:00:00+00:00
/authors/wickerson/
2014-04-03T00:00:00+00:00
/entries/Probabilistic_Noninterference.html
2014-03-11T00:00:00+00:00
/entries/AWN.html
2014-03-08T00:00:00+00:00
/entries/Partial_Function_MR.html
2014-02-18T00:00:00+00:00
/entries/Random_Graph_Subgraph_Threshold.html
2014-02-13T00:00:00+00:00
/authors/petrovic/
2014-02-11T00:00:00+00:00
/entries/Selection_Heap_Sort.html
2014-02-11T00:00:00+00:00
/entries/Affine_Arithmetic.html
2014-02-07T00:00:00+00:00
/entries/Real_Impl.html
2014-02-06T00:00:00+00:00
/entries/Regex_Equivalence.html
2014-01-30T00:00:00+00:00
/entries/Secondary_Sylow.html
2014-01-28T00:00:00+00:00
/authors/armstrong/
2014-01-25T00:00:00+00:00
/entries/Relation_Algebra.html
2014-01-25T00:00:00+00:00
/entries/KAT_and_DRA.html
2014-01-23T00:00:00+00:00
/entries/Featherweight_OCL.html
2014-01-16T00:00:00+00:00
/entries/CryptoBasedCompositionalProperties.html
2014-01-11T00:00:00+00:00
/entries/Sturm_Sequences.html
2014-01-11T00:00:00+00:00
/entries/Tail_Recursive_Functions.html
2013-12-01T00:00:00+00:00
/entries/Incompleteness.html
2013-11-17T00:00:00+00:00
/entries/HereditarilyFinite.html
2013-11-17T00:00:00+00:00
/entries/Coinductive_Languages.html
2013-11-15T00:00:00+00:00
/entries/FocusStreamsCaseStudies.html
2013-11-14T00:00:00+00:00
/entries/GoedelGod.html
2013-11-12T00:00:00+00:00
/authors/paleo/
2013-11-12T00:00:00+00:00
/entries/Decreasing-Diagrams.html
2013-11-01T00:00:00+00:00
/authors/zankl/
2013-11-01T00:00:00+00:00
/entries/Automatic_Refinement.html
2013-10-02T00:00:00+00:00
/entries/Native_Word.html
2013-09-17T00:00:00+00:00
/entries/IEEE_Floating_Point.html
2013-07-27T00:00:00+00:00
/authors/yu/
2013-07-27T00:00:00+00:00
/dependencies/lehmer/
2013-07-22T00:00:00+00:00
/entries/Lehmer.html
2013-07-22T00:00:00+00:00
/entries/Pratt_Certificate.html
2013-07-22T00:00:00+00:00
/entries/Koenigsberg_Friendship.html
2013-07-19T00:00:00+00:00
/entries/Sort_Encodings.html
2013-06-27T00:00:00+00:00
/entries/ShortestPath.html
2013-05-22T00:00:00+00:00
/entries/Graph_Theory.html
2013-04-28T00:00:00+00:00
/dependencies/finger-trees/
2013-04-15T00:00:00+00:00
/entries/Containers.html
2013-04-15T00:00:00+00:00
/dependencies/trie/
2013-04-15T00:00:00+00:00
/entries/Nominal2.html
2013-02-21T00:00:00+00:00
/entries/Launchbury.html
2013-01-31T00:00:00+00:00
/entries/Ribbon_Proofs.html
2013-01-19T00:00:00+00:00
/entries/Rank_Nullity_Theorem.html
2013-01-16T00:00:00+00:00
/entries/Kleene_Algebra.html
2013-01-15T00:00:00+00:00
/dependencies/cauchy/
2013-01-03T00:00:00+00:00
/entries/Sqrt_Babylonian.html
2013-01-03T00:00:00+00:00
/entries/Separation_Logic_Imperative_HOL.html
2012-11-14T00:00:00+00:00
/authors/meis/
2012-11-14T00:00:00+00:00
/authors/ogawa/
2012-11-02T00:00:00+00:00
/entries/Open_Induction.html
2012-11-02T00:00:00+00:00
/authors/makarios/
2012-10-30T00:00:00+00:00
/entries/Tarskis_Geometry.html
2012-10-30T00:00:00+00:00
/authors/avigad/
2012-10-27T00:00:00+00:00
/entries/Bondy.html
2012-10-27T00:00:00+00:00
/entries/Possibilistic_Noninterference.html
2012-09-10T00:00:00+00:00
/entries/Datatype_Order_Generator.html
2012-08-07T00:00:00+00:00
/entries/Impossible_Geometry.html
2012-08-05T00:00:00+00:00
/authors/romanos/
2012-08-05T00:00:00+00:00
/authors/debrat/
2012-07-27T00:00:00+00:00
/entries/Heard_Of.html
2012-07-27T00:00:00+00:00
/entries/PCF.html
2012-07-01T00:00:00+00:00
/entries/Tycon.html
2012-06-26T00:00:00+00:00
/authors/bengtson/
2012-05-29T00:00:00+00:00
/entries/CCS.html
2012-05-29T00:00:00+00:00
/entries/Psi_Calculi.html
2012-05-29T00:00:00+00:00
/entries/Pi_Calculus.html
2012-05-29T00:00:00+00:00
/authors/gaudel/
2012-05-27T00:00:00+00:00
/entries/Circus.html
2012-05-27T00:00:00+00:00
/authors/boyton/
2012-05-11T00:00:00+00:00
/entries/Separation_Algebra.html
2012-05-11T00:00:00+00:00
/entries/Stuttering_Equivalence.html
2012-05-07T00:00:00+00:00
/authors/bella/
2012-05-02T00:00:00+00:00
/entries/Inductive_Confidentiality.html
2012-05-02T00:00:00+00:00
/dependencies/lorenz_approximation/
2012-04-26T00:00:00+00:00
/entries/Ordinary_Differential_Equations.html
2012-04-26T00:00:00+00:00
/entries/Well_Quasi_Orders.html
2012-04-13T00:00:00+00:00
/entries/Abortable_Linearizable_Modules.html
2012-03-01T00:00:00+00:00
/authors/guerraoui/
2012-03-01T00:00:00+00:00
/authors/kuncak/
2012-03-01T00:00:00+00:00
/entries/Transitive-Closure-II.html
2012-02-29T00:00:00+00:00
/entries/Girth_Chromatic.html
2012-02-06T00:00:00+00:00
/entries/Dijkstra_Shortest_Path.html
2012-01-30T00:00:00+00:00
/entries/Refine_Monadic.html
2012-01-30T00:00:00+00:00
/dependencies/gauss-jordan-elim-fun/
2012-01-03T00:00:00+00:00
/entries/Markov_Models.html
2012-01-03T00:00:00+00:00
/entries/TLA.html
2011-11-19T00:00:00+00:00
/authors/grov/
2011-11-19T00:00:00+00:00
/entries/Efficient-Mergesort.html
2011-11-09T00:00:00+00:00
/entries/MonoBoolTranAlgebra.html
2011-09-22T00:00:00+00:00
/authors/georgescu/
2011-09-22T00:00:00+00:00
/entries/LatticeProperties.html
2011-09-22T00:00:00+00:00
/dependencies/latticeproperties/
2011-09-22T00:00:00+00:00
/authors/leustean/
2011-09-22T00:00:00+00:00
/entries/PseudoHoops.html
2011-09-22T00:00:00+00:00
/entries/Myhill-Nerode.html
2011-08-26T00:00:00+00:00
/authors/wu/
2011-08-26T00:00:00+00:00
/entries/Gauss-Jordan-Elim-Fun.html
2011-08-19T00:00:00+00:00
/entries/Max-Card-Matching.html
2011-07-21T00:00:00+00:00
/entries/KBPs.html
2011-05-17T00:00:00+00:00
/entries/General-Triangle.html
2011-04-01T00:00:00+00:00
/entries/Transitive-Closure.html
2011-03-14T00:00:00+00:00
/entries/AutoFocus-Stream.html
2011-02-23T00:00:00+00:00
/entries/List-Infinite.html
2011-02-23T00:00:00+00:00
/entries/Nat-Interval-Logic.html
2011-02-23T00:00:00+00:00
/dependencies/list-infinite/
2011-02-23T00:00:00+00:00
/dependencies/nat-interval-logic/
2011-02-23T00:00:00+00:00
/authors/trachtenherz/
2011-02-23T00:00:00+00:00
/entries/LightweightJava.html
2011-02-07T00:00:00+00:00
/authors/parkinson/
2011-02-07T00:00:00+00:00
/authors/strnisa/
2011-02-07T00:00:00+00:00
/entries/RIPEMD-160-SPARK.html
2011-01-10T00:00:00+00:00
/authors/grechuk/
2011-01-08T00:00:00+00:00
/entries/Lower_Semicontinuous.html
2011-01-08T00:00:00+00:00
/entries/Marriage.html
2010-12-17T00:00:00+00:00
/authors/jiangd/
2010-12-17T00:00:00+00:00
/entries/Shivers-CFA.html
2010-11-16T00:00:00+00:00
/entries/Binomial-Heaps.html
2010-10-28T00:00:00+00:00
/entries/Finger-Trees.html
2010-10-28T00:00:00+00:00
/entries/Binomial-Queues.html
2010-10-28T00:00:00+00:00
/authors/koerner/
2010-10-28T00:00:00+00:00
/authors/nielsen/
2010-10-28T00:00:00+00:00
/authors/doczkal/
2010-08-29T00:00:00+00:00
/entries/Lam-ml-Normalization.html
2010-08-29T00:00:00+00:00
/entries/Polynomials.html
2010-08-10T00:00:00+00:00
/entries/Statecharts.html
2010-08-08T00:00:00+00:00
/authors/helke/
2010-08-08T00:00:00+00:00
/entries/Free-Groups.html
2010-06-24T00:00:00+00:00
/entries/Category2.html
2010-06-20T00:00:00+00:00
/authors/katovsky/
2010-06-20T00:00:00+00:00
/entries/Matrix.html
2010-06-17T00:00:00+00:00
/entries/Abstract-Rewriting.html
2010-06-14T00:00:00+00:00
/authors/back/
2010-05-28T00:00:00+00:00
/dependencies/datarefinementibp/
2010-05-28T00:00:00+00:00
/entries/DataRefinementIBP.html
2010-05-28T00:00:00+00:00
/entries/GraphMarkingIBP.html
2010-05-28T00:00:00+00:00
/entries/Robbins-Conjecture.html
2010-05-22T00:00:00+00:00
/authors/krauss/
2010-05-12T00:00:00+00:00
/entries/Regular-Sets.html
2010-05-12T00:00:00+00:00
/authors/henrio/
2010-04-30T00:00:00+00:00
/entries/Locally-Nameless-Sigma.html
2010-04-30T00:00:00+00:00
/authors/lutz/
2010-04-30T00:00:00+00:00
/authors/sudhof/
2010-04-30T00:00:00+00:00
/entries/Free-Boolean-Algebra.html
2010-03-29T00:00:00+00:00
/dependencies/hrb-slicing/
2010-03-23T00:00:00+00:00
/entries/InformationFlowSlicing.html
2010-03-23T00:00:00+00:00
/entries/InformationFlowSlicing_Inter.html
2010-03-23T00:00:00+00:00
/authors/wasserrab/
2010-03-23T00:00:00+00:00
/entries/List-Index.html
2010-02-20T00:00:00+00:00
/entries/Coinductive.html
2010-02-12T00:00:00+00:00
/entries/DPT-SAT-Solver.html
2009-12-09T00:00:00+00:00
/authors/heller/
2009-12-09T00:00:00+00:00
/entries/Presburger-Automata.html
2009-12-03T00:00:00+00:00
/authors/reiter/
2009-12-03T00:00:00+00:00
/dependencies/binomial-heaps/
2009-11-25T00:00:00+00:00
/entries/Collections.html
2009-11-25T00:00:00+00:00
/entries/Tree-Automata.html
2009-11-25T00:00:00+00:00
/authors/ijbema/
2009-11-22T00:00:00+00:00
/entries/Perfect-Number-Thm.html
2009-11-22T00:00:00+00:00
/entries/HRB-Slicing.html
2009-11-13T00:00:00+00:00
/entries/WorkerWrapper.html
2009-10-30T00:00:00+00:00
/entries/Ordinals_and_Cardinals.html
2009-09-01T00:00:00+00:00
/authors/chapman/
2009-08-28T00:00:00+00:00
/entries/SequentInvertibility.html
2009-08-28T00:00:00+00:00
/entries/CofGroups.html
2009-08-04T00:00:00+00:00
/authors/kastermans/
2009-08-04T00:00:00+00:00
/entries/FinFun.html
2009-05-06T00:00:00+00:00
/entries/Stream-Fusion.html
2009-04-29T00:00:00+00:00
/entries/BytecodeLogicJmlTypes.html
2008-12-12T00:00:00+00:00
/authors/beringer/
2008-12-12T00:00:00+00:00
/authors/hofmann/
2008-12-12T00:00:00+00:00
/entries/SIFPL.html
2008-11-10T00:00:00+00:00
/entries/SenSocialChoice.html
2008-11-09T00:00:00+00:00
/entries/FunWithTilings.html
2008-11-07T00:00:00+00:00
/entries/Huffman.html
2008-10-15T00:00:00+00:00
/entries/Slicing.html
2008-09-16T00:00:00+00:00
/entries/VolpanoSmith.html
2008-09-02T00:00:00+00:00
/authors/snelting/
2008-09-02T00:00:00+00:00
/entries/ArrowImpossibilityGS.html
2008-09-01T00:00:00+00:00
/entries/FunWithFunctions.html
2008-08-26T00:00:00+00:00
/entries/SATSolverVerification.html
2008-07-23T00:00:00+00:00
/authors/nedzelsky/
2008-04-05T00:00:00+00:00
/entries/Recursion-Theory-I.html
2008-04-05T00:00:00+00:00
/entries/Simpl.html
2008-02-29T00:00:00+00:00
/entries/BDD.html
2008-02-29T00:00:00+00:00
/authors/ortner/
2008-02-29T00:00:00+00:00
/authors/aehlig/
2008-02-18T00:00:00+00:00
/entries/NormByEval.html
2008-02-18T00:00:00+00:00
/entries/LinearQuantifierElim.html
2008-01-11T00:00:00+00:00
/entries/Program-Conflict-Analysis.html
2007-12-14T00:00:00+00:00
/authors/olm/
2007-12-14T00:00:00+00:00
/entries/JinjaThreads.html
2007-12-03T00:00:00+00:00
/authors/boehme/
2007-11-06T00:00:00+00:00
/entries/MuchAdoAboutTwo.html
2007-11-06T00:00:00+00:00
/entries/Fermat3_4.html
2007-08-12T00:00:00+00:00
/authors/oosterhuis/
2007-08-12T00:00:00+00:00
/entries/SumSquares.html
2007-08-12T00:00:00+00:00
/entries/Valuation.html
2007-08-08T00:00:00+00:00
/dependencies/group-ring-module/
2007-08-08T00:00:00+00:00
/authors/kobayashi/
2007-08-08T00:00:00+00:00
/entries/FOL-Fitting.html
2007-08-02T00:00:00+00:00
/entries/POPLmark-deBruijn.html
2007-08-02T00:00:00+00:00
/entries/HotelKeyCards.html
2006-09-09T00:00:00+00:00
/entries/Abstract-Hoare-Logics.html
2006-08-08T00:00:00+00:00
/authors/bauer/
2006-05-22T00:00:00+00:00
/entries/Flyspeck-Tame.html
2006-05-22T00:00:00+00:00
/dependencies/flyspeck-tame/
2006-05-22T00:00:00+00:00
/entries/CoreC++.html
2006-05-15T00:00:00+00:00
/entries/FeatherweightJava.html
2006-03-31T00:00:00+00:00
/authors/fosterj/
2006-03-31T00:00:00+00:00
/authors/vytiniotis/
2006-03-31T00:00:00+00:00
/authors/barsotti/
2006-03-15T00:00:00+00:00
/entries/ClockSynchInst.html
2006-03-15T00:00:00+00:00
/entries/Cauchy.html
2006-03-14T00:00:00+00:00
/authors/porter/
2006-03-14T00:00:00+00:00
/entries/Ordinal.html
2005-11-11T00:00:00+00:00
/entries/FFT.html
2005-10-12T00:00:00+00:00
/entries/GenClock.html
2005-06-24T00:00:00+00:00
/authors/jaskelioff/
2005-06-22T00:00:00+00:00
/entries/DiskPaxos.html
2005-06-22T00:00:00+00:00
/entries/JiveDataStoreModel.html
2005-06-20T00:00:00+00:00
/authors/rauch/
2005-06-20T00:00:00+00:00
/entries/Jinja.html
2005-06-01T00:00:00+00:00
/authors/lindenberg/
2005-05-02T00:00:00+00:00
/entries/RSAPSS.html
2005-05-02T00:00:00+00:00
/authors/wirt/
2005-05-02T00:00:00+00:00
/entries/Category.html
2005-04-21T00:00:00+00:00
/authors/keefe/
2005-04-21T00:00:00+00:00
/entries/FileRefinement.html
2004-12-09T00:00:00+00:00
/authors/zee/
2004-12-09T00:00:00+00:00
/entries/Integration.html
2004-11-19T00:00:00+00:00
/authors/richter/
2004-11-19T00:00:00+00:00
/entries/Verified-Prover.html
2004-09-28T00:00:00+00:00
/authors/ridge/
2004-09-28T00:00:00+00:00
/entries/Completeness.html
2004-09-20T00:00:00+00:00
/authors/margetson/
2004-09-20T00:00:00+00:00
/entries/Ramsey-Infinite.html
2004-09-20T00:00:00+00:00
/entries/Compiling-Exceptions-Correctly.html
2004-07-09T00:00:00+00:00
/entries/Depth-First-Search.html
2004-06-24T00:00:00+00:00
/authors/nishihara/
2004-06-24T00:00:00+00:00
/authors/chen/
2004-05-18T00:00:00+00:00
/entries/Group-Ring-Module.html
2004-05-18T00:00:00+00:00
/authors/murao/
2004-05-18T00:00:00+00:00
/authors/friedrich/
2004-04-26T00:00:00+00:00
/entries/Lazy-Lists-II.html
2004-04-26T00:00:00+00:00
/dependencies/lazy-lists-ii/
2004-04-26T00:00:00+00:00
/entries/Topology.html
2004-04-26T00:00:00+00:00
/entries/BinarySearchTree.html
2004-04-05T00:00:00+00:00
/entries/Functional-Automata.html
2004-03-30T00:00:00+00:00
/entries/AVL-Trees.html
2004-03-19T00:00:00+00:00
/entries/MiniML.html
2004-03-19T00:00:00+00:00
/authors/naraschewski/
2004-03-19T00:00:00+00:00
/authors/pusch/
2004-03-19T00:00:00+00:00
/webapp/
/theories/abortable_linearizable_modules/
/about/
/theories/abs_int_itp2012/
/theories/abstract-hoare-logics/
/theories/abstract-rewriting/
/theories/abstract_completeness/
/theories/abstract_soundness/
/theories/aby3_protocols/
/theories/ackermanns_not_pr/
/theories/actuarial_mathematics/
/theories/adaptive_state_counting/
/theories/ads_functor/
/theories/affine_arithmetic/
/theories/aggregation_algebras/
/theories/ai_planning_languages_semantics/
/theories/akra_bazzi/
/theories/algebraic_numbers/
/theories/algebraic_vcs/
/theories/allen_calculus/
/theories/amicable_numbers/
/theories/amortized_complexity/
/theories/anselmgod/
/theories/aodv/
/theories/aot/
/theories/applicative_lifting/
/theories/approximation_algorithms/
/theories/architectural_design_patterns/
/theories/aristotles_assertoric_syllogistic/
/theories/arith_prog_rel_primes/
/theories/arrowimpossibilitygs/
/theories/attack_trees/
/theories/auto2_hol/
/theories/auto2_imperative_hol/
/theories/autofocus-stream/
/theories/automated_stateful_protocol_verification/
/theories/automatic_refinement/
/theories/avl-trees/
/theories/awn/
/theories/axiomaticcategorytheory/
/theories/balog_szemeredi_gowers/
/theories/banach_steinhaus/
/theories/bd_security_compositional/
/theories/bdd/
/theories/belief_revision/
/theories/bell_numbers_spivey/
/theories/benor_kozen_reif/
/theories/berlekamp_zassenhaus/
/theories/bernoulli/
/theories/bertrands_postulate/
/theories/bicategory/
/theories/binary_code_imprimitive/
/theories/binarysearchtree/
/theories/binding_syntax_theory/
/theories/binomial-heaps/
/theories/binomial-queues/
/theories/birdkmp/
/theories/birkhoff_finite_distributive_lattices/
/theories/blue_eyes/
/theories/bnf_cc/
/theories/bnf_operations/
/theories/bondy/
/theories/boolean_expression_checkers/
/theories/boolos_curious_inference/
/theories/boolos_curious_inference_automated/
/theories/bounded_deducibility_security/
/theories/btree/
/theories/buchi_complementation/
/theories/budan_fourier/
/theories/buffons_needle/
/theories/buildings/
/theories/bytecodelogicjmltypes/
/theories/c2ka_distributedsystems/
/theories/cakeml/
/theories/cakeml_codegen/
/theories/call_arity/
/theories/card_equiv_relations/
/theories/card_multisets/
/theories/card_number_partitions/
/theories/card_partitions/
/theories/cartan_fp/
/theories/case_labeling/
/theories/catalan_numbers/
/theories/category/
/theories/category2/
/theories/category3/
/theories/cauchy/
/theories/cava_automata/
/theories/cava_base/
/theories/cava_ltl_modelchecker/
/theories/cava_setup/
/theories/cayley_hamilton/
/theories/ccs/
/theories/certification_monads/
/theories/chandy_lamport/
/theories/cheri-c_memory_model/
/theories/chord_segments/
/theories/circus/
/theories/cisc-kernel/
/theories/clean/
/theories/clique_and_monotone_circuits/
/theories/clocksynchinst/
/theories/closest_pair_points/
/theories/cocon/
/theories/cofgroups/
/theories/coinductive/
/theories/coinductive_languages/
/theories/collections/
/theories/collections_examples/
/theories/combinable_wands/
/theories/combinatorial_enumeration_algorithms/
/theories/combinatorics_words/
/theories/combinatorics_words_graph_lemma/
/theories/combinatorics_words_lyndon/
/theories/commcsl/
/theories/commuting_hermitian/
/theories/comparison_sort_lower_bound/
/theories/compiling-exceptions-correctly/
/theories/complete_non_orders/
/theories/completeness/
/theories/complex_bounded_operators/
/theories/complex_bounded_operators_dependencies/
/theories/complex_geometry/
/theories/complx/
/theories/componentdependencies/
/topics/computer-science/algorithms/
/topics/computer-science/algorithms/approximation/
/topics/computer-science/algorithms/concurrent/
/topics/computer-science/algorithms/distributed/
/topics/computer-science/algorithms/geometry/
/topics/computer-science/algorithms/graph/
/topics/computer-science/algorithms/mathematical/
/topics/computer-science/algorithms/online/
/topics/computer-science/algorithms/optimization/
/topics/computer-science/algorithms/quantum-computing/
/topics/computer-science/algorithms/randomized/
/topics/computer-science/artificial-intelligence/
/topics/computer-science/automata-and-formal-languages/
/topics/computer-science/concurrency/
/topics/computer-science/concurrency/process-calculi/
/topics/computer-science/data-management-systems/
/topics/computer-science/data-structures/
/topics/computer-science/functional-programming/
/topics/computer-science/hardware/
/topics/computer-science/machine-learning/
/topics/computer-science/networks/
/topics/computer-science/programming-languages/
/topics/computer-science/programming-languages/compiling/
/topics/computer-science/programming-languages/lambda-calculi/
/topics/computer-science/programming-languages/language-definitions/
/topics/computer-science/programming-languages/logics/
/topics/computer-science/programming-languages/misc/
/topics/computer-science/programming-languages/static-analysis/
/topics/computer-science/programming-languages/type-systems/
/topics/computer-science/security/
/topics/computer-science/security/cryptography/
/topics/computer-science/semantics-and-reasoning/
/topics/computer-science/system-description-languages/
/theories/concurrent_ref_alg/
/theories/concurrent_revisions/
/theories/concurrentgc/
/theories/concurrentimp/
/theories/conditional_simplification/
/theories/conditional_transfer_rule/
/theories/consensus_refined/
/theories/constructive_cryptography/
/theories/constructive_cryptography_cm/
/theories/constructor_funs/
/theories/containers/
/theories/containers-benchmarks/
/theories/cook_levin/
/theories/core_dom/
/theories/core_sc_dom/
/theories/corec++/
/theories/correctness_algebras/
/theories/cosmed/
/theories/cosmedis/
/theories/cotangent_pfd_formula/
/theories/count_complex_roots/
/theories/crdt/
/theories/crypthol/
/theories/crypto_standards/
/theories/cryptobasedcompositionalproperties/
/theories/crystals-kyber/
/theories/csp_reftk/
/theories/cubic_quartic_equations/
/theories/cvp_hardness/
/theories/cyk/
/theories/czh_elementary_categories/
/theories/czh_foundations/
/theories/czh_universal_constructions/
/theories/datarefinementibp/
/theories/datatype_order_generator/
/theories/dcr-executionequivalence/
/theories/decl_sem_fun_pl/
/theories/decreasing-diagrams/
/theories/decreasing-diagrams-ii/
/theories/dedekind_real/
/theories/deep_learning/
/theories/delta_system_lemma/
/theories/density_compiler/
/theories/dependent_sifum_refinement/
/theories/dependent_sifum_type_systems/
/theories/depth-first-search/
/theories/derangements/
/theories/deriving/
/theories/descartes_sign_rule/
/theories/design_theory/
/theories/dfs_framework/
/theories/dict_construction/
/theories/differential_dynamic_logic/
/theories/differential_game_logic/
/theories/digit_expansions/
/theories/digitsinbase/
/theories/dijkstra_shortest_path/
/theories/diophantine_eqns_lin_hom/
/theories/directed_sets/
/theories/dirichlet_l/
/theories/dirichlet_series/
/theories/discrete_summation/
/theories/discretepricing/
/theories/diskpaxos/
/theories/distributed_distinct_elements/
/theories/dom_components/
/theories/dominance_chk/
/download/
/theories/dprm_theorem/
/theories/dpt-sat-solver/
/theories/dynamic_tables/
/theories/dynamicarchitectures/
/theories/e_transcendental/
/theories/echelon_form/
/theories/edmondskarp_maxflow/
/theories/edwards_elliptic_curves_group/
/theories/efficient-mergesort/
/theories/efficient_weighted_path_order/
/theories/elliptic_curves_group_law/
/theories/encodability_process_calculi/
/submission/
/theories/epistemic_logic/
/theories/equivalence_relation_enumeration/
/theories/ergodic_theory/
/theories/error_function/
/theories/euler_maclaurin/
/theories/euler_partition/
/theories/eval_fo/
+ /theories/example-submission/
+
/theories/executable_randomized_algorithms/
/theories/expander_graphs/
/theories/extended_finite_state_machine_inference/
/theories/extended_finite_state_machines/
/theories/factor_algebraic_polynomial/
/theories/factored_transition_system_bounding/
/theories/falling_factorial_sum/
/theories/farkas/
/theories/featherweight_ocl/
/theories/featherweightjava/
/theories/fermat3_4/
/theories/fft/
/theories/filerefinement/
/theories/finfun/
/theories/finger-trees/
/theories/finite-map-extras/
/theories/finite_automata_hf/
/theories/finite_fields/
/theories/finitely_generated_abelian_groups/
/theories/first_order_terms/
/theories/first_welfare_theorem/
/theories/fishburn_impossibility/
/theories/fisher_yates/
/theories/fishers_inequality/
/theories/flow_networks/
/theories/floyd_warshall/
/theories/flp/
/theories/flyspeck-tame/
/theories/flyspeck-tame-computation/
/theories/fo_theory_rewriting/
/theories/focusstreamscasestudies/
/theories/fol-fitting/
/theories/fol_axiomatic/
/theories/fol_harrison/
/theories/fol_seq_calc1/
/theories/fol_seq_calc2/
/theories/fol_seq_calc3/
/theories/forcing/
/theories/formal_puiseux_series/
/theories/formal_ssa/
/theories/formula_derivatives/
/theories/formula_derivatives-examples/
/theories/foundation_of_geometry/
/theories/fourier/
/theories/free-boolean-algebra/
/theories/free-groups/
/theories/frequency_moments/
/theories/fresh_identifiers/
/theories/fsm_tests/
/theories/functional-automata/
/theories/functional_ordered_resolution_prover/
/theories/funwithfunctions/
/theories/funwithtilings/
/theories/furstenberg_topology/
/theories/gabow_scc/
/theories/gale_shapley/
/theories/galestewart_games/
/theories/game_based_crypto/
/theories/gauss-jordan-elim-fun/
/theories/gauss_jordan/
/theories/gauss_sums/
/theories/gaussian_integers/
/theories/genclock/
/theories/general-triangle/
/theories/generalized_counting_sort/
/theories/generic_deriving/
/theories/generic_join/
/theories/gewirthpgcproof/
/theories/girth_chromatic/
/theories/given_clause_loops/
/theories/goedel_hfset_semantic/
/theories/goedel_hfset_semanticless/
/theories/goedel_incompleteness/
/theories/goedelgod/
/theories/goodstein_lambda/
/theories/gpu_kernel_pl/
/theories/graph_saturation/
/theories/graph_theory/
/theories/graphmarkingibp/
/theories/gray_codes/
/theories/green/
/theories/groebner_bases/
/theories/groebner_macaulay/
/theories/gromov_hyperbolicity/
/theories/grothendieck_schemes/
/theories/group-ring-module/
/theories/hahn_jordan_decomposition/
/theories/hales_jewett/
/theories/heard_of/
/theories/hello_world/
/help/
/theories/hereditarilyfinite/
/theories/hermite/
/theories/hermite_lindemann/
/theories/hidden_markov_models/
/theories/higher_order_terms/
/theories/hoare_time/
/theories/hoarefordivergence/
/theories/hol-csp/
/theories/hol-ode-arch-comp/
/theories/hol-ode-examples/
/theories/hol-ode-numerics/
/theories/holcf-prelude/
/theories/hood_melville_queue/
/theories/hotelkeycards/
/theories/hrb-slicing/
/theories/huffman/
/theories/hybrid_logic/
/theories/hybrid_multi_lane_spatial_logic/
/theories/hybrid_systems_vcs/
/theories/hyperctl/
/theories/hyperdual/
/theories/hyperhoarelogic/
/theories/ieee_floating_point/
/theories/ifc_tracking/
/theories/imap-crdt/
/theories/imo2019/
/theories/imp2/
/theories/imp2_binary_heap/
/theories/imp_compiler/
/theories/imp_compiler_reuse/
/theories/imperative_insertion_sort/
/theories/implicational_logic/
/theories/impossible_geometry/
/theories/incompleteness/
/theories/incredible_proof_machine/
/theories/independence_ch/
/theories/inductive_confidentiality/
/theories/inductive_inference/
/theories/informationflowslicing/
/theories/informationflowslicing_inter/
/theories/infpathelimination/
/theories/integration/
/theories/interpolation_polynomials_hol_algebra/
/theories/interpreter_optimizations/
/theories/interval_arithmetic_word32/
/theories/intro_dest_elim/
/theories/involutions2squares/
/theories/ip_addresses/
/theories/iptables_semantics/
/theories/iptables_semantics_examples/
/theories/iptables_semantics_examples_big/
/theories/irrational_series_erdos_straus/
/theories/irrationality_j_hancl/
/theories/irrationals_from_thebook/
/theories/isabelle_c/
/theories/isabelle_marries_dirac/
/theories/isabelle_meta_model/
/theories/isageocoq/
/theories/isanet/
/theories/jacobson_basic_algebra/
/theories/jinja/
/theories/jinjadci/
/theories/jinjathreads/
/theories/jivedatastoremodel/
/theories/jordan_hoelder/
/theories/jordan_normal_form/
/theories/kad/
/theories/kat_and_dra/
/theories/kbps/
/theories/kd_tree/
/theories/key_agreement_strong_adversaries/
/theories/khovanskii_theorem/
/theories/kleene_algebra/
/theories/kneser_cauchy_davenport/
/theories/knights_tour/
/theories/knot_theory/
/theories/knuth_bendix_order/
/theories/knuth_morris_pratt/
/theories/koenigsberg_friendship/
/theories/kruskal/
/theories/kuratowski_closure_complement/
/theories/lam-ml-normalization/
/theories/lambda_free_epo/
/theories/lambda_free_kbos/
/theories/lambda_free_rpos/
/theories/lambdaauth/
/theories/lambdamu/
/theories/lambert_w/
/theories/landau_symbols/
/theories/laplace_transform/
/theories/latin_square/
/theories/latticeproperties/
/theories/launchbury/
/theories/laws_of_large_numbers/
/theories/lazy-lists-ii/
/theories/lazy_case/
/theories/lehmer/
/theories/lem/
/theories/lifting_definition_option/
/theories/lifting_the_exponent/
/theories/lightweightjava/
/theories/linear_inequalities/
/theories/linear_programming/
/theories/linear_recurrences/
/theories/linear_recurrences_solver/
/theories/linearquantifierelim/
/theories/liouville_numbers/
/theories/list-index/
/theories/list-infinite/
/theories/list_interleaving/
/theories/list_inversions/
/theories/list_update/
/theories/lll_basis_reduction/
/theories/lll_factorization/
/theories/localization_ring/
/theories/locallexing/
/theories/locally-nameless-sigma/
/theories/loft/
/theories/logging_independent_anonymity/
/topics/logic/computability/
/topics/logic/general-logic/
/topics/logic/general-logic/classical-first-order-logic/
/topics/logic/general-logic/classical-propositional-logic/
/topics/logic/general-logic/decidability-of-theories/
/topics/logic/general-logic/logics-of-knowledge-and-belief/
/topics/logic/general-logic/mechanization-of-proofs/
/topics/logic/general-logic/modal-logic/
/topics/logic/general-logic/paraconsistent-logics/
/topics/logic/general-logic/temporal-logic/
/topics/logic/philosophical-aspects/
/topics/logic/proof-theory/
/topics/logic/rewriting/
/topics/logic/set-theory/
/theories/lorenz_approximation/
/theories/lorenz_c0/
/theories/lorenz_c1/
/theories/lowe_ontological_argument/
/theories/lower_semicontinuous/
/theories/lp/
/theories/lp_duality/
/theories/ltl/
/theories/ltl_master_theorem/
/theories/ltl_normal_form/
/theories/ltl_to_dra/
/theories/ltl_to_gba/
/theories/lucas_theorem/
/theories/markov_models/
/theories/marriage/
/theories/mason_stothers/
/topics/mathematics/algebra/
/topics/mathematics/analysis/
/topics/mathematics/category-theory/
/topics/mathematics/combinatorics/
/topics/mathematics/games-and-economics/
/topics/mathematics/geometry/
/topics/mathematics/graph-theory/
/topics/mathematics/measure-and-integration/
/topics/mathematics/misc/
/topics/mathematics/number-theory/
/topics/mathematics/order/
/topics/mathematics/physics/
/topics/mathematics/physics/quantum-information/
/topics/mathematics/probability-theory/
/topics/mathematics/topology/
/theories/matrices_for_odes/
/theories/matrix/
/theories/matrix_tensor/
/theories/matroids/
/theories/max-card-matching/
/theories/maximum_segment_sum/
/theories/mdp-algorithms/
/theories/mdp-rewards/
/theories/median_method/
/theories/median_of_medians_selection/
/theories/menger/
/theories/mereology/
/theories/mersenne_primes/
/theories/metalogic_proofchecker/
/theories/mfmc_countable/
/theories/mfodl_monitor_optimized/
/theories/mfotl_monitor/
/theories/mhcomputation/
/theories/minimal_ssa/
/theories/miniml/
/theories/minisail/
/theories/minkowskis_theorem/
/theories/minsky_machines/
/theories/mlss_decision_proc/
/theories/modal_logics_for_nts/
/theories/modular_arithmetic_lll_and_hnf_algorithms/
/theories/modular_assembly_kit_security/
/theories/monad_memo_dp/
/theories/monad_normalisation/
/theories/monobooltranalgebra/
/theories/monoidalcategory/
/theories/monomorphic_monad/
/theories/mso_regex_equivalence/
/theories/muchadoabouttwo/
/theories/multi_party_computation/
/theories/multirelations/
/theories/multirelations_heterogeneous/
/theories/multiset_ordering_npc/
/theories/multitape_to_singletape_tm/
/theories/myhill-nerode/
/theories/name_carrying_type_inference/
/theories/nano_json/
/theories/nash_williams/
/theories/nat-interval-logic/
/theories/native_word/
/theories/nested_multisets_ordinals/
/theories/network_security_policy_verification/
/theories/neumann_morgenstern_utility/
/theories/no_ftl_observers/
/theories/no_ftl_observers_gen_rel/
/theories/nominal2/
/theories/noninterference_concurrent_composition/
/theories/noninterference_csp/
/theories/noninterference_generic_unwinding/
/theories/noninterference_inductive_unwinding/
/theories/noninterference_ipurge_unwinding/
/theories/noninterference_sequential_composition/
/theories/normbyeval/
/theories/nullstellensatz/
/theories/number_theoretic_transform/
/theories/octonions/
/theories/old_datatype_show/
/theories/open_induction/
/theories/opsets/
/theories/optics/
/theories/optimal_bst/
/theories/orbit_stabiliser/
/theories/order_lattice_props/
/theories/ordered_resolution_prover/
/theories/ordinal/
/theories/ordinal_partitions/
/theories/ordinals_and_cardinals/
/theories/ordinary_differential_equations/
/theories/pac_checker/
/theories/package_logic/
/theories/padic_field/
/theories/padic_ints/
/theories/pairing_heap/
/theories/pal/
/theories/papp_impossibility/
/theories/paraconsistency/
/theories/parity_game/
/theories/partial_function_mr/
/theories/partial_order_reduction/
/theories/password_authentication_protocol/
/theories/pcf/
/theories/pell/
/theories/perfect-number-thm/
/theories/perron_frobenius/
/theories/pgcl/
/theories/physical_quantities/
/theories/pi_calculus/
/theories/pi_transcendental/
/theories/planarity_certificates/
/theories/plm/
/theories/pluennecke_ruzsa_inequality/
/theories/poincare_bendixson/
/theories/poincare_disc/
/theories/polynomial_factorization/
/theories/polynomial_interpolation/
/theories/polynomials/
/theories/pop_refinement/
/theories/poplmark-debruijn/
/theories/posix-lexing/
/theories/possibilistic_noninterference/
/theories/power_sum_polynomials/
/theories/pratt_certificate/
/theories/prefix_free_code_combinators/
/theories/presburger-automata/
/theories/prim_dijkstra_simple/
/theories/prime_distribution_elementary/
/theories/prime_harmonic_series/
/theories/prime_number_theorem/
/theories/priority_queue_braun/
/theories/priority_search_trees/
/theories/probabilistic_noninterference/
/theories/probabilistic_prime_tests/
/theories/probabilistic_system_zoo/
/theories/probabilistic_timed_automata/
/theories/probabilistic_while/
/theories/probability_inequality_completeness/
/theories/program-conflict-analysis/
/theories/progress_tracking/
/theories/projective_geometry/
/theories/projective_measurements/
/theories/promela/
/theories/proof_strategy_language/
/theories/propositional_logic_class/
/theories/propositional_proof_systems/
/theories/proprespi/
/theories/prpu_maxflow/
/theories/psemigroupsconvolution/
/theories/pseudohoops/
/theories/psi_calculi/
/theories/ptolemys_theorem/
/theories/public_announcement_logic/
/theories/qhlprover/
/theories/qr_decomposition/
/theories/quantales/
/theories/quantifier_elimination_hybrid/
/theories/quasi_borel_spaces/
/theories/quaternions/
/theories/query_optimization/
/theories/quick_sort_cost/
/theories/ramsey-infinite/
/theories/random_bsts/
/theories/random_graph_subgraph_threshold/
/theories/randomised_bsts/
/theories/randomised_social_choice/
/theories/rank_nullity_theorem/
/theories/real_impl/
/theories/real_power/
/theories/real_time_deque/
/theories/recursion-addition/
/theories/recursion-theory-i/
/theories/refine_imperative_hol/
/theories/refine_monadic/
/theories/refinementreactive/
/theories/regex_equivalence/
/theories/registers/
/theories/regression_test_selection/
/theories/regular-sets/
/theories/regular_algebras/
/theories/regular_tree_relations/
/theories/relation_algebra/
/theories/relational-incorrectness-logic/
/theories/relational_disjoint_set_forests/
/theories/relational_forests/
/theories/relational_method/
/theories/relational_minimum_spanning_trees/
/theories/relational_paths/
/theories/rensets/
/theories/rep_fin_groups/
/theories/residuated_lattices/
/theories/residuatedtransitionsystem/
/theories/resolution_fol/
/theories/rewrite_properties_reduction/
/theories/rewriting_z/
/theories/ribbon_proofs/
/theories/ripemd-160-spark/
/theories/risk_free_lending/
/theories/robbins-conjecture/
/theories/robdd/
/theories/robinson_arithmetic/
/theories/root_balanced_tree/
/theories/roth_arithmetic_progressions/
/theories/routing/
/theories/roy_floyd_warshall/
/theories/rsapss/
/theories/safe_distance/
/theories/safe_ocl/
/theories/safe_range_rc/
/theories/satsolververification/
/theories/saturation_framework/
/theories/saturation_framework_extensions/
/theories/sauer_shelah_lemma/
/theories/sc_dom_components/
/theories/scc_bloemen_sequential/
/theories/schutz_spacetime/
/theories/schwartz_zippel/
/theories/sds_impossibility/
/search/
0.1
/theories/secondary_sylow/
/theories/security_protocol_refinement/
/theories/selection_heap_sort/
/theories/sensocialchoice/
/theories/separata/
/theories/separation_algebra/
/theories/separation_logic_imperative_hol/
/theories/separation_logic_unbounded/
/theories/sepref_basic/
/theories/sepref_iicf/
/theories/sepref_prereq/
/theories/sequentinvertibility/
/theories/shadow_dom/
/theories/shadow_sc_dom/
/theories/shivers-cfa/
/theories/shortestpath/
/theories/show/
/theories/sifpl/
/theories/sifum_type_systems/
/theories/sigma_commit_crypto/
/theories/signature_groebner/
/theories/simpl/
/theories/simple_clause_learning/
/theories/simple_firewall/
/theories/simplex/
/theories/simplicial_complexes_and_boolean_functions/
/theories/simplifiedontologicalargument/
/theories/skew_heap/
/theories/skip_lists/
/theories/slicing/
/theories/sliding_window_algorithm/
/theories/sm/
/theories/sm_base/
/theories/smith_normal_form/
/theories/smooth_manifolds/
/theories/solidity/
/theories/sophomores_dream/
/theories/sort_encodings/
/theories/source_coding_theorem/
/theories/sparcv8/
/theories/speccheck/
/theories/special_function_bounds/
/theories/splay_tree/
/theories/sqrt_babylonian/
/theories/stable_matching/
/theories/stalnaker_logic/
/theories/statecharts/
/theories/stateful_protocol_composition_and_typing/
/statistics/
/theories/stellar_quorums/
/theories/stern_brocot/
/theories/stewart_apollonius/
/theories/stirling_formula/
/theories/stochastic_matrices/
/theories/stone_algebras/
/theories/stone_kleene_relation_algebras/
/theories/stone_relation_algebras/
/theories/store_buffer_reduction/
/theories/stream-fusion/
/theories/stream_fusion_code/
/theories/strictomegacategories/
/theories/strong_security/
/theories/sturm_sequences/
/theories/sturm_tarski/
/theories/stuttering_equivalence/
/webapp/submission/
/webapp/submit/
/theories/subresultants/
/theories/subset_boolean_algebras/
/theories/sumsquares/
/theories/sunflowers/
/theories/supercalc/
/theories/suppes_theorem/
/theories/surprise_paradox/
/theories/symmetric_polynomials/
/theories/syntax_independent_logic/
/theories/synthetic_completeness/
/theories/szemeredi_regularity/
/theories/szpilrajn/
/theories/tail_recursive_functions/
/theories/tarskis_geometry/
/theories/taylor_models/
/theories/tesl_language/
/theories/
/theories/three_circles/
/theories/three_squares/
/theories/timed_automata/
/theories/tla/
/theories/topological_semantics/
/theories/topology/
/theories/tortoisehare/
/theories/transcendence_series_hancl_rucki/
/theories/transformer_semantics/
/theories/transition_systems_and_automata/
/theories/transitive-closure/
/theories/transitive-closure-ii/
/theories/transitive_models/
/theories/treaps/
/theories/tree-automata/
/theories/tree_decomposition/
/theories/tree_enumeration/
/theories/triangle/
/theories/trie/
/theories/tsirelsonbound/
/theories/turans_graph_theorem/
/theories/twelvefold_way/
/theories/two_generated_word_monoids_intersection/
/theories/tycon/
/theories/types_tableaus_and_goedels_god/
/theories/types_to_sets_extension/
/theories/undirected_graph_theory/
/theories/universal_hash_families/
/theories/universal_turing_machine/
/theories/updown_scheme/
/theories/upf/
/theories/upf_firewall/
/theories/utp/
/theories/utp-toolkit/
/theories/valuation/
/theories/van_der_waerden/
/theories/van_emde_boas_trees/
/theories/vectorspace/
/theories/vericomp/
/theories/verified-prover/
/theories/verified_sat_based_ai_planning/
/theories/verifythis2018/
/theories/verifythis2019/
/theories/vickrey_clarke_groves/
/theories/virtual_substitution/
/theories/volpanosmith/
/theories/vydra_mdl/
/theories/webassembly/
/theories/weight_balanced_trees/
/theories/weighted_arithmetic_geometric_mean/
/theories/weighted_path_order/
/theories/well_quasi_orders/
/theories/wetzels_problem/
/theories/whatandwhere_security/
/theories/winding_number_eval/
/theories/woot_strong_eventual_consistency/
/theories/word_lib/
/theories/workerwrapper/
/theories/x86_semantics/
/theories/xml/
/theories/youngs_inequality/
/theories/zeckendorf/
/theories/zeta_3_irrational/
/theories/zeta_function/
/theories/zfc_in_hol/
diff --git a/web/theories/index.xml b/web/theories/index.xml
--- a/web/theories/index.xml
+++ b/web/theories/index.xml
@@ -1,7030 +1,7039 @@
Theories on Archive of Formal Proofs
/theories/
Recent content in Theories on Archive of Formal Proofs
Hugo -- gohugo.io
en-gb
-
Abortable_Linearizable_Modules
/theories/abortable_linearizable_modules/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abortable_linearizable_modules/
-
Abs_Int_ITP2012
/theories/abs_int_itp2012/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abs_int_itp2012/
-
Abstract-Hoare-Logics
/theories/abstract-hoare-logics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract-hoare-logics/
-
Abstract-Rewriting
/theories/abstract-rewriting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract-rewriting/
-
Abstract_Completeness
/theories/abstract_completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract_completeness/
-
Abstract_Soundness
/theories/abstract_soundness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/abstract_soundness/
-
ABY3_Protocols
/theories/aby3_protocols/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aby3_protocols/
-
Ackermanns_not_PR
/theories/ackermanns_not_pr/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ackermanns_not_pr/
-
Actuarial_Mathematics
/theories/actuarial_mathematics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/actuarial_mathematics/
-
Adaptive_State_Counting
/theories/adaptive_state_counting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/adaptive_state_counting/
-
ADS_Functor
/theories/ads_functor/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ads_functor/
-
Affine_Arithmetic
/theories/affine_arithmetic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/affine_arithmetic/
-
Aggregation_Algebras
/theories/aggregation_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aggregation_algebras/
-
AI_Planning_Languages_Semantics
/theories/ai_planning_languages_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ai_planning_languages_semantics/
-
Akra_Bazzi
/theories/akra_bazzi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/akra_bazzi/
-
Algebraic_Numbers
/theories/algebraic_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/algebraic_numbers/
-
Algebraic_VCs
/theories/algebraic_vcs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/algebraic_vcs/
-
Allen_Calculus
/theories/allen_calculus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/allen_calculus/
-
Amicable_Numbers
/theories/amicable_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/amicable_numbers/
-
Amortized_Complexity
/theories/amortized_complexity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/amortized_complexity/
-
AnselmGod
/theories/anselmgod/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/anselmgod/
-
AODV
/theories/aodv/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aodv/
-
AOT
/theories/aot/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aot/
-
Applicative_Lifting
/theories/applicative_lifting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/applicative_lifting/
-
Approximation_Algorithms
/theories/approximation_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/approximation_algorithms/
-
Architectural_Design_Patterns
/theories/architectural_design_patterns/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/architectural_design_patterns/
-
Aristotles_Assertoric_Syllogistic
/theories/aristotles_assertoric_syllogistic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/aristotles_assertoric_syllogistic/
-
Arith_Prog_Rel_Primes
/theories/arith_prog_rel_primes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/arith_prog_rel_primes/
-
ArrowImpossibilityGS
/theories/arrowimpossibilitygs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/arrowimpossibilitygs/
-
Attack_Trees
/theories/attack_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/attack_trees/
-
Auto2_HOL
/theories/auto2_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/auto2_hol/
-
Auto2_Imperative_HOL
/theories/auto2_imperative_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/auto2_imperative_hol/
-
AutoFocus-Stream
/theories/autofocus-stream/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/autofocus-stream/
-
Automated_Stateful_Protocol_Verification
/theories/automated_stateful_protocol_verification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/automated_stateful_protocol_verification/
-
Automatic_Refinement
/theories/automatic_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/automatic_refinement/
-
AVL-Trees
/theories/avl-trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/avl-trees/
-
AWN
/theories/awn/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/awn/
-
AxiomaticCategoryTheory
/theories/axiomaticcategorytheory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/axiomaticcategorytheory/
-
Balog_Szemeredi_Gowers
/theories/balog_szemeredi_gowers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/balog_szemeredi_gowers/
-
Banach_Steinhaus
/theories/banach_steinhaus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/banach_steinhaus/
-
BD_Security_Compositional
/theories/bd_security_compositional/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bd_security_compositional/
-
BDD
/theories/bdd/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bdd/
-
Belief_Revision
/theories/belief_revision/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/belief_revision/
-
Bell_Numbers_Spivey
/theories/bell_numbers_spivey/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bell_numbers_spivey/
-
BenOr_Kozen_Reif
/theories/benor_kozen_reif/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/benor_kozen_reif/
-
Berlekamp_Zassenhaus
/theories/berlekamp_zassenhaus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/berlekamp_zassenhaus/
-
Bernoulli
/theories/bernoulli/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bernoulli/
-
Bertrands_Postulate
/theories/bertrands_postulate/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bertrands_postulate/
-
Bicategory
/theories/bicategory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bicategory/
-
Binary_Code_Imprimitive
/theories/binary_code_imprimitive/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binary_code_imprimitive/
-
BinarySearchTree
/theories/binarysearchtree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binarysearchtree/
-
Binding_Syntax_Theory
/theories/binding_syntax_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binding_syntax_theory/
-
Binomial-Heaps
/theories/binomial-heaps/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binomial-heaps/
-
Binomial-Queues
/theories/binomial-queues/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/binomial-queues/
-
BirdKMP
/theories/birdkmp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/birdkmp/
-
Birkhoff_Finite_Distributive_Lattices
/theories/birkhoff_finite_distributive_lattices/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/birkhoff_finite_distributive_lattices/
-
Blue_Eyes
/theories/blue_eyes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/blue_eyes/
-
BNF_CC
/theories/bnf_cc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bnf_cc/
-
BNF_Operations
/theories/bnf_operations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bnf_operations/
-
Bondy
/theories/bondy/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bondy/
-
Boolean_Expression_Checkers
/theories/boolean_expression_checkers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/boolean_expression_checkers/
-
Boolos_Curious_Inference
/theories/boolos_curious_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/boolos_curious_inference/
-
Boolos_Curious_Inference_Automated
/theories/boolos_curious_inference_automated/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/boolos_curious_inference_automated/
-
Bounded_Deducibility_Security
/theories/bounded_deducibility_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bounded_deducibility_security/
-
BTree
/theories/btree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/btree/
-
Buchi_Complementation
/theories/buchi_complementation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/buchi_complementation/
-
Budan_Fourier
/theories/budan_fourier/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/budan_fourier/
-
Buffons_Needle
/theories/buffons_needle/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/buffons_needle/
-
Buildings
/theories/buildings/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/buildings/
-
BytecodeLogicJmlTypes
/theories/bytecodelogicjmltypes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/bytecodelogicjmltypes/
-
C2KA_DistributedSystems
/theories/c2ka_distributedsystems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/c2ka_distributedsystems/
-
CakeML
/theories/cakeml/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cakeml/
-
CakeML_Codegen
/theories/cakeml_codegen/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cakeml_codegen/
-
Call_Arity
/theories/call_arity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/call_arity/
-
Card_Equiv_Relations
/theories/card_equiv_relations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_equiv_relations/
-
Card_Multisets
/theories/card_multisets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_multisets/
-
Card_Number_Partitions
/theories/card_number_partitions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_number_partitions/
-
Card_Partitions
/theories/card_partitions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/card_partitions/
-
Cartan_FP
/theories/cartan_fp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cartan_fp/
-
Case_Labeling
/theories/case_labeling/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/case_labeling/
-
Catalan_Numbers
/theories/catalan_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/catalan_numbers/
-
Category
/theories/category/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/category/
-
Category2
/theories/category2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/category2/
-
Category3
/theories/category3/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/category3/
-
Cauchy
/theories/cauchy/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cauchy/
-
CAVA_Automata
/theories/cava_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_automata/
-
CAVA_Base
/theories/cava_base/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_base/
-
CAVA_LTL_Modelchecker
/theories/cava_ltl_modelchecker/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_ltl_modelchecker/
-
CAVA_Setup
/theories/cava_setup/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cava_setup/
-
Cayley_Hamilton
/theories/cayley_hamilton/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cayley_hamilton/
-
CCS
/theories/ccs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ccs/
-
Certification_Monads
/theories/certification_monads/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/certification_monads/
-
Chandy_Lamport
/theories/chandy_lamport/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/chandy_lamport/
-
CHERI-C_Memory_Model
/theories/cheri-c_memory_model/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cheri-c_memory_model/
-
Chord_Segments
/theories/chord_segments/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/chord_segments/
-
Circus
/theories/circus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/circus/
-
CISC-Kernel
/theories/cisc-kernel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cisc-kernel/
-
Clean
/theories/clean/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/clean/
-
Clique_and_Monotone_Circuits
/theories/clique_and_monotone_circuits/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/clique_and_monotone_circuits/
-
ClockSynchInst
/theories/clocksynchinst/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/clocksynchinst/
-
Closest_Pair_Points
/theories/closest_pair_points/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/closest_pair_points/
-
CoCon
/theories/cocon/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cocon/
-
CofGroups
/theories/cofgroups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cofgroups/
-
Coinductive
/theories/coinductive/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/coinductive/
-
Coinductive_Languages
/theories/coinductive_languages/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/coinductive_languages/
-
Collections
/theories/collections/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/collections/
-
Collections_Examples
/theories/collections_examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/collections_examples/
-
Combinable_Wands
/theories/combinable_wands/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinable_wands/
-
Combinatorial_Enumeration_Algorithms
/theories/combinatorial_enumeration_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorial_enumeration_algorithms/
-
Combinatorics_Words
/theories/combinatorics_words/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorics_words/
-
Combinatorics_Words_Graph_Lemma
/theories/combinatorics_words_graph_lemma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorics_words_graph_lemma/
-
Combinatorics_Words_Lyndon
/theories/combinatorics_words_lyndon/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/combinatorics_words_lyndon/
-
CommCSL
/theories/commcsl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/commcsl/
-
Commuting_Hermitian
/theories/commuting_hermitian/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/commuting_hermitian/
-
Comparison_Sort_Lower_Bound
/theories/comparison_sort_lower_bound/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/comparison_sort_lower_bound/
-
Compiling-Exceptions-Correctly
/theories/compiling-exceptions-correctly/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/compiling-exceptions-correctly/
-
Complete_Non_Orders
/theories/complete_non_orders/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complete_non_orders/
-
Completeness
/theories/completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/completeness/
-
Complex_Bounded_Operators
/theories/complex_bounded_operators/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complex_bounded_operators/
-
Complex_Bounded_Operators_Dependencies
/theories/complex_bounded_operators_dependencies/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complex_bounded_operators_dependencies/
-
Complex_Geometry
/theories/complex_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complex_geometry/
-
Complx
/theories/complx/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/complx/
-
ComponentDependencies
/theories/componentdependencies/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/componentdependencies/
-
Concurrent_Ref_Alg
/theories/concurrent_ref_alg/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrent_ref_alg/
-
Concurrent_Revisions
/theories/concurrent_revisions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrent_revisions/
-
ConcurrentGC
/theories/concurrentgc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrentgc/
-
ConcurrentIMP
/theories/concurrentimp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/concurrentimp/
-
Conditional_Simplification
/theories/conditional_simplification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/conditional_simplification/
-
Conditional_Transfer_Rule
/theories/conditional_transfer_rule/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/conditional_transfer_rule/
-
Consensus_Refined
/theories/consensus_refined/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/consensus_refined/
-
Constructive_Cryptography
/theories/constructive_cryptography/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/constructive_cryptography/
-
Constructive_Cryptography_CM
/theories/constructive_cryptography_cm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/constructive_cryptography_cm/
-
Constructor_Funs
/theories/constructor_funs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/constructor_funs/
-
Containers
/theories/containers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/containers/
-
Containers-Benchmarks
/theories/containers-benchmarks/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/containers-benchmarks/
-
Cook_Levin
/theories/cook_levin/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cook_levin/
-
Core_DOM
/theories/core_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/core_dom/
-
Core_SC_DOM
/theories/core_sc_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/core_sc_dom/
-
CoreC++
/theories/corec++/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/corec++/
-
Correctness_Algebras
/theories/correctness_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/correctness_algebras/
-
CoSMed
/theories/cosmed/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cosmed/
-
CoSMeDis
/theories/cosmedis/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cosmedis/
-
Cotangent_PFD_Formula
/theories/cotangent_pfd_formula/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cotangent_pfd_formula/
-
Count_Complex_Roots
/theories/count_complex_roots/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/count_complex_roots/
-
CRDT
/theories/crdt/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crdt/
-
CryptHOL
/theories/crypthol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crypthol/
-
Crypto_Standards
/theories/crypto_standards/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crypto_standards/
-
CryptoBasedCompositionalProperties
/theories/cryptobasedcompositionalproperties/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cryptobasedcompositionalproperties/
-
CRYSTALS-Kyber
/theories/crystals-kyber/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/crystals-kyber/
-
CSP_RefTK
/theories/csp_reftk/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/csp_reftk/
-
Cubic_Quartic_Equations
/theories/cubic_quartic_equations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cubic_quartic_equations/
-
CVP_Hardness
/theories/cvp_hardness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cvp_hardness/
-
CYK
/theories/cyk/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/cyk/
-
CZH_Elementary_Categories
/theories/czh_elementary_categories/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/czh_elementary_categories/
-
CZH_Foundations
/theories/czh_foundations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/czh_foundations/
-
CZH_Universal_Constructions
/theories/czh_universal_constructions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/czh_universal_constructions/
-
DataRefinementIBP
/theories/datarefinementibp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/datarefinementibp/
-
Datatype_Order_Generator
/theories/datatype_order_generator/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/datatype_order_generator/
-
DCR-ExecutionEquivalence
/theories/dcr-executionequivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dcr-executionequivalence/
-
Decl_Sem_Fun_PL
/theories/decl_sem_fun_pl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/decl_sem_fun_pl/
-
Decreasing-Diagrams
/theories/decreasing-diagrams/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/decreasing-diagrams/
-
Decreasing-Diagrams-II
/theories/decreasing-diagrams-ii/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/decreasing-diagrams-ii/
-
Dedekind_Real
/theories/dedekind_real/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dedekind_real/
-
Deep_Learning
/theories/deep_learning/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/deep_learning/
-
Delta_System_Lemma
/theories/delta_system_lemma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/delta_system_lemma/
-
Density_Compiler
/theories/density_compiler/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/density_compiler/
-
Dependent_SIFUM_Refinement
/theories/dependent_sifum_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dependent_sifum_refinement/
-
Dependent_SIFUM_Type_Systems
/theories/dependent_sifum_type_systems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dependent_sifum_type_systems/
-
Depth-First-Search
/theories/depth-first-search/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/depth-first-search/
-
Derangements
/theories/derangements/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/derangements/
-
Deriving
/theories/deriving/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/deriving/
-
Descartes_Sign_Rule
/theories/descartes_sign_rule/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/descartes_sign_rule/
-
Design_Theory
/theories/design_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/design_theory/
-
DFS_Framework
/theories/dfs_framework/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dfs_framework/
-
Dict_Construction
/theories/dict_construction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dict_construction/
-
Differential_Dynamic_Logic
/theories/differential_dynamic_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/differential_dynamic_logic/
-
Differential_Game_Logic
/theories/differential_game_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/differential_game_logic/
-
Digit_Expansions
/theories/digit_expansions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/digit_expansions/
-
DigitsInBase
/theories/digitsinbase/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/digitsinbase/
-
Dijkstra_Shortest_Path
/theories/dijkstra_shortest_path/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dijkstra_shortest_path/
-
Diophantine_Eqns_Lin_Hom
/theories/diophantine_eqns_lin_hom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/diophantine_eqns_lin_hom/
-
Directed_Sets
/theories/directed_sets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/directed_sets/
-
Dirichlet_L
/theories/dirichlet_l/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dirichlet_l/
-
Dirichlet_Series
/theories/dirichlet_series/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dirichlet_series/
-
Discrete_Summation
/theories/discrete_summation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/discrete_summation/
-
DiscretePricing
/theories/discretepricing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/discretepricing/
-
DiskPaxos
/theories/diskpaxos/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/diskpaxos/
-
Distributed_Distinct_Elements
/theories/distributed_distinct_elements/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/distributed_distinct_elements/
-
DOM_Components
/theories/dom_components/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dom_components/
-
Dominance_CHK
/theories/dominance_chk/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dominance_chk/
-
DPRM_Theorem
/theories/dprm_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dprm_theorem/
-
DPT-SAT-Solver
/theories/dpt-sat-solver/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dpt-sat-solver/
-
Dynamic_Tables
/theories/dynamic_tables/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dynamic_tables/
-
DynamicArchitectures
/theories/dynamicarchitectures/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/dynamicarchitectures/
-
E_Transcendental
/theories/e_transcendental/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/e_transcendental/
-
Echelon_Form
/theories/echelon_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/echelon_form/
-
EdmondsKarp_Maxflow
/theories/edmondskarp_maxflow/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/edmondskarp_maxflow/
-
Edwards_Elliptic_Curves_Group
/theories/edwards_elliptic_curves_group/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/edwards_elliptic_curves_group/
-
Efficient-Mergesort
/theories/efficient-mergesort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/efficient-mergesort/
-
Efficient_Weighted_Path_Order
/theories/efficient_weighted_path_order/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/efficient_weighted_path_order/
-
Elliptic_Curves_Group_Law
/theories/elliptic_curves_group_law/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/elliptic_curves_group_law/
-
Encodability_Process_Calculi
/theories/encodability_process_calculi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/encodability_process_calculi/
-
Epistemic_Logic
/theories/epistemic_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/epistemic_logic/
-
Equivalence_Relation_Enumeration
/theories/equivalence_relation_enumeration/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/equivalence_relation_enumeration/
-
Ergodic_Theory
/theories/ergodic_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ergodic_theory/
-
Error_Function
/theories/error_function/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/error_function/
-
Euler_MacLaurin
/theories/euler_maclaurin/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/euler_maclaurin/
-
Euler_Partition
/theories/euler_partition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/euler_partition/
-
Eval_FO
/theories/eval_fo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/eval_fo/
-
+
Example-Submission
+ /theories/example-submission/
+ Mon, 01 Jan 0001 00:00:00 +0000
+
+ /theories/example-submission/
+
+
+
+ -
Executable_Randomized_Algorithms
/theories/executable_randomized_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/executable_randomized_algorithms/
-
Expander_Graphs
/theories/expander_graphs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/expander_graphs/
-
Extended_Finite_State_Machine_Inference
/theories/extended_finite_state_machine_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/extended_finite_state_machine_inference/
-
Extended_Finite_State_Machines
/theories/extended_finite_state_machines/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/extended_finite_state_machines/
-
Factor_Algebraic_Polynomial
/theories/factor_algebraic_polynomial/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/factor_algebraic_polynomial/
-
Factored_Transition_System_Bounding
/theories/factored_transition_system_bounding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/factored_transition_system_bounding/
-
Falling_Factorial_Sum
/theories/falling_factorial_sum/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/falling_factorial_sum/
-
Farkas
/theories/farkas/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/farkas/
-
Featherweight_OCL
/theories/featherweight_ocl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/featherweight_ocl/
-
FeatherweightJava
/theories/featherweightjava/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/featherweightjava/
-
Fermat3_4
/theories/fermat3_4/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fermat3_4/
-
FFT
/theories/fft/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fft/
-
FileRefinement
/theories/filerefinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/filerefinement/
-
FinFun
/theories/finfun/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finfun/
-
Finger-Trees
/theories/finger-trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finger-trees/
-
Finite-Map-Extras
/theories/finite-map-extras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finite-map-extras/
-
Finite_Automata_HF
/theories/finite_automata_hf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finite_automata_hf/
-
Finite_Fields
/theories/finite_fields/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finite_fields/
-
Finitely_Generated_Abelian_Groups
/theories/finitely_generated_abelian_groups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/finitely_generated_abelian_groups/
-
First_Order_Terms
/theories/first_order_terms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/first_order_terms/
-
First_Welfare_Theorem
/theories/first_welfare_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/first_welfare_theorem/
-
Fishburn_Impossibility
/theories/fishburn_impossibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fishburn_impossibility/
-
Fisher_Yates
/theories/fisher_yates/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fisher_yates/
-
Fishers_Inequality
/theories/fishers_inequality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fishers_inequality/
-
Flow_Networks
/theories/flow_networks/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flow_networks/
-
Floyd_Warshall
/theories/floyd_warshall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/floyd_warshall/
-
FLP
/theories/flp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flp/
-
Flyspeck-Tame
/theories/flyspeck-tame/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flyspeck-tame/
-
Flyspeck-Tame-Computation
/theories/flyspeck-tame-computation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/flyspeck-tame-computation/
-
FO_Theory_Rewriting
/theories/fo_theory_rewriting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fo_theory_rewriting/
-
FocusStreamsCaseStudies
/theories/focusstreamscasestudies/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/focusstreamscasestudies/
-
FOL-Fitting
/theories/fol-fitting/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol-fitting/
-
FOL_Axiomatic
/theories/fol_axiomatic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_axiomatic/
-
FOL_Harrison
/theories/fol_harrison/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_harrison/
-
FOL_Seq_Calc1
/theories/fol_seq_calc1/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_seq_calc1/
-
FOL_Seq_Calc2
/theories/fol_seq_calc2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_seq_calc2/
-
FOL_Seq_Calc3
/theories/fol_seq_calc3/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fol_seq_calc3/
-
Forcing
/theories/forcing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/forcing/
-
Formal_Puiseux_Series
/theories/formal_puiseux_series/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formal_puiseux_series/
-
Formal_SSA
/theories/formal_ssa/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formal_ssa/
-
Formula_Derivatives
/theories/formula_derivatives/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formula_derivatives/
-
Formula_Derivatives-Examples
/theories/formula_derivatives-examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/formula_derivatives-examples/
-
Foundation_of_geometry
/theories/foundation_of_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/foundation_of_geometry/
-
Fourier
/theories/fourier/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fourier/
-
Free-Boolean-Algebra
/theories/free-boolean-algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/free-boolean-algebra/
-
Free-Groups
/theories/free-groups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/free-groups/
-
Frequency_Moments
/theories/frequency_moments/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/frequency_moments/
-
Fresh_Identifiers
/theories/fresh_identifiers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fresh_identifiers/
-
FSM_Tests
/theories/fsm_tests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/fsm_tests/
-
Functional-Automata
/theories/functional-automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/functional-automata/
-
Functional_Ordered_Resolution_Prover
/theories/functional_ordered_resolution_prover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/functional_ordered_resolution_prover/
-
FunWithFunctions
/theories/funwithfunctions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/funwithfunctions/
-
FunWithTilings
/theories/funwithtilings/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/funwithtilings/
-
Furstenberg_Topology
/theories/furstenberg_topology/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/furstenberg_topology/
-
Gabow_SCC
/theories/gabow_scc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gabow_scc/
-
Gale_Shapley
/theories/gale_shapley/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gale_shapley/
-
GaleStewart_Games
/theories/galestewart_games/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/galestewart_games/
-
Game_Based_Crypto
/theories/game_based_crypto/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/game_based_crypto/
-
Gauss-Jordan-Elim-Fun
/theories/gauss-jordan-elim-fun/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gauss-jordan-elim-fun/
-
Gauss_Jordan
/theories/gauss_jordan/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gauss_jordan/
-
Gauss_Sums
/theories/gauss_sums/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gauss_sums/
-
Gaussian_Integers
/theories/gaussian_integers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gaussian_integers/
-
GenClock
/theories/genclock/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/genclock/
-
General-Triangle
/theories/general-triangle/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/general-triangle/
-
Generalized_Counting_Sort
/theories/generalized_counting_sort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/generalized_counting_sort/
-
Generic_Deriving
/theories/generic_deriving/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/generic_deriving/
-
Generic_Join
/theories/generic_join/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/generic_join/
-
GewirthPGCProof
/theories/gewirthpgcproof/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gewirthpgcproof/
-
Girth_Chromatic
/theories/girth_chromatic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/girth_chromatic/
-
Given_Clause_Loops
/theories/given_clause_loops/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/given_clause_loops/
-
Goedel_HFSet_Semantic
/theories/goedel_hfset_semantic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedel_hfset_semantic/
-
Goedel_HFSet_Semanticless
/theories/goedel_hfset_semanticless/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedel_hfset_semanticless/
-
Goedel_Incompleteness
/theories/goedel_incompleteness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedel_incompleteness/
-
GoedelGod
/theories/goedelgod/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goedelgod/
-
Goodstein_Lambda
/theories/goodstein_lambda/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/goodstein_lambda/
-
GPU_Kernel_PL
/theories/gpu_kernel_pl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gpu_kernel_pl/
-
Graph_Saturation
/theories/graph_saturation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/graph_saturation/
-
Graph_Theory
/theories/graph_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/graph_theory/
-
GraphMarkingIBP
/theories/graphmarkingibp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/graphmarkingibp/
-
Gray_Codes
/theories/gray_codes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gray_codes/
-
Green
/theories/green/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/green/
-
Groebner_Bases
/theories/groebner_bases/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/groebner_bases/
-
Groebner_Macaulay
/theories/groebner_macaulay/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/groebner_macaulay/
-
Gromov_Hyperbolicity
/theories/gromov_hyperbolicity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/gromov_hyperbolicity/
-
Grothendieck_Schemes
/theories/grothendieck_schemes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/grothendieck_schemes/
-
Group-Ring-Module
/theories/group-ring-module/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/group-ring-module/
-
Hahn_Jordan_Decomposition
/theories/hahn_jordan_decomposition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hahn_jordan_decomposition/
-
Hales_Jewett
/theories/hales_jewett/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hales_jewett/
-
Heard_Of
/theories/heard_of/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/heard_of/
-
Hello_World
/theories/hello_world/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hello_world/
-
HereditarilyFinite
/theories/hereditarilyfinite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hereditarilyfinite/
-
Hermite
/theories/hermite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hermite/
-
Hermite_Lindemann
/theories/hermite_lindemann/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hermite_lindemann/
-
Hidden_Markov_Models
/theories/hidden_markov_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hidden_markov_models/
-
Higher_Order_Terms
/theories/higher_order_terms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/higher_order_terms/
-
Hoare_Time
/theories/hoare_time/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hoare_time/
-
HoareForDivergence
/theories/hoarefordivergence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hoarefordivergence/
-
HOL-CSP
/theories/hol-csp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-csp/
-
HOL-ODE-ARCH-COMP
/theories/hol-ode-arch-comp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-ode-arch-comp/
-
HOL-ODE-Examples
/theories/hol-ode-examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-ode-examples/
-
HOL-ODE-Numerics
/theories/hol-ode-numerics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hol-ode-numerics/
-
HOLCF-Prelude
/theories/holcf-prelude/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/holcf-prelude/
-
Hood_Melville_Queue
/theories/hood_melville_queue/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hood_melville_queue/
-
HotelKeyCards
/theories/hotelkeycards/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hotelkeycards/
-
HRB-Slicing
/theories/hrb-slicing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hrb-slicing/
-
Huffman
/theories/huffman/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/huffman/
-
Hybrid_Logic
/theories/hybrid_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hybrid_logic/
-
Hybrid_Multi_Lane_Spatial_Logic
/theories/hybrid_multi_lane_spatial_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hybrid_multi_lane_spatial_logic/
-
Hybrid_Systems_VCs
/theories/hybrid_systems_vcs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hybrid_systems_vcs/
-
HyperCTL
/theories/hyperctl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hyperctl/
-
Hyperdual
/theories/hyperdual/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hyperdual/
-
HyperHoareLogic
/theories/hyperhoarelogic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/hyperhoarelogic/
-
IEEE_Floating_Point
/theories/ieee_floating_point/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ieee_floating_point/
-
IFC_Tracking
/theories/ifc_tracking/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ifc_tracking/
-
IMAP-CRDT
/theories/imap-crdt/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imap-crdt/
-
IMO2019
/theories/imo2019/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imo2019/
-
IMP2
/theories/imp2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp2/
-
IMP2_Binary_Heap
/theories/imp2_binary_heap/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp2_binary_heap/
-
IMP_Compiler
/theories/imp_compiler/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp_compiler/
-
IMP_Compiler_Reuse
/theories/imp_compiler_reuse/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imp_compiler_reuse/
-
Imperative_Insertion_Sort
/theories/imperative_insertion_sort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/imperative_insertion_sort/
-
Implicational_Logic
/theories/implicational_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/implicational_logic/
-
Impossible_Geometry
/theories/impossible_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/impossible_geometry/
-
Incompleteness
/theories/incompleteness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/incompleteness/
-
Incredible_Proof_Machine
/theories/incredible_proof_machine/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/incredible_proof_machine/
-
Independence_CH
/theories/independence_ch/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/independence_ch/
-
Inductive_Confidentiality
/theories/inductive_confidentiality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/inductive_confidentiality/
-
Inductive_Inference
/theories/inductive_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/inductive_inference/
-
InformationFlowSlicing
/theories/informationflowslicing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/informationflowslicing/
-
InformationFlowSlicing_Inter
/theories/informationflowslicing_inter/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/informationflowslicing_inter/
-
InfPathElimination
/theories/infpathelimination/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/infpathelimination/
-
Integration
/theories/integration/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/integration/
-
Interpolation_Polynomials_HOL_Algebra
/theories/interpolation_polynomials_hol_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/interpolation_polynomials_hol_algebra/
-
Interpreter_Optimizations
/theories/interpreter_optimizations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/interpreter_optimizations/
-
Interval_Arithmetic_Word32
/theories/interval_arithmetic_word32/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/interval_arithmetic_word32/
-
Intro_Dest_Elim
/theories/intro_dest_elim/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/intro_dest_elim/
-
Involutions2Squares
/theories/involutions2squares/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/involutions2squares/
-
IP_Addresses
/theories/ip_addresses/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ip_addresses/
-
Iptables_Semantics
/theories/iptables_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/iptables_semantics/
-
Iptables_Semantics_Examples
/theories/iptables_semantics_examples/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/iptables_semantics_examples/
-
Iptables_Semantics_Examples_Big
/theories/iptables_semantics_examples_big/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/iptables_semantics_examples_big/
-
Irrational_Series_Erdos_Straus
/theories/irrational_series_erdos_straus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/irrational_series_erdos_straus/
-
Irrationality_J_Hancl
/theories/irrationality_j_hancl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/irrationality_j_hancl/
-
Irrationals_From_THEBOOK
/theories/irrationals_from_thebook/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/irrationals_from_thebook/
-
Isabelle_C
/theories/isabelle_c/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isabelle_c/
-
Isabelle_Marries_Dirac
/theories/isabelle_marries_dirac/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isabelle_marries_dirac/
-
Isabelle_Meta_Model
/theories/isabelle_meta_model/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isabelle_meta_model/
-
IsaGeoCoq
/theories/isageocoq/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isageocoq/
-
IsaNet
/theories/isanet/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/isanet/
-
Jacobson_Basic_Algebra
/theories/jacobson_basic_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jacobson_basic_algebra/
-
Jinja
/theories/jinja/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jinja/
-
JinjaDCI
/theories/jinjadci/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jinjadci/
-
JinjaThreads
/theories/jinjathreads/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jinjathreads/
-
JiveDataStoreModel
/theories/jivedatastoremodel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jivedatastoremodel/
-
Jordan_Hoelder
/theories/jordan_hoelder/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jordan_hoelder/
-
Jordan_Normal_Form
/theories/jordan_normal_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/jordan_normal_form/
-
KAD
/theories/kad/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kad/
-
KAT_and_DRA
/theories/kat_and_dra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kat_and_dra/
-
KBPs
/theories/kbps/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kbps/
-
KD_Tree
/theories/kd_tree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kd_tree/
-
Key_Agreement_Strong_Adversaries
/theories/key_agreement_strong_adversaries/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/key_agreement_strong_adversaries/
-
Khovanskii_Theorem
/theories/khovanskii_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/khovanskii_theorem/
-
Kleene_Algebra
/theories/kleene_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kleene_algebra/
-
Kneser_Cauchy_Davenport
/theories/kneser_cauchy_davenport/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kneser_cauchy_davenport/
-
Knights_Tour
/theories/knights_tour/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knights_tour/
-
Knot_Theory
/theories/knot_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knot_theory/
-
Knuth_Bendix_Order
/theories/knuth_bendix_order/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knuth_bendix_order/
-
Knuth_Morris_Pratt
/theories/knuth_morris_pratt/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/knuth_morris_pratt/
-
Koenigsberg_Friendship
/theories/koenigsberg_friendship/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/koenigsberg_friendship/
-
Kruskal
/theories/kruskal/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kruskal/
-
Kuratowski_Closure_Complement
/theories/kuratowski_closure_complement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/kuratowski_closure_complement/
-
Lam-ml-Normalization
/theories/lam-ml-normalization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lam-ml-normalization/
-
Lambda_Free_EPO
/theories/lambda_free_epo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambda_free_epo/
-
Lambda_Free_KBOs
/theories/lambda_free_kbos/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambda_free_kbos/
-
Lambda_Free_RPOs
/theories/lambda_free_rpos/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambda_free_rpos/
-
LambdaAuth
/theories/lambdaauth/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambdaauth/
-
LambdaMu
/theories/lambdamu/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambdamu/
-
Lambert_W
/theories/lambert_w/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lambert_w/
-
Landau_Symbols
/theories/landau_symbols/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/landau_symbols/
-
Laplace_Transform
/theories/laplace_transform/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/laplace_transform/
-
Latin_Square
/theories/latin_square/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/latin_square/
-
LatticeProperties
/theories/latticeproperties/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/latticeproperties/
-
Launchbury
/theories/launchbury/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/launchbury/
-
Laws_of_Large_Numbers
/theories/laws_of_large_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/laws_of_large_numbers/
-
Lazy-Lists-II
/theories/lazy-lists-ii/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lazy-lists-ii/
-
Lazy_Case
/theories/lazy_case/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lazy_case/
-
Lehmer
/theories/lehmer/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lehmer/
-
LEM
/theories/lem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lem/
-
Lifting_Definition_Option
/theories/lifting_definition_option/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lifting_definition_option/
-
Lifting_the_Exponent
/theories/lifting_the_exponent/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lifting_the_exponent/
-
LightweightJava
/theories/lightweightjava/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lightweightjava/
-
Linear_Inequalities
/theories/linear_inequalities/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_inequalities/
-
Linear_Programming
/theories/linear_programming/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_programming/
-
Linear_Recurrences
/theories/linear_recurrences/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_recurrences/
-
Linear_Recurrences_Solver
/theories/linear_recurrences_solver/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linear_recurrences_solver/
-
LinearQuantifierElim
/theories/linearquantifierelim/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/linearquantifierelim/
-
Liouville_Numbers
/theories/liouville_numbers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/liouville_numbers/
-
List-Index
/theories/list-index/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list-index/
-
List-Infinite
/theories/list-infinite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list-infinite/
-
List_Interleaving
/theories/list_interleaving/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list_interleaving/
-
List_Inversions
/theories/list_inversions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list_inversions/
-
List_Update
/theories/list_update/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/list_update/
-
LLL_Basis_Reduction
/theories/lll_basis_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lll_basis_reduction/
-
LLL_Factorization
/theories/lll_factorization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lll_factorization/
-
Localization_Ring
/theories/localization_ring/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/localization_ring/
-
LocalLexing
/theories/locallexing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/locallexing/
-
Locally-Nameless-Sigma
/theories/locally-nameless-sigma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/locally-nameless-sigma/
-
LOFT
/theories/loft/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/loft/
-
Logging_Independent_Anonymity
/theories/logging_independent_anonymity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/logging_independent_anonymity/
-
Lorenz_Approximation
/theories/lorenz_approximation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lorenz_approximation/
-
Lorenz_C0
/theories/lorenz_c0/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lorenz_c0/
-
Lorenz_C1
/theories/lorenz_c1/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lorenz_c1/
-
Lowe_Ontological_Argument
/theories/lowe_ontological_argument/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lowe_ontological_argument/
-
Lower_Semicontinuous
/theories/lower_semicontinuous/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lower_semicontinuous/
-
Lp
/theories/lp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lp/
-
LP_Duality
/theories/lp_duality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lp_duality/
-
LTL
/theories/ltl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl/
-
LTL_Master_Theorem
/theories/ltl_master_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_master_theorem/
-
LTL_Normal_Form
/theories/ltl_normal_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_normal_form/
-
LTL_to_DRA
/theories/ltl_to_dra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_to_dra/
-
LTL_to_GBA
/theories/ltl_to_gba/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ltl_to_gba/
-
Lucas_Theorem
/theories/lucas_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/lucas_theorem/
-
Markov_Models
/theories/markov_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/markov_models/
-
Marriage
/theories/marriage/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/marriage/
-
Mason_Stothers
/theories/mason_stothers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mason_stothers/
-
Matrices_for_ODEs
/theories/matrices_for_odes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matrices_for_odes/
-
Matrix
/theories/matrix/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matrix/
-
Matrix_Tensor
/theories/matrix_tensor/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matrix_tensor/
-
Matroids
/theories/matroids/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/matroids/
-
Max-Card-Matching
/theories/max-card-matching/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/max-card-matching/
-
Maximum_Segment_Sum
/theories/maximum_segment_sum/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/maximum_segment_sum/
-
MDP-Algorithms
/theories/mdp-algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mdp-algorithms/
-
MDP-Rewards
/theories/mdp-rewards/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mdp-rewards/
-
Median_Method
/theories/median_method/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/median_method/
-
Median_Of_Medians_Selection
/theories/median_of_medians_selection/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/median_of_medians_selection/
-
Menger
/theories/menger/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/menger/
-
Mereology
/theories/mereology/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mereology/
-
Mersenne_Primes
/theories/mersenne_primes/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mersenne_primes/
-
Metalogic_ProofChecker
/theories/metalogic_proofchecker/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/metalogic_proofchecker/
-
MFMC_Countable
/theories/mfmc_countable/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mfmc_countable/
-
MFODL_Monitor_Optimized
/theories/mfodl_monitor_optimized/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mfodl_monitor_optimized/
-
MFOTL_Monitor
/theories/mfotl_monitor/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mfotl_monitor/
-
MHComputation
/theories/mhcomputation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mhcomputation/
-
Minimal_SSA
/theories/minimal_ssa/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minimal_ssa/
-
MiniML
/theories/miniml/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/miniml/
-
MiniSail
/theories/minisail/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minisail/
-
Minkowskis_Theorem
/theories/minkowskis_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minkowskis_theorem/
-
Minsky_Machines
/theories/minsky_machines/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/minsky_machines/
-
MLSS_Decision_Proc
/theories/mlss_decision_proc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mlss_decision_proc/
-
Modal_Logics_for_NTS
/theories/modal_logics_for_nts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/modal_logics_for_nts/
-
Modular_arithmetic_LLL_and_HNF_algorithms
/theories/modular_arithmetic_lll_and_hnf_algorithms/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/modular_arithmetic_lll_and_hnf_algorithms/
-
Modular_Assembly_Kit_Security
/theories/modular_assembly_kit_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/modular_assembly_kit_security/
-
Monad_Memo_DP
/theories/monad_memo_dp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monad_memo_dp/
-
Monad_Normalisation
/theories/monad_normalisation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monad_normalisation/
-
MonoBoolTranAlgebra
/theories/monobooltranalgebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monobooltranalgebra/
-
MonoidalCategory
/theories/monoidalcategory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monoidalcategory/
-
Monomorphic_Monad
/theories/monomorphic_monad/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/monomorphic_monad/
-
MSO_Regex_Equivalence
/theories/mso_regex_equivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/mso_regex_equivalence/
-
MuchAdoAboutTwo
/theories/muchadoabouttwo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/muchadoabouttwo/
-
Multi_Party_Computation
/theories/multi_party_computation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multi_party_computation/
-
Multirelations
/theories/multirelations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multirelations/
-
Multirelations_Heterogeneous
/theories/multirelations_heterogeneous/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multirelations_heterogeneous/
-
Multiset_Ordering_NPC
/theories/multiset_ordering_npc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multiset_ordering_npc/
-
Multitape_To_Singletape_TM
/theories/multitape_to_singletape_tm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/multitape_to_singletape_tm/
-
Myhill-Nerode
/theories/myhill-nerode/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/myhill-nerode/
-
Name_Carrying_Type_Inference
/theories/name_carrying_type_inference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/name_carrying_type_inference/
-
Nano_JSON
/theories/nano_json/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nano_json/
-
Nash_Williams
/theories/nash_williams/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nash_williams/
-
Nat-Interval-Logic
/theories/nat-interval-logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nat-interval-logic/
-
Native_Word
/theories/native_word/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/native_word/
-
Nested_Multisets_Ordinals
/theories/nested_multisets_ordinals/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nested_multisets_ordinals/
-
Network_Security_Policy_Verification
/theories/network_security_policy_verification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/network_security_policy_verification/
-
Neumann_Morgenstern_Utility
/theories/neumann_morgenstern_utility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/neumann_morgenstern_utility/
-
No_FTL_observers
/theories/no_ftl_observers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/no_ftl_observers/
-
No_FTL_observers_Gen_Rel
/theories/no_ftl_observers_gen_rel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/no_ftl_observers_gen_rel/
-
Nominal2
/theories/nominal2/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nominal2/
-
Noninterference_Concurrent_Composition
/theories/noninterference_concurrent_composition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_concurrent_composition/
-
Noninterference_CSP
/theories/noninterference_csp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_csp/
-
Noninterference_Generic_Unwinding
/theories/noninterference_generic_unwinding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_generic_unwinding/
-
Noninterference_Inductive_Unwinding
/theories/noninterference_inductive_unwinding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_inductive_unwinding/
-
Noninterference_Ipurge_Unwinding
/theories/noninterference_ipurge_unwinding/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_ipurge_unwinding/
-
Noninterference_Sequential_Composition
/theories/noninterference_sequential_composition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/noninterference_sequential_composition/
-
NormByEval
/theories/normbyeval/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/normbyeval/
-
Nullstellensatz
/theories/nullstellensatz/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/nullstellensatz/
-
Number_Theoretic_Transform
/theories/number_theoretic_transform/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/number_theoretic_transform/
-
Octonions
/theories/octonions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/octonions/
-
Old_Datatype_Show
/theories/old_datatype_show/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/old_datatype_show/
-
Open_Induction
/theories/open_induction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/open_induction/
-
OpSets
/theories/opsets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/opsets/
-
Optics
/theories/optics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/optics/
-
Optimal_BST
/theories/optimal_bst/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/optimal_bst/
-
Orbit_Stabiliser
/theories/orbit_stabiliser/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/orbit_stabiliser/
-
Order_Lattice_Props
/theories/order_lattice_props/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/order_lattice_props/
-
Ordered_Resolution_Prover
/theories/ordered_resolution_prover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordered_resolution_prover/
-
Ordinal
/theories/ordinal/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinal/
-
Ordinal_Partitions
/theories/ordinal_partitions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinal_partitions/
-
Ordinals_and_Cardinals
/theories/ordinals_and_cardinals/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinals_and_cardinals/
-
Ordinary_Differential_Equations
/theories/ordinary_differential_equations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ordinary_differential_equations/
-
PAC_Checker
/theories/pac_checker/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pac_checker/
-
Package_logic
/theories/package_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/package_logic/
-
Padic_Field
/theories/padic_field/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/padic_field/
-
Padic_Ints
/theories/padic_ints/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/padic_ints/
-
Pairing_Heap
/theories/pairing_heap/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pairing_heap/
-
PAL
/theories/pal/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pal/
-
PAPP_Impossibility
/theories/papp_impossibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/papp_impossibility/
-
Paraconsistency
/theories/paraconsistency/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/paraconsistency/
-
Parity_Game
/theories/parity_game/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/parity_game/
-
Partial_Function_MR
/theories/partial_function_mr/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/partial_function_mr/
-
Partial_Order_Reduction
/theories/partial_order_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/partial_order_reduction/
-
Password_Authentication_Protocol
/theories/password_authentication_protocol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/password_authentication_protocol/
-
PCF
/theories/pcf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pcf/
-
Pell
/theories/pell/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pell/
-
Perfect-Number-Thm
/theories/perfect-number-thm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/perfect-number-thm/
-
Perron_Frobenius
/theories/perron_frobenius/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/perron_frobenius/
-
pGCL
/theories/pgcl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pgcl/
-
Physical_Quantities
/theories/physical_quantities/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/physical_quantities/
-
Pi_Calculus
/theories/pi_calculus/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pi_calculus/
-
Pi_Transcendental
/theories/pi_transcendental/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pi_transcendental/
-
Planarity_Certificates
/theories/planarity_certificates/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/planarity_certificates/
-
PLM
/theories/plm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/plm/
-
Pluennecke_Ruzsa_Inequality
/theories/pluennecke_ruzsa_inequality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pluennecke_ruzsa_inequality/
-
Poincare_Bendixson
/theories/poincare_bendixson/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/poincare_bendixson/
-
Poincare_Disc
/theories/poincare_disc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/poincare_disc/
-
Polynomial_Factorization
/theories/polynomial_factorization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/polynomial_factorization/
-
Polynomial_Interpolation
/theories/polynomial_interpolation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/polynomial_interpolation/
-
Polynomials
/theories/polynomials/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/polynomials/
-
Pop_Refinement
/theories/pop_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pop_refinement/
-
POPLmark-deBruijn
/theories/poplmark-debruijn/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/poplmark-debruijn/
-
Posix-Lexing
/theories/posix-lexing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/posix-lexing/
-
Possibilistic_Noninterference
/theories/possibilistic_noninterference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/possibilistic_noninterference/
-
Power_Sum_Polynomials
/theories/power_sum_polynomials/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/power_sum_polynomials/
-
Pratt_Certificate
/theories/pratt_certificate/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pratt_certificate/
-
Prefix_Free_Code_Combinators
/theories/prefix_free_code_combinators/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prefix_free_code_combinators/
-
Presburger-Automata
/theories/presburger-automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/presburger-automata/
-
Prim_Dijkstra_Simple
/theories/prim_dijkstra_simple/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prim_dijkstra_simple/
-
Prime_Distribution_Elementary
/theories/prime_distribution_elementary/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prime_distribution_elementary/
-
Prime_Harmonic_Series
/theories/prime_harmonic_series/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prime_harmonic_series/
-
Prime_Number_Theorem
/theories/prime_number_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prime_number_theorem/
-
Priority_Queue_Braun
/theories/priority_queue_braun/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/priority_queue_braun/
-
Priority_Search_Trees
/theories/priority_search_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/priority_search_trees/
-
Probabilistic_Noninterference
/theories/probabilistic_noninterference/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_noninterference/
-
Probabilistic_Prime_Tests
/theories/probabilistic_prime_tests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_prime_tests/
-
Probabilistic_System_Zoo
/theories/probabilistic_system_zoo/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_system_zoo/
-
Probabilistic_Timed_Automata
/theories/probabilistic_timed_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_timed_automata/
-
Probabilistic_While
/theories/probabilistic_while/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probabilistic_while/
-
Probability_Inequality_Completeness
/theories/probability_inequality_completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/probability_inequality_completeness/
-
Program-Conflict-Analysis
/theories/program-conflict-analysis/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/program-conflict-analysis/
-
Progress_Tracking
/theories/progress_tracking/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/progress_tracking/
-
Projective_Geometry
/theories/projective_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/projective_geometry/
-
Projective_Measurements
/theories/projective_measurements/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/projective_measurements/
-
Promela
/theories/promela/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/promela/
-
Proof_Strategy_Language
/theories/proof_strategy_language/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/proof_strategy_language/
-
Propositional_Logic_Class
/theories/propositional_logic_class/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/propositional_logic_class/
-
Propositional_Proof_Systems
/theories/propositional_proof_systems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/propositional_proof_systems/
-
PropResPI
/theories/proprespi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/proprespi/
-
Prpu_Maxflow
/theories/prpu_maxflow/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/prpu_maxflow/
-
PSemigroupsConvolution
/theories/psemigroupsconvolution/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/psemigroupsconvolution/
-
PseudoHoops
/theories/pseudohoops/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/pseudohoops/
-
Psi_Calculi
/theories/psi_calculi/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/psi_calculi/
-
Ptolemys_Theorem
/theories/ptolemys_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ptolemys_theorem/
-
Public_Announcement_Logic
/theories/public_announcement_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/public_announcement_logic/
-
QHLProver
/theories/qhlprover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/qhlprover/
-
QR_Decomposition
/theories/qr_decomposition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/qr_decomposition/
-
Quantales
/theories/quantales/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quantales/
-
Quantifier_Elimination_Hybrid
/theories/quantifier_elimination_hybrid/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quantifier_elimination_hybrid/
-
Quasi_Borel_Spaces
/theories/quasi_borel_spaces/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quasi_borel_spaces/
-
Quaternions
/theories/quaternions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quaternions/
-
Query_Optimization
/theories/query_optimization/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/query_optimization/
-
Quick_Sort_Cost
/theories/quick_sort_cost/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/quick_sort_cost/
-
Ramsey-Infinite
/theories/ramsey-infinite/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ramsey-infinite/
-
Random_BSTs
/theories/random_bsts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/random_bsts/
-
Random_Graph_Subgraph_Threshold
/theories/random_graph_subgraph_threshold/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/random_graph_subgraph_threshold/
-
Randomised_BSTs
/theories/randomised_bsts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/randomised_bsts/
-
Randomised_Social_Choice
/theories/randomised_social_choice/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/randomised_social_choice/
-
Rank_Nullity_Theorem
/theories/rank_nullity_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rank_nullity_theorem/
-
Real_Impl
/theories/real_impl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/real_impl/
-
Real_Power
/theories/real_power/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/real_power/
-
Real_Time_Deque
/theories/real_time_deque/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/real_time_deque/
-
Recursion-Addition
/theories/recursion-addition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/recursion-addition/
-
Recursion-Theory-I
/theories/recursion-theory-i/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/recursion-theory-i/
-
Refine_Imperative_HOL
/theories/refine_imperative_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/refine_imperative_hol/
-
Refine_Monadic
/theories/refine_monadic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/refine_monadic/
-
RefinementReactive
/theories/refinementreactive/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/refinementreactive/
-
Regex_Equivalence
/theories/regex_equivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regex_equivalence/
-
Registers
/theories/registers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/registers/
-
Regression_Test_Selection
/theories/regression_test_selection/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regression_test_selection/
-
Regular-Sets
/theories/regular-sets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regular-sets/
-
Regular_Algebras
/theories/regular_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regular_algebras/
-
Regular_Tree_Relations
/theories/regular_tree_relations/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/regular_tree_relations/
-
Relation_Algebra
/theories/relation_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relation_algebra/
-
Relational-Incorrectness-Logic
/theories/relational-incorrectness-logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational-incorrectness-logic/
-
Relational_Disjoint_Set_Forests
/theories/relational_disjoint_set_forests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_disjoint_set_forests/
-
Relational_Forests
/theories/relational_forests/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_forests/
-
Relational_Method
/theories/relational_method/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_method/
-
Relational_Minimum_Spanning_Trees
/theories/relational_minimum_spanning_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_minimum_spanning_trees/
-
Relational_Paths
/theories/relational_paths/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/relational_paths/
-
Rensets
/theories/rensets/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rensets/
-
Rep_Fin_Groups
/theories/rep_fin_groups/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rep_fin_groups/
-
Residuated_Lattices
/theories/residuated_lattices/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/residuated_lattices/
-
ResiduatedTransitionSystem
/theories/residuatedtransitionsystem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/residuatedtransitionsystem/
-
Resolution_FOL
/theories/resolution_fol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/resolution_fol/
-
Rewrite_Properties_Reduction
/theories/rewrite_properties_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rewrite_properties_reduction/
-
Rewriting_Z
/theories/rewriting_z/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rewriting_z/
-
Ribbon_Proofs
/theories/ribbon_proofs/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ribbon_proofs/
-
RIPEMD-160-SPARK
/theories/ripemd-160-spark/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/ripemd-160-spark/
-
Risk_Free_Lending
/theories/risk_free_lending/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/risk_free_lending/
-
Robbins-Conjecture
/theories/robbins-conjecture/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/robbins-conjecture/
-
ROBDD
/theories/robdd/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/robdd/
-
Robinson_Arithmetic
/theories/robinson_arithmetic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/robinson_arithmetic/
-
Root_Balanced_Tree
/theories/root_balanced_tree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/root_balanced_tree/
-
Roth_Arithmetic_Progressions
/theories/roth_arithmetic_progressions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/roth_arithmetic_progressions/
-
Routing
/theories/routing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/routing/
-
Roy_Floyd_Warshall
/theories/roy_floyd_warshall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/roy_floyd_warshall/
-
RSAPSS
/theories/rsapss/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/rsapss/
-
Safe_Distance
/theories/safe_distance/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/safe_distance/
-
Safe_OCL
/theories/safe_ocl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/safe_ocl/
-
Safe_Range_RC
/theories/safe_range_rc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/safe_range_rc/
-
SATSolverVerification
/theories/satsolververification/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/satsolververification/
-
Saturation_Framework
/theories/saturation_framework/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/saturation_framework/
-
Saturation_Framework_Extensions
/theories/saturation_framework_extensions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/saturation_framework_extensions/
-
Sauer_Shelah_Lemma
/theories/sauer_shelah_lemma/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sauer_shelah_lemma/
-
SC_DOM_Components
/theories/sc_dom_components/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sc_dom_components/
-
SCC_Bloemen_Sequential
/theories/scc_bloemen_sequential/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/scc_bloemen_sequential/
-
Schutz_Spacetime
/theories/schutz_spacetime/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/schutz_spacetime/
-
Schwartz_Zippel
/theories/schwartz_zippel/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/schwartz_zippel/
-
SDS_Impossibility
/theories/sds_impossibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sds_impossibility/
-
Secondary_Sylow
/theories/secondary_sylow/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/secondary_sylow/
-
Security_Protocol_Refinement
/theories/security_protocol_refinement/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/security_protocol_refinement/
-
Selection_Heap_Sort
/theories/selection_heap_sort/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/selection_heap_sort/
-
SenSocialChoice
/theories/sensocialchoice/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sensocialchoice/
-
Separata
/theories/separata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separata/
-
Separation_Algebra
/theories/separation_algebra/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separation_algebra/
-
Separation_Logic_Imperative_HOL
/theories/separation_logic_imperative_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separation_logic_imperative_hol/
-
Separation_Logic_Unbounded
/theories/separation_logic_unbounded/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/separation_logic_unbounded/
-
Sepref_Basic
/theories/sepref_basic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sepref_basic/
-
Sepref_IICF
/theories/sepref_iicf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sepref_iicf/
-
Sepref_Prereq
/theories/sepref_prereq/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sepref_prereq/
-
SequentInvertibility
/theories/sequentinvertibility/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sequentinvertibility/
-
Shadow_DOM
/theories/shadow_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shadow_dom/
-
Shadow_SC_DOM
/theories/shadow_sc_dom/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shadow_sc_dom/
-
Shivers-CFA
/theories/shivers-cfa/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shivers-cfa/
-
ShortestPath
/theories/shortestpath/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/shortestpath/
-
Show
/theories/show/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/show/
-
SIFPL
/theories/sifpl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sifpl/
-
SIFUM_Type_Systems
/theories/sifum_type_systems/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sifum_type_systems/
-
Sigma_Commit_Crypto
/theories/sigma_commit_crypto/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sigma_commit_crypto/
-
Signature_Groebner
/theories/signature_groebner/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/signature_groebner/
-
Simpl
/theories/simpl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simpl/
-
Simple_Clause_Learning
/theories/simple_clause_learning/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simple_clause_learning/
-
Simple_Firewall
/theories/simple_firewall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simple_firewall/
-
Simplex
/theories/simplex/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simplex/
-
Simplicial_complexes_and_boolean_functions
/theories/simplicial_complexes_and_boolean_functions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simplicial_complexes_and_boolean_functions/
-
SimplifiedOntologicalArgument
/theories/simplifiedontologicalargument/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/simplifiedontologicalargument/
-
Skew_Heap
/theories/skew_heap/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/skew_heap/
-
Skip_Lists
/theories/skip_lists/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/skip_lists/
-
Slicing
/theories/slicing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/slicing/
-
Sliding_Window_Algorithm
/theories/sliding_window_algorithm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sliding_window_algorithm/
-
SM
/theories/sm/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sm/
-
SM_Base
/theories/sm_base/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sm_base/
-
Smith_Normal_Form
/theories/smith_normal_form/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/smith_normal_form/
-
Smooth_Manifolds
/theories/smooth_manifolds/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/smooth_manifolds/
-
Solidity
/theories/solidity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/solidity/
-
Sophomores_Dream
/theories/sophomores_dream/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sophomores_dream/
-
Sort_Encodings
/theories/sort_encodings/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sort_encodings/
-
Source_Coding_Theorem
/theories/source_coding_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/source_coding_theorem/
-
SPARCv8
/theories/sparcv8/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sparcv8/
-
SpecCheck
/theories/speccheck/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/speccheck/
-
Special_Function_Bounds
/theories/special_function_bounds/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/special_function_bounds/
-
Splay_Tree
/theories/splay_tree/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/splay_tree/
-
Sqrt_Babylonian
/theories/sqrt_babylonian/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sqrt_babylonian/
-
Stable_Matching
/theories/stable_matching/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stable_matching/
-
Stalnaker_Logic
/theories/stalnaker_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stalnaker_logic/
-
Statecharts
/theories/statecharts/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/statecharts/
-
Stateful_Protocol_Composition_and_Typing
/theories/stateful_protocol_composition_and_typing/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stateful_protocol_composition_and_typing/
-
Stellar_Quorums
/theories/stellar_quorums/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stellar_quorums/
-
Stern_Brocot
/theories/stern_brocot/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stern_brocot/
-
Stewart_Apollonius
/theories/stewart_apollonius/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stewart_apollonius/
-
Stirling_Formula
/theories/stirling_formula/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stirling_formula/
-
Stochastic_Matrices
/theories/stochastic_matrices/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stochastic_matrices/
-
Stone_Algebras
/theories/stone_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stone_algebras/
-
Stone_Kleene_Relation_Algebras
/theories/stone_kleene_relation_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stone_kleene_relation_algebras/
-
Stone_Relation_Algebras
/theories/stone_relation_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stone_relation_algebras/
-
Store_Buffer_Reduction
/theories/store_buffer_reduction/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/store_buffer_reduction/
-
Stream-Fusion
/theories/stream-fusion/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stream-fusion/
-
Stream_Fusion_Code
/theories/stream_fusion_code/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stream_fusion_code/
-
StrictOmegaCategories
/theories/strictomegacategories/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/strictomegacategories/
-
Strong_Security
/theories/strong_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/strong_security/
-
Sturm_Sequences
/theories/sturm_sequences/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sturm_sequences/
-
Sturm_Tarski
/theories/sturm_tarski/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sturm_tarski/
-
Stuttering_Equivalence
/theories/stuttering_equivalence/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/stuttering_equivalence/
-
Subresultants
/theories/subresultants/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/subresultants/
-
Subset_Boolean_Algebras
/theories/subset_boolean_algebras/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/subset_boolean_algebras/
-
SumSquares
/theories/sumsquares/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sumsquares/
-
Sunflowers
/theories/sunflowers/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/sunflowers/
-
SuperCalc
/theories/supercalc/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/supercalc/
-
Suppes_Theorem
/theories/suppes_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/suppes_theorem/
-
Surprise_Paradox
/theories/surprise_paradox/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/surprise_paradox/
-
Symmetric_Polynomials
/theories/symmetric_polynomials/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/symmetric_polynomials/
-
Syntax_Independent_Logic
/theories/syntax_independent_logic/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/syntax_independent_logic/
-
Synthetic_Completeness
/theories/synthetic_completeness/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/synthetic_completeness/
-
Szemeredi_Regularity
/theories/szemeredi_regularity/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/szemeredi_regularity/
-
Szpilrajn
/theories/szpilrajn/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/szpilrajn/
-
Tail_Recursive_Functions
/theories/tail_recursive_functions/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tail_recursive_functions/
-
Tarskis_Geometry
/theories/tarskis_geometry/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tarskis_geometry/
-
Taylor_Models
/theories/taylor_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/taylor_models/
-
TESL_Language
/theories/tesl_language/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tesl_language/
-
Three_Circles
/theories/three_circles/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/three_circles/
-
Three_Squares
/theories/three_squares/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/three_squares/
-
Timed_Automata
/theories/timed_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/timed_automata/
-
TLA
/theories/tla/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tla/
-
Topological_Semantics
/theories/topological_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/topological_semantics/
-
Topology
/theories/topology/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/topology/
-
TortoiseHare
/theories/tortoisehare/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tortoisehare/
-
Transcendence_Series_Hancl_Rucki
/theories/transcendence_series_hancl_rucki/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transcendence_series_hancl_rucki/
-
Transformer_Semantics
/theories/transformer_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transformer_semantics/
-
Transition_Systems_and_Automata
/theories/transition_systems_and_automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transition_systems_and_automata/
-
Transitive-Closure
/theories/transitive-closure/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transitive-closure/
-
Transitive-Closure-II
/theories/transitive-closure-ii/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transitive-closure-ii/
-
Transitive_Models
/theories/transitive_models/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/transitive_models/
-
Treaps
/theories/treaps/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/treaps/
-
Tree-Automata
/theories/tree-automata/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tree-automata/
-
Tree_Decomposition
/theories/tree_decomposition/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tree_decomposition/
-
Tree_Enumeration
/theories/tree_enumeration/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tree_enumeration/
-
Triangle
/theories/triangle/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/triangle/
-
Trie
/theories/trie/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/trie/
-
TsirelsonBound
/theories/tsirelsonbound/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tsirelsonbound/
-
Turans_Graph_Theorem
/theories/turans_graph_theorem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/turans_graph_theorem/
-
Twelvefold_Way
/theories/twelvefold_way/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/twelvefold_way/
-
Two_Generated_Word_Monoids_Intersection
/theories/two_generated_word_monoids_intersection/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/two_generated_word_monoids_intersection/
-
Tycon
/theories/tycon/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/tycon/
-
Types_Tableaus_and_Goedels_God
/theories/types_tableaus_and_goedels_god/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/types_tableaus_and_goedels_god/
-
Types_To_Sets_Extension
/theories/types_to_sets_extension/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/types_to_sets_extension/
-
Undirected_Graph_Theory
/theories/undirected_graph_theory/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/undirected_graph_theory/
-
Universal_Hash_Families
/theories/universal_hash_families/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/universal_hash_families/
-
Universal_Turing_Machine
/theories/universal_turing_machine/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/universal_turing_machine/
-
UpDown_Scheme
/theories/updown_scheme/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/updown_scheme/
-
UPF
/theories/upf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/upf/
-
UPF_Firewall
/theories/upf_firewall/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/upf_firewall/
-
UTP
/theories/utp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/utp/
-
UTP-Toolkit
/theories/utp-toolkit/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/utp-toolkit/
-
Valuation
/theories/valuation/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/valuation/
-
Van_der_Waerden
/theories/van_der_waerden/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/van_der_waerden/
-
Van_Emde_Boas_Trees
/theories/van_emde_boas_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/van_emde_boas_trees/
-
VectorSpace
/theories/vectorspace/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vectorspace/
-
VeriComp
/theories/vericomp/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vericomp/
-
Verified-Prover
/theories/verified-prover/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verified-prover/
-
Verified_SAT_Based_AI_Planning
/theories/verified_sat_based_ai_planning/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verified_sat_based_ai_planning/
-
VerifyThis2018
/theories/verifythis2018/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verifythis2018/
-
VerifyThis2019
/theories/verifythis2019/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/verifythis2019/
-
Vickrey_Clarke_Groves
/theories/vickrey_clarke_groves/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vickrey_clarke_groves/
-
Virtual_Substitution
/theories/virtual_substitution/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/virtual_substitution/
-
VolpanoSmith
/theories/volpanosmith/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/volpanosmith/
-
VYDRA_MDL
/theories/vydra_mdl/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/vydra_mdl/
-
WebAssembly
/theories/webassembly/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/webassembly/
-
Weight_Balanced_Trees
/theories/weight_balanced_trees/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/weight_balanced_trees/
-
Weighted_Arithmetic_Geometric_Mean
/theories/weighted_arithmetic_geometric_mean/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/weighted_arithmetic_geometric_mean/
-
Weighted_Path_Order
/theories/weighted_path_order/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/weighted_path_order/
-
Well_Quasi_Orders
/theories/well_quasi_orders/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/well_quasi_orders/
-
Wetzels_Problem
/theories/wetzels_problem/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/wetzels_problem/
-
WHATandWHERE_Security
/theories/whatandwhere_security/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/whatandwhere_security/
-
Winding_Number_Eval
/theories/winding_number_eval/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/winding_number_eval/
-
WOOT_Strong_Eventual_Consistency
/theories/woot_strong_eventual_consistency/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/woot_strong_eventual_consistency/
-
Word_Lib
/theories/word_lib/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/word_lib/
-
WorkerWrapper
/theories/workerwrapper/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/workerwrapper/
-
X86_Semantics
/theories/x86_semantics/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/x86_semantics/
-
XML
/theories/xml/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/xml/
-
Youngs_Inequality
/theories/youngs_inequality/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/youngs_inequality/
-
Zeckendorf
/theories/zeckendorf/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zeckendorf/
-
Zeta_3_Irrational
/theories/zeta_3_irrational/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zeta_3_irrational/
-
Zeta_Function
/theories/zeta_function/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zeta_function/
-
ZFC_in_HOL
/theories/zfc_in_hol/
Mon, 01 Jan 0001 00:00:00 +0000
/theories/zfc_in_hol/