1,813 research outputs found
Step-Indexed Relational Reasoning for Countable Nondeterminism
Programming languages with countable nondeterministic choice are
computationally interesting since countable nondeterminism arises when modeling
fairness for concurrent systems. Because countable choice introduces
non-continuous behaviour, it is well-known that developing semantic models for
programming languages with countable nondeterminism is challenging. We present
a step-indexed logical relations model of a higher-order functional programming
language with countable nondeterminism and demonstrate how it can be used to
reason about contextually defined may- and must-equivalence. In earlier
step-indexed models, the indices have been drawn from {\omega}. Here the
step-indexed relations for must-equivalence are indexed over an ordinal greater
than {\omega}
Data Definitions in the ACL2 Sedan
We present a data definition framework that enables the convenient
specification of data types in ACL2s, the ACL2 Sedan. Our primary motivation
for developing the data definition framework was pedagogical. We were teaching
undergraduate students how to reason about programs using ACL2s and wanted to
provide them with an effective method for defining, testing, and reasoning
about data types in the context of an untyped theorem prover. Our framework is
now routinely used not only for pedagogical purposes, but also by advanced
users.
Our framework concisely supports common data definition patterns, e.g. list
types, map types, and record types. It also provides support for polymorphic
functions. A distinguishing feature of our approach is that we maintain both a
predicative and an enumerative characterization of data definitions.
In this paper we present our data definition framework via a sequence of
examples. We give a complete characterization in terms of tau rules of the
inclusion/exclusion relations a data definition induces, under suitable
restrictions. The data definition framework is a key component of
counterexample generation support in ACL2s, but can be independently used in
ACL2, and is available as a community book.Comment: In Proceedings ACL2 2014, arXiv:1406.123
Logical relations for coherence of effect subtyping
A coercion semantics of a programming language with subtyping is typically
defined on typing derivations rather than on typing judgments. To avoid
semantic ambiguity, such a semantics is expected to be coherent, i.e.,
independent of the typing derivation for a given typing judgment. In this
article we present heterogeneous, biorthogonal, step-indexed logical relations
for establishing the coherence of coercion semantics of programming languages
with subtyping. To illustrate the effectiveness of the proof method, we develop
a proof of coherence of a type-directed, selective CPS translation from a typed
call-by-value lambda calculus with delimited continuations and control-effect
subtyping. The article is accompanied by a Coq formalization that relies on a
novel shallow embedding of a logic for reasoning about step-indexing
Logical Step-Indexed Logical Relations
Appel and McAllester's "step-indexed" logical relations have proven to be a
simple and effective technique for reasoning about programs in languages with
semantically interesting types, such as general recursive types and general
reference types. However, proofs using step-indexed models typically involve
tedious, error-prone, and proof-obscuring step-index arithmetic, so it is
important to develop clean, high-level, equational proof principles that avoid
mention of step indices. In this paper, we show how to reason about binary
step-indexed logical relations in an abstract and elegant way. Specifically, we
define a logic LSLR, which is inspired by Plotkin and Abadi's logic for
parametricity, but also supports recursively defined relations by means of the
modal "later" operator from Appel, Melli\`es, Richards, and Vouillon's "very
modal model" paper. We encode in LSLR a logical relation for reasoning
relationally about programs in call-by-value System F extended with general
recursive types. Using this logical relation, we derive a set of useful rules
with which we can prove contextual equivalence and approximation results
without counting steps
Practical Subtyping for System F with Sized (Co-)Induction
We present a rich type system with subtyping for an extension of System F.
Our type constructors include sum and product types, universal and existential
quantifiers, inductive and coinductive types. The latter two size annotations
allowing the preservation of size invariants. For example it is possible to
derive the termination of the quicksort by showing that partitioning a list
does not increase its size. The system deals with complex programs involving
mixed induction and coinduction, or even mixed (co-)induction and polymorphism
(as for Scott-encoded datatypes). One of the key ideas is to completely
separate the induction on sizes from the notion of recursive programs. We use
the size change principle to check that the proof is well-founded, not that the
program terminates. Termination is obtained by a strong normalization proof.
Another key idea is the use symbolic witnesses to handle quantifiers of all
sorts. To demonstrate the practicality of our system, we provide an
implementation that accepts all the examples discussed in the paper and much
more
A Compositional Treatment of Polysemous Arguments in Categorial Grammar
We discuss an extension of the standard logical rules (functional application
and abstraction) in Categorial Grammar (CG), in order to deal with some
specific cases of polysemy. We borrow from Generative Lexicon theory which
proposes the mechanism of {\em coercion}, next to a rich nominal lexical
semantic structure called {\em qualia structure}.
In a previous paper we introduced coercion into the framework of {\em
sign-based} Categorial Grammar and investigated its impact on traditional
Fregean compositionality. In this paper we will elaborate on this idea, mostly
working towards the introduction of a new semantic dimension. Where in current
versions of sign-based Categorial Grammar only two representations are derived:
a prosodic one (form) and a logical one (modelling), here we introduce also a
more detaled representation of the lexical semantics. This extra knowledge will
serve to account for linguistic phenomena like {\em metonymy\/}.Comment: LaTeX file, 19 pages, uses pubsmacs, pubsbib, pubsarticle, leqn
A generic operational metatheory for algebraic effects
We provide a syntactic analysis of contextual preorder and equivalence for a polymorphic programming language with effects. Our approach applies uniformly across a range of algebraic effects, and incorporates, as instances: errors, input/output, global state, nondeterminism, probabilistic choice, and combinations thereof. Our approach is to extend Plotkin and Power’s structural operational semantics for algebraic effects (FoSSaCS 2001) with a primitive “basic preorder” on ground type computation trees. The basic preorder is used to derive notions of contextual preorder and equivalence on program terms. Under mild assumptions on this relation, we prove fundamental properties of contextual preorder (hence equivalence) including extensionality properties and a characterisation via applicative contexts, and we provide machinery for reasoning about polymorphism using relational parametricity
Aspect-Oriented Programming with Type Classes
We consider the problem of adding aspects to a strongly typed language which supports type classes. We show that type classes as supported by the Glasgow Haskell Compiler can model an AOP style of programming via a simple syntax-directed transformation scheme where AOP programming idioms are mapped to type classes. The drawback of this approach is that we cannot easily advise functions in programs which carry type annotations. We sketch a more principled approach which is free of such problems by combining ideas from intentional type analysis with advanced overloading resolution strategies. Our results show that type-directed static weaving is closely related to type class resolution -- the process of typing and translating type class programs
- …