Extensible and Efficient Automation Through Reflective Tactics

Malecha, Gregory; Bengtson, Jesper

doi:10.1007/978-3-662-49498-1_21

Cited by 14 publications

(21 citation statements)

References 33 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…A simple backtracking solver for equalities in commutative monoids was used in Malecha and Bengtson [2016] to compare the performance of Ltac and Rtac. For comparison, we implemented this solver in Lean as well.…”

Section: Experimental Evaluationmentioning

confidence: 99%

“…Backtracking solver for commutative monoids. Malecha and Bengtson [2016] on the same benchmark set. In practice, we expect users to use the built-in simplifier or the SMT state to solve this kind of problem instead, so we also compared the performance of those two tactics.…”

Section: Experimental Evaluationmentioning

confidence: 99%

“…Runtime on the monoid cancellation benchmark. Ltac and Rtac are the implementations presented in Malecha and Bengtson [2016]. Lean refers to the same solver implemented in Lean as described above.…”

Section: Experimental Evaluationmentioning

confidence: 99%

See 2 more Smart Citations

A metaprogramming framework for formal verification

Ebner

Ullrich²,

Roesch

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

We describe the metaprogramming framework currently used in Lean, an interactive theorem prover based on dependent type theory. This framework extends Lean's object language with an API to some of Lean's internal structures and procedures, and provides ways of reflecting object-level expressions into the metalanguage. We provide evidence to show that our implementation is performant, and that it provides a convenient and flexible way of writing not only small-scale interactive tactics, but also more substantial kinds of automation.bridge the gap between interactive use and automation. Lean implements a version of the Calculus of Inductive Constructions [Coquand and Huet 1988;Coquand and Paulin 1990], the details of which are described in Section 3. Its elaborator and unification algorithms are designed around the use of type classes, which support algebraic reasoning, programming abstractions, and other generally useful means of expression. Lean also has parallel compilation and checking of proofs, and provides a server mode that supports a continuous compilation and rich user interaction in editing environments such as Emacs and Visual Studio Code. It currently has a conditional term rewriter and several components commonly found in state-of-the-art Satisfiability Modulo Theories (SMT) solvers, such as forward chaining, congruence closure [Nelson and Oppen 1980], handling of associative and commutative operators, and E-matching [Detlefs et al. 2005].In Lean, definitions are compiled to bytecode that can then be evaluated in an efficient virtual machine. This is one sense in which Lean can be viewed as a programming language. (Native compilation is under development.) We obtain a metaprogramming language by exposing an API for procedures implemented natively in Lean's underlying C++ code base, thus taking us outside the axiomatic framework. Within a Lean source file, the keyword meta marks a clear distinction between definitions that make use of such extensions and those that are in the pure object language. Metadefinitions can also call themselves recursively, relaxing the termination restriction imposed by ordinary type theory. Otherwise, definitions and metadefinitions look very much the same, and can be written side-by-side in a Lean source file.There are a number of advantages to this approach. One is that users do not have to learn a new programming language to write metaprograms; they can work with the same constructs and notation used to define ordinary objects in the theorem prover's library. Another advantage is that everything in that library is available for metaprogramming purposes, including integers, lists, datatype constructors, records, and algebraic structures. Finally, metaprograms can be written and debugged in the same interactive environment, making it possible to develop the object library and supporting automation at the same time.A key application for metaprogramming is to implement tactics, which is to say, procedures which facilitate interactive theorem proving by carrying out straightf...

show abstract

Section: Experimental Evaluationmentioning

confidence: 99%

Section: Experimental Evaluationmentioning

confidence: 99%

See 1 more Smart Citation

A metaprogramming framework for formal verification

Ebner

Ullrich²,

Roesch

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Our experience has been that even Coq's tactic system slows down considerably when automating all of these details, and we foresee using proof by reflection in either Coq (e.g. Rtac [20]) or Agda to automate these proofs in a way that maintains proof-checker performance.…”

Section: Monadic Abstract Interpretationmentioning

confidence: 99%

Constructive Galois connections: taming the Galois connection framework for mechanized metatheory

Darais

Horn

2016

Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming

View full text Add to dashboard Cite

Galois connections are a foundational tool for structuring abstraction in semantics and their use lies at the heart of the theory of abstract interpretation. Yet, mechanization of Galois connections remains limited to restricted modes of use, preventing their general application in mechanized metatheory and certified programming.This paper presents constructive Galois connections, a variant of Galois connections that is effective both on paper and in proof assistants; is complete with respect to a large subset of classical Galois connections; and enables more general reasoning principles, including the "calculational" style advocated by Cousot.To design constructive Galois connection we identify a restricted mode of use of classical ones which is both general and amenable to mechanization in dependently-typed functional programming languages. Crucial to our metatheory is the addition of monadic structure to Galois connections to control a "specification effect". Effectful calculations may reason classically, while pure calculations have extractable computational content. Explicitly moving between the worlds of specification and implementation is enabled by our metatheory.To validate our approach, we provide two case studies in mechanizing existing proofs from the literature: one uses calculational abstract interpretation to design a static analyzer, the other forms a semantic basis for gradual typing. Both mechanized proofs closely follow their original paper-and-pencil counterparts, employ reasoning principles not captured by previous mechanization approaches, support the extraction of verified algorithms, and are novel. Abstracting IntegersWe design a simple sign abstraction for integers, although more powerful abstractions are certainly possible [24]. The final abstract interpreter for WHILE is parameterized by any abstraction for integers, meaning another abstraction can be plugged in without added proof effort.The sign abstraction begins with three representative elements: neg, zer and pos, representing negative integers, the integer 0, and positive integers. To support representing integers which could be negative or 0, negative or positive, or 0 or positive, etc. we design a set which is complete w.r.t these logical disjunctions:i ♯ ∈ Z ♯ := {none, neg, zer, pos, negz, nzer, posz, any} Z ♯ is given meaning through an interpretation function µ z , the analog of a γ from the classical Galois connection framework: µ z : Z ♯ → ℘(Z) µ z (none) := {} µ z (negz) := {i | i ≤ 0} µ z (neg) := {i | i < 0} µ z (nzer) := {i | i = 0} µ z (zer) := {0} µ z (posz) := {i | i ≥ 0} µ z (pos) := {i | i > 0} µ z (any) := {i | i ∈ Z}

show abstract

“…Once unification is implemented, we can look at even higher-level tools: elaboration from concrete syntax trees, unification hints like canonical structures and type class resolution, domain-specific and general purpose tactic languages. A key inspiration in this regard is the work of Malecha and Bengston [17] which implemented this idea on a restricted fragment of CIC.…”

Section: Related Work and Future Workmentioning

confidence: 99%

Towards Certified Meta-Programming with Typed Template-Coq

Anand

Boulier

Cohen

et al. 2018

Interactive Theorem Proving

View full text Add to dashboard Cite

Abstract. Template-Coq (https://template-coq.github.io/templatecoq) is a plugin for Coq, originally implemented by Malecha [18], which provides a reifier for Coq terms and global declarations, as represented in the Coq kernel, as well as a denotation command. Initially, it was developed for the purpose of writing functions on Coq's AST in Gallina. Recently, it was used in the CertiCoq certified compiler project [4], as its front-end language, to derive parametricity properties [3], and to extract Coq terms to a CBV λ-calculus [13]. However, the syntax lacked semantics, be it typing semantics or operational semantics, which should reflect, as formal specifications in Coq, the semantics of Coq's type theory itself. The tool was also rather bare bones, providing only rudimentary quoting and unquoting commands. We generalize it to handle the entire Calculus of Inductive Constructions (CIC), as implemented by Coq, including the kernel's declaration structures for definitions and inductives, and implement a monad for general manipulation of Coq's logical environment. We demonstrate how this setup allows Coq users to define many kinds of general purpose plugins, whose correctness can be readily proved in the system itself, and that can be run efficiently after extraction. We give a few examples of implemented plugins, including a parametricity translation. We also advocate the use of Template-Coq as a foundation for higher-level tools.

show abstract

Extensible and Efficient Automation Through Reflective Tactics

Cited by 14 publications

References 33 publications

A metaprogramming framework for formal verification

A metaprogramming framework for formal verification

Constructive Galois connections: taming the Galois connection framework for mechanized metatheory

Towards Certified Meta-Programming with Typed Template-Coq

Contact Info

Product

Resources

About