Satisfiability Rahul Santhanam University of Edinburgh joint work with Ryan Williams Plan of the Talk Introduction Background Results Algorithmic Results Small Number of Quantifier Alternations ID: 207215
Download Presentation The PPT/PDF document "Beating Brute Force Search for QBF" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
Beating Brute Force Search for QBF Satisfiability
Rahul
Santhanam
University of Edinburgh
(joint work with Ryan Williams)Slide2
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide3
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide4
The QBFSAT Problem
Input
: A quantified Boolean formula
ψ
= Q
1
X
1
Q
2
X
2
...
Q
k
X
k
φ
(X
1
, ... ,
X
k
)
Q
i
’s
are quantifiers in {
,
} : if
Q
i
=
, then Q
i+1
=
, and conversely
X
i
’s are
blocks
of variables
This is a k-QBFSAT instance. The number of
alternations
is k-1 (alternatively, the number of quantifier blocks is k)
φ
is by default a formula in CNF if
Q
k
=
, else in DNF (more generally, it could be a Boolean formula/circuit)
Question
: Is
ψ
true?Slide5
The QBFSAT Problem
Ψ
=
x
y
z
(x V y)
Λ
(x’ V z)
x
y
y
z
z
z
z
0
1
1
0
1
1
0
0Slide6
The QBFSAT Problem
Ψ
=
x
y
z
(x V y)
Λ
(x’ V z)
x
y
y
z
z
z
z
0
1
1
0
1
1
0
0
Ψ
is a YES instanceSlide7
Easy Facts
Brute Force Search
: QBFSAT can be solved in time 2
n
poly(m) on QBFs of size m with n variables
Hardness
: QBFSAT is PSPACE-complete
QBFSAT is unlikely to be in P, but can we do better than brute-force search?Slide8
Conventional Algorithmic Paradigms for
Satisfiability
DLL/Branching Algorithms
: Explore tree of potential assignments by iteratively choosing variables to branch on
Local Search
: Perform local search of solution space for a satisfying assignmentSlide9
Conventional Algorithmic Paradigms applied to QBFSAT
DLL/Branching Algorithms
: Power of DLL algorithms for SAT comes from choice of variables to branch on. For QBFs, this choice is much more restricted
Local Search
: “Solutions” are not polynomial-size any more, so search of solution space becomes infeasibleSlide10
Notation
Given a function s: N → N, we say that QBFSAT has
savings
s if there is an algorithm for QBFSAT running in time 2
n-s(n)
poly(m), where n is the number of variables and m the instance size
We call savings
ω
(log(n))
non-trivial
C-SAT:
Satisfiability problem for circuit class CSlide11
The Relevance of Theory to Practice
Algorithmic ideas which make implementations more effective/efficient
Insights into the structure of hard instancesSlide12
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide13
Our Results: Algorithms
Theorem 1:
k-QBFSAT has savings
Ω
(n
1/(k+1)
) when m = poly(n) (Note that this is non-trivial when k = o(log(n)/
loglog
(n))
Theorem 2:
k-QBFSAT has savings
Ω(k) (Note that this is non-trivial when k = ω(log(n)))Slide14
Our Results: Connections to Circuit Lower Bounds
Theorem 3:
Non-trivial savings for QBFSAT would imply NEXP does not have poly-size Boolean formulas
Theorem 4:
Savings
Ω
(n
ω
(1)/k
) for k-QBFSAT would imply NEXP does not have poly-size Boolean formulasSlide15
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide16
Reminder of Theorem 1
Theorem 1:
k-QBFSAT has savings
Ω
(n
1/(k+1)
) when m = poly(n) Slide17
Reminder of Theorem 1
Theorem 1:
k-QBFSAT has savings
Ω
(n
1/(k+1)
) when m = poly(n)
Proof Idea:
Branching +
memoization
Let
ψ = Q X Q’ Y φ(X,Y), where |X| = n-n1/(k+1), and Q, Q’ are strings of quantifiers
Let f(X) = Q’ Y φ(X,Y). First compute the truth table of f in time O(2n-n^{1/(k+1)})To solve
ψ, branch on X, using stored truth table to answer leaf queries in the branching tree. This can again be done in time O(2n-n^{1/(k+1)}) Slide18
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide19
Proof Sketch for Theorem 2
Reminder of Theorem 2:
k-QBFSAT has savings
Ω
(k)
The algorithm works even when
φ
(the quantifier-free part) is a Boolean circuit
Somewhat counter-intuitive: Problem gets
easier
when number of alternations increases! Slide20
The Idea
Essentially same as “game tree evaluation” of [Snir85] and [Saks-Wigderson86]
Evaluate existential and universal branches
randomly,
halting the existential search when a 1 is returned and the universal search when a 0 is returned
In either the YES or NO case, this saves
Ω
(1) bits on average for every two consecutive alternationsSlide21
Illustration
Ψ
=
x
y
z
(x V y)
Λ
(x’ V z)
x
y
y
z
z
z
z
0
1
1
0
1
1
0
0
Ψ
is a YES instance
Right branch, chosen with probability 1/2Slide22
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide23
Improved Algorithms?
Can we hope to achieve better savings than in Theorems 1 and 2?
How do different variants of QBFSAT relate to each other,
eg
., when
φ
is a Boolean formula as opposed to a CNF?Slide24
Reducing FormulaSAT
to QBFSAT
Lemma 1:
There is a polynomial-time algorithm which, given as input any Boolean formula on n variables of size poly(n), outputs an equivalent QBFSAT instance with
n+O
(log(n)) variables, size poly(n) and O(log(n)) alternations
Complexity inspiration: Classical result that NC
1
= ALOGTIME
Much more efficient than
Tseitin
transformationSlide25
Reducing QBFormulaSAT
to QBFSAT
Lemma 1’:
There is a polynomial-time algorithm which, given as input any quantified Boolean formula with k’ alternations on n variables of size poly(n), outputs an equivalent QBFSAT instance with
n+O
(log(n)) variables, size poly(n) and
k’+O
(log(n)) alternations
Complexity inspiration: Classical result that NC
1
= ALOGTIMESlide26
Implications
Corollary:
If QBFSAT in time 1.9
n
, then
QBFormulaSAT
in time 1.9
n+o(n)
By Williams’ algorithms-lbs connection for formulas,
i
f
FormulaSAT has savings ω(log(n)), then NEXP does not have poly-size formulasReminder of Theorem 4:
Non-trivial savings for QBFSAT would imply NEXP does not have poly-size formulasProof: By Lemma 1, non-trivial savings for QBFSAT imply non-trivial savings for FormulaSATSlide27
Reducing FormulaSAT
to k-QBFSAT
Lemma 2:
There is a polynomial-time algorithm which, given as input any Boolean formula on n variables of size poly(n), outputs an equivalent QBFSAT instance with
n+O
(n
1/k
) variables, size poly(n) and O(k) alternations
Complexity inspiration:
Nepomnjascii’s
result that every language in NC
1 in Σ
k-LIN for some fixed kSlide28
Reducing
QBFormulaSAT
to k-QBFSAT
Lemma 2’:
There is a polynomial-time algorithm which, given as input any quantified Boolean formula with k’ alternations on n variables of size poly(n), outputs an equivalent QBFSAT instance with
n+O
(n
1/k
) variables, size poly(n) and
k’+O
(k) alternations
Complexity inspiration: Nepomnjascii’s result that every language in NC
1 in Σk-LIN for some fixed kSlide29
Implications
Corollary:
If k-QBFSAT in time 1.9
n
, then
QBFormulaSAT
in time 1.9
n+o(n)
By Williams’ algorithms-lbs connection for formulas,
i
f
FormulaSAT has savings ω(log(n)), then NEXP does not have poly-size formulasReminder of Theorem 4:
Savings Ω(nω(1)/k) for k-QBFSAT would imply NEXP does not have poly-size formulasProof:
By Lemma 2, savings Ω(nω(1)/k) for k-QBFSAT imply non-trivial savings for FormulaSATSlide30
The Relevance of Theory to Practice
Algorithmic ideas which make implementations more effective/efficient: Game tree search, reductions of
FormulaSAT
to QBFSAT and k-QBFSAT?
Insights into the structure of hard instances: Instances are hard for k around log(n), doesn’t matter much whether base formula
φ
is constant width CNF or a general Boolean formulaSlide31
Plan of the Talk
Introduction
Background
Results
Algorithmic Results
Small Number of Quantifier Alternations
Large Number of Quantifier Alternations
Implications for Circuit Complexity
Future DirectionsSlide32
Future Directions
Algorithms for QBFSAT using polynomial space?
Better algorithms when instances are structured?
Evidence against improved algorithms based on conventional hardness assumptions?Slide33
Thank You!