diff --git a/web/authors/yu/index.html b/web/authors/yu/index.html --- a/web/authors/yu/index.html +++ b/web/authors/yu/index.html @@ -1,99 +1,99 @@ Lei Yu- Archive of Formal Proofs

Lei Yu

E-Mails 📧

- +

Entries

2013

Jul 27
\ No newline at end of file diff --git a/web/entries/ABY3_Protocols.html b/web/entries/ABY3_Protocols.html --- a/web/entries/ABY3_Protocols.html +++ b/web/entries/ABY3_Protocols.html @@ -1,165 +1,168 @@ ABY3 Multiplication and Array Shuffling - Archive of Formal Proofs

ABY3 Multiplication and Array Shuffling

Shuwei Hu 📧

January 27, 2023

Abstract

We formalizes two protocols from a privacy-preserving machine-learning framework based on ABY3, a particular three-party computation framework where inputs are systematically ‘reshared’ without being considered as privacy leakage. In particular, we consider the multiplication protocol and the array shuffling protocol, both based on ABY3's additive secret sharing scheme. We proved their security in the semi-honest setting under the ideal/real simulation paradigm. These two proof-of-concept opens the door to further verification of more protocols within the framework.

License

BSD License

Topics

Session ABY3_Protocols

Depends on

\ No newline at end of file diff --git a/web/entries/AOT.html b/web/entries/AOT.html --- a/web/entries/AOT.html +++ b/web/entries/AOT.html @@ -1,187 +1,190 @@ Abstract Object Theory - Archive of Formal Proofs

Abstract Object Theory

Daniel Kirchner 📧

November 28, 2022

Abstract

We utilize and extend the method of shallow semantic embeddings (SSEs) in classical higher-order logic (HOL) to construct a custom theorem proving environment for abstract objects theory (AOT) on the basis of Isabelle/HOL. SSEs are a means for universal logical reasoning by translating a target logic to HOL using a representation of its semantics. AOT is a foundational metaphysical theory, developed by Edward Zalta, that explains the objects presupposed by the sciences as abstract objects that reify property patterns. In particular, AOT aspires to provide a philosphically grounded basis for the construction and analysis of the objects of mathematics. We can support this claim by verifying Uri Nodelman's and Edward Zalta's reconstruction of Frege's theorem: we can confirm that the Dedekind-Peano postulates for natural numbers are consistently derivable in AOT using Frege's method. Furthermore, we can suggest and discuss generalizations and variants of the construction and can thereby provide theoretical insights into, and contribute to the philosophical justification of, the construction. In the process, we can demonstrate that our method allows for a nearly transparent exchange of results between traditional pen-and-paper-based reasoning and the computerized implementation, which in turn can retain the automation mechanisms available for Isabelle/HOL. During our work, we could significantly contribute to the evolution of our target theory itself, while simultaneously solving the technical challenge of using an SSE to implement a theory that is based on logical foundations that significantly differ from the meta-logic HOL. In general, our results demonstrate the fruitfulness of the practice of Computational Metaphysics, i.e. the application of computational methods to metaphysical questions and theories.

License

BSD License

Topics

Related publications

  • Kirchner, D. (2022). Computer-Verified Foundations of Metaphysics and an Ontology of Natural Numbers in Isabelle/HOL [Freie UniversitĂ€t Berlin]. https://doi.org/10.17169/REFUBIUM-35141
  • http://mally.stanford.edu/principia-2021-10-13.pdf
  • http://mally.stanford.edu/principia.pdf

Session AOT

\ No newline at end of file diff --git a/web/entries/Balog_Szemeredi_Gowers.html b/web/entries/Balog_Szemeredi_Gowers.html --- a/web/entries/Balog_Szemeredi_Gowers.html +++ b/web/entries/Balog_Szemeredi_Gowers.html @@ -1,195 +1,198 @@ The Balog–SzemerĂ©di–Gowers Theorem - Archive of Formal Proofs

The Balog–SzemerĂ©di–Gowers Theorem

Angeliki Koutsoukou-Argyraki 🌐, Mantas Bakơys 🌐 and Chelsea Edmonds 🌐

November 11, 2022

Abstract

We formalise the Balog–SzemerĂ©di–Gowers Theorem, a profound result in additive combinatorics which played a central role in Gowers's proof deriving the first effective bounds for SzemerĂ©di's Theorem. The proof is of great mathematical interest given that it involves an interplay between different mathematical areas, namely applications of graph theory and probability theory to additive combinatorics involving algebraic objects. This interplay is what made the process of the formalisation, for which we had to develop formalisations of new background material in the aforementioned areas, more rich and technically challenging. We demonstrate how locales, Isabelle’s module system, can be employed to handle such interplays. To treat the graph-theoretic aspects of the proof, we make use of a new, more general undirected graph theory library developed recently by Chelsea Edmonds, which is both flexible and extensible. For the formalisation we followed a proof presented in the 2022 lecture notes by Timothy Gowers Introduction to Additive Combinatorics for Part III of the Mathematical Tripos taught at the University of Cambridge. In addition to the main theorem, which, following our source, is formulated for difference sets, we also give an alternative version for sumsets which required a formalisation of an auxiliary triangle inequality following a proof by Yufei Zhao from his book Graph Theory and Additive Combinatorics . We moreover formalise a few additional results in additive combinatorics that are not used in the proof of the main theorem. This is the first formalisation of the Balog–SzemerĂ©di–Gowers Theorem in any proof assistant to our knowledge.

License

BSD License

Topics

Related publications

Session Balog_Szemeredi_Gowers

\ No newline at end of file diff --git a/web/entries/Binary_Code_Imprimitive.html b/web/entries/Binary_Code_Imprimitive.html --- a/web/entries/Binary_Code_Imprimitive.html +++ b/web/entries/Binary_Code_Imprimitive.html @@ -1,189 +1,192 @@ Binary codes that do not preserve primitivity - Archive of Formal Proofs

Binary Codes That Do Not Preserve Primitivity

Ơtěpán Holub 📧 and Martin Raơka

January 3, 2023

Abstract

A code $X$ is not primitivity preserving if there is a primitive list $\mathtt{ws} \in \mathtt{lists} \ X$ whose concatenation is imprimitive. We formalize a full characterization of such codes in the binary case in the proof assistant Isabelle/HOL. Part of the formalization, interesting on its own, is a description of $\{x,y\}$-interpretations of the square $xx$ if $\mathtt{length}\ y \leq \mathtt{length} \ x$. We also provide a formalized parametric solution of the related equation $x^jy^k = z^\ell$. The core of the theory is an investigation of imprimitive words which are concatenations of copies of two noncommuting words (such a pair of words is called a binary code). We follow the article [Barbin-Le Rest, Le Rest, 85] (mainly ThĂ©orĂšme 2.1 and Lemme 3.1), while substantially optimizing the proof. See also [J.-C. Spehner. Quelques problĂšmes d’extension, de conjugaison et de prĂ©sentation des sous-monoĂŻdes d’un monoĂŻde libre. PhD thesis, UniversitĂ© Paris VII, 1976] for an earlier result on this question, and [Maƈuch, 01] for another proof.

License

BSD License

History

August 17, 2023
Updated to version v1.10.1.

Topics

Related publications

  • Holub, Ć ., RaĆĄka, M., & Starosta, Ć . (2023). Binary Codes that do not Preserve Primitivity. Journal of Automated Reasoning, 67(3). https://doi.org/10.1007/s10817-023-09674-2
  • Rest, E. B., & Rest, M. L. (1985). Sur la combinatoire des codes Ă  deux mots. Theoretical Computer Science, 41, 61–80. https://doi.org/10.1016/0304-3975(85)90060-x
  • Maƈuch, J. (2001). Defect Effect of Bi-infinite Words in the Two-element Case. Discrete Mathematics & Theoretical Computer Science, Vol. 4 no. 2. https://doi.org/10.46298/dmtcs.279
  • J.-C. Spehner. Quelques problĂšmes d’extension, de conjugaison et de prĂ©sentation des sous-monoĂŻdes d’un monoĂŻde libre. PhD thesis, UniversitĂ© Paris VII, 1976
  • Development repository

Session Binary_Code_Imprimitive

\ No newline at end of file diff --git a/web/entries/Birkhoff_Finite_Distributive_Lattices.html b/web/entries/Birkhoff_Finite_Distributive_Lattices.html --- a/web/entries/Birkhoff_Finite_Distributive_Lattices.html +++ b/web/entries/Birkhoff_Finite_Distributive_Lattices.html @@ -1,168 +1,171 @@ Birkhoff's Representation Theorem For Finite Distributive Lattices - Archive of Formal Proofs

Birkhoff's Representation Theorem for Finite Distributive Lattices

Matthew Doty 📧

December 6, 2022

Abstract

This theory proves a theorem of Birkhoff that asserts that any finite distributive lattice is isomorphic to the set of down-sets of that lattice's join-irreducible elements. The isomorphism preserves order, meets and joins as well as complementation in the case the lattice is a Boolean algebra. A consequence of this representation theorem is that every finite Boolean algebra is isomorphic to a powerset algebra.

License

BSD License

Topics

Related publications

  • Birkhoff, G. (1937). Rings of sets. Duke Mathematical Journal, 3(3). https://doi.org/10.1215/s0012-7094-37-00334-x
  • B. A. Davey and H. A. Priestley, “Chapter 5.  Representation: The Finite Case,” in Introduction to Lattices and Order, 2nd ed., Cambridge, UK ; New York, NY: Cambridge University Press, 2002, pp. 112–124.

Session Birkhoff_Finite_Distributive_Lattices

\ No newline at end of file diff --git a/web/entries/Boolos_Curious_Inference_Automated.html b/web/entries/Boolos_Curious_Inference_Automated.html --- a/web/entries/Boolos_Curious_Inference_Automated.html +++ b/web/entries/Boolos_Curious_Inference_Automated.html @@ -1,159 +1,162 @@ Automation of Boolos' Curious Inference in Isabelle/HOL - Archive of Formal Proofs

Automation of Boolos' Curious Inference in Isabelle/HOL

Christoph BenzmĂŒller 📧, David Fuenmayor 📧, Alexander Steen and Geoff Sutcliffe

December 5, 2022

Abstract

Boolos’ Curious Inference is automated in Isabelle/HOL after interactive speculation of a suitable shorthand notation (one or two definitions).

License

BSD License

Topics

Related publications

  • BenzmĂŒller, C., Fuenmayor, D., Steen, A., & Sutcliffe, G. (2022). Who Finds the Short Proof? An Exploration of Variants of Boolos' Curious Inference using Higher-order Automated Theorem Provers. ArXiv. https://doi.org/10.48550/ARXIV.2208.06879

Session Boolos_Curious_Inference_Automated

\ No newline at end of file diff --git a/web/entries/CHERI-C_Memory_Model.html b/web/entries/CHERI-C_Memory_Model.html --- a/web/entries/CHERI-C_Memory_Model.html +++ b/web/entries/CHERI-C_Memory_Model.html @@ -1,164 +1,167 @@ A Formal CHERI-C Memory Model - Archive of Formal Proofs

A Formal CHERI-C Memory Model

Seung Hoon Park 🌐

November 25, 2022

Abstract

In this work, we present a formal memory model that provides a memory semantics for CHERI-C programs with uncompressed capabilities in a 'purecap' environment. We present a CHERI-C memory model theory with properties suitable for verification and potentially other types of analyses. Our theory generates an OCaml executable instance of the memory model, which is then used to instantiate the parametric Gillian program analysis framework, enabling concrete execution of CHERI-C programs. The tool can run a CHERI-C test suite, demonstrating the correctness of our tool, and catch a good class of safety violations that the CHERI hardware might miss.

License

BSD License

Topics

Related publications

  • Park, S. H., Pai, R., & Melham, T. (2022). A Formal CHERI-C Semantics for Verification. ArXiv. https://doi.org/10.48550/ARXIV.2211.07511

Session CHERI-C_Memory_Model

\ No newline at end of file diff --git a/web/entries/CVP_Hardness.html b/web/entries/CVP_Hardness.html --- a/web/entries/CVP_Hardness.html +++ b/web/entries/CVP_Hardness.html @@ -1,173 +1,176 @@ Hardness of Lattice Problems - Archive of Formal Proofs

Hardness of Lattice Problems

Katharina Kreuzer 📧

February 2, 2023

Abstract

This article formalizes the NP-hardness proofs of the Closest Vector Problem (CVP) and the Shortest Vector Problem (SVP) in maximum norm as well as the CVP in any p-norm for p>=1. CVP and SVP are two fundamental problems in lattice theory. Lattices are a discrete, additive subgroup of R^n and are used for lattice-based cryptography. The CVP asks to find the nearest lattice vector to a target. The SVP asks to find the shortest non-zero lattice vector. This entry formalizes the basic properties of lattices, the reduction from CVP to Subset Sum in both maximum and p-norm for a finite p with 1<= p and the reduction of SVP to Partition using the Bounded Homogeneous Linear Equations problem (BHLE) as an intermediate step. The formalization uncovered a number of problems with the existing proofs in the literature.

License

BSD License

Topics

Session CVP_Hardness

\ No newline at end of file diff --git a/web/entries/Catoids.html b/web/entries/Catoids.html --- a/web/entries/Catoids.html +++ b/web/entries/Catoids.html @@ -1,191 +1,194 @@ Catoids, Categories, Groupoids - Archive of Formal Proofs

Catoids, Categories, Groupoids

Georg Struth 📧

August 14, 2023

Abstract

This AFP entry formalises catoids, which are generalisations of single-set categories, and groupoids. More specifically, in catoids, the partial composition of arrows in a category is generalised to a multioperation, which sends pairs of elements to sets of elements, and the definedness condition of arrow composition -- two arrows can be composed if and only the target of the first matches the source of the second -- is relaxed. Beyond a library of basic laws for catoids, single-set categories and groupoids, I formalise the facts that every catoid can be lifted to a modal powerset quantale, that every groupoid can be lifted to a Dedekind quantale and to power set relation algebras, a special case of a famous result of JĂłnsson and Tarski. Finally, I show that single-set categories are equivalent to a standard axiomatisation of categories based on a set of objects and a set of arrows, and compare catoids with related structures such as multimonoid and relational monoids (monoids in the monoidal category Rel).

License

BSD License

Topics

Related publications

  • Cranch, J., Doherty, S., & Struth, G. (2020). Convolution and Concurrency (Version 1). arXiv. https://doi.org/10.48550/ARXIV.2002.02321
  • Calk, C., Fahrenberg, U., Johansen, C., Struth, G., & ZiemiaƄski, K. (2021). $$\ell r$$-Multisemigroups, Modal Quantales and the Origin of Locality. Lecture Notes in Computer Science, 90–107. https://doi.org/10.1007/978-3-030-88701-8_6
  • Fahrenberg, U., Johansen, C., Struth, G., & ZiemiaƄski, K. (2023). Catoids and modal convolution algebras. Algebra Universalis, 84(2). https://doi.org/10.1007/s00012-023-00805-9
  • Calk, C., Malbos, P., Pous, D., & Struth, G. (2023). Higher Catoids, Higher Quantales and their Correspondences (Version 1). arXiv. https://doi.org/10.48550/ARXIV.2307.09253

Session Catoids

\ No newline at end of file diff --git a/web/entries/Ceva.html b/web/entries/Ceva.html --- a/web/entries/Ceva.html +++ b/web/entries/Ceva.html @@ -1,162 +1,165 @@ Ceva's Theorem - Archive of Formal Proofs

Ceva's Theorem

Mathias Schack Rabing 📧

August 16, 2023

Abstract

This entry contains a definition of the area the triangle constructed by three points. Building on this, some basic geometric properties about the area of a triangle are derived. These properties are used to prove Ceva's theorem.

License

BSD License

Topics

Session Ceva

\ No newline at end of file diff --git a/web/entries/Combinatorial_Enumeration_Algorithms.html b/web/entries/Combinatorial_Enumeration_Algorithms.html --- a/web/entries/Combinatorial_Enumeration_Algorithms.html +++ b/web/entries/Combinatorial_Enumeration_Algorithms.html @@ -1,188 +1,191 @@ Combinatorial Enumeration Algorithms - Archive of Formal Proofs

Combinatorial Enumeration Algorithms

Paul Hofmeier 📧 and Emin Karayel 📧

November 11, 2022

Abstract

Combinatorial objects have configurations which can be enumerated by algorithms, but especially for imperative programs, it is difficult to find out if they produce the correct output and don’t generate duplicates. Therefore, for some of the most common combinatorial objects, namely n_Sequences, n_Permutations, n_Subsets, Powerset, Integer_Compositions, Integer_Partitions, Weak_Integer_Compositions, Derangements and Trees, this entry formalizes efficient functional programs and verifies their correctness. In addition, it provides cardinality proofs for those combinatorial objects. Some cardinalities are verified using the enumeration functions and others are shown using existing libraries including other AFP entries.

License

BSD License

Topics

Related publications

  • Hofmeier, Paul. (2022). Verification of Combinatorial Algorithms [Bachelor's Thesis, Technische UniversitĂ€t MĂŒnchen]. mediaTUM. https://mediatum.ub.tum.de/1693026

Session Combinatorial_Enumeration_Algorithms

\ No newline at end of file diff --git a/web/entries/CommCSL.html b/web/entries/CommCSL.html --- a/web/entries/CommCSL.html +++ b/web/entries/CommCSL.html @@ -1,171 +1,174 @@ Formalization of CommCSL: A Relational Concurrent Separation Logic for Proving Information Flow Security in Concurrent Programs - Archive of Formal Proofs

Formalization of CommCSL: A Relational Concurrent Separation Logic for Proving Information Flow Security in Concurrent Programs

Thibault Dardinier 📧

March 15, 2023

Abstract

Information flow security ensures that the secret data manipulated by a program does not influence its observable output. Proving information flow security is especially challenging for concurrent programs, where operations on secret data may influence the execution time of a thread and, thereby, the interleaving between threads. Such internal timing channels may affect the observable outcome of a program even if an attacker does not observe execution times. Existing verification techniques for information flow security in concurrent programs attempt to prove that secret data does not influence the relative timing of threads. However, these techniques are often restrictive (for instance because they disallow branching on secret data) and make strong assumptions about the execution platform (ignoring caching, processor instructions with data-dependent execution time, and other common features that affect execution time).

In this entry, we formalize and prove the soundness of CommCSL, a novel relational concurrent separation logic for proving secure information flow in concurrent programs that lifts these restrictions and does not make any assumptions about timing behavior. The key idea is to prove that all mutating operations performed on shared data commute, such that different thread interleavings do not influence its final value. Crucially, commutativity is required only for an abstraction of the shared data that contains the information that will be leaked to a public output. Abstract commutativity is satisfied by many more operations than standard commutativity, which makes our technique widely applicable.

License

BSD License

Topics

Related publications

  • Eilers, M., Dardinier, T., & MĂŒller, P. (2022). CommCSL: Proving Information Flow Security for Concurrent Programs using Abstract Commutativity (Version 2). arXiv. https://doi.org/10.48550/ARXIV.2211.08459

Session CommCSL

\ No newline at end of file diff --git a/web/entries/Cook_Levin.html b/web/entries/Cook_Levin.html --- a/web/entries/Cook_Levin.html +++ b/web/entries/Cook_Levin.html @@ -1,182 +1,185 @@ The Cook-Levin theorem - Archive of Formal Proofs

The Cook-Levin Theorem

Frank J. Balbach 📧

January 8, 2023

Abstract

The Cook-Levin theorem states that deciding the satisfiability of Boolean formulas in conjunctive normal form is $\mathcal{NP}$-complete. This entry formalizes a proof of this theorem based on the textbook Computational Complexity: A Modern Approach by Arora and Barak. It contains definitions of deterministic multi-tape Turing machines, the complexity classes $\mathcal{P}$ and $\mathcal{NP}$, polynomial-time many-one reduction, and the decision problem $\mathtt{SAT}$. For the $\mathcal{NP}$-hardness of $\mathtt{SAT}$, the proof first shows that every polynomial-time computation can be performed by a two-tape oblivious Turing machine. An $\mathcal{NP}$ problem can then be reduced to $\mathtt{SAT}$ by a polynomial-time Turing machine that encodes computations of the problem's oblivious two-tape verifier Turing machine as formulas in conjunctive normal form.

License

BSD License

Topics

Related publications

  • Sanjeev Arora and Boaz Barak. Computational Complexity: A Modern Approach. Cambridge University Press, 2006.
  • Stephen A. Cook. The complexity of theorem-proving procedures. Proceedings of the third annual ACM symposium on Theory of computing, 1971.
  • L. A. Levin. Universal sequential search problems. Problems of Information Transmission, 9(3):265–266, 1973.

Session Cook_Levin

\ No newline at end of file diff --git a/web/entries/Crypto_Standards.html b/web/entries/Crypto_Standards.html --- a/web/entries/Crypto_Standards.html +++ b/web/entries/Crypto_Standards.html @@ -1,334 +1,337 @@ Cryptographic Standards - Archive of Formal Proofs

Cryptographic Standards

A Whitley 📧

June 6, 2023

Abstract

In this set of theories, we express well-known crytographic standards in the language of Isabelle.  The standards we have translated so far are:

 

   FIPS 180-4

NIST's Secure Hash Standard, rev 4.

   FIPS 186-4

Only the elliptic curves over prime fields, i.e. NIST's "P-" curves

   FIPS 198-1

NIST's The Keyed-Hash Message Authentication Code (HMAC Standard)

   PKCS #1 v2.2

RSA Laboratories' RSA Cryptography Standard, version 2.2

   SEC1 v2.0

SEC's Elliptic Curve Cryptography, version 2.0   

 

The intention is that these translations will be used to prove that any particular implementation matches the relevant standard.  With that in mind, the overriding principle is to adhere as closely as possible, given the syntax of HOL, to the written standard.  It should be obvious to any reader, regardless of their past experience with Isabelle, that these translations exactly match the  standards.  Thus we use the same function and variable names as in the written standards whenever possible and explain in the comments the few times when that is not possible. 

 

We want the users of these theories to have faith that errors were not made in the translations. We do two things to achieve this.  First, in addition to translating a standard, we provide a robust supporting theory that proves anything that one might wish to know about the primitives that the standard defines.  For example, we prove that encryption and decryption are inverse  operations.  We prove when RSA keys are equivalent.  We prove that if a message is signed, then that signature and message will pass the verification operation.  Any fact that you may need in using these standards, we hope and believe we have already proved for you. 

 

Second, we prove (by evaluation) that the test vectors provided by NIST, et al, check as intended (whether a passing or failing test case.)  The test vectors may be found in theories named *_Test_Vectors.thy.  These files can be large and take time for Isabelle to process.  Thus, they are not imported by this main Crypto_Standards theory.  Users may open those separately.  As an aside, Isabelle must be told how to compute certain operations efficiently.  For example, modular exponentiation or scalar multiplication of a point on an elliptic curve.  The Efficient*.thy files are necessary to check the test vectors. 

 

We attempt to be as agnostic to implementation details as possible.  For example, we do not  assume any particular data type has been used as input or output.  Many standards operate on octets, or 8-bit values.  For these theories, an octet string is modeled as a list of natural numbers.  Then a nat x is a "valid octet" exactly when x < 256.  Words.thy contains all the  operations needed to convert natural number to a string of n-bit values and back to a natural number.  There you will also find definitions for handling padding and bit manipulations that are found in the above standards.  Again, we believe that we have proved anything you may need to apply these theories.  We have erred on the side of including lemmas that may be of practical use as opposed to proving a minimal set of lemmas required. 

License

BSD License

Topics

Session Crypto_Standards

\ No newline at end of file diff --git a/web/entries/DCR-ExecutionEquivalence.html b/web/entries/DCR-ExecutionEquivalence.html --- a/web/entries/DCR-ExecutionEquivalence.html +++ b/web/entries/DCR-ExecutionEquivalence.html @@ -1,161 +1,164 @@ DCR Syntax and Execution Equivalent Markings - Archive of Formal Proofs

DCR Syntax and Execution Equivalent Markings

Axel Christfort 📧 and Sþren Debois

June 16, 2023

Abstract

We present an Isabelle formalization of the basics of Dynamic Condition Response (DCR) graphs before defining Execution Equivalent markings. We then prove that execution equivalent markings are perfectly interchangeable during process execution, yielding significant state-space reduction for execution-based model-checking of DCR graphs.

License

BSD License

Topics

Session DCR-ExecutionEquivalence

\ No newline at end of file diff --git a/web/entries/DigitsInBase.html b/web/entries/DigitsInBase.html --- a/web/entries/DigitsInBase.html +++ b/web/entries/DigitsInBase.html @@ -1,156 +1,159 @@ Positional Notation for Natural Numbers in an Arbitrary Base - Archive of Formal Proofs

Positional Notation for Natural Numbers in an Arbitrary Base

Charles Staats 📧

April 3, 2023

Abstract

We demonstrate the existence and uniqueness of the base-$n$ representation of a natural number, where $n$ is any natural number greater than 1. This comes up when trying to translate mathematical contest problems and solutions into Isabelle/HOL.

License

BSD License

Topics

Session DigitsInBase

\ No newline at end of file diff --git a/web/entries/Distributed_Distinct_Elements.html b/web/entries/Distributed_Distinct_Elements.html --- a/web/entries/Distributed_Distinct_Elements.html +++ b/web/entries/Distributed_Distinct_Elements.html @@ -1,167 +1,170 @@ Distributed Distinct Elements - Archive of Formal Proofs

Distributed Distinct Elements

Emin Karayel 📧

April 3, 2023

Abstract

This entry formalizes a randomized cardinality estimation data structure with asymptotically optimal space usage. It is inspired by the streaming algorithm presented by Błasiok in 2018. His work closed the gap between the best-known lower bound and upper bound after a long line of research started by Flajolet and Martin in 1984 and was to first to apply expander graphs (in addition to hash families) to the problem. The formalized algorithm has two improvements compared to the algorithm by Błasiok. It supports operation in parallel mode, and it relies on a simpler pseudo-random construction avoiding the use of code based extractors.

License

BSD License

Topics

Session Distributed_Distinct_Elements

\ No newline at end of file diff --git a/web/entries/Earley_Parser.html b/web/entries/Earley_Parser.html --- a/web/entries/Earley_Parser.html +++ b/web/entries/Earley_Parser.html @@ -1,171 +1,174 @@ Earley Parser - Archive of Formal Proofs

Earley Parser

Martin Rau 📧

July 16, 2023

Abstract

In 1968, Earley introduced his parsing algorithm, capable of parsing all context-free grammars in cubic space and time. This entry contains a formalization of an executable Earley parser. We base our development on Jones' extensive paper proof of Earley's recognizer and Obua's formalization of context-free grammars and derivations. We implement and prove correct a functional recognizer modeling Earley's original imperative implementation and extend it with the necessary data structures to enable the construction of parse trees, following the work of Scott. We then develop a functional algorithm that builds a single parse tree, and we prove its correctness. Finally, we generalize this approach to an algorithm for a complete parse forest and prove soundness.

License

BSD License

Topics

Session Earley_Parser

\ No newline at end of file diff --git a/web/entries/Edwards_Elliptic_Curves_Group.html b/web/entries/Edwards_Elliptic_Curves_Group.html --- a/web/entries/Edwards_Elliptic_Curves_Group.html +++ b/web/entries/Edwards_Elliptic_Curves_Group.html @@ -1,160 +1,163 @@ Group Law of Edwards Elliptic Curves - Archive of Formal Proofs

Group Law of Edwards Elliptic Curves

Rodrigo Raya 🌐

February 16, 2023

Abstract

This article gives an elementary computational proof of the group law for Edwards elliptic curves. The associative law is expressed as a polynomial identity over the integers that is directly checked by polynomial division. Unlike other proofs, no preliminaries such as intersection numbers, B́ezout’s theorem, projective geometry, divisors, or Riemann Roch are required.

License

BSD License

Topics

Related publications

Session Edwards_Elliptic_Curves_Group

\ No newline at end of file diff --git a/web/entries/Efficient_Weighted_Path_Order.html b/web/entries/Efficient_Weighted_Path_Order.html --- a/web/entries/Efficient_Weighted_Path_Order.html +++ b/web/entries/Efficient_Weighted_Path_Order.html @@ -1,195 +1,198 @@ A Verified Efficient Implementation of the Weighted Path Order - Archive of Formal Proofs

A Verified Efficient Implementation of the Weighted Path Order

RenĂ© Thiemann 🌐 and Elias Wenninger

June 1, 2023

Abstract

The Weighted Path Order (WPO) of Yamada is a powerful technique for proving termination. In a previous AFP entry, the WPO was defined and properties of WPO have been formally verified. However, the implementation of WPO was naive, leading to an exponential runtime in the worst case.

Therefore, in this AFP entry we provide a poly-time implementation of WPO. The implementation is based on memoization. Since WPO generalizes the recursive path order (RPO), we also easily derive an efficient implementation of RPO.

License

BSD License

Topics

Related publications

  • Thiemann, R., Schöpf, J., Sternagel, C., & Yamada, A. (2020). Certifying the Weighted Path Order (Invited Talk). Schloss Dagstuhl - Leibniz-Zentrum FĂŒr Informatik. https://doi.org/10.4230/LIPICS.FSCD.2020.4
  • Yamada, A., Kusakari, K., & Sakabe, T. (2015). A unified ordering for termination proving. Science of Computer Programming, 111, 110–134. https://doi.org/10.1016/j.scico.2014.07.009

Session Efficient_Weighted_Path_Order

\ No newline at end of file diff --git a/web/entries/Example-Submission.html b/web/entries/Example-Submission.html --- a/web/entries/Example-Submission.html +++ b/web/entries/Example-Submission.html @@ -1,242 +1,244 @@ Example Submission - Archive of Formal Proofs

Example Submission

Gerwin Klein 🌐

February 25, 2004

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.

License

BSD License

Topics

Session Example-Submission

\ No newline at end of file diff --git a/web/entries/Executable_Randomized_Algorithms.html b/web/entries/Executable_Randomized_Algorithms.html --- a/web/entries/Executable_Randomized_Algorithms.html +++ b/web/entries/Executable_Randomized_Algorithms.html @@ -1,180 +1,183 @@ Executable Randomized Algorithms - Archive of Formal Proofs

Executable Randomized Algorithms

Emin Karayel 📧 and Manuel Eberl 📧

June 19, 2023

Abstract

In Isabelle, randomized algorithms are usually represented using probability mass functions (PMFs), with which it is possible to verify their correctness, particularly properties about the distribution of their result. However, that approach does not provide a way to generate executable code for such algorithms. In this entry, we introduce a new monad for randomized algorithms, for which it is possible to generate code and simultaneously reason about the correctness of randomized algorithms. The latter works by a Scott-continuous monad morphism between the newly introduced random monad and PMFs. On the other hand, when supplied with an external source of random coin flips, the randomized algorithms can be executed.

License

BSD License

Topics

Session Executable_Randomized_Algorithms

\ No newline at end of file diff --git a/web/entries/Expander_Graphs.html b/web/entries/Expander_Graphs.html --- a/web/entries/Expander_Graphs.html +++ b/web/entries/Expander_Graphs.html @@ -1,180 +1,183 @@ Expander Graphs - Archive of Formal Proofs

Expander Graphs

Emin Karayel 📧

March 3, 2023

Abstract

Expander Graphs are low-degree graphs that are highly connected. They have diverse applications, for example in derandomization and pseudo-randomness, error-correcting codes, as well as pure mathematical subjects such as metric embeddings. This entry formalizes the concept and derives main theorems about them such as Cheeger's inequality or tail bounds on distribution of random walks on them. It includes a strongly explicit construction for every size and spectral gap. The latter is based on the Margulis-Gabber-Galil graphs and several graph operations that preserve spectral properties. The proofs are based on the survey papers/monographs by Hoory et al. and Vadhan, as well as results from Impagliazzo and Kabanets and Murtagh et al.

License

BSD License

Topics

Session Expander_Graphs

\ No newline at end of file diff --git a/web/entries/Fixed_Length_Vector.html b/web/entries/Fixed_Length_Vector.html --- a/web/entries/Fixed_Length_Vector.html +++ b/web/entries/Fixed_Length_Vector.html @@ -1,162 +1,165 @@ Fixed-length vectors - Archive of Formal Proofs

Fixed-Length Vectors

Lars Hupel 📧

August 14, 2023

Abstract

This theory introduces a type constructor for lists with known length, also known as "vectors". Those vectors are indexed with a numeral type that represent their length. This can be employed to avoid carrying around length constraints on lists. Instead, those constraints are discharged by the type checker. As compared to the vectors defined in the distribution, this definition can easily work with unit vectors. We exploit the fact that the cardinality of an infinite type is defined to be 0: thus any infinite length index type represents a unit vector. Furthermore, we set up automation and BNF support.

License

BSD License

Topics

Session Fixed_Length_Vector

\ No newline at end of file diff --git a/web/entries/Given_Clause_Loops.html b/web/entries/Given_Clause_Loops.html --- a/web/entries/Given_Clause_Loops.html +++ b/web/entries/Given_Clause_Loops.html @@ -1,180 +1,183 @@ Given Clause Loops - Archive of Formal Proofs

Given Clause Loops

Jasmin Christian Blanchette 📧, Qi Qiu 📧 and Sophie Tourret 📧

January 25, 2023

Abstract

This Isabelle/HOL formalization extends the Saturation_Framework and Saturation_Framework_Extensions entries of the Archive of Formal Proofs with the specification and verification of four semiabstract given clause procedures, or "loops": the DISCOUNT, Otter, iProver, and Zipperposition loops. For each loop, (dynamic) refutational completeness is proved under the assumption that the underlying calculus is (statically) refutationally complete and that the used queue data structures are fair. The formalization is inspired by the proof sketches found in the article "A comprehensive framework for saturation theorem proving" by Uwe Waldmann, Sophie Tourret, Simon Robillard, and Jasmin Blanchette (Journal of Automated Reasoning 66(4): 499-539, 2022). A paper titled "Verified given clause procedures" about the present formalization is in the works.

License

BSD License

Topics

Related publications

  • Waldmann, U., Tourret, S., Robillard, S., & Blanchette, J. (2022). A Comprehensive Framework for Saturation Theorem Proving. Journal of Automated Reasoning, 66(4), 499–539. https://doi.org/10.1007/s10817-022-09621-7

Session Given_Clause_Loops

\ No newline at end of file diff --git a/web/entries/Gray_Codes.html b/web/entries/Gray_Codes.html --- a/web/entries/Gray_Codes.html +++ b/web/entries/Gray_Codes.html @@ -1,163 +1,166 @@ Gray Codes for Arbitrary Numeral Systems - Archive of Formal Proofs

Gray Codes for Arbitrary Numeral Systems

Maximilian Spitz 📧

July 11, 2023

Abstract

The original Gray code after Frank Gray, also known as reflected binary code (RBC), is an ordering of the binary numeral system such that two successive values differ only in one bit. We provide a theory for a non-Boolean Gray code, which is a generalisation of the idea for an arbitrary base. Contained is the necessary theoretical environment to express and reason about the respective properties.

License

BSD License

Topics

Related publications

  • Sankar, K. J., Pandharipande, V. M., & Moharir, P. S. (n.d.). Generalized gray codes. Proceedings of 2004 International Symposium on Intelligent Signal Processing and Communication Systems, 2004. ISPACS 2004. https://doi.org/10.1109/ispacs.2004.1439140

Session Gray_Codes

\ No newline at end of file diff --git a/web/entries/HoareForDivergence.html b/web/entries/HoareForDivergence.html --- a/web/entries/HoareForDivergence.html +++ b/web/entries/HoareForDivergence.html @@ -1,177 +1,180 @@ A Hoare Logic for Diverging Programs - Archive of Formal Proofs

A Hoare Logic for Diverging Programs

Johannes Åman Pohjola 📧, Magnus O. Myreen 📧 and Miki Tanaka 📧

January 20, 2023

Abstract

This submission contains:
  1. a formalisation of a small While language with support for output;
  2. a standard total-correctness Hoare logic that has been proved sound and complete; and
  3. a new Hoare logic for proofs about programs that diverge: this new logic has also been proved sound and complete.

License

BSD License

Topics

Related publications

  • Åman Pohjola, J., Rostedt, H., & Myreen, M. O. (2019). Characteristic Formulae for Liveness Properties of Non-Terminating CakeML Programs. Schloss Dagstuhl - Leibniz-Zentrum Fuer Informatik GmbH, Wadern/Saarbruecken, Germany. https://doi.org/10.4230/LIPICS.ITP.2019.32

Session HoareForDivergence

Depends on

\ No newline at end of file diff --git a/web/entries/HyperHoareLogic.html b/web/entries/HyperHoareLogic.html --- a/web/entries/HyperHoareLogic.html +++ b/web/entries/HyperHoareLogic.html @@ -1,165 +1,168 @@ Formalization of Hyper Hoare Logic: A Logic to (Dis-)Prove Program Hyperproperties - Archive of Formal Proofs

Formalization of Hyper Hoare Logic: A Logic to (Dis-)Prove Program Hyperproperties

Thibault Dardinier 📧

April 3, 2023

Abstract

Hoare logics are proof systems that allow one to formally establish properties of computer programs. Traditional Hoare logics prove properties of individual program executions (so-called trace properties, such as functional correctness). On the one hand, Hoare logic has been generalized to prove properties of multiple executions of a program (so-called hyperproperties, such as determinism or non-interference). These program logics prove the absence of (bad combinations of) executions. On the other hand, program logics similar to Hoare logic have been proposed to disprove program properties (e.g., Incorrectness Logic [8]), by proving the existence of (bad combinations of) executions. All of these logics have in common that they specify program properties using assertions over a fixed number of states, for instance, a single pre- and post-state for functional properties or pairs of pre- and post-states for non-interference. In this entry, we formalize Hyper Hoare Logic, a generalization of Hoare logic that lifts assertions to properties of arbitrary sets of states. The resulting logic is simple yet expressive: its judgments can express arbitrary trace- and hyperproperties over the terminating executions of a program. By allowing assertions to reason about sets of states, Hyper Hoare Logic can reason about both the absence and the existence of (combinations of) executions, and, thereby, supports both proving and disproving program (hyper-)properties within the same logic. In fact, we prove that Hyper Hoare Logic subsumes the properties handled by numerous existing correctness and incorrectness logics, and can express hyperproperties that no existing Hoare logic can. We also prove that Hyper Hoare Logic is sound and complete.

License

BSD License

Topics

Related publications

  • Dardinier, T., & MĂŒller, P. (2023). Hyper Hoare Logic: (Dis-)Proving Program Hyperproperties (extended version) (Version 2). arXiv. https://doi.org/10.48550/ARXIV.2301.10037

Session HyperHoareLogic

\ No newline at end of file diff --git a/web/entries/IEEE_Floating_Point.html b/web/entries/IEEE_Floating_Point.html --- a/web/entries/IEEE_Floating_Point.html +++ b/web/entries/IEEE_Floating_Point.html @@ -1,211 +1,211 @@ A Formal Model of IEEE Floating Point Arithmetic - Archive of Formal Proofs

A Formal Model of IEEE Floating Point Arithmetic

-

Lei Yu 📧 +

Lei Yu 📧 with contributions from Fabian Hellauer 📧, Fabian Immler 🌐 and Tjark Weber 📧

July 27, 2013

Abstract

This development provides a formal model of IEEE-754 floating-point arithmetic. This formalization, including formal specification of the standard and proofs of important properties of floating-point arithmetic, forms the foundation for verifying programs with floating-point computation. There is also a code generation setup for floats so that we can execute programs using this formalization in functional programming languages.

License

BSD License

History

May 22, 2023
Added a model of floating-point arithmetic with a single NaN value.
Added a translation of floating-point arithmetic into SMT-LIB.
May 10, 2023
Added the IEEE rounding mode "roundNearestTiesToAway".
February 5, 2018
'Modernized' representation following the formalization in HOL4: former "float_format" and predicate "is_valid" is now encoded in a type "('e, 'f) float" where 'e and 'f encode the size of exponent and fraction.
September 25, 2017
Added conversions from and to software floating point numbers (by Fabian Hellauer and Fabian Immler).

Topics

Session IEEE_Floating_Point

\ No newline at end of file diff --git a/web/entries/Kneser_Cauchy_Davenport.html b/web/entries/Kneser_Cauchy_Davenport.html --- a/web/entries/Kneser_Cauchy_Davenport.html +++ b/web/entries/Kneser_Cauchy_Davenport.html @@ -1,170 +1,173 @@ Kneser's Theorem and the Cauchy–Davenport Theorem - Archive of Formal Proofs

Kneser's Theorem and the Cauchy–Davenport Theorem

Mantas Bakơys 📧 and Angeliki Koutsoukou-Argyraki 📧

November 21, 2022

Abstract

We formalise Kneser's Theorem in combinatorics following the proof from the 2014 paper A short proof of Kneser’s addition theorem for abelian groups by Matt DeVos. We also show a strict version of Kneser's Theorem as well as the Cauchy–Davenport Theorem as a corollary of Kneser's Theorem.

License

BSD License

Topics

Related publications

  • DeVos, M. (2014). A Short Proof of Kneser’s Addition Theorem for Abelian Groups. Combinatorial and Additive Number Theory, 39–41. https://doi.org/10.1007/978-1-4939-1601-6_3
  • Nathanson, Melvyn B, Additive Number Theory: Inverse Problems and the Geometry of Sumsets, Springer-Verlag, 1996, vol. 165, Graduate Texts in Mathematics, isbn 978-0-387-94655-9
  • Ruzsa, Imre Z., Sumsets and Structure, Course notes, 2008, available on https://www.math.cmu.edu/users/af1p/Teaching/AdditiveCombinatorics/Additive-Combinatorics.pdf

Session Kneser_Cauchy_Davenport

\ No newline at end of file diff --git a/web/entries/MHComputation.html b/web/entries/MHComputation.html --- a/web/entries/MHComputation.html +++ b/web/entries/MHComputation.html @@ -1,164 +1,167 @@ The Halting Problem is Soluble in Malament-Hogarth Spacetimes - Archive of Formal Proofs

The Halting Problem Is Soluble in Malament-Hogarth Spacetimes

Mike Stannett 📧

April 29, 2023

Abstract

We provide an Isabelle verification that the Halting Problem can be solved in Malament-Hogarth (MH) spacetimes. Our proof is quite general -- rather than assume the full machinery of general relativity, we only assume the existence of a reachability relation defined on an abstract space of locations. An MH spacetime can then be described as a space in which there exists an unboundedly long path together with a location which is reachable from all points on that path. Likewise, we use a very general notion of computation - the current state of a computation is assumed to be representable as a machine configuration containing all the information required to determine how the system changes with the execution of each ensuing instruction. The program is deemed to halt if the system enters a stable configuration. Since this situation is generally detectable by an operating system, we can use its occurrence to trigger events that exploit the nature of MH spacetimes, thereby enabling us to detect whether or not halting will eventually have occurred. Our verification follows existing arguments in the literature, albeit translated into this more general setting.

License

BSD License

Topics

Related publications

  • G. Etesi and I. NĂ©meti. Non-turing computations via Malament- Hogarth space-times. Int. J. Theor. Phys., 41:341–370, 2002.
  • M. Hogarth. Deciding arithmetic using SAD computers. British Journal for the Philosophy of Science, 55:681–691, 2004.
  • M. Stannett. Towards formal verification of computations and hypercomputations in relativistic physics. In J. Durand-Lose and B. Nagy, editors, Machines, Computations, and Universality 2015, 09-11 Sep 2015, Famagusta, North Cyprus, number 9288 in Lecture Notes in Computer Science. Springer Verlag, 2015.

Session MHComputation

\ No newline at end of file diff --git a/web/entries/MLSS_Decision_Proc.html b/web/entries/MLSS_Decision_Proc.html --- a/web/entries/MLSS_Decision_Proc.html +++ b/web/entries/MLSS_Decision_Proc.html @@ -1,196 +1,199 @@ MLSS Decision Procedure - Archive of Formal Proofs

MLSS Decision Procedure

Lukas Stevens 📧

May 5, 2023

Abstract

This formalization verifies a decision procedure due to Cantone and Zarba for a quantifier-free fragment of set theory. The fragment is called multi-level syllogistic with singleton, or MLSS for short. Its syntax syntax includes the usual set operations union, intersection, difference, membership, equality as well as the construction of a set containing a single element. We specify the semantics of MLSS in terms of hereditarily finite sets and provide a sound and complete tableau calculus for it. We also provide an executable specification of a decision procedure that applies the rules of the calculus exhaustively and prove its termination. Furthermore, we extend the calculus with a light-weight type system that paves the way for an integration of the procedure into Isabelle/HOL.

License

BSD License

Topics

Related publications

  • Stevens, L. (2022). Towards a Verified Tableau Prover for a Quantifier-Free Fragment of Set Theory (Version 2). arXiv. https://doi.org/10.48550/ARXIV.2209.14133

Session MLSS_Decision_Proc

\ No newline at end of file diff --git a/web/entries/Multirelations_Heterogeneous.html b/web/entries/Multirelations_Heterogeneous.html --- a/web/entries/Multirelations_Heterogeneous.html +++ b/web/entries/Multirelations_Heterogeneous.html @@ -1,167 +1,170 @@ Inner Structure, Determinism and Modal Algebra of Multirelations - Archive of Formal Proofs

Inner Structure, Determinism and Modal Algebra of Multirelations

Walter Guttmann 📧 and Georg Struth 📧

May 22, 2023

Abstract

Binary multirelations form a model of alternating nondeterminism useful for analysing games, interactions of computing systems with their environments or abstract interpretations of probabilistic programs. We investigate this alternating structure in a relational language based on power allegories extended with specific operations on multirelations. We develop algebras of modal operators over multirelations, related to concurrent dynamic logics, in this language.

License

BSD License

Topics

Related publications

  • Furusawa, H., Guttmann, W., & Struth, G. (2023). On the Inner Structure of Multirelations (Version 2). arXiv. https://doi.org/10.48550/ARXIV.2305.11342
  • Furusawa, H., Guttmann, W., & Struth, G. (2023). Determinism of Multirelations (Version 2). arXiv. https://doi.org/10.48550/ARXIV.2305.11344
  • Furusawa, H., Guttmann, W., & Struth, G. (2023). Modal Algebra of Multirelations (Version 2). arXiv. https://doi.org/10.48550/ARXIV.2305.11346

Session Multirelations_Heterogeneous

\ No newline at end of file diff --git a/web/entries/Multitape_To_Singletape_TM.html b/web/entries/Multitape_To_Singletape_TM.html --- a/web/entries/Multitape_To_Singletape_TM.html +++ b/web/entries/Multitape_To_Singletape_TM.html @@ -1,166 +1,169 @@ A Verified Translation of Multitape Turing Machines into Singletape Turing Machines - Archive of Formal Proofs

A Verified Translation of Multitape Turing Machines Into Singletape Turing Machines

Christian Dalvit and RenĂ© Thiemann 📧

November 30, 2022

Abstract

We define single- and multitape Turing machines (TMs) and verify a translation from multitape TMs to singletape TMs. In particular, the following results have been formalized: the accepted languages coincide, and whenever the multitape TM runs in $\mathcal{O}(f(n))$ time, then the singletape TM has a worst-time complexity of $\mathcal{O}(f(n)^2 + n)$. The translation is applicable both on deterministic and non-deterministic TMs.

License

BSD License

Topics

Session Multitape_To_Singletape_TM

\ No newline at end of file diff --git a/web/entries/No_FTL_observers_Gen_Rel.html b/web/entries/No_FTL_observers_Gen_Rel.html --- a/web/entries/No_FTL_observers_Gen_Rel.html +++ b/web/entries/No_FTL_observers_Gen_Rel.html @@ -1,193 +1,196 @@ No Faster-Than-Light Observers (GenRel) - Archive of Formal Proofs

No Faster-Than-Light Observers (GenRel)

Mike Stannett 📧, Edward Higgins, Hajnal Andreka 🌐, Judit Madarasz 🌐, IstvĂĄn NĂ©meti 🌐 and Gergely Szekely 🌐

March 5, 2023

Abstract

We have previously verified, in the first order theory SpecRel of Special Relativity, that inertial observers cannot travel faster than light. We now prove the corresponding result for GenRel, the first-order theory of General Relativity. Specifically, we prove that whenever an observer m encounters another observer k (so that m and k are both present at some spacetime location x), k will necessarily be observed by m to be traveling at less than light speed.

License

BSD License

Topics

Related publications

  • https://isa-afp.org/entries/No_FTL_observers.html

Session No_FTL_observers_Gen_Rel

\ No newline at end of file diff --git a/web/entries/PAPP_Impossibility.html b/web/entries/PAPP_Impossibility.html --- a/web/entries/PAPP_Impossibility.html +++ b/web/entries/PAPP_Impossibility.html @@ -1,188 +1,191 @@ The Incompatibility of Strategy-Proofness and Representation in Party-Approval Multi-Winner Elections - Archive of Formal Proofs

The Incompatibility of Strategy-Proofness and Representation in Party-Approval Multi-Winner Elections

ThĂ©o Delemazure 🌐, Tom Demeulemeester 🌐, Manuel Eberl 🌐, Jonas Israel 🌐 and Patrick Lederer 🌐

November 10, 2022

Abstract

In party-approval multi-winner elections, the goal is to allocate the seats of a fixed-size committee to parties based on approval ballots of the voters over the parties. In particular, each can approve multiple parties and each party can be assigned multiple seats.

Three central requirements in this settings are:

  • Anonymity: The result is invariant under renaming the voters.
  • Representation:Every sufficiently large group of voters with similar preferences is represented by some committee members.
  • Strategy-proofness: No voter can benefit by misreporting her true preferences.

We show that these three basic axioms are incompatible for party-approval multi-winner voting rules, thus proving a far-reaching impossibility theorem.

The proof of this result is obtained by formulating the problem in propositional logic and then letting a SAT solver show that the formula is unsatisfiable. The DRUP proof output by the SAT solver is then converted into Lammich's GRAT format and imported into Isabelle/HOL with some custom-written ML code.

This transformation is proof-producing, so the final Isabelle/HOL theorem does not rely on any oracles or other trusted external trusted components.

License

BSD License

Topics

Session PAPP_Impossibility

\ No newline at end of file diff --git a/web/entries/Polygonal_Number_Theorem.html b/web/entries/Polygonal_Number_Theorem.html --- a/web/entries/Polygonal_Number_Theorem.html +++ b/web/entries/Polygonal_Number_Theorem.html @@ -1,174 +1,177 @@ Polygonal Number Theorem - Archive of Formal Proofs

Polygonal Number Theorem

Kevin Lee 📧, Zhengkun Ye 📧 and Angeliki Koutsoukou-Argyraki 📧

August 10, 2023

Abstract

We formalize the proofs of Cauchy's and Legendre's Polygonal Number Theorems given in Melvyn B. Nathanson's book "Additive Number Theory: The Classical Bases".

For $m \geq 1$, the $k$-th polygonal number of order $m+2$ is defined to be $p_m(k)=\frac{mk(k-1)}{2}+k$. The theorems state that:

1. If $m \ge 4$ and $N \geq 108m$, then $N$ can be written as the sum of $m+1$ polygonal numbers of order $m+2$, at most four of which are different from $0$ or $1$. If $N \geq 324$, then $N$ can be written as the sum of five pentagonal numbers, at least one of which is $0$ or $1$.

2. Let $m \geq 3$ and $N \geq 28m^3$. If $m$ is odd, then $N$ is the sum of four polygonal numbers of order $m+2$. If $m$ is even, then $N$ is the sum of five polygonal numbers of order $m+2$, at least one of which is $0$ or $1$.

We also formalize the proof of Gauss's theorem which states that every non-negative integer is the sum of three triangular numbers.

License

BSD License

Topics

Related publications

Session Polygonal_Number_Theorem

\ No newline at end of file diff --git a/web/entries/Probability_Inequality_Completeness.html b/web/entries/Probability_Inequality_Completeness.html --- a/web/entries/Probability_Inequality_Completeness.html +++ b/web/entries/Probability_Inequality_Completeness.html @@ -1,167 +1,170 @@ A Sound and Complete Calculus for Probability Inequalities - Archive of Formal Proofs

A Sound and Complete Calculus for Probability Inequalities

Matthew Doty 📧

February 20, 2023

Abstract

We give a sound an complete multiple-conclusion calculus \(\$\vdash\) for finitely additive probability inequalities. In particular, we show $$\mathbf{\sim} \Gamma \$\vdash \mathbf{\sim} \Phi \equiv \forall \mathcal{P} \in probabilities. \sum \phi \leftarrow \Phi.\ \mathcal{P} \phi \leq \sum \gamma \leftarrow \Gamma.\ \mathcal{P} \gamma $$ ... where $\sim \Gamma$ is the negation of all of the formulae in $\Gamma$ (and similarly for $\sim\Phi$). We prove this by using an abstract form of MaxSAT. We also show $$MaxSAT (\mathbf{\sim} \Gamma\ @\ \Phi) + c\leq length\ \Gamma \equiv \forall \mathcal{P} \in probabilities. \left(\sum \phi \leftarrow \Phi.\ \mathcal{P} \phi\right) + c \leq \sum \gamma \leftarrow \Gamma.\ \mathcal{P} \gamma $$ Finally, we establish a collapse theorem, which asserts that $\left(\sum \phi \leftarrow \Phi.\ \mathcal{P} \phi\right) + c \leq \sum \gamma \leftarrow \Gamma.\ \mathcal{P} \gamma$ holds for all probabilities $\mathcal{P}$ if and only if $\left(\sum \phi \leftarrow \Phi.\ \delta \phi\right) + c \leq \sum \gamma \leftarrow \Gamma.\ \delta \gamma$ holds for all binary-valued probabilities $\delta$.

License

BSD License

Topics

Session Probability_Inequality_Completeness

\ No newline at end of file diff --git a/web/entries/Propositional_Logic_Class.html b/web/entries/Propositional_Logic_Class.html --- a/web/entries/Propositional_Logic_Class.html +++ b/web/entries/Propositional_Logic_Class.html @@ -1,179 +1,182 @@ Class-based Classical Propositional Logic - Archive of Formal Proofs

Class-Based Classical Propositional Logic

Matthew Doty 📧

December 15, 2022

Abstract

We formulate classical propositional logic as an axiom class. Our class represents a Hilbert-style proof system with the axioms \(\vdash \varphi \to \psi \to \varphi\), \(\vdash (\varphi \to \psi \to \chi) \to (\varphi \to \psi) \to \varphi \to \chi\), and \(\vdash ((\varphi \to \bot) \to \bot) \to \varphi\) along with the rule modus ponens \(\vdash \varphi \to \psi \Longrightarrow \; \vdash \varphi \Longrightarrow \; \vdash \psi\). In this axiom class we provide lemmas to obtain Maximally Consistent Sets via Zorn's lemma. We define the concrete classical propositional calculus inductively and show it instantiates our axiom class. We formulate the usual semantics for the propositional calculus and show strong soundness and completeness. We provide conventional definitions of the other logical connectives and prove various common identities. Finally, we show that the propositional calculus embeds into any logic in our axiom class.

License

BSD License

Topics

Session Propositional_Logic_Class

\ No newline at end of file diff --git a/web/entries/Quantales_Converse.html b/web/entries/Quantales_Converse.html --- a/web/entries/Quantales_Converse.html +++ b/web/entries/Quantales_Converse.html @@ -1,182 +1,185 @@ Modal quantales, involutive quantales, Dedekind Quantales - Archive of Formal Proofs

Modal Quantales, Involutive Quantales, Dedekind Quantales

Georg Struth 📧 and Cameron Calk

July 25, 2023

Abstract

This AFP entry provides mathematical components for modal quantales, involutive quantales and Dedekind quantales. Modal quantales are simple extensions of modal Kleene algebras useful for the verification of recursive programs. Involutive quantales appear in the study of C*-algebras. Dedekind quantales are relatives of Tarski's relation algebras, hence relevant to program verification and beyond that to higher rewriting. We also provide components for weaker variants such as Kleene algebras with converse and modal Kleene algebras with converse.

License

BSD License

Topics

Related publications

  • Fahrenberg, U., Johansen, C., Struth, G., & ZiemiaƄski, K. (2023). Catoids and modal convolution algebras. Algebra Universalis, 84(2). https://doi.org/10.1007/s00012-023-00805-9
  • Calk, C., Malbos, P., Pous, D., & Struth, G. (2023). Higher Catoids, Higher Quantales and their Correspondences (Version 1). arXiv. https://doi.org/10.48550/ARXIV.2307.09253

Session Quantales_Converse

\ No newline at end of file diff --git a/web/entries/Quantifier_Elimination_Hybrid.html b/web/entries/Quantifier_Elimination_Hybrid.html --- a/web/entries/Quantifier_Elimination_Hybrid.html +++ b/web/entries/Quantifier_Elimination_Hybrid.html @@ -1,188 +1,193 @@ A First Complete Algorithm for Real Quantifier Elimination in Isabelle/HOL - Archive of Formal Proofs

A First Complete Algorithm for Real Quantifier Elimination in Isabelle/HOL

Katherine Kosaian 📧, Yong Kiam Tan 📧 and AndrĂ© Platzer 📧

December 15, 2022

Abstract

We formalize a multivariate quantifier elimination (QE) algorithm in the theorem prover Isabelle/HOL. Our algorithm is complete, in that it is able to reduce any quantified formula in the first-order logic of real arithmetic to a logically equivalent quantifier-free formula. The algorithm we formalize is a hybrid mixture of Tarski's original QE algorithm and the Ben-Or, Kozen, and Reif algorithm, and it is the first complete multivariate QE algorithm formalized in Isabelle/HOL.

License

BSD License

Topics

Related publications

  • Kosaian, K., Tan, Y. K., & Platzer, A. (2023). A First Complete Algorithm for Real Quantifier Elimination in Isabelle/HOL. Proceedings of the 12th ACM SIGPLAN International Conference on Certified Programs and Proofs. https://doi.org/10.1145/3573105.3575672

Session Quantifier_Elimination_Hybrid

\ No newline at end of file diff --git a/web/entries/Rensets.html b/web/entries/Rensets.html --- a/web/entries/Rensets.html +++ b/web/entries/Rensets.html @@ -1,172 +1,175 @@ Renaming-Enriched Sets (Rensets) and Renaming-Based Recursion - Archive of Formal Proofs

Renaming-Enriched Sets (Rensets) and Renaming-Based Recursion

Andrei Popescu 📧

February 28, 2023

Abstract

I formalize the notion of renaming-enriched sets (rensets for short) and renaming-based recursion introduced in my IJCAR 2022 paper “Rensets and Renaming-Based Recursion for Syntax with Bindings”. Rensets are an algebraic axiomatization of renaming (variable-for-variable substitution). The formalization includes a connection with nominal sets, showing that any renset naturally gives rise to a nominal set. It also includes examples of deploying the renaming-based recursor: semantic interpretation, counting functions for free and bound occurrences, unary and parallel substitution, etc. Finally, it includes a variation of rensets that axiomatize term-for-variable substitution, called substitutive sets, which yields a corresponding recursion principle.

License

BSD License

Topics

Related publications

Session Rensets

\ No newline at end of file diff --git a/web/entries/Sauer_Shelah_Lemma.html b/web/entries/Sauer_Shelah_Lemma.html --- a/web/entries/Sauer_Shelah_Lemma.html +++ b/web/entries/Sauer_Shelah_Lemma.html @@ -1,159 +1,162 @@ Sauer-Shelah Lemma - Archive of Formal Proofs

Sauer-Shelah Lemma

Ata Keskin 📧

November 24, 2022

Abstract

The Sauer-Shelah Lemma is a fundamental result in extremal set theory and combinatorics. It guarantees the existence of a set $T$ of size $k$ that is shattered by a family of sets $\mathcal{F}$ if the cardinality of the family is greater than some bound dependent on $k$. A set $T$ is said to be shattered by a family $\mathcal{F}$ if every subset of $T$ can be obtained as an intersection of $T$ with some set $S \in \mathcal{F}$. The Sauer-Shelah Lemma has found use in diverse fields such as computational geometry, approximation algorithms and machine learning. In this entry we formalize the notion of shattering and prove the generalized and standard versions of the Sauer-Shelah Lemma.

License

BSD License

Topics

Session Sauer_Shelah_Lemma

\ No newline at end of file diff --git a/web/entries/Schwartz_Zippel.html b/web/entries/Schwartz_Zippel.html --- a/web/entries/Schwartz_Zippel.html +++ b/web/entries/Schwartz_Zippel.html @@ -1,160 +1,163 @@ The Schwartz-Zippel Lemma - Archive of Formal Proofs

The Schwartz-Zippel Lemma

Sunpill Kim and Yong Kiam Tan 📧

April 27, 2023

Abstract

This short entry formalizes a version of the Schwartz-Zippel lemma for probabilistic (multivariate) polynomial identity testing. The entry includes a textbook example using the lemma to test for perfect matchings in a bipartite graph. The lemma is attributed to several independent authors, including Schwartz, Zippel, and DeMillo and Lipton; a historical perspective is given by Lipton.

License

BSD License

Topics

Session Schwartz_Zippel

\ No newline at end of file diff --git a/web/entries/Simple_Clause_Learning.html b/web/entries/Simple_Clause_Learning.html --- a/web/entries/Simple_Clause_Learning.html +++ b/web/entries/Simple_Clause_Learning.html @@ -1,170 +1,173 @@ A Formalization of the SCL(FOL) Calculus: Simple Clause Learning for First-Order Logic - Archive of Formal Proofs

A Formalization of the SCL(FOL) Calculus: Simple Clause Learning for First-Order Logic

Martin Desharnais 📧

April 20, 2023

Abstract

This Isabelle/HOL formalization covers the unexecutable specification of Simple Clause Learning for first-order logic without equality: SCL(FOL). The main results are formal proofs of soundness, non-redundancy of learned clauses, termination, and refutational completeness. Compared to the unformalized version, the formalized calculus is simpler, a number of results were generalized, and the non-redundancy statement was strengthened. We found and corrected one bug in a previously published version of the SCL Backtrack rule. Compared to related formalizations, we introduce a new technique for showing termination based on non-redundant clause learning.

License

BSD License

Topics

Session Simple_Clause_Learning

\ No newline at end of file diff --git a/web/entries/StrictOmegaCategories.html b/web/entries/StrictOmegaCategories.html --- a/web/entries/StrictOmegaCategories.html +++ b/web/entries/StrictOmegaCategories.html @@ -1,162 +1,165 @@ Strict Omega Categories - Archive of Formal Proofs

Strict Omega Categories

Anthony Bordg 📧 and AdriĂĄn Doña Mateo 📧

January 14, 2023

Abstract

This theory formalises a definition of strict $\omega$-categories and the strict $\omega$-category of pasting diagrams. It is the first step towards a formalisation of weak infinity categories Ă  la Batanin–Leinster.

License

BSD License

Topics

Related publications

  • Leinster, T. (2004). Higher Operads, Higher Categories. https://doi.org/10.1017/cbo9780511525896

Session StrictOmegaCategories

\ No newline at end of file diff --git a/web/entries/Sturm_Tarski.html b/web/entries/Sturm_Tarski.html --- a/web/entries/Sturm_Tarski.html +++ b/web/entries/Sturm_Tarski.html @@ -1,193 +1,195 @@ The Sturm–Tarski Theorem - Archive of Formal Proofs

The Sturm–Tarski Theorem

Wenda Li 🌐

September 19, 2014

Abstract

We have formalized the Sturm–Tarski theorem (also referred as the Tarski theorem), which generalizes Sturm's theorem. Sturm's theorem is usually used as a way to count distinct real roots, while the Sturm-Tarksi theorem forms the basis for Tarski's classic quantifier elimination for real closed field.

License

BSD License

History

November 9, 2022
Added theory file Tarski_Query_Impl to the entry proof session.

Topics

Session Sturm_Tarski

\ No newline at end of file diff --git a/web/entries/Suppes_Theorem.html b/web/entries/Suppes_Theorem.html --- a/web/entries/Suppes_Theorem.html +++ b/web/entries/Suppes_Theorem.html @@ -1,181 +1,184 @@ Suppes' Theorem For Probability Logic - Archive of Formal Proofs

Suppes' Theorem for Probability Logic

Matthew Doty 📧

January 22, 2023

Abstract

We develop finitely additive probability logic and prove a theorem of Patrick Suppes that asserts that $\Psi \vdash \phi$ in classical propositional logic if and only if $(\sum \psi \leftarrow \Psi.\; 1 - \mathcal{P} \psi) \geq 1 - \mathcal{P} \phi$ holds for all probabilities $\mathcal{P}$. We also provide a novel dual form of Suppes' Theorem, which holds that $(\sum \phi \leftarrow \Phi.\; \mathcal{P} \phi) \leq \mathcal{P} \psi$ for all probabilities $\mathcal{P}$ if and only $\left(\bigvee \Phi\right) \vdash \psi$ and all of the formulae in $\Phi$ are logically exclusive from one another. Our proofs use Maximally Consistent Sets, and as a consequence, we obtain two collapse theorems. In particular, we show $(\sum \phi \leftarrow \Phi.\; \mathcal{P} \phi) \geq \mathcal{P} \psi$ holds for all probabilities $\mathcal{P}$ if and only if $(\sum \phi \leftarrow \Phi.\; \delta\; \phi) \geq \delta\; \psi$ holds for all binary-valued probabilities $\delta$, along with the dual assertion that $(\sum \phi \leftarrow \Phi. \;\mathcal{P} \phi) \leq \mathcal{P} \psi$ holds for all probabilities $\mathcal{P}$ if and only if $(\sum \phi \leftarrow \Phi.\; \delta\; \phi) \leq \delta\; \psi$ holds for all binary-valued probabilities $\delta$.

License

BSD License

Topics

Related publications

  • Suppes, P. (1966). Probabilistic Inference and the Concept of Total Evidence. Studies in Logic and the Foundations of Mathematics, 49–65. https://doi.org/10.1016/s0049-237x(08)71662-8

Session Suppes_Theorem

\ No newline at end of file diff --git a/web/entries/Synthetic_Completeness.html b/web/entries/Synthetic_Completeness.html --- a/web/entries/Synthetic_Completeness.html +++ b/web/entries/Synthetic_Completeness.html @@ -1,191 +1,194 @@ Synthetic Completeness - Archive of Formal Proofs

Synthetic Completeness

Asta Halkjér From 📧

January 9, 2023

Abstract

In this work, I provide an abstract framework for proving the completeness of a logical calculus using the synthetic method. The synthetic method is based on maximal consistent saturated sets (MCSs). A set of formulas is consistent (with respect to the calculus) when we cannot derive a contradiction from it. It is maximally consistent when it contains every formula that is consistent with it. For logics where it is relevant, it is saturated when it contains a witness for every existential formula. To prove completeness using these maximal consistent saturated sets, we prove a truth lemma: every formula in an MCS has a satisfying model. Here, Hintikka sets provide a useful stepping stone. These can be seen as characterizations of the MCSs based on simple subformula conditions rather than via the calculus. We then prove that every Hintikka set gives rise to a satisfying model and that MCSs are Hintikka sets. Now, assume a valid formula cannot be derived. Then its negation must be consistent and therefore satisfiable. This contradicts validity and the original formula must be derivable.

To start, I build maximal consistent saturated sets for any logic that satisfies a small set of assumptions. I do this using a transfinite version of Lindenbaum's lemma, which allows me to support languages of any cardinality. I then prove useful abstract results about derivations and refutations as they relate to MCSs. Finally, I show how Hintikka sets can be derived from the logic's semantics, outlining one way to prove the required truth lemma.

To demonstrate the versatility of the framework, I instantiate it with five different examples. The formalization contains soundness and completeness results for: a propositional tableau calculus, a propositional sequent calculus, an axiomatic system for modal logic, a labelled natural deduction system for hybrid logic and a natural deduction system for first-order logic. The tableau example uses custom Hintikka sets based on the calculus, but the other four examples derive them from the semantics in the style of the framework. The hybrid and first-order logic examples rely on saturated MCSs. This places requirements on the cardinalities of their languages to ensure that there are enough witnesses available. In both cases, the type of witnesses must be infinite and have cardinality at least that of the type of propositional/predicate symbols.

License

BSD License

Topics

Session Synthetic_Completeness

\ No newline at end of file diff --git a/web/entries/Three_Squares.html b/web/entries/Three_Squares.html --- a/web/entries/Three_Squares.html +++ b/web/entries/Three_Squares.html @@ -1,207 +1,210 @@ Three Squares Theorem - Archive of Formal Proofs

Three Squares Theorem

Anton Danilkin and LoĂŻc Chevalier

May 3, 2023

Abstract

We formalize the Legendre's three squares theorem and its consequences, in particular the following results:
  1. A natural number can be represented as the sum of three squares of natural numbers if and only if it is not of the form $4^a (8 k + 7)$, where $a$ and $k$ are natural numbers.
  2. If $n$ is a natural number such that $n \equiv 3 \pmod{8}$, then $n$ can be be represented as the sum of three squares of odd natural numbers.
Consequences include the following:
  1. An integer $n$ can be written as $n = x^2 + y^2 + z^2 + z$, where $x$, $y$, $z$ are integers, if and only if $n \geq 0$.
  2. The Legendre's four squares theorem: any natural number can be represented as the sum of four squares of natural numbers.

License

BSD License

Topics

Session Three_Squares

\ No newline at end of file diff --git a/web/entries/Tree_Enumeration.html b/web/entries/Tree_Enumeration.html --- a/web/entries/Tree_Enumeration.html +++ b/web/entries/Tree_Enumeration.html @@ -1,170 +1,173 @@ Tree Enumeration - Archive of Formal Proofs

Tree Enumeration

Nils Cremer 📧

May 9, 2023

Abstract

This thesis presents the verification of enumeration algorithms for trees. The first algorithm is based on the well known PrĂŒfer-correspondence and allows the enumeration of all possible labeled trees over a fixed finite set of vertices. The second algorithm enumerates rooted, unlabeled trees of a specified size up to graph isomorphism. It allows for the efficient enumeration without the use of an intermediate encoding of the trees with level sequences, unlike the algorithm by Beyer and Hedetniemi it is based on. Both algorithms are formalized and verified in Isabelle/HOL. The formalization of trees and other graph theoretic results is also presented.

License

BSD License

Topics

Related publications

Session Tree_Enumeration

\ No newline at end of file diff --git a/web/entries/TsirelsonBound.html b/web/entries/TsirelsonBound.html --- a/web/entries/TsirelsonBound.html +++ b/web/entries/TsirelsonBound.html @@ -1,170 +1,173 @@ The CHSH inequality: Tsirelson's upper-bound and other results - Archive of Formal Proofs

The CHSH Inequality: Tsirelson's Upper-Bound and Other Results

Mnacho Echenim 📧, Mehdi Mhalla 📧 and Coraline Mori 📧

April 18, 2023

Abstract

The CHSH inequality, named after Clauser, Horne, Shimony and Holt, was used by Alain Aspect to prove experimentally that Einstein's hypothesis stating that quantum mechanics could be defined using local hidden variables was incorrect. The CHSH inequality is based on a setting in which an experiment consisting of two separate parties performing joint measurements is run several times, and a score is derived from these runs. If the local hidden variable hypothesis had been correct, this score would have been bounded by $2$, but a suitable choice of observables in a quantum setting permits to violate this inequality when measuring the Bell state; this is the result that Aspect obtained experimentally. Tsirelson answered the question of how large this violation could be by proving that in the quantum setting, the highest score that can be obtained when running this experiment is $2\sqrt{2}$. Along with elementary results on density matrices which represent quantum states in the finite dimensional setting, we formalize Tsirelson's result and summarize the main results on the CHSH score:
  1. Under the local hidden variable hypothesis, this score admits 2 as an upper-bound.
  2. When the density matrix under consideration is separable, the upper-bound cannot be violated.
  3. When one of the parties in the experiment performs measures using commuting observables, this upper-bound remains valid.
  4. Otherwise, the upper-bound of this score is $2\sqrt{2}$, regardless of the observables that are used and the quantum state that is measured, and
  5. This upper-bound is reached for a suitable choice of observables when measuring the Bell state.

License

BSD License

Topics

Session TsirelsonBound

\ No newline at end of file diff --git a/web/entries/Turans_Graph_Theorem.html b/web/entries/Turans_Graph_Theorem.html --- a/web/entries/Turans_Graph_Theorem.html +++ b/web/entries/Turans_Graph_Theorem.html @@ -1,180 +1,183 @@ TurĂĄn's Graph Theorem - Archive of Formal Proofs

TurĂĄn's Graph Theorem

Nils Lauermann 📧

November 14, 2022

Abstract

TurĂĄn's Graph Theorem states that any undirected, simple graph with $n$ vertices that does not contain a $p$-clique, contains at most $\left( 1 - \frac{1}{p-1} \right) \frac{n^2}{2}$ edges. The theorem is an important result in graph theory and the foundation of the field of extremal graph theory. The formalisation follows Aigner and Ziegler's presentation in Proofs from THE BOOK of TurĂĄn's initial proof. Besides a direct adaptation of the textbook proof, a simplified, second proof is presented which decreases the size of the formalised proof significantly.

License

BSD License

Topics

Related publications

Session Turans_Graph_Theorem

\ No newline at end of file diff --git a/web/entries/Two_Generated_Word_Monoids_Intersection.html b/web/entries/Two_Generated_Word_Monoids_Intersection.html --- a/web/entries/Two_Generated_Word_Monoids_Intersection.html +++ b/web/entries/Two_Generated_Word_Monoids_Intersection.html @@ -1,174 +1,177 @@ Intersection of two monoids generated by two element codes - Archive of Formal Proofs

Intersection of Two Monoids Generated by Two Element Codes

Ơtěpán Holub 📧 and Ơtěpán Starosta 📧

January 3, 2023

Abstract

This article provides a formalization of the classification of intersection \( \{x,y\}^* \cap \{u,v\}^*\) of two monoids generated by two element codes. Namely, the intersection has one of the following forms \( \{\beta,\gamma\}^* \quad \text{ or } \quad \left(\beta_0 + \beta(\gamma(1+\delta+ \cdots + \delta^t))^*\epsilon\right)^*.\) Note that it can be infinitely generated. The result is due to [KarhumÀki, 84]. Our proof uses the terminology of morphisms which allows us to formulate the result in a shorter and more transparent way.

License

BSD License

History

August 17, 2023
Updated to version v1.10.1.

Topics

Related publications

  • KarhumĂ€ki, J. (n.d.). A note on intersections of free submonoids of a free monoid. Lecture Notes in Computer Science, 397–407. https://doi.org/10.1007/bfb0036924
  • Development repository

Session Two_Generated_Word_Monoids_Intersection

\ No newline at end of file diff --git a/web/entries/Zeckendorf.html b/web/entries/Zeckendorf.html --- a/web/entries/Zeckendorf.html +++ b/web/entries/Zeckendorf.html @@ -1,160 +1,163 @@ Zeckendorf’s Theorem - Archive of Formal Proofs

Zeckendorf’s Theorem

Christian Dalvit 📧

June 12, 2023

Abstract

This work formalizes Zeckendorf's theorem. The theorem states that every positive integer can be uniquely represented as a sum of one or more non-consecutive Fibonacci numbers. More precisely, if $N$ is a positive integer, there exist unique positive integers $c_i \ge 2$ with $c_{i+1} > c_i + 1$, such that \[ N = \sum_{i=0}^k F_{c_i} \] where $F_n$ is the $n$-th Fibonacci number.

License

BSD License

Topics

Session Zeckendorf

\ No newline at end of file