27 research outputs found
UTP2: Higher-Order Equational Reasoning by Pointing
We describe a prototype theorem prover, UTP2, developed to match the style of
hand-written proof work in the Unifying Theories of Programming semantical
framework. This is based on alphabetised predicates in a 2nd-order logic, with
a strong emphasis on equational reasoning. We present here an overview of the
user-interface of this prover, which was developed from the outset using a
point-and-click approach. We contrast this with the command-line paradigm that
continues to dominate the mainstream theorem provers, and raises the question:
can we have the best of both worlds?Comment: In Proceedings UITP 2014, arXiv:1410.785
Automatic and Transparent Transfer of Theorems along Isomorphisms in the Coq Proof Assistant
In mathematics, it is common practice to have several constructions for the
same objects. Mathematicians will identify them modulo isomorphism and will not
worry later on which construction they use, as theorems proved for one
construction will be valid for all.
When working with proof assistants, it is also common to see several
data-types representing the same objects. This work aims at making the use of
several isomorphic constructions as simple and as transparent as it can be done
informally in mathematics. This requires inferring automatically the missing
proof-steps.
We are designing an algorithm which finds and fills these missing proof-steps
and we are implementing it as a plugin for Coq
Smart matching
One of the most annoying aspects in the formalization of mathematics is the
need of transforming notions to match a given, existing result. This kind of
transformations, often based on a conspicuous background knowledge in the given
scientific domain (mostly expressed in the form of equalities or isomorphisms),
are usually implicit in the mathematical discourse, and it would be highly
desirable to obtain a similar behavior in interactive provers. The paper
describes the superposition-based implementation of this feature inside the
Matita interactive theorem prover, focusing in particular on the so called
smart application tactic, supporting smart matching between a goal and a given
result.Comment: To appear in The 9th International Conference on Mathematical
Knowledge Management: MKM 201
Superposition as a logical glue
The typical mathematical language systematically exploits notational and
logical abuses whose resolution requires not just the knowledge of domain
specific notation and conventions, but not trivial skills in the given
mathematical discipline. A large part of this background knowledge is expressed
in form of equalities and isomorphisms, allowing mathematicians to freely move
between different incarnations of the same entity without even mentioning the
transformation. Providing ITP-systems with similar capabilities seems to be a
major way to improve their intelligence, and to ease the communication between
the user and the machine. The present paper discusses our experience of
integration of a superposition calculus within the Matita interactive prover,
providing in particular a very flexible, "smart" application tactic, and a
simple, innovative approach to automation.Comment: In Proceedings TYPES 2009, arXiv:1103.311
Type classes for efficient exact real arithmetic in Coq
Floating point operations are fast, but require continuous effort on the part
of the user in order to ensure that the results are correct. This burden can be
shifted away from the user by providing a library of exact analysis in which
the computer handles the error estimates. Previously, we [Krebbers/Spitters
2011] provided a fast implementation of the exact real numbers in the Coq proof
assistant. Our implementation improved on an earlier implementation by O'Connor
by using type classes to describe an abstract specification of the underlying
dense set from which the real numbers are built. In particular, we used dyadic
rationals built from Coq's machine integers to obtain a 100 times speed up of
the basic operations already. This article is a substantially expanded version
of [Krebbers/Spitters 2011] in which the implementation is extended in the
various ways. First, we implement and verify the sine and cosine function.
Secondly, we create an additional implementation of the dense set based on
Coq's fast rational numbers. Thirdly, we extend the hierarchy to capture order
on undecidable structures, while it was limited to decidable structures before.
This hierarchy, based on type classes, allows us to share theory on the
naturals, integers, rationals, dyadics, and reals in a convenient way. Finally,
we obtain another dramatic speed-up by avoiding evaluation of termination
proofs at runtime.Comment: arXiv admin note: text overlap with arXiv:1105.275
Moessner's theorem: An exercise in coinductive reasoning in COQ
Moessner's Theorem describes a construction of the sequence of powers (1n, 2n, 3n,…), by repeatedly dropping and summing elements from the sequence of positive natural numbers. The theorem was presented by Moessner in 1951 without a proof and later proved and generalized in several directions. More recently, a coinductive proof of the original theorem was given by Niqui and Rutten. We present a formalization of their proof in the Coq proof assistant. This formalization serves as a non-trivial illustration of the use of coinduction in Coq. During the formalization, we discovered that Long and Salié's generalizations could also be proved using (almost) the same bisimulation
Coq's Prolog and application to defining semi-automatic tactics
International audienceWe report on a work-in-progress to re-implement Coq's apply tactic in order to embed some form of simple automation. We design it in a declarative way, relying on typeclasses eauto, a tactic which gives access to the proof-search mechanism behind type classes. We qualify this mechanism of " Coq's Prolog " and describe it in a generic way and explain how it can be used to support the construction of automatic and semi-automatic tactics
Extensional equality preservation and verified generic programming
In verified generic programming, one cannot exploit the structure of concrete
data types but has to rely on well chosen sets of specifications or abstract
data types (ADTs). Functors and monads are at the core of many applications of
functional programming. This raises the question of what useful ADTs for
verified functors and monads could look like. The functorial map of many
important monads preserves extensional equality. For instance, if are extensionally equal, that is, , then and are also
extensionally equal. This suggests that preservation of extensional equality
could be a useful principle in verified generic programming. We explore this
possibility with a minimalist approach: we deal with (the lack of) extensional
equality in Martin-L\"of's intensional type theories without extending the
theories or using full-fledged setoids. Perhaps surprisingly, this minimal
approach turns out to be extremely useful. It allows one to derive simple
generic proofs of monadic laws but also verified, generic results in dynamical
systems and control theory. In turn, these results avoid tedious code
duplication and ad-hoc proofs. Thus, our work is a contribution towards
pragmatic, verified generic programming.Comment: Manuscript ID: JFP-2020-003
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