255 research outputs found
Formalizing Mathematical Knowledge as a Biform Theory Graph: A Case Study
A biform theory is a combination of an axiomatic theory and an algorithmic
theory that supports the integration of reasoning and computation. These are
ideal for formalizing algorithms that manipulate mathematical expressions. A
theory graph is a network of theories connected by meaning-preserving theory
morphisms that map the formulas of one theory to the formulas of another
theory. Theory graphs are in turn well suited for formalizing mathematical
knowledge at the most convenient level of abstraction using the most convenient
vocabulary. We are interested in the problem of whether a body of mathematical
knowledge can be effectively formalized as a theory graph of biform theories.
As a test case, we look at the graph of theories encoding natural number
arithmetic. We used two different formalisms to do this, which we describe and
compare. The first is realized in , a version of Church's
type theory with quotation and evaluation, and the second is realized in Agda,
a dependently typed programming language.Comment: 43 pages; published without appendices in: H. Geuvers et al., eds,
Intelligent Computer Mathematics (CICM 2017), Lecture Notes in Computer
Science, Vol. 10383, pp. 9-24, Springer, 201
Two-Level Type Theory and Applications
We define and develop two-level type theory (2LTT), a version of Martin-L\"of
type theory which combines two different type theories. We refer to them as the
inner and the outer type theory. In our case of interest, the inner theory is
homotopy type theory (HoTT) which may include univalent universes and higher
inductive types. The outer theory is a traditional form of type theory
validating uniqueness of identity proofs (UIP). One point of view on it is as
internalised meta-theory of the inner type theory.
There are two motivations for 2LTT. Firstly, there are certain results about
HoTT which are of meta-theoretic nature, such as the statement that
semisimplicial types up to level can be constructed in HoTT for any
externally fixed natural number . Such results cannot be expressed in HoTT
itself, but they can be formalised and proved in 2LTT, where will be a
variable in the outer theory. This point of view is inspired by observations
about conservativity of presheaf models.
Secondly, 2LTT is a framework which is suitable for formulating additional
axioms that one might want to add to HoTT. This idea is heavily inspired by
Voevodsky's Homotopy Type System (HTS), which constitutes one specific instance
of a 2LTT. HTS has an axiom ensuring that the type of natural numbers behaves
like the external natural numbers, which allows the construction of a universe
of semisimplicial types. In 2LTT, this axiom can be stated simply be asking the
inner and outer natural numbers to be isomorphic.
After defining 2LTT, we set up a collection of tools with the goal of making
2LTT a convenient language for future developments. As a first such
application, we develop the theory of Reedy fibrant diagrams in the style of
Shulman. Continuing this line of thought, we suggest a definition of
(infinity,1)-category and give some examples.Comment: 53 page
Frex: dependently-typed algebraic simplification
We present an extensible, mathematically-structured algebraic simplification
library design. We structure the library using universal algebraic concepts: a
free algebra -- fral -- and a free extension -- frex -- of an algebra by a set
of variables. The library's dependently-typed API guarantees simplification
modules, even user-defined ones, are terminating, sound, and complete with
respect to a well-specified class of equations. Completeness offers intangible
benefits in practice -- our main contribution is the novel design. Cleanly
separating between the interface and implementation of simplification modules
provides two new modularity axes. First, simplification modules share thousands
of lines of infrastructure code dealing with term-representation,
pretty-printing, certification, and macros/reflection. Second, new
simplification modules can reuse existing ones. We demonstrate this design by
developing simplification modules for monoid varieties: ordinary, commutative,
and involutive. We implemented this design in the new Idris2 dependently-typed
programming language, and in Agda
Extending Nunchaku to Dependent Type Theory
Nunchaku is a new higher-order counterexample generator based on a sequence
of transformations from polymorphic higher-order logic to first-order logic.
Unlike its predecessor Nitpick for Isabelle, it is designed as a stand-alone
tool, with frontends for various proof assistants. In this short paper, we
present some ideas to extend Nunchaku with partial support for dependent types
and type classes, to make frontends for Coq and other systems based on
dependent type theory more useful.Comment: In Proceedings HaTT 2016, arXiv:1606.0542
Gradual Certified Programming in Coq
Expressive static typing disciplines are a powerful way to achieve
high-quality software. However, the adoption cost of such techniques should not
be under-estimated. Just like gradual typing allows for a smooth transition
from dynamically-typed to statically-typed programs, it seems desirable to
support a gradual path to certified programming. We explore gradual certified
programming in Coq, providing the possibility to postpone the proofs of
selected properties, and to check "at runtime" whether the properties actually
hold. Casts can be integrated with the implicit coercion mechanism of Coq to
support implicit cast insertion a la gradual typing. Additionally, when
extracting Coq functions to mainstream languages, our encoding of casts
supports lifting assumed properties into runtime checks. Much to our surprise,
it is not necessary to extend Coq in any way to support gradual certified
programming. A simple mix of type classes and axioms makes it possible to bring
gradual certified programming to Coq in a straightforward manner.Comment: DLS'15 final version, Proceedings of the ACM Dynamic Languages
Symposium (DLS 2015
Code Generation for Higher Inductive Types
Higher inductive types are inductive types that include nontrivial
higher-dimensional structure, represented as identifications that are not
reflexivity. While work proceeds on type theories with a computational
interpretation of univalence and higher inductive types, it is convenient to
encode these structures in more traditional type theories with mature
implementations. However, these encodings involve a great deal of error-prone
additional syntax. We present a library that uses Agda's metaprogramming
facilities to automate this process, allowing higher inductive types to be
specified with minimal additional syntax.Comment: 16 pages, Accepted for presentation in WFLP 201
Elaborator reflection : extending Idris in Idris
Many programming languages and proof assistants are defined by elaboration from a high-level language with a great deal of implicit information to a highly explicit core language. In many advanced languages, these elaboration facilities contain powerful tools for program construction, but these tools are rarely designed to be repurposed by users. We describe elaborator reflection, a paradigm for metaprogramming in which the elaboration machinery is made directly available to metaprograms, as well as a concrete realization of elaborator reflection in Idris, a functional language with full dependent types. We demonstrate the applicability of Idris’s reflected elaboration framework to a number of realistic problems, we discuss the motivation for the specific features of its design, and we explore the broader meaning of elaborator reflection as it can relate to other languages.Postprin
- …