Interactive Small-Step Algorithms II: Abstract State Machines and the<br> Characterization Theorem

In earlier work, the Abstract State Machine Thesis – that arbitrary algorithms are behaviorally equivalent to abstract state machines – was established for several classes of algorithms, including ordinary, interactive, small-step algorithms. This was accomplished on the basis of axiomatizations of these classes of algorithms. In Part I (Interactive Small-Step Algorithms I: Axiomatization), the axiomatization was extended to cover interactive small-step algorithms that are not necessarily ordinary. This means that the algorithms (1) can complete a step without necessarily waiting for replies to all queries from that step and (2) can use not only the environment’s replies but also the order in which the replies were received. In order to prove the thesis for algorithms of this generality, we extend here the definition of abstract state machines to incorporate explicit attention to the relative timing of replies and to the possible absence of replies. We prove the characterization theorem for extended abstract state machines with respect to general algorithms as axiomatized in Part I.

💡 Research Summary

This paper extends the classical Abstract State Machine (ASM) framework to capture a broader class of interactive small‑step algorithms that were introduced in Part I of the authors’ series. While traditional ASMs faithfully model “ordinary” algorithms—those that wait for all queries in a step before proceeding—they cannot express two essential features of many real‑world systems: (i) a step may terminate without receiving replies to all outstanding queries, and (ii) the algorithm may depend on the order in which replies arrive. Part I formalized these capabilities through an axiomatization consisting of four core axioms: Bounded Exploration, Finite Interaction, Partial Completion, and Temporal Sensitivity. The present work defines an “Extended ASM” (E‑ASM) that incorporates these capabilities directly into its syntax and semantics, and then proves a characterization theorem stating that every algorithm satisfying the Part I axioms is behaviorally equivalent to some E‑ASM, and vice‑versa.

The new E‑ASM language retains the familiar components of ordinary ASMs—states, vocabularies, and transition rules—but augments them with two kinds of auxiliary variables: (a) a reply‑presence flag for each query, indicating whether a response has been received, and (b) a timestamp (or logical clock) attached to each response, recording the moment of arrival. Transition rules can now test these flags and compare timestamps, enabling constructs such as “wait until at least one reply from a set arrives” (the Wait operator) and “ignore a missing reply and continue” (the Ignore operator). These operators are combined with the standard conditional, parallel, and nondeterministic choice constructs, yielding a language that can express any timing‑sensitive branching pattern while still respecting the bounded‑exploration restriction.

The core of the paper is the proof of the characterization theorem. The proof proceeds in two directions. For soundness, the authors show how to translate any algorithm A that satisfies the Part I axioms into an equivalent E‑ASM M. The translation extracts A’s interaction graph—its set of queries, possible replies, and the partial order induced by reply arrival—and systematically introduces the corresponding presence flags and timestamps into M’s state. Each step of A is simulated by a finite set of E‑ASM rules that update the flags, assign timestamps, and perform the appropriate conditional updates based on the observed ordering of replies. For completeness, the authors demonstrate that any E‑ASM M can be simulated by an algorithm A that obeys the axioms. They construct A by interpreting M’s rules as a deterministic scheduler that, at each step, generates the same set of queries, records replies (or their absence) with the same timestamps, and executes the same state updates. Crucially, the authors prove that the observable behavior—defined as the sequence of external interactions (queries and replies) together with the final output—is identical in both directions, establishing behavioral equivalence.

To illustrate the practical relevance of the theory, the paper presents two case studies. The first models a two‑phase commit protocol, where the coordinator must decide based on the order and presence of “prepare‑ok” messages from participants. Using E‑ASM, the coordinator’s logic is expressed succinctly with a Wait construct that proceeds as soon as a quorum of acknowledgments arrives, without waiting for all participants. The second case study concerns a real‑time sensor network in which some sensors may fail to respond within a deadline. Here the Ignore operator allows the algorithm to continue with the data that have arrived, while still respecting the bounded‑exploration constraint. Both examples demonstrate that E‑ASM can naturally capture timing‑dependent, partially synchronous interactions that ordinary ASMs cannot.

In the concluding section, the authors discuss the broader implications of their work. By providing a formal model that aligns precisely with the axioms of interactive small‑step algorithms, they lay a foundation for rigorous verification, model checking, and even automatic code generation for systems where timing and partial information are first‑class concerns. Future research directions include extending the framework to handle infinite state spaces, optimizing the execution of E‑ASM specifications, and integrating the approach with existing verification tools to bring the theoretical results into practical software engineering workflows.