Results 1  10
of
65
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 28 (1 self)
 Add to MetaCart
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
The Abella interactive theorem prover (system description
 In Fourth International Joint Conference on Automated Reasoning
, 2008
"... Abella [3] is an interactive system for reasoning about aspects of object languages that have been formally presented through recursive rules based on syntactic structure. Abella utilizes a twolevel logic approach to specification and reasoning. One level is defined by a specification logic which s ..."
Abstract

Cited by 25 (4 self)
 Add to MetaCart
Abella [3] is an interactive system for reasoning about aspects of object languages that have been formally presented through recursive rules based on syntactic structure. Abella utilizes a twolevel logic approach to specification and reasoning. One level is defined by a specification logic which supports a transparent
The Bedwyr system for model checking over syntactic expressions
 21th Conference on Automated Deduction, LNAI 4603, 391–397
, 2007
"... Bedwyr is a generalization of logic programming that allows model checking directly on syntactic expressions possibly containing bindings. This system, written in OCaml, is a direct implementation of two recent advances in the theory of proof search. The first is centered on the fact that both finit ..."
Abstract

Cited by 21 (12 self)
 Add to MetaCart
Bedwyr is a generalization of logic programming that allows model checking directly on syntactic expressions possibly containing bindings. This system, written in OCaml, is a direct implementation of two recent advances in the theory of proof search. The first is centered on the fact that both finite success and finite failure can be captured in the sequent calculus by incorporating inference rules for definitions that allow fixed points to be explored. As a result, proof search in such a sequent calculus can capture simple model checking problems as well as may and must behavior in operational semantics. The second is that higherorder abstract syntax is directly supported using termlevel λbinders and the quantifier known as ∇. These features allow reasoning directly on expressions containing bound variables. 2
A congruence rule format for namepassing process calculi from mathematical structural operational semantics
 In Proc. LICS’06
, 2006
"... We introduce a GSOSlike rule format for namepassing process calculi. Specifications in this format correspond to theories in nominal logic. The intended models of such specifications arise by initiality from a general categorical model theory. For operational semantics given in this rule format, a ..."
Abstract

Cited by 20 (5 self)
 Add to MetaCart
We introduce a GSOSlike rule format for namepassing process calculi. Specifications in this format correspond to theories in nominal logic. The intended models of such specifications arise by initiality from a general categorical model theory. For operational semantics given in this rule format, a natural behavioural equivalence — a form of open bisimilarity — is a congruence.
Modal proofs as distributed programs
 13th European Symposium on Programming
, 2003
"... We develop a new foundation for distributed programming languages by defining an intuitionistic, modal logic and then interpreting the modal proofs as distributed programs. More specifically, the proof terms for the various modalities have computational interpretations as remote procedure calls, com ..."
Abstract

Cited by 20 (1 self)
 Add to MetaCart
We develop a new foundation for distributed programming languages by defining an intuitionistic, modal logic and then interpreting the modal proofs as distributed programs. More specifically, the proof terms for the various modalities have computational interpretations as remote procedure calls, commands to broadcast computations to all nodes in the network, commands to use portable code, and finally, commands to invoke computational agents that can find their own way to safe places in the network where they can execute. We prove some simple metatheoretic results about our logic as well as a safety theorem that demonstrates that the deductive rules act as a sound type system for a distributed programming language. 1
Combining generic judgments with recursive definitions
 in "23th Symp. on Logic in Computer Science", F. PFENNING (editor), IEEE Computer Society Press, 2008, p. 33–44, http://www.lix.polytechnique.fr/Labo/Dale.Miller/papers/lics08a.pdf US
"... Many semantical aspects of programming languages are specified through calculi for constructing proofs: consider, for example, the specification of structured operational semantics, labeled transition systems, and typing systems. Recent proof theory research has identified two features that allow di ..."
Abstract

Cited by 16 (4 self)
 Add to MetaCart
Many semantical aspects of programming languages are specified through calculi for constructing proofs: consider, for example, the specification of structured operational semantics, labeled transition systems, and typing systems. Recent proof theory research has identified two features that allow direct, logicbased reasoning about such descriptions: the treatment of atomic judgments as fixed points (recursive definitions) and an encoding of binding constructs via generic judgments. However, the logics encompassing these two features have thus far treated them orthogonally. In particular, they have not contained the ability to form definitions of objectlogic properties that themselves depend on an intrinsic treatment of binding. We propose a new and simple integration of these features within an intuitionistic logic enhanced with induction over natural numbers and we show that the resulting logic is consistent. The pivotal part of the integration allows recursive definitions to define generic judgments in general and not just the simpler atomic judgments that are traditionally allowed. The usefulness of this logic is illustrated by showing how it can provide elegant treatments of objectlogic contexts that appear in proofs involving typing calculi and arbitrarily cascading substitutions in reducibility arguments.
A Definitional TwoLevel Approach to Reasoning with HigherOrder Abstract Syntax
 Journal of Automated Reasoning
, 2010
"... Abstract. Combining higherorder abstract syntax and (co)induction in a logical framework is well known to be problematic. Previous work [ACM02] described the implementation of a tool called Hybrid, within Isabelle HOL, syntax, and reasoned about using tactical theorem proving and principles of (co ..."
Abstract

Cited by 16 (4 self)
 Add to MetaCart
Abstract. Combining higherorder abstract syntax and (co)induction in a logical framework is well known to be problematic. Previous work [ACM02] described the implementation of a tool called Hybrid, within Isabelle HOL, syntax, and reasoned about using tactical theorem proving and principles of (co)induction. Moreover, it is definitional, which guarantees consistency within a classical type theory. The idea is to have a de Bruijn representation of syntax, while offering tools for reasoning about them at the higher level. In this paper we describe how to use it in a multilevel reasoning fashion, similar in spirit to other metalogics such as Linc and Twelf. By explicitly referencing provability in a middle layer called a specification logic, we solve the problem of reasoning by (co)induction in the presence of nonstratifiable hypothetical judgments, which allow very elegant and succinct specifications of object logic inference rules. We first demonstrate the method on a simple example, formally proving type soundness (subject reduction) for a fragment of a pure functional language, using a minimal intuitionistic logic as the specification logic. We then prove an analogous result for a continuationmachine presentation of the operational semantics of the same language, encoded this time in an ordered linear logic that serves as the specification layer. This example demonstrates the ease with which we can incorporate new specification logics, and also illustrates a significantly
Mixing finite success and finite failure in an automated prover
 In Proceedings of ESHOL’05: Empirically Successful Automated Reasoning in HigherOrder Logics, pages 79 – 98
, 2005
"... Abstract. The operational semantics and typing judgements of modern programming and specification languages are often defined using relations and proof systems. In simple settings, logic programming languages can be used to provide rather direct and natural interpreters for such operational semantic ..."
Abstract

Cited by 14 (7 self)
 Add to MetaCart
Abstract. The operational semantics and typing judgements of modern programming and specification languages are often defined using relations and proof systems. In simple settings, logic programming languages can be used to provide rather direct and natural interpreters for such operational semantics. More complex features of specifications such as names and their bindings, proof rules with negative premises, and the exhaustive enumeration of state spaces, all pose significant challenges to conventional logic programming systems. In this paper, we describe a simple architecture for the implementation of deduction systems that allows a specification to interleave between finite success and finite failure. The implementation techniques for this prover are largely common ones from higherorder logic programming, i.e., logic variables, (higherorder pattern) unification, backtracking (using streambased computation), and abstract syntax based on simply typed λterms. We present a particular instance of this prover’s architecture and its prototype implementation, Level 0/1, based on the dual interpretation of (finite) success and finite failure in proof search. We show how Level 0/1 provides a highlevel and declarative implementation of model checking and bisimulation checking for the (finite) πcalculus. 1
Logical reasoning for higherorder functions with local state
 In Foundations of Software Science and Computation Structure
"... ABSTRACT. We introduce an extension of Hoare logic for callbyvalue higherorder functions with MLlike local reference generation. Local references may be generated dynamically and exported outside their scope, may store higherorder functions and may be used to construct complex mutable data stru ..."
Abstract

Cited by 13 (4 self)
 Add to MetaCart
ABSTRACT. We introduce an extension of Hoare logic for callbyvalue higherorder functions with MLlike local reference generation. Local references may be generated dynamically and exported outside their scope, may store higherorder functions and may be used to construct complex mutable data structures. This primitive is captured logically using a predicate asserting reachability of a reference name from a possibly higherorder datum and quantifiers over hidden references. We explore the logic’s descriptive and reasoning power with nontrivial programming examples combining higherorder procedures and dynamically generated local state. Axioms for reachability and local invariant play a central role for reasoning about the examples.
Combining de Bruijn indices and higherorder abstract syntax in Coq
 Proceedings of TYPES 2006, volume 4502 of Lecture Notes in Computer Science
, 2006
"... Abstract. The use of higherorder abstract syntax is an important approach for the representation of binding constructs in encodings of languages and logics in a logical framework. Formal metareasoning about such object languages is a particular challenge. We present a mechanism for such reasoning, ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
Abstract. The use of higherorder abstract syntax is an important approach for the representation of binding constructs in encodings of languages and logics in a logical framework. Formal metareasoning about such object languages is a particular challenge. We present a mechanism for such reasoning, formalized in Coq, inspired by the Hybrid tool in Isabelle. At the base level, we define a de Bruijn representation of terms with basic operations and a reasoning framework. At a higher level, we can represent languages and reason about them using higherorder syntax. We take advantage of Coq’s constructive logic by formulating many definitions as Coq programs. We illustrate the method on two examples: the untyped lambda calculus and quantified propositional logic. For each language, we can define recursion and induction principles that work directly on the higherorder syntax. 1