47 research outputs found
Parametric Compositional Data Types
In previous work we have illustrated the benefits that compositional data
types (CDTs) offer for implementing languages and in general for dealing with
abstract syntax trees (ASTs). Based on Swierstra's data types \'a la carte,
CDTs are implemented as a Haskell library that enables the definition of
recursive data types and functions on them in a modular and extendable fashion.
Although CDTs provide a powerful tool for analysing and manipulating ASTs, they
lack a convenient representation of variable binders. In this paper we remedy
this deficiency by combining the framework of CDTs with Chlipala's parametric
higher-order abstract syntax (PHOAS). We show how a generalisation from
functors to difunctors enables us to capture PHOAS while still maintaining the
features of the original implementation of CDTs, in particular its modularity.
Unlike previous approaches, we avoid so-called exotic terms without resorting
to abstract types: this is crucial when we want to perform transformations on
CDTs that inspect the recursively computed CDTs, e.g. constant folding.Comment: In Proceedings MSFP 2012, arXiv:1202.240
A dependent nominal type theory
Nominal abstract syntax is an approach to representing names and binding
pioneered by Gabbay and Pitts. So far nominal techniques have mostly been
studied using classical logic or model theory, not type theory. Nominal
extensions to simple, dependent and ML-like polymorphic languages have been
studied, but decidability and normalization results have only been established
for simple nominal type theories. We present a LF-style dependent type theory
extended with name-abstraction types, prove soundness and decidability of
beta-eta-equivalence checking, discuss adequacy and canonical forms via an
example, and discuss extensions such as dependently-typed recursion and
induction principles
Alpha-Structural Induction and Recursion for the Lambda Calculus in Constructive Type Theory
We formulate principles of induction and recursion for a variant of lambda calculus in its original syntax (i.e., with only one sort of names) where alpha-conversion is based upon name swapping as in nominal abstract syntax. The principles allow to work modulo alpha-conversion and implement the Barendregt variable convention. We derive them all from the simple structural induction principle on concrete terms and work out applications to some fundamental meta-theoretical results, such as the substitution lemma for alpha-conversion and the lemma on substitution composition. The whole work is implemented in Agda
Nominal Logic with Equations Only
Many formal systems, particularly in computer science, may be captured by
equations modulated by side conditions asserting the "freshness of names";
these can be reasoned about with Nominal Equational Logic (NEL). Like most
logics of this sort NEL employs this notion of freshness as a first class
logical connective. However, this can become inconvenient when attempting to
translate results from standard equational logic to the nominal setting. This
paper presents proof rules for a logic whose only connectives are equations,
which we call Nominal Equation-only Logic (NEoL). We prove that NEoL is just as
expressive as NEL. We then give a simple description of equality in the empty
NEoL-theory, then extend that result to describe freshness in the empty
NEL-theory.Comment: In Proceedings LFMTP 2011, arXiv:1110.668
Formalising the pi-calculus using nominal logic
We formalise the pi-calculus using the nominal datatype package, based on
ideas from the nominal logic by Pitts et al., and demonstrate an implementation
in Isabelle/HOL. The purpose is to derive powerful induction rules for the
semantics in order to conduct machine checkable proofs, closely following the
intuitive arguments found in manual proofs. In this way we have covered many of
the standard theorems of bisimulation equivalence and congruence, both late and
early, and both strong and weak in a uniform manner. We thus provide one of the
most extensive formalisations of a process calculus ever done inside a theorem
prover.
A significant gain in our formulation is that agents are identified up to
alpha-equivalence, thereby greatly reducing the arguments about bound names.
This is a normal strategy for manual proofs about the pi-calculus, but that
kind of hand waving has previously been difficult to incorporate smoothly in an
interactive theorem prover. We show how the nominal logic formalism and its
support in Isabelle accomplishes this and thus significantly reduces the tedium
of conducting completely formal proofs. This improves on previous work using
weak higher order abstract syntax since we do not need extra assumptions to
filter out exotic terms and can keep all arguments within a familiar
first-order logic.Comment: 36 pages, 3 figure
Mechanizing the metatheory of sledgehammer
This paper presents an Isabelle/HOL formalization of recent research in automated reasoning: efficient encodings of sorts in unsorted first-order logic, as implemented in Isabelle’s Sledgehammer proof tool. The formalization provides the general-purpose machinery to reason about formulas and models, emulating the theory of institutions. Quantifiers are represented using a nominal-like approach designed for interpreting syntax in semantic domains
Generalized Multisets: From ZF to FSM
We study generalized multisets (multisets that allow possible negative multiplicities) both in the Zermelo-Fraenkel framework and in the finitely supported mathematics. We extend the notion of generalized multiset over a finite alphabet, and we replace it by the notion of algebraically finitely supported generalized multiset over a possibly infinite alphabet. We analyze the correspondence between some properties of generalized multisets obtained in finitely supported mathematics where only finitely supported objects are allowed, and those obtained in the classical Zermelo-Fraenkel framework
Recommended from our members
Nominal techniques
This is the author accepted manuscript. The final version is available from the Association for Computing Machinery via http://dx.doi.org/10.1145/2893582.2893594
Programming languages abound with features making use of names in various ways. There is a mathematical foundation for the semantics of such features which uses groups of permutations of names and the notion of the
support
of an object with respect to the action of such a group. The relevance of this kind of mathematics for the semantics of names is perhaps not immediately obvious. That it is relevant and useful has emerged over the last 15 years or so in a body of work that has acquired its own name:
nominal techniques.
At the same time, the application of these techniques has broadened from semantics to computation theory in general. This article introduces the subject and is based upon a tutorial at LICS-ICALP 2015 [Pitts 2015a].
</jats:p