Algol-like Language Research Articles

Quantum Programming Made Easy

We present IQu, namely a quantum programming language that extends Reynold's Idealized Algol, the paradigmatic core of Algol-like languages. IQu combines imperative programming with high-order features, mediated by a simple type theory. IQu mildly merges its quantum features with the classical programming style that we can experiment through Idealized Algol, the aim being to ease a transition towards the quantum programming world. The proposed extension is done along two main directions. First, IQu makes the access to quantum co-processors by means of quantum stores. Second, IQu includes some support for the direct manipulation of quantum circuits, in accordance with recent trends in the development of quantum programming languages. Finally, we show that IQu is quite effective in expressing well-known quantum algorithms.

Automata-Theoretic Semantics of Idealized Algol with Passive Expressions

Passive expressions in Algol-like languages represent computations that read the state but do not modify it. The need for such read-only computations arises in programming logics as well as in concurrent programming. It is also a central facet in Reynoldsʼs Syntactic Control of Interference. Despite its importance and essentially basic character, capturing the notion of passivity in semantic models has proved to be difficult. In this paper, we provide a new model of passive expressions using an automata-theoretic framework recently proposed by the author. The central idea is that the store of a program is viewed as an abstract form of an automaton, with a representation of its states as well as state transitions. The framework allows us to combine the strengths of conventional state-based models and the more recent event-based models to synthesize new “automata-based” models. Once this basic framework is set up, relational parametricity does the job of identifying passive computations.

A fibrational framework for possible-world semantics of Algol-like languages

A fibrational framework for possible-world semantics of Algol-like languages

An approach to deciding the observational equivalence of Algol-like languages

We prove that the observational equivalence of third-order finitary (i.e. recursion-free) Idealized Algol (IA) is decidable using Game Semantics. By modelling the state explicitly in our games, we show that the denotation of a term M of this fragment of IA is a compactly innocent strategy-with-state, i.e. the strategy is generated by a finite view function f M . Given any such f M , we construct a real-time deterministic pushdown automaton (DPDA) that recognizes the complete plays of the knowing-strategy denotation of M. Since such plays characterize observational equivalence, and there is an algorithm for deciding whether any two DPDAs recognize the same language, we obtain a procedure for deciding the observational equivalence of third-order finitary IA. Restricted to second-order terms, the DPDA representation cuts down to a deterministic finite automaton; thus our approach gives a new proof of Ghica and McCusker’s regular-expression characterization for this fragment. Our algorithmic representation of program meanings, which is compositional, provides a foundation for model-checking a wide range of behavioural properties of IA and other cognate programming languages. Another result concerns second-order IA with full recursion: we show that observational equivalence for this fragment is undecidable.

The Essence of Parallel Algol

We consider a parallel Algol-like language, combining procedures with shared-variable parallelism. Procedures permit encapsulation of common parallel programming idioms. Local variables provide a way to restrict interference between parallel commands. The combination of local variables, procedures, and parallelism supports a form of concurrent object-oriented programming. We provide a denotational semantics for this language, simultaneously adapting possible worlds to the parallel setting and generalizing transition traces to the procedural setting. This semantics supports reasoning about safety and liveness properties of parallel programs, and validates a number of natural laws of program equivalence based on noninterference properties of local variables. The semantics also validates familiar laws of functional programming. We also provide a relationally parallel semantics. This semantics supports standard methods of reasoning about representational independence, adapted to shared-variable programs. The clean design of the programming language and its semantics shows that procedures and shared-variable parallelism can be combined smoothly.

Objects and Classes in Algol-Like Languages

Many object-oriented languages used in practice descend from Algol. With this motivation, we study the theoretical issues underlying such languages via the theory of Algol-like languages. It is shown that the basic framework of this theory extends cleanly and elegantly to the concepts of objects and classes. Moreover, a clear correspondence emerges between classes and abstract data types, whose theory corresponds to that of existential types. Equational and Hoare-like reasoning methods and relational parametricity provide powerful formal tools for reasoning about Algol-like object-oriented programs.

Predicate transformer semantics of a higher-order imperative language with record subtyping

Using a set-theoretic model of predicate transformers and ordered data types, we give a total-correctness semantics for a typed higher-order imperative programming language that includes record extension, local variables, and procedure-type variables and parameters. The language includes infeasible specification constructs, for a calculus of refinement. Procedures may have global variables, subject to mild syntactic restrictions to avoid the semantic complications of Algol-like languages. The semantics is used to validate simple proof rules for non-interference, type extension, and calls of procedure variables and constants.

Syntactic control of interference revisited

In “syntactic control of interference” (POPL, 1978), J.C. Reynolds proposes three design principles intended to constrain the scope of imperative state effects in Algol-like languages. The resulting linguistic framework seems to be a very satisfactory way of combining functional and imperative concepts, having the desirable attributes of both purely functional languages (such as PCF) and simple imperative languages (such as the language of while programs). However, Reynolds points out that the “obvious” syntax for interference control has the unfortunate property that β-reductions do not always preserve typings. Reynolds has subsequently presented a solution to this problem (ICALP, 1989), but it is fairly complicated and requires intersection types in the type system. Here, we present a much simpler solution which does not require intersection types. We first describe a new type system inspired in part by linear logic and verify that reductions preserve typings. We then define a class of “bireflective” models, which provide a categorical analysis of structure underlying the new typing rules; a companion paper “Bireflectivity”, in this volume, exposes wider ramifications of this structure. Finally, we describe a concrete model for an illustrative programming language based on the new type system; this improves on earlier such efforts in that states are not assumed to be structured using locations.

Objects, interference, and the Yoneda embedding

We present a new semantics for Algol-like languages that combines methods from two prior lines of development: 1. the object-based approach of Reddy, where the meaning of an imperative program is described in terms of sequences of observable actions, and 2. the functor-category approach initiated by Reynolds, where the varying nature of the run-time stack is explained using functors from a category of store shapes to a category of cpos. The semantics gives an account of both the phemomena of local state and irreversibility of state change. As an indication of the accuracy obtained, we present a full abstraction result for closed terms of second-order type in a language containing active expressions, i.e. value-returning commands.

Beyond ML

We believe that the most pressing problem in programming-language design is to control the interference that arises when functional and imperative programming are combined, and to give the user more control of storage allocation, without sacrificing the virtues of higher-order procedures, rigorous typing, and modularity that characterize ML. Towards this end, we intend to pursue research on Algol-like languages, linear typing, and the use of regions for storage allocation.

Full abstraction for the second order subset of an Algol-like language

We present a denotational semantics for an Algol-like language Alg, which is fully abstract for the second order subset of Alg. This constitutes the first significant full abstraction result for a block structured language with local variables. As all the published ‘test equivalences’ [8, 13,22] for Algol-like languages are contained in the second order subset, they can all be validated (easily) in our denotational model. The general technique for our model construction — namely ‘relationally structured locally complete partial orders’ with ‘relation preserving locally continuous functions’ — has already been developed in [13], but our particular model differs from the one in [13] in that we now use a larger set of relations. In a certain sense it is the ‘largest possible’ set of relations, an idea which we have successfully used in [32] to obtain a fully abstract model for the second order subset of the functional language PCF [26]. The overall structure of our full abstraction proof is also taken from [32], but for the single parts of the proof we had to solve considerable new problems which are specific to the imperative ( Algol-like) setting.

Parametricity and local variables

We propose that the phenomenon of local state may be understood in terms of Strachey's concept of parametric (i.e., uniform) polymorphism. The intuitive basis for our proposal is the following analogy: a non-local procedure is independent of locally-declared variables in the same way that a parametrically polymorphic function is independent of types to which it is instantiated. A connection between parametricity and representational abstraction was first suggested by J.C. Reynolds. Reynolds used logical relations to formalize this connection in languages with type variables and user-defined types. We use relational parametricity to construct a model for an Algol-like language in which interactions between local and non-local entities satisfy certain relational criteria. Reasoning about local variables essentially involved proving properties of polymorphic functions. The new model supports straightforward validations of all the test equivalences that have been proposed in the literature for local-variable semantics, and encompasses standard methods of reasoning about data representations. It is not known whether our techniques yield fully abstract semantics. A model based on partial equivalence relations on the natural numbers is also briefly examined.

Syntactic Control of Interference Revisited

In “Syntactic Control of Interference” (POPL, 1978), J. C. Reynolds proposes three design principles intended to constrain the scope of imperative state effects in Algol-like languages. The resulting linguistic framework seems to be a very satisfactory way of combining functional and imperative concepts, having the desirable attributes of both purely functional languages (such as PCF) and simple imperative languages (such as the language of while programs).However, Reynolds points out that an “obvious” syntax for interference control has the unfortunate property that β-reductions do not always preserve typings. Reynolds has subsequently presented a solution to this problem (ICALP, 1989), but it is fairly complicated and requires intersection types in the type system. Here, we present a much simpler solution which does not require intersection types.We first describe a new type system inspired in part by linear logic and verify that reductions preserve typings. We then define a class of “bireflective” models, which are shown to provide a sound interpretation of the type system; a companion paper, “Bireflectivity”, in this volume provides a categorical analysis of these models. Finally, we describe a concrete model for an illustrative programming language based on the new type system; this improves on earlier such efforts in that states are not assumed to be structured using locations.

Objects, Interference, and the Yoneda Embedding

We present a new semantics for Algol-like languages that combines methods from two prior lines of development: •the object-based approach of [21,22], where the meaning of an imperative program is described in terms of sequences of observable actions, and•the functor-category approach initiated by Reynolds [24], where the varying nature of the run-time stack is explained using functors from a category of store shapes to a category of cpos.The semantics gives an account of both the phemomena of local state and irreversibility of state change. As an indication of the accuracy obtained, we present a full abstraction result for closed terms of second-order type in a language containing active expressions, i.e. value-returning commands.

Semantical Analysis of Specification Logic, 2

The "specification logic" of J. C. Reynolds ( in "Tools and Notions for Program Construction" (D. Néel, Ed.), pp. 121-161, Cambridge Univ. Press, Cambridge, 1982) is a formal system for proving partial-correctness properties of programs in an Algol-like language with higher-order procedures. In a previous publication (Tennent, Inform. and Comput. 85 , 135-162 (1990)), a model was presented that validates all axioms of the system except those involving non-interference formulas for procedural phrases. Following Reynolds, non-interference for procedural phrases was there defined syntactically , by induction on types. Here, we present a new semantic interpretation of non-interference (for phrases of arbitrary type) which is equivalent to the interpretation given earlier for phrases of basic type. This interpretation provides the first model for all of Reynold′s axioms (except the equivalences formerly used to define procedural non-interference). A slightly more refined model is used to validate also a new axiom which formalizes a method used by Reynolds ("The Craft of Programming," Prentice-Hall, London, 1981) to reason about programs with multiple levels of abstraction.

FORK: A high-level language for PRAMs

We present a new programming language designed to allow the convenient expression of algorithms for a parallel random access machine (PRAM). The language attempts to satisfy two potentially conflicting goals: On the one hand, it should be simple and clear enough to serve as a vehicle for human-to-human communication of algorithmic ideas. On the other hand, it should be automatically translatable to efficient machine (i.e. PRAM) code, and it should allow precise statements to be made about the amount of resources (primarily time) consumed by a given program. In the sequential setting, both objectives are reasonably well met by the Algol-like languages, e.g. with the RAM as the underlying machine model, but we are not aware of any language that allows a satisfactory expression of typical PRAM algorithms. Our contribution should be seen as a modest attempt to fill this gap.

A Hoare-like verification system for a language with an exception handling mechanism

This paper presents a Hoare-like system for the language L exc containing typical statements, recursive procedures and an exception handling mechanism. The exception handling mechanism supports both termination and resumption as handler responses to an exception The semantics of the language is defined by a copy rule. The Hoare-like system is based on the system defined in Olderog (1981) for an Algol-like language. It is relatively complete for programs with a finite C -index ( C stands for a copy rule). The example of a correctness proof fo a simple program is presented.

Reasoning about procedures as parameters in the language L4

We provide a sound and relatively complete axiom system for partial correctness assertions in an Algol-like language with procedures passed as parameters, but with no global variables (traditionally known as the language L4). The axiom system allows us to reason syntactically about programs and to construct proofs for assertions about complicated programs from proofs of assertions about their components. Such an axiom system for a language with these features had been sought by a number of researchers, but no previously published solution has been entirely satisfactory. Our axiom system extends the natural style of reasoning used in previous Hoare axiom systems to programs with procedures of higher type. The details of the proof that our axiom system is relatively complete in the sense of Cook may be of independent interest, because we introduce results about expressiveness for programs with higher types that are useful beyond the immediate problem of the language L4. We also prove a new incompleteness result that applies to our logic and to similar Hoare logics.

Elementary data structures in ALGOL-like languages

J.C. Reynolds has pointed out that ALGOL 60 has a set of properties not shared by most of the languages usually regarded as being its successors. We propose to use this ALGOL-like framework to design a language that could adequately support both applicative and imperative programming while also retaining the advantages of each of the “pure” frameworks. This paper discusses elementary data-structuring facilities (products, arrays, sums) for such a language, taking advantage of recent developments, such as this author's “quantification” notation, and the notion of “conjunctive type” proposed by Coppo and Dezani, and adapted to explicitly-typed languages by Reynolds.

Escher-a geometrical layout system for recursively defined circuits

An Escher circuit description is a hierarchical structure composed of cells, wires, connectors between wires, and pins that connect wires to cells. Cells may correspond to primitive circuit elements, or they may be defined in terms of lower level subcells. Unlike other geometrical layout systems, a subcell may be an instance of the cell being defined. When such a recursive cell definition is initiated, the recursion is unwound in a manner reminiscent of the procedure call copy rule in Algol-like programming languages. Cell specifications may have parameters that are used to control the unwinding of recursive cells and to provide for cell families with varying numbers of pins and other internal components. It is shown how the Escher layout system might be used with several nontrivial examples, including a parallel sorting network and a FFT (fast Fourier transform) implementation. The unwinding algorithm is also briefly described. >