338 research outputs found
Detecting Decidable Classes of Finitely Ground Logic Programs with Function Symbols
In this article, we propose a new technique for checking whether the bottom-up evaluation of logic programs with function symbols terminates. The technique is based on the definition of
mappings
from arguments to strings of function symbols, representing possible values which could be taken by arguments during the bottom-up evaluation. Starting from mappings, we identify
mapping-restricted
arguments, a subset of limited arguments, namely arguments that take values from finite domains. Mapping-restricted programs, consisting of rules whose arguments are all mapping restricted, are terminating under the bottom-up computation, as all of its arguments take values from finite domains. We show that mappings can be computed by transforming the original program into a unary logic program: this allows us to establish decidability of checking if a program is mapping restricted. We study the complexity of the presented approach and compare it to other techniques known in the literature. We also introduce an extension of the proposed approach that is able to recognize a wider class of logic programs. The presented technique provides a significant improvement, as it can detect terminating programs not identified by other criteria proposed so far. Furthermore, it can be combined with other techniques to further enlarge the class of programs recognized as terminating under the bottom-up evaluation.
</jats:p
The data-exchange chase under the microscope
In this paper we take closer look at recent developments for the chase
procedure, and provide additional results. Our analysis allows us create a
taxonomy of the chase variations and the properties they satisfy. Two of the
most central problems regarding the chase is termination, and discovery of
restricted classes of sets of dependencies that guarantee termination of the
chase. The search for the restricted classes has been motivated by a fairly
recent result that shows that it is undecidable to determine whether the chase
with a given dependency set will terminate on a given instance. There is a
small dissonance here, since the quest has been for classes of sets of
dependencies guaranteeing termination of the chase on all instances, even
though the latter problem was not known to be undecidable. We resolve the
dissonance in this paper by showing that determining whether the chase with a
given set of dependencies terminates on all instances is coRE-complete. For the
hardness proof we use a reduction from word rewriting systems, thereby also
showing the close connection between the chase and word rewriting. The same
reduction also gives us the aforementioned instance-dependent RE-completeness
result as a byproduct. For one of the restricted classes guaranteeing
termination on all instances, the stratified sets dependencies, we provide new
complexity results for the problem of testing whether a given set of
dependencies belongs to it. These results rectify some previous claims that
have occurred in the literature.Comment: arXiv admin note: substantial text overlap with arXiv:1303.668
Exploiting Equality Generating Dependencies in Checking Chase Termination
The chase is a well-known algorithm with a wide range of applications in data exchange, data cleaning, data integration, query optimization, and ontological reasoning. Since the chase evaluation might not terminate and it is undecidable whether it terminates, the problem of defining (decidable) sufficient conditions ensuring termination has received a great deal of interest in recent years. In this regard, several termination criteria have been proposed. One of the main weaknesses of current approaches is the limited analysis they perform on
equality generating dependencies
(EGDs).
In this paper, we propose sufficient conditions ensuring that a set of dependencies has at least one terminating chase sequence. We propose novel criteria which are able to perform a more accurate analysis of EGDs. Specifically, we propose a new stratification criterion and an adornment algorithm. The latter can both be used as a termination criterion and be combined with current techniques to make them more effective, in that strictly more sets of dependencies are identified. Our techniques identify sets of dependencies that are not recognized by any of the current criteria.</jats:p
Using linear constraints for logic program termination analysis
It is widely acknowledged that function symbols are an important feature in
answer set programming, as they make modeling easier, increase the expressive
power, and allow us to deal with infinite domains. The main issue with their
introduction is that the evaluation of a program might not terminate and
checking whether it terminates or not is undecidable. To cope with this
problem, several classes of logic programs have been proposed where the use of
function symbols is restricted but the program evaluation termination is
guaranteed. Despite the significant body of work in this area, current
approaches do not include many simple practical programs whose evaluation
terminates. In this paper, we present the novel classes of rule-bounded and
cycle-bounded programs, which overcome different limitations of current
approaches by performing a more global analysis of how terms are propagated
from the body to the head of rules. Results on the correctness, the complexity,
and the expressivity of the proposed approach are provided.Comment: Under consideration in Theory and Practice of Logic Programming
(TPLP
Checking termination of bottom-up evaluation of logic programs with function symbols
Recently, there has been an increasing interest in the bottom-up evaluation
of the semantics of logic programs with complex terms. The presence of function
symbols in the program may render the ground instantiation infinite, and
finiteness of models and termination of the evaluation procedure, in the
general case, are not guaranteed anymore. Since the program termination problem
is undecidable in the general case, several decidable criteria (called program
termination criteria) have been recently proposed. However, current conditions
are not able to identify even simple programs, whose bottom-up execution always
terminates. The paper introduces new decidable criteria for checking
termination of logic programs with function symbols under bottom-up evaluation,
by deeply analyzing the program structure. First, we analyze the propagation of
complex terms among arguments by means of the extended version of the argument
graph called propagation graph. The resulting criterion, called
Gamma-acyclicity, generalizes most of the decidable criteria proposed so far.
Next, we study how rules may activate each other and define a more powerful
criterion, called safety. This criterion uses the so-called safety function
able to analyze how rules may activate each other and how the presence of some
arguments in a rule limits its activation. We also study the application of the
proposed criteria to bound queries and show that the safety criterion is
well-suited to identify relevant classes of programs and bound queries.
Finally, we propose a hierarchy of classes of terminating programs, called
k-safety, where the k-safe class strictly includes the (k-1)-safe class. Note:
To appear in Theory and Practice of Logic Programming (TPLP).Comment: 36 pages, 7 figure
- …