8,837 research outputs found
Linear-Logic Based Analysis of Constraint Handling Rules with Disjunction
Constraint Handling Rules (CHR) is a declarative committed-choice programming
language with a strong relationship to linear logic. Its generalization CHR
with Disjunction (CHRv) is a multi-paradigm declarative programming language
that allows the embedding of horn programs. We analyse the assets and the
limitations of the classical declarative semantics of CHR before we motivate
and develop a linear-logic declarative semantics for CHR and CHRv. We show how
to apply the linear-logic semantics to decide program properties and to prove
operational equivalence of CHRv programs across the boundaries of language
paradigms
A correct, precise and efficient integration of set-sharing, freeness and linearity for the analysis of finite and rational tree languages
It is well known that freeness and linearity information positively interact with aliasing information, allowing both the precision and the efficiency of the sharing analysis of logic programs to be improved. In this paper, we present a novel combination of set-sharing with freeness and linearity information, which is characterized by an improved abstract unification operator. We provide a new abstraction function and prove the correctness of the analysis for both the finite tree and the rational tree cases.
Moreover, we show that the same notion of redundant information as identified in Bagnara et al. (2000) and Zaffanella et al. (2002) also applies to this abstract domain combination: this allows for the implementation of an abstract unification operator running in polynomial time and achieving the same precision on all the considered observable properties
Transforming specifications of observable behaviour into programs
A methodology for deriving programs from specifications of observable
behaviour is described. The class of processes to which this methodology
is applicable includes those whose state changes are fully definable by labelled
transition systems, for example communicating processes without
internal state changes. A logic program representation of such labelled
transition systems is proposed, interpreters based on path searching techniques
are defined, and the use of partial evaluation techniques to derive
the executable programs is described
Problem of Time in Quantum Gravity
The Problem of Time occurs because the `time' of GR and of ordinary Quantum
Theory are mutually incompatible notions. This is problematic in trying to
replace these two branches of physics with a single framework in situations in
which the conditions of both apply, e.g. in black holes or in the very early
universe. Emphasis in this Review is on the Problem of Time being multi-faceted
and on the nature of each of the eight principal facets. Namely, the Frozen
Formalism Problem, Configurational Relationalism Problem (formerly Sandwich
Problem), Foliation Dependence Problem, Constraint Closure Problem (formerly
Functional Evolution Problem), Multiple Choice Problem, Global Problem of Time,
Problem of Beables (alias Problem of Observables) and Spacetime
Reconstruction/Replacement Problem. Strategizing in this Review is not just
centred about the Frozen Formalism Problem facet, but rather about each of the
eight facets. Particular emphasis is placed upon A) relationalism as an
underpinning of the facets and as a selector of particular strategies
(especially a modification of Barbour relationalism, though also with some
consideration of Rovelli relationalism). B) Classifying approaches by the full
ordering in which they embrace constrain, quantize, find time/history and find
observables, rather than only by partial orderings such as "Dirac-quantize". C)
Foliation (in)dependence and Spacetime Reconstruction for a wide range of
physical theories, strategizing centred about the Problem of Beables, the
Patching Approach to the Global Problem of Time, and the role of the
question-types considered in physics. D) The Halliwell- and
Gambini-Porto-Pullin-type combined Strategies in the context of semiclassical
quantum cosmology.Comment: Invited Review: 26 pages including 2 Figures. This v2 has a number of
minor improvements and correction
Algorithmic Thermodynamics
Algorithmic entropy can be seen as a special case of entropy as studied in
statistical mechanics. This viewpoint allows us to apply many techniques
developed for use in thermodynamics to the subject of algorithmic information
theory. In particular, suppose we fix a universal prefix-free Turing machine
and let X be the set of programs that halt for this machine. Then we can regard
X as a set of 'microstates', and treat any function on X as an 'observable'.
For any collection of observables, we can study the Gibbs ensemble that
maximizes entropy subject to constraints on expected values of these
observables. We illustrate this by taking the log runtime, length, and output
of a program as observables analogous to the energy E, volume V and number of
molecules N in a container of gas. The conjugate variables of these observables
allow us to define quantities which we call the 'algorithmic temperature' T,
'algorithmic pressure' P and algorithmic potential' mu, since they are
analogous to the temperature, pressure and chemical potential. We derive an
analogue of the fundamental thermodynamic relation dE = T dS - P d V + mu dN,
and use it to study thermodynamic cycles analogous to those for heat engines.
We also investigate the values of T, P and mu for which the partition function
converges. At some points on the boundary of this domain of convergence, the
partition function becomes uncomputable. Indeed, at these points the partition
function itself has nontrivial algorithmic entropy.Comment: 20 pages, one encapsulated postscript figur
On the Expressive Power of Multiple Heads in CHR
Constraint Handling Rules (CHR) is a committed-choice declarative language
which has been originally designed for writing constraint solvers and which is
nowadays a general purpose language. CHR programs consist of multi-headed
guarded rules which allow to rewrite constraints into simpler ones until a
solved form is reached. Many empirical evidences suggest that multiple heads
augment the expressive power of the language, however no formal result in this
direction has been proved, so far.
In the first part of this paper we analyze the Turing completeness of CHR
with respect to the underneath constraint theory. We prove that if the
constraint theory is powerful enough then restricting to single head rules does
not affect the Turing completeness of the language. On the other hand,
differently from the case of the multi-headed language, the single head CHR
language is not Turing powerful when the underlying signature (for the
constraint theory) does not contain function symbols.
In the second part we prove that, no matter which constraint theory is
considered, under some reasonable assumptions it is not possible to encode the
CHR language (with multi-headed rules) into a single headed language while
preserving the semantics of the programs. We also show that, under some
stronger assumptions, considering an increasing number of atoms in the head of
a rule augments the expressive power of the language.
These results provide a formal proof for the claim that multiple heads
augment the expressive power of the CHR language.Comment: v.6 Minor changes, new formulation of definitions, changed some
details in the proof
- …