The Contour Model Lambda Calculus Machine

This book – the first of two volumes – explores the syntactical constructs of the most common programming languages, and sheds a mathematical light on their semantics, while also providing an accurate presentation of the material aspects that interfere with coding. Concepts and Semantics of Programming Languages 1 is dedicated to functional and imperative features. Included is the formal study of the semantics of typing and execution; their acquisition is facilitated by implementation into OCaml and Python, as well as by worked examples. Data representation is considered in detail: endianness, pointers, memory management, union types and pattern-matching, etc., with examples in OCaml, C and C++. The second volume introduces a specific model for studying modular and object features and uses this model to present Ada and OCaml modules, and subsequently Java, C++, OCaml and Python classes and objects. This book is intended not only for computer science students and teachers but also seasoned programmers, who will find a guide to reading reference manuals and the foundations of program verification.

This paper proves correctness of Nöcker's method of strictness analysis, implemented in the Clean compiler, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work Clark, Hankin and Hunt did on the correctness of the abstract reduction rules in two aspects. Our correctness proof is based on a functional core language and a contextual semantics, thus proving a wider range of strictness-based optimizations as correct, and our method fully considers the cycle detection rules, which contribute to the strength of Nöcker's strictness analysis. Our algorithm SAL is a reformulation of Nöcker's strictness analysis algorithm in a functional core language LR. This is a higher order call-by-need lambda calculus with case , constructors, letrec , and seq , which is extended during strictness analysis by set constants like Top or Inf , denoting sets of expressions, which indicate different evaluation demands. It is also possible to define new set constants by recursive equations with a greatest fixpoint semantics. The operational semantics of LR is a small-step semantics. Equality of expressions is defined by a contextual semantics that observes termination of expressions. Basically, SAL is a nontermination checker. The proof of its correctness and hence of Nöcker's strictness analysis is based mainly on an exact analysis of the lengths of evaluations, i.e., normal-order reduction sequences to WHNF. The main measure being the number of “essential” reductions in evaluations. Our tools and results provide new insights into call-by-need lambda calculi, the role of sharing in functional programming languages, and into strictness analysis in general. The correctness result provides a foundation for Nöcker's strictness analysis in Clean, and also for its use in Haskell.

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.

In this paper, we give a general framework for the foundation of an operational (small step) semantics of object-based languages with an emphasis on functional and imperative issues. The framework allows classifying very naturally many object-based calculi according to their main implementation techniques of inheritance, namely delegation and embedding, and their particular strategies. This distinction comes easily from a choice in the rules. Our framework is founded on two previous works: λObj/+, a version of the Lambda Calculus of Objects of Fischer, Honsell, and Mitchell, for the object aspects, and λσaw of Benaissa, Lescanne, and Rose, for the description of the operational semantics and sharing. The former is the formalization of a small delegation-based language which contains both lambda calculus and object primitives to create, update, and send messages to objects, while the latter is designed to provide a generic description of functional language implementations and is based on a calculus of explicit substitution extended with addresses to deal with memory management. The framework is presented as a set of modules, each of which captures a particular aspect of object-calculi (functional vs. imperative, delegation vs. embedding, and any combination of them). Above all, it introduces and illustrates a new promising approach to formally reason about the operational semantics of languages with (possibly) mutable states.KeywordsDesign of functional and imperative object-oriented languagesoperational semanticsimplementation issuesmemory management

The aim of this work is to correlate two dierent approaches to the semantics of programming languages: game semantics and intersection type assignment systems (ITAS). Namely, we present an ITAS that provides the description of the semantic interpretation of a typed lambda calculus in a game model based on innocent strategies. Compared to the traditional ITAS used to describe the semantic interpretation in domain theoretic models, the ITAS presented in this paper has two main dierences: the introduction of a notion of labelling on moves, and the omission of several rules, i.e. the subtyping rules and some structural rules.

Complexity characterizations of attribute grammar languages

The abstract interpretation of programs relates the exact semantics of a programming language to a finite approximation of those semantics. In this article, we describe an approach to abstract interpretation that is based in logic and logic programming.Our approach consists of faithfully representing a transition system within logic and then manipulating this initial specification to create a logical approximation of the original specification. The objective is to derive a logical approximation that can be interpreted as a terminating forward-chaining logic program; this ensures that the approximation is finite and that, furthermore, an appropriate logic programming interpreter can implement the derived approximation.We are particularly interested in the specification of the operational semantics of programming languages in ordered logic, a technique we call substructural operational semantics (SSOS). We show that manifestly sound control flow and alias analyses can be derived as logical approximations of the substructural operational semantics of relevant languages.

We describe a first course in program verification and the semantics of programming languages developed for advanced undergraduate and beginning graduate students. The course is intended to support other courses in the curriculum that stress a disciplined approach to programming as well as to prepare students for more advanced courses in semantics and other areas such as software engineering and compiler technology. In order of emphasis, the course covers axiomatic, operational, translational, and denotational semantics. We discuss the development of the course, course prerequisites, the rationale for the selection of the topics covered, and the appropriateness of the course in the curriculum.

While the theory of functional higher-order languages, starting from lambda-calculi, is a well-established research field, it is only in recent years that the operational semantics of higher-order languages with probabilistic operators has started to be extensively studied. A fundamental notion in the semantics of programming languages is that of program equivalence. In higher-order languages, program equivalence is generally formalized as a contextual equivalence [Morris, 1968], which can be hard to prove directly. This has motivated the study of proof techniques for contextual equivalence, from inductive ones, such as logical relations [Andrew Pitts, 2005], to coinductive ones, mainly in the form of bisimulations [Abramsky, 1990]. In this talk I will discuss proof techniques for program equivalence in languages combining higher-order and probabilistic features. Several operational methods, traditionally developed in a deterministic setting, have been adapted to probabilistic higher-order languages [Ales Bizjak and Lars Birkedal, 2015; Dal Lago et al., 2014; Raphaëlle Crubillé and Ugo Dal Lago, 2014]. I will discuss these proof methods and focus on bisimulation-based techniques, showing how probabilities, combined with different language features, force a number of modifications to the definition of bisimulation [Crubillé et al., 2015; Sangiorgi and Vignudelli, 2016].

In this paper we discuss the semantics of a simple block-structured programming language which allows sharing or aliasing. Sharing, which arises naturally in procedural languages which permit certain forms of parameter passing, has typically been regarded as problematical for the semantic treatment of a language. Difficulties have been encountered in both denotational and axiomatic treatments of sharing in the literature. Nevertheless, we find that it is possible to define a clean and elegant formal semantics for sharing. The key to our success is the choice of semantic model; we show that conventional approaches based on locations are less than satisfactory for the purposes of reasoning about partial correctness, and that in a well defined sense locations are unnecessary.We begin by defining a denotational semantics for our programming language. The semantic model is not based on locations, but instead uses an abstract sharing relation on identifiers to represent the notion of aliasing, and uses an abstract state with a stack-like structure to capture the semantics of blocks and accurately model the scope rules. The semantics is shown to be fully abstract with respect to partial correctness properties, in contrast to conventional location-based models. This means that the semantics identifies terms if and only if they induce identical partial correctness behaviour in all program contexts. This property usually fails for location-based semantics because in such models it is possible to distinguish between terms on the basis of their effect on individual locations, which has no bearing on partial correctness.We believe that axiomatic reasoning about program behaviour should be based directly on a semantic model specifically tailored for that purpose; full abstraction with respect to an appropriate behavioural notion is a formal criterion against which to judge the suitability of a semantics. The structure of a semantic model should be used directly to suggest the structure of an assertion language for expressing program properties. With this in mind, we build a Hoare-style (syntax-directed) proof system for partial correctness properties of our programming language, and we prove soundness and relative completeness of this system. The proof system is built up in a hierarchical manner which reflects the syntactic and semantic structure of the programming language. We first design a proof system for declarations, and then use it in building proof rules for commands. We claim that our proof rules are conceptually simpler to understand than other rules proposed in the literature for aliasing, without losing any expressive power. We show, for example, that it is possible to define a “generic” inference rule for blocks which is uniformly applicable to3 blocks headed by different forms of declaration. The important point here is that, unlike most of the proof systems for these constructs in the literature, we do not have to design a separate rule for blocks for each possible form of declaration. This results in greater flexibility and adaptability in our proof system. We demonstrate that some well known rules from the literature for blocks can be derived in our system.

This paper provides an analysis of the meaning–reference problem, as traditionally advanced in the philosophy of language, for imperative programming languages. Addressing the problem is relevant for the philosophy of computer science in the context of the debate of whether simulative programs can be considered representational theories of their simulated systems. This paper challenges the thesis that, since programming languages have semantics, they also have reference, presumably to the external world. First, denotational, operational, game theoretic, and axiomatic semantics are epistemologically analysed to provide a theory of meaning for high-level language programs. It is argued that programming language semantics can be seen, to some extent, under the light of Fregean descriptivism, thereby rejecting the view that it is reference that determines meaning. Secondly, descriptivist, causal, character, and intentionalist theories of reference are examined to argue that meaning is not sufficient for programming languages to determine reference, thereby rejecting the view that meaning determines reference. It is argued that it is the intentions of agents that allow programming language semantics to identify referents. The paper concludes that if the semantics of programming languages may determine their reference, the latter is not to the external world but to the internal operations of the implementation executing them. This does not prevent simulative programs from representing empirical systems, but they do so not on the basis of programming language semantics.

The theory and semantics of programming languages are typically formulated using abstract mathematical models that have no obvious connection to any physical theory. While this approach has a number of advantages, it does not generalize to complex nondiscrete systems, and it obscures the underlying mathematical connections between computational and physical theory. Moreover, it can lead to inaccurate models of more complex phenomena such as concurrency. In this paper, we describe the current directions and initial results of our efforts to build connections between programming language theory and semantics and physical theory. The first and most mature of these efforts aims to develop a denotational semantic model that expands upon the mathematical formulation of quantum systems to provide a denotational foundation for concurrent languages. The second effort aims to generalize the notion of type systems to a probability inference system based on Bayesian probability. The third and final effort aims to develop an understanding of the dynamics of concurrent processes, with the goal of reasoning about the real behavior of processes in greater detail. In each of these efforts, we aim to draw connections between computing and other scientific disciplines.

While much of the current study on quantum computation employs low-level formalisms such as quantum circuits, several high-level languages/calculi have been recently proposed aiming at structured quantum programming. The current work contributes to the semantical study of such languages, by providing interaction-based semantics of a functional quantum programming language, the latter is based on linear lambda calculus and is equipped with features like the! modality and recursion. The proposed denotational model is the first one that supports the full features of a quantum functional programming language, we also prove adequacy of our semantics. The construction of our model is by a series of existing techniques taken from the semantics of classical computation as well as from process theory. The most notable among them is Girard's Geometry of Interaction (GoI), categorically formulated by Abramsky, Haghverdi and Scott. The mathematical genericity of these techniques - largely dueto their categorical formulation - is exploited for our move from classical to quantum.

We apply Dijkstra’s semantics for programming languages [Dijkstra, 1976; Dijkstra and Scholten, 1990] to formalization of reasoning about action and change. The basic idea is to specify effects of actions in terms of formula transformers, i.e. functions from formulae into formulae.1 More specifically, with each action A we associate two formula transformers, called the strongest postcondition for A and the weakest liberal precondition for A. The former, when applied to a formula α, returns a formula representing the set of all states that can be achieved by starting execution of A in some state satisfying α. The latter, when applied to a formula α, returns a formula providing a description of all states such that whenever execution of A starts in any one of them and terminates, the output state satisfies α 2.

Semantics of programming languages: Using Asf+Sdf