Results 11  20
of
101
Partial recursive functions in higherorder logic
 Int. Joint Conference on Automated Reasoning (IJCAR 2006), LNCS
, 2006
"... Abstract. Based on inductive definitions, we develop an automated tool for defining partial recursive functions in HigherOrder Logic and providing appropriate reasoning tools for them. Our method expresses termination in a uniform manner and includes a very general form of pattern matching, where p ..."
Abstract

Cited by 19 (2 self)
 Add to MetaCart
(Show Context)
Abstract. Based on inductive definitions, we develop an automated tool for defining partial recursive functions in HigherOrder Logic and providing appropriate reasoning tools for them. Our method expresses termination in a uniform manner and includes a very general form of pattern matching, where patterns can be arbitrary expressions. Termination proofs can be deferred, restricted to subsets of arguments and are interchangeable with other proofs about the function. We show that this approach can also facilitate termination arguments for total functions, in particular for nested recursions. We implemented our tool as a definitional specification mechanism for Isabelle/HOL. 1
A Framework for Specifying, Prototyping, and Reasoning about Computational Systems
, 2009
"... In this thesis we are interested in a framework for specifying, prototyping, and reasoning about systems that describe computations over formal objects such as formulas, proofs, and programs. The computations of interest include those like evaluation and typing in a programming language, provability ..."
Abstract

Cited by 17 (4 self)
 Add to MetaCart
In this thesis we are interested in a framework for specifying, prototyping, and reasoning about systems that describe computations over formal objects such as formulas, proofs, and programs. The computations of interest include those like evaluation and typing in a programming language, provability in a logic, and behavior in a concurrency system. The development of these computational systems is often an iterative
LNgen: Tool Support for Locally Nameless Representations
"... Given the complexity of the metatheoretic reasoning involved with current programming languages and their type systems, techniques for mechanical formalization and checking of the metatheory have received much recent attention. In previous work, we advocated a combination of locally nameless represe ..."
Abstract

Cited by 17 (5 self)
 Add to MetaCart
(Show Context)
Given the complexity of the metatheoretic reasoning involved with current programming languages and their type systems, techniques for mechanical formalization and checking of the metatheory have received much recent attention. In previous work, we advocated a combination of locally nameless representation and cofinite quantification as a lightweight style for carrying out such formalizations in the Coq proof assistant. As part of the presentation of that methodology, we described a number of operations associated with variable binding and listed a number of properties, called “infrastructure lemmas, ” about those operations that needed to be shown. The proofs of these infrastructure lemmas are generally straightforward, given a specification of the binding structure of the language. In this work, we present LNgen, a prototype tool for automatically generating these definitions, lemmas, and proofs from Ottlike language specifications. Furthermore, the tool also generates a recursion scheme for defining functions over syntax, which was not available in our previous work. We also show the soundness and completeness of our tool’s output. For untyped lambda terms, we prove the adequacy of our representation with respect to a fully concrete representation, and we argue that the representation is complete—that we generate the right set of lemmas—with respect to Gordon and Melham’s “Five Axioms of AlphaConversion. ” Finally, we claim that our recursion scheme is simpler to work with than either Gordon and Melham’s recursion scheme or the recursion scheme of Nominal Logic. 1.
Mechanizing the Metatheory of LF
, 2008
"... LF is a dependent type theory in which many other formal systems can be conveniently embedded. However, correct use of LF relies on nontrivial metatheoretic developments such as proofs of correctness of decision procedures for LF’s judgments. Although detailed informal proofs of these properties hav ..."
Abstract

Cited by 16 (7 self)
 Add to MetaCart
LF is a dependent type theory in which many other formal systems can be conveniently embedded. However, correct use of LF relies on nontrivial metatheoretic developments such as proofs of correctness of decision procedures for LF’s judgments. Although detailed informal proofs of these properties have been published, they have not been formally verified in a theorem prover. We have formalized these properties within Isabelle/HOL using the Nominal Datatype Package, closely following a recent article by Harper and Pfenning. In the process, we identified and resolved a gap in one of the proofs and a small number of minor lacunae in others. Besides its intrinsic interest, our formalization provides a foundation for studying the adequacy of LF encodings, the correctness of Twelfstyle metatheoretic reasoning, and the metatheory of extensions to LF.
Foundational, Compositional (Co)datatypes for HigherOrder Logic  Category Theory Applied to Theorem Proving
"... Higherorder logic (HOL) forms the basis of several popular interactive theorem provers. These follow the definitional approach, reducing highlevel specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in H ..."
Abstract

Cited by 16 (10 self)
 Add to MetaCart
(Show Context)
Higherorder logic (HOL) forms the basis of several popular interactive theorem provers. These follow the definitional approach, reducing highlevel specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in HOL4, HOL Light, and Isabelle/HOL is fundamentally noncompositional, limiting its efficiency and flexibility, and it does not cater for codatatypes. We present a fully modular framework for constructing (co)datatypes in HOL, with support for mixed mutual and nested (co)recursion. Mixed (co)recursion enables type definitions involving both datatypes and codatatypes, such as the type of finitely branching trees of possibly infinite depth. Our framework draws heavily from category theory. The key notion is that of a rich type constructor—a functor satisfying specific properties preserved by interesting categorical operations. Our ideas are formalized in Isabelle and implemented as a new definitional package, answering a longstanding user request.
A HeadtoHead Comparison of de Bruijn Indices and Names
 IN PROC. INT. WORKSHOP ON LOGICAL FRAMEWORKS AND METALANGUAGES: THEORY AND PRACTICE
, 2006
"... Often debates about pros and cons of various techniques for formalising lambdacalculi rely on subjective arguments, such as de Bruijn indices are hard to read for humans or nominal approaches come close to the style of reasoning employed in informal proofs. In this paper we will compare four formal ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
(Show Context)
Often debates about pros and cons of various techniques for formalising lambdacalculi rely on subjective arguments, such as de Bruijn indices are hard to read for humans or nominal approaches come close to the style of reasoning employed in informal proofs. In this paper we will compare four formalisations based on de Bruijn indices and on names from the nominal logic work, thus providing some hard facts about the pros and cons of these two formalisation techniques. We conclude that the relative merits of the different approaches, as usual, depend on what task one has at hand and which goals one pursues with a formalisation.
PsiCalculi in Isabelle
 In Proc of the 22nd Conference on Theorem Proving in Higher Order Logics (TPHOLs), volume 5674 of LNCS
"... Abstract. Psicalculi are extensions of the picalculus, accommodating arbitrary nominal datatypes to represent not only data but also communication channels, assertions and conditions, giving it an expressive power beyond the applied picalculus and the concurrent constraint picalculus. We have for ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
(Show Context)
Abstract. Psicalculi are extensions of the picalculus, accommodating arbitrary nominal datatypes to represent not only data but also communication channels, assertions and conditions, giving it an expressive power beyond the applied picalculus and the concurrent constraint picalculus. We have formalised psicalculi in the interactive theorem prover Isabelle using its nominal datatype package. One distinctive feature is that the framework needs to treat binding sequences, as opposed to single binders, in an efficient way. While different methods for formalising single binder calculi have been proposed over the last decades, representations for such binding sequences are not very well explored. The main effort in the formalisation is to keep the machine checked proofs as close to their penandpaper counterparts as possible. We discuss two approaches to reasoning about binding sequences along with their strengths and weaknesses. We also cover custom induction rules to remove the bulk of manual alphaconversions. 1
Simple nominal type theory
"... Abstract. Nominal logic is an extension of firstorder logic with features useful for reasoning about abstract syntax with bound names. For computational applications such as programming and formal reasoning, it is desirable to develop constructive type theories for nominal logic which extend standa ..."
Abstract

Cited by 14 (2 self)
 Add to MetaCart
(Show Context)
Abstract. Nominal logic is an extension of firstorder logic with features useful for reasoning about abstract syntax with bound names. For computational applications such as programming and formal reasoning, it is desirable to develop constructive type theories for nominal logic which extend standard type theories for propositional, first or higherorder logic. This has proven difficult, largely because of complex interactions between nominal logic’s nameabstraction operation and ordinary functional abstraction. This difficulty already arises in the case of propositional logic and simple type theory. In this paper we show how this difficulty can be overcome, and present a simple nominal type theory which enjoys properties such as type soundness and strong normalization, and which can be soundly interpreted using existing nominal set models of nominal logic. We also sketch how recursion combinators for languages with binding structure can be provided. This is an important first step towards understanding the constructive content of nominal logic and incorporating it into existing logics and type theories. 1
Nominal renaming sets
"... Abstract. Nominal techniques are based on the idea of sets with a finitelysupported atomspermutation action. We consider the idea of nominal renaming sets, which are sets with a finitelysupported atomsrenaming action; renamings can identify atoms, permutations cannot. We show that nominal renaming ..."
Abstract

Cited by 13 (8 self)
 Add to MetaCart
(Show Context)
Abstract. Nominal techniques are based on the idea of sets with a finitelysupported atomspermutation action. We consider the idea of nominal renaming sets, which are sets with a finitelysupported atomsrenaming action; renamings can identify atoms, permutations cannot. We show that nominal renaming sets exhibit many of the useful qualities found in (permutative) nominal sets; an elementary setsbased presentation, inductive datatypes of syntax up to binding, cartesian closure, and being a topos. Unlike is the case for nominal sets, the notion of namesabstraction coincides with functional abstraction. Thus we obtain a concrete presentation of sheaves on
Proof pearl: de bruijn terms really do work
 In TPHOLs, volume 4732 of LNCS
, 2007
"... Abstract. Placing our result in a web of related mechanised results, we give a direct proof that the de Bruijn λcalculus (à laHuet,Nipkowand Shankar) is isomorphic to an αquotiented λcalculus. In order to establish the link, we introduce an “indexcarrying ” abstraction mechanism over de Bruijn t ..."
Abstract

Cited by 10 (3 self)
 Add to MetaCart
(Show Context)
Abstract. Placing our result in a web of related mechanised results, we give a direct proof that the de Bruijn λcalculus (à laHuet,Nipkowand Shankar) is isomorphic to an αquotiented λcalculus. In order to establish the link, we introduce an “indexcarrying ” abstraction mechanism over de Bruijn terms, and consider it alongside a simplified substitution mechanism. Relating the new notions to those of the αquotiented and the proper de Bruijn formalisms draws on techniques from the theory of nominal sets. 1