44 research outputs found
Towards Correctness of Program Transformations Through Unification and Critical Pair Computation
Correctness of program transformations in extended lambda calculi with a
contextual semantics is usually based on reasoning about the operational
semantics which is a rewrite semantics. A successful approach to proving
correctness is the combination of a context lemma with the computation of
overlaps between program transformations and the reduction rules, and then of
so-called complete sets of diagrams. The method is similar to the computation
of critical pairs for the completion of term rewriting systems. We explore
cases where the computation of these overlaps can be done in a first order way
by variants of critical pair computation that use unification algorithms. As a
case study we apply the method to a lambda calculus with recursive
let-expressions and describe an effective unification algorithm to determine
all overlaps of a set of transformations with all reduction rules. The
unification algorithm employs many-sorted terms, the equational theory of
left-commutativity modelling multi-sets, context variables of different kinds
and a mechanism for compactly representing binding chains in recursive
let-expressions.Comment: In Proceedings UNIF 2010, arXiv:1012.455
Adequacy of compositional translations for observational semantics
We investigate methods and tools for analysing translations between programming languages with respect to observational semantics. The behaviour of programs is observed in terms of may- and must-convergence in arbitrary contexts, and adequacy of translations, i.e., the reflection of program equivalence, is taken to be the fundamental correctness condition. For compositional translations we propose a notion of convergence equivalence as a means for proving adequacy. This technique avoids explicit reasoning about contexts, and is able to deal with the subtle role of typing in implementations of language extension
From IF to BI: a tale of dependence and separation
We take a fresh look at the logics of informational dependence and
independence of Hintikka and Sandu and Vaananen, and their compositional
semantics due to Hodges. We show how Hodges' semantics can be seen as a special
case of a general construction, which provides a context for a useful
completeness theorem with respect to a wider class of models. We shed some new
light on each aspect of the logic. We show that the natural propositional logic
carried by the semantics is the logic of Bunched Implications due to Pym and
O'Hearn, which combines intuitionistic and multiplicative connectives. This
introduces several new connectives not previously considered in logics of
informational dependence, but which we show play a very natural role, most
notably intuitionistic implication. As regards the quantifiers, we show that
their interpretation in the Hodges semantics is forced, in that they are the
image under the general construction of the usual Tarski semantics; this
implies that they are adjoints to substitution, and hence uniquely determined.
As for the dependence predicate, we show that this is definable from a simpler
predicate, of constancy or dependence on nothing. This makes essential use of
the intuitionistic implication. The Armstrong axioms for functional dependence
are then recovered as a standard set of axioms for intuitionistic implication.
We also prove a full abstraction result in the style of Hodges, in which the
intuitionistic implication plays a very natural r\^ole.Comment: 28 pages, journal versio
Bisimilarity as a Theory of Functional Programming
AbstractMorris-style contextual equivalence â invariance of termination under any context of ground type â is the usual notion of operational equivalence for deterministic functional languages such as FPC (PCF plus sums, products and recursive types). Contextual equivalence is hard to establish directly. Instead we define a labelled transition system for call-by-name FPC (and variants) and prove that CCS-style bisimilarity equals contextual equivalence â a form of operational extensionality. Using co-induction we establish equational laws for FPC. By considering variations of Milner's âbisimulations up to âŒâ we obtain a second co-inductive characterisation of contextual equivalence in terms of reduction behaviour and production of values. Hence we use co-inductive proofs to establish contextual equivalence in a series of stream-processing examples. Finally, we consider a form of Milner's original context lemma for FPC, but conclude that our form of bisimilarity supports simpler co-inductive proofs
Preliminary draft
is permitted for educational or research use on condition that this copyright notice is included in any copy. See back inner page for a list of recent publications in the BRICS Report Series. Copies may be obtained by contacting: BRIC
Processes, Systems \& Tests: Defining Contextual Equivalences
In this position paper, we would like to offer and defend a new template to
study equivalences between programs -- in the particular framework of process
algebras for concurrent computation.We believe that our layered model of
development will clarify the distinction that is too often left implicit
between the tasks and duties of the programmer and of the tester. It will also
enlighten pre-existing issues that have been running across process algebras as
diverse as the calculus of communicating systems, the -calculus -- also
in its distributed version -- or mobile ambients.Our distinction starts by
subdividing the notion of process itself in three conceptually separated
entities, that we call \emph{Processes}, \emph{Systems} and \emph{Tests}.While
the role of what can be observed and the subtleties in the definitions of
congruences have been intensively studied, the fact that \emph{not every
process can be tested}, and that \emph{the tester should have access to a
different set of tools than the programmer} is curiously left out, or at least
not often formally discussed.We argue that this blind spot comes from the
under-specification of contexts -- environments in which comparisons takes
place -- that play multiple distinct roles but supposedly always \enquote{stay
the same}.We illustrate our statement with a simple Java example, the
\enquote{usual} concurrent languages, but also back it up with
-calculus and existing implementations of concurrent languages as
well