Results 1  10
of
63
System Description: Twelf  A MetaLogical Framework for Deductive Systems
 Proceedings of the 16th International Conference on Automated Deduction (CADE16
, 1999
"... . Twelf is a metalogical framework for the specification, implementation, and metatheory of deductive systems from the theory of programming languages and logics. It relies on the LF type theory and the judgmentsastypes methodology for specification [HHP93], a constraint logic programming interp ..."
Abstract

Cited by 363 (56 self)
 Add to MetaCart
(Show Context)
. Twelf is a metalogical framework for the specification, implementation, and metatheory of deductive systems from the theory of programming languages and logics. It relies on the LF type theory and the judgmentsastypes methodology for specification [HHP93], a constraint logic programming interpreter for implementation [Pfe91], and the metalogic M2 for reasoning about object languages encoded in LF [SP98]. It is a significant extension and complete reimplementation of the Elf system [Pfe94]. Twelf is written in Standard ML and runs under SML of New Jersey and MLWorks on Unix and Window platforms. The current version (1.2) is distributed with a complete manual, example suites, a tutorial in the form of online lecture notes [Pfe], and an Emacs interface. Source and binary distributions are accessible via the Twelf home page http://www.cs.cmu.edu/~twelf. 1 The Twelf System The Twelf system is a tool for experimentation in the theory of programming languages and logics. It supports...
Higherorder Unification via Explicit Substitutions (Extended Abstract)
 Proceedings of LICS'95
, 1995
"... Higherorder unification is equational unification for βηconversion. But it is not firstorder equational unification, as substitution has to avoid capture. In this paper higherorder unification is reduced to firstorder equational unification in a suitable theory: the &lambda ..."
Abstract

Cited by 109 (13 self)
 Add to MetaCart
Higherorder unification is equational unification for &beta;&eta;conversion. But it is not firstorder equational unification, as substitution has to avoid capture. In this paper higherorder unification is reduced to firstorder equational unification in a suitable theory: the &lambda;&sigma;calculus of explicit substitutions.
Automating the Meta Theory of Deductive Systems
, 2000
"... not be interpreted as representing the o cial policies, either expressed or implied, of NSF or the U.S. Government. This thesis describes the design of a metalogical framework that supports the representation and veri cation of deductive systems, its implementation as an automated theorem prover, a ..."
Abstract

Cited by 88 (16 self)
 Add to MetaCart
(Show Context)
not be interpreted as representing the o cial policies, either expressed or implied, of NSF or the U.S. Government. This thesis describes the design of a metalogical framework that supports the representation and veri cation of deductive systems, its implementation as an automated theorem prover, and experimental results related to the areas of programming languages, type theory, and logics. Design: The metalogical framework extends the logical framework LF [HHP93] by a metalogic M + 2. This design is novel and unique since it allows higherorder encodings of deductive systems and induction principles to coexist. On the one hand, higherorder representation techniques lead to concise and direct encodings of programming languages and logic calculi. Inductive de nitions on the other hand allow the formalization of properties about deductive systems, such as the proof that an operational semantics preserves types or the proof that a logic is is a proof calculus whose proof terms are recursive functions that may be consistent.M +
Contextual modal type theory
 ACM Transactions on Computational Logic
"... All intext references underlined in blue are linked to publications on ResearchGate, letting you access and read them immediately. ..."
Abstract

Cited by 86 (29 self)
 Add to MetaCart
All intext references underlined in blue are linked to publications on ResearchGate, letting you access and read them immediately.
Pure Pattern Type Systems
 In POPL’03
, 2003
"... We introduce a new framework of algebraic pure type systems in which we consider rewrite rules as lambda terms with patterns and rewrite rule application as abstraction application with builtin matching facilities. This framework, that we call “Pure Pattern Type Systems”, is particularly wellsuite ..."
Abstract

Cited by 54 (26 self)
 Add to MetaCart
(Show Context)
We introduce a new framework of algebraic pure type systems in which we consider rewrite rules as lambda terms with patterns and rewrite rule application as abstraction application with builtin matching facilities. This framework, that we call “Pure Pattern Type Systems”, is particularly wellsuited for the foundations of programming (meta)languages and proof assistants since it provides in a fully unified setting higherorder capabilities and pattern matching ability together with powerful type systems. We prove some standard properties like confluence and subject reduction for the case of a syntactic theory and under a syntactical restriction over the shape of patterns. We also conjecture the strong normalization of typable terms. This work should be seen as a contribution to a formal connection between logics and rewriting, and a step towards new proof engines based on the CurryHoward isomorphism.
Structured Type Theory
, 1999
"... Introduction We present our implementation AGDA of type theory. We limit ourselves in this presentation to a rather primitive form of type theory (dependent product with a simple notion of sorts) that we extend to structure facility we find in most programming language: let expressions (local defin ..."
Abstract

Cited by 43 (4 self)
 Add to MetaCart
Introduction We present our implementation AGDA of type theory. We limit ourselves in this presentation to a rather primitive form of type theory (dependent product with a simple notion of sorts) that we extend to structure facility we find in most programming language: let expressions (local definition) and a package mechanism. We call this language Structured Type Theory. The first part describes the syntax of the language and an informal description of the typechecking. The second part contains a detailed description of a core language, which is used to implement Strutured Type Theory. We give a realisability semantics, and typechecking rules are proved correct with respect to this semantics. The notion of metavariables is explained at this level. The third part explains how to interpret Structured Type Theory in this core language. The main contributions are: ffl use of explicit substitution to simplify and make
A Coverage Checking Algorithm for LF
, 2003
"... Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the first ..."
Abstract

Cited by 41 (13 self)
 Add to MetaCart
(Show Context)
Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the firstorder, simplytyped case, but is in general undecidable in the presence of dependent types. In this paper we present a terminating algorithm for verifying coverage of higherorder, dependently typed patterns.
Nominal logic programming
, 2006
"... Nominal logic is an extension of firstorder logic which provides a simple foundation for formalizing and reasoning about abstract syntax modulo consistent renaming of bound names (that is, αequivalence). This article investigates logic programming based on nominal logic. This technique is especial ..."
Abstract

Cited by 40 (9 self)
 Add to MetaCart
Nominal logic is an extension of firstorder logic which provides a simple foundation for formalizing and reasoning about abstract syntax modulo consistent renaming of bound names (that is, αequivalence). This article investigates logic programming based on nominal logic. This technique is especially wellsuited for prototyping type systems, proof theories, operational semantics rules, and other formal systems in which bound names are present. In many cases, nominal logic programs are essentially literal translations of “paper” specifications. As such, nominal logic programming provides an executable specification language for prototyping, communicating, and experimenting with formal systems. We describe some typical nominal logic programs, and develop the modeltheoretic, prooftheoretic, and operational semantics of such programs. Besides being of interest for ensuring the correct behavior of implementations, these results provide a rigorous foundation for techniques for analysis and reasoning about nominal logic programs, as we illustrate via two examples.
Practical programming with higherorder encodings and dependent types
 In Proceedings of the European Symposium on Programming (ESOP ’08
, 2008
"... Abstract. Higherorder abstract syntax (HOAS) refers to the technique of representing variables of an objectlanguage using variables of a metalanguage. The standard firstorder alternatives force the programmer to deal with superficial concerns such as substitutions, whose implementation is often ..."
Abstract

Cited by 34 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Higherorder abstract syntax (HOAS) refers to the technique of representing variables of an objectlanguage using variables of a metalanguage. The standard firstorder alternatives force the programmer to deal with superficial concerns such as substitutions, whose implementation is often routine, tedious, and errorprone. In this paper, we describe the underlying calculus of Delphin. Delphin is a fully implemented functionalprogramming language supporting reasoning over higherorder encodings and dependent types, while maintaining the benefits of HOAS. More specifically, just as representations utilizing HOAS free the programmer from concerns of handling explicit contexts and substitutions, our system permits programming over such encodings without making these constructs explicit, leading to concise and elegant programs. To this end our system distinguishes bindings of variables intended for instantiation from those that will remain uninstantiated, utilizing a variation of Miller and Tiu’s ∇quantifier [1]. 1