4,150 research outputs found
Complexity Bounds for Ordinal-Based Termination
`What more than its truth do we know if we have a proof of a theorem in a
given formal system?' We examine Kreisel's question in the particular context
of program termination proofs, with an eye to deriving complexity bounds on
program running times.
Our main tool for this are length function theorems, which provide complexity
bounds on the use of well quasi orders. We illustrate how to prove such
theorems in the simple yet until now untreated case of ordinals. We show how to
apply this new theorem to derive complexity bounds on programs when they are
proven to terminate thanks to a ranking function into some ordinal.Comment: Invited talk at the 8th International Workshop on Reachability
Problems (RP 2014, 22-24 September 2014, Oxford
Synthesis of sup-interpretations: a survey
In this paper, we survey the complexity of distinct methods that allow the
programmer to synthesize a sup-interpretation, a function providing an upper-
bound on the size of the output values computed by a program. It consists in a
static space analysis tool without consideration of the time consumption.
Although clearly related, sup-interpretation is independent from termination
since it only provides an upper bound on the terminating computations. First,
we study some undecidable properties of sup-interpretations from a theoretical
point of view. Next, we fix term rewriting systems as our computational model
and we show that a sup-interpretation can be obtained through the use of a
well-known termination technique, the polynomial interpretations. The drawback
is that such a method only applies to total functions (strongly normalizing
programs). To overcome this problem we also study sup-interpretations through
the notion of quasi-interpretation. Quasi-interpretations also suffer from a
drawback that lies in the subterm property. This property drastically restricts
the shape of the considered functions. Again we overcome this problem by
introducing a new notion of interpretations mainly based on the dependency
pairs method. We study the decidability and complexity of the
sup-interpretation synthesis problem for all these three tools over sets of
polynomials. Finally, we take benefit of some previous works on termination and
runtime complexity to infer sup-interpretations.Comment: (2012
Classes of Terminating Logic Programs
Termination of logic programs depends critically on the selection rule, i.e.
the rule that determines which atom is selected in each resolution step. In
this article, we classify programs (and queries) according to the selection
rules for which they terminate. This is a survey and unified view on different
approaches in the literature. For each class, we present a sufficient, for most
classes even necessary, criterion for determining that a program is in that
class. We study six classes: a program strongly terminates if it terminates for
all selection rules; a program input terminates if it terminates for selection
rules which only select atoms that are sufficiently instantiated in their input
positions, so that these arguments do not get instantiated any further by the
unification; a program local delay terminates if it terminates for local
selection rules which only select atoms that are bounded w.r.t. an appropriate
level mapping; a program left-terminates if it terminates for the usual
left-to-right selection rule; a program exists-terminates if there exists a
selection rule for which it terminates; finally, a program has bounded
nondeterminism if it only has finitely many refutations. We propose a
semantics-preserving transformation from programs with bounded nondeterminism
into strongly terminating programs. Moreover, by unifying different formalisms
and making appropriate assumptions, we are able to establish a formal hierarchy
between the different classes.Comment: 50 pages. The following mistake was corrected: In figure 5, the first
clause for insert was insert([],X,[X]
Ackermannian and Primitive-Recursive Bounds with Dickson's Lemma
Dickson's Lemma is a simple yet powerful tool widely used in termination
proofs, especially when dealing with counters or related data structures.
However, most computer scientists do not know how to derive complexity upper
bounds from such termination proofs, and the existing literature is not very
helpful in these matters.
We propose a new analysis of the length of bad sequences over (N^k,\leq) and
explain how one may derive complexity upper bounds from termination proofs. Our
upper bounds improve earlier results and are essentially tight
Problem Theory
The Turing machine, as it was presented by Turing himself, models the
calculations done by a person. This means that we can compute whatever any
Turing machine can compute, and therefore we are Turing complete. The question
addressed here is why, Why are we Turing complete? Being Turing complete also
means that somehow our brain implements the function that a universal Turing
machine implements. The point is that evolution achieved Turing completeness,
and then the explanation should be evolutionary, but our explanation is
mathematical. The trick is to introduce a mathematical theory of problems,
under the basic assumption that solving more problems provides more survival
opportunities. So we build a problem theory by fusing set and computing
theories. Then we construct a series of resolvers, where each resolver is
defined by its computing capacity, that exhibits the following property: all
problems solved by a resolver are also solved by the next resolver in the
series if certain condition is satisfied. The last of the conditions is to be
Turing complete. This series defines a resolvers hierarchy that could be seen
as a framework for the evolution of cognition. Then the answer to our question
would be: to solve most problems. By the way, the problem theory defines
adaptation, perception, and learning, and it shows that there are just three
ways to resolve any problem: routine, trial, and analogy. And, most
importantly, this theory demonstrates how problems can be used to found
mathematics and computing on biology.Comment: 43 page
Termination Casts: A Flexible Approach to Termination with General Recursion
This paper proposes a type-and-effect system called Teqt, which distinguishes
terminating terms and total functions from possibly diverging terms and partial
functions, for a lambda calculus with general recursion and equality types. The
central idea is to include a primitive type-form "Terminates t", expressing
that term t is terminating; and then allow terms t to be coerced from possibly
diverging to total, using a proof of Terminates t. We call such coercions
termination casts, and show how to implement terminating recursion using them.
For the meta-theory of the system, we describe a translation from Teqt to a
logical theory of termination for general recursive, simply typed functions.
Every typing judgment of Teqt is translated to a theorem expressing the
appropriate termination property of the computational part of the Teqt term.Comment: In Proceedings PAR 2010, arXiv:1012.455
On Probabilistic Parallel Programs with Process Creation and Synchronisation
We initiate the study of probabilistic parallel programs with dynamic process
creation and synchronisation. To this end, we introduce probabilistic
split-join systems (pSJSs), a model for parallel programs, generalising both
probabilistic pushdown systems (a model for sequential probabilistic procedural
programs which is equivalent to recursive Markov chains) and stochastic
branching processes (a classical mathematical model with applications in
various areas such as biology, physics, and language processing). Our pSJS
model allows for a possibly recursive spawning of parallel processes; the
spawned processes can synchronise and return values. We study the basic
performance measures of pSJSs, especially the distribution and expectation of
space, work and time. Our results extend and improve previously known results
on the subsumed models. We also show how to do performance analysis in
practice, and present two case studies illustrating the modelling power of
pSJSs.Comment: This is a technical report accompanying a TACAS'11 pape
- …