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&#x27;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&ouml;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&ouml;del's Incompleteness Theorems&mdash;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&ouml;del's Incompleteness Theorems&mdash;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 &lambda;-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/