977 research outputs found
Combining and Relating Control Effects and their Semantics
Combining local exceptions and first class continuations leads to programs
with complex control flow, as well as the possibility of expressing powerful
constructs such as resumable exceptions. We describe and compare games models
for a programming language which includes these features, as well as
higher-order references. They are obtained by contrasting methodologies: by
annotating sequences of moves with "control pointers" indicating where
exceptions are thrown and caught, and by composing the exceptions and
continuations monads.
The former approach allows an explicit representation of control flow in
games for exceptions, and hence a straightforward proof of definability (full
abstraction) by factorization, as well as offering the possibility of a
semantic approach to control flow analysis of exception-handling. However,
establishing soundness of such a concrete and complex model is a non-trivial
problem. It may be resolved by establishing a correspondence with the monad
semantics, based on erasing explicit exception moves and replacing them with
control pointers.Comment: In Proceedings COS 2013, arXiv:1309.092
Applying quantitative semantics to higher-order quantum computing
Finding a denotational semantics for higher order quantum computation is a
long-standing problem in the semantics of quantum programming languages. Most
past approaches to this problem fell short in one way or another, either
limiting the language to an unusably small finitary fragment, or giving up
important features of quantum physics such as entanglement. In this paper, we
propose a denotational semantics for a quantum lambda calculus with recursion
and an infinite data type, using constructions from quantitative semantics of
linear logic
Abstract Hidden Markov Models: a monadic account of quantitative information flow
Hidden Markov Models, HMM's, are mathematical models of Markov processes with
state that is hidden, but from which information can leak. They are typically
represented as 3-way joint-probability distributions.
We use HMM's as denotations of probabilistic hidden-state sequential
programs: for that, we recast them as `abstract' HMM's, computations in the
Giry monad , and we equip them with a partial order of increasing
security. However to encode the monadic type with hiding over some state
we use rather
than the conventional that suffices for
Markov models whose state is not hidden. We illustrate the
construction with a small
Haskell prototype.
We then present uncertainty measures as a generalisation of the extant
diversity of probabilistic entropies, with characteristic analytic properties
for them, and show how the new entropies interact with the order of increasing
security. Furthermore, we give a `backwards' uncertainty-transformer semantics
for HMM's that is dual to the `forwards' abstract HMM's - it is an analogue of
the duality between forwards, relational semantics and backwards,
predicate-transformer semantics for imperative programs with demonic choice.
Finally, we argue that, from this new denotational-semantic viewpoint, one
can see that the Dalenius desideratum for statistical databases is actually an
issue in compositionality. We propose a means for taking it into account
Abstract Diagnosis for Timed Concurrent Constraint programs
The Timed Concurrent Constraint Language (tccp in short) is a concurrent
logic language based on the simple but powerful concurrent constraint paradigm
of Saraswat. In this paradigm, the notion of store-as-value is replaced by the
notion of store-as-constraint, which introduces some differences w.r.t. other
approaches to concurrency. In this paper, we provide a general framework for
the debugging of tccp programs. To this end, we first present a new compact,
bottom-up semantics for the language that is well suited for debugging and
verification purposes in the context of reactive systems. We also provide an
abstract semantics that allows us to effectively implement debugging algorithms
based on abstract interpretation. Given a tccp program and a behavior
specification, our debugging approach automatically detects whether the program
satisfies the specification. This differs from other semiautomatic approaches
to debugging and avoids the need to provide symptoms in advance. We show the
efficacy of our approach by introducing two illustrative examples. We choose a
specific abstract domain and show how we can detect that a program is
erroneous.Comment: 16 page
- …