13,835 research outputs found
Towards an ASM thesis for reflective sequential algorithms
Starting from Gurevich's thesis for sequential algorithms (the so-called
"sequential ASM thesis"), we propose a characterization of the behaviour of
sequential algorithms enriched with reflection. That is, we present a set of
postulates which we conjecture capture the fundamental properties of reflective
sequential algorithms (RSAs). Then we look at the plausibility of an ASM thesis
for the class of RSAs, defining a model of abstract state machine (which we
call reflective ASM) that we conjecture captures the class of RSAs as defined
by our postulates
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
ASMs and Operational Algorithmic Completeness of Lambda Calculus
We show that lambda calculus is a computation model which can step by step
simulate any sequential deterministic algorithm for any computable function
over integers or words or any datatype. More formally, given an algorithm above
a family of computable functions (taken as primitive tools, i.e., kind of
oracle functions for the algorithm), for every constant K big enough, each
computation step of the algorithm can be simulated by exactly K successive
reductions in a natural extension of lambda calculus with constants for
functions in the above considered family. The proof is based on a fixed point
technique in lambda calculus and on Gurevich sequential Thesis which allows to
identify sequential deterministic algorithms with Abstract State Machines. This
extends to algorithms for partial computable functions in such a way that
finite computations ending with exceptions are associated to finite reductions
leading to terms with a particular very simple feature.Comment: 37 page
Abstract State Machines 1988-1998: Commented ASM Bibliography
An annotated bibliography of papers which deal with or use Abstract State
Machines (ASMs), as of January 1998.Comment: Also maintained as a BibTeX file at http://www.eecs.umich.edu/gasm
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
Cellular Automata are Generic
Any algorithm (in the sense of Gurevich's abstract-state-machine
axiomatization of classical algorithms) operating over any arbitrary unordered
domain can be simulated by a dynamic cellular automaton, that is, by a
pattern-directed cellular automaton with unconstrained topology and with the
power to create new cells. The advantage is that the latter is closer to
physical reality. The overhead of our simulation is quadratic.Comment: In Proceedings DCM 2014, arXiv:1504.0192
Evolving MultiAlgebras unify all usual sequential computation models
It is well-known that Abstract State Machines (ASMs) can simulate
"step-by-step" any type of machines (Turing machines, RAMs, etc.). We aim to
overcome two facts: 1) simulation is not identification, 2) the ASMs simulating
machines of some type do not constitute a natural class among all ASMs. We
modify Gurevich's notion of ASM to that of EMA ("Evolving MultiAlgebra") by
replacing the program (which is a syntactic object) by a semantic object: a
functional which has to be very simply definable over the static part of the
ASM. We prove that very natural classes of EMAs correspond via "literal
identifications" to slight extensions of the usual machine models and also to
grammar models. Though we modify these models, we keep their computation
approach: only some contingencies are modified. Thus, EMAs appear as the
mathematical model unifying all kinds of sequential computation paradigms.Comment: 12 pages, Symposium on Theoretical Aspects of Computer Scienc
Interactive Small-Step Algorithms I: Axiomatization
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. Here we extend the axiomatization and, in a
companion paper, the proof, 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
- …