The λ-calculus is considered a useful mathematical tool in the study of programming languages, since programs can be identified with λ-terms. However, if one goes further and uses βη-conversion to prove equivalence of programs, then a gross simplification is introduced (programs are identified with total functions from values to values ) that may jeopardise the applicability of theoretical results. In this paper we introduce calculi, based on a categorical semantics for computations , that provide a correct basis for proving equivalence of programs for a wide range of notions of computation .

Notions of computation and monads

Functions, types and expressions programming languages and their operational semantics compilation partial evaluation of a flow chart languages partial evaluation of a first-order functional languages the view from Olympus partial evaluation of the Lambda calculus partial evaluation of prolog aspects of Similix - a partial evaluator for a subset of scheme partial evaluation of C applications of partial evaluation termination of partial evaluation program analysis more general program transformation guide to the literature the self-applicable scheme specializer.

Partial evaluation and automatic program generation

Conditional rewriting logic as a unified model of concurrency

There is a population explosion among the logical systems used in computing science. Examples include first-order logic, equational logic, Horn-clause logic, higher-order logic, infinitary logic, dynamic logic, intuitionistic logic, order-sorted logic, and temporal logic; moreover, there is a tendency for each theorem prover to have its own idiosyncratic logical system. The concept of institution is introduced to formalize the informal notion of “logical system.” The major requirement is that there is a satisfaction relation between models and sentences that is consistent under change of notation. Institutions enable abstracting away from syntactic and semantic detail when working on language structure “in-the-large”; for example, we can define language features for building large logical system. This applies to both specification languages and programming languages. Institutions also have applications to such areas as database theory and the semantics of artificial and natural languages. A first main result of this paper says that any institution such that signatures (which define notation) can be glued together, also allows gluing together theories (which are just collections of sentences over a fixed signature). A second main result considers when theory structuring is preserved by institution morphisms. A third main result gives conditions under which it is sound to use a theorem prover for one institution on theories from another. A fourth main result shows how to extend institutions so that their theories may include, in addition to the original sentences, various kinds of constraint that are useful for defining abstract data types, including both “data” and “hierarchy” constraints. Further results show how to define institutions that allow sentences and constraints from two or more institutions. All our general results apply to such “duplex” and “multiplex” institutions.

Institutions: abstract model theory for specification and programming

Uppaal is a tool suite for automatic verification of safety and bounded liveness properties of real-time systems modeled as networks of timed automata. It includes: a graphical interface that supports graphical and textual representations of networks of timed automata, and automatic transformation from graphical representations to textual format, a compiler that transforms a certain class of linear hybrid systems to networks of timed automata, and a model-checker which is implemented based on constraint-solving techniques. Uppaal also supports diagnostic model-checking providing diagnostic information in case verification of a particular real-time systems fails.

UPPAAL: a Tool Suite for Automatic Verification of Real Time Systems

Denotational semantics

https://homepages.inf.ed.ac.uk/dts/pub/casl.pdf

CASL: the common algebraic specification language

A distinguishing characteristic of action semantics is its facet system, which defines the variety of information flows in a language definition. The facet system can be analyzed to validate the well-formedness of a language definition, to infer the typings of its inputs and outputs, and to calculate the operational semantics of programs. We present a single framework for doing all of the above. The framework exploits the internal subsorting structure of the facets so that sort checking, static analysis, and operational semantics are related, sound instances of the same underlying analysis. The framework also suggests that action semantics's extensibility can be understood as a kind of "weakening rule" in a "logic" of actions. In this paper, the framework is used to perform type inference on specific programs, to justify meaning-preserving code transformations, and to "stage" an action semantics definition of a programming language into a static semantics stage and a dynamic semantics stage.

Action semantics

Modular structural operational semantics

Syntax Sorts and Constructors . ...................... 495 Synabol Index . ................................................. 501 Concept Index . ................................................ 511

Peter D. Mosses

Papers

Denotational semantics

CASL: the common algebraic specification language

Action semantics

Modular structural operational semantics

Casl Reference Manual