6 research outputs found
A Logic for Non-Deterministic Parallel Abstract State Machines
We develop a logic which enables reasoning about single steps of
non-deterministic parallel Abstract State Machines (ASMs). Our logic builds
upon the unifying logic introduced by Nanchen and St\"ark for reasoning about
hierarchical (parallel) ASMs. Our main contribution to this regard is the
handling of non-determinism (both bounded and unbounded) within the logical
formalism. Moreover, we do this without sacrificing the completeness of the
logic for statements about single steps of non-deterministic parallel ASMs,
such as invariants of rules, consistency conditions for rules, or step-by-step
equivalence of rules.Comment: arXiv admin note: substantial text overlap with arXiv:1602.0748
Concurrent Computing with Shared Replicated Memory
The behavioural theory of concurrent systems states that any concurrent
system can be captured by a behaviourally equivalent concurrent Abstract State
Machine (cASM). While the theory in general assumes shared locations, it
remains valid, if different agents can only interact via messages, i.e. sharing
is restricted to mailboxes. There may even be a strict separation between
memory managing agents and other agents that can only access the shared memory
by sending query and update requests to the memory agents. This article is
dedicated to an investigation of replicated data that is maintained by a memory
management subsystem, whereas the replication neither appears in the requests
nor in the corresponding answers. We show how the behaviour of a concurrent
system with such a memory management can be specified using concurrent
communicating ASMs. We provide several refinements of a high-level ground model
addressing different replication policies and internal messaging between data
centres. For all these refinements we analyse their effects on the runs such
that decisions concerning the degree of consistency can be consciously made.Comment: 23 page
Behavioural Theory of Reflective Algorithms I: Reflective Sequential Algorithms
We develop a behavioural theory of reflective sequential algorithms (RSAs),
i.e. sequential algorithms that can modify their own behaviour. The theory
comprises a set of language-independent postulates defining the class of RSAs,
an abstract machine model, and the proof that all RSAs are captured by this
machine model. As in Gurevich's behavioural theory for sequential algorithms
RSAs are sequential-time, bounded parallel algorithms, where the bound depends
on the algorithm only and not on the input. Different from the class of
sequential algorithms every state of an RSA includes a representation of the
algorithm in that state, thus enabling linguistic reflection. Bounded
exploration is preserved using terms as values. The model of reflective
sequential abstract state machines (rsASMs) extends sequential ASMs using
extended states that include an updatable representation of the main ASM rule
to be executed by the machine in that state. Updates to the representation of
ASM signatures and rules are realised by means of a sophisticated tree algebra.Comment: 32 page
A Behavioural Theory of Recursive Algorithms
"What is an algorithm?" is a fundamental question of computer science.
Gurevich's behavioural theory of sequential algorithms (aka the sequential ASM
thesis) gives a partial answer by defining (non-deterministic) sequential
algorithms axiomatically, without referring to a particular machine model or
programming language, and showing that they are captured by (non-deterministic)
sequential Abstract State Machines (nd-seq ASMs). Moschovakis pointed out that
recursive algorithms such as mergesort are not covered by this theory. In this
article we propose an axiomatic definition of the notion of sequential
recursive algorithm which extends Gurevich's axioms for sequential algorithms
by a Recursion Postulate and allows us to prove that sequential recursive
algorithms are captured by recursive Abstract State Machines, an extension of
nd-seq ASMs by a CALL rule. Applying this recursive ASM thesis yields a
characterization of sequential recursive algorithms as finitely composed
concurrent algorithms all of whose concurrent runs are partial-order runs.Comment: 34 page