Eric G. Wagner

Initial Algebra Semantics and Continuous Algebras

Many apparently divergent approaches to specifying formal semantics of programming languages are applications of initial algebra semantics. In this paper an overview of initial algebra semantics is provided. The major technical feature is an initial continuous algebra which permits unified algebraic treatment of iterative and recursive semantic features in the same framework as more basic operations.

Rational algebraic theories and fixed-point solutions

In a wide variety of situations, computer science has found it convenient to define complex object as (fixed-point) solutions of certain equations. This has been done in both algebraic and order-theoretic settings, and has often been contrasted with other approaches. This paper shows how to formulate such solutions in a setting which encompasses both algebraic and order-theoretic aspects, so that the advantages of both worlds are available. Moreover, we try to show how this is consistent with other approaches to defining complex objects, through a number of applications, including: languages defined by context-free grammars; flow charts and their interpretations; and monadic recursive program schemes. The main mathematical results concern free rational theories and quotients of rational theories. However, the main goal has been to open up what we believe to be a beautiful and powerful new approach to the syntax and semantics of complex recursive specifications.

Parameter passing in algebraic specification languages

Abstract In this paper we study the semantics of the parameter passing mechanism in algebraic specification languages. More precisely, this problem is studied for parameterized data types and parameterized specifications. The given results include the extension of the model functor (which is useful for correctness proofs) and the semantic properties of the result of inserting actual parameters into parameterized specifications. In particular, actual parameters can be parameterized and the result is nested parameterized specification. Correctness of an applied ( matrix ( int )) or a nested ( bintree ( string ())) parameterized specification is shown given correctness of the parts. The formal theory in this paper is restricted to the basic algebraic case where only equations are allowed in the parameter declaration and parameter passing is given by specification morphisms. But we also give the main ideas of a corresponding theory with requirements where we allow different kinds of restrictions in the parameter declaration.

More on advice on structuring compilers and proving them correct

Abstract Following Lockwood Morris, a method for algebraically structuring a compiler and proving it correct is described. An example language with block structure and side-effects is presented. This determines an initial many-sorted algebra L which is the ‘abstract syntax’ of the example language. Then the semantics of L is completely determined by describing a semantic algebra M ‘similar’ to L . In particular, initiality of L ensures that there is a unique homomorphism Lsem: L →> M . This is algebraically structuring the semantic definition of the language. A category of flow-charts over a stack machine is used as a target language for the purposes of compilation. The semantics of the flow charts (Tsem: T → S ) is also algebraically determined given interpretations of the primitive operations on the stack and store. The homomorphism comp: L → T is the compiler which is also uniquely determined by presenting an algebra T of flowcharts similar to L . This is algebraically structuring the compiler. Finally a function encode: M → S describes source meanings in terms of target meanings. The proof that the compiler is correct reduces to a proof that encode: M → S is a homomorphism; then both comp ∘ Tsem and Lsem ∘ encode are homomorphisms from L to S and they must be equal because there is only one homomorphism from L to S .

Data type specification: Parameterization and the power of specification techniques

This paper extends our earlier work on abstract data types by providing an algebraic treatment of parametrized data types (e.g., sets-of-(), stacks-of-(), etc.), as well as answering a number of questions on the power and limitations of algebraic specification techniques. In brief: we investigate the “hidden function” problem (the need to include operations in specifications which we want to be hidden from the user); we prove that conditional specifications are inherently more powerful than equational specifications; we show that parameterized specifications must contain “side conditions” (e.g., that finite-sets-of-d requires an equality predicate on d), and we compare the power of the algebraic approach taken here with the more categorical approach of Lehman and Smyth.

Algebraic Specifications with Generating Constraints

In this paper we take a new look at one of the basic principles of abstract data types. Due to this principle the domain of an abstract data type must be generated by the operations. In the initial algebraic approach as well as in the loose case with initial restrictions or data constraints this principle is satisfied because of initiality resp. free construction. Actually initiality makes sure that the data under consideration are not only generated but even freely generated by the operations. In this paper we do not consider free generation but only generation leading to the new concept of algebraic specifications with generating constraints.

An algebraic theory of recursive definitions and recursive languages

This is the introductory paper in a series devoted to a general algebraic theory of “recursive definitions” and “recursive languages”. In this paper we present the fundamental concepts and theorems concerning the basic structure (basic syntax), the semantics and the combination and manipulation of “recursive definitions” and the closure properties of “recursive languages”. The development is carried out within the framework of category theory and lattice theory. To illustrate the generality of the approach and our results we show how they apply directly to the specific examples of “recursive languages” of (generalized) context-free grammars, Turing machines, and flowcharts.

Algebraic topological methods for the synthesis of switching systems, part III: minimization of nonsingular Boolean trees

An algorithm is given for solving a general problem in combinational switching-circuit minimization theory. The circuits considered consist of a disjunction (OR-ing together) of trees of any set of logical elements, with the restriction that in any given tree no input appears more than once. To each logical element is attached a positive cost. A method is presented for designing a minimum-cost circuit of this variety for any given logical function. Two parallel treatments are given, one viewing it as an abstract mathematical problem, the other considering it as an engineering problem.

Parameter Passing in Algebraic Specification Languages

In this paper we study the semantics of the parameter passing mechanism in algebraic specification languages. More precisely, this problem is studied for parameterized data types and parameterized specifications. The given results include the extension of the model functor (which is useful for correctness proofs) and the semantic properties of the result of inserting actual parameters into parameterized specifications. In particular, actual parameters can be parameterized and the result is nested parameterized specification. Correctness of an applied (matrix (int)) or a nested (bintree (string ())) parameterized specification is shown given correctness of the parts. The formal theory in this paper is restricted to the basic algebraic case where only equations are allowed in the parameter declaration and parameter passing is given by specification morphisms. But we also give the main ideas of a corresponding theory with requirements where we allow different kinds of restrictions in the parameter declaration.

Recursion and iteration in continuous theories: The “M-construction”

Abstract The purpose of this paper is two-fold: first to show how a natural mathematical formulation of the “solution” of a system of recursion equations is formally almost identical with well-known formulations of a solution of a system of “iteration equations.” The second aim is to present a construction which takes an algebraic theory T and yields another algebraic theory M ( T ) whose morphisms correspond to systems of recursion equations over T . This construction is highly uniform, i.e., the correspondence between T and M ( T ) is functorial.