Loading in 5 sec....

The Evergreen Project: The Promise of Polynomials to Boost CSP/SAT Techniques*PowerPoint Presentation

The Evergreen Project: The Promise of Polynomials to Boost CSP/SAT Techniques*

- By
**eli** - Follow User

- 113 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' The Evergreen Project: The Promise of Polynomials to Boost CSP/SAT Techniques*' - eli

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### The Evergreen Project: The Promise of Polynomials to Boost CSP/SAT Techniques*

Where we are

### The Evergreen Project: triedHow To Learn From Mistakes Caused by Blurry Vision in MAX-CSP Solving

### MAX-CSP: triedSuperresolution and P-Optimality

### The Evergreen Project: triedAssessing the Guidanceof Look-Ahead Polynomials in MAX-CSP Solving

Karl J. Lieberherr

Northeastern University

Boston

joint work with Ahmed Abdelmeged, Christine Hang and Daniel Rinehart

Title inspired by a paper by Carla Gomes / David Shmoys

Abstract

We invent a simple game, called the Evergreen Game, which is about generating and solving Boolean MAX-CSP problems. The fallouts from the Evergreen Game are surprising:

- Although the game is about constructing and solving MAX-CSP problems, simple, efficient algorithms are sufficient to guarantee a draw. The best game-playing strategy leads to a significant reduction of the huge search space for both formula generation and solving.

Abstract

- Fallouts (continued)
- The Evergreen Game shows us how to systematically translate a CSP formula into a polynomial that is fundamental in playing the game well.
- We have some (but incomplete) evidence that those polynomials are useful for efficient MAX-CSP as well as MAX-SAT and SAT solvers.

Where we are

- Introduction
- The Evergreen Game
- The Evergreen Player as Preprocessor
- Some Experimental Results

Problem Snapshot

- SAT: classic problem in complexity theory
- SAT & MAX-SAT Solvers: working on CNFs (a multi-set of disjunctions).
- Boolean CSP: constraint satisfaction problem
- Each constraint uses a Boolean relation.
- e.g. a Boolean relation 1in3(x y z) is satisfied iff exactly one of its parameters is true.

- Boolean MAX-CSPa multi-set of constraints.

Introduction

- Boolean MAX-CSP(G) for rank d, G = set of relations of rank d
- Input
- Input = Bag of Constraint = CSP(G) instance
- Constraint = Relation + Set of Variable
- Relation = int. // Relation number < 2 ^ (2 ^ d) in G
- Variable = int

- Output
- (0,1) assignment to variables which maximizes the number of satisfied constraints.

- Input
- Example Input: G = {22} of rank 3. H =
- 22:1 2 3 0
- 22:1 2 4 0
- 22:1 3 4 0

1in3 has number 22

M = {1 !2 !3 !4} satisfies all

Variation

MAX-CSP(G,f):

Given a CSP(G) instance H expressed in n variables which may assume only the values 0 or 1, find an assignment to the n variables which satisfies at least the fraction f of the constraints in H.

Example: G = {22} of rank 3

MAX-CSP({22},f): H =

22:1 2 3 0

22:1 2 4 0 in MAX-CSP({22},?). Highest value for ?

22:1 3 4 0

22: 2 3 4 0

Where we are

- Introduction
- The Evergreen Game
- The Evergreen Player as Preprocessor
- Some Experimental Results

The Game by Example(special case of Evergreen(2,2))

- The Evergreen Game is played by two players, Anna and Bob, that take turns creating and solving CSP formulae and paying each other a percentage of a wager based on the fraction of constraints satisfied.
- Let the wager w be 1 million dollars and the constraints limited to Gamma ={OR(x,y), NOT(x)}.

The Game by Example

- Anna starts by constructing FInitial =
- {100: NOT(x), 150: NOT(y), 200: OR(x,y)}.

- Bob tries to find an assignment that satisfies the largest possible fraction of constraints. For example, the assignment {x=true, y=false} will satisfy (150+200)/450 approx 0.78. Anna then pays Bob 0.78 million dollars (w*0.78).

The Game by Example

- Bob now constructs a formula that Anna solves and pays Anna the percentage of the wager that she solved.

- Now Bob constructs a formula for Anna:
{3: NOT(x),

3: NOT(y),

2: NOT(z)

1: OR(x, y),

1: OR(x, z),

1: OR( y, z)}

- The best assignment that Anna finds is {x=false, y=false, z=true} which satisfies about the fraction 0.72.
- Bob keeps 0.06 million in his pocket.

Theorem 1

Game Evergreen(2,2) has polynomial time algorithms Construct(2,2) and Solve(2,2) for Bob so that Bob can achieve a draw even if Anna has unlimited computational resources.

The Game Evergreen(r,m) for Boolean MAX-CSP(G), r>1,m>0

Two players: They agree on a protocol P1 to choose a set of m relations of rank r.

- The players use P1 to choose a set G of m relations of rank r.
- Player 1 constructs a CSP(G) formula H with 1000 variables and gives it to player 2 (1 second limit).
- Player 2 gets paid the fraction of constraints she can satisfy in H (100 seconds limit).
- Take 1 turn and stop.

How would you play this game intelligently?

For details

- http://www.ccs.neu.edu/home/lieber/evergreen/game-life-science.html

Anna’s Objective:inf max problem

sat(H,M) = fraction of satisfied constraints in

CSP(G)-formula H by assignment M

tG = inf max sat(H,M)

all CSP(G)

instances H

all (0,1) assignments M

Bob’s Objective

Find an assignment that is at least as good as tG :

Algorithm Evergreen Player (linear time).

tG = inf max sat(H,M)

all CSP(G)

instances H

all (0,1) assignments M

Where we are

- Introduction
- The Evergreen Game
- The Evergreen Player as Preprocessor
- Some Experimental Results

Experiment

- We propose to put the Evergreen Player into action as a preprocessor for state-of-the-art SAT and MAX-SAT solvers.
- Use Evergreen Player to create a maximal assignment J for an input formula F.
- Feed n-map(F,J) to a fast solver.

- Introduction
- The Evergreen Game
- The Evergreen Player as Preprocessor
- Some Experimental Results

Results from 2007 Benchmarks

- Within the MAX3SAT benchmarks, there are 4 formulae where Toolbar timed out at 1200 seconds. (v70-c700.wcnf ~ v70-c1000.wcnf). Among these formulae, 1 has its ratio gotten worse (0.9985795) and 3 of 4 have their ratio gotten better with the average being roughly 1.0099673.
- Within the 3 MAXCUT benchmarks I've tried, there is one formula where Toolbar timed out at 1200 seconds. This formulae has its ratio unchanged.
- Among all the 20 benchmarks I've finished, 5 of them fall into the time-out category.

Other results from 2007 Benchmarks

- On some benchmarks where no timeout occurred the running time got better (by factors of 2 and 3) in 50 % of the cases with preprocessing.
- Preprocessing is very fast (linear).

yices: a nice improvement on one of the first examples we tried

- Yices without preprocessing:v2000-c8400average time = 888.048average sat ratio = 0.947143
- Yices with preprocessing:v2000-c8400average time = 0.0342615average sat ratio = 1

Conclusions tried

- Worth to investigate further.
- Suggests a cheap way to parallelize MAX-SAT and SAT solving: Run preprocessed and unpreprocessed version in parallel.

Thank you. tried

- The End.

Our approach by Example: triedSAT Rank 2 example

14 : 1 2 014 : 3 4 014 : 5 6 0 7 : 1 3 0 7 : 1 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

14: 1 2 = or(1 2)

7: 1 3 = or(!1 !3)

excellent peripheral vision tried

0 1 2 3 4 5 6 = k

8/9

7/9

Blurry vision

- What do we learn from the abstract representation?
- set 1/3 of the variables to true (maximize).
- the best assignment will satisfy at least 7/9 constraints.
- very useful but the vision is blurry in the “middle”.

appmean = approximation of the mean (k variables true)

Our approach by Example tried

- Given a CSP(G)-instance H and an assignment N which satisfies fraction f in H.
- Is there an assignment that satisfies more than f?
- YES (we are done), absH(mb) > f
- MAYBE, The closer absH() comes to f, the better

- Is it worthwhile to set a certain literal k to 1 so that we can reach an assignment which satisfies more than f
- YES (we are done), H1 = Hk=1, absH1(mb1) > f
- MAYBE, the closer absH1(mb1) comes to f, the better
- NO, UP or clause learning

- Is there an assignment that satisfies more than f?

absH= abstract representation of H

8/9 tried

7/9

abstract representation

14 : 1 2 014 : 3 4 014 : 5 6 0 7 : 1 3 0 7 : 1 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

H

3/9

0 1 2 3 4 5 6

14 : 2 014 : 3 4 014 : 5 6 0 7 : 1 3 0 7 : 1 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

6/7 = 8/9

5/7=7/9

H0

3/7=5/9

maximum assignment away

from max bias: blurry

0 1 2 3 4 5

8/9 tried

7/9

14 : 1 2 014 : 3 4 014 : 5 6 0 7 : 1 3 0 7 : 1 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

3/8

H

0 1 2 3 4 5 6

clearly

above

3/4

14 : 1 2 014 : 3 4 014 : 5 6 0 7 : 3 0 7 : 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

7/8=8/9

6/8=7/9

H1

maximum assignment away

from max bias: blurry

2/7=3/8

0 1 2 3 4 5

14 : 1 2 0 tried14 : 3 4 014 : 5 6 0 7 : 1 3 0 7 : 1 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

8/9

7/9

abstract representation

guarantees 7/9

H

7/8 = 8/9

6/7=8/9

6/8 = 7/9

5/7=7/9

abstract representation

guarantees 7/9

abstract representation

guarantees 8/9

H0

H1

NEVER GOES DOWN: DERANDOMIZATION

rank 2 tried

10: 1 = or(1)

7: 1 2 = or(!1 !2)

4/6

4/6

10 : 1 0

10 : 2 0

10 : 3 0

7 : 1 2 0

7 : 1 3 0

7 : 2 3 0

3/6

3/6

abstract representation guarantees

0.625 * 6 = 3.75: 4 satisfied.

0 1 2 3

4/6

4/6

4/6

4/6

5 : 1 0

10 : 2 0

10 : 3 0

13 : 1 2 0

13 : 1 3 0

7 : 2 3 0

3/6

3/6

rank 2

5: 1 = or(!1)

13: 1 2 = or(1 !2)

The effect of n-map

First Impression tried

- The abstract representation = look-ahead polynomials seems useful for guiding the search.
- The look-ahead polynomials give us averages: the guidance can be misleading because of outliers.
- But how can we compute the look-ahead polynomials?

Where we are tried

- Introduction
- Look-forward
- Look-backward
- SPOT: how to use the look-ahead polynomials together with superresolution.

Look Forward tried

- Why?
- To make informed decisions

- How?
- Abstract representation based on look-ahead polynomials

Look-ahead Polynomial tried(Intuition)

- The look-ahead polynomial computes the expected fraction of satisfied constraints among all random assignments that are produced with bias p.

Consider an instance: 40 variables, tried1000 constraints (1in3)

1, … ,40

22: 6 7 9 0

22: 12 27 38 0

Abstract representation:

reduce the instance to

look-ahead polynomial

3p(1-p)2 = B1,3(p) (Bernstein)

3p(1-p) tried2 for MAX-CSP({22})

Look-ahead Polynomial tried(Definition)

- H is a CSP(G) instance.
- N is an arbitrary assignment.
- The look-ahead polynomial laH,N(p) computes the expected fraction of satisfied constraints of H when each variable in N is flipped with probability p.

The general case MAX-CSP(G) tried

G = {R1, … }, tR(F) = fraction of constraints in F that use R.

appSATR(x) over all R is a

super set of the Bernstein polynomials

(computer graphics, weighted sum of Bernstein polynomials)

x = p

Rational Bezier Curves tried

Bernstein Polynomials tried

http://graphics.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf

all the appSAT triedR(x) polynomials

Look-ahead Polynomial in Action tried

- Focus on purely mathematical question first
- Algorithmic solution will follow
- Mathematical question: Given a CSP(G) instance. For which fractions f is there always an assignment satisfying fraction f of the constraints? In which constraint systems is it impossible to satisfy many constraints?

Remember? tried

MAX-CSP(G,f):

Given a CSP(G) instance H expressed in n variables which may assume only the values 0 or 1, find an assignment to the n variables which satisfies at least the fraction f of the constraints in H.

Example: G = {22} of rank 3

MAX-CSP({22},f):

22:1 2 3 0

22:1 2 4 0

22:1 3 4 0

22: 2 3 4 0

Mathematical Critical Transition Point tried

MAX-CSP({22},f):

For f ≤ u: problem has always a solution

For f≥ u + e: problem has not always a solution, e>0.

1

not always (solid)

u = critical transition point

always (fluid)

0

The Magic Number tried

- u = 4/9

3p(1-p) tried2 for MAX-CSP({22})

Produce the Magic Number tried

- Use an optimally biased coin
- 1/3 in this case

- In general: min max problem

The 22 reductions: triedNeeded for implementation

1,0

2,0

22

60

240

3,0

2,1

3,1

1,1

2,0

3,0

3

15

255

3,1

2,1

22 is expanded into 6 additional

relations.

0

The 22 N-Mappings: triedNeeded for implementation

1

41

134

2

2

0

0

1

1

22

73

146

104

2

2

0

0

97

148

1

22 is expanded into 7 additional

relations.

The 22 N-Mappings: triedNeeded for implementation

- N-mapped vars Relation#2 1 0 |------------------------0 0 0 | 220 0 1 | 410 1 0 | 731 0 0 | 97 0 1 1 | 1341 0 1 | 146 1 1 0 | 1481 1 1 | 104

General Dichotomy Theorem tried

MAX-CSP(G,f): For each finite set G of relations

there exists an algebraic number tG

For f ≤ tG: MAX-CSP(G,f) has polynomial solution

For f≥ tG+ e: MAX-CSP(G,f) is NP-complete, e>0.

1

hard (solid)

NP-complete

polynomial solution:

Use optimally biased coin.

Derandomize.

P-Optimal.

tG = critical transition point

easy (fluid)

Polynomial

0

due to Lieberherr/Specker (1979, 1982)

Context tried

- Ladner [Lad 75]: if P !=NP, then there are decision problems in NP that are neither NP-complete, nor they belong to P.
- Conceivable that MAX-CSP(G,f) contains problems of intermediate complexity.

General Dichotomy Theorem tried(Discussion)

MAX-CSP(G,f): For each finite set G of relations

there exists an algebraic number tG

For f≤ tG: MAX-CSP(G,f) has polynomial solution

For f≥ tG+ e: MAX-CSP(G,f) is NP-complete, e>0.

1

hard (solid), NP-complete

exponential, super-polynomial proofs ???

relies on clause learning

tG = critical transition point

easy (fluid), Polynomial (finding an assignment)

constant proofs (done statically using look-ahead polynomials)

no clause learning

0

The Game Evergreen(r,m) for triedBoolean MAX-CSP(G), r>1,m>0

Two players: They agree on a protocol P1 to choose a set of m relations of rank r.

- The players use P1 to choose a set G of m relations of rank r.
- Player 1 constructs a CSP(G) instance H with 1000 variables and gives it to player 2 (1 second limit).
- Player 2 gets paid the fraction of constraints she can satisfy in H (100 seconds limit).
- Take turns (go to 1).

Evergreen(3,2) tried

- Rank 3: Represent relations by the integer corresponding to the truth table in standard sorted order 000 – 111.
- choose relations between 1 and 254 (exclude 0 and 255).
- Don’t choose two odd numbers: All false would satisfy all constraints.
- Don’t choose both numbers above 128: All true would satisfy all constraints.

For tried

Evergreen(3,2)

min max problem tried

sat(H,M) = fraction of satisfied constraints in

CSP(G)-instance H by assignment M

tG = min max sat(H,M)

all CSP(G)

instances H

all (0,1) assignments M

Problem reductions are the key tried

- Solution to simpler problem implies solution to original problem.

min max problem tried

sat(H,M,n) = fraction of satisfied constraints in

CSP(G)-instance H by assignment M with n variables.

tG = lim min max sat(H,M,n)

all SYMMETRIC

constraint

systems H with

n variables

all (0,1) assignments M

to n variables

n to

infinity

Reduction achieved tried

- Instead of minimizing over all constraint systems it is sufficient to minimize over the symmetric constraint systems.

Reduction tried

- Symmetric case is the worst-case: If in a symmetric constraint system the fraction f of constraints can be satisfied, then in any constraint system the fraction f can be satisfied.

Symmetric the worst-case tried

n variables

n! permutations

If in the big system the

fraction f is satisfied,

then there must

be a least one small system

where the fraction f is satisfied

.

.

min max problem tried

sat(H,M,n) = fraction of satisfied constraints in

system S by assignment I

tG = lim min max sat(H,M,n)

all SYMMETRIC

constraint

systems H with

n variables

all (0,1) assignments M

to n variables where the

first k variables are set

to 1

n to

infinity

Observations tried

- The look-ahead polynomial look-forward approach has not been used in state-of-the-art MAX-SAT and Boolean MAX-CSP solvers.
- Often a fair coin is used. The optimally biased coin is often significantly better.

How the look-ahead tried

polynomial depends

on its context, the

currently best

assignment.

N0 ={!v1,!v2,!v3,!v4}

N tried0‘ ={v1,!v2,!v3,!v4}

Other magic numbers tried(Lieberherr/Specker (1982))

- G = all relations used in SAT (Or)
- tG = ½ (easy)
- 2-satisfiable (disallow A and !A for any A):
tG=(sqrt(5)-1)/2

- G = {R0,R1,R2,R3}; Rj : rank 3, exactly j of 3 variables are true. tG= ¼

Other magic numbers (2) tried(Lieberherr/Specker (1982))

- G(p,q) = {Rp,q = disjunctions containing at least p positive or q negative literals (p,q≥1)}
- Let a be the solution of (1-x)p=xq in (0,1). tG(p,q)=1-aq

SAT Rank 2 example tried9 constraints

14 : 1 2 014 : 3 4 014 : 5 6 0 7 : 1 3 0 7 : 1 5 0 7 : 3 5 0 7 : 2 4 0 7 : 2 6 0 7 : 4 6 0

14: 1 2 = or(1 2)

7: 1 3 = or(!1 !3)

What is the look-ahead

polynomial?

excellent peripheral vision tried

Blurry vision

- What do we learn from the abstract representation?
- set 1/3 of the variables to true (maximize).
- the best assignment will satisfy at least 7/9 constraints.
- very useful but the vision is blurred in the “middle”.

appmean = lookahead is an approximation of the true mean

Conclusions tried

The End tried

- Thank You

Where we are tried

- Introduction
- Look-forward
- Look-back
- SPOT: how to use the look-ahead polynomials with superresolution

SPOT (Superresolution P-OpTimal) tried

- Look-forward based on look-ahead polynomials
- value-ordering
- variable-ordering

- Look-backward
- superresolution
- many different learning schemes developed by SAT community (different cuts of the implication graph)

- superresolution

SPOT defines a family

of solvers that rely on

look-ahead polynomials

and (optimized) superresolvents.

Our approach triedto Solving H in MAX-CSP(G,f)

- Given an assignment N which satisfies fraction f.
- Is there an assignment that satisfies more than f?
- YES (we are done), laH,N(mb) > f
- MAYBE, The closer laH,N() comes to f, the better

- Is it worthwhile to set a certain literal k to 1 so that we can reach an assignment which satisfies more than f
- YES (we are done), H1 = UP*(Hk=1,N), laH1,N(mb1) > f
- MAYBE, the closer laH1,N() comes to f, the better
- NO, UP or clause learning

- Is there an assignment that satisfies more than f?

UP*(F,M) : apply UP as often as possible after applying assignment M to F

The problem: MAYBE happens

frequently, especially when f is close to 1.

Value Ordering tried

- Given is F and currently best assignment N.
- H1 = UP*(Hx=1,N)
- H0 = UP*(Hx=0,N)
- Choose x = 1, if laH1,N(mb1) ≥ laH0,N(mb0)

UP*(F,M) : apply UP as often as possible after applying assignment M to F

Two ways to look forward using look-ahead polynomials tried

- Reduction: Hk=d (d=0,1; k a literal)
- n-map(H,k)
- connection:
- abs((n-map(H,k)k=d)= abs(Hk=!d)
- abstract representation can achieve maximum either by repeated reductions or by repeated n-maps.

- connection:

The SPOT space tried

- How to use the look-ahead polynomials
- Choose top k (number of true variables).
- Choose among top 5 (4 is the winner).

2

1

4 3 5

SPOT-Conjecture tried

- There is a member U of the SPOT family of solvers:
- U finds a maximum assignment “quickly”.
- But U spends a long time proving that it is the maximum assignment.

- Stopping rule problem.

The bold SPOT-Conjecture tried

- There is a member U of the SPOT family of solvers:
- U finds the maximum assignment after at most |F|c superresolution steps where c is a constant.
- Any superresolution proof for maximality is probably superpolynomial.

SPOT-Conjecture tried

only one helper: superresolvents

stopping rule problem!

1

percentage

satisfied

maximum

look-ahead polynomials become

totally useless !?!

tG

two helpers:

1. look-ahead polynomial

2. superresolvents

random

assignment N

0

only one helper:

look-ahead polynomial

number of tries (proof steps)

SPOT-Conjecture tried

only one helper: superresolvents

stopping rule problem!

1

percentage

satisfied

maximum

look-ahead polynomials become

totally useless !?! symmetric instance

laF,N(mb)

two helpers:

1. look-ahead polynomial

2. superresolvents

random

assignment N

0

only one helper:

look-ahead polynomial

number of tries (proof steps)

Are look-ahead polynomials useful? tried

Some fast MAX-CSP solver MC

1

percentage

satisfied

maximum

How often does this happen in practice:

MC has to search using clause learning,

while the look-ahead polynomial can construct

a better assignment without search.

Intuition: the better the assignment N1, the

less likely it is that the look-ahead

polynomial improves N1.

laF,N1(mb)

random

assignment N

N1

0

number of tries (proof steps)

What is new? tried

- New: Superresolution for MAX-CSP
- New: Integration of look-ahead polynomials with superresolution
- Old: Superresolution for SAT (1977)
- Old: Look-ahead polynomials (1983)

Additional Information tried

- Rich literature on clause learning in SAT and CSP solver domain. Superresolution is the most general form of clause learning with restarts.
- Papers on look-ahead polynomials and superresolution: http://www.ccs.neu.edu/research/demeter/papers/publications.html

Additional Information tried

- Useful unpublished paper on look-ahead polynomials: http://www.ccs.neu.edu/research/demeter/biblio/partial-sat-II.html
- Technical report on the topic of this talk: http://www.ccs.neu.edu/research/demeter/biblio/POptMAXCSP.html

Future work tried

- Exploring best combination of look-forward and look-back techniques.
- Find all maximum-assignments or estimate their number.
- Robustness of maximum assignments.
- Are our MAX-CSP solvers useful for reasoning about biological pathways?

Conclusions tried

- Presented SPOT, a family of MAX-CSP solvers based on look-ahead polynomials and non-chronological backtracking.
- SPOT has a desirable property: P-optimal.
- SPOT can be implemented very efficiently.
- Preliminary experimental results are encouraging. A lot more work is needed to assess the practical value of the look-ahead polynomials.

end for now tried

Karl J. Lieberherr

Northeastern University

Boston

joint work with Ahmed Abdelmeged, Christine Hang and Daniel Rinehart

Karl J. Lieberherr

Northeastern University

Boston

joint work with Ahmed Abdelmeged, Christine Hang and Daniel Rinehart

Binomial Distribution tried

Example tried

x1 + x2 + x3 = 1

x1 + x2 + + x4 = 1 can satisfy 6/7

x1 + x3 + x4 = 1

x1 + x3 + x4 = 1

x1 + x2 + + x5 = 1

x1 + x3 + x5 = 1

x2 + x3 + x5 =1

maximize 3x(1-x) tried2

Transition Rules tried

- Unit-Propagation (UP):
M || F || SR || N → Mk || F || SR || N

- if k is undefined in M, and
- unsat (SR,M¬k) > 0 or unsat(F,M¬k) ≥ unsat(F,N).

Transition Rules tried

- Decide (D):
M || F || SR || N → Mkd || F || SR || N

- if k is undefined in M, and
- v(k) occurs in some constraint of F.

Transition Rules tried

- Update:
M || F || SR || N → M || F || SR || M

- if M is complete, and
- unsat(F,M) < unsat(F,N).

Transition Rules tried

- Restart:
M || F || SR || N → { } || F || SR || N

Transition Rules tried

- Finale:
M || F || SR || N → M || F || SR || N

- if Φ SR or unsat(F,N) = 0.

Transition Rules tried

- Semi-Superresolution (SSR):
NewSR = V (¬k), where k Md

M || F || SR || N → M || F || SR, NewSR || N

- if unsat(SR,M) > 0 or unsat(F,M) ≥ unsat(F,N).

Transition Manager tried

Transition Rules tried

Transition Rules (cont.) tried

Where we are tried

- Introduction
- Look-forward
- Look-back
- Packed Truth Tables
- SPOT: how to use the look-ahead polynomials

Requirements for Packed triedTruth Tables

- The look-ahead polynomial can be computed efficiently. Requires efficient truth table analysis.
- Reduction of an instance must be efficient.
- Efficiently compute the forced variables.
- Each relation has a unique representation.

Packed Truth Tables tried

22 254

RelationI: implemented by triedbitwise operations

int isForced(int variablePosition)

boolean isIrrelevant(int variablePosition)

int nMap(int variablePosition)

int numberOfRelevantVariables()

int q(int s)

int reduce(int variablePosition, int value)

int rename(int permutationSemantics, int... permutation)

Different ways of constructing implication graph (SAT) tried

- Lieberherr 1977:
- edge from l1 to l2 is labeled by the set of already forced literals L so that l1 union L forces l2 because of a clause C.

- Beame 2004 (now the standard, due to Marques-Silva & Sakallah, 1996)
- edge from l1 to l2 is labeled by clause C. l1 is responsible for forcing l2 because of clause C.

Karl J. Lieberherr

Northeastern University

Boston

joint work with Ahmed Abdelmeged, Christine Hang and Daniel Rinehart

Where we are tried

- Introduction
- Look-forward
- Look-backward
- SPOT: how to use the look-ahead polynomials

Look Backward tried

- Why?
- to avoid past mistakes

- How?
- Transition system based on superresolution.
- Superresolution was first introduced for SAT, now we generalize it for MAX-CSP.

Observation tried

- Optimally biased coin technique based on look-ahead polynomials is “best-possible”.
- If we could improve it by a trillionth in polynomial time, then P=NP.
- We improve it now by learning new constraints that will influence the polynomial.

Clause Learning tried

- Let’s go beyond what an optimally biased coin guarantees!
- Goal: satisfy the maximum number of constraints.
- Approach: Superresolution.
- When to apply: number of constraints guaranteed to be unsatisfied doesn’t decrease
- A mistake is made.

- Who to blame: a subset of the decision literals
- They are the culprits.

- How to penalize: add the disjunctions of their negations as a superresolvent
- The gang of culprits is watched.

- When to apply: number of constraints guaranteed to be unsatisfied doesn’t decrease

Transition Rules tried

- Unit-Propagation (UP):
M || F || SR || N → Mk || F || SR || N

- if k is undefined in M, and
- unsat (SR,M¬k) > 0 or unsat(F,M¬k) ≥ unsat(F,N).

old mistake(M¬k) new mistake(M¬k)

mistake(M) = old mistake(M) or new mistake(M)

Transition Rules tried

- Semi-Superresolution (SSR):
NewSR = V (¬k), where k Md

M || F || SRs || N → M || F || SRs, NewSR || N

- if unsat(SR,M) > 0 or unsat(F,M) ≥ unsat(F,N).

old mistake(M) new mistake(M)

mistake(M) = old mistake(M) or new mistake(M)

Transition Rules tried

- Superresolution (SR): 1977
M || F || SRs || N → M || F || SRs, Common || N

- if there exists a literal k so that by SSR applied twice:
- NewSR=Common, k
- NewSR=Common, !k

- if there exists a literal k so that by SSR applied twice:

Notes: Note that Common is a resolvent.

Superresolution is the mother of clause learning: other clause

learning schemes learn clauses implied from superresolvents

by UnitPropagation.

Resolution and Superresolution are polynomially equivalent (1977,

Beame et al. (2004)).

Superresolution tried

- Mother of clause learning: minimal elements of learned clauses
- But from superresolution to making clause learning a suitable and efficient technique in SAT and CSP and MAX-CSP solvers there is a long way

Transition Rules tried

NewSR is minimal

UP*(F,M) : apply UP as often as possible after applying M to F

- Opt-Semi-Superresolution (OSSR):
NewSR = V (¬k), where kєM’ subset Md

M || F || SRs || N → M || F || SRs, NewSR || N

- if mistake(M) and not newM(F,M*), for all M* where M* is M’ with one literal deleted.

oldM(M) = unsat(SR,M)>0newM(F,M) = unsat(UP*(F,M),M) ≥ unsat(F,N)

mistake(M) = oldM(M) or newM(F,M)

Optimized Semi-Superresolution tried

- Not all decision literals may be responsible for the “mistake”.
- Want to find a minimal superresolvent so that deleting one literal would destroy the superresolvent property.
- Can be implemented by a traversal back the implication graph that is built as part of unit propagation.

Optimized Semi-Superresolution tried(Fast implementation)

- Can be implemented by a traversal back the implication graph that is built as part of unit propagation.

v

k1

k2

k3

k6

w

k8

k4

k5

k7

!k8

Algorithm plan tried

- start with an arbitrary assignment N.
- while (proof incomplete) {
- try to improve N by creating new assignment from scratch using optimally biased coin to flip the assignments;
- success: Update N;
- failure: learn a new constraint that will prevent same mistake and will “improve” the polynomial. }

- try to improve N by creating new assignment from scratch using optimally biased coin to flip the assignments;

UP / D tried

Properties of TS tried

- TS finds the maximum in an exponential number of steps.
- It creates a polynomially checkable proof that we indeed found the maximum.

Download Presentation

Connecting to Server..