8 research outputs found
System Description: an Interface Between CLAM and HOL
. The CLaM proof planner has been interfaced to the HOL interactive theorem prover to provide the power of proof planning to people using HOL for formal verification, etc. The interface sends HOL goals to CLaM for planning and translates plans back into HOL tactics that solve the initial goals. The project homepage can be found at http://www.cl.cam.ac.uk/Research/HVG/Clam.HOL/intro.html. 1 Introduction CLaM [2] is a proof planning system for Oyster, a tactic-based implementation of the constructive type theory of Martin-Lof. CLaM works by using formalized pre- and post-conditions of Oyster tactics as the basis of plan search. These specifications of tactics are called methods. When a plan for a goal is found, the expectation is that the resulting tactic will solve the goal. Experience shows that the search space for plans is often tractable: CLaM has been able to automatically plan many proofs. A particular emphasis of research with CLaM has been the automation of inductive proo..
System Description: an Interface Between CLAM and HOL
The CLAM proof planner has been interfaced to the HOL interactive theorem prover to provide the power of proof planning to people using HOL for formal verification, etc. The interface sends HOL goals to CLAM for planning and translates plans back into HOL tactics that solve the initial goals. The project homepage can be found at http://www.cl.cam.ac.uk/Research/HVG/Clam.HOL/intro.html
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
Hammering towards QED
This paper surveys the emerging methods to automate reasoning over large libraries developed with formal proof assistants. We call these methods hammers. They give the authors of formal proofs a strong āone-strokeā tool for discharging difficult lemmas without the need for careful and detailed manual programming of proof search. The main ingredients underlying this approach are efficient automatic theorem provers that can cope with hundreds of axioms, suitable translations of the proof assistantās logic to the logic of the automatic provers, heuristic and learning methods that select relevant facts from large libraries, and methods that reconstruct the automatically found proofs inside the proof assistants. We outline the history of these methods, explain the main issues and techniques, and show their strength on several large benchmarks. We also discuss the relation of this technology to the QED Manifesto and consider its implications for QED-like efforts.Blanchetteās Sledgehammer research was supported by the Deutsche Forschungs-
gemeinschaft projects Quis Custodiet (grants NI 491/11-1 and NI 491/11-2) and
Hardening the Hammer (grant NI 491/14-1). Kaliszyk is supported by the Austrian
Science Fund (FWF) grant P26201. Sledgehammer was originally supported by the
UKās Engineering and Physical Sciences Research Council (grant GR/S57198/01).
Urbanās work was supported by the Marie-Curie Outgoing International Fellowship
project AUTOKNOMATH (grant MOIF-CT-2005-21875) and by the Netherlands
Organisation for Scientific Research (NWO) project Knowledge-based Automated
Reasoning (grant 612.001.208).This is the final published version. It first appeared at http://jfr.unibo.it/article/view/4593/5730?acceptCookies=1
Supporting formal reasoning about functional programs
It is often claimed that functional programming languages, and in particular pure functional
languages are suitable for formal reasoning. This claim is supported by the fact
that many people in the functional programming community do reason about languages
and programs in a formal or semi-formal way. Different reasoning principles such as
equational reasoning, induction and co-induction, are used, depending on the nature of
the problem.
Using a computer program to check the application of rules and to mechanise the
tedious bookkeeping involved can simplify proofs and provide more confidence in their
correctness. When reasoning about programs, this can also allow experiments with
new rules and reasoning styles, where a user may not be confident about structuring a
proof on paper. Checking the applicability of a rule can eliminate the risk of mistakes
caused by misunderstanding the theory being used. Just as there are different ways in
which formal or informal reasoning can be applied in functional programming, there are
different ways in which tools can be provided to support this reasoning.
This thesis describes an investigation of how to develop a mechanised reasoning
system to allow reasoning about algorithms as a functional programmer would write
them, not an encoding of the algorithm into a significantly different form. In addition,
this work aims to develop a system to support a user who is not a theorem proving
expert or an expert in the theoretical foundations of functional programming. The work is aimed towards a system that could be used by a functional programmer developing
real programs and wishing to prove some or all of the programs correct or to prove that
two programs are equivalent
A Proof Planning Framework For Isabelle
Centre for Intelligent Systems and their ApplicationsProof planning is a paradigm for the automation of proof that focuses on encoding intelligence
to guide the proof process. The idea is to capture common patterns of reasoning which can be
used to derive abstract descriptions of proofs known as proof plans. These can then be executed
to provide fully formal proofs.
This thesis concerns the development and analysis of a novel approach to proof planning
that focuses on an explicit representation of choices during search. We embody our approach
as a proof planner for the generic proof assistant Isabelle and use the Isar language, which is
human-readable and machine-checkable, to represent proof plans. Within this framework we
develop an inductive theorem prover as a case study of our approach to proof planning.
Our prover uses the difference reduction heuristic known as rippling to automate the step
cases of the inductive proofs. The development of a flexible approach to rippling that supports
its various modifications and extensions is the second major focus of this thesis. Here, our
inductive theorem prover provides a context in which to evaluate rippling experimentally.
This work results in an efficient and powerful inductive theorem prover for Isabelle as well
as proposals for further improving the efficiency of rippling. We also draw observations in order
to direct further work on proof planning. Overall, we aim to make it easier for mathematical
techniques, and those specific to mechanical theorem proving, to be encoded and applied to
problems
Supporting dependently typed functional programming with proof automation and testing
Dependent types can be used to capture useful properties about programs at compile time. However, developing dependently typed programs can be difficult in current
systems. Capturing interesting program properties usually requires the user to write
proofs, where constructing the latter can be both a difficult and tedious process. Additionally, finding and fixing errors in program scripts can be challenging.
This thesis concerns ways in which functional programming with dependent types
can be made easier. In particular, we focus on providing help for developing programs
that incorporate user-defined types and user-defined functions. For the purpose of supporting dependently typed programming, we have designed a framework that provides
improved proof automation and error feedback.
Proof automation is provided with the use of heuristic based tactics that automate
common patterns of proofs that arise when programming with dependent types. In
particular, we use heuristics for generalising goals and employ the rippling heuristic
for guiding inductive and non-inductive proofs. The automation we describe includes
features for caching and reusing lemmas proven during proof search and, whenever
proof search fails, the user can assist the prover by providing high-level hints.
We concentrate on providing improved feedback for the errors that occur when
there is a mismatch between the specification of a program, described with the use of
dependent types, and the behaviour of the program. We employ a QuickCheck-like
testing tool for automatically identifying these forms of errors, where the counter examples generated are used as error messages.
To demonstrate the effectiveness of our framework for supporting dependently
typed programming, we have developed a prototype based around the Coq theorem
prover. We demonstrate that the framework as a whole makes program development
easier by conducting a series of case studies. In these case studies, which involved
verifying properties of tail recursive functions, sorting functions and a binary adder, a
significant number of the proofs required were automated