10 research outputs found
Multi-level Contextual Type Theory
Contextual type theory distinguishes between bound variables and
meta-variables to write potentially incomplete terms in the presence of
binders. It has found good use as a framework for concise explanations of
higher-order unification, characterize holes in proofs, and in developing a
foundation for programming with higher-order abstract syntax, as embodied by
the programming and reasoning environment Beluga. However, to reason about
these applications, we need to introduce meta^2-variables to characterize the
dependency on meta-variables and bound variables. In other words, we must go
beyond a two-level system granting only bound variables and meta-variables.
In this paper we generalize contextual type theory to n levels for arbitrary
n, so as to obtain a formal system offering bound variables, meta-variables and
so on all the way to meta^n-variables. We obtain a uniform account by
collapsing all these different kinds of variables into a single notion of
variabe indexed by some level k. We give a decidable bi-directional type system
which characterizes beta-eta-normal forms together with a generalized
substitution operation.Comment: In Proceedings LFMTP 2011, arXiv:1110.668
Nominal Henkin Semantics: simply-typed lambda-calculus models in nominal sets
We investigate a class of nominal algebraic Henkin-style models for the
simply typed lambda-calculus in which variables map to names in the denotation
and lambda-abstraction maps to a (non-functional) name-abstraction operation.
The resulting denotations are smaller and better-behaved, in ways we make
precise, than functional valuation-based models.
Using these new models, we then develop a generalisation of \lambda-term
syntax enriching them with existential meta-variables, thus yielding a theory
of incomplete functions. This incompleteness is orthogonal to the usual notion
of incompleteness given by function abstraction and application, and
corresponds to holes and incomplete objects.Comment: In Proceedings LFMTP 2011, arXiv:1110.668
Permissive nominal terms
We present a simplified version of nominal terms with improved properties. Nominal terms are themselves a version of first-order terms, adapted to provide primitive support for names, binding, capturing substitution, and alpha-conversion. Nominal terms lack certain properties of first-order terms; it is always possible to 'choose a fresh variable symbol' for a first-order term and it is always possible to 'alpha-convert a bound variable symbol to a fresh symbol'. This is not the case for nominal terms. Permissive nominal terms preserve the flavour and the basic theory of nominal terms, including two levels of variable symbol, freshness, and permutation - but they recover the 'always fresh' and 'always alpha-rename' properties of first- and higher-order syntax, and they simplify the theory by eliding freshness contexts and by supporting a notion of term-unifier based on substitution alone, rather than the nominal terms' substitution and freshness conditions. No expressivity is lost moving to the permissive case
Extensions of nominal terms
This thesis studies two major extensions of nominal terms. In particular, we
study an extension with -abstraction over nominal unknowns and atoms, and an
extension with an arguably better theory of freshness and -equivalence.
Nominal terms possess two levels of variable: atoms a represent variable symbols,
and unknowns X are `real' variables. As a syntax, they are designed to facilitate
metaprogramming; unknowns are used to program on syntax with variable symbols.
Originally, the role of nominal terms was interpreted narrowly. That is, they
were seen solely as a syntax for representing partially-speci ed abstract syntax with
binding.
The main motivation of this thesis is to extend nominal terms so that they can
be used for metaprogramming on proofs, programs, etc. and not just for metaprogramming
on abstract syntax with binding. We therefore extend nominal terms
in two signi cant ways: adding -abstraction over nominal unknowns and atoms|
facilitating functional programing|and improving the theory of -equivalence that
nominal terms possesses.
Neither of the two extensions considered are trivial. The capturing substitution
action of nominal unknowns implies that our notions of scope, intuited from working
with syntax possessing a non-capturing substitution, such as the -calculus, is no
longer applicable. As a result, notions of -abstraction and -equivalence must be
carefully reconsidered.
In particular, the rst research contribution of this thesis is the two-level -
calculus, intuitively an intertwined pair of -calculi. As the name suggests, the
two-level -calculus has two level of variable, modelled by nominal atoms and unknowns,
respectively. Both levels of variable can be -abstracted, and requisite
notions of -reduction are provided. The result is an expressive context-calculus.
The traditional problems of handling -equivalence and the failure of commutation
between instantiation and -reduction in context-calculi are handled through the
use of two distinct levels of variable, swappings, and freshness side-conditions on
unknowns, i.e. `nominal technology'.
The second research contribution of this thesis is permissive nominal terms,
an alternative form of nominal term. They retain the `nominal' rst-order
avour
of nominal terms (in fact, their grammars are almost identical) but forego the use
of explicit freshness contexts. Instead, permissive nominal terms label unknowns
with a permission sort, where permission sorts are in nite and coin nite sets of
atoms. This in nite-coin nite nature means that permissive nominal terms recover
two properties|we call them the `always-fresh' and `always-rename' properties
that nominal terms lack. We argue that these two properties bring the theory of
-equivalence on permissive nominal terms closer to `informal practice'.
The reader may consider -abstraction and -equivalence so familiar as to be
`solved problems'. The work embodied in this thesis stands testament to the fact
that this isn't the case. Considering -abstraction and -equivalence in the context
of two levels of variable poses some new and interesting problems and throws light
on some deep questions related to scope and binding
Polarities & Focussing: a journey from Realisability to Automated Reasoning
This dissertation explores the roles of polarities and focussing in various aspects of Computational Logic.These concepts play a key role in the the interpretation of proofs as programs, a.k.a. the Curry-Howard correspondence, in the context of classical logic. Arising from linear logic, they allow the construction of meaningful semantics for cut-elimination in classical logic, some of which relate to the Call-by-Name and Call-by-Value disciplines of functional programming. The first part of this dissertation provides an introduction to these interpretations, highlighting the roles of polarities and focussing. For instance: proofs of positive formulae provide structured data, while proofs of negative formulae consume such data; focussing allows the description of the interaction between the two kinds of proofs as pure pattern-matching. This idea is pushed further in the second part of this dissertation, and connected to realisability semantics, where the structured data is interpreted algebraically, and the consumption of such data is modelled with the use of an orthogonality relation. Most of this part has been proved in the Coq proof assistant.Polarities and focussing were also introduced with applications to logic programming in mind, where computation is proof-search. In the third part of this dissertation, we push this idea further by exploring the roles that these concepts can play in other applications of proof-search, such as theorem proving and more particularly automated reasoning. We use these concepts to describe the main algorithm of SAT-solvers and SMT-solvers: DPLL. We then describe the implementation of a proof-search engine called Psyche. Its architecture, based on the concept of focussing, offers a platform where smart techniques from automated reasoning (or a user interface) can safely and trustworthily be implemented via the use of an API
The lambda-context calculus (extended version)
AbstractWe present the Lambda Context Calculus. This simple lambda-calculus features variables arranged in a hierarchy of strengths such that substitution of a strong variable does not avoid capture with respect to abstraction by a weaker variable. This allows the calculus to express both capture-avoiding and capturing substitution (instantiation). The reduction rules extend the ‘vanilla’ lambda-calculus in a simple and modular way and preserve the look and feel of a standard lambda-calculus with explicit substitutions.Good properties of the lambda-calculus are preserved. The LamCC is confluent, and a natural injection into the LamCC of the untyped lambda-calculus exists and preserves strong normalisation.We discuss the calculus and its design with full proofs. In the presence of the hierarchy of variables, functional binding splits into a functional abstraction λ (lambda) and a name-binder и (new). We investigate how the components of this calculus interact with each other and with the reduction rules, with examples. In two more extended case studies we demonstrate how global state can be expressed, and how contexts and contextual equivalence can be naturally internalised using function application