11 research outputs found
The Marriage of Univalence and Parametricity
International audienceReasoning modulo equivalences is natural for everyone, including mathematicians. Unfortunately, in proof assistants based on type theory, which are frequently used to mechanize mathematical results and carry out program verification efforts, equality is appallingly syntactic and, as a result, exploiting equivalences is cumbersome at best. Parametricity and univalence are two major concepts that have been explored in the literature to transport programs and proofs across type equivalences, but they fall short of achieving seamless, automatic transport. This work first clarifies the limitations of these two concepts when considered in isolation, and then devises a fruitful marriage between both. The resulting concept, called univalent parametricity, is an extension of parametricity strengthened with univalence that fully realizes programming and proving modulo equivalences. Our approach handles both type and term dependency, as well as type-level computation. In addition to the theory of univalent parametricity, we present a lightweight framework implemented in the Coq proof assistant that allows the user to transparently transfer definitions and theorems for a type to an equivalent one, as if they were equal. For instance, this makes it possible to conveniently switch between an easy-to-reason-about representation and a computationally-efficient representation, as soon as they are proven equivalent. The combination of parametricity and univalence supports transport Ă la carte: basic univalent transport, which stems from a type equivalence, can be complemented with additional proofs of equivalences between functions over these types, in order to be able to transport more programs and proofs, as well as to yield more efficient terms. We illustrate the use of univalent parametricity on several examples, including a recent integration of native integers in Coq. This work paves the way to easier-to-use proof assistants by supporting seamless programming and proving modulo equivalences
Trocq: Proof Transfer for Free, With or Without Univalence
Libraries of formalized mathematics use a possibly broad range of different
representations for a same mathematical concept. Yet light to major manual
input from users remains most often required for obtaining the corresponding
variants of theorems, when such obvious replacements are typically left
implicit on paper. This article presents Trocq, a new proof transfer framework
for dependent type theory. Trocq is based on a novel formulation of type
equivalence, used to generalize the univalent parametricity translation. This
framework takes care of avoiding dependency on the axiom of univalence when
possible, and may be used with more relations than just equivalences. We have
implemented a corresponding plugin for the Coq proof assistant, in the CoqElpi
meta-language. We use this plugin on a gallery of representative examples of
proof transfer issues in interactive theorem proving, and illustrate how Trocq
covers the spectrum of several existing tools, used in program verification as
well as in formalized mathematics in the broad sense
Strict Rezk completions of models of HoTT and homotopy canonicity
We give a new constructive proof of homotopy canonicity for homotopy type
theory (HoTT). Canonicity proofs typically involve gluing constructions over
the syntax of type theory. We instead use a gluing construction over a "strict
Rezk completion" of the syntax of HoTT. The strict Rezk completion is specified
and constructed in the topos of cartesian cubical sets. It completes a model of
HoTT to an equivalent model satisfying a saturation condition, providing an
equivalence between terms of identity types and cubical paths between terms.
This generalizes the ordinary Rezk completion of a 1-category
Transport via Partial Galois Connections and Equivalences
Multiple types can represent the same concept. For example, lists and trees
can both represent sets. Unfortunately, this easily leads to incomplete
libraries: some set-operations may only be available on lists, others only on
trees. Similarly, subtypes and quotients are commonly used to construct new
type abstractions in formal verification. In such cases, one often wishes to
reuse operations on the representation type for the new type abstraction, but
to no avail: the types are not the same.
To address these problems, we present a new framework that transports
programs via equivalences. Existing transport frameworks are either designed
for dependently typed, constructive proof assistants, use univalence, or are
restricted to partial quotient types. Our framework (1) is designed for simple
type theory, (2) generalises previous approaches working on partial quotient
types, and (3) is based on standard mathematical concepts, particularly Galois
connections and equivalences. We introduce the notion of partial Galois
connections and equivalences and prove their closure properties under
(dependent) function relators, (co)datatypes, and compositions. We formalised
the framework in Isabelle/HOL and provide a prototype.
This is the extended version of "Transport via Partial Galois Connections and
Equivalences", 21st Asian Symposium on Programming Languages and Systems, 2023.Comment: 18 pages; will appear at 21st Asian Symposium on Programming
Languages and Systems, 202
Modular pre-processing for automated reasoning in dependent type theory
The power of modern automated theorem provers can be put at the service of
interactive theorem proving. But this requires in particular bridging the
expressivity gap between the logics these provers are respectively based on.
This paper presents the implementation of a modular suite of pre-processing
transformations, which incrementally bring certain formulas expressed in the
Calculus of Inductive Constructions closer to the first-order logic of
Satifiability Modulo Theory solvers. These transformations address issues
related to the axiomatization of inductive types, to polymorphic definitions or
to the different implementations of a same theory signature. This suite is
implemented as a plugin for the Coq proof assistant, and integrated to the
SMTCoq toolchain
Functional Extensionality for Refinement Types
Refinement type checkers are a powerful way to reason about functional
programs. For example, one can prove properties of a slow, specification
implementation, porting the proofs to an optimized implementation that behaves
the same. Without functional extensionality, proofs must relate functions that
are fully applied. When data itself has a higher-order representation, fully
applied proofs face serious impediments! When working with first-order data,
fully applied proofs lead to noisome duplication when using higher-order
functions.
While dependent type theories are typically consistent with functional
extensionality axioms, refinement type systems with semantic subtyping treat
naive phrasings of functional extensionality inconsistently, leading to
unsoundness. We demonstrate this unsoundness and develop a new approach to
equality in Liquid Haskell: we define a propositional equality in a library we
call PEq. Using PEq avoids the unsoundness while still proving useful
equalities at higher types; we demonstrate its use in several case studies. We
validate PEq by building a small model and developing its metatheory.
Additionally, we prove metaproperties of PEq inside Liquid Haskell itself using
an unnamed folklore technique, which we dub `classy induction'
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 22nd International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2019, which took place in Prague, Czech Republic, in April 2019, held as part of the European Joint Conference on Theory and Practice of Software, ETAPS 2019. The 29 papers presented in this volume were carefully reviewed and selected from 85 submissions. They deal with foundational research with a clear significance for software science