70 research outputs found
Bounds on BDD-Based Bucket Elimination
We study BDD-based bucket elimination, an approach to satisfiability testing using variable elimination which has seen several practical implementations in the past. We prove that it allows solving the standard pigeonhole principle formulas efficiently, when allowing different orders for variable elimination and BDD-representations, a variant of bucket elimination that was recently introduced. Furthermore, we show that this upper bound is somewhat brittle as for formulas which we get from the pigeonhole principle by restriction, i.e., fixing some of the variables, the same approach with the same variable orders has exponential runtime. We also show that the more common implementation of bucket elimination using the same order for variable elimination and the BDDs has exponential runtime for the pigeonhole principle when using either of the two orders from our upper bound, which suggests that the combination of both is the key to efficiency in the setting
Notes on "Bounds on BDD-Based Bucket Elimination''
This paper concerns Boolean satisfiability (SAT) solvers based on Ordered
Binary Decision Diagrams (BDDs), especially those that can generate proofs of
unsatisfiability. Mengel (arXiv:2306.00886) has presented a theoretical
analysis that a BDD-based SAT solver can generate a proof of unsatisfiability
for the pigeonhole problem (PHP) in polynomial time, even when the problem
is encoded in the standard ``direct'' form. His approach is based on bucket
elimination, using different orderings for the variables in the BDDs than in
the buckets. We show experimentally that these proofs scale as . We
also confirm the exponential scaling that occurs when the same variable
ordering is used for the BDDs as for the buckets.Comment: Unpublished not
Inference in Probabilistic Logic Programs using Weighted CNF's
Probabilistic logic programs are logic programs in which some of the facts
are annotated with probabilities. Several classical probabilistic inference
tasks (such as MAP and computing marginals) have not yet received a lot of
attention for this formalism. The contribution of this paper is that we develop
efficient inference algorithms for these tasks. This is based on a conversion
of the probabilistic logic program and the query and evidence to a weighted CNF
formula. This allows us to reduce the inference tasks to well-studied tasks
such as weighted model counting. To solve such tasks, we employ
state-of-the-art methods. We consider multiple methods for the conversion of
the programs as well as for inference on the weighted CNF. The resulting
approach is evaluated experimentally and shown to improve upon the
state-of-the-art in probabilistic logic programming
Proof Generation for CDCL Solvers Using Gauss-Jordan Elimination
Traditional Boolean satisfiability (SAT) solvers based on the conflict-driven
clause-learning (CDCL) framework fare poorly on formulas involving large
numbers of parity constraints. The CryptoMiniSat solver augments CDCL with
Gauss-Jordan elimination to greatly improve performance on these formulas.
Integrating the TBUDDY proof-generating BDD library into CryptoMiniSat enables
it to generate unsatisfiability proofs when using Gauss-Jordan elimination.
These proofs are compatible with standard, clausal proof frameworks.Comment: Presented at 2022 Workshop on the Pragmatics of SA
Generating Extended Resolution Proofs with a BDD-Based SAT Solver
In 2006, Biere, Jussila, and Sinz made the key observation that the
underlying logic behind algorithms for constructing Reduced, Ordered Binary
Decision Diagrams (BDDs) can be encoded as steps in a proof in the extended
resolution logical framework. Through this, a BDD-based Boolean satisfiability
(SAT) solver can generate a checkable proof of unsatisfiability for a set of
clauses. Such a proof indicates that the formula is truly unsatisfiable without
requiring the user to trust the BDD package or the SAT solver built on top of
it.
We extend their work to enable arbitrary existential quantification of the
formula variables, a critical capability for BDD-based SAT solvers. We
demonstrate the utility of this approach by applying a prototype solver to
several problems that are very challenging for search-based SAT solvers,
obtaining polynomially sized proofs on benchmarks for parity formulas, as well
as the Urquhart, mutilated chessboard, and pigeonhole problems.Comment: Extended version of paper published at TACAS 202
Making Practical: Efficient Interactive Protocols for BDD Algorithms
We show that interactive protocols between a prover and a verifier, a
well-known tool of complexity theory, can be used in practice to certify the
correctness of automated reasoning tools.
Theoretically, interactive protocols exist for all
problems. The verifier of a protocol checks the prover's answer to a problem
instance in polynomial time, with polynomially many bits of communication, and
with exponentially small probability of error. (The prover may need exponential
time.) Existing interactive protocols are not used in practice because their
provers use naive algorithms, inefficient even for small instances, that are
incompatible with practical implementations of automated reasoning.
We bridge the gap between theory and practice by means of a novel interactive
protocol whose prover uses BDDs. We consider the problem of counting the number
of assignments to a QBF instance (), which has a natural
BDD-based algorithm. We give an interactive protocol for whose
prover is implemented on top of an extended BDD library. The prover has only a
linear overhead in computation time over the natural algorithm.
We have implemented our protocol in , a certifying tool for
. Experiments on standard QBF benchmarks show that \blic\ is
competitive with state-of-the-art QBF-solvers. The run time of the verifier is
negligible. While loss of absolute certainty can be concerning, the error
probability in our experiments is at most and reduces to
by repeating the verification times
Efficient Certified Resolution Proof Checking
We present a novel propositional proof tracing format that eliminates complex
processing, thus enabling efficient (formal) proof checking. The benefits of
this format are demonstrated by implementing a proof checker in C, which
outperforms a state-of-the-art checker by two orders of magnitude. We then
formalize the theory underlying propositional proof checking in Coq, and
extract a correct-by-construction proof checker for our format from the
formalization. An empirical evaluation using 280 unsatisfiable instances from
the 2015 and 2016 SAT competitions shows that this certified checker usually
performs comparably to a state-of-the-art non-certified proof checker. Using
this format, we formally verify the recent 200 TB proof of the Boolean
Pythagorean Triples conjecture
Extracting verified decision procedures: DPLL and Resolution
This article is concerned with the application of the program extraction technique to a new class of problems: the synthesis of decision procedures for the classical satisfiability problem that are correct by construction. To this end, we formalize a completeness proof for the DPLL proof system and extract a SAT solver from it. When applied to a propositional formula in conjunctive normal form the program produces either a satisfying assignment or a DPLL derivation showing its unsatisfiability. We use non-computational quantifiers to remove redundant computational content from the extracted program and translate it into Haskell to improve performance. We also prove the equivalence between the resolution proof system and the DPLL proof system with a bound on the size of the resulting resolution proof. This demonstrates that it is possible to capture quantitative information about the extracted program on the proof level. The formalization is carried out in the interactive proof assistant Minlog
- …