Showing papers on "Operational semantics published in 1985"

CIRCAL and the representation of communication, concurrency, and time

Abstract: The CIRCAL calculus is presented as a mathematical framework in which to describe and analyze concurrent systems, whether hardware or software.The dot operator is used to compose CIRCAL descriptions, and it is this operator which permits the natural modeling of asynchronous and simultaneous behavior, thus allowing the representation and analysis of system timing properties such as those found in circuits.The CIRCAL framework uses an abstraction operator to permit the modeling of a system at different levels of detail. Behavioral complexity of real systems makes abstraction crucial when producing a tractable model, and we illustrate how abstraction introduces nondeterminisim into system representations.An operational semantics, acceptance semantics, is introduced, and it is in terms of this active experimentation that meaning is given to the CIRCAL syntax, thus allowing proof of system properties to be constructed.

Acceptance trees

Abstract: A simple model, AT, for nondeterministic machines is presented which is based on certain types of trees. A set of operations, S, is defined over AT and it is shown to be completely characterized by a set of inequations over S. AT is used to define the denotational semantics of a language for defining nondeterministic machines. The significance of the model is demonstrated by showing that this semantics reflects an intuitive operational semantics of machines based on the idea that machines should only be differentiated if there is some experiment that differentiates between them.

Algebraic Methods in Semantics

Abstract: This book, which contains contributions from leading researchers in France, USA and Great Britain, gives detailed accounts of a variety of methods for describing the semantics of programming languages, i.e. for attaching to programs mathematical objects that encompass their meaning. Consideration is given to both denotational semantics, where the meaning of a program is regarded as a function from inputs to outputs, and operational semantics, where the meaning includes the sequence of states or terms generated internally during the computation. The major problems considered include equivalence relations between operational and denotational semantics, rules for obtaining optimal computations (especially for nondeterministic programs), equivalence of programs, meaning-preserving transformations of programs and program proving by assertions. Such problems are discussed for a variety of programming languages and formalisms, and a wealth of mathematical tools is described.

Operational Semantics for Order-Sorted Algebra

Abstract: generalized many basic results of standard many-sorted algebra to OSA, and [9] simplified and generalized [6]; [5] gives a slightly more complex and less general simplification. [9] also gives sound and complete rules of deduction for OSA, introduces the important concept of =sort constraint =, and reduces OSA to standard conditional many-sorted algebra, thus automatically lifting conditional many-sorted algebra results to OSA. After reviewing this, we present here a rewrite rule-based operational semantics for OSA such that: • A term t in an order-sorted term algebra corresponds to a congruence class modulo a set J of equations in an algebra of mdisambiguated m parse trees. J admits a set J o f ChurchRosser rewrite rules, such that each term in the order-sorted term algebra has a unique disambiguated parse, the ~normal form of all disambiguated parses. • Church-Rosser and terminating rewrites in the order-sorted term algebra correspond to similar rewrites on lowest parses in the disambiguated algebra. This provides an efficient operational semantics that avoids rewriting in J-congruence classes; but it requires carefully constructing disambiguated rules from order-sorted rules; in particular, an order-sorted rule may generate several disambiguated rules for the Church-Rosser property to hold. i These results apply to both conditional rewriting and to rewriting modulo equations, by using pattern matching in the theory of the equations. We show that pattern matching in an order-sorted theory C corresponds to pattern matching in a disambiguated theory £@, but the matchings may be different. Associative matching in the disambiguated theory reduces to standard associative matching, but the reduction is quite subtle. • There is a very useful form of error-recovery: A term that is not itself well-formed, but becomes well-formed after some rewriting, such as s(4/2) with s the successor function, will recover. We formalize this with retracts, which are left inverses to subsort coercions. An ill-formed term t is parsed with retracts; if it reduces to a well-formed term, then it is called admissible. We prove that rewriting of admissible terms is Church-Rosser and terminating iff standard rewrites are Church-Rosser and terminating for well-formed terms, under the simple hypothesis that the sort of the righthand side of each order-sorted equation is less than or equal to that of its lefthand side. • These results imply we can check whether an order-sorted specification is Church-Rosser by checking its disambiguated specification with standard Knuth-Bendix, e.g. using RE',q~ [12]. Moreover, once the specification is Church-Rosser, error-recovery comes for free. • Last but not least, we give operational semantics for sort constraints, generalizing the =declarations = of [6]; these permit defining what would otherwise be partial functions as total functions on an equationally defined subsort, thus giving the power of [1] and [4]. A major motivation is to handle erroneous and meaningless expressions, such as top of an empty stack or division by zero. This has been important from the earliest days of =initial algebra semantics = and was approached awkwardly in [10]. Our results support OBJ2 [3], a programming language with operational semantics based on rewrite rules and mathematical semantics based on

Detecting global variables in denotational specifications

Abstract: Sufficient criteria are given for replacing all occurrences of the store argument in a Scott-Strachey denotational definition of a programming language by a single global variable. The criteria and transformation are useful for transforming denotational definitions into compilers and interpreters for imperative machines, for optimizing applicative programs, and for judging the suitability of semantic notations for describing imperative languages. An example transformation of a semantics of a repeat-loop language to one which uses a global store variable is given to illustrate the technique.

Continuation Semantics in Typed Lambda-Calculi (Summary)

Abstract: This paper reports preliminary work on the semantics of the continuation transform. Previous work on the semantics of continuations has concentrated on untyped lambda-calculi and has used primarily the mechanism of inclusive predicates. Such predicates are easy to understand on atomic values, but they become obscure on functional values. In the case of the typed lambda-calculus, we show that such predicates can be replaced by retractions. The main theorem states that the meaning of a closed term is a retraction of the meaning of the corresponding continuationized term.

A modular verifiable exception handling mechanism

Abstract: This paper presents a new model for exception handling, called the replacement model. The replacement model, in contrast to other exception-handling proposals, supports all the handler responses of resumption, termination, retry, and exception propagation, within both statements and expressions, in a modular, simple, and uniform fashion. The model can be embedded in any expression-oriented language and can also be adapted to languages which are not expression oriented with almost all the above advantages. This paper presents the syntactic extensions for embedding the replacement model into Algol 68 and its operational semantics. An axiomatic semantic definition for the model can be found in [27].

A proof rule for fair termination of guarded commands

Abstract: We present a proof rule for fairly terminating guarded commands based on a well-foundedness argument. The rule is applied to several examples, and proved to be sound and (semantically) complete w.r.t. an operational semantics of computation trees. The rule is related to another rule suggested by Lehmann, Pnueli, and Stavi ( in “Proc. Internat. Colloq. Automata Lang. and Programming, '81,” Acre, July 1981), by showing that the (semantic) completeness of the LPS-rule follows from the completeness or ours.

Semantics of Vague Concepts

Abstract: For many years vagueness understood as a deficiency of meaning has been the subject of investigations and many authors are engaged in this research. The present paper is an attempt to show that problems concerning semantics of vague concepts may find their proper foundation in the theory of rough sets originated by Pawlak (1982). We give a formal framework to what is considered to be different ways of making vague concepts precise and we describe semantics within this framework. Following the idea accepted by many logicians that reasoning in a language containing expressions representing vague concepts requires a special logic, we present a kind of modal logic suitable for deductions in the presence of vagueness.

A procedural logic

Abstract: Much of our commonsense knowledge about the real world is concerned with the way things are done. This knowledge is often in the form of procedures or sequences of actions for achieving particular goals. In this paper, a formalism is presented for representing such knowledge based on the notion of process. A declarative semantics for the representation is given, which allows a user to state facts about the effects of doing things in the problem domain of interest. An operational semantics is also provided, which shows how this knowledge can be used to achieve given goals or to form intentions regarding their achievement. The formalism also serves as an executable program specification language suitable for constructing complex systems.

A Computational Semantics for Natural Language

Abstract: In the new Head-driven Phrase Structure Grammar (HPSG) language processing system that is currently under development at Hewlett-Packard Laboratories, the Montagovian semantics of the earlier GPSG system (see [Gawron et al. 1982]) is replaced by a radically different approach with a number of distinct advantages. In place of the lambda calculus and standard first-order logic, our medium of conceptual representation is a new logical formalism called NFLT (Neo-Fregean Language of Thought); compositional semantics is effected, not by schematic lambda expressions, but by LISP procedures that operate on NFLT expressions to produce new expressions. NFLT has a number of features that make it well-suited for natural language translations, including predicates of variable arity in which explicitly marked situational roles supercede order-coded argument positions, sortally restricted quantification, a compositional (but nonextensional) semantics that handles causal contexts, and a principled conceptual raising mechanism that we expect to lead to a computationally tractable account of propositional attitudes. The use of semantically compositional LISP procedures in place of lambda-schemas allows us to produce fully reduced translations on the fly, with no need for post-processing. This approach should simplify the task of using semantic information (such as sortal incompatibilities) to eliminate bad parse paths.

CSP-programs as nets with individual tokens

Abstract: We define a subclass of predicate/transition-nets and show how to translate CSP-programs into such nets. We consider a subset of CSP for which Hennessy, Li and Plotkin have given an operational semantics in [HLP]. We show that the firing sequences of our net translation correspond to this operational semantics. Additionally, we also give a non-interleaving semantics to CSP by considering unfoldings and processes of the net translation.

TSL: task sequencing language

Abstract: TSL is a language for specifying sequences of tasking events in Ada1 programs. TSL specifications are submitted with an Ada program and are monitored at runtime for consistency with the actual tasking events as they occur. This paper presents a preliminary design for TSL, an informal overview of its capabilities, and an operational semantics.

Proving Termination of Prolog Programs

Abstract: The paper presented two kinds of proof rules to prove B-termination, the kind of termination obtained by the combination of backtracking and recursion as displayed by Prolog. The first kind of rule takes into account the context of the whole program and is based on a tree oriented operational semantics. The second kind is more compositional, dealing with separate procedures in a context independent way. It is based on a stream oriented semantics.

Refining and extending the procedural net

Abstract: This paper presents a new definition for Plans The objects defined are called Plan Nets, and are similar in spirit to Sacerdoti's Procedural Nets (1975). It is argued that Plan Nets are more descriptive tham Procedural Nets, because they can easily describe iterative behaviour The Plan Net definition is motivated by providing an operational semantics for the Procedural Net, and noticing that all Procedural Net state spaces are "loop free" This is seen to restrict the behaviours that can be described by the Procedural Net to those which do not. include iteration It is suggested that Plan Net. state spaces can contain loops, and thus can describe iterative behaviour.

A Fully Abstract Semantics and a Proof System for an ALGOL-Like Language with Sharing

Abstract: 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.

Comparing Categories of Domains

Abstract: We discuss some of the reasons for the proliferation of categories of domains suggested for the mathematical foundations of the Scott-Strachey theory of programming semantics. Five general conditions are presented which such a category should satisfy and they are used to motivate a number of examples. An attempt is made to survey some of the methods whereby these examples may be compared and their relationships expressed. We also ask a few mathematical questions about the examples.

Embedding type structure in semantics

Abstract: We show how a programming language designer may embed the type structure of a programming language in the more robust type structure of the typed lambda calculus. This is done by translating programs of the language into terms of the typed lambda calculus. Our translation, however, does not always yield a well-typed lambda term. Programs whose translations are not well-typed are considered meaningless, that is, ill-typed. We give a conditionally type-correct semantics for a simple language with continuation semantics. We provide a set of static type-checking rules for our source language, and prove that they are sound and complete: that is, a program passes the typing rules if and only if its translation is well-typed. This proves the correctness of our static semantics relative to the well-established typing rules of the typed lambda-calculus.

Denotational semantics and rewrite rules for FP

Abstract: We consider languages whose operational semantics is given by a set of rewrite rules. For such languages, it is important to be able to determine that there are enough rules to completely reduce all meaningful expressions, but not so many that the system of rules is inconsistent. We develop a formal framework in which to give a precise treatment of these soundness and completeness issues. We believe our approach to be novel in that we make heavy use of denotational semantics in our proof of completeness. The particular language for which we answer these questions is an extended version of the functional programming language FP; however the applicability of these techniques extends beyond the realm of FP rewriting systems.

An Axiomatic Treatment of a Parallel Programming Language

Abstract: This paper describes a semantically-based axiomatic treatment of a parallel programming language with shared variable concurrency and conditional critical regions, essentially the language discussed by Owicki and Gries [20,21] We use a structural operational semantics for this language, based on work of Hennessy and Plotkin [22,26], and we use the semantic structure to suggest a class of assertions for expressing properties of commands We then define syntactic operations on assertions which correspond precisely to syntactic constructs of the programming language; in particular, we define sequential and parallel composition of assertions This enables us to design a truly compositional proof system for program properties Our proof system is sound and relatively complete We examine the relationship between our proof system and the Owicki-Gries proof system Our assertions are more expressive than Owicki's, and her proof outlines correspond roughly to a special subset of our assertion language Owicki's parallel rule can be thought of as being based on a slightly different form of parallel composition of assertions; our form does not require interference-freedom, and our proof system is relatively complete without the need for auxiliary variables Connections with other work, including the “Generalized Hoare Logic” of Lamport and Schneider [16,17], and with the Transition Logic of Gerth [11], are discussed briefly

Two complete axiom systems for a theory of communicating sequential processes

Abstract: In C. A. R. Hoare, S. D. Brookes, and A. D. Roscoe (1984, J. Assoc. Comput. Mach. 31(3), 560) an abstract version of Hoare's CSP is defined and a denotational semantics based on the possible failures of processes is given for it. This semantics induces a natural preorder on processes. We define formally this preorder and prove that it can be characterized as the smallest relation satisfying a particular set of axioms. The characterization sheds lights on problems arising from the way divergence and underspecification are handled. After small changes to the semantic domains we propose a new semantics which is closer to the operational intuitions and suggests a possible solution to the above problems. Finally we give an axiomatic characterization for the equivalence induced by the new semantics which leads to fully abstract models in the sense of Scott.