106 research outputs found
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
A Bi-Directional Refinement Algorithm for the Calculus of (Co)Inductive Constructions
The paper describes the refinement algorithm for the Calculus of
(Co)Inductive Constructions (CIC) implemented in the interactive theorem prover
Matita. The refinement algorithm is in charge of giving a meaning to the terms,
types and proof terms directly written by the user or generated by using
tactics, decision procedures or general automation. The terms are written in an
"external syntax" meant to be user friendly that allows omission of
information, untyped binders and a certain liberal use of user defined
sub-typing. The refiner modifies the terms to obtain related well typed terms
in the internal syntax understood by the kernel of the ITP. In particular, it
acts as a type inference algorithm when all the binders are untyped. The
proposed algorithm is bi-directional: given a term in external syntax and a
type expected for the term, it propagates as much typing information as
possible towards the leaves of the term. Traditional mono-directional
algorithms, instead, proceed in a bottom-up way by inferring the type of a
sub-term and comparing (unifying) it with the type expected by its context only
at the end. We propose some novel bi-directional rules for CIC that are
particularly effective. Among the benefits of bi-directionality we have better
error message reporting and better inference of dependent types. Moreover,
thanks to bi-directionality, the coercion system for sub-typing is more
effective and type inference generates simpler unification problems that are
more likely to be solved by the inherently incomplete higher order unification
algorithms implemented. Finally we introduce in the external syntax the notion
of vector of placeholders that enables to omit at once an arbitrary number of
arguments. Vectors of placeholders allow a trivial implementation of implicit
arguments and greatly simplify the implementation of primitive and simple
tactics
Recommended from our members
Programming and proving with classical types
The propositions-as-types correspondence is ordinarily presen-
ted as linking the metatheory of typed λ-calculi and the proof theory
of intuitionistic logic. Griffin observed that this correspondence could
be extended to classical logic through the use of control operators. This
observation set off a flurry of further research, leading to the development
of Parigot’s λμ-calculus. In this work, we use the λμ-calculus as the
foundation for a system of proof terms for classical first-order logic. In
particular, we define an extended call-by-value λμ-calculus with a type
system in correspondence with full classical logic. We extend the language
with polymorphic types, add a host of data types in ‘direct style’, and
prove several metatheoretical properties. All of our proofs and definitions
are mechanised in Isabelle/HOL, and we automatically obtain an inter-
preter for a system of proof terms cum programming language—called
μML—using Isabelle’s code generation mechanism. Atop our proof terms,
we build a prototype LCF-style interactive theorem prover—called μTP—
for classical first-order logic, capable of synthesising μML programs from
completed tactic-driven proofs. We present example closed μML programs
with classical tautologies for types, including some inexpressible as closed
programs in the original λμ-calculus, and some example tactic-driven
μTP proofs of classical tautologies
User-friendly Support for Common Concepts in a Lightweight Verifier
Machine verification of formal arguments can only increase our confidence in the correctness of those arguments, but the costs of employing machine verification still outweigh the benefits for some common kinds of formal reasoning activities. As a result, usability is becoming increasingly important in the design of formal verification tools. We describe the "aartifact" lightweight verification system, designed for processing formal arguments involving basic, ubiquitous mathematical concepts. The system is a prototype for investigating potential techniques for improving the usability of formal verification systems. It leverages techniques drawn both from existing work and from our own efforts. In addition to a parser for a familiar concrete syntax and a mechanism for automated syntax lookup, the system integrates (1) a basic logical inference algorithm, (2) a database of propositions governing common mathematical concepts, and (3) a data structure that computes congruence closures of expressions involving relations found in this database. Together, these components allow the system to better accommodate the expectations of users interested in verifying formal arguments involving algebraic and logical manipulations of numbers, sets, vectors, and related operators and predicates. We demonstrate the reasonable performance of this system on typical formal arguments and briefly discuss how the system's design contributed to its usability in two case studies
A Web Interface for Matita
This article describes a prototype implementation of a web interface for the
Matita proof assistant. The interface supports all basic functionalities of the
local Gtk interface, but takes advantage of the markup to enrich the document
with several kinds of annotations or active elements. Annotations may have both
a presentational/hypertextual nature, aimed to improve the quality of the proof
script as a human readable document, or a more semantic nature, aimed to help
the system in its processing of the script. The latter kind comprises
information automatically generated by the proof assistant during previous
compilations, and stored to improve the performance of re-executing expensive
operations like disambiguation or automation
A Synthesis of the Procedural and Declarative Styles of Interactive Theorem Proving
We propose a synthesis of the two proof styles of interactive theorem
proving: the procedural style (where proofs are scripts of commands, like in
Coq) and the declarative style (where proofs are texts in a controlled natural
language, like in Isabelle/Isar). Our approach combines the advantages of the
declarative style - the possibility to write formal proofs like normal
mathematical text - and the procedural style - strong automation and help with
shaping the proofs, including determining the statements of intermediate steps.
Our approach is new, and differs significantly from the ways in which the
procedural and declarative proof styles have been combined before in the
Isabelle, Ssreflect and Matita systems. Our approach is generic and can be
implemented on top of any procedural interactive theorem prover, regardless of
its architecture and logical foundations. To show the viability of our proposed
approach, we fully implemented it as a proof interface called miz3, on top of
the HOL Light interactive theorem prover. The declarative language that this
interface uses is a slight variant of the language of the Mizar system, and can
be used for any interactive theorem prover regardless of its logical
foundations. The miz3 interface allows easy access to the full set of tactics
and formal libraries of HOL Light, and as such has "industrial strength". Our
approach gives a way to automatically convert any procedural proof to a
declarative counterpart, where the converted proof is similar in size to the
original. As all declarative systems have essentially the same proof language,
this gives a straightforward way to port proofs between interactive theorem
provers
Dedukti: a Logical Framework based on the -Calculus Modulo Theory
Dedukti is a Logical Framework based on the -Calculus Modulo
Theory. We show that many theories can be expressed in Dedukti: constructive
and classical predicate logic, Simple type theory, programming languages, Pure
type systems, the Calculus of inductive constructions with universes, etc. and
that permits to used it to check large libraries of proofs developed in other
proof systems: Zenon, iProver, FoCaLiZe, HOL Light, and Matita
A Certified Study of a Reversible Programming Language
We advance in the study of the semantics of Janus, a C-like reversible programming language. Our study makes utterly explicit some backward and forward evaluation symmetries. We want to deepen mathematical knowledge about the foundations and design principles of reversible computing and programming languages. We formalize a big-step operational semantics and a denotational semantics of Janus. We show a full abstraction result between the operational and denotational semantics. Last, we certify our results by means of the proof assistant Matita
- …