44,838 research outputs found
Instruction sequence processing operators
Instruction sequence is a key concept in practice, but it has as yet not come
prominently into the picture in theoretical circles. This paper concerns
instruction sequences, the behaviours produced by them under execution, the
interaction between these behaviours and components of the execution
environment, and two issues relating to computability theory. Positioning
Turing's result regarding the undecidability of the halting problem as a result
about programs rather than machines, and taking instruction sequences as
programs, we analyse the autosolvability requirement that a program of a
certain kind must solve the halting problem for all programs of that kind. We
present novel results concerning this autosolvability requirement. The analysis
is streamlined by using the notion of a functional unit, which is an abstract
state-based model of a machine. In the case where the behaviours exhibited by a
component of an execution environment can be viewed as the behaviours of a
machine in its different states, the behaviours concerned are completely
determined by a functional unit. The above-mentioned analysis involves
functional units whose possible states represent the possible contents of the
tapes of Turing machines with a particular tape alphabet. We also investigate
functional units whose possible states are the natural numbers. This
investigation yields a novel computability result, viz. the existence of a
universal computable functional unit for natural numbers.Comment: 37 pages; missing equations in table 3 added; combined with
arXiv:0911.1851 [cs.PL] and arXiv:0911.5018 [cs.LO]; introduction and
concluding remarks rewritten; remarks and examples added; minor error in
proof of theorem 4 correcte
On the behaviours produced by instruction sequences under execution
We study several aspects of the behaviours produced by instruction sequences
under execution in the setting of the algebraic theory of processes known as
ACP. We use ACP to describe the behaviours produced by instruction sequences
under execution and to describe two protocols implementing these behaviours in
the case where the processing of instructions takes place remotely. We also
show that all finite-state behaviours considered in ACP can be produced by
instruction sequences under execution.Comment: 36 pages, consolidates material from arXiv:0811.0436 [cs.PL],
arXiv:0902.2859 [cs.PL], and arXiv:0905.2257 [cs.PL]; abstract and
introduction rewritten, examples and proofs adde
Turing Impossibility Properties for Stack Machine Programming
The strong, intermediate, and weak Turing impossibility properties are
introduced. Some facts concerning Turing impossibility for stack machine
programming are trivially adapted from previous work. Several intriguing
questions are raised about the Turing impossibility properties concerning
different method interfaces for stack machine programming.Comment: arXiv admin note: substantial text overlap with arXiv:0910.556
Functional units for natural numbers
Interaction with services provided by an execution environment forms part of
the behaviours exhibited by instruction sequences under execution. Mechanisms
related to the kind of interaction in question have been proposed in the
setting of thread algebra. Like thread, service is an abstract behavioural
concept. The concept of a functional unit is similar to the concept of a
service, but more concrete. A state space is inherent in the concept of a
functional unit, whereas it is not inherent in the concept of a service. In
this paper, we establish the existence of a universal computable functional
unit for natural numbers and related results.Comment: 17 pages; notational mistakes in tables 5 and 6 corrected; erroneous
definition at bottom of page 9 correcte
Instruction sequences for the production of processes
Single-pass instruction sequences under execution are considered to produce
behaviours to be controlled by some execution environment. Threads as
considered in thread algebra model such behaviours: upon each action performed
by a thread, a reply from its execution environment determines how the thread
proceeds. Threads in turn can be looked upon as producing processes as
considered in process algebra. We show that, by apposite choice of basic
instructions, all processes that can only be in a finite number of states can
be produced by single-pass instruction sequences.Comment: 23 pages; acknowledgement corrected, reference update
On the expressiveness of single-pass instruction sequences
We perceive programs as single-pass instruction sequences. A single-pass
instruction sequence under execution is considered to produce a behaviour to be
controlled by some execution environment. Threads as considered in basic thread
algebra model such behaviours. We show that all regular threads, i.e. threads
that can only be in a finite number of states, can be produced by single-pass
instruction sequences without jump instructions if use can be made of Boolean
registers. We also show that, in the case where goto instructions are used
instead of jump instructions, a bound to the number of labels restricts the
expressiveness.Comment: 14 pages; error corrected, acknowledgement added; another error
corrected, another acknowledgement adde
Thread extraction for polyadic instruction sequences
In this paper, we study the phenomenon that instruction sequences are split
into fragments which somehow produce a joint behaviour. In order to bring this
phenomenon better into the picture, we formalize a simple mechanism by which
several instruction sequence fragments can produce a joint behaviour. We also
show that, even in the case of this simple mechanism, it is a non-trivial
matter to explain by means of a translation into a single instruction sequence
what takes place on execution of a collection of instruction sequence
fragments.Comment: 21 pages; error corrected; presentation improve
On algorithmic equivalence of instruction sequences for computing bit string functions
Every partial function from bit strings of a given length to bit strings of a
possibly different given length can be computed by a finite instruction
sequence that contains only instructions to set and get the content of Boolean
registers, forward jump instructions, and a termination instruction. We look
for an equivalence relation on instruction sequences of this kind that captures
to a reasonable degree the intuitive notion that two instruction sequences
express the same algorithm.Comment: 27 pages, the preliminaries have textual overlaps with the
preliminaries in arXiv:1308.0219 [cs.PL], arXiv:1312.1529 [cs.PL], and
arXiv:1312.1812 [cs.PL]; 27 pages, three paragraphs about Milner's
algorithmic equivalence hypothesis added to concluding remarks; 26 pages,
several minor improvements of the presentation mad
Probabilistic thread algebra
We add probabilistic features to basic thread algebra and its extensions with
thread-service interaction and strategic interleaving. Here, threads represent
the behaviours produced by instruction sequences under execution and services
represent the behaviours exhibited by the components of execution environments
of instruction sequences. In a paper concerned with probabilistic instruction
sequences, we proposed several kinds of probabilistic instructions and gave an
informal explanation for each of them. The probabilistic features added to the
extension of basic thread algebra with thread-service interaction make it
possible to give a formal explanation in terms of non-probabilistic
instructions and probabilistic services. The probabilistic features added to
the extensions of basic thread algebra with strategic interleaving make it
possible to cover strategies corresponding to probabilistic scheduling
algorithms.Comment: 25 pages (arXiv admin note: text overlap with arXiv:1408.2955,
arXiv:1402.4950); some simplifications made; substantially revise
- …