David F. Martin

An order-algebraic definition of knuthian semantics

This paper presents a formulation, within the framework of initial algebra semantics, of Knuthian semantic systems (K-systems) which contain both synthesized and inherited attributes. The approach is based on viewing the semantics of a derivation tree of a context-free grammar as a set of values, called an attribute valuation, assigned to the attributes of all its nodes. Any trees attribute valuation which is consistent with the semantic rules of the K-system may be chosen as the semantics of that derivation tree.The set of attribute valuations of a given tree is organized as a complete partially ordered set such that the semantic rules define a continuous transformation on this set. The least fixpoint of this transformation is chosen as the semantics of a given derivation tree. The mapping from derivation trees to their least fixpoint semantics is a homomorphism between certain algebras. Thus, the semantics of a K-system is an application of the Initial Algebra Semantics Principle of Goguen and Thatcher. This formulation permits a precise definition of K-systems, and generalizes Knuths original formulation by defining the meaning of recursive (circular) semantic specifications.The algebraic formulation of K-systems is applied to proving the equivalence of K-systems having the same underlying grammar. Such proofs may require verifying that a K-system possesses certain properties and to this end, a principle of structural induction on many-sorted algebras is formulated, justified, and applied.

Models of Computations and Systems—Evaluation of Vertex Probabilities in Graph Models of Computations

This paper concerns itself with the modeling of computations and systems and the generation of a priori estimates of expected computation time for given problems on given processing systems. In particular, methods are discussed for determining the probabilities of reaching vertices in a graph model of computations.

A mechanically verified verification condition generator

Verification Condition Generator (VCG) tools have bee, effective in simplifying the task of proving programs correct. However, in the past these VCG tools have in general not themselves been mechanically proven, so any proof using and depending on these VCGs might not be sound. In our work, we define and rigorously prove correct a VCG tool within the HOL theorem proving system, for a standard while-loop language, with one new feature not usually treated: expressions with side effects. Starting from a structural operational semantics of this programming language, we prove as theorem the axioms and rules of inference of a Hoare style axiomatic semantics, verifying their soundness. This axiomatic semantics is then used to define and prove correct a VCG tool for this language. Finally, this verified VCG is applied to an example program to verify its correctness.

Toward compiler implementation correctness proofs

Aspect of the interaction between compiler theory and practice is addressed. Presented is a technique for the syntax-directed specification of compilers together with a method for proving the correctness of their parse-driven implementations. The subject matter is presented in an order-algebraic framework; while not strictly necessary, this approach imposes beneficial structure and modularity on the resulting specifications and implementation correctness proofs. Compilers are specified using an order-algebraic definition of attribute grammars. A practical class of compiler implementations is considered, consisting of those driven by LR(k) or LL(k) parsers which cause a sequence of translation routine activations to modify a suitably initialized collection of data structures (called a translation environment). The implementation correctness criterion consists of appropriately comparing, for each source program, the corresponding object program (contained in the final translation environment) produced by the compiler implementation to the object program dictated by the compiler specification. Provided that suitable intermediate assertions (called translation invariants) are supplied, the program consisting of the (parse-induced) sequence of translation routine activations can be proven partially correct via standard inductive assertion methods.

Path Length Computations on Graph Models of Computations

This paper discusses essential difficulties in calculating mean path lengths on a directed graph model of computations. This study was part of a larger study of a priori scheduling of computer programs in a parallel processing environment. Efficient approximations to mean processing time (mean path length) of programs in such an environment are given.

Mechanical Verification of Mutually Recursive Procedures

The verification of programs that contain mutually recursive procedures is a difficult task, and one which has not been satisfactorily addressed in the literature. Published proof rules have been later discovered to be unsound. Verification Condition Generator (VCG) tools have been effective in partially automating the verification of programs, but in the past these VCG tools have in general not themselves been proven, so any proof using and depending on these VCGs might not be sound. In this paper we present a set of proof rules for proving the partial correctness of programs with mutually recursive procedures, together with a VCG that automates the use of the proof rules in program correctness proofs. The soundness of the proof rules and the VCG itself have been mechanically proven within the Higher Order Logic theorem prover, with respect to the underlying structural operational semantics of the programming language. This proof of soundness then forms the core of an implementation of the VCG that significantly eases the verification of individual programs with complete security.

A debugger for Ada tasking

The capabilities needed in an Ada debugger are discussed in light of the languages tasking constructs, and the design for a debugger is presented which operates in concert with a single-processor Ada interpreter. This debugger design demonstrates the extensions to sequential debugging techniques that are necessary to handle concurrency, and shows that significant debugging functionality can be provided even without the inclusion of automatic error diagnosis methods. The issues considered include isolation of effects and display of the full dynamic execution status, both of which are essential to diagnosis of concurrent programs. >

Time required for reference count management in retention block-structured languages. Part 1

In this paper, two implementations of generalized block-structured languages are presented and their time requirements compared. One implementation, the lifetime stack model (LSM), implements the deletion strategy with lifetime checks; the other, the partial reference count contour machine (PRCCM), implements the retention strategy. For a large subset of the lifetime well-stacking programs, which are precisely those that run correctly on the first model, the two models are shown to require nearly the same order of magnitude of time. The use of full-label values is shown to have a detrimental effect on the time efficiency of the latter model. Part 1, in this issue, gives a general description of the machines and part of their definitions, and proves the results. Part 2, in the next issue, serving as an appendix to Part 1, contains most of the formal definitions of the machines.

Algebraic properties of operator precedence languages

This paper presents new results on the algebraic ordering properties of operator precedence grammars and languages. This work was motivated by, and applied to, the mechanical acquisition or inference of operator precedence grammars. A new normal form of operator precedence grammars called homogeneous is defined. An algorithm is given to construct a grammar, called max-grammar, generating the largest language which is compatible with a given precedence matrix. Then the class of free grammars is introduced as a special subclass of operator precedence grammars. It is shown that operator precedence languages corresponding to a given precedence matrix form a Boolean algebra.

An algebraic formulation of knuthian semantics

This paper presents a formulation, within the framework of initial algebra semantics, of Knuthian semantic systems (K-systems) which contain both synthesized and inherited attributes. This formulation permits a precise definition of K-systems, and combines their intuitive appeal with the theoretical power of algebraic methods. The basic approach consists of algebraically specifying the semantic portion of a given K-system, converting this K-system into another equivalent one which contains only synthesized attributes, and then defining the new equivalent K-system by means of an algebraic formulation. The practical implications of the algebraic definition of K-systems are discussed, and the combined use of Knuths original formulation and the algebraic approach for the development of semantic definitions is advocated.