3,184 research outputs found
Foundational Extensible Corecursion
This paper presents a formalized framework for defining corecursive functions
safely in a total setting, based on corecursion up-to and relational
parametricity. The end product is a general corecursor that allows corecursive
(and even recursive) calls under well-behaved operations, including
constructors. Corecursive functions that are well behaved can be registered as
such, thereby increasing the corecursor's expressiveness. The metatheory is
formalized in the Isabelle proof assistant and forms the core of a prototype
tool. The corecursor is derived from first principles, without requiring new
axioms or extensions of the logic
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 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
Instruction sequences with dynamically instantiated instructions
We study sequential programs that are instruction sequences with dynamically
instantiated instructions. We define the meaning of such programs in two
different ways. In either case, we give a translation by which each program
with dynamically instantiated instructions is turned into a program without
them that exhibits on execution the same behaviour by interaction with some
service. The complexity of the translations differ considerably, whereas the
services concerned are equally simple. However, the service concerned in the
case of the simpler translation is far more powerful than the service concerned
in the other case.Comment: 25 pages; phrasing improve
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
Cyclic Datatypes modulo Bisimulation based on Second-Order Algebraic Theories
Cyclic data structures, such as cyclic lists, in functional programming are
tricky to handle because of their cyclicity. This paper presents an
investigation of categorical, algebraic, and computational foundations of
cyclic datatypes. Our framework of cyclic datatypes is based on second-order
algebraic theories of Fiore et al., which give a uniform setting for syntax,
types, and computation rules for describing and reasoning about cyclic
datatypes. We extract the "fold" computation rules from the categorical
semantics based on iteration categories of Bloom and Esik. Thereby, the rules
are correct by construction. We prove strong normalisation using the General
Schema criterion for second-order computation rules. Rather than the fixed
point law, we particularly choose Bekic law for computation, which is a key to
obtaining strong normalisation. We also prove the property of "Church-Rosser
modulo bisimulation" for the computation rules. Combining these results, we
have a remarkable decidability result of the equational theory of cyclic data
and fold.Comment: 38 page
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
Programming an interpreter using molecular dynamics
PGA (ProGram Algebra) is an algebra of programs which concerns programs in
their simplest form: sequences of instructions. Molecular dynamics is a simple
model of computation developed in the setting of PGA, which bears on the use of
dynamic data structures in programming. We consider the programming of an
interpreter for a program notation that is close to existing assembly languages
using PGA with the primitives of molecular dynamics as basic instructions. It
happens that, although primarily meant for explaining programming language
features relating to the use of dynamic data structures, the collection of
primitives of molecular dynamics in itself is suited to our programming wants.Comment: 27 page
A Hoare-like logic of asserted single-pass instruction sequences
We present a formal system for proving the partial correctness of a
single-pass instruction sequence as considered in program algebra by
decomposition into proofs of the partial correctness of segments of the
single-pass instruction sequence concerned. The system is similar to Hoare
logics, but takes into account that, by the presence of jump instructions,
segments of single-pass instruction sequences may have multiple entry points
and multiple exit points. It is intended to support a sound general
understanding of the issues with Hoare-like logics for low-level programming
languages.Comment: 22 pages, the preliminaries have textual overlaps with the
preliminaries in arXiv:1402.4950 [cs.LO] and earlier papers; introduction and
conclusions rewritten, explanatory remarks added; introduction partly
rewritten; 24 pages, clarifying examples adde
- …