Continuation Semantics Research Articles

Continuous semantics for strong normalisation

We prove a general strong normalisation theorem for higher type rewrite systems based on Tait's strong computability predicates and a strictly continuous domain-theoretic semantics. The theorem applies to extensions of Godel's system T, but also to various forms of barrecursion for which strong normalisation was hitherto unknown.

On the expressiveness of MTL in the pointwise and continuous semantics

We show that the pointwise version of the logic MTL is strictly less expressive than the continuous version, over finitewords. The proof is constructive in that we exhibit a timed language, which is definable in the continuous semantics but is not definable in the pointwise semantics.

Surgical scenario for laparoscopic surgery with timed automata

In this paper we show that the satisfaction of timed CTL (TCTL) formulas under the natural continuous semantics for both discrete-time and dense-time timed Kripke structures can be reduced to a model-checking problem in the pointwise semantics for a large class of timed Kripke structures, which includes many discrete-event systems. We then present a TCTL model checking algorithm for the pointwise case. An important consequence of our results is that they together describe a sound and complete TCTL model checking procedure for time-robust real-time rewrite theories also for dense time domains. We have implemented such a TCTL model checker for Real-Time Maude. Our model checker provides for free a sound and complete TCTL model checker for subsets of modeling languages, such as Ptolemy II and (Synchronous) AADL, which have Real-Time Maude analysis integrated into their tool environments.

Provably Correct Code Generation: A Case Study

Provably correct compilation is an important aspect in development of high assurance software systems. In this paper we present an approach to provably correct compilation based on Horn logical semantics of programming languages and partial evaluation. We also show that continuation semantics can be expressed in the Horn logical framework, and introduce Definite Clause Semantics. We illustrate our approach by developing the semantics for the SCR specification language, and using it to (automatically) generate target code in a provably correct manner.

Map Theory: From Well-Foundation to Antifoundation

Map Theory is a powerful extension of type-free lamba-calculus (with only a few term constants added). Due to Klaus Grue, it was designed to be a common foundation for Computer Sciences and for Mathematics. All the primitive notions of first-order logic and set theory, including truth values, connectives and quantifiers, set-membership and set-equality, are interpreted as terms. All the usual set-theoretic constructs, including inductive data-types, get computational interpretations. Now, Grue’s version of Map Theory is founded, in the sense that it only considers mathematical sets or classes which are well-founded with respect to the membership relation. In [19], we have shown that it was possible to design an alternative version which takes non-well-founded sets into account, and allows for co-inductive reasoning over them. This new version opens the way to a direct representation of co-inductive data-types and of circular processes and phenomena in Map Theory. In this article, we give parallel presentations of the two versions of Map Theory and of their relations with ZFC. We also give a flavor of the proofs of their relative consistency with respect to the existence of a strongly inaccessible cardinal. These proofs take place inside the κ-continuous semantics, which is an extension of Scott’s continuous semantics (where κ = ω) to any regular cardinal κ.

Building continuous webbed models for system F

We present here a large family of concrete models for Girard and Reynolds polymorphism (system F), in a noncategorical setting. The family generalizes the construction of the model of Barbanera and Berardi (Tech. Report, University of Turin, 1997), hence it contains complete models for Fη (A βη-complete model for system F, preprint, June, 1998) and we conjecture that it contains models which are complete for F. It also contains simpler models, the simplest of them, E 2 , being a second-order variant of the Engeler–Plotkin model E . All the models here belong to the continuous semantics and have underlying prime algebraic domains, all have the maximum number of polymorphic maps. The class contains models which can be viewed as two intertwined compatible webbed models of untyped λ-calculus (in the sense of Berline (From computations to foundations: the λ-calculus and its webbed models, revised version, Theoret. Comput. Sci. 86 pp., to appear)), but it is much larger than this. Finally, many of its models might be read as two intertwined strict intersection type systems.

Completeness of Continuation Models for λμ-Calculus

We show that a certain simple call-by-name continuation semantics of Parigot's λ μ -calculus is complete. More precisely, for every λ μ -theory we construct a cartesian closed category such that the ensuing continuation-style interpretation of λ μ , which maps terms to functions sending abstract continuations to responses, is full and faithful. Thus, any λ μ -category in the sense of L. Ong (1996, in “Proceedings of LICS '96,” IEEE Press, New York) is isomorphic to a continuation model (Y. Lafont, B. Reus, and T. Streicher, “Continuous Semantics or Expressing Implication by Negation,” Technical Report 93-21, University of Munich) derived from a cartesian-closed category of continuations. We also extend this result to a later call-by-value version of λ μ developed by C.-H. L. Ong and C. A. Stewart (1997, in “Proceedings of ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Paris, January 1997,” Assoc. Comput. Mach. Press, New York).

A Continuation Semantics of Interrogatives That Accounts for Baker's Ambiguity

No abstract.

A unifying approach to goal-directed evaluation

Goal-directed evaluation, as embodied in Icon and Snobol, is built on the notions of backtracking and of generating successive results, and therefore it has always been something of a challenge to specify and implement. In this article, we address this challenge using computational monads and partial evaluation.We consider a subset of Icon and we specify it with a monadic semantics and a list monad. We then consider a spectrum of monads that also fit the bill, and we relate them to each other. For example, we derive a continuation monad as a Church encoding of the list monad. The resulting semantics coincides with Gudeman's continuation semantics of Icon.We then compile Icon programs by specializing their interpreter (i.e., by using the first Futamura projection), using type-directed partial evaluation. Through various back ends, including a run-time code generator, we generate ML code, C code, and OCaml byte code. Binding-time analysis and partial evaluation of the continuation-based interpreter automatically give rise to C programs that coincide with the result of Proebsting's optimized compiler.

A Unifying Approach to Goal-Directed Evaluation

Goal-directed evaluation, as embodied in Icon and Snobol, is built on the notions of backtracking and of generating successive results, and therefore it has always been something of a challenge to specify and implement. In this article, we address this challenge using computational monads and partial evaluation.<br /> <br />We consider a subset of Icon and we specify it with a monadic semantics and a list monad. We then consider a spectrum of monads that also fit the bill, and we relate them to each other. For example, we derive a continuation monad as a Church encoding of the list monad. The resulting semantics coincides with Gudeman's continuation semantics of Icon.<br /> <br />We then compile Icon programs by specializing their interpreter (i.e., by using the first Futamura projection), using type-directed partial evaluation. Through various back ends, including a run-time code generator, we generate ML code, C code, and OCaml byte code. Binding-time analysis and partial evaluation of the continuation-based interpreter automatically give rise to C programs that coincide with the result of Proebsting's optimized compiler.

Domain-Freeλµ-Calculus

We introduce a domain-free λµ-calculus of call-by-value as a short-hand for the second order Church-style. Our motivation comes from the observation that in Curry-style polymorphic calculi, control operators such as callcc-operators cannot, in general, handle correctly the terms placed on the control operator's left, so that the Curry-style system can fail to prove the subject reduction property. Following the continuation semantics, we also discuss the notion of values in classical system, and propose an extended form of values. It is proved that the CPS-translation is sound with respect to domain-free λ2 (second-order λ-calculus). As a by-product, we obtain the strong normalization property for the second-order λµ-calculus of call-by-value in domain-free style. We also study the problems of type inference, typability, and type checking for the call-by-value system. Finally, we give a brief comparison with standard ML plus callcc, and discuss a natural way to avoid the unsoundness of ML with callcc.

Functional reactive programming from first principles

Functional Reactive Programming , or FRP , is a general framework for programming hybrid systems in a high-level, declarative manner. The key ideas in FRP are its notions of behaviors and events . Behaviors are time-varying, reactive values, while events are time-ordered sequences of discrete-time event occurrences. FRP is the essence of Fran , a domain-specific language embedded in Haskell for programming reactive animations, but FRP is now also being used in vision, robotics and other control systems applications. In this paper we explore the formal semantics of FRP and how it relates to an implementation based on streams that represent (and therefore only approximate) continuous behaviors. We show that, in the limit as the sampling interval goes to zero, the implementation is faithful to the formal, continuous semantics, but only when certain constraints on behaviors are observed. We explore the nature of these constraints, which vary amongst the FRP primitives. Our results show both the power and limitations of this approach to language design and implementation. As an example of a limitation, we show that streams are incapable of representing instantaneous predicate events over behaviors.

Metric Semantics for Synchronous and Asynchronous Communication: A Continuation-based Approach

We introduce a technique - that we name continuation semantics for concurrency (CSC) - which can be used to model both sequential and parallel composition (in interleaving semantics) while providing the general advantages of the technique of continuations. We apply the CSC technique in designing operational and denotational models for two simple nonuniform concurrent languages: syn and asyn. syn provides CSP-like synchronous communication. asyn provides a mechanism for asynchronous communication. The operational and the denotational models are defined and related by using techniques from metric semantics.Our work was clearly inspired by the methodology for the design of control flow semantics advocated by the Amsterdam Concurrency Group, headed by Jaco de Bakker. We are specially grateful to Jaco de Bakker, Jan Rutten and Erik de Vink for their scientific support. The anonymous referees are thanked for their constructive comments.

Building continuous webbed models for system F

We present here a large family of concrete models for Girard and Reynolds polymorphism (System F), in a non categorical setting. The family generalizes the construction of the model of Barbanera and Berardi [2], hence it contains complete models for Fη [5] and we conjecture that it contains models which are complete for F. It also contains simpler models, the simplest of them, ε2, being a second order variant of the Engeler-Plotkin model ε. All the models here belong to the continuous semantics and have underlying prime algebraic domains, all have the maximum number of polymorphic maps. The class contains models which can be viewed as two intertwined compatible webbed models of untyped λ-calculus (in the sense of [8]), but it is much larger than this. Finally many of its models might be read as two intertwined strict intersection type systems.

Deriving Proof Rules from Continuation Semantics

Abstract. We claim that a continuation style semantics of a programming language can provide a starting point for constructing its proof system. The basic idea is to see weakest preconditions as a particular instance of continuation style semantics, hence to interpret correctness assertions (e.g. Hoare triples { p } C { r }) as inequalities over continuations. This approach also shows a correspondence between labels in a program and annotations.

An Operational Investigation of the CPS Hierarchy

We explore the hierarchy of control induced by successive transformations into continuation-passing style (CPS) in the presence of "control delimiters'' and "composable continuations''. Specifically, we investigate the structural operational semantics associated with the CPS hierarchy.<br /> <br />To this end, we characterize an operational notion of continuation semantics. We relate it to the traditional CPS transformation and we use it to account for the control operator shift and the control delimiter reset operationally. We then transcribe the resulting continuation semantics in ML, thus obtaining a native and modular implementation of the entire hierarchy. We illustrate it with a few examples, the most significant of which is layered monads.<br /><br />P.S. Not published. No full text available.

Classical logic, continuation semantics and abstract machines

One of the goals of this paper is to demonstrate that denotational semantics is useful for operational issues like implementation of functional languages by abstract machines. This is exemplified in a tutorial way by studying the case of extensional untyped call-by-name λ-calculus with Felleisen's control operator [Cscr ]. We derive the transition rules for an abstract machine from a continuation semantics which appears as a generalization of the ¬¬-translation known from logic. The resulting abstract machine appears as an extension of Krivine's machine implementing head reduction. Though the result, namely Krivine's machine, is well known our method of deriving it from continuation semantics is new and applicable to other languages (as e.g. call-by-value variants). Further new results are that Scott's D∞-models are all instances of continuation models. Moreover, we extend our continuation semantics to Parigot's λμ-calculus from which we derive an extension of Krivine's machine for λμ-calculus. The relation between continuation semantics and the abstract machines is made precise by proving computational adequacy results employing an elegant method introduced by Pitts.

Continuous functions and neural network semantics

Continuous functions and neural network semantics

Continuation Semantics and Self-adjointness

We give an abstract categorical presentation of continuation semantics by taking the continuation type constructor ¬ (or cont in Standard ML of New Jersey) as primitive. This constructor on types extends to a contravariant functor on terms which is adjoint to itself on the left; restricted to the subcategory of those programs that do not manipulate the current continuation, it is adjoint to itself on the right.The motivating example of such a category is built from (equivalence classes of typing judgements for) continuation passing style (CPS) terms.A call-by-value λ-calculus with the control operator callcc as well as a call-by-name λ-calculus can be interpreted. Arrow types are broken down into continuation types for argument/result-continuations pairs. Specialising the semantics to the CPS term model allows a reconstruction of CPS transforms.

Semantics directed program execution monitoring

AbstractMonitoring semanticsis a formal model of program execution which captures ‘monitoring activity’ as found in profilers, tracers, debuggers, etc. Beyond its theoretical interest, this formalism provides a new methodology for implementing a large family of source-level monitoring activities for sequential deterministic programming languages. In this article we explore the use of monitoring semantics in the specification and implementation of a variety of monitors: profilers, tracers, collecting interpreters, and, most importantly, interactive source-level debuggers. Although we consider such monitors only for (both strict and non-strict) functional languages, the methodology extends easily to imperative languages, since it begins with a continuation semantics specification.In addition, using standard partial evaluation techniques as an optimization strategy, we show that the methodology forms a practical basis for building real monitors. Our system can be optimized at two levels of specialization: specializing the interpreter with respect to a monitor specification automatically yields an instrumented interpreter; further specializing this instrumented interpreter with respect to a source program yields an instrumented program, i.e. one in which the extra code to perform monitoring has been automatically embedded into the program.