Algorithmische Intelligenz „Symbolische Suche“

Algorithmische Intelligenz

„Symbolische Suche“

Peter Kissmann

Spiele

 Einpersonenspiele

(n² - 1)-Puzzle

Solitär

 Zweipersonenspiele

Tic-Tac-Toe

Clobber

Vier Gewinnt

Motivation

 Zustandsraumexplosion

#erreichbare Zustände:

 (n²-1)-Puzzle: (n²)!/2

• 15-Puzzle: ≈ 10¹³

• 24-Puzzle: ≈ 7,8 x 10²⁴

• 35-Puzzle: ≈ 1,9 x 10⁴¹

 Solitär: 375 110 246

 Clobber (4x5): 26 787 440

 4 Gewinnt: ≤ 70 728 639 995 483 (≈ 7 x 10¹³) (Allis, 1988) (tatsächlich: 4 531 985 219 092 (≈ 4,5 x 10¹²))

Motivation

 Speicher sparen z.B. mittels Binären Entscheidungsdiagrammen (BDDs)

verwalten Zustandsmengen

sparen unnötige Knoten ein → teils exponentiell viele

 Beispiel: vollständiges Lösen von allgemeinen Spielen

(General Game Playing)

Überblick

 Wiederholung: BDDs

 BDD-basierte Suche

 BFS, Dijkstra, A*

 Anwendung auf allgemeine Spiele („General Game Playing“)

 BDDs als perfekte Hash-Funktion

Überblick

 Wiederholung: BDDs

 BDD-basierte Suche

 BFS, Dijkstra, A*

 Anwendung auf allgemeine Spiele („General Game Playing“)

 BDDs als perfekte Hash-Funktion

BDDs (Binary Decision Diagrams)

 Repräsentieren Zustandsmenge

 gerichteter azyklischer Graph von Wurzel zu 0- oder 1- Senke

 Knoten für (binäre) Variablen

Zwei Ausgänge: low und high (auch 0 und 1)

 Pfad von Wurzel bis 1-Senke

Zustand entsprechender Variablenbelegung in repräsentierter Menge enthalten

OBDDs (Ordered BDDs)

 Feste Variablenordnung π

Gute Variablenordnung → exponentiell weniger Knoten (möglicherweise)

Finden guter Variablenordnung NP-schwer

 Graphisch: Schichten gleicher Variablen

ROBDDs (Reduced OBDDs)

 Zwei Vereinfachungsregeln:

 ROBDDs eindeutig

 Im Folgenden nur ROBDDs

x₁ x₁ x₁

x₂ x₃ x₂ x₃

BDDs für logische Operatoren

x₁

x₂

0 1

x

∧ x

x₁

x₂

0 1

x

∨ x

x₁

0 1

¬x

x₁

x₂ x₂

0 1

x

⇔ x

ROBDDs (Beispiele)

column- x

row- x

diagonal- x

Überblick

 Wiederholung: BDDs

 BDD-basierte Suche

 BFS, Dijkstra, A*

 Anwendung auf allgemeine Spiele („General Game Playing“)

 BDDs als perfekte Hash-Funktion

BDD-basierte Suche (Voraussetzungen)

 S Menge aller Zustände

 Initialzustand I ∈ S

 Menge von Zielzuständen G ⊆ S

 Transitionsrelation T ⊆ S x S

beschreibt Zustandsübergänge durch Vorgänger und Nachfolger

 mögliche Ziele:

finde kürzesten Pfad von I nach g ∈ G

berechne alle erreichbaren Zustände

 2 Variablensätze:

x für Vorgängervariablen

x‘ für Nachfolgervariablen

 in Variablenordnung x_i und x_i‘ abwechselnd (interleaved)

BDD-basierte Suche

 Finden von Nachfolgern (image)

Relationales Produkt:

 Finden von Vorgängern (pre-image) analog:

 zusätzlich: nach jedem (pre-)image:

Verschieben der Variablen

image ( s ) =∃ x . ( ^{T ( x , x ' ) ∧s ( x )} )

preimage ( s ) =∃ x ' . ( ^{T ( x , x ' ) ∧s ( x ' )} )

BDD-basierte Suche

 Partitionierte Berechnung:

T = V_aT_a für alle Aktionen a

∃ und ∨ kommutieren

(entsprechend auch für pre-image)

Vorteil: Berechnung monolithischer Transitionsrelation teuer (Zeit und Speicher)

image ( s ) =¿

∃ x . ( ^T

( x , x ' ) ∧ s ( x ) )

BDD-basierte Suche

 Finden der Vorgänger, deren Nachfolger alle in s liegen (strong pre-image):

 strong pre-image auf pre-image zurückführbar → Übungsaufgabe

strong

( s ) =∀ x ' . ( ^{T ( x , x ' ) ⇒ s ( x ' )} )

BDD-basierte Suche

 image

 pre-image

 strong pre-image

Überblick

 Wiederholung: BDDs

 BDD-basierte Suche

 BFS, Dijkstra, A*

 Anwendung auf allgemeine Spiele („General Game Playing“)

 BDDs als perfekte Hash-Funktion

Breitensuche (SBFS)



iterativ images berechnen

reach ← I

wiederhole

 newBDD ← image(reach) ∧ ⌐reach

 reach ← reach ∨ newBDD

solange Abbruchkriterium nicht erfüllt



mögliche Abbruchkriterien:

newBDD = ⊥ (alle Zustände bestimmt)

reach ∧ G ≠ ⊥ (kürzester Weg zum Ziel gefunden)

Mögliche Verbesserung

 Jeden Zustand nur einmal expandieren (Duplikatserkennung)

 Dazu: Closed-BDD

front ← I

wiederhole

 closed ← closed ∨ front

 front ← image(front) ∧ ⌐closed

solange Abbruchkriterium nicht erfüllt

Bestimmung erreichbarer Zustände mittels SBFS

n: Anzahl BDD-Knoten zur Repräsentation aller Zustände

s: Anzahl aller erreichbarer Zustände

Bestimmung erreichbarer Zustände in „Vier

Gewinnt“ (SBFS)

Bestimmung erreichbarer Zustände in „Vier Gewinnt“ (SBFS)

0 5 10 15 20 25 30 35 40

1E+00 1E+02 1E+04 1E+06 1E+08 1E+10 1E+12 1E+14

Knoten (BDD) Zustände (BDD)

Zustände (Allis-Schätzung)

Bidirektionale Breitensuche (SBBFS)

I

G

Schnitt gefunden

Bidirektionale Breitensuche (SBBFS)

 BFS von Start und Ziel „gleichzeitig“

Ende, wenn Suchfronten überschneiden

 ffront ← I, bfront ← G

 wiederhole

• falls vorwärts

 ffront ← image(ffront)

• sonst

 bfront ← pre-image(bfront)

 solange ffront ∧ bfront = ⊥

Auswahlkriterium etwa Zeit der letzten Iteration

Verwendung von closed-BDDs möglich

Symbolischer Dijkstra

 BFS nur bei uniformen Kosten

 Gewichtete Transitionsrelation → „Single Source Shortest Path“→ Dijkstra

Kosten c ∈ {1, …, C}

T = V_cT_c

Symbolischer Dijkstra

open₀ ← I, closed ← ⊥, g ← 0

wiederhole

 falls (open_g ∧ G ≠ ⊥) STOPP

 open_g ← open_g ∧ ⌐closed

 für c ← 1, …, C

• ^openg+c ← open_g+c ∨ image_c(open_g)

 closed ← closed ∨ open_g

 g ← g + 1

Symbolisches A* (BDDA*)

 Ähnlich Dijkstra; Expansion nach f-Wert:

 Verwendung einer Heuristik

z.B. aus Musterdatenbank (pattern database (PDB))

Heuristik h darf nicht überschätzen (zulässig)

 h = 0 → Dijkstra

f ( v ) = g ( v ) +h ( v )

Symbolisches A* (BDDA*)

h

g

Symbolisches A* (BDDA*)

 open(0,h(I)) ← I, closed(0, …, |h|) ← ⊥, f ← h(I)

 wiederhole

für g ← 0, …, f

 h ← f - g

 falls (h = 0 & open(g, h) ∧ G ≠ ⊥) STOPP

 open(g, h) ← open(g, h) ∧ ⌐ closed(h)

 für c ← 1, …, C

• ^succc ← image_c(open(g, h))

• ^{für h}succ ← 0, …, |h|

 open(g + c, h_succ) ← open(g + c, h_succ) ∨ (succ_c ∧ h_succ)

 closed(h) ← closed(h) ∨ open(g, h)

f← f + 1

Überblick

 Wiederholung: BDDs

 BDD-basierte Suche

 BDD-BFS, BDD-Dijkstra, BDDA*

 Anwendung auf allgemeine Spiele („General Game Playing“)

 BDDs als perfekte Hash-Funktion

Überblick 2 (Lösen allgemeiner Spiele)

 General Game Playing

 Einpersonenspiele

 Zweipersonenspiele

Zweipersonen-Nullsummenspiele

Zweipersonenspiele mit allgemeinen Gewinnen

Überblick 2 (Lösen allgemeiner Spiele)

 General Game Playing

 Einpersonenspiele

 Zweipersonenspiele

Zweipersonen-Nullsummenspiele

Zweipersonenspiele mit allgemeinen Gewinnen

General Game Playing

 Beschreibung für Spiele mit folgenden Eigenschaften:

endlich

diskret

deterministisch

vollständige Information

 Spiele können

Ein- oder Mehr-Personenspiele sein

gleichzeitige oder abwechselnde Züge ermöglichen

General Game Playing



„Game Description Language“ (GDL)



Gegeben:

Initialzustand

Bestimmung legaler Züge

Effekt eines Zuges

Terminierungsbedingungen

Verteilung der Gewinne {0, …, 100} darin



Gesucht:

Lösung erreichbarer Zustände

Bestimmung optimaler Gewinn-Verteilung

General Game Playing

 Beispiele:

Blocksworld

 Original GDL-Datei: .kif

Tic-Tac-Toe

 Original GDL-Datei: .kif

 Mehr Informationen:

http://games.stanford.edu (dort entwickelt; leider veraltet)

http://www.general-game-playing.de

http://euklid.inf.tu-dresden.de:8180/ggpserver (aktuelle Spiele etc.)

Überblick 2 (Lösen allgemeiner Spiele)

 General Game Playing

 Einpersonenspiele

 Zweipersonenspiele

Zweipersonen-Nullsummenspiele

Zweipersonenspiele mit allgemeinen Gewinnen

Lösen von Einpersonenspielen

 Erst: Erreichbare Zustände finden (BFS)

 Dann: Rückwärtssuche

Start: Zielzustände mit Gewinn 100

 BFS (rückwärts)

Weiter: Zielzustände mit Gewinn 99

 BFS (rückwärts)

 dabei: bereits gelöste Zustände auslassen

Weiter bis Gewinn 0

Lösen von Einpersonenspielen

75 100 90 80

99

75 80

100 100

100

100

90

90

80

80

75

Ergebnisse für Solitär

 Erreichbar: 375 110 246 Zustände

Überblick 2 (Lösen allgemeiner Spiele)

 General Game Playing

 Einpersonenspiele

 Zweipersonenspiele

Zweipersonen-Nullsummenspiele

Zweipersonenspiele mit allgemeinen Gewinnen

Lösen von Zweipersonen- Nullsummenspielen

 Mögliche Gewinne: 0, 50, 100

 Jeder Spieler versucht, möglichst hohen Gewinn zu erreichen

 Lösung liefert Verteilung der Gewinne (bei optimaler

Spielweise)

Lösen von Zweipersonen- Nullsummenspielen



BFS für Finden erreichbarer Zustände



Zwei Rückwärtssuchen (eine pro Spieler):

 Start bei verlorenen Zielzuständen

 Bestimmung verlorener Vorgänger (2 Schritte)

 für alle Züge, die Spieler durchführen kann, kann Gegenspieler Zug zu verlorenem Zustand wählen (pre-image und strong pre-image)

 Iterieren, solange neue Zustände gefunden

player 0‘s turn player 1‘s turn

lost for player 0 lost for player 1

Lösen von Zweipersonen- Nullsummenspielen

reach ← berechneErreichbareZustände()

für jeden Spieler p ∈ {0, 1}

 front ← verloren_p ← reach ∧ gewinn(p, 0) ∧ G ∧ zug_p

 gewonnen_1-p ← reach ∧ gewinn(p, 0) ∧ G ∧ zug_1-p

 wiederhole

• pred ← pre-image(front) ∧ reach

• ^gewonnen1-p ← gewonnen_1-p ∨ pred

• front ← strong-pre-image(gewonnen_1-p) ∧ reach ∧ ⌐verloren_p

• ^verlorenp ← verloren_p ∨ front

 solange front ≠ ⊥

Überblick 2 (Lösen allgemeiner Spiele)

 General Game Playing

 Einpersonenspiele

 Zweipersonenspiele

Zweipersonen-Nullsummenspiele

Zweipersonenspiele mit allgemeinen Gewinnen

Lösen allgemeiner Zweipersonenspiele

 Mögliche Gewinne ∈ {0, …, 100}

 Verwendung von (101 x 101)-Matrix

Zustand an Position (i, j):

 i Punkte für Spieler 0

 j Punkte für Spieler 1

 falls unvollständig, Verwendung als Endspieldatenbank

Lösen allgemeiner Zweipersonenspiele

 Eine Vorwärts- und eine Rückwärtssuche

finde alle Vorgänger, deren Nachfolger alle gelöst sind (strong pre- image)

finde optimales Bucket für diese (pre-image)

füge sie ein

iteriere, bis alle Zustände gelöst

Einschub: Reihenfolge beim Lösen

 schwierig im allgemeinen Fall

 eigenen Gewinn maximieren

(und gegnerischen minimieren)?

 oder Differenz zum gegnerischen Gewinn maximieren?

 Hier: 2. Fall

own

100 opponent 0

0 100

…

…

own

100 opponent 0

0 100

…

…

Beispiel

player 0

player 1

0 0

1 1

2

2

3

3

player 0‘s turn

player 1‘s turn ^0/1

0/1

0/3 2/0

3/1

2/0

2/0 3/1

3/1

0/1 3/1 3/1

0/1 0/1

0/3 0/3

0/1 3/1 0/1 2/0

0/1 0/1

0/1

Lösen allgemeiner Zweipersonenspiele

reach ← berechneErreichbareZustände()

init matrix; solved ← alle Zustände in Matrix

unsolved ← reach ∧ ⌐solved

solange unsolved ≠ ⊥

 für jeden Spieler p ∈ {0, 1}

• solvable ← strong-pre-image(solved) ∧ unsolved ∧ zug_p

• falls solvable ≠ ⊥

 matrix ← fügeZuständeEin(solvable, p, matrix)

 solved ← solved ∨ solvable

 unsolved ← unsolved ∧ ⌐solvable

Ergebnisse

Game t

t

Clobber 3x4 - 1.1s

Clobber 3x4 0-sum 1.0s 1.4s Clobber 4x5 - 2:14:20 Clobber 4x5 0-sum 0:54:35 1:22:09

Minichess 1.0s 0.7s

TicTacToe 0.1s 0.2s

Nim 40 0.0s 0.1s

Überblick

 Wiederholung: BDDs

 BDD-basierte Suche

 BDD-BFS, BDD-Dijkstra, BDDA*

 Anwendung auf allgemeine Spiele („General Game Playing“)

 BDDs als perfekte Hash-Funktion

Hashing

 Gegeben: Menge von Zuständen S

 Gesucht: Abbildung S → R ⊆ ℕ

 Hashfunktion ordnet jedem Zustand einen Wert zu

 perfektes Hashing: Hashwert jedes Zustandes eindeutig

 minimales perfektes Hashing: |R| = |S|

Sat-Count

 Anzahl gespeicherter Zustände in BDD G

 mögliche Berechnung:

sat-count(0-Senke) ← 0, sat-count(1-Senke) ← 1

für Knoten v aus Schicht i mit 0-Nachfolger u in Schicht j > i und 1- Nachfolger w in Schicht k > i

 sat-count(v) ← 2^j-i-1 * sat-count(u) + 2^k-i-1 * sat-count(w)

falls Wurzel in Schicht i:

 sat-count(G) ← 2^i-1 * sat-count(Wurzel)

 Laufzeit- und Speicherbedarf: ≤ O(|G|)

Sat-Count (Beispiel)

0 1

1 1

1

30

16 14

4

3 5

2 2

2

 abgedeckte Zustände:

000001

000111

001011

001101

010011

010100

010101

010110

010111

011011

011100

011101

011110

011111

100011

100100

100101

100110

100111

101011

101100

101101

101110

101111

110010

110011

110111

111010

111011

111111

Ranking

 Gegeben: BDD G, Zustand s

 Gesucht: Hash-Wert von s (in {0, …, sat-count(G) - 1})

 Vorverarbeitung:

Berechne Sat-Count aller Knoten

speichere diese Sat-Counts

Ranking

 rank(G,s)

falls Wurzel in Schicht i

 d ← Binärwert von (s₁, …, s_i-1)

 gib (d+1) * lexicographic-count(G,s,Wurzel) - 1 zurück

Ranking

 lexicographic-count(G,s,v)

falls v 0-Senke, gib 0 zurück; falls v 1-Senke, gib 1 zurück

falls v in Schicht i mit 0-Nachf. u in j und 1-Nachf. w in k

 falls s_i = 0

• ^r0 ← lexicographic-count(G,s,u)

• ^d0 ← Binärwert von (s_i+1, …, s_j-1)

• ^{gib d}0 * sat-count(u) + r₀ zurück

 falls s_i = 1

• ^r1 ← lexicographic-count(G,s,w)

• ^d1 ← Binärwert von (s_i+1, …, s_k-1)

• ^{gib 2j-i-1} * sat-count(u) + d₁ * sat-count(w) + r₁ zurück

Ranking (Beispiel)

 s ← 011101

rank(G,s) ← [()₂ + 1] * lc(G,s,v₀) - 1

lc(G,s,v₀) ← ()₂ * sc(v₁) + lc(G,s,v₁)

lc(G,s,v₁) ← 2^3-2-1 * sc(v₃) + (1)₂ * sc(v₆) + lc(G,s,v₆)

lc(G,s,v₆) ← 2^5-4-1 * sc(v₉) + (01)₂ * sc(v₁₃) + lc(G,s,v₁₃)

v₁₃ ist 1-Senke → lc(G,s,v₁₃) ← 1

lc(G,s,v₆) ← 2^{0 *} sc(v₉) + 1 * sc(v₁₃) + lc(G,s,v₁₃)

= 1 * 1 + 1 * 1 + 1 = 3

lc(G,s,v₁) ← 2⁰ * sc(v₃) + 1 * sc(v₆) + lc(G,s,v₆)

= 1 * 4 + 1 * 5 + 3 = 12

lc(G,s,v₀) ← 0 * sc(v₁) + lc(G,s,v₁) = 12

rank(G,s) ← 1 * lc(G,s,v₀) - 1 = 11

0 1

1 1

1

30

16 14

4

3 5

2 2

2

v₀

v₁ v₂

v₃

v₄ v₅ v₆ v₇

v₈ v₉ v₁₀

v₁₁

v₁₂ v₁₃

Unranking

 Gegeben: BDD G, Hash-Wert r

 Gesucht: zugehöriger Zustand

Unranking

 unrank(G,r)

starte an der Wurzel

falls Wurzel in Schicht l

 (s₁, …, s_l-1) ← Binärrepräsentation von r div sat-count(Wurzel)

 r ← r mod sat-count(Wurzel)

v ← Wurzel; i ← l

wiederhole, bis v 0- oder 1-Senke

 falls v Knoten in Schicht i mit 0-Nachf. u in j 1-Nachf. w in k

• falls r < 2^j-i-1 * sat-count(u)

 s_i ← 0; (s_i+1, …, s_j-1) ← Binärrepräsentation von r div sat-count(u)

 r ← r mod sat-count(u)

 v ← u; i ← j

• falls r ≥ 2^j-i-1 * sat-count(u)

 s_i ← 1; r ← r - 2^j-i-1 * sat-count(u)

 (s_i+1, …, s_k-1) ← Binärrepräsentation von r div sat-count(w)

 r ← r mod sat-count(w)

 v ← w; i ← k

Unranking (Beispiel)

 r ← 19

i ← 1; r ≥ 2^2-1-1 * sc(v₁) = 1 * 14 = 14

 s₁ ← 1; r ← r - 2^2-1-1 * sc(v₁) = 19 - 1 * 14 = 5

 r ← r mod sc(v₂) = 5 mod 16 = 5

i ← 2; r < 2^4-2-1 * sc(v₆) = 2 * 5 = 10

 s₂ ← 0; (s₃) ← (r div sc(v₆))₂ = (5 div 5)₂ = 1₂ = 1

 r ← r mod sc(v₆) = 5 mod 5 = 0

i ← 4; r < 2^5-4-1 * sc(v₉) = 1 * 1 = 1

 s₄ ← 0; r ← r mod sc(v₉) = 0 mod 1 = 0

i ← 5; r ≥ 2^6-5-1 * sc(v₁₂) = 2 * 0 = 0

 s₅ ← 1; r ← r - 2^7-5-1 * sc(v₁₂) = 0 - 2 * 0 = 0

 r ← r mod sc(v₁₁) = 0 mod 1 = 0

i ← 6; r ≥ 2^7-6-1 * sc(v₁₂) = 1 * 0 = 0

 s₆ ← 1; r ← r - 2^7-6-1 * sc(v₁₂) = 0 - 1 * 0 = 0

 r ← r mod sc(v₁₃) = 0 mod 1 = 0

0 1

1 1

1

30

16 14

4

3 5

2 2

2

v₀

v₁ v₂

v₃

v₄ v₅ v₆ v₇

v₈ v₉ v₁₀

v₁₁

v₁₂ v₁₃

 s ←

 s ← 1

 s ← 101

 s ← 1010

 s ← 10101

 s ← 101011

Ranking und Unranking (Analyse)

 Vorverarbeitung: O(|G|)

 Ranking pro Zustand: O(n)

 Unranking pro Zustand: O(n)

 Vorverarbeitung beschriftet jeden Knoten mit n-bit Zahl →

O(n|G|) extra Bits nötig

Zusammenfassung

 Symbolische Suche zur Verringerung der Speicherlast

speichern von Zustandsmengen (als BDDs) statt einzelner Zustände

 Vorgänger- und Nachfolgerberechnungen (image und pre- image) liefern direkt SBFS und SBBFS

 Symbolische Formen von Dijkstra und A*

 Lösen von Spielen mittels symbolischer Suche

 BDDs als perfekte Hash-Funktion