118,704 research outputs found
Justifications in Constraint Handling Rules for Logical Retraction in Dynamic Algorithms
We present a straightforward source-to-source transformation that introduces
justifications for user-defined constraints into the CHR programming language.
Then a scheme of two rules suffices to allow for logical retraction (deletion,
removal) of constraints during computation. Without the need to recompute from
scratch, these rules remove not only the constraint but also undo all
consequences of the rule applications that involved the constraint. We prove a
confluence result concerning the rule scheme and show its correctness. When
algorithms are written in CHR, constraints represent both data and operations.
CHR is already incremental by nature, i.e. constraints can be added at runtime.
Logical retraction adds decrementality. Hence any algorithm written in CHR with
justifications will become fully dynamic. Operations can be undone and data can
be removed at any point in the computation without compromising the correctness
of the result. We present two classical examples of dynamic algorithms, written
in our prototype implementation of CHR with justifications that is available
online: maintaining the minimum of a changing set of numbers and shortest paths
in a graph whose edges change.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
Asymptotic Proportion of Hard Instances of the Halting Problem
Although the halting problem is undecidable, imperfect testers that fail on
some instances are possible. Such instances are called hard for the tester. One
variant of imperfect testers replies "I don't know" on hard instances, another
variant fails to halt, and yet another replies incorrectly "yes" or "no". Also
the halting problem has three variants: does a given program halt on the empty
input, does a given program halt when given itself as its input, or does a
given program halt on a given input. The failure rate of a tester for some size
is the proportion of hard instances among all instances of that size. This
publication investigates the behaviour of the failure rate as the size grows
without limit. Earlier results are surveyed and new results are proven. Some of
them use C++ on Linux as the computational model. It turns out that the
behaviour is sensitive to the details of the programming language or
computational model, but in many cases it is possible to prove that the
proportion of hard instances does not vanish.Comment: 18 pages. The differences between this version and arXiv:1307.7066v1
are significant. They have been listed in the last paragraph of Section 1.
Excluding layout, this arXiv version is essentially identical to the Acta
Cybernetica versio
Face-to-face and online collaboration: appreciating rules and adding complexity
This paper reports how 6-8 year-old children build, play and share video-games in an animated programming environment. Children program their games using rules as creative tools in the construction process. While working both face-to-face and remotely on their games, we describe how they can collaboratively come to explain phenomena arising from programmed or 'system' rules. Focusing on one illustrative case study of two children, we propose two conjectures. First, we claim that in face-to-face collaboration, the children centre their attention on narrative, and address the problem of translating the narrative into system rules which can be =programmed‘ into the computer. This allowed the children to debug any conflicts between system rules in order to maintain the flow of the game narrative. A second conjecture is that over the Internet children were encouraged to add complexity and innovative elements to their games, not by the addition of socially-constructed or 'player' rules but rather through additional system rules which elaborate the mini-formalism in which they engaged. This shift of attention to system rules occurred at the same time, and perhaps as a result of, a loosening of the game narrative that was a consequence of the remoteness of the interaction
Active Self-Assembly of Algorithmic Shapes and Patterns in Polylogarithmic Time
We describe a computational model for studying the complexity of
self-assembled structures with active molecular components. Our model captures
notions of growth and movement ubiquitous in biological systems. The model is
inspired by biology's fantastic ability to assemble biomolecules that form
systems with complicated structure and dynamics, from molecular motors that
walk on rigid tracks and proteins that dynamically alter the structure of the
cell during mitosis, to embryonic development where large-scale complicated
organisms efficiently grow from a single cell. Using this active self-assembly
model, we show how to efficiently self-assemble shapes and patterns from simple
monomers. For example, we show how to grow a line of monomers in time and
number of monomer states that is merely logarithmic in the length of the line.
Our main results show how to grow arbitrary connected two-dimensional
geometric shapes and patterns in expected time that is polylogarithmic in the
size of the shape, plus roughly the time required to run a Turing machine
deciding whether or not a given pixel is in the shape. We do this while keeping
the number of monomer types logarithmic in shape size, plus those monomers
required by the Kolmogorov complexity of the shape or pattern. This work thus
highlights the efficiency advantages of active self-assembly over passive
self-assembly and motivates experimental effort to construct general-purpose
active molecular self-assembly systems
Concepts and their Use for Modelling Objects and References in Programming Languages
In the paper a new programming construct, called concept, is introduced.
Concept is pair of two classes: a reference class and an object class.
Instances of the reference classes are passed-by-value and are intended to
represent objects. Instances of the object class are passed-by-reference. An
approach to programming where concepts are used instead of classes is called
concept-oriented programming (CoP). In CoP objects are represented and accessed
indirectly by means of references. The structure of concepts describes a
hierarchical space with a virtual address system. The paper describes this new
approach to programming including such mechanisms as reference resolution,
complex references, method interception, dual methods, life-cycle management
inheritance and polymorphism.Comment: 43 pages. Related papers: http://conceptoriented.com
- …