Programming Inductive Proofs - A New Approach Based on Contextual Types

In this paper, we present an overview to programming with proofs in the reasoning framework, Beluga. Beluga supports the specification of formal systems given by axioms and inference rules within the logical framework LF. It also supports implementing proofs about formal systems as dependently typed recursive functions. What distinguishes Beluga from other frameworks is that it not only represents binders using higher-order abstract syntax, but directly supports reasoning with contexts and contextual objects. Contextual types allows us to characterize precisely hypothetical and parametric derivations, i.e. derivations which depend on variables and assumptions, and lead to a direct and elegant implementation of inductive proofs as recursive functions. Because of the intrinsic support for binders and contexts, one can think of the design of Beluga as the most advanced technology for specifying and prototyping formal systems together with their meta-theory.

[1]  Amy P. Felty,et al.  Two-Level Hybrid: A System for Reasoning Using Higher-Order Abstract Syntax , 2008, Electron. Notes Theor. Comput. Sci..

[2]  Andrew Gacek.  The Abella Interactive Theorem Prover (System Description) , 2008, IJCAR.

[3]  Martín Abadi,et al.  Explicit substitutions , 1989, POPL '90.

[4]  Frank Pfenning,et al.  Contextual modal type theory , 2008, TOCL.

[5]  Orna Grumberg,et al.  A game-based framework for CTL counterexamples and 3-valued abstraction-refinement , 2007, TOCL.

[6]  Frank Pfenning,et al.  Primitive recursion for higher-order abstract syntax , 1997, Theoretical Computer Science.

[7]  Brigitte Pientka.  A type-theoretic foundation for programming with higher-order abstract syntax and first-class substitutions , 2008, POPL '08.

[8]  Brigitte Pientka,et al.  Programming with proofs and explicit contexts , 2008, PPDP '08.

[9]  Brigitte Pientka,et al.  Case Analysis of Higher-Order Data , 2009, Electron. Notes Theor. Comput. Sci..

[10]  Carsten Schürmann,et al.  System Description: Delphin - A Functional Programming Language for Deductive Systems , 2008, LFMTP@LICS.

[11]  Peter Lee,et al.  Topics in advanced language implementation , 1991 .

[12]  George C. Necula,et al.  Proof-Carrying Code , 2011, Encyclopedia of Cryptography and Security.

[13]  F. Pfenning.  Logic programming in the LF logical framework , 1991 .

[14]  Jason Reed,et al.  Higher-order constraint simplification in dependent type theory , 2009, LFMTP '09.

[15]  Patrick J. Hayes,et al.  Computation and Deduction , 1973, MFCS.

[16]  Jaime G. Carbonell,et al.  Automated Deduction — CADE-16 , 2002, Lecture Notes in Computer Science.

[17]  Brigitte Pientka,et al.  Beluga: A Framework for Programming and Reasoning with Deductive Systems (System Description) , 2010, IJCAR.

[18]  Adam Chlipala,et al.  A certified type-preserving compiler from lambda calculus to assembly language , 2007, PLDI '07.

[19]  Frank Pfenning,et al.  A Semi-Functional Implementation of a Higher-Order Logic Programming Language , 1990 .

[20]  Karl Crary,et al.  Towards a mechanized metatheory of standard ML , 2007, POPL '07.

[21]  Hanne Riis Nielson,et al.  Programming Languages and Systems — ESOP '96 , 1996, Lecture Notes in Computer Science.

[22]  Sam Lindley,et al.  Extensional Rewriting with Sums , 2007, TLCA.

[23]  Larry Wos,et al.  What Is Automated Reasoning? , 1987, J. Autom. Reason..

[24]  G. Gentzen.  Untersuchungen über das logische Schließen. I , 1935 .

[25]  Amy P. Felty,et al.  Reasoning with Higher-Order Abstract Syntax and Contexts: A Comparison , 2010, ITP.

[26]  Frank Pfenning,et al.  Logical Frameworks , 2001, Handbook of Automated Reasoning.

[27]  Amy P. Felty,et al.  Reasoning with hypothetical judgments and open terms in hybrid , 2009, PPDP '09.

[28]  Furio Honsell,et al.  A framework for defining logics , 1993, JACM.

[29]  David Aspinall,et al.  Formalising Java's Data Race Free Guarantee , 2007, TPHOLs.

[30]  Martín Abadi,et al.  Explicit substitutions , 1989, POPL '90.

[31]  Xavier Leroy,et al.  A Formally Verified Compiler Back-end , 2009, Journal of Automated Reasoning.

[32]  Adam Chlipala,et al.  A verified compiler for an impure functional language , 2010, POPL '10.

[33]  Brigitte Pientka.  Proof Pearl: The Power of Higher-Order Encodings in the Logical Framework LF , 2007, TPHOLs.

[34]  Frank Pfenning,et al.  Mode and Termination Checking for Higher-Order Logic Programs , 1996, ESOP.

[35]  Thorsten Altenkirch.  A Formalization of the Strong Normalization Proof for System F in LEGO , 1993, TLCA.

[36]  Benjamin C. Pierce,et al.  Mechanized Metatheory for the Masses: The PoplMark Challenge , 2005, TPHOLs.

[37]  Frank Pfenning,et al.  System Description: Twelf - A Meta-Logical Framework for Deductive Systems , 1999, CADE.

[38]  Brigitte Pientka.  Verifying Termination and Reduction Properties about Higher-Order Logic Programs , 2005, Journal of Automated Reasoning.