503 research outputs found
Knowledge Compilation of Logic Programs Using Approximation Fixpoint Theory
To appear in Theory and Practice of Logic Programming (TPLP), Proceedings of
ICLP 2015
Recent advances in knowledge compilation introduced techniques to compile
\emph{positive} logic programs into propositional logic, essentially exploiting
the constructive nature of the least fixpoint computation. This approach has
several advantages over existing approaches: it maintains logical equivalence,
does not require (expensive) loop-breaking preprocessing or the introduction of
auxiliary variables, and significantly outperforms existing algorithms.
Unfortunately, this technique is limited to \emph{negation-free} programs. In
this paper, we show how to extend it to general logic programs under the
well-founded semantics.
We develop our work in approximation fixpoint theory, an algebraical
framework that unifies semantics of different logics. As such, our algebraical
results are also applicable to autoepistemic logic, default logic and abstract
dialectical frameworks
TP-Compilation for inference in probabilistic logic programs
We propose TP -compilation, a new inference technique for probabilistic logic programs that is based on forward reasoning. TP -compilation proceeds incrementally in that it interleaves the knowledge compilation step for weighted model counting with forward reasoning on the logic program. This leads to a novel anytime algorithm that provides hard bounds on the inferred probabilities. The main difference with existing inference techniques for probabilistic logic programs is that these are a sequence of isolated transformations. Typically, these transformations include conversion of the ground program into an equivalent propositional formula and compilation of this formula into a more tractable target representation for weighted model counting. An empirical evaluation shows that TP -compilation effectively handles larger instances of complex or cyclic real-world problems than current sequential approaches, both for exact and anytime approximate inference. Furthermore, we show that TP -compilation is conducive to inference in dynamic domains as it supports efficient updates to the compiled model
Beyond the grounding bottleneck: Datalog techniques for inference in probabilistic logic programs
State-of-the-art inference approaches in probabilistic logic programming
typically start by computing the relevant ground program with respect to the
queries of interest, and then use this program for probabilistic inference
using knowledge compilation and weighted model counting. We propose an
alternative approach that uses efficient Datalog techniques to integrate
knowledge compilation with forward reasoning with a non-ground program. This
effectively eliminates the grounding bottleneck that so far has prohibited the
application of probabilistic logic programming in query answering scenarios
over knowledge graphs, while also providing fast approximations on classical
benchmarks in the field
Incremental and Modular Context-sensitive Analysis
Context-sensitive global analysis of large code bases can be expensive, which
can make its use impractical during software development. However, there are
many situations in which modifications are small and isolated within a few
components, and it is desirable to reuse as much as possible previous analysis
results. This has been achieved to date through incremental global analysis
fixpoint algorithms that achieve cost reductions at fine levels of granularity,
such as changes in program lines. However, these fine-grained techniques are
not directly applicable to modular programs, nor are they designed to take
advantage of modular structures. This paper describes, implements, and
evaluates an algorithm that performs efficient context-sensitive analysis
incrementally on modular partitions of programs. The experimental results show
that the proposed modular algorithm shows significant improvements, in both
time and memory consumption, when compared to existing non-modular, fine-grain
incremental analysis techniques. Furthermore, thanks to the proposed
inter-modular propagation of analysis information, our algorithm also
outperforms traditional modular analysis even when analyzing from scratch.Comment: 56 pages, 27 figures. To be published in Theory and Practice of Logic
Programming. v3 corresponds to the extended version of the ICLP2018 Technical
Communication. v4 is the revised version submitted to Theory and Practice of
Logic Programming. v5 (this one) is the final author version to be published
in TPL
Efficient Groundness Analysis in Prolog
Boolean functions can be used to express the groundness of, and trace
grounding dependencies between, program variables in (constraint) logic
programs. In this paper, a variety of issues pertaining to the efficient Prolog
implementation of groundness analysis are investigated, focusing on the domain
of definite Boolean functions, Def. The systematic design of the representation
of an abstract domain is discussed in relation to its impact on the algorithmic
complexity of the domain operations; the most frequently called operations
should be the most lightweight. This methodology is applied to Def, resulting
in a new representation, together with new algorithms for its domain operations
utilising previously unexploited properties of Def -- for instance,
quadratic-time entailment checking. The iteration strategy driving the analysis
is also discussed and a simple, but very effective, optimisation of induced
magic is described. The analysis can be implemented straightforwardly in Prolog
and the use of a non-ground representation results in an efficient, scalable
tool which does not require widening to be invoked, even on the largest
benchmarks. An extensive experimental evaluation is givenComment: 31 pages To appear in Theory and Practice of Logic Programmin
Incremental analysis of logic programs
Global analyzers traditionally read and analyze the entire program at once, in a non-incremental way. However, there are many situations which are not well suited to this simple model and which instead require reanalysis of certain parts of a program which has already been analyzed. In these cases, it appears inefficient to perform the analysis of the program again from scratch, as needs to be done with current systems. We describe how the fixpoint algorithms in current generic analysis engines can be extended to support incremental analysis. The possible changes to a program are classified into three types: addition, deletion, and arbitrary change. For each one of these, we provide one or more algorithms for identifying the parts of the analysis that must be recomputed and for performing the actual recomputation. The potential benefits and drawbacks of these algorithms are discussed. Finally, we present some experimental results obtained with an implementation of the algorithms in the PLAI generic abstract interpretation framework. The results show significant benefits when using the proposed incremental analysis algorithms
- …