Operational Semantics

Abstract. We develop an imperative calculus that provides a formal model for both single and mixin inheritance. By introducing classes and mixins as the basic object-oriented constructs in a λ-calculus with records and references, we obtain a system with an intuitive operational ...

This paper introduces a graphical notation called algebraic state transition diagrams (ASTD), which allows for the combination of state transition diagrams using classical process algebra operators like sequence, iteration, parallel composition, quantified choice and quantified synchronization. It is inspired from automata, statecharts and process algebras. Hence, it combines the strength of all these notations: graphical representation, hierarchy, orthogonality, compositionality, abstraction. Quantification is one of the salient features of ASTDs, because it provides a powerful mechanism for modeling an arbitrary number of instances of an ASTD. A formal operational semantics is given. Our target application domain is the specification of information systems, but ASTDs are presented in a generic manner.

Defeasible Logic Programming (DeLP) is a suitable tool for knowledge representation and reasoning. Its operational semantics is based on a dialectical analysis where arguments for and against a literal interact in order to determine whether this literal is believed by a reasoning agent. The semantics GS is a declarative trivalued game-based semantics for DeLP that is sound and complete for DeLP operational semantics. Complexity theory has become an important tool for comparing different formalism and for helping to ...

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 [271. Categories and Subject Descriptors: D.3.3 [Programming Languages]: Language Constructsabstract

Message passing is a key ingredient of concurrent programming. The purpose of this paper is to describe the equivalence between the proof theory, the categorical semantics, and term calculus of message passing. In order to achieve this we introduce the categorical notion of a linear actegory and the related polycategorical notion of a poly-actegory. Not surprisingly the notation used for the term calculus borrows heavily from the (synchronous) pi-calculus. The cut elimination procedure for the system provides an operational semantics.

More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, due to several factors such as the widespread availability of multi-core/parallel architectures and Internet-based systems. This leads to the extension of mainstream object-oriented programming languages and platforms–Java is a main example–with libraries providing fine-grained mechanisms and idioms to support concurrent programming, in

Parallel (lazy) functional programs must describe both computation and coordination, i.e., what to compute and how to arrange the computation in parallel. The formal manipulation of the behaviours of such programs requires a semantics which accurately captures lazy evaluation, and the dependence of execution on the availability of (physical) resources. In this paper we present a lockstep semantics as a

A formalism for expressing the operational semantics of proof languages used in procedural theorem provers is proposed. It is argued that this formalism provides an elegant way to describe the computational features of proof languages, such as side effects, exception handling, and backtracking. The formalism, called proof monads, finds its roots in category theory, and in particular satisfies the monad

The formal description of the semantics of object-oriented data models is still an open problem. Some characteristic features of object-oriented data models, such as methods and inheritance, involve investigating data and schema. Therefore they can not be handled straightforwardly with first order logic. As an alternative, we propose the evolving algebra approach to specify the formal semantics of object-oriented data models. Evolving algebras provide a framework for defining the operational semantics of programming languages based on dynamic structures. In this paper we show how evolving algebras can be used in particular to define the operational semantics of object creation, of overriding and dynamic binding, and of inheritance at the type level (type specialization) and at the instance level (object specialization).

This paper presents a technique for specifying and reasoning about the operational semantics of distributed programming languages. We formalize the concept of “vertical stacking” of distributed systems, an extension of Joyce's, Windley's and Curzon's stacking methodologies for sequential systems and of the CLI “short stack” which stacks interpreters for object code, assembly code, and a high-level sequential language. We use a state transition model to account for the issues of atomicity, concurrency and nondeterminism at all levels in our stack. A correctness definition is given, which for each pair of adjacent language semantics and mappings between them, produces proof obligations corresponding to the correctness of the language implementation. We present an application of the method to a two-level stack: the microSR distributed programming language and a multi-processor instruction set, which is the target language for a compiler for microSR. We also present the development of a verified programming logic for microSR, using the same microSR semantic specification. The HOL system is used for the specification and the proofs.

We present a program logic for reasoning about resource consumption of programs written in Grail, an abstract fragment of the Java Virtual Machine Language. Serving as the target logic of a certifying compiler, the logic exploits Grail’s dual nature of combining a functional interpretation with object-oriented features and a cost model for the JVM. We present the resource-aware operational semantics of Grail, the program logic, and prove soundness and completeness. All of the work described has been formalised in the theorem prover Isabelle/HOL, which provides us with an implementation of the logic as well as confidence in the results. We conclude with examples of using the logic for proving resource bounds on code resulting from compiling high-level functional programs.

This survey article introduces into the essential concepts and methods underlying rule-based query languages. It covers four complementary areas: declarative semantics based on adaptations of mathematical logic, operational semantics, complexity and expressive power, and optimisation of query evaluation. The treatment of these areas is foundation-oriented, the foundations having resulted from over four decades of research in the logic programming and database communities on combinations of query languages and rules. These results have later formed the basis for conceiving, improving, and implementing several Web and Semantic Web technologies, in particular query languages such as XQuery or SPARQL for querying relational, XML, and RDF data, and rule languages like the “Rule Interchange Framework (RIF) ” currently being developed in a working group of the W3C. Coverage of the article is deliberately limited to declarative languages in a classical setting: issues such as query answerin...