Frank Pfenning

Higher-order abstract syntax

We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and substitution or unification are central operations. Higher-order abstract syntax incorporates name binding information in a uniform and language generic way. Thus it acts as a powerful link integrating diverse tools in such formal environments. We have implemented higher-order abstract syntax, a supporting matching and unification algorithm, and some clients in Common Lisp in the framework of the Ergo project at Carnegie Mellon University.

Uniform Proofs as a Foundation for Logic Programming

Abstract Miller, D., G. Nadathur, F. Pfenning and A. Scedrov, Uniform proofs as a foundation for logic programming, Annals of Pure and Applied Logic 51 (1991) 125–157. A proof-theoretic characterization of logical languages that form suitable bases for Prolog-like programming languages is provided. This characterization is based on the principle that the declarative meaning of a logic program, provided by provability in a logical system, should coincide with its operational meaning, provided by interpreting logical connectives as simple and fixed search instructions. The operational semantics is formalized by the identification of a class of cut-free sequent proofs called uniform proofs. A uniform proof is one that can be found by a goal-directed search that respects the interpretation of the logical connectives as search instructions. The concept of a uniform proof is used to define the notion of an abstract logic programming language, and it is shown that first-order and higher-order Horn clauses with classical provability are examples of such a language. Horn clauses are then generalized to hereditary Harrop formulas and it is shown that first-order and higher-order versions of this new class of formulas are also abstract logic programming languages if the inference rules are those of either intuitionistic or minimal logic. The programming language significance of the various generalizations to first-order Horn clauses is briefly discussed.

Dependent types in practical programming

We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) language schema. This allows specification and inference of significantly more precise type information, facilitating program error detection and compiler optimization. A major complication resulting from introducing dependent types is that pure type inference for the enriched system is no longer possible, but we show that type-checking a sufficiently annotated program in DML(C) can be reduced to constraint satisfaction in the constraint domain C. We exhibit the unobtrusiveness of our approach through practical examples and prove that DML(C) is conservative over ML. The main contribution of the paper lies in our language design, including the formulation of type-checking rules which makes the approach practical. To our knowledge, no previous type system for a general purpose programming language such as ML has combined dependent types with features including datatype declarations, higher-order functions, general recursions, let-polymorphism, mutable references, and exceptions. In addition, we have finished a prototype implementation of DML(C) for an integer constraint domain C, where constraints are linear inequalities (Xi and Pfenning 1998).

A judgmental reconstruction of modal logic

We reconsider the foundations of modal logic, following Martin-Lofs methodology of distinguishing judgments from propositions. We give constructive meaning explanations for necessity and possibility, which yields a simple and uniform system of natural deduction for intuitionistic modal logic that does not exhibit anomalies found in other proposals. We also give a new presentation of lax logic and find that the lax modality is already expressible using possibility and necessity. Through a computational interpretation of proofs in modal logic we further obtain a new formulation of Moggis monadic metalanguage.

Refinement types for ML

Abstract : Programming computers is a notoriously error-prone process. It is the job of the programming language designer to make this process more reliable. One approach to this is to impose some sort of typing discipline on the programs. In doing this, the programming language designer is immediately faced with a tradeoff: if the type system is too simple, it cannot accurately express important properties of the program; if it is too expressive, then mechanically checking or inferring the types becomes impractical. This thesis describes a type system called refinement types, which is an example of a new way to make this tradeoff, as well as a potentially useful system in itself. Refinement type inference requires programs to have types in two type systems: an expressive type inference system (intersection types with subtyping) and a relatively simple type system (basic polymorphic type inference). Refinement type inference inherits some properties from each of these: as in intersection types with subtyping, we can use the type system to do abstract interpretation; as in basic polymorphic type inference, refinement type inference is decidable (preliminary experiments suggest refinement type inference may be practical as well). We have implemented refinement type inference for a subset of Standard ML to test these ideas. We have added new syntax, called rectype declarations, to allow the programmer to specify relevant domains for the abstract interpretation.

Eliminating array bound checking through dependent types

We present a type-based approach to eliminating array bound checking and list tag checking by conservatively extending Standard ML with a restricted form of dependent types. This enables the programmer to capture more invariants through types while type-checking remains decidable in theory and can still be performed efficiently in practice. We illustrate our approach through concrete examples and present the result of our preliminary experiments which support support the feasibility and effectiveness of our approach.

Logic programming in the LF logical framework

3 A Meta-Logic for Unification 4 3.1 A First-Order Unification Logic with Quantifier Dependencies . . . . . . . . . . . . . 5 3.2 Transformations for First-Order Unification . . . . . . . . . . . . . . . . . . . . . . . 6 3.3 A Unification Logic for LF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.4 A Generalization of Lλ Unification to LF . . . . . . . . . . . . . . . . . . . . . . . . 7 3.5 Precompleteness of the Transformations for Unification . . . . . . . . . . . . . . . . . 11

Automated Deduction – CADE-21

Session 1. Invited Talk: Colin Stirling.- Games, Automata and Matching.- Session 2. Higher-Order Logic.- Formalization of Continuous Probability Distributions.- Compilation as Rewriting in Higher Order Logic.- Barendregts Variable Convention in Rule Inductions.- Automating Elementary Number-Theoretic Proofs Using Grobner Bases.- Session 3. Description Logic.- Optimized Reasoning in Description Logics Using Hypertableaux.- Conservative Extensions in the Lightweight Description Logic .- An Incremental Technique for Automata-Based Decision Procedures.- Session 4. Intuitionistic Logic.- Bidirectional Decision Procedures for the Intuitionistic Propositional Modal Logic IS4.- A Labelled System for IPL with Variable Splitting.- Session 5. Invited Talk: Ashish Tiwari.- Logical Interpretation: Static Program Analysis Using Theorem Proving.- Session 6. Satisfiability Modulo Theories.- Solving Quantified Verification Conditions Using Satisfiability Modulo Theories.- Efficient E-Matching for SMT Solvers.- -Decision by Decomposition.- Towards Efficient Satisfiability Checking for Boolean Algebra with Presburger Arithmetic.- Session 7. Induction, Rewriting, and Polymorphism.- Improvements in Formula Generalization.- On the Normalization and Unique Normalization Properties of Term Rewrite Systems.- Handling Polymorphism in Automated Deduction.- Session 8. First-Order Logic.- Automated Reasoning in Kleene Algebra.- SRASS - A Semantic Relevance Axiom Selection System.- Labelled Clauses.- Automatic Decidability and Combinability Revisited.- Session 9. Invited Talk: K. Rustan M. Leino.- Designing Verification Conditions for Software.- Session 10. Model Checking and Verification.- Encodings of Bounded LTL Model Checking in Effectively Propositional Logic.- Combination Methods for Satisfiability and Model-Checking of Infinite-State Systems.- The KeY system 1.0 (Deduction Component).- KeY-C: A Tool for Verification of C Programs.- The Bedwyr System for Model Checking over Syntactic Expressions.- System for Automated Deduction (SAD): A Tool for Proof Verification.- Session 11. Invited Talk: Peter Baumgartner.- Logical Engineering with Instance-Based Methods.- Session 12. Termination.- Predictive Labeling with Dependency Pairs Using SAT.- Dependency Pairs for Rewriting with Non-free Constructors.- Proving Termination by Bounded Increase.- Certified Size-Change Termination.- Session 13. Tableaux and First-Order Systems.- Encoding First Order Proofs in SAT.- Hyper Tableaux with Equality.- System Description: E- KRHyper.- System Description: Spass Version 3.0.

Contextual modal type theory

The intuitionistic modal logic of necessity is based on the judgmental notion of categorical truth. In this article we investigate the consequences of relativizing these concepts to explicitly specified contexts. We obtain contextual modal logic and its type-theoretic analogue. Contextual modal type theory provides an elegant, uniform foundation for understanding metavariables and explicit substitutions. We sketch some applications in functional programming and logical frameworks.

A linear logical framework

We present the linear type theory LLF as the formal basis for a conservative extension of the LF logical framework. LLF combines the expressive power of dependent types with linear logic to permit the natural and concise representation of a whole new class of deductive systems, namely those dealing with state. As an example we encode a version of Mini-ML with references including its type system, its operational semantics, and a proof of type preservation. Another example is the encoding of a sequent calculus for classical linear logic and its cut elimination theorem. LLF can also be given an operational interpretation as a logic programming language under which the representations above can be used for type inference, evaluation and cut-elimination.