6,649 research outputs found
On finitely recursive programs
Disjunctive finitary programs are a class of logic programs admitting
function symbols and hence infinite domains. They have very good computational
properties, for example ground queries are decidable while in the general case
the stable model semantics is highly undecidable. In this paper we prove that a
larger class of programs, called finitely recursive programs, preserves most of
the good properties of finitary programs under the stable model semantics,
namely: (i) finitely recursive programs enjoy a compactness property; (ii)
inconsistency checking and skeptical reasoning are semidecidable; (iii)
skeptical resolution is complete for normal finitely recursive programs.
Moreover, we show how to check inconsistency and answer skeptical queries using
finite subsets of the ground program instantiation. We achieve this by
extending the splitting sequence theorem by Lifschitz and Turner: We prove that
if the input program P is finitely recursive, then the partial stable models
determined by any smooth splitting omega-sequence converge to a stable model of
P.Comment: 26 pages, Preliminary version in Proc. of ICLP 2007, Best paper awar
Disjunctive ASP with Functions: Decidable Queries and Effective Computation
Querying over disjunctive ASP with functions is a highly undecidable task in
general. In this paper we focus on disjunctive logic programs with stratified
negation and functions under the stable model semantics (ASP^{fs}). We show
that query answering in this setting is decidable, if the query is finitely
recursive (ASP^{fs}_{fr}). Our proof yields also an effective method for query
evaluation. It is done by extending the magic set technique to ASP^{fs}_{fr}.
We show that the magic-set rewritten program is query equivalent to the
original one (under both brave and cautious reasoning). Moreover, we prove that
the rewritten program is also finitely ground, implying that it is decidable.
Importantly, finitely ground programs are evaluable using existing ASP solvers,
making the class of ASP^{fs}_{fr} queries usable in practice.Comment: 16 pages, 1 figur
Termination Proofs for Logic Programs with Tabling
Tabled logic programming is receiving increasing attention in the Logic
Programming community. It avoids many of the shortcomings of SLD execution and
provides a more flexible and often extremely efficient execution mechanism for
logic programs. In particular, tabled execution of logic programs terminates
more often than execution based on SLD-resolution. In this article, we
introduce two notions of universal termination of logic programming with
Tabling: quasi-termination and (the stronger notion of) LG-termination. We
present sufficient conditions for these two notions of termination, namely
quasi-acceptability and LG-acceptability, and we show that these conditions are
also necessary in case the tabling is well-chosen. Starting from these
conditions, we give modular termination proofs, i.e., proofs capable of
combining termination proofs of separate programs to obtain termination proofs
of combined programs. Finally, in the presence of mode information, we state
sufficient conditions which form the basis for automatically proving
termination in a constraint-based way.Comment: 48 pages, 6 figures, submitted to ACM Transactions on Computational
Logic (TOCL
On Generalized Computable Universal Priors and their Convergence
Solomonoff unified Occam's razor and Epicurus' principle of multiple
explanations to one elegant, formal, universal theory of inductive inference,
which initiated the field of algorithmic information theory. His central result
is that the posterior of the universal semimeasure M converges rapidly to the
true sequence generating posterior mu, if the latter is computable. Hence, M is
eligible as a universal predictor in case of unknown mu. The first part of the
paper investigates the existence and convergence of computable universal
(semi)measures for a hierarchy of computability classes: recursive, estimable,
enumerable, and approximable. For instance, M is known to be enumerable, but
not estimable, and to dominate all enumerable semimeasures. We present proofs
for discrete and continuous semimeasures. The second part investigates more
closely the types of convergence, possibly implied by universality: in
difference and in ratio, with probability 1, in mean sum, and for Martin-Loef
random sequences. We introduce a generalized concept of randomness for
individual sequences and use it to exhibit difficulties regarding these issues.
In particular, we show that convergence fails (holds) on generalized-random
sequences in gappy (dense) Bernoulli classes.Comment: 22 page
Enforcing Termination of Interprocedural Analysis
Interprocedural analysis by means of partial tabulation of summary functions
may not terminate when the same procedure is analyzed for infinitely many
abstract calling contexts or when the abstract domain has infinite strictly
ascending chains. As a remedy, we present a novel local solver for general
abstract equation systems, be they monotonic or not, and prove that this solver
fails to terminate only when infinitely many variables are encountered. We
clarify in which sense the computed results are sound. Moreover, we show that
interprocedural analysis performed by this novel local solver, is guaranteed to
terminate for all non-recursive programs --- irrespective of whether the
complete lattice is infinite or has infinite strictly ascending or descending
chains
The Semantics of Graph Programs
GP (for Graph Programs) is a rule-based, nondeterministic programming
language for solving graph problems at a high level of abstraction, freeing
programmers from handling low-level data structures. The core of GP consists of
four constructs: single-step application of a set of conditional
graph-transformation rules, sequential composition, branching and iteration. We
present a formal semantics for GP in the style of structural operational
semantics. A special feature of our semantics is the use of finitely failing
programs to define GP's powerful branching and iteration commands
On approximate decidability of minimal programs
An index in a numbering of partial-recursive functions is called minimal
if every lesser index computes a different function from . Since the 1960's
it has been known that, in any reasonable programming language, no effective
procedure determines whether or not a given index is minimal. We investigate
whether the task of determining minimal indices can be solved in an approximate
sense. Our first question, regarding the set of minimal indices, is whether
there exists an algorithm which can correctly label 1 out of indices as
either minimal or non-minimal. Our second question, regarding the function
which computes minimal indices, is whether one can compute a short list of
candidate indices which includes a minimal index for a given program. We give
some negative results and leave the possibility of positive results as open
questions
- …