1,739 research outputs found
Abstract Canonical Inference
An abstract framework of canonical inference is used to explore how different
proof orderings induce different variants of saturation and completeness.
Notions like completion, paramodulation, saturation, redundancy elimination,
and rewrite-system reduction are connected to proof orderings. Fairness of
deductive mechanisms is defined in terms of proof orderings, distinguishing
between (ordinary) "fairness," which yields completeness, and "uniform
fairness," which yields saturation.Comment: 28 pages, no figures, to appear in ACM Trans. on Computational Logi
Complexity of Propositional Proofs under a Promise
We study -- within the framework of propositional proof complexity -- the
problem of certifying unsatisfiability of CNF formulas under the promise that
any satisfiable formula has many satisfying assignments, where ``many'' stands
for an explicitly specified function \Lam in the number of variables . To
this end, we develop propositional proof systems under different measures of
promises (that is, different \Lam) as extensions of resolution. This is done
by augmenting resolution with axioms that, roughly, can eliminate sets of truth
assignments defined by Boolean circuits. We then investigate the complexity of
such systems, obtaining an exponential separation in the average-case between
resolution under different size promises:
1. Resolution has polynomial-size refutations for all unsatisfiable 3CNF
formulas when the promise is \eps\cd2^n, for any constant 0<\eps<1.
2. There are no sub-exponential size resolution refutations for random 3CNF
formulas, when the promise is (and the number of clauses is
), for any constant .Comment: 32 pages; a preliminary version appeared in the Proceedings of
ICALP'0
Cellular Automata are Generic
Any algorithm (in the sense of Gurevich's abstract-state-machine
axiomatization of classical algorithms) operating over any arbitrary unordered
domain can be simulated by a dynamic cellular automaton, that is, by a
pattern-directed cellular automaton with unconstrained topology and with the
power to create new cells. The advantage is that the latter is closer to
physical reality. The overhead of our simulation is quadratic.Comment: In Proceedings DCM 2014, arXiv:1504.0192
Automatic Termination Analysis of Programs Containing Arithmetic Predicates
For logic programs with arithmetic predicates, showing termination is not
easy, since the usual order for the integers is not well-founded. A new method,
easily incorporated in the TermiLog system for automatic termination analysis,
is presented for showing termination in this case.
The method consists of the following steps: First, a finite abstract domain
for representing the range of integers is deduced automatically. Based on this
abstraction, abstract interpretation is applied to the program. The result is a
finite number of atoms abstracting answers to queries which are used to extend
the technique of query-mapping pairs. For each query-mapping pair that is
potentially non-terminating, a bounded (integer-valued) termination function is
guessed. If traversing the pair decreases the value of the termination
function, then termination is established. Simple functions often suffice for
each query-mapping pair, and that gives our approach an edge over the classical
approach of using a single termination function for all loops, which must
inevitably be more complicated and harder to guess automatically. It is worth
noting that the termination of McCarthy's 91 function can be shown
automatically using our method.
In summary, the proposed approach is based on combining a finite abstraction
of the integers with the technique of the query-mapping pairs, and is
essentially capable of dividing a termination proof into several cases, such
that a simple termination function suffices for each case. Consequently, the
whole process of proving termination can be done automatically in the framework
of TermiLog and similar systems.Comment: Appeared also in Electronic Notes in Computer Science vol. 3
A General Framework for Automatic Termination Analysis of Logic Programs
This paper describes a general framework for automatic termination analysis
of logic programs, where we understand by ``termination'' the finitenes s of
the LD-tree constructed for the program and a given query. A general property
of mappings from a certain subset of the branches of an infinite LD-tree into a
finite set is proved. From this result several termination theorems are
derived, by using different finite sets. The first two are formulated for the
predicate dependency and atom dependency graphs. Then a general result for the
case of the query-mapping pairs relevant to a program is proved (cf.
\cite{Sagiv,Lindenstrauss:Sagiv}). The correctness of the {\em TermiLog} system
described in \cite{Lindenstrauss:Sagiv:Serebrenik} follows from it. In this
system it is not possible to prove termination for programs involving
arithmetic predicates, since the usual order for the integers is not
well-founded. A new method, which can be easily incorporated in {\em TermiLog}
or similar systems, is presented, which makes it possible to prove termination
for programs involving arithmetic predicates. It is based on combining a finite
abstraction of the integers with the technique of the query-mapping pairs, and
is essentially capable of dividing a termination proof into several cases, such
that a simple termination function suffices for each case. Finally several
possible extensions are outlined
- …