Ausarbeitung

Recursive Learning
und GRASP
SAT-Engines-Seminar
WS 2000/01
Stefan Disch
Die Papers
1994:
Recursive Learning: A New Implication Technique for Efficient
Solutions to CAD Problems – Test, Verfifications, and
Optimization
Wolfgang Kunz, Dhiraj K. Pradhan
1996:
GRASP - A New Search Algorithm for Satisfiability
João P. Marques-Silva, Karem A. Sakallah
1998:
Improving Satisfiability Algorithms by using Recursive
Learning João P. Marques-Silva
1999:
Combinational Equivalence Checking Using Satisfiability and
Recursive Learning
João P. Marques-Silva, Thomas Glass
Recursive Learning und GRASP
Inhalt
Recursive Learning
GRASP
GRASP und Recursive Learning
Combinational Equivalence Checking und SAT
Recursive Learning
Lösung von Entscheidungsproblemen
Ursprünglich für kombinatorische Schaltkreise
Bei GRASP Teil der Preprocessing Engine oder der
Deduction Engine
Recursive Learning
Begriffe / Definitionen (1)
Gegeben sei ein Gatter G, welches mindestens ein Eingangs- oder Ausgangsignal spezifiziert
hat: Gatter G wird als unjustified bezeichnet, wenn es ein oder mehrere nicht spezifizierte
Eingangs- oder Ausgangssignale gibt, die bei geeigneter Belegung zu einem Konflikt führen
können. Sonst ist das Gatter G justified.
a
a=1
a
c=1
c
b=1
b=0
unjustified
b
d=0
c=0
justified
Recursive Learning
justified
Begriffe / Definitionen (2)
Es wird folgendes logische Alphabet verwendet:
B3  0,1, X 
Ein Signal gilt als spezifiziert, wenn es einen der Werte 0,1 hat.
Ein Signal gilt als nicht spezifiziert, wenn es den Wert X hat.
Sei f ein willkürliches, nicht spezifiziertes Signal und V ein logischer Wert.
Wenn alle konsistenten Kombinationen von Wertzuweisungen, für die kein
„unjustified“ Gatter im Schaltkreis übrigbleibt, die Zuweisung f = V enthalten,
wird f = V als notwendig bezeichnet.
Implikationen werden als vollständig oder präzise bezeichnet, wenn sie alle
notwendigen Zuweisungen bestimmen.
Recursive Learning
Begriffe / Definitionen (3)
Direkte Implikationen sind Implikationen, die durch einfaches Auswerten der Wahrheits-
tafel eines bestimmten Gatters mit den gegebenen Zuweisungen und durch Propagieren
der gewonnenen Signale gewonnen werden können.
Recursive Learning
Beispiel:
Lernen:
v=1
u=1
x=1
s=0
w=0
v=1
t=0
y=1
z=0
x =x1
r=0
p=0
q=0
Recursive Learning
u=1
Beispiel:
0. Learning level
1. Learning level
z = 0 unjustified
unjust. line z = 0 :
1. just. v = 1:
2. just. u = 1
3. just. y = 1
w = 0 (unjust.)
 p = 0 (unjust.)
v = 1, x = 1
u = 1, x = 1
v = 1, u = 1, x = 1
2. Learning level
unjust. line w = 0:
1. just. s = 0
v=1
x = 1
2. just. t = 0
v = 1
x = 1

unjust. line p = 0:
...


Recursive Learning
Der naive Algorithmus
demo_recursive_learning() {
for each unsatisfied line {
for each input: justification {
- assign controlling value (e.g. 0 for AND)
- make implications and set up new list of
resulting unjustified lines
- if consistent: demo_recursive_learning() }
if there are one or several signals f in the circuit, such
that f assumes the same logic value V for all consistent
justifications:
then learn f = V, make implications for all learned signal
values
if all justifications are inconsistent: learn that the
current situation of value assignments is inconsistent.}
}
Recursive Learning
Problem: unvollst. Implikationen
ee=1
e
a
1b
b=0
y=0
1
c
d
1
x=0
Aus x = 0 folgt y = 0, da aus b = 0 d = 1 folgt, bzw. aus b = 1 folgt e = 1 und somit immer y = 0.
demo_recursive_learning würde hier scheitern und die Implikation x = 0 y = 0 nicht finden.
demo_recursive_learning wertet nur direkte Implikationen aus.
Recursive Learning
Notationen
r
Tiefe der Rekursion
rmax
max. Tiefe der Rekursion
U  G1 , G2 , G3 ,... ist die Menge der „unjustified“ Gatter im aktuellen
0
Stand des Algorithmus
Gx
J r   f1  V1 , f 2  V2 ,... ist die Menge der Zuweisungen, die eine
„justification“ eines Gatters Gx zur Rekursionstiefe r repräsentiert.
Gx
C r  J1 , J 2 , J 3 ,... ist die vollständige Menge von „justifications“
eines Gatters Gx .
Jx
U r  G1 , G2 , G3 ,...
ist die Menge der „unjustified“ Gatter einer
gegebenen „justification“ J x in der Rekursionstiefe r.
Recursive Learning
Bsp. vollst. Implikation (1)
a
0
c
b
0
d
1
e
f
G1
G2
1
k
0
0
g
l
G3
i
j
X
0
n
G4
G6
r
m
h
p=1
G5
0
Recursive Learning
0
q
0
Bsp. vollst. Implikation (2)
0. Learning level
1. Learning level
2. Learning level
p=1 (unjust.)
(Gate G6 unjust.)
unjust. Gate G6:
1. justification: q = 0, r = 0
k = 0 (G1 unjust.)
 l = 0 (G2 unjust.)
m = 0 (G3 unjust.)
n = 0 (G4 unjust.)
unjust. Gate G1:
1. justification c=0
e = 1
f = 0 (since l = 0)
i = 1
j = 0 (since n = 0)
inconsistency at b
2. justification d=0
g = 1
h = 0 (since m = 0)
j = 1
i = 0 (since n = 0)
inconsistency at a
1. justification inconsistent
current situation of value
assignments inconsistent
8
Recursive Learning
Alg. für vollständige Implikation
initially: r=0
make_all_implications(r,r_max) {
make all direct implications and set up a List U_r of
resulting unjustified gates
if r < r_max: learning {
for each gate G_x, x=1,2,... in U_r: justifications {
set up a list of justifications C_r for gate G_x
for each justification J_i  C_r: {
-make the assignments contained in J_i
-make_all_implications(r+1,r_max)
}
if there is one or several signals f in the
circuit, which assume the same logic value V for
all consistent justifications J_i  C_r then learn:
f = V is uniquely determined in level r, make
direct implications for all learned values in level r
if all justifications are inconsistent, then learn:
given situation of value assignments in level r is
inconsistent
}
}
}
Recursive Learning
Maximale Rekursionstiefe
Der Prozeß terminiert auch im Falle von rmax   , da nach einer diskreten
Anzahl von Schritten die Eingänge oder Ausgänge des Schaltkreises erreicht
werden.
Die tatsächliche Wahl von
werden.
rmax muss durch eine geeignete Heuristik bestimmt
Recursive Learning
Experimentelle Ergebnisse
rmax  5
Recursive Learning
Inhalt
Recursive Learning
GRASP
GRASP und Recursive Learning
Combinational Equivalence Checking und SAT
GRASP
GRASP: generic search algorithm for the satisfiability problem
•Integration von „search-pruning-techniques“
•Verwendung von Konflikt-Analyse-Tools
•Zentrale Idee: non-chronological backtracking
=> Der Suchraum wird kleiner
GRASP
Definitionen und Notationen
assigned: Einer Variablen wurde während des Suchprozesses ein Wert 0 oder 1
zugewiesen. Ist dies nicht der Fall spricht man von unassigned .
truth assignment A ist eine Menge von „assigned“ Variablen und ihren Werten. Man
spricht von einem vollständigen „assignment“, wenn A  n gilt.
Bsp.:
A  x1  0, x5  1, x16  0
satisfying assignment:
j A 1
unsatisfying assignment:
j A 0
j: Formel in CNF
Die Klauseln eines Ausdrucks j werden durch ein assignment in drei Partitionen
aufgeteilt: erfüllte Klauseln, unerfüllte Klauseln und nicht gelöste Klauseln. Die
unassigned Literale einer Klausel werden als freie Literale bezeichnet. Klauseln mit nur
einem freien Literal werden als unit clause bezeichnet.
GRASP
Die Suche (Prinzip)
Es wird mit einem leeren truth assignment begonnen. Ein Backtracking-Such-Algorithmus
traversiert den Suchraum in Form eines Entscheidungsbaumes. Jeder Knoten des Baumes
repräsentiert eine Zuweisung einer Variable. Die Zuweisungen werden als decision
assignments, die Tiefe im Baum als decision level bezeichnet.
Der Suchprozeß durchläuft folgende Schritte iterativ:
1.
Im aktuellen decision level wird ein decision assignment gewählt und das truth
assignment erweitert (im Falle einer unassigned Variable). Der Prozeß terminiert
erfolgreich, wenn alle Klauseln erfüllt sind. Er terminiert nicht erfolgreich, wenn nicht
alle Klauseln erfüllt sind, aber alle möglichen decision assignments gemacht wurden.
2.
Durch Implikation wird das truth assignment erweitert. Bei diesem Schritt kann es
auch zu unerfüllten Klauseln kommen. Dies wird als Konflikt bezeichnet. Das truth
assignment wird zum unsatisfying assignment.
3.
Der letzte Schritt (2.) wird rückgängig gemacht, wenn ein Konflikt aufgetreten ist.
(Backtracking Schritt)
GRASP
Konflikt-Management
conflict-based equivalence (CBE)
Neue Implikanten, die nicht in der Klausel-Menge vorkommen und durch einen Konflikt
gefunden wurden, werden zur Klausel-Menge hinzugefügt. Dadurch kann man den gleichen
Fehler an anderer Stelle vermeiden.
failure-driven assertion (FDA)
Wenn ein decision assignment im aktuellen decision-level zum Konflikt führte, wird die
inverse Zuweisung (falls noch nicht versucht) benutzt.
conflict-directed backtracking (CDB)
Wenn der Konflikt aus einem früheren decision-level stammt, wird die Suche an diese
Stelle zurückspringen. Diese Technik ist eine Form des nonchronological backtracking.
Mit ihr kann man den Suchprozeß signifikant reduzieren.
GRASP
Struktur des Suchprozesses (1)
Der zugrundeliegende Mechanismus, um Implikationen aus einer Klausel-Menge zu
erhalten, ist die boolean constraint propagation (BCP). Dies ist nichts anderes als die
iterierte Anwendung der unit clause rule (M. Davis, D. Putnam).
Gegeben sei eine Klausel   l1  ...  lk  . Diese impliziert eine Zuweisung für die
Variable x (vgl. unit clause rule). Das antecedent assignment A(x) ist eine Menge von
assignments für die gilt: A(x) enthält Variablen und ihre Zuweisungen aus 
x  A(x )
Beispiel:
  ( x  y  z )
A( x)  { y  0, z  1}
A( y )  {x  0, z  1}
A( z )  {x  0, y  0}
GRASP
Struktur des Suchprozesses (2)
Wenn die Variable x assigned ist, gibt v(x) den zugewiesenen boolschen Wert zurück.
Eine Sequenz von durch BCP generierten Implikationen wird durch einen gerichteten
implication graph I abgebildet:
1.
2.
3.
Jeder Knoten in I repräsentiert eine Zuweisung x = v(x)
Die Vorgänger des Knotens x = v(x) sind in A(x) und der entsprechenden unit clause 
enthalten. Die gerichteten Kanten von den Knoten in A(x) nach x = v(x) werden mit 
beschriftet. Knoten ohne Vorgänger sind decision assignments.
Spezielle Konflikt-Knoten K werden in I benutzt um Konflikte anzuzeigen. Die
Vorgänger entsprechen A(K) und die Kanten werden wieder mit der entsprechenden
Klausel beschriftet.
Der decision level wird wie folgt definiert:
 ( x)  max  ( y)  y, v( y) A( x)
GRASP
Algorithmus (1)
Der Algorithmus besteht aus folgenden Grundkomponenten:
Decide(), hier wird ein decision assignment gewählt. In der Regel werden Heuristiken
verwendet. Im folgendem Beispiel wird diese greedy Heuristik verwendet:
An jedem Knoten im decision tree wird die Anzahl der direkt
erfüllten Klauseln ermittelt. Dies wird für jede Variable und
Zuweisung gemacht. Es wird die Variable und Zuweisung gewählt,
die am meisten Klauseln erfüllt.
Deduce(), hier wird BCP angewandt und der entsprechende implication graph erstellt.
Diagnose(), hier werden die Konflikte identifiziert und die clause database mit
Implikanten erweitert.
Erase(), diese Prozedur löscht die assignments im aktuellen decision level.
GRASP
Beispiel für Deduce()
Assignment:x9  0 @1, x10  0 @ 3, x11  0 @ 3, x12  1@ 2, x13  1@ 2,...
Decision Assignment:
x1  1@ 6
x10  0 @ 3
4
Klauselmenge:
1  x1  x2 
 2  x1  x3  x9 
 3  x2  x3  x4 
 4  x4  x5  x10 
 5  x4  x6  x11 
 6  x5  x6 
 7  x1  x7  x12 
 8  x1  x8 
 9  x7  x8  x13 
x2  1@ 6
1
3
x5  1@ 6
4
6
x4  1@ 6
x1  1@ 6
3
2
5
5
x9  0 @1
x11  0 @ 3
Implication Graph
GRASP
6
x6  1@ 6
x3  1@ 6
2
K
Die Diagnose() Prozedur
Conflict_Induced_Clause()
Hier wird eine Klausel omega_C_K wie folgt generiert:
 ( x)   y, v( y )   A( x)  ( y )   ( x)
( x)   y, v( y )   A( x)  ( y )   ( x)
x, v( x) 



AC ( x)
( x)    AC ( y )
 y ,v ( y )  ( x ) 

C ( K ) 
x


v( x)
 x ,v ( x ) AC ( K )
Partition von A(x) nach decision level
wenn A( x)  
sonst
wobei gilt : x 0  x und x1  x
GRASP
Die Diagnose() Prozedur
Im Beispiel würde dies zu folgendem Ergebnis führen:
AC ( K )  x1  1, x9  0, x10  0, x11  0
 C ( K )  x1  x9  x10  x11 
GRASP
Beispiel 2
Assignment:x9  0 @1, x10  0 @ 3, x11  0 @ 3, x12  1@ 2, x13  1@ 2,...
Decision Assignment:
x1  0 @ 6
Klauselmenge:
1  x1  x2 
 2  x1  x3  x9 
 3  x2  x3  x4 
 4  x4  x5  x10 
 5  x4  x6  x11 
 6  x5  x6 
 7  x1  x7  x12 
 8  x1  x8 
 9  x7  x8  x13 
x8  1@ 6
8
9
K´
x1  0 @ 6
7
9
x7  1@ 6
x12  1@ 2
 C ( K )  x1  x9  x10  x11 
7
Implication Graph
GRASP
9
x13  1@ 2
Beispiel 2 / CDB
Hier führt FDA zu einem erneuten Konflikt:
AC ( K´)  x9  0, x10  0, x11  0, x12  1, x13  1
 C ( K´)  x9  x10  x11  x12  x12 
Nun muss ein Backtrack-Schritt zum backtrack level b(CDB) erfolgen:
b  max  ( x) x, v( x) AC ( K´)
Im Beispiel würde b = 3 sein. Dies würde zu einem FDA in Level 3 führen.
Die Klausel  C (K´) wird der clause database hinzugefügt.
=> conflict-induced necessary assignments
GRASP
Algorithmus (2)
// Global variables:
clause database phi
//
variable assignment A
// Return value:
FAILURE or SUCCESS
// Auxiliary variables:
backtracking level beta
//
GRASP()
{
return (Search (0,beta) != SUCCESS) ?
FAILURE:SUCCESS;
}
GRASP
Algorithmus (3)
// input argument:
current decision level d
// output argument:
backtracking level beta
// return value:
CONFLICT or SUCCESS
//
Search (d, &beta)
{
if (Decide (d) == SUCCESS) return SUCCESS;
while (true) {
if (Deduce (d) != CONFLICT) {
if (Search (d + 1, beta) == SUCCESS)
return SUCCESS;
else if (beta != d) {
Erase(); return CONFLICT;
}
}
if (Diagnose (d, beta) == CONFLICT) {
Erase(); return CONFLICT;
}
Erase();
}
}
GRASP
Algorithmus (4)
Diagnose (d, &beta)
{
omega_C_K = Conflict_Induced_Clause();
Update_Clause_Database (omega_C_K);
beta = Compute_Max_Level();
if (beta != d) {
add new conflict vertex K to I;
record A(K);
return CONFLICT;
}
return SUCCESS;
}
GRASP
Experimentelle Ergebnisse
#M: Anzahl Class members
#S: Anzahl Class members, für die
der Algorithmus terminiert
Inhalt
Recursive Learning
GRASP
GRASP und Recursive Learning
Combinational Equivalence Checking und SAT
GRASP und Recursive Learning
Recursive Learning kann in GRASP als Teil der Preprocessing Engine oder in
der Deduction Engine eingesetzt werden.
Idee:
Es wird in beiden Fällen versucht mittels RL die notwendigen assignments zu
finden.
Diese werden der clause database als unit clause hinzugefügt.
Innerhalb der Deduction Engine wird BCP durch RL ersetzt.
GRASP und Recursive Learning
Beispiel:
Assignments:
Klauseln (CNF):
{z  1, u  0}
1  (u  x  w)
 2  ( x  y )
 3  ( w  y  z )
Es folgt:
( z  1)  (u  0)  ( x  1)
neue Klausel:
4  (z  u  x) (Lernschritt)
GRASP und Recursive Learning
Problem
Der Umfang der clause database wird schnell zu groß!
Strategie 1: Relevance-Based Learning
Wenn eine größere Anzahl an Literalen einer gelernten Klausel unassigned
werden, wird sie gelöscht.
Strategie 2: k-bounded Learning
Nur Klauseln mit max. k Literalen werden aufgezeichnet.
GRASP und Recursive Learning
Experimentelle Ergebnisse
k-bounded learning: k = 6
relevance-based learning: Anzahl der unassigned Literale = 3
rmax  2
GRASP und Recursive Learning
Inhalt
Recursive Learning
GRASP
GRASP und Recursive Learning
Combinational Equivalence Checking und SAT
Combinational Equivalence Checking
und SAT
Das CEC-Problem wird auf das SAT-Problem übertragen.
Combinational Equivalence
Checking und SAT
Prinzip
1.
Es wird ein miter erzeugt.
2.
Der erhaltene Schaltkreis wird in CNF überführt.
3.
Ist der CNF-Ausdruck erfüllbar, sind die Schaltkreise nicht äquvivalent.
miter:
A
SK 1
B
C
SK 2
Combinational Equivalence
Checking und SAT
Experimentelle Ergebnisse