Abstract We give an axiomatic description of parallel, synchronous algorithms. Our main result is that every such algorithm can be simulated, step for step, by an abstract state machine with a background that provides for multisets. \Lambda

We define three composition and structuring concepts which...

Abstract: This paper describes a generic proof method for the correctness of refinements of Abstract State Machines based on commuting diagrams. The method generalizes forward simulations from the refinement of I/O automata by allowing arbitrary m:n diagrams, and by combining it with the refinement of data structures.

y Abstract What is an algorithm? The interest in this foundational problem is not only theoretical; applications include specification, validation and verification of software and hardware systems. We describe the quest to understand and define the notion of algorithm. We start with the Church-Turing thesis and contrast Church's and Turing's approaches, and we finish with some recent investigations.

We capture the principal models of computation and specification in the literature by a uniform set of transparent mathematical descriptions which—starting from scratch—provide the conceptual basis for a comparative study 1. 1

Abstract. Turbo Abstract State Machines are ASMs with parallel and sequential composition and possibly recursive submachine calls. Turbo ASMs are viewed as black-boxes that can combine arbitrary many steps of one or more submachines into one big step. The intermediate steps of a turbo ASM are not observable from outside. It is not even clear what exactly the intermediate steps are, because the semantics of turbo ASMs is usually defined inductively along the call graph of the ASM and the structure of the rule bodies. The most important application of turbo ASMs are recursive algorithms. Such algorithms can directly be simulated on turbo ASMs without transforming them into multi-agent (distributed) ASMs. In this article we analyze the hidden intermediate steps of turbo ASMs and characterize them using PAR/SEQ trees. We also address the problem of the reserve in the presence of recursion and sequential composition. 1

Abstract. We introduce the concept of an algebraic state machine. This is a state transition machine all parts of that are described by algebraic and logical means. This way we base the description of state transition systems exclusively on the concept of algebraic specifications. Also the state of an algebraic state machine is represented by an algebra. In particular, we describe the state spaces of the state machine by algebraic techniques, and the state transitions by special axioms called transition rules. Then we show how known concepts from algebraic specifications can be used to provide a notion of parallel composition with asynchronous interaction for algebraic state machines. As example we introduce a notion of object-oriented component and show how algebraic state machines can formalize such components. 1

Montages are a semi-visual formalism for defining the static and dynamic semantics of a programming language using Gurevich's Abstract State Machines (ASMs). We describe an application of Montages to describe the static and dynamic semantics of the C programming language.

A new version of SDL called SDL-2000 is currently reaching maturity, and is expected to pass the standardization bodies shortly. It will offer new features as object-oriented data types, simplify and unify concepts of previous language versions and provide an alignment with UML. Due to the significant changes to SDL it was necessary to define a new formal semantics for SDL. Abstract State Machines (ASMs) have been chosen as the underlying formalism. In this paper, after introducing the new SDL language features, it is shown, how these features get an executable formal semantics using ASMs. 1

Abstract. The question raised in [15] is answered how to naturally model widely used forms of recursion by abstract machines. We show that turbo ASMs as defined in [7] allow one to faithfully reflect the common intuitive single-agent understanding of recursion. The argument is illustrated by turbo ASMs for Mergesort and Quicksort. Using turbo ASMs for returning function values allows one to seamlessly integrate functional description and programming techniques into the high-level ’abstract programming ’ by state transforming ASM rules. 1