478 research outputs found
A Vernacular for Coherent Logic
We propose a simple, yet expressive proof representation from which proofs
for different proof assistants can easily be generated. The representation uses
only a few inference rules and is based on a frag- ment of first-order logic
called coherent logic. Coherent logic has been recognized by a number of
researchers as a suitable logic for many ev- eryday mathematical developments.
The proposed proof representation is accompanied by a corresponding XML format
and by a suite of XSL transformations for generating formal proofs for
Isabelle/Isar and Coq, as well as proofs expressed in a natural language form
(formatted in LATEX or in HTML). Also, our automated theorem prover for
coherent logic exports proofs in the proposed XML format. All tools are
publicly available, along with a set of sample theorems.Comment: CICM 2014 - Conferences on Intelligent Computer Mathematics (2014
A Graphical Language for Proof Strategies
Complex automated proof strategies are often difficult to extract, visualise,
modify, and debug. Traditional tactic languages, often based on stack-based
goal propagation, make it easy to write proofs that obscure the flow of goals
between tactics and are fragile to minor changes in input, proof structure or
changes to tactics themselves. Here, we address this by introducing a graphical
language called PSGraph for writing proof strategies. Strategies are
constructed visually by "wiring together" collections of tactics and evaluated
by propagating goal nodes through the diagram via graph rewriting. Tactic nodes
can have many output wires, and use a filtering procedure based on goal-types
(predicates describing the features of a goal) to decide where best to send
newly-generated sub-goals.
In addition to making the flow of goal information explicit, the graphical
language can fulfil the role of many tacticals using visual idioms like
branching, merging, and feedback loops. We argue that this language enables
development of more robust proof strategies and provide several examples, along
with a prototype implementation in Isabelle
Learning-Assisted Automated Reasoning with Flyspeck
The considerable mathematical knowledge encoded by the Flyspeck project is
combined with external automated theorem provers (ATPs) and machine-learning
premise selection methods trained on the proofs, producing an AI system capable
of answering a wide range of mathematical queries automatically. The
performance of this architecture is evaluated in a bootstrapping scenario
emulating the development of Flyspeck from axioms to the last theorem, each
time using only the previous theorems and proofs. It is shown that 39% of the
14185 theorems could be proved in a push-button mode (without any high-level
advice and user interaction) in 30 seconds of real time on a fourteen-CPU
workstation. The necessary work involves: (i) an implementation of sound
translations of the HOL Light logic to ATP formalisms: untyped first-order,
polymorphic typed first-order, and typed higher-order, (ii) export of the
dependency information from HOL Light and ATP proofs for the machine learners,
and (iii) choice of suitable representations and methods for learning from
previous proofs, and their integration as advisors with HOL Light. This work is
described and discussed here, and an initial analysis of the body of proofs
that were found fully automatically is provided
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
Capturing Hiproofs in HOL Light
Hierarchical proof trees (hiproofs for short) add structure to ordinary proof
trees, by allowing portions of trees to be hierarchically nested. The
additional structure can be used to abstract away from details, or to label
particular portions to explain their purpose. In this paper we present two
complementary methods for capturing hiproofs in HOL Light, along with a tool to
produce web-based visualisations. The first method uses tactic recording, by
modifying tactics to record their arguments and construct a hierarchical tree;
this allows a tactic proof script to be modified. The second method uses proof
recording, which extends the HOL Light kernel to record hierachical proof trees
alongside theorems. This method is less invasive, but requires care to manage
the size of the recorded objects. We have implemented both methods, resulting
in two systems: Tactician and HipCam
Object-Level Reasoning with Logics Encoded in HOL Light
We present a generic framework that facilitates object level reasoning with
logics that are encoded within the Higher Order Logic theorem proving
environment of HOL Light. This involves proving statements in any logic using
intuitive forward and backward chaining in a sequent calculus style. It is made
possible by automated machinery that take care of the necessary structural
reasoning and term matching automatically. Our framework can also handle type
theoretic correspondences of proofs, effectively allowing the type checking and
construction of computational processes via proof. We demonstrate our
implementation using a simple propositional logic and its Curry-Howard
correspondence to the lambda-calculus, and argue its use with linear logic and
its various correspondences to session types.Comment: In Proceedings LFMTP 2020, arXiv:2101.0283
Improving legibility of natural deduction proofs is not trivial
In formal proof checking environments such as Mizar it is not merely the
validity of mathematical formulas that is evaluated in the process of adoption
to the body of accepted formalizations, but also the readability of the proofs
that witness validity. As in case of computer programs, such proof scripts may
sometimes be more and sometimes be less readable. To better understand the
notion of readability of formal proofs, and to assess and improve their
readability, we propose in this paper a method of improving proof readability
based on Behaghel's First Law of sentence structure. Our method maximizes the
number of local references to the directly preceding statement in a proof
linearisation. It is shown that our optimization method is NP-complete.Comment: 33 page
Workshop on Verification and Theorem Proving for Continuous Systems (NetCA Workshop 2005)
Oxford, UK, 26 August 200
- …