14 research outputs found
A Realizability Model for Impredicative Hoare Type Theory
We present a denotational model of impredicative Hoare Type Theory, a very expressive dependent type theory in which one can specify and reason about mutable abstract data types.
The model ensures soundness of the extension of Hoare Type Theory with impredicative polymorphism; makes the connections to separation logic clear, and provides a basis for investigation of further sound extensions of the theory, in particular equations between computations and types.Engineering and Applied Science
Relating Two Semantics of Locally Scoped Names
The operational semantics of programming constructs involving locally
scoped names typically makes use of stateful "dynamic allocation": a
set of currently-used names forms part of the state and upon entering
a scope the set is augmented by a new name bound to the scoped
identifier. More abstractly, one can see this as a transformation of
local scopes by expanding them outward to an implicit top-level. By
contrast, in a neglected paper from 1994, Odersky gave a stateless
lambda calculus with locally scoped names whose dynamics contracts
scopes inward. The properties of "Odersky-style" local names are quite
different from dynamically allocated ones and it has not been clear,
until now, what is the expressive power of Odersky\u27s notion. We show
that in fact it provides a direct semantics of locally scoped names
from which the more familiar dynamic allocation semantics can be
obtained by continuation-passing style (CPS) translation. More
precisely, we show that there is a CPS translation of typed lambda
calculus with dynamically allocated names (the Pitts-Stark
nu-calculus) into Odersky\u27s lambda-nu-calculus which is
computationally adequate with respect to observational equivalence in
the two calculi
Relational Parametricity and Separation Logic
Separation logic is a recent extension of Hoare logic for reasoning about
programs with references to shared mutable data structures. In this paper, we
provide a new interpretation of the logic for a programming language with
higher types. Our interpretation is based on Reynolds's relational
parametricity, and it provides a formal connection between separation logic and
data abstraction
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
Nominal Logic Programming
Nominal logic is an extension of first-order logic which provides a simple
foundation for formalizing and reasoning about abstract syntax modulo
consistent renaming of bound names (that is, alpha-equivalence). This article
investigates logic programming based on nominal logic. We describe some typical
nominal logic programs, and develop the model-theoretic, proof-theoretic, 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 examples.Comment: 46 pages; 19 page appendix; 13 figures. Revised journal submission as
of July 23, 200
Proof-relevant logical relations for name generation
Pitts and Stark's nu-calculus is a paradigmatic total language for studying the problem of contextual equivalence in higher-order languages with name generation. Models for the nu-calculus that validate basic equivalences concerning names may be constructed using functor categories or nominal sets, with a dynamic allocation monad used to model computations that may allocate fresh names. If recursion is added to the language and one attempts to adapt the models from (nominal) sets to(nominal)domains, however, the direct-style construction of the allocation monad no longer works. This issue has previously been addressed by using a monad that combines dynamic allocation with continuations, at some cost to abstraction. This paper presents a direct-style model of a nu-calculus-like language with recursion using the novel framework of proof-relevant logical relations, in which logical relations also contain objects (or proofs) demonstrating the equivalence of (the semantic counterparts of) programs. Apart from providing a fresh solution to an old problem, this work provides an accessible setting in which to introduce the use of proof-relevant logical relations, free of the additional complexities associated with their use for more sophisticated languages
Denotational semantics with nominal scott domains
When defining computations over syntax as data, one often runs into tedious issues concerning
α
-equivalence and semantically correct manipulations of binding constructs. Here we study a semantic framework in which these issues can be dealt with automatically by the programming language. We take the user-friendly ânominalâ approach in which bound objects are named. In particular, we develop a version of Scott domains within nominal sets and define two programming languages whose denotational semantics are based on those domains. The first language,
λΜ
-PCF, is an extension of Plotkinâs PCF with names that can be swapped, tested for equality and locally scoped; although simple, it already exposes most of the semantic subtleties of our approach. The second language, PNA, extends the first with name abstraction and concretion so that it can be used for metaprogramming over syntax with binders.
For both languages, we prove a full abstraction result for nominal Scott domains analogous to Plotkinâs classic result about PCF and conventional Scott domains: two program phrases have the same observable operational behaviour in all contexts if and only if they denote equal elements of the nominal Scott domain model. This is the first full abstraction result we know of for languages combining higher-order functions with some form of locally scoped names which uses a domain theory based on ordinary extensional functions, rather than using the more intensional approach of game semantics.
To obtain full abstraction, we need to add two functionals, one for existential quantification over names and one for âdefinite descriptionâ over names. Only adding one of them is not enough, as we give counter-examples to full abstraction in both cases.This work is supported by a Gates Cambridge Scholarship and the ERC Advanced Grant Events, Causality and Symmetry (ECSYM)This version is the author accepted manuscript. The final version is available from ACM at http://dl.acm.org/citation.cfm?id=2629529