Controlled
Conspiracy Number
Search
Schriftliche Arbeit zur Erlangung
des Doktorgrades
des Fachbereichs Mathematik / Informatik
der Universit¨at-Gesamthochschule Paderborn
von
Ulf Lorenz
Fachbereich Mathematik / Informatik
Universit¨at GH Paderborn
Paderborn, Deutschland
Dezember 2000
2
Inhaltsverzeichnis
1 Einleitung 1
1.1 Spiele .................................... 1
1.2 Computerschach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Die Anf¨ange . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.2 Modernes Computerschach . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Weitreichende Bedeutung . . . . . . . . . . . . . . . . . . . . . 5
1.3 Algorithmen und Software . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1 Minimax: Der Basisalgorithmus . . . . . . . . . . . . . . . . . . 7
1.3.2 Der
-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 N¨aherungsl¨osungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5 Conspiracy Number Search . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.1 Conspiracy Numbers (dt. Verschw¨orungszahlen) . . . . . . . . . 12
1.5.2 Conspiracy Number Search (CNS) . . . . . . . . . . . . . . . . . 13
1.5.3 Beobachtungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.6 Ergebnisse dieser Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.7 Aufbau dieser Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.8 Definitionen und Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.8.1 Allgemeine Definitionen . . . . . . . . . . . . . . . . . . . . . . 19
1.8.2 Spezielle Definitionen . . . . . . . . . . . . . . . . . . . . . . . 22
2 Das Cc2s-Verfahren 25
2.1 Beschreibung des Cc2s-Algorithmus . . . . . . . . . . . . . . . . . . . . 25
2.1.1 Conspiracy Numbers und blattdisjunkte Strategien . . . . . . . . 25
2.1.2 Metabeschreibung des neuen Vorgehens . . . . . . . . . . . . . . 27
2.1.3 Ein erstes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.1.4 Algorithmische Details . . . . . . . . . . . . . . . . . . . . . . . 30
ii Inhaltsverzeichnis
2.1.5 Komplexes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . 43
2.2 Hergeleitete Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.2.1 Vergleich zwischen der Cc1s und dem
-Algorithmus . . . . . . 46
2.2.2 Cc2s im Vergleich zu Auswahl-Expansion-Aktualisierung basier-
ten Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.3 Heuristiken zur Beschleunigung . . . . . . . . . . . . . . . . . . . . . . 48
2.4 Experimentelle Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.4.1 Baumbeschneidungen und schnelle Bewertungen . . . . . . . . . 56
2.4.2 Form der Suchb¨aume . . . . . . . . . . . . . . . . . . . . . . . . 57
2.5 Beweise zu Kap. 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3 Der Parallele Cc2s-Algorithmus 65
3.1 Hardware .................................. 66
3.2 Bekannte parallele Spielbaumsuchverfahren . . . . . . . . . . . . . . . . 69
3.2.1 Schnelle Zugerzeugung und Bewertung . . . . . . . . . . . . . . 69
3.2.2 Parallele Fenstersuche . . . . . . . . . . . . . . . . . . . . . . . 69
3.2.3 Spielbaumzerlegung . . . . . . . . . . . . . . . . . . . . . . . . 70
3.3 Spielbaumzerlegung beim Cc2s-Algorithmus . . . . . . . . . . . . . . . 72
3.3.1 Verwertung von Parallelit¨at . . . . . . . . . . . . . . . . . . . . . 72
3.3.2 Designentscheidungen bei der Lastverteilung . . . . . . . . . . . 74
3.4 Senderinitiierte parallele Cc2s-Suche . . . . . . . . . . . . . . . . . . . . 76
3.4.1 Grundversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.4.2 Abgaben von Bewertungen . . . . . . . . . . . . . . . . . . . . . 87
3.4.3 Verteilte Transpositionstabelle . . . . . . . . . . . . . . . . . . . 88
3.5 Experimentelle Leistungsbewertung . . . . . . . . . . . . . . . . . . . . 89
3.5.1 Turniere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.5.2 BT2630 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.5.3 Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
3.5.4 Speedupmessungen f¨ur senderinitiierte Cc2s . . . . . . . . . . . 94
3.5.5 Streuungsmessungen auf der HPCLine . . . . . . . . . . . . . . 100
4 Spielbaumsuche mit Fehlern 103
4.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
4.1.1 Das Vorgehen der Anwender . . . . . . . . . . . . . . . . . . . . 104
4.1.2 Fehlermodelle anderer Autoren . . . . . . . . . . . . . . . . . . 104
Inhaltsverzeichnis iii
4.2 Spielbaumsuche ¨uber Bewertungen mit Fehlern . . . . . . . . . . . . . . 106
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨alligen Fehlern . . . . . . . . 108
4.3.1 Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
4.3.2 Interpretation der Ergebnisse . . . . . . . . . . . . . . . . . . . . 112
4.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
4.5 Nachtrag: Modell und Wirklichkeit . . . . . . . . . . . . . . . . . . . . . 124
5 Zusammenfassung und offene Probleme 129
A Der BT2630-Test 131
B Literaturverzeichnis 135
iv Inhaltsverzeichnis
Abbildungsverzeichnis
1.1 Grundform des
-Algorithmus . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Nur die H¨ulle wird von einem Suchalgorithmus abgesucht. . . . . . . . . 9
1.3 Conspiracy Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Rekursive Berechnung der Conspiracy Numbers cn(
,
) . . . . . . . . . 14
1.5 Auswahl, Expansion und Aktualisierung . . . . . . . . . . . . . . . . . . 14
1.6 Zwei blattdisjunkte Strategien beweisen an der Wurzel sechs als untere
Schranke .................................. 21
2.1 Prinzipielles Verhalten . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.2 Beispiel-Spielbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.3 Ausgangssituation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4 Nach der Expansion des Knotens
.................... 29
2.5 Nach der Expansion des Knotens
.................... 30
2.6 Entscheidungsfindung auf oberster Ebene . . . . . . . . . . . . . . . . . 31
2.7 Rekursive Suchprozedur . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.8 Update von heuristischen Knotenwerten . . . . . . . . . . . . . . . . . . 34
2.9 Widerspruchsaufl¨osung (1) . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.10 Widerspruchsaufl¨osung (2) . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.11 ALL- und CUT-Knoten . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.12 Aufteilung von Targets an CUT- bzw. ALL-Knoten . . . . . . . . . . . . 37
2.13 Die Splitprozedur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.14 Teil-Expansion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.15 Soll man
bewerten?............................ 41
2.16 Bewertung eines Knotens . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.17 OnTarget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.18 Schnappschuß vom Suchbaum (1) . . . . . . . . . . . . . . . . . . . . . 43
2.19 Schnappschuß vom Suchbaum (2) . . . . . . . . . . . . . . . . . . . . . 44
vi Abbildungsverzeichnis
2.20 Endg¨ultiger Suchbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.21 Zwei blattdisjunkte Entscheidungsstrategien . . . . . . . . . . . . . . . . 46
2.22 Schreibe Hash-Tabelleneintrag . . . . . . . . . . . . . . . . . . . . . . . 51
2.23 Lese Hash-Tabelleneintrag . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.24 Verwertbarkeit von fehlgeschlagenen Suchen . . . . . . . . . . . . . . . 52
2.25 L¨osche Hash-Tabelleneintrag . . . . . . . . . . . . . . . . . . . . . . . . 53
2.26 Testergebnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.27 Nutzen der Targets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.28 Anzahl der Knoten pro Ebene des Cc1s-Verfahrens . . . . . . . . . . . . 58
2.29 Anzahl von Knoten pro Ebene des Cc2s-Verfahrens . . . . . . . . . . . . 59
3.1 Parallelit¨at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.2 Die Topologie des hpcLine-Rechners . . . . . . . . . . . . . . . . . . . . 66
3.3 SCI-Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.4 Die Topologie des CC-48 Rechners . . . . . . . . . . . . . . . . . . . . . 68
3.5 Ein 3x3 - Gitter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.6 Berechnungsausschnitt . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
3.7 Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.8 Prozeßstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.9 Iterationsschleife des parallelen Cc2s-Algorithmus . . . . . . . . . . . . 78
3.10 Pseudo-Rekursion des parallelen Cc2s-Algorithmus . . . . . . . . . . . . 79
3.11 Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.12 Behandlung von Inkonsistenzen . . . . . . . . . . . . . . . . . . . . . . 85
3.13 Parallelit¨at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.14 Parallelit¨at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3.15 HPCLine vs. Quattro . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
3.16 Speedups auf dem HPCLine System . . . . . . . . . . . . . . . . . . . . 95
3.17 Searchoverhead auf dem HPCLine System . . . . . . . . . . . . . . . . . 95
3.18 Auslastung auf dem HPCLine System . . . . . . . . . . . . . . . . . . . 96
3.19 Speedups auf dem HPCLine System unter MPICH . . . . . . . . . . . . 98
3.20 Searchoverhead auf dem HPCLine System unter MPICH . . . . . . . . . 98
3.21 Auslastung auf dem HPCLine System unter MPICH . . . . . . . . . . . . 99
3.22 Streuung bei 39 Prozessoren . . . . . . . . . . . . . . . . . . . . . . . . 100
4.1 Spielbaum
................................107
Abbildungsverzeichnis vii
4.2 Skizze m¨oglicher Kurvenverl¨aufe von
. ...............113
4.3
(links),
(rechts) . . . . . . . . . . . . . . . . . . . . . 115
4.4 M¨ogliche Konfigurationen an Spielbaumwurzeln . . . . . . . . . . . . . 116
4.5 Schachstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
4.6 Wirkung blattdisjunkter Strategien (bdS) ....................128
viii Abbildungsverzeichnis
Tabellenverzeichnis
3.1 Alle Turnierteilnahmen von P.ConNerS . . . . . . . . . . . . . . . . . . 90
3.2 Ergebnisse auf dem BT2630-Test . . . . . . . . . . . . . . . . . . . . . . 91
3.3 Ergebnisse auf dem CC48 Rechner . . . . . . . . . . . . . . . . . . . . . 100
x Tabellenverzeichnis
Kapitel 1
Einleitung
1.1 Spiele
Jeder von uns steht immer wieder einmal vor der Aufgabe, eine Folge von Entscheidun-
gen innerhalb einer beschr¨ankten Zeitspanne treffen zu m¨ussen. Normalerweise haben
wir dabei nicht gen¨ugend Zeit, alle Konsequenzen unserer Entscheidung zu ber¨ucksichti-
gen. Einmal gef¨allt, ist unsere Entscheidung unwiderruflich. Als besonders unangenehm
empfinden wir dabei Situationen, in denen es andere Personen gibt, die aus unseren Feh-
lern auf unsere Kosten einen Gewinn f¨ur sich selber erzielen wollen. Solche Situationen
m¨ochte man besser verstehen und darin nach M¨oglichkeit sogar Computer zu konkur-
renzf¨ahigen Akteuren machen.
Nun h¨atte selbst Newton wohl kaum die Bewegungsgesetze entdeckt, wenn er versucht
h¨atte, Wasserf¨alle und Wirbelst¨urme zu verstehen. Stattdessen hat er das Problem auf
den urspr¨unglichsten Fall, den er sich vorstellen konnte, vereinfacht: auf Planeten, die
sich im Vakuum bewegen. Typische Vorgehensweisen bei der Modellierung komplexer
Zusammenh¨ange sind also Abstraktion und Vereinfachung.
Modelle, die sich mit der zu Anfang beschriebenen Art von Problemen besch¨aftigen, be-
zeichnen wir als Spiele. Man findet sie in Form von Gesellschafts- und Lernspielen, wie
z.B. Schach, Dame oder Othello, oder als Modelle von komplexen wirtschaftlichen Zu-
sammenh¨angen [vNM43]. Spiele sind somit selber kleine Welten, die es erlauben, sich
auf das Wesentliche dessen zu konzentrieren, was eine vorausschauende Entscheidung
ausmacht.
Sie bilden kleine Welten, die durch wenige, einfache Regeln beschrieben werden k¨onnen.
Spiele stellen klare Kriterien f¨ur Erfolg und Mißerfolg zur Verf¨ugung, erfordern kein all-
zu großes Faktenwissen und sind obendrein einfach zu programmieren. Deshalb sind sie
2 Einleitung
schon immer als ideale Testumgebungen Teil der K¨unstlichen Intelligenz und als Unter-
suchungsgegenstand Teil der Mathematik [EBG82] gewesen. Man kann eine Reihe von
interessanten und nat¨urlichen mathematischen Problemen, die zugleich die schwierigsten
in den Komplexit¨atsklassen PSPACE, EXPTIME oder EXPSPACE sind, als Zweiperso-
nenspiele auffassen[Fra95].
Eine Methode, um in Zweipersonenspielen gute Entscheidungen zu f¨allen, besteht darin,
f¨ur alle m¨oglichen Situationen, die auftreten k¨onnen, die bestm¨ogliche Entscheidung aus-
zurechnen und in einer Datenbank abzulegen. Bei Bedarf kann man in der Datenbank
schnell nach einer konkreten Stellung suchen und bekommt die dazugeh¨orige L¨osung
ausgegeben. Vier-Gewinnt [LVAvdH89], Go-Moku [All94] sowie M¨uhle [Gas95] sind
auf diese Weise vollst¨andig gel¨ost worden. Computer spielen diese Spiele perfekt.
F¨ur Spiele, bei denen man nicht in der Lage ist, alle m¨oglichen Situationen aufzuz¨ahlen
und abzuspeichern, benutzt man oft Baumsuchverfahren, um gute Entscheidungen zu er-
rechnen. Baumsuche ist ein sehr allgemeines Paradigma in der Informatik, das eine wich-
tige Rolle in vielen Anwendungen spielt. Sie bildet die Basis in Beweissystemen, Exper-
tensystemen, Robotersteuerungen u.v.a.
Baumsuche kann auch beim Schachspiel, das weltweit wohl den gr¨oßten Bekanntheits-
grad aller Spiele errungen hat, eingesetzt werden. Da das Schachspiel zwar eine kleine
Welt aus wenigen, einfachen Regeln bildet, aber zum einen so komplex ist, daß es wohl
niemals vollst¨andig gel¨ost werden wird, und zum anderen oft herangezogen wird, um
Aussagen ¨uber die F¨ahigkeiten strategischen und taktischen Denkens einer Person zu
machen, haben wir dieses Spiel zur Beispielanwendung unserer Forschungen gemacht.
Außerdem ¨ubt die Idee, eine Maschine zu konstruieren, die einen menschlichen Weltmei-
ster im Schach schl¨agt, auf viele Menschen (u.a. auf den Verfasser dieser Arbeit) eine
ungebrochene Faszination aus.
1.2 Computerschach
1.2.1 Die Anf¨
ange
F¨ur Levy beginntdie Geschichte des Computerschachs mit Charles Babbage (1792-1871).
Der schrieb um 1840 einen Artikel f¨ur ’The Life of a Philosopher’, aus dem hier aus
Authentizit¨atsgr¨unden ein kleiner Teil zitiert werden soll (entnommen aus Levy [LN91],
Seite 25f):
’After much consideration I selected for my test the contrivance of a machine that should
be able to play a game of purely intellectual skill successfully; such as tit-tat-to, drafts,
1.2 Computerschach 3
chess, etc.
I endeavoured to ascertain the opinions of persons in every class of life and of all ages,
whether they thought it required human reason to play games of skill. The almost constant
answer was in the affirmative. Some supported this view of the case by observing, that if
it were otherwise, then an automaton could play such games. A few of those who had
considerable acquaintance with mathematical science allowed the possibility of machina-
ry being capable of such work; but they most stoutly denied the possibility of contriving
such machinary on account of the myriads of combinations which even the simplest ga-
mes included.
On the first part of my inquiry I soon arrived at a demonstration that every game of skill
is susceptible of being played by an automaton. ...’
Er entwickelte im weiteren seine Ideen zur Vorausschau, die dem Minimaxprinzip sehr
¨ahneln. Diese weiteren hier nicht aufgef¨uhrten Gedanken wirken aus heutiger Sicht zwar
sehr schwerf¨allig, man sieht aber sehr deutlich an den Reaktionen, die er von den von
ihm befragten Personen bekommt, wie revolution¨ar und futuristisch die Idee war, eine
Maschine Schach spielen zu lassen.
Zu Beginn des 20. Jahrhunderts baute Torres y Quevedo eine mechanische Maschine, die
in der Lage war, mit K¨onig und Turm den gegnerischen K¨onig mattzusetzen.
1.2.2 Modernes Computerschach
1945 beschrieb Zuse eine erste Formalisierung eines Schachspiels in seinem Werk ’Der
Plankalk¨ul’ [Zus84].
1949 stellte Shannon [Sha50] ein Papier vor, dessen Brisanz darin liegt, daß die von ihm
beschriebenen Grundlagen bis heute in jedem Computerschachprogramm vorhanden sind.
Er formulierte eine sogenannte ’Typ-A-Strategie’, bei der alle Varianten bis zu einer be-
stimmten Tiefe durchsucht, die Bl¨atter durch heuristische Bewertungen evaluiert und die
Ergebnisse nach dem Minimax-Prinzip zur Ausgangsstellung zur¨uckgerechnet werden.
Außerdem gab er eine ’Typ-B-Strategie’ an, bei der einige Varianten tiefer untersucht
werden als die ¨ubrigen. Er pr¨agte auch den Begriff der Ruhesuche, in der nur Stellungen
bewertet werden d¨urfen, die ’ruhig’ sind. Beim Schachspiel z.B. sind ruhige Stellungen
solche, in denen es keine Schlagz¨uge und keine einem Schach ausweichenden Z¨uge auf
dem Brett gibt.
In den sp¨aten 50er Jahren unseres Jahrhunderts wurde dann das erste Schachprogramm
entwickelt. Es basierte auf den Vorschl¨agen von Shannon und Turing [Tur53].
Anfang der 60er Jahre waren Computer wegen ihrer Gr¨oße und der Anschaffungskosten
ausschließlich beim Milit¨ar und bei milit¨arnahen Einrichtungen zu finden. In dieser Zeit
gab es keine nennenswerten Fortschritte im Computerschach. Gegen Ende der 60er Jahre
4 Einleitung
verf¨ugten dann nahezu alle Universit¨aten und die großen Firmen ¨uber ein eigenes Re-
chenzentrum, das aus einem Großrechner und einer Vielzahl von Terminals bestand. In
dieser Zeit entstanden die ersten Schachprogramme, wie wir sie heute kennen. Sie spiel-
ten Schach auf Anf¨angerniveau. 1967 erspielte sich ein Schachprogramm zum ersten Mal
eine ELO-Zahl von 1640. Es war das Programm MACHACK [GEIC67] von Greenblatt,
Eastlake und Crocker. Von da an nahm die Spielst¨arke von Schachprogrammen rasant zu,
was haupts¨achlich daran lag, daß die zugrunde liegende Hardware schneller wurde. Die
Computerschachprogramme dieser Zeit wurden ausschließlich von Universit¨atsangeh¨ori-
gen geschrieben.
Ihrem akademischen Selbstverst¨andnis folgend, ver¨offentlichten die Forscher und Ent-
wickler von Schachprogrammen ihre Ergebnisse.
Zu Beginn der 80er Jahre eroberte der Personalcomputer die Welt. Die besten Schachpro-
gramme wurden von da an von professionellen Schachprogrammierern geschrieben. Die
Programme von Richard Lang dominierten ¨uber viele Jahre die Computerschachwelt im
Bereich der PCs. Einem Vergleich mit den Programmen der Universit¨aten, die auf we-
sentlich leistungsf¨ahigerer Hardware liefen, konnten sie allerdings nicht standhalten. Das
schaffte aber 1992 Ed Schroeder, als er mit seinem Programm ’Chess Machine’ die offene
Weltmeisterschaft in Madrid vor allen Großrechnern gewann.
Im Gegensatz zu den akademischen Teams gibt es f¨ur die professionellen Computer-
schachprogrammierer gute Gr¨unde, ihre Geheimnisse nicht preiszugeben. Im Gegenteil:
Wissensvorsprung bedeutet Wettbewerbsvorteil. Seit 1990 gibt es nur noch sehr wenige
Artikel und Arbeiten, die Bedeutung haben. Der Informationsaustausch verl¨auft ¨uber in-
formelle Kan¨ale. Christian Donninger, der Programmierer des spielstarken Programms
’Nimzo’, sieht die Zeit bis 1998 so [Don00]: ’Die etwas konnten, sagten nichts, und die
etwas sagten, konnten nichts.’
Einige wenige ausgezeichnete Ver¨offentlichungen, die zu Durchbr¨uchen gef¨uhrt haben,
gab es allerdings doch: Da ist zum einen die Arbeit Donningers ¨uber die sogenannte Null-
movetechnik [Don93], die daf¨ur sorgte, daß eine Reihe von Programmen Meisterniveau
erreichen konnten. Zum anderen gibt es diejenigen Arbeiten, die sich mit der Paralleli-
sierung von Spielbaumsuchverfahren auseinandersetzen, in erster Linie die Arbeiten von
Rainer Feldmann [Fel93] und Peter Mysliwietz [Mys94].
1997 ¨uberraschte das IBM Programm Deep Blue mit der Sensation, Garry Kasparov, den
zu der Zeit st¨arksten Schachspieler der Welt, mit 3,5 zu 2,5 zu schlagen. Allerdings ge-
schahen die Arbeiten an Deep Blue ebenfalls im geheimen.
1999 beschrieb E.A. Heinz [Hei99] in seiner Dissertation den Status Quo im Computer-
schach und ver¨offentlichte mehrere heute gebr¨auchliche Methoden zur selektiven Such-
steuerung.
1.2 Computerschach 5
1.2.3 Weitreichende Bedeutung
Zeigt ein Schachcomputer Intelligenz?
Die Frage, ob Maschinen Intelligenz besitzen k¨onnen, besch¨aftigt Forscher ebenso wie
Science Fiction Autoren, seit es Computer gibt. Diese Frage ist nat¨urlich noch ungel¨ost.
Man muß aber immerhin anerkennen, daß Computer in der Lage sind, erstaunliche intel-
lektuelle Leistungen zu erbringen. Dies zeigt sich besonders deutlich beim Schachspiel:
Schachspieler bel¨achelten die ersten Schachprogramme, als diese vor 30 Jahren entwickelt
wurden. Es galt als unm¨oglich, daß ein Computer ’gut’ Schach spielen kann. Das Schach-
spiel galt sogar als Paradebeispiel f¨ur die ¨uberlegene menschliche Intelligenz. Heute hin-
gegen ist kein Großmeister mehr vor einer Niederlage sicher, wenn er gegen eines der
besten Schachprogramme antreten muß. Vorausschauen, planen, taktieren und Fehler kon-
sequent ausnutzen k¨onnen Schachprogramme mittlerweile genauso gut wie menschliche
Schachgroßmeister. Der bisherige H¨ohepunkt des Computerschachs ist der ber¨uhmt ge-
wordene Kampf des Schachprogramms Deep Blue gegen Garry Kasparov [JS97] [Sei97],
bei dem sich der menschliche Weltmeister geschlagen geben mußte.
Die anf¨angliche Ablehnung des Computerschachs unter Schachspielern ist von konstruk-
tiver Nutzung abgel¨ost worden.
Turnierschach
Entscheidende Bedeutung f¨ur das Turnierschach unter Menschen bekam der Schachcom-
puter schon Mitte der achtziger Jahre. Die besten k¨auflichen Schachprogramme hatten zu
der Zeit das Niveau sehr guter Vereinsspieler erreicht. Mitte der neunziger Jahre spielten
sie schon in etwa so stark wie Internationale Meister.
Nahezu jeder Schachspieler weiß seitdem die Objektivit¨at und die nie endende Aufmerk-
samkeit seines Schachprogramms bei Analysen und Turniervorbereitungen zu sch¨atzen.
Das Computerschach hat dem Schachspiel als solchem neue Impulse geben k¨onnen. Je-
der Schachspieler hat n¨amlich die M¨oglichkeit, zu Hause mit seinem eigenen Experten
Stellungen und Partien zu analysieren. Es ist jetzt nicht mehr das Privileg einiger weni-
ger, die das Gl¨uck haben, begabte Eltern oder Freunde zu haben, oder die zuf¨allig in ein
F¨orderprogramm gerutscht sind, gutes Schach spielen zu k¨onnen. Mit ein wenig ¨
Ubung
kann jeder herausfinden, welche Z¨uge gut und welche schlecht sind. Auf diese Weise ist
Turnierschach auf breiter Front, von der Kreisliga bis zur Weltspitze, st¨arker geworden.
Die Verbesserung vieler einzelner Entscheidungen mit Computerunterst¨utzung (insbeson-
dere in der Er¨offnungsvorbereitung) hat zu einer Verbesserung des Gesamtsystems (d.h.
zu h¨oherwertigen Partien) gef¨uhrt. Ein subjektiver Nebeneffekt ist, daß das Schachspiel
wieder interessanter geworden ist. Mitte der 70er, Anfang der 80er Jahre galt Schach als
6 Einleitung
nahezu erforscht. Fast alle Spiele von Weltklassespielern endeten Remis. Der Computer
hat erheblich dazu beigetragen, daß neue Wege entdeckt wurden, die das Spiel deutlich
dynamischer erscheinen lassen, als bis dahin angenommen wurde.
Gesellschaft
Daß Manager von Firmen zur Entscheidungsunterst¨utzung vorausschauende Software zur
Verf¨ugung bekommen, ist die Vision derjenigen, die sich interdisziplin¨ar wissenschaftlich
mit Strategieerforschung besch¨aftigen. Man darf dann darauf hoffen, daß wie im Schach
auch die Verbesserung aller Einzelentscheidungen zu einer Verbesserung des Gesamtsy-
stems f¨uhrt. Diese Vision scheint in den letzten Jahren sehr viel n¨aher ger¨uckt zu sein,
da sich offenbar auch in den Betriebswirtschaften der Gedanke durchsetzt, daß voraus-
schauendes Handeln einem rein r¨uckw¨arts gerichteten Erfahrungshandeln ¨uberlegen sein
k¨onnte, besonders dann, wenn sich Rahmenbedingungen so rasant ¨andern, wie es im Mo-
ment der Fall ist. Man kann dieses z.B. daran erkennen, daß 1994 ein Nobelpreis an J.C.
Harsanyi, J. F. Nash Jr. und R. Selten [Sel91] f¨ur die Verbindung von Spieltheorie und
den Betriebswirtschaften verliehen wurde. Es sei allerdings angemerkt, daß jene Form der
Spieltheorie nur wenig mit den hier vorgestellten, algorithmischen Ans¨atzen gemeinsam
hat. Außerdem h¨aufen sich Zeitungsartikel wie die im ’Schwerpunkt Unternehmenssteue-
rung’ der Computerwoche [CW99], in denen ¨uber Softwaretools berichtet wird, die das
Management von Firmen bei ihren Entscheidungen unterst¨utzen sollen.
Computerschach ist aber auch noch von einem ganz anderen Standpunkt her interessant,
n¨amlich aus der Sicht von Wissensmanagement. Dadurch, daß Partien gespielt werden,
wird das Spiel von vorne nach hinten St¨uck f¨ur St¨uck analysiert und erforscht. Jeder,
der Partieprotokolle beitr¨agt, tr¨agt zur Erforschung des Spiels bei. Man kann also sagen,
Tausende von Menschen in aller Welt erforschen zusammen das Schachspiel. Kommu-
nikationsbasis ist dabei ein Schachdatenbank-System wie z.B. das der Firma ChessBase,
die Partiedatenbanken, Analysewerkzeuge und sehr starke Schachprogramme vermarktet.
Einen zweiten Pfeiler bildet das Internet, ¨uber das man ¨uber sogenannte Schachserver
gegen Menschen in aller Welt Schach spielen kann. Unter
http://www.chess.co.uk/twic/twic.html
werden Partien von der Oberliga bis zur Weltspitze ver¨offentlicht. Schachserver erm¨ogli-
chen rund um die Uhr das Spielen gegen Gegner aus aller Welt.
1.3 Algorithmen und Software 7
1.3 Algorithmen und Software
1.3.1 Minimax: Der Basisalgorithmus
Aus der klassischen Sichtweise der Informatik handelt es sich beim Schachspiel um ein
Beispiel f¨ur ein Zweipersonen-Nullsummenspiel mit vollst¨andiger Information und ab-
wechselndem Zugrecht. Es gibt zwei Spieler, die gegens¨atzliche Interessen haben. Des
einen Freud ist also des anderen Leid. Beiden ist das Spiel vollst¨andig bekannt, d.h. beide
kennen die aktuelle (Start-)Stellung, alle Z¨uge zu jeder Stellung und die Bewertung von
Endstellungen des Spiels.
Weist man nun den Spielern die Namen MAX und MIN zu (beim Schach Weiß und
Schwarz), den Positionen, in denen MAX gewinnt (im Schach also den Positionen, in
denen Weiß gerade Matt gesetzt hat) den Wert 1, den Positionen, in denen MIN gewinnt,
den Wert -1 und den Remis-Stellungen den Wert 0 zu, kann man mit Hilfe des Minimax-
Algorithmus zu jeder Stellung einen Wert bestimmen, der angibt, wer bei optimalem Spiel
beider Seiten gewinnt.
Einer Endstellung
wird der Wert
!"
zugewiesen:
#"%$
&
')(+* ,
falls
f¨ur MAX gewonnen
-
,
falls
remis
.
* ,
falls
f¨ur MIN gewonnen
F¨ur eine beliebige Stellung
/
mit den Nachfolgestellungen
/010102/3 546
l¨aßt sich nun der
Wert von
/
rekursiv berechnen, wenn man davon ausgeht, daß es keine unendlich langen
Zugfolgen gibt.
7
#/89$;:
max
<
7
=/>
,
01010
,
7
#/?3 @42 BA
,
falls MAX am Zug ist
min
<
7
#/C
,
01010
,
7
#/ 3@42=A
,
falls MIN am Zug ist
Man nennt
7
=/D
den Minimaxwert der Stellung
/
. Um den in der Informatik ¨ublichen Be-
griffen gerecht zu werden, bezeichnen wir im folgenden die Menge der Stellungen als die
Menge
E
von Knoten und die Menge der Z¨uge als die Menge
FHGIJELKMEN
von Kanten.
Wenn nun
JE
,
FN
ein gerichteter Baum ist und
7
eine Funktion, die Knoten auf Zahlen
abbildet, wird
O$P6JE
,
FQ
,
7
Spielbaum genannt. Knoten, die Endstellungen entspre-
chen werden als Bl¨
atter, der Knoten, der der Startstellung entspricht, wird als Wurzel
R
von
bezeichnet.
Der Minimaxalgorithmus, der direkt aus der oben genannten rekursiven Definition von
Werten hervorgeht, baut bei seiner Berechnung einen Spielbaum auf und wertet ihn aus.
8 Einleitung
1.3.2 Der
SUT
-Algorithmus
Wenn wir der Vereinfachung halber davon ausgehen, daß der entstehende Spielbaum b/t-
uniform ist, d.h., jede Stellung genau
V
Nachfolger und jede Endstellung den Abstand
W
zur Startstellung hat, stellen wir fest, daß der Minimaxalgorithmus
VX
viele Endstellungen
besucht. Zu demselben Ergebnis, jedoch in vielen F¨allen wesentlich schneller zur L¨osung
kommt der
-Algorithmus.
value alphabeta(node
Y
, value
Z
, value
[
)
1generiere alle Nachfolger
Y2\]]]^\ Y3
von
Y
2if
_9`ba
return
cedfYhgjilk
(Blattbewertung)
kmi
3for
npo@`rqsut_
4if
Y
ist ein MAX-Knoten
v
5
Zwo@`
max
dxZ \
alphabeta
dfY1y \Z\[jgzg
6if
Z|{}[
return
Z
7if
n~`_
return
Z
8
else
v
9
[o@`
min
df[ \
alphabeta
dfY y
\Z\[jgzg
10 if
Z|{}[
return
[
11 if
n~`_
return
[
12
Abb. 1.1: Grundform des
-Algorithmus
1975 haben Knuth und Moore [KM75] gezeigt, daß f¨ur jeden Knoten
des Spielbaums
folgende Ungleichungen gelten:
alphabeta
#
,
,
falls
7
#D
alphabeta
#
,
,
$
7
#D
falls
b
7
#
alphabeta
#
,
,
falls
7
#D
Deshalb berechnet der Aufruf von alphabeta
#
,
.
,
den Wert minimax
#
. Bei opti-
maler Sortierung der generierten Knoten inspiziert dieser Algorithmus lediglich
Vh X
J9
Vh X
J
.
*
Bl¨atter.
In seinem Buch [Rei89] pr¨asentiert Reinefeld eine Reihe von Varianten des
-Algorith-
mus, die noch einfachere Programmierung erlauben und in den getesteten Anwendungen
die Anzahl der gesuchten Knoten verringern.
1.4 N¨
aherungsl¨
osungen 9
Zwei zus¨atzliche Heuristiken haben dem
-Algorithmus zu seinem Siegeszug beim
Schachspiel verholfen: die sogenannten Transpositionstabellen, das sind Hashtabellen,
die es erm¨oglichen, die Zugsortierung enorm zu verbessern, und die sogenannte Null-
moveheuristik, die es erlaubt, mit zu vernachl¨assigbarem Aufwand große Teilb¨aume w¨ah-
rend der
-Suche abzuschneiden.
Eine ¨
Ubersicht ¨uber die modernsten und erfolgreichsten Varianten der
-Suche findet
man in der Doktorarbeit von E.A. Heinz [Hei99].
In praktischen Anwendungen, wie z.B. im Schachspiel, ist es aufgrund der Gr¨oße der ent-
stehenden Suchb¨aume allerdings nur selten m¨oglich, das Spiel auf die eben vorgestellte
Weise ersch¨opfend zu untersuchen. Deshalb behilft man sich mit einem Trick: Man unter-
sucht nicht den vollst¨andigen Schach-Spielbaum, sondern nur einen kleinen Teil davon.
Statt der tats¨achlichen Stellungswerte (die man nicht zur Verf¨ugung hat) werden an den
Bl¨attern dieses Baums Sch¨atzwerte eingesetzt, die dann nach dem oben beschriebenen
Minimax-Prinzip ausgewertet werden. Jahrelange Beobachtungen zeigen, daß in vielen
Spielen gr¨oßere Suchb¨aume zu besserer Entscheidungsqualit¨at f¨uhren, obwohl die Qua-
lit¨at der Sch¨atzwerte an allen Knoten gleich ist.
1.4 N¨
aherungsl¨
osungen
F¨ur einige Spiele hat man zeigen k¨onnen, daß sie PSPACE-vollst¨andig sind. Die Konse-
quenz ist, daß man (zumindest solange die Polynomzeithierarchie bestehen bleibt) nichts
Besseres tun kann, als einen Spielbaum auszuwerten, um eine perfekte Entscheidung tref-
fen zu k¨onnen. Da die entstehenden Spielb¨aume im allgemeinen viel zu groß sind, um sie
vollst¨andig zu untersuchen, und da man die echten Werte eines Spiels normalerweise nicht
kennt, ist man gezwungen, seine Entscheidungen auf unscharfes und unsicheres Wissen
zu st¨utzen.
Hülle
Vollständiger Spielbaum
Abb. 1.2: Nur die H¨ulle wird von einem Suchalgorithmus abgesucht.
Eine Approximation einer Entscheidung in einem Zweipersonen-Nullsummenspiel wird
10 Einleitung
in der Praxis folgendermaßen errechnet:
Zun¨achst einmal wird ein Teilbaum, der die gleiche Startstellung besitzt wie der eigent-
liche Spielbaum, f¨ur eine Untersuchung ausgew¨ahlt. Wir bezeichnen diesen Teilbaum im
folgenden immer als H¨ulle. Ein geeignetes Spielbaumsuchverfahren versieht die Bl¨atter
der H¨ulle mit heuristischen Werten und rechnet diese Werte nach dem Minimax-Prinzip
zur Wurzel hoch. In fast allen F¨allen wird eine Variante des
-Algorithmus eingesetzt,
da dieser zusammen mit einer Reihe von Sortierheuristiken [Sch89b], [Fel93] ein sehr
gutes Zeitverhalten besitzt.
Eine N¨aherungsl¨osung durch H¨ullen, die an jedem inneren Knoten alle Nachfolger enthal-
ten, die auch im Originalspielbaum enthalten sind und deren Bl¨atter alle eine Entfernung
W
zur Wurzel haben, liefert in vielen F¨allen gute Resultate. Allerdings hat man mittlerwei-
le Heuristiken gefunden, um eine H¨ulle individueller zu gestalten und damit die durch-
schnittliche Qualit¨at von Entscheidungen deutlich anzuheben. Einige dieser Techniken
sind anwendungsunabh¨angig wie z.B. die Singular Extensions [Ana91], die Nullmoves
[Bea89] [Don93] oder die Fail High Reduktionen [Fel96]. Viele andere sind anwendungs-
abh¨angig. Man ist sich in Computerschachkreisen einig, daß die Form der H¨ulle ganz ent-
scheidende Bedeutung f¨ur die Qualit¨at der Suche hat [Don95].
Man kann zwei Klassen von Spielbaum-Suchalgorithmen unterscheiden. Auf der einen
Seite gibt es diejenigen, die einen Minimaxwert einer zuvor fest gew¨ahlten H¨ulle er-
rechnen: Der
-Algorithmus, der SCOUT-Algorithmus [Pea84] [MRS87] oder SSS
[Sto79] sind in den letzten 30 Jahren ersch¨opfend untersucht worden. Eine Arbeit von
Plaat [Pla93] ¨uber den MTD(f) Algorithmus zeigt, daß man den SSS
Algorithmus durch
eine Folge von
-Nullfenstersuchen simulieren kann.
Auf der anderen Seite stehen sogenannte iterative Suchheuristiken [Riv87], die einen
Spielbaum in jeder Zeiteinheit einen Schritt ’wachsen’ lassen. In jedem Schritt wird ein
Blatt ausgew¨ahlt (Auswahlphase), und die Nachfolger dieses Blattes werden dem Spiel-
baum hinzugef¨ugt (Expansion). Dann werden die neuen Bl¨atter bewertet, und der neue
heuristische Minimaxwert wird von den Bl¨attern zur Wurzel aktualisiert (Aktualisierungs-
phase).
Die auf diese Weise gewachsenen Spielb¨aume brauchen weder tiefenuniform zu sein,
noch ist es notwendig, die H¨ulle vor Beendigung der Spielbaumsuche festzulegen. Bei-
spiele f¨ur solch iterative Suchheuristiken sind Berliners B
Algorithmus [Ber79], Palays
wahrscheinlichkeitsbasierte Methode [Pal85] und Conspiracy Number Search. Letztere
wurde von D. McAllester [McA88] vorgeschlagen. J. Schaeffer [Sch90] griff die Idee auf
und implementierte einen Algorithmus, der sich als sehr gut im Bereich taktischer Suchen
beim Schach erwiesen hat. U. Lorenz und andere [LRFM95] haben bereits 1995 Ide-
1.4 N¨
aherungsl¨
osungen 11
en pr¨asentiert, die es erm¨oglichen sollten, Conspiracy Number Suchen effizienter durch-
zuf¨uhren.
Der Ausgangspunkt f¨ur Conspiracy Number Search (CNS) ist die Beobachtung, daß der
-Algorithmus in gewissem Sinn Entscheidungen mit niedriger Sicherheit liefert:
Im allgemeinen kann n¨amlich die ¨
Anderung eines einzelnen Blattwertes (z.B. durch einen
Fehler der heuristischenBewertungsfunktion) zu einer ¨
Anderungder Entscheidungf¨uhren,
die an der Wurzel gef¨allt werden muß. Der
-Algorithmus f¨allt also Entscheidungen mit
Sicherheit (d.h. mit Conspiracy Number) eins.
Das Ziel von CNS ist es, die vorhandenen Ressourcen so zu verteilen, daß garantiert ist,
daß eine Entscheidung mit einer Conspiracy Number
*
gef¨allt wird. Das bedeu-
tet dann, daß eine Entscheidung an der Wurzel stabil ist, gegen¨uber einer willk¨urlichen
Ver¨anderung von bis zu
.
*
Blattwerten. Schaeffers Algorithmus verwaltet die n¨otigen
Informationen mit Hilfe von Vektoren, die er an allen Knoten des Spielbaums speichert.
Ein Conspiracy Number Vektor eines Knotens
informiert dar¨uber, wieviele Knoten un-
terhalb von
ihren Wert zu einer Zahl
ver¨andern m¨ussen, damit sich der Minimaxwert
von
auf den Wert
¨andert. Weil alle gesammelten Informationen jederzeit verf¨ugbar
sein m¨ussen, wird der Speicherbedarf des Verfahrens durch die Anzahl der untersuchten
Knoten und vor allem durch die Granularit¨at der Bewertungsfunktion bestimmt.
Der enorme Speicherbedarf ist auch einer der Gr¨unde, weshalb sich der Einsatz von CNS
bisher auf taktische Suchen beschr¨ankt hat. Schaeffer [Sch90] hat versucht, mit Hilfe ei-
ner grob-granularen Bewertungsfunktion Entscheidungen zu finden, die deutlich besser
erscheinen als die Alternativen. F¨ur taktische Stellungen hat sich CNS den uniform ge-
stalteten Suchen als ¨uberlegen erwiesen.
Allgemeine Eingaben erf¨ullen allerdings nicht die Eigenschaft, daß klar ¨uberlegene Ent-
scheidungen vorhanden sind. Die Spielbaumsuche auf Instanzen, bei denen eine Ent-
scheidung zu finden ist, die nur marginal besser ist als ihre Alternativen, bezeichnet man
auch als positionelle oder strategische Suche. Zu diesem Zweck ben¨otigt man eine fein-
granulare Bewertungsfunktion und damit auch sehr viel Speicher. Es ist entt¨auschend
zu sehen, wie die konventionelle CNS ernste Probleme mit der Terminierung bekommt,
wenn man eine fein-granulare Bewertung einsetzt. Manchmal untersucht CNS schon rie-
sige Teilb¨aume, um eine Entscheidung auch nur mit niedriger Sicherheit zu finden. Als
Konsequenz haben diese Nachteile dazu gef¨uhrt, daß die CNS nicht erfolgreich f¨ur allge-
meine Eingabeinstanzen implementiert wurde.
12 Einleitung
1.5 Conspiracy Number Search
1.5.1 Conspiracy Numbers (dt. Verschw¨
orungszahlen)
In jedem Spielbaum, dessen Wert so zustande kommt, daß man seine Bl¨atter mit heu-
ristischen Werten belegt, die man nach dem Minimax-Prinzip zur Wurzel hochrechnet,
h¨angt der Wert der Wurzel von den heuristischen Blattwerten ab. Wenn ein Spielbaum
nun so aufgebaut wird, daß bestehende Bl¨atter eines Spielbaums zu inneren Knoten ge-
macht werden k¨onnen, indem alle Nachfolger dieses Blattes erzeugt und heuristisch be-
wertet werden, kann es passieren, daß sich nach solch einem Erweiterungsschritt der Wert
der Wurzel ebenfalls ¨andert. Der Effekt, den Blattwertver¨anderungen auf einen Wurzel-
wert haben k¨onnen, ist die Rechtfertigung der Conspiracy Numbers, die von McAlle-
ster [McA88] 1988 erstmals vorgestellt wurden. Eines der Hauptziele ist die Bek¨amp-
fung einiger Schw¨achen des
-Algorithmus: In der Grundversion schneidet der
-
Algorithmus seinen Suchbaum in einer festen Tiefe ab, unabh¨angig von der Wichtigkeit
bestimmter Varianten. Im Extremfall kann es passieren, daß das Ergebnis des Algorith-
mus an der Wurzel des Spielbaums von einer einzigen statischen Bewertung eines Blattes
abh¨angt.
A=3
B=2 C=3
D=5 E=2 F=3 G=4
1
2
3
4
5
6
2
1
0
1
1
2
Wert Conspiracy
Number Knoten
(D oder E) und (F oder G)
F oder G
E oder F
E
(D und E) oder (F und G)
1
2
3
4
5
6
Wert CN
1
0
1
1
1
2
1
2
3
4
5
6
Wert CN
1
1
0
1
2
2
Abb. 1.3: Conspiracy Numbers
Die originale Definition einer Conspiracy Number (dt. Verschw¨orungszahl) ist wie folgt:
Definition 1.5-1 (Conspiracy Number)
Sei
$E
,
FN
ein gerichteter Baum und
eine heuristische Bewertungsfunktion, die
Knoten auf Zahlen abbildet. Die Conspiracy Number der Wurzel eines Spielbaums
;$
6E
,
FN
,
f¨ur einen Wert
ist definiert als die minimale Anzahl der Bl¨atter von
, die
1.5 Conspiracy Number Search 13
ihren Wert zu
¨andern m¨ussen, um den Minimaxwert der Wurzel von
zu
zu ¨andern.
Eine Conspiracy Number
besagt, daß sich mindestens
Blattwerte ¨andern (d.h. ’ver-
schw¨oren’) m¨ussen, um den Wert der Wurzel zu
zu ver¨andern. Betrachten wir zur Ver-
deutlichung das Beispiel in Abb. 1.3 [Sch90]. Die Anzahl der Nachfolger jedes inneren
Knotens sei dabei 2, die m¨oglichen Werte seien 1 bis 6. Innerhalb der Knoten sind der je-
weilige Name und der Minimaxwert eingezeichnet. Neben den inneren Knoten ist jeweils
eine Tabelle zu sehen, die zeigt, wieviele Bl¨atter ihren Wert mindestens ¨andern m¨ussen,
um den Wert der Wurzel zu 1,2,3,4,5 oder 6 zu ¨andern. So braucht sich z.B nur der Wert
des Blattes
F
auf 5 zu ¨andern, und schon wird auch der Wert der Wurzel 5.
Es gibt eine einfacheM¨oglichkeit, die Conspiracy Numbersrekursivzu berechnen [Sch90]
[vdM90].
Die Conspiracy Numbereines Blattes ist 0 f¨ur den Wert des Blattes. F¨ur alle anderen
Werte ist die Conspiracy Number 1.
Wenn wir den Wert
eines MAX-Knotens (MIN-Knotens)
auf
senken
(
erh¨ohen) wollen, m¨ussen alle Nachfolger von
, die einen Wert gr¨oßer
(kleiner) als
haben, ihren Wert absenken (erh¨ohen). Wenn
j0m0106l
diese Nach-
folger sind, wobei
B9#
,
j010106u =l
,
gerade die Conspiracy Numbers der je-
weiligen Knoten f¨ur den Wert
sind, ist die Conspiracy Number des Knotens
f¨ur
den Wert
offensichtlich die Summe der
u =
,
j010m02B9=l
,
.
Wenn wir den Wert
eines MAX-Knotens (MIN-Knotens )
auf
L
erh¨ohen
(
vermindern) wollen, reicht es, wenn ein Nachfolger von
den Wert
an-
nimmt. Seien
u =
,
j0m0106B9#
,
die Conspiracy Numbers der jeweiligen Kno-
ten f¨ur den Wert
. Die Conspiracy Number von
f¨ur
ist das Minimum der
B9=
,
j010102B9#
,
.
Abbildung 1.4 zeigt den Sachverhalt formal. Minimax(
) bezeichnet den Minimaxwert
des Teilbaums, dessen Wurzel
ist,
u =
,
"
bezeichnet die Conspiracy Number (Ver-
schw¨orungszahl) von
f¨ur den Wert
.
1.5.2 Conspiracy Number Search (CNS)
Conspiracy Numbers sind ein Maß f¨ur die Sicherheit, daß der Wert der Wurzel richtig
eingesch¨atzt wird. Das Ziel einer Suche muß es deshalb sein, einen Suchbaum so aus
dem Gesamtspielbaum herauszuschneiden, daß der Wurzelwert mit einer vorgegebenen
Conspiracy Number sicher ist.
14 Einleitung
if minimax(
) =
cn(
,
) := 0;
else if
ist ein Blatt
<
cn(
,
) := 1;
A
else
<
if
ist ein MAX-Knoten und
minimax
#
cn(
,
) :=
¢¡#£B¤^¥
¡
x¦ §1¨
minimax
¡#£
cn(
^©
,
);
ª«U¬
=
bezeichne die Menge aller Nachfolger von
«?ª
ª«
^©
sei der
-te Nachfolger
«?ª
else if
ist ein MIN-Knoten and
®
minimax
#
cn(
,
) :=
¡#£B¤^¥
¡
x¦ §1¯
minimax
¡#£
cn(
^©
,
);
else if (
ist ein MAX-Knoten und
®
minimax
=
)
oder (
ist ein MIN-Knoten und
minimax
#
)
cn(
,
) :=
°²±´³
¡#£¤m¥
¡
cn(
^©
,
);
A
Abb. 1.4: Rekursive Berechnung der Conspiracy Numbers cn(
,
)
In den von Schaeffer und van der Meulen [vdM90] vorgestellten Algorithmen, denen ei-
ne Sicherheitsschranke
vorgegeben wird, wird folgendermaßen vorgegangen: Wenn der
Wert einer Wurzel so gesichert ist, daß sich
Bl¨atter ver¨andern m¨ussen, um den Wur-
zelwert ¨uberhaupt zu beeinflussen, gilt der Wurzelwert als sicher, und der Algorithmus
terminiert. Solange es einen Wert gibt, dessen zugeh¨orige Conspiracy Number kleiner als
ist, werden die folgenden drei Phasen durchlaufen (vgl. Abbildung 1.5):
Auswahl Expansion Aktualisierung
Abb. 1.5: Auswahl, Expansion und Aktualisierung
Zun¨achst l¨auft der CNS-Algorithmus von der Wurzel zu einem Blatt, das zu der Menge
von Bl¨attern geh¨ort, die den Wurzelwert auf
bringen k¨onnen. Diese erste Phase wird
Auswahlphase genannt. Der Algorithmus findet ein solches Blatt mit Hilfe der an den
Knoten gespeicherten Conspiracy Number Vektoren. Es ist m¨oglich, aufgrund rein lokaler
1.5 Conspiracy Number Search 15
Entscheidungen einen Pfad
µ¶$ =²$·R
,
01010
,
l¸h
von der Spielbaumwurzel zu einem
geeigneten Blatt
¹¸
zu finden. Wie der Auswahlprozeß abl¨auft, betrachten wir am besten
an dem Beispiel in Abb. 1.3.
Sei eine Sicherheitsschranke
º$¼»
vorgegeben. An einem Knoten
werden Werte, deren
Conspiracy Numbers kleiner als
sind, als plausible Werte bezeichnet. Der Wert, f¨ur den
die Conspiracy Number an
gleich Null ist, wird als der plausibelste Wert angesehen.
Der vorliegende Spielbaum soll so erweitert werden, daß die Conspiracy Number des
am weitesten vom Wurzelwert entfernten plausiblen Wertes (
E½
) erh¨oht wird. Dazu wird
dasjenige Blatt des Spielbaums erweitert (d.h., es werden alle Nachfolger davon generiert
und bewertet), das am ehesten in der Lage zu sein scheint, den Wert der Wurzel auf
E½
zu
ziehen. (Falls es mehrere gleichwertige Kandidaten gibt, wird der linkeste der Kandidaten
erweitert.)
In unserem Beispiel beginnt die Auswahlphase bei der Wurzel
¾
. Die Werte 1 und 6
der Wurzel in Abb. 1.3 werden als nicht in Frage kommend betrachtet, weil ihre Con-
spiracy Numbers schon gr¨oßer oder gleich
sind. Der kleinste plausible Wert (
E¿
y
¸
)
ist 2, der gr¨oßte plausible Wert (
E8¿À>§
) ist 5, und der plausibelste Wert (
EÁÂBÃzÄÆÅÇ
) ist 3.
Es gibt mehr plausible Werte oberhalb von
EÁÈÂuÃÉÄ>ÅÇ
, als darunter (
E8¿À>§
.
EÁÂBÃzÄÆÅÇ|
EÁÈÂBÃzÄÆÅJÇ
.
E8¿
y
¸
). Deshalb versucht der Algorithmus, den Bereich der plausiblen Werte
oberhalb von
EÁÈÂBÃzÄÆÅJÇ
zu verkleinern. Er erweitert den Knoten, der am ehesten in der Lage
zu sein scheint, den Wert der Wurzel zu 5 zu ¨andern. Aus Sicht der Wurzel hat der Kno-
ten
Ê
nur eine Conspiracy Number von 1 f¨ur den Wert 5, der Knoten
Ë
eine Conspiracy
Number von 2. Es hat den Anschein, als m¨usse man unter
Ê
weniger Arbeit investieren,
um den Wert der Wurzel, wenn ¨uberhaupt, auf 5 zu bringen. Der Auswahlprozeß ver-
zweigt deshalb zum Knoten
Ê
. Danach wird nach
F
verzweigt, da eine ¨
Anderung des
Wertes von
F
auf 5 den Wert der Wurzel zu 5 werden ließe, eine ¨
Anderung (in diesem
Fall eine Beibehaltung) des Wertes von
Ì
auf 5 keine Auswirkung h¨atte.
Die Erweiterungsphase erzeugt und bewertet alle Nachfolger des Blattes, das in der Aus-
wahlphase ausgew¨ahlt wurde.
In der dritten Phase werden die neuen Erkenntnisse der Erweiterungsphase in den Such-
baum eingebunden. Man spricht von der Aktualisierungsphase. Die Werte der neuen
Bl¨atter werden zur Wurzel hin nach dem Minimax-Prinzip ausgewertet.
Die Algorithmen von Schaeffer und van der Meulen suchen sehr selektiv schmale Vari-
anten ab. Leider erweitern sie den Suchbaum auch ab und an in unn¨otige Tiefen, um et-
was zu beweisen, was nicht zu beweisen ist. Das Konvergenzverhalten des Verfahrens ist
manchmal sehr langsam, bzw. wenn man unendlich große Instanzen zul¨aßt, kann es pas-
sieren, daß die Verfahren ihre Berechnungen niemals beenden. Beide Implementationen
der Conspiracy Number Suche zeigen gutes Verhalten auf taktischen Schachstellungen,
zeigen aber auch Schw¨achen:
16 Einleitung
Die Erweiterung desSuchbaums ist sehr aufwendig,weil keine vorgegebenenSchran-
ken wie z.B. beim
-Verfahren vorhanden sind.
An jedem Knoten m¨ussen Conspiracy Number Vektoren gespeichert werden. Der
Speicherverbrauch h¨angt deshalb stark von der Granularit¨at der benutzten Bewer-
tungsfunktion ab.
Strategisches Positionsschach ist kaum m¨oglich, weil das Konvergenzverhalten bei
Benutzung einer fein-granularen Bewertungsfunktion sehr schlecht ist.
Dadurch, daß in jedem Metaschritt (Auswahl
Expansion
Aktualisierung) der
Algorithmen der jeweilige Suchbaum an einem Blatt erweitert wird, sind beide Im-
plementationen inh¨arent sequentiell.
Wie bei allen Bestensuchverfahren muß der Suchbaum vollst¨andig im Speicher ge-
halten werden. Die Speicheranforderungen sind somit linear in der Suchzeit.
1.5.3 Beobachtungen
Beobachtung 1.5-1
Sei
µ $ =RÍ$Î
,
01010
,
¹¸
der Pfad der
W
-ten Auswahlphase. Dann gibt es h¨aufig ein
^©
,1*
ÏТ
, dessen Conspiracy Number Vektor durch die folgende Spielbaumerweite-
rung gar nicht beeinflußt wird. Deshalb sind
"010m06^©
auch Teil des Pfades der
#W
*
-sten
Auswahlphase.
Beobachtung 1.5-2
Eine MAX(/MIN)-Strategie in einem Spielbaum
ist ein Teilbaum von
(mit der-
selben Wurzel wie
), der an jedem MAX(/MIN)-Knoten genau einen und an jedem
MIN(/MAX)-Knoten alle Nachfolger, die es entsprechend
gibt, enth¨alt. Eine MAX-
(/MIN)-Strategie liefert eine untere(/obere) Schranke f¨ur den Minimaxwert von
.
Der Begriff der Conspiracy Numbers l¨aßt sich auch mit Hilfe des Strategiebegriffs aus-
dr¨ucken. Wenn n¨amlich mindestens
Bl¨atter ihren Wert zu
¨andern m¨ussen, um den
Wurzelwert zu
zu ¨andern, gibt es
blattdisjunkte Strategien, die zeigen, daß der Wert
der Wurzel nicht
ist. Gibt es umgekehrt
blattdisjunkte Strategien, die zeigen, daß der
Wert gr¨oßer (bzw. kleiner) einer bestimmten Schranke
ist, m¨ussen sich mindestens
Blattwerte ¨andern, damit der Minimaxwert der Wurzel die gegebene Schranke verletzt (s.
Abschnitt 2.1.1). Deswegen werden wir den Begriff der Conspiracy Numbers im n¨achsten
Kapitel f¨ur Schranken definieren.
1.6 Ergebnisse dieser Arbeit 17
Beobachtung 1.5-3
Die gerade gemachte Beobachtung impliziert die folgende: Wenn ein konventioneller
CNS-Algorithmus einen Wurzelwert
’einschn¨urt’ und nacheinander ’beweist’, daß der
Wert nicht
ÉѼÒÓÒÓÒ8Ï
ist, sucht er nacheinander Strategien, die zeigen, daß der
Wert der Wurzel
¼
,
¢zÑ
,
01010
,
¼
ist. Eine Strategie, die beweist, daß der Wurzel-
wert
Ô
ist, beweist aber schon, daß der Wert auch
Ô
ist.
Beobachtung 1.5-4
Es gen¨ugt, an der Wurzel eines Spielbaums einen besten Zug zu finden. Der absolute
Wert der dazugeh¨origen Wurzel ist dann nicht wichtig. Es gen¨ugt zu wissen, daß der
Minimaxwert des einen Wurzelnachfolgers besser ist als die Minimaxwerte der anderen
Wurzelnachfolger.
1.6 Ergebnisse dieser Arbeit
In dieser Arbeit werden wir ein neuartiges Spielbaumsuchverfahren vorstellen, das wir
auch erfolgreich parallelisiert haben.
Es handelt sich um einen von uns so genannten Controlled Conspiracy Number Search
Algorithmus, der eine wesentlich zielgerichtetere Suche darstellt als die herk¨ommliche
Conspiracy Number Search. Er l¨ost die im vorigen Abschnitt skizzierten Probleme soweit,
daß ein sehr erfolgreicher Einsatz in einem Schachprogramm m¨oglich ist. Der Suchalgo-
rithmus wird von sogenannten Targets kontrolliert, die w¨ahrend der Suche Anforderungen
an Knoten definieren.
Das neue Spielbaumsuchverfahren wird im Weltklasse-Schachprogramm P.ConNerS ver-
wendet, das u.a. als erstes Programm der Welt ein offizielles Schachgroßmeisterturnier
unter regul¨aren Turnierbedingungen gewinnen konnte.
Beim 10. Lippst¨adter Großmeisterturnier 2000 lief P.ConNerS auf einem System mit 160
Pentium II 450MHz Prozessoren. Damit ist der in dieser Arbeit vorgestellte parallele Al-
gorithmus der erste, der in einem erfolgreichen Schachprogramm auf einem Workstation-
cluster dieser Gr¨oße effizientes Verhalten zeigt.
Eine theoretische Analyse von Blattfehlerbewertungen in Spielb¨aumen verhilft zu der
Einsicht, daß die Spielbaumstruktur entscheidenden Einfluß auf die Fortpflanzung solcher
Fehler besitzt. Sie motiviert noch einmal die Conspiracy Number Idee.
18 Einleitung
1.7 Aufbau dieser Arbeit
Im zweiten Kapitel zeigen wir zun¨achst (Abschnitt 2.1.1), daß man Conspiracy Numbers
auch ¨uber den Begriff von ’blattdisjunkten Strategien’, die den Wert der Spielbaumwurzel
belegen, definieren kann.
In den folgenden Abschnitten, beginnend bei Abschnitt 2.1.2, beschreiben wir den Cc2s-
Algorithmus, der folgendes Sicherheitskonzept umsetzt: Um an der Wurzel eines Spiel-
baums zu einer Entscheidung zu kommen, m¨ussen wir eine untere Schranke f¨ur den Wert
des besten Wurzelnachfolgers bestimmen und obere Schranken f¨ur die Werte der anderen
Nachfolger. Das Ziel ist es, eine H¨ulle nach dem Minimax-Prinzip auszuwerten, deren
Bl¨atter eine Entfernung von mindestens
W
zur Wurzel haben und die gleichzeitig minde-
stens zwei blattdisjunkte Strategien f¨ur jede, wie gerade beschriebene, zu berechnende
Schranke enth¨alt. (Man vergleiche diese Zielsetzung mit dem dritten Kapitel ¨uber Fehler-
fortpflanzung in Spielb¨aumen.)
Eine Erweiterung des Verfahrens mit fester Conspiracy Number 2 zu einem allgemeinen
Controlled CNS-Algorithmus ist leicht m¨oglich.
Es folgen im Abschnitt 2.2 einige hergeleitete Eigenschaften des Verfahrens, und wir
vergleichen es soweit m¨oglich mit dem
-Algorithmus und mit konventionellen inkre-
mentellen Suchalgorithmen. Dabei machen wir die folgenden Beobachtungen:
a) Wenn der Cc2s-Algorithmus terminiert ist, basiert das Ergebnis auf einer H¨ulle
Õ
mit den gew¨unschten Eigenschaften, und dieses Ergebnis basiert auf Minimaxwerten der
H¨ulle
Õ
. D.h. bei vorgegebener H¨ulle
Õ
k¨ame jede Variante eines Minimax-Algorithmus
zu demselben Ergebnis.
b) Wenn wir uns auf vordefinierte und endliche H¨ullen beschr¨anken (was z.B. f¨ur Analy-
sen des
-Algorithmus immer getan wurde), terminiert unser Algorithmus in endlicher
Zeit.
c) Wenn wir wie in b) nur vordefinierte und endliche H¨ullen betrachten und somit nicht
zwei blattdisjunkte Beweisstrategien als Sicherheit fordern, untersucht unser Algorithmus
im besten Fall die minimal m¨ogliche Anzahl Bl¨atter.
Danach richten wir unsere Aufmerksamkeit auf das Verhalten des Verfahrens in einer
Anwendung, und zwar in unserem Schachprogramm ConNerS. Zun¨achst werden zu die-
sem Zweck einige praxisrelevante Zusatzheuristiken zur Beschleunigung der Suche kurz
vorgestellt (Abschnitt 2.3). Abschnitt 2.4 zeigt die experimentellen Ergebnisse in der An-
wendung Schach.
Kapitel 3 besch¨aftigt sich mit der Parallelisierung des neuen Verfahrens. Abschnitt 3.1 be-
schreibt die verwendeten Hardwareplattformen. Abschnitt 3.2 gibt einen ¨
Uberblick ¨uber
die wichtigsten Ver¨offentlichungen zum Thema parallele bzw. verteilte Spielbaumsuche.
1.8 Definitionen und Begriffe 19
Der Rest von Kapitel 3 beschreibt die Parallelisierung des Cc2s-Algorithmus (Abschnitt
3.3) und dazugeh¨orige experimentelle Ergebnisse (Abschnitt 3.5).
Kapitel 4 beschreibt eine Analyse von Fehlerfortpflanzungen in Spielb¨aumen mit nicht-
perfekter Bewertungsfunktion. Wir werden dort zeigen, daß der Begriff der ’blattdis-
junkten den Wurzelwert belegenden Strategien’ sowohl unter Worstcasebetrachtungen als
auch unter Durchschnittsbetrachtungen von entscheidender Bedeutung ist. Die Analyse
motiviert noch einmal die Verwendung von Conspiracy Numbers.
1.8 Definitionen und Begriffe
1.8.1 Allgemeine Definitionen
Definition 1.8-2 (Spielbaum)
Ö$!
,
ist ein Spielbaum, wenn
×$ØE
,2Ù
ein gerichteter Baum ist und
bÚjEÜÛ
Ý!Ý
eine Funktion von der Menge der Knoten in die Menge der ganzen Zahlen.
Þßà
bezeichnet die Menge der Bl¨atter von
.
¬
=
ist die Menge der Nachfolger des Knotens
. Knoten des Baums
bezeichnen wir auch als Knoten des Spielbaums
.
Bemerkung: Wir identifizieren Knoten eines Spielbaums
mit Stellungen des vorliegen-
den Spiels und Kanten von
mit Z¨ugen von einer Stellung zur n¨achsten. Außerdem gibt
es zwei Spieler: MIN und MAX, die abwechselnd ziehen (d.h. eine Kante w¨ahlen). Wenn
wir nicht explizit etwas anderes voraussetzen, gehen wir davon aus, daß die Wurzel ein
MAX-Knoten ist. D.h., MAX zieht an den Knoten in den geraden Ebenen von
, MIN an
den Knoten in den ungeraden Ebenen.
Definition 1.8-3 (H¨ulle)
Es sei
ein Spielbaum mit Wurzel
R
. Ein Teilbaum
Õ
von
heißt H¨
ulle von
, wenn
gilt:
RºáâÕ
bã
ÐáâÕäÚ
¬
å#D%$
¬
=
oder
¬
å#D9$¢æ
.
Bemerkung: Sei
ç
ein Suchalgorithmus f¨ur Spielb¨aume. Wir unterscheiden nicht nur
zwischen Spielbaum und H¨ulle, sondern zus¨atzlich noch zwischen H¨ulle und (aktuel-
lem) Suchbaum. Ein Suchbaum ist ein Teilbaum einer H¨ulle. So k¨onnte zum Beispiel
20 Einleitung
ein in Breite und Tiefe uniformer Teilbaum eines Gesamtspielbaums als H¨ulle dienen.
Der Minimax-Algorithmus und der
-Algorithmus k¨amen bei der Auswertung dieser
H¨ulle zwar zu dem gleichen Ergebnis, w¨urden aber verschiedene Suchb¨aume erzeugen.
Sei
ein Knoten und sei
¬
#
die Menge der Nachfolger von
, eine H¨ulle
Õ
betreffend.
¬
##D
bezeichnet die Menge derjenigen Nachfolger von
, die explizit vom Algorithmus
ç
zu einem Zeitpunkt
W
untersucht wurden. Streng genommen m¨ußten wir also
¬
##D
als
¬
è
¦
X
=
schreiben. Aus Gr¨unden der ¨
Ubersichtlichkeit verzichten wir, falls es zu keinen
Verwechslungen kommen kann, auf die Mehrfachindizierung.
Definition 1.8-4 (Minimaxwerte)
Sei
é$·!
,
ein Spielbaum und
êáLE
ein Knoten von
. Die Funktion minimax
Ú
EëÛ
Ý!Ý
ist rekursiv definiert durch
minimax
=Ú$
&ì
ì
ì
ì
ì
'
ì
ì
ì
ì
ì
(
#
falls
²áâÞßà
°Mílî<
minimax
=åï=
,
ðáâFñA
falls
ª
áâÞß=Q
und MAX ist am Zug
°²±´³<
minimax
#
åï=
,
á®FñA
falls
ª
áâÞß=Q
und MIN ist am Zug
Wir nennen minimax
#D
den Minimaxwert von
. Der Minimaxwert der Wurzel von
wird auch als minimax
à
bezeichnet.
Definition 1.8-5 (Strategie)
Sei
$ #
,
ein Spielbaum (oder eine H¨ulle),
ò+áØ<
MIN
,
MAX
A
mit der Wurzel
RóáëE
. F¨ur einen beliebigen Knoten
ô+áõE
sei
¬
=ô"
die Menge der Nachfolger von
ô
im Spielbaum
. Eine Strategie f¨
ur einen Spieler
ò
ist ein Teilbaum
ö~÷à$øJE÷
,
FU÷
des
Spielbaums
, f¨ur den gilt:
RºáùE÷
Falls
ô|áùE÷
ein innerer Knoten von
ist, bei dem
ò
am Zug ist, gibt es genau einen
Nachfolger
ôá
¬
#ô"
von
ô
mit
ôáùE÷
und
#ô
,
ôáâFß÷
.
Falls
ôOáE÷
ein innerer Knoten von
ist, bei dem der Gegner
ò
von
ò
(
òLá
<
MAX,MIN
A
.
<òhA
) am Zug ist, gilt
¬
#ô"G+E÷
und f¨ur alle
ôá
¬
=ô"
ist
=ô
,
ôðá
Fß÷
.
Eine MAX-Strategie (vgl. auch Abb. 1.6) ist damit ein Teilbaum mit Wurzel
R
von
, der
an jedem MAX-Knoten genau einen und an jedem MIN-Knoten alle Nachfolger von
enth¨alt. F¨ur MIN-Strategien ist es genau anders herum. Knoten, die innerhalb einer Stra-
tegie genau einen Nachfolger besitzen, nennen wir CUT-Knoten. Die Knoten, an denen
alle Nachfolger vorhanden sind, werden als ALL-Knoten bezeichnet.
1.8 Definitionen und Begriffe 21
Bemerkung: Eine Strategie ist ein Teilbaum von
, der eine Schranke f¨ur den Minimax-
wert von der Wurzel von
beweist. Eine MIN-Strategie beweist eine obere Schranke f¨ur
den Minimaxwert von
(diese Schranke entspricht gerade dem gr¨oßten Blattwert der
Strategie), und eine MAX-Strategie beweist eine untere Schranke (diese Schranke ent-
spricht gerade dem kleinsten Blattwert der Strategie). In der Literatur findet man auch oft
den Begriff solution tree anstelle des Strategiebegriffs.
Definition 1.8-6 (Blattdisjunkte Strategien)
Zwei Strategien werden blattdisjunkt genannt, wenn sie kein Blatt gemeinsam haben.
Bemerkung: Da Strategien immer bis an die Bl¨atter von H¨ullen heranreichen, gibt es
keine Bl¨atter einer Strategie, die gleichzeitig innere Knoten anderer Strategien sind.
6
6
67
67 6 2 5 4 0 4 1
6 6
6666
5 4
4
Wurzel der Hülle H
Blätter der 1. Strategie
Blätter der 2. Strategie
Knoten beider Strategien
Abb. 1.6: Zwei blattdisjunkte Strategien beweisen an der Wurzel sechs als untere Schran-
ke
Definition 1.8-7 (Conspiracy Number)
Es sei
Õ
eine H¨ulle mit Wurzel
R
. Es gebe eine Strategie, die belegt, daß der Minimax-
wert der H¨ulle
Ô
(bzw.
Ô
) ist. Dann gibt die Conspiracy Number cn(
,
) die kleinste
Anzahl von Bl¨attern der H¨ulle an, die ihren Wert ¨andern m¨ussen, um den Minimaxwert
der H¨ulle zu einem Wert
Ï
(bzw.
) werden zu lassen.
22 Einleitung
1.8.2 Spezielle Definitionen
Definition 1.8-8 (Bester Zug)
Sei
Õ $úJE
,
FN
,
eine H¨ulle. Als einen besten Zug in
Õ
bezeichnen wir einen Zug
von der Wurzel zu einem Wurzelnachfolger, der denselben Wert hat wie die Wurzel. Sei
û
$H=
,
so ein Zug. Wir sagen
û
ist sicher mit Conspiracy Number
Ë
und der Tiefe
ü
, wenn es ein
®á
Ý!Ý
gibt, so daß es
a) wenigstens
Ë
blattdisjunkte Beweisstrategien in
Õ
gibt, deren Bl¨atter mindestens in
Tiefe
ü
liegen und beweisen, daß der Minimaxwert des besten Zuges gr¨oßer oder gleich
ist, und
b) f¨ur alle anderen Nachfolger der Wurzel gilt, daß es wenigstens
Ë
blattdisjunkte Be-
weisstrategien in
Õ
gibt, deren Bl¨atter mindestens in Tiefe
ü
liegen und beweisen, daß
der Minimaxwert des jeweiligen Wurzelnachfolgers h¨ochstens
ist.
Auf diese Weise ist sichergestellt, daß sich mindestens
Ë
Bl¨atter im Wert ¨andern m¨ussen,
damit sich die Entscheidung an der Wurzel ¨andert.
Definition 1.8-9 (Wert)
Sei
+$ýJE
,
FN
,
ein Spielbaum. Ein Wert ist ein Tupel
þ
$ý=ÿ
,
á <
’
’
,
’
’
,
’#’
ANK
Ý!Ý
0
Wir nennen
ÿ
das Attribut des Wertes
þ
und
den Zahlwert von
þ
.
$;<
’
’
,
’
’
,
’#’
A K
Ý!Ý
ist die Menge der m¨oglichen Werte. Wenn wir die Bindung
eines Wertes
þ
an einen Knoten
ausdr¨ucken m¨ochten, schreiben wir diesen als
þ
¡
$
ÿ
¡
,
¡
. Wenn
y
der i-te Nachfolger eines Knotens
ist und es zu keinen inhaltlichen
Verwechslungen kommen kann, erlauben wir uns statt
þ
¡
$=ÿ
¡
,
¡
abk¨urzend
þ
y
$
ÿ
y
,
y
zu schreiben.
Bemerkung: Sei
ein Knoten.
þ
¡
$Î
’
’
,
"
wird im folgenden ausdr¨ucken, daß es
einen Teilbaum (eine (Teil)-H¨ulle) unter
gibt, dessen Minimaxwert
ist.
þ
¡
$
’
’
,
"
wird analog benutzt.
þ
¡
$
’#’
,
"
impliziert, daß es eine Teilh¨ulle unter
gibt, deren Minimaxwert
¢
ist, und daß es eine Teilh¨ulle unter
gibt, deren Minimax-
wert
Ô
ist. Die beiden H¨ullen m¨ussen nicht dieselben sein.
Zwei Werte
þ
¡
und
þ
¡
(hochgestellte Zahlen sind hier Indizes) an ein und demselben
Knoten
k¨onnen in verschiedenen Relationen zueinander stehen. Uns interessieren in
erster Linie die Relationen ’widerspr¨uchlich’, ’unterst¨utzend’ und ’ungekl¨art’.
Definition 1.8-10 (widerspr¨uchlich, unterst¨utzend, ungekl¨
art)
þ
$ý=ÿ
,
ist widerspr¨uchlich zu
þ
$ýÿ
,
g.d.w. gilt:
1.8 Definitionen und Begriffe 23
(
ÿ
á <
’
’
,
’#’
A
und
ÿ
á <
’
’
,
’#’
A
und
),
oder
es ist (
ÿ
áÍ<
’
’
,
’#’
A
und
ÿ
áb<
’
’
,
’#’
A
und
).
þ
$ý=ÿ
,
unterst¨utzt
þ
$×ÿ
,
g.d.w. gilt:
(
ÿ
á <
’
’
,
’#’
A
und
ÿ
$
’
’ und
),
oder
es ist (
ÿ
á <
’
’
,
’#’
A
und
ÿ
$
’
’ und
),
oder
(
$
und
ÿ
$¢ÿ
$
’#’ ).
þ
$ý=ÿ
,
ist ungekl¨art zu
þ
$ ÿ
,
g.d.w. gilt:
þ
unterst¨utzt
þ
nicht, und
þ
widerspricht
þ
nicht.
Beispiele
So sind z.B.
þ
¡
$
’
’
,
und
þ
¡
$
’
’
,
an einem Knoten
widerspr¨uchlich, da
sie zwei Schranken repr¨asentieren, die innerhalb einer ausgewerteten H¨ulle nicht beide
gelten k¨onnen. (Trotzdem k¨onnen sie durchaus an ein und demselben Knoten beobachtet
werden, n¨amlich als Werte zweier unterschiedlicher H¨ullen.)
Ist
þ
¡
$Ö
’
’
,
, so widerspricht der Wert
þ
¡
$Ü
’
’
,
þ
¡
nicht. Er suggeriert zwar
eine genauere Schranke, unterst¨utzt aber im wesentlichen den Wert
þ
¡
.
Den Fall, daß z.B.
þ
¡
$¶
’
’
,
und
þ
¡
$·
’
’
,
sind, bezeichnen wir mit ’unge-
kl¨art’. Nehmen wir einmal an, die beiden Werte seien Auswertungen zweier verschiede-
ner H¨ullen. Dann wissen wir nicht, ob eine vollst¨andige Auswertung der ersten H¨ulle der
vollst¨andigen Auswertung der zweiten H¨ulle widerspricht oder ob eine Auswertung die
andere unterst¨utzen w¨urde.
Definition 1.8-11 (Target)
Ein Target ist ein Tupel
W%$×
,
Ó,
, wobei
ein Wert ist und
Ó,
á
sind.
Bemerkung: Targets beschreiben Anforderungen, die wir an Knoten stellen. Sei
W
¡
$
¡
,
¡
,
¡
ein Target, das zu einem Knoten
geh¨ort.
¡
dr¨uckt die geforderte Distanz
von Bl¨attern der endg¨ultigen H¨ulle zum Knoten
in der endg¨ultigen H¨ulle aus.
¡
ist die
Conspiracy Number von
W
¡
. Sie informiert dar¨uber, auf wieviele blattdisjunkte Beweis-
strategien sich das Ergebnis st¨utzen muß. Falls die Anforderungen an die sp¨atere H¨ulle,
die vom Target
W
¡
beschrieben werden, erf¨ullt worden sind, sprechen wir davon, daß das
Target
W
¡
erf¨
ullt wurde.
24 Einleitung
Kapitel 2
Das Cc2s-Verfahren
2.1 Beschreibung des Cc2s-Algorithmus
Bevor wir in diesem zentralen Kapitel dieser Arbeit den Cc2s-Algorithmus beschreiben
(vgl. auch [Lor00]), zeigen wir, daß die Begriffe ’Conspiracy Number’ und ’Blattdis-
junkte Strategien’ eng miteinander verwandt sind und als Synonyme verwendet werden
k¨onnen.
Es folgt eine Metabeschreibung der Cc2s-Suche, die die wichtigsten Ideen und die Vor-
gehensweise grob erkl¨art. Der Name Cc2s steht f¨ur eine Conspiracy Number Suche, bei
der wir einfordern, daß sich wenigstens ein beliebiges Blatt im Wert beliebig ¨andern darf,
ohne die Entscheidung an der Wurzel ver¨andern zu k¨onnen, also eine Suche mit Conspi-
racy Number 2. Das erste Beispiel l¨aßt sich dann bereits ohne formale genaue Kenntnis
des Vorgehens verstehen.
Wir beschrieben dann den Algorithmus detailliert in top-down Manier. Das Kapitel wird
abgerundet durch ¨
Uberlegungen zur Korrektheit des Verfahrens und durch Analysen des
Suchaufwands sowie durch ein weiteres Beispiel.
2.1.1 Conspiracy Numbers und blattdisjunkte Strategien
Satz 2.1-1
Es sei
Ö$OJE
,
FN
,
ein Spielbaum mit Wert
ë
(
ë
) an der Wurzel von
. Dann
sind ¨aquivalent:
1. Es gibt
blattdisjunkte Min- (Max-)Strategien, die belegen, daß der Wert an der
Wurzel
Ô
(
Ô
) ist.
2. Man muß die Werte von mindestens
Bl¨attern ¨andern, um den Wert der Wurzel zu
26 Das Cc2s-Verfahren
ê
(
) zu ¨andern.
Beweis :
a)
Û
b) Es seien
ö
,
01010
,
öjº
blattdisjunkte Strategien, die belegen, daß der Wert der
Wurzel von
×+
(bzw.
¢
) ist. ¨
Andert man nun
Blattwerte, so bleibt auf jeden
Fall eine Strategie
öêáb<öj0m010öj6A
¨ubrig, die belegt, daß der Wert der Wurzel von
ë
(bzw.
) ist.
b)
Û
a)
Wir beschreiben im folgenden eine ’Zerst¨orungsstrategie’, die mit der ¨
Anderung von
Blattwerten alle
blattdisjunkten Strategien zerst¨ort, die die entsprechende Schranke an
der Wurzel belegen.
Induktion ¨uber die Tiefe
W
des Spielbaums:
Sei
WÈ$
-
. Bei einem Spielbaum, der nur aus einem Knoten besteht, ist klar, daß es nur
eine Strategie gibt und daß man diese durch die Ver¨anderung eines Wertes zerst¨oren kann.
Die Induktionsvoraussetzung sei also: Unter der Annahme, daß
nur
B
blattdis-
junkte Strategien
ö"01010öj
(die
als obere (untere) Schranke belegen) enth¨alt, gen¨ugen
Blattwert¨anderungen, um den Wert der Wurzel
ê
(bzw.
) werden zu lassen.
Induktionsschluß:
W
.
*
Û W
Wir unterscheiden zwei F¨alle:
Wenn die Wurzel
R
von
ein ALL-Knoten ist und sich unter
R
genau
belegende Strate-
gien daf¨ur befinden, daß der Wert der Wurzel
Ô
(bzw.
Ô
) ist, befinden sich unter allen
Nachfolgern der Wurzel mindestens
viele solcher belegenden Strategien. Unter minde-
stens einem der Nachfolger befinden sich aber auch genau
viele belegende Strategien.
Einen dieser letztgenannten Nachfolger w¨ahlen wir aus, und mit der Induktionsvorausset-
zung folgt die Behauptung.
Wenn die Wurzel
R
von
ein CUT-Knoten ist und sich unter
R
genau
belegende Stra-
tegien daf¨ur befinden, daß der Wert der Wurzel
(bzw.
) ist, kann das nur daran
liegen, daß die Summe
y
y
(
ü
die Anzahl der Nachfolger von
R
,
y
die Anzahl der
belegenden Strategien des i-ten Nachfolgers
y
der Wurzel
R
) gleich
ist. Mit Hilfe der
Induktionsvoraussetzung sorgen wir daf¨ur, daß alle diese Nachfolger einen Wert
(bzw.
) bekommen. Damit wird auch der Wert der Wurzel
(bzw.
).
2.1 Beschreibung des Cc2s-Algorithmus 27
2.1.2 Metabeschreibung des neuen Vorgehens
Targets Wert + (NOT)−OK
((′≥′,0),δ,γ) ((′≤′,0),δ,γ)
((′≤′,0),δ,γ)
′≥′,0
′≤′,0
′≤′,0
′≥′,0
Abb. 2.1: Prinzipielles Verhalten
Abbildung 2.1 verdeutlicht den Datenfluß unseres Algorithmus. Im Gegensatz zum Mi-
nimax-Algorithmus oder dem
-Algorithmus sind wir nicht gezwungen, den Minimax-
wert der Wurzel zu bestimmen. Stattdessen versuchen wir, den besten Zug dadurch von
den anderen zu trennen, daß wir einen Spaltwert
bestimmen, von dem wir wissen, daß
der Wert des Nachfolgers, der zum besten Zug geh¨ort, mindestens
ist und die Werte der
anderen Wurzelnachfolger h¨ochstens
sind.
Ganz zu Anfang werden alle Wurzelnachfolger bewertet. Danach stellt der bis dato be-
suchte Spielbaum zu jedem Zeitpunkt einen Spaltwert
und einen besten Zug
û
zur
Verf¨ugung. Wie sicher dieser Zug ist, wissen wir allerdings nur zu bestimmten Zeitpunk-
ten. Solange wir nicht wissen, wie sicher
û
ist, betrachten wir
und
û
lediglich als
Hypothese. Wir beauftragen jeden Nachfolger der Wurzel, entweder seinen Teil der Hy-
pothese zu ’verifizieren’ oder zu zeigen, daß neue Bewertungen, die durch eine Erweite-
rung des Suchbaums zustande gekommen sind, die Hypothese ’falsifizieren’. Die Begriffe
’verifizieren’ und ’falsifizieren’ werden von uns auf eine weiche Art verwendet. Sie be-
ziehen sich immer auf den neuesten Stand des Wissens und nicht auf absolute Wahrheit.
Eine ’Verifikation’ ist also nicht mit dem Beweis vergleichbar, den ein
-Algorithmus
f¨ur eine Schranke des Wurzelwertes durchf¨uhrt. ’Verifikation’ bedeutet eher, Vertrauen in
einen Wert zu st¨arken. Die Verifikation wird mit Hilfe von Targets durchgef¨uhrt, die von
der Wurzel zu den Bl¨attern aufgeteilt und verteilt werden. Jeder Knoten
, der ein Target
bekommen hat, nimmt seinen eigenen Wert als richtig an, auch wenn unter
ein paar
Knoten dazugef¨ugt werden. Er bildet f¨ur seine Nachfolger Unterhypothesen und Teil-
targets in der Art, daß wenn die Nachfolger ihre Teiltargets erf¨ullen, auch
selber sein
28 Das Cc2s-Verfahren
Target erf¨ullt. Dann beauftragt
seine Nachfolger, die entsprechenden Unterhypothesen
zu untersuchen. Wenn ein Knoten
sein Target erf¨ullen konnte, sendet es ein OK an sei-
nen Vorg¨anger. Wenn das nicht m¨oglich war, hat sich der aktuelle Wert von
ge¨andert. In
diesem Fall meldet
den neuen Wert und ein NOT-OK an seinen Vorg¨anger.
2.1.3 Ein erstes Beispiel
7
6
6787
5 6 7 4 8 7
v.1 v.2
v.1.1 v.1.2 v.2.1 v.2.2
v.1.1.1
v.1.2.1 v.1.2.2 v.2.1.1 v.2.1.2 v.2.2.1 v.2.2.2
67 4 0
7
5
54
77
v.1.1.1.1 v.1.1.1.4
5 5 6 7
Sehr großer, aber endlicher Spielbaum
ε
Abb. 2.2: Beispiel-Spielbaum
Abb. 2.2 zeigt die obere Spitze eines Spielbaums, der im folgenden Grundlage unserer
Beispiele ist. Sei
die zu diesem Spielbaum geh¨orige heuristische Bewertungsfunktion.
Wir gehen im folgenden davon aus, daß wir eine Bewertungs-Prozedur zur Verf¨ugung
haben, die uns entweder die heuristische Zahl
#
als Funktionswert eines Knotens
zur¨uckliefert (das f¨uhrt z.B. bei Knoten
0»0
*
zu dem von uns so genannten ’Punktwert’
’#’
,
), oder die Frage beantwortet, ob
p=
kleiner oder gleich einer Schranke
ist. Im
letzteren Fall w¨are die Antwort unserer Bewertungs-Prozedur auf die Frage, ob der Wert
von
0»C0
*
kleiner oder gleich 5 ist somit
’
’
,
. Wir nennen so einen Wert im folgenden
auch einen ’Schrankenwert’.
An den inneren Knoten des Beispiel-Spielbaums befinden sich zwei Zahlen: Die innere
ist eine punktgenaue, direkte heuristische Bewertung
pÆ01010
.¨
Uber den Knoten befinden
sich die Minmaxwerte, die sich aus den heuristischen ’Werten’ (genauer: Zahlen; nicht zu
verwechseln mit unserer speziellen Definition von ’Wert’) der ’Bl¨atter’ ergeben. Bl¨atter
sind hierbei die Knoten
0
*
0
*
0
*
0
*
bis
0
*
0
*
0
*
0
,
0
*
05»0
*
,
0
*
05»05»
,
0»0
*
0
*
,
0»C0
*
05»
,
0»C0»0
*
und
05»0»C0»
. Unter den Knoten befinden sich die Namen der Knoten, zugewiesen nach
dem Dewey-Dezimal System.
2.1 Beschreibung des Cc2s-Algorithmus 29
Im folgenden sehr einfachen ersten Beispiel, in dem jede Erweiterung des Suchbaums
zu den gefaßten Hypothesen paßt, ist es die Aufgabe, einen besten Zug zu finden, der
sich auf eine H¨ulle st¨utzt, deren Bl¨atter eine Entfernung von zwei zur Wurzel haben. Die
Abbildungen 2.3-2.5 zeigen das inkrementelle Wachstum der Strategien.
v.1 v.2(’#’,4)
(’#’,5)
(’#’,5)
≤
’,5),1,1)((’
((’ ’,5),1,1)
≥
ε
Abb. 2.3: Ausgangssituation
Zun¨achst werden alle Nachfolger der Wurzel
R
mit einem Punktwert versehen, um ¨uber-
haupt eine Starthypothese zu bekommen. Da uns unsere heuristische Bewertung f¨ur die
Knoten
0
*
und
05»
Punktwerte geliefert haben soll, bekommen die Werte das Attribut
’#’. Das bedeutet ja z.B. f¨ur
0
*
nichts anderes, als daß es unter
0
*
eine H¨ulle gibt, die
einen Minimaxwert von
besitzt, und daß es eine (m¨oglicherweise andere) H¨ulle gibt,
deren Minimaxwert
ist. In diesem Fall bestehen beide H¨ullen nur aus
0
*
.
Bez¨uglich der durchgef¨uhrten Tiefe-1 Suche ist
0
*
der beste Wurzelnachfolger (d.h. der
mit dem h¨ochsten Wert). Deshalb bilden wir die Hypothese, daß er auch bei einer Tiefe-2
Suche der beste Zug bleiben wird. F¨ur
W
¡
bilden wir das Target
W
¡
$P6
’
’
,
,1*h,1*
,
und f¨ur
05»
bilden wir
W
¡
$×6
’
’
,
,m*h,1*
. (s. Abb. 2.3)
An
0
*
beginnen wir mit dem Verifikationsprozeß, da es der linke Nachfolger der Wurzel
ist. Es werden solange Nachfolger generiert, wie sie alle einen Wert
haben (denn um
das Target zu erf¨ullen, m¨ussen alle einen solchen Wert vorweisen).
v.1 v.2
v.1.1 v.1.2
(’#’,4)
≥’,5)(’
(’#’,5)
≥’,5)(’
(’#’,5)
≥
((’ ’,5),0,1)
≤
((’ ’,5),1,1)
≥
((’ ’,5),1,1)
≥
((’ ’,5),0,1)
ε
Abb. 2.4: Nach der Expansion des Knotens
Auch den Knoten
0
*
0
*
und
0
*
05»
werden Targets zugewiesen (Abb. 2.4). Der Algorithmus
30 Das Cc2s-Verfahren
untersucht diese Knoten der Reihe nach und gibt jeweils ein OK zur¨uck, da die Targets
trivialerweise erf¨ullt sind. (Es wurde n¨amlich gefordert, daß die Werte von
0
*
0
*
und
0
*
05»
sicher sind mit einer Resttiefe von 0 und einer Conspiracy Number von 1.) Danach gibt
auch
0
*
ein OK an die Wurzel zur¨uck.
Anschließend wird der erste Nachfolger von
05»
generiert, und es wird die Bewertung
angefragt, ob der Wert dieses neuen Nachfolgers
ist. Das ist der Fall (Abb. 2.5), und
so geben auch
05»0
*
an
0»
und
05»
an
R
jeweils OK zur¨uck. Wir wissen nun, daß der Zug
v
v.1 v.2
v.1.1 v.1.2
(’#’,4)
≥
’,5)(’
(’#’,5)
≥
’,5)(’
(’#’,5)
((’ ’,5),0,1)
≤
((’ ’,5),1,1)
(’ ’,5)
≤
v.2.1
≤
Abb. 2.5: Nach der Expansion des Knotens
l
von der Wurzel nach
0
*
sicher ist mit Tiefe 2 und Conspiracy Number 1. Die Werte der
inneren Knoten wurden nur gebraucht, um die Suche zu steuern.
Die Targets ben¨otigen wesentlich weniger Platz als die Conspiracy Number Vektoren der
konventionellen CNS. Dar¨uberhinaus erlauben sie einen effizienten Beschneidungsme-
chanismus, ¨ahnlich dem des
-Algorithmus. Wir k¨onnen zus¨atzlich ausnutzen, daß es
oft mehr Zeit kostet, einen punktgenauen heuristischen Wert auszurechnen, als einfach
nur in Erfahrung zu bringen, ob dieser Wert gr¨oßer oder kleiner einer vorgegeben Zahl
ist. Diese Eigenschaften erm¨oglichen es dem Cc2s-Algorithmus, auch f¨ur positionelle
Suchen eingesetzt zu werden, f¨ur die man eine feingranulare Bewertung braucht. Das
top-down Verteilen von Targets bietet eine hohe Flexibilit¨at und erlaubt es, nahezu belie-
bige Sicherheitskonzepte zu verwirklichen. Im folgenden pr¨asentieren wir eine hybride
Mischung aus Suchen mit fester Tiefe (das sind Suchen, bei denen alle Bl¨atter die gleiche
Entfernung zur Wurzel haben) und Conspiracy Number Suchen.
2.1.4 Algorithmische Details
Der Suchalgorithmus
Um den Suchalgorithmus ¨ubersichtlicher darstellen zu k¨onnen, haben wir ihn unterteilt.
Es gibt zum einen die Prozedur, die die Entscheidungsauswahl an der Wurzel des Spiel-
baums vornimmt, und die rekursive Prozedur Cc2s(
0m010
), die sich nicht mehr um die Aus-
2.1 Beschreibung des Cc2s-Algorithmus 31
wahl eines Zuges k¨ummern muß, sondern nur noch Schranken von Werten nachweist.
Diejenige Prozedur, die an der Wurzelstellung eine Entscheidung extrahiert und die den
Startpunkt unseres Algorithmus darstellt, nennen wir DetermineMove(root
R
, Resttiefe
ü
).
ü
steht dabei f¨ur die vom Benutzer geforderte Tiefe. Die geforderte Conspiracy Number
Ë
wird in der Prozedur DetermineMove(
01010
) in Zeile 5 festgelegt.
DetermineMove(root
!
pilk
oBdA sei
!
ein MAX-Knoten
kmi
), Resttiefe
"
)
1Erzeuge alle Nachfolger der Wurzelstellung
!
, i.e.
#
d
!
g
;
2
ilk
Seien
Y]]] Y3
die Nachfolger von
!
,
3
$
]]]
$
3
die Targets der Knoten
Y8]]] Y3
, und
4
%
]]]
%
3
die Werte, die zu den Knoten
Y]]] Y3
geh¨oren.
kmi
5
&
Ôo@`
('
;
ilk
)&
Ôo@`Ôq
f¨uhrt zu herk¨ommlichen Suchen fester Tiefe.
kmi
6for all
Yy
+* #
d
!
g
,%
yo@`
Evaluate(
Yy
\
-/.
\
0.
);
7
%
o@`rd
’#’
\
13254
v
76
uy
8
zn
*
vlq ]]] _BÓmg
08
8
ilk
Alle Nachfolger
Y1y
der Wurzel haben einen Wert
9der Form
%
y`rd
’#’
\
6
yg
.
kmi
10 do
v
11 tausche
Y
und
Y©
so, daß danach
6
{
96
y
\
;:
n
*
vlq ]]] _B
;
12
$
o@` dzd
’
{
’
\
6
g\
"-
q\
&
ßg
;
13 for all
n
*
v
<'
]]] _u
=$
yo@`rdzd
’
>
’
\
6
g\
"-
q\
&
ßg
;
14 for
no@`Ôq
to
? #
d
!
g
?
do
v
15
@
:= Cc2s(
Yy
\
$
y
);
16
%
:= UpdateValue(
!
);
17 if
@
= NOT OK break ;
18
ilk
Verlasse die for-Schleife und stelle neue Hypothesen auf!
kmi
19
20
while
@
ß`
NOT OK;
Abb. 2.6: Entscheidungsfindung auf oberster Ebene
Falls die Nachfolger der Wurzel noch nicht generiert worden sind, werden sie erzeugt
und mit Werten der Form
’#’
,
010102
versehen (Abb. 2.6, Z. 1-9). Es handelt sich dabei
um Punktwerte, die wie oben beschrieben von der Bewertungsfunktion geliefert wer-
den k¨onnen. Die Routine DetermineMove(
010m0
) stellt dann auf Grundlage des aktuellen
Spielbaums eine Hypothese ¨uber den besten Zug auf (Abb. 2.6, Z. 11-13). Das ist der
Zug, der den augenblicklich h¨ochsten Minimaxwert besitzt. Da der aktuelle Spielbaum
zumindest die Wurzel selber und alle ihre Nachfolger enth¨alt (zumindest nach Been-
digung der Zeile 7), ist dies immer m¨oglich. Der beste Nachfolger der Wurzel wird
mit dem Target
’
’
,
,
ü
.
*h,
Ëà
versehen und alle anderen Nachfolger mit Tar-
gets
6
’
’
,
,
ü
.
*h,
Ëà
. Dann wird die Prozedur Cc2s(
010m0
) beauftragt, die Verifika-
32 Das Cc2s-Verfahren
tion durchzuf¨uhren. DetermineMove(
01010
) wiederholt die beschriebenen Schritte, bis alle
Wurzelnachfolger mit OK geantwortet haben.
Seien
¬
=
die Nachfolger eines Knotens
, die im aktuellen Suchbaum vorhanden sind.
Sei
W
¡
das Target f¨ur
,
þ
¡
der Wert von
. Seien
"010106
BA
¥
¡
A
die Nachfolger von
,
bez¨uglich des aktuellen Suchbaums,
W2"01010>W
A
¥
´
¡
A
die Targets der Knoten
j010106
A
¥
¡
A
, und
þ
"01010
þ
A
¥
¡
A
ihre Werte.
Wir bezeichnen einen Knoten als OnTarget(
,
W
¡
), wenn der Wert von
nicht im Wi-
derspruch zu der Wertkomponente des Targets
W
¡
steht (vgl. Def. ’Wert’ und ’wider-
spr¨uchlich’, S.22). Dieses Attribut eines Knotens bringt zum Ausdruck, daß sich der Su-
cher noch auf dem richtigen Weg befindet. Wenn die Prozedur Cc2s(
01010
) (Abbildung
bool Cc2s(node
Y
, target
$
¡
` dzdxZ
¡
\[
¡
g\
DC
¡
\
FE
¡
g
)
1if (
C
¡
`ba
and
E
¡
>
êq
)or
? #
dfYhg
?
¹`ba
return OK;
2
@
:= NOT OK;
3while
@
= NOT OK do
v
4PartialExpansion(
Y\
$
¡
);
5if not OnTarget(
Y\
$
¡
)return NOT OK;
6Split(
Y\
$
¡
\Y
]]] Y
A
¥
¡
A
);
ilk
weist den Nachfolgern Targets zu
kmi
7for
no@`Ôq
to
? #
dfYhg
?
do
v
8
@
:= Cc2s(
Yy
\
$
y
);
9
%
¡
:= UpdateValue(
Y
);
10 if not OnTarget(
Y\
$
¡
)return NOT OK;
11 if
@
= NOT OK break ;
ilk
die for-Schleife verlassen, springe zu Z.3
kmi
12
13
ilk
while ...
kmi
;
14 return OK;
Abb. 2.7: Rekursive Suchprozedur
2.7) f¨ur einen Knoten
aufgerufen wird, ist garantiert, daß der Wert von
die Wert-
komponente des Targets
W
¡
unterst¨utzt (entweder durch DetermineMove(
01010
) oder wegen
Abbildung 2.7, Z. 4-6). Zu allererst wird kontrolliert, ob
ein Blatt ist, d.h., ob
W
¡
tri-
vial erf¨ullt ist (Z.1). Das ist der Fall, wenn die erforderliche Suchtiefe erreicht worden
ist (
¡
$
-
) und wenn die geforderte Anzahl blattdisjunkter Beweisstrategien Eins ist
(
¡
*
). Ein Knoten
ist auch dann ein Blatt, wenn
ein Blatt des Gesamtspielbaums
ist. Das zugrunde liegende Spiel l¨aßt dann eine Erweiterung des Knotens
nicht zu (z.B.
wegen eines Schachmatts).
Der Unteralgorithmus PartialExpansion(
0m010
) versucht, Nachfolger zu finden, die f¨ur die
sogenannte Split-Operation gut geeignet sind. Er bewertet von links nach rechts Nach-
2.1 Beschreibung des Cc2s-Algorithmus 33
folger von
, die entweder noch nie bewertet worden sind, oder von denen ’ungekl¨art’
ist, ob ihre Werte im Widerspruch zur Wertkomponente des Targets
W
¡
stehen (s. Def.
’Wert’, ’widerspr¨uchlich’ und ’ungekl¨art’, S.22). Wenn ein Knoten
ò
schon einmal be-
wertet worden ist und nun noch einmal bewertet wird, wird er mit einem Punktwert der
Form
’#’
,
÷
versehen. Es ist wichtig, daß ein ’#’ -Wert
þ
¡
nie ungekl¨art in Relation zu
der Wertkomponente eines ebenfalls zu
geh¨orenden Targets
W
¡
steht. Deshalb kann jeder
Knoten h¨ochstens zweimal bewertet werden!
F¨ur einen noch nie zuvor bewerteten Nachfolger
ò
von
wird angefragt, ob der Wert
von
ò
die Wertkomponente des Targets
W
¡
unterst¨utzt oder ihr widerspricht.
ò
bekommt
dann einen Wert
’
’
,
÷6
oder
’
’
,
÷
. Der Unteralgorithmus zur Teilexpansion geht
von links nach rechts vor und ruft nach jeder Bewertung auch f¨ur den Knoten
den
UpdateValue-Operator auf.
Falls
ein ALL-Knoten ist und eine Teilerweiterung des Suchbaums eine Ver¨anderung
des Wertes von
hervorbringt, so daß dieser neue Wert dem Target
W
¡
widerspricht, h¨ort
PartialExpansion(
01010
) sofort damit auf, Nachfolger von
zu bewerten und Cc2s(
01010
)
verl¨aßt
mit Hilfe von Zeile 5. Wenn
ein CUT-Knoten ist, bewertetPartialExpansion(
01010
)
solange Nachfolger von
, bis es
¡
-viele geeignete gefunden hat, auf die sich das Target
W
¡
verteilen l¨aßt, oder bis alle Nachfolger von
bewertet worden sind.
Anschließend wird das Target
W
¡
’gesplittet’, d.h., es werden Targets f¨ur die Nachfolger
von
erarbeitet (Zeile 6). Das Aufteilen von Targets wird von der Prozedur Split(
01010
) so
durchgef¨uhrt, daß das Target von
erf¨ullt sein wird, wenn die neu gebildeten Teiltargets
erf¨ullt werden. Split(
01010
) ben¨otigt die von der Prozedur PartialExpansion(
01010
) herausge-
suchten Kandidaten, auf die das Target
W
¡
aufgeteilt werden kann. In den n¨achsten Ab-
schnitten werden diese Routinen noch genauer untersucht.
Die neuen Targets werden den Nachfolgern von
zugewiesen, und Cc2s(
0m010
) untersucht
die Nachfolger von
, bis entweder alle Nachfolger ihre Targets erf¨ullt haben, oder bis der
Wert von
dem Target
W
¡
widerspricht, was bedeutet, daß
nicht mehr OnTarget(
01010
) ist
und damit Cc2s(
01010
) sich nicht mehr auf dem richtigen Weg befindet. Wenn ein Aufruf
von Cc2s(
01010
) mit dem Resultat OK vom Knoten
y
(Zeile 8) zu
zur¨uckkehrt, konn-
te
y
sein Target erf¨ullen. Kehrt Cc2s mit NOT-OK zur¨uck, haben sich Werte unterhalb
von
y
ver¨andert, so daß das Target von
y
nicht mehr erf¨ullbar erscheint. In diesem Fall
muß die Prozedur Cc2s(
01010
) entscheiden, ob
ein NOT-OK an seinen Vorg¨anger melden
muß (Z.10) oder ob am Knoten
umdisponiert werden kann und neue Teiltargets f¨ur die
Nachfolger von
gebildet werden k¨onnen (Z.11 und 13).
34 Das Cc2s-Verfahren
Wertbildung von unten nach oben
Ein wichtiger zu kl¨arender Punkt ist, was geschehen soll, wenn eine Erweiterung des
Suchbaums zu einem Widerspruch zwischen einem Wert
þ
¡
eines Knotens
und der
Wertkomponente eines zu
geh¨orenden Targets
W
¡
f¨uhrt. Die Aufgabe ist es dann, die
neue Information aufzunehmen und sicherzustellen, daß die Cc2s-Prozedur, die von die-
sen Werten gesteuert wird, nicht in eine Endlosschleife geschickt werden kann. Wir haben
den Operator in Abbildung 2.8 erarbeitet, der uns dabei entscheidend hilft.
value UpdateValue(node
Y
)
]]]
1
ilk
Sei
Y
ein MAX-Knoten
kmi
2if
#
dfYhg
HG
`
I#
dfYg
or
JLK *#
dfYg
with
2
h÷ `
’
{
’or
3
JLK *#
dfYg
with (
2
h÷ `
’
>
’ and
6
÷{
96
¡
)then
v
4if
2
¡
`
’
>
’and
JMK *#
dfYhg
with (
2
÷
*
v
’
{
’
\
’#’
and
6
÷
{
N6
¡
)
5then
2
¡
o@`
’#’ ;
6
6
¡
o@`
max
v
76
¡
\
max
v
76
÷
?<K *#
dfYg \
O2
?÷
*
v
’#’
\
’
{
’
Ó
P8
7
else
v
8if
2
¡
`
’
{
’or (
2
¡
`
’
>
’and
JMK *#
dfYhg
with (
2
h÷ `
’#’ and
6
÷{
96
¡
))
9then
2
¡
o@`
’#’ ;
10
6
¡
o@`
max
v
76
÷
?7K *#
dfYhg>
P8
ilk
Falls
Y
ein MIN-Knoten ist, ist das Ergebnis analog definiert.
kmi
ilk
Man tausche
>
mit
{
, und max mit min.
kmi
Abb. 2.8: Update von heuristischen Knotenwerten
Vereinfacht gesagt, macht UpdateValue(
0m010
) folgendes: Es nimmt sich die Werte der
Nachfolger eines Knotens
vor, bildet so weit wie m¨oglich Minimaxinformationen dar-
aus und reichert den entstandenen Wert mit den alten Informationen, dem alten Wert von
an.
Betrachten wir zwei Beispiele eines Widerspruchs und seiner Aufl¨osung: Sei
ein MAX-
Knoten mit dem Wert
’
’
,
. Der Wert soll dadurch zustande gekommen sein, daß alle
Nachfolger bewertet wurden und einen Wert
’
’
,
haben. Nun bewerten wir
mit
Hilfe unserer Bewertungsprozedur
direkt und erhalten einen Wert
, z.B.
’
’
,
Q
oder
’#’
,
Q
. So, wie wir den Cc2s-Algorithmus bisher beschrieben haben, kann der
Fall, daß die Bewertungsprozedur
’
’
,
Q
liefert zwar streng genommen nicht eintreten.
Trotzdem halten wir es f¨ur sinnvoll, auch solche F¨alle mit abzudecken. Dadurch ist es
zum einen m¨oglich, Beschleunigungsheuristiken wie in Abschnitt 2.3 einzusetzen. Zum
anderen kann es in der Praxis Sinn machen, eine heuristische Bewertung zu verwenden,
die bei mehrfacher Bewertung eines Knotens nicht unbedingt jedesmal den gleichen Wert
2.1 Beschreibung des Cc2s-Algorithmus 35
zur¨uckliefert. UpdateValue weist
den Wert
’#’
,
(Abb. 2.9) zu und l¨ost somit den
(’ ’,7)
≥
(’ ’,5)
≤
(’ ’,5)
≤
(’#’,5)
Abb. 2.9: Widerspruchsaufl¨osung (1)
Widerspruch auf (Abb. 2.8,Z.9,10). Um den Sinn dieser Operation zu verstehen, m¨ussen
wir uns in Erinnerung rufen, daß die Werte innerer Knoten lediglich zur Steuerung der
Cc2s-Routine dienen. Daß das Ergebnis an der Wurzel, der beste Zug, auch wirklich
vertrauensw¨urdig ist, wissen wir nur durch die Werte der Bl¨atter und durch den Target-
Mechanismus. Insofern ist ein innerer Wert ein heuristischer Helfer. Nun besagte der alte
Wert, daß es eine H¨ulle
ÕÐ
unterhalb von
gibt, die einen Minimaxwert von
hat.
Die direkte Bewertung besagt, daß es eine H¨ulle
Õ
gibt, deren Minimaxwert
Q
ist. Die
H¨ulle besteht nur aus
selber. Offenbar ist dann doch die H¨ulle
Õ
eine echte Teilh¨ulle
von
ÕM
. Wenn man davon ausgeht, daß mehr Suche zu besseren Ergebnissen f¨uhrt (und
alles andere w¨are absurd, da man dann jedwede Suche besser bleiben ließe), macht es hier
keinen Sinn, davon auszugehen, daß man ein Target mit einer Wertkomponente
’
’
,
erf¨ullen kann. Andererseits sagt die H¨ulle
ÕM
nichts ¨uber eine untere Schranke des Wertes
von
aus. Da es eine H¨ulle gibt, die eine untere Schranke von 5 plausibel erscheinen l¨aßt
(die H¨ulle
Õ
), ist der Knoten immer noch ein guter Kanditat, wenn es darum geht, ein
Target mit Wertkomponente
’
’
,
zu erf¨ullen.
Ein anderes Beispiel: Sei
ein MAX-Knoten mit dem Wert
’
’
,
und zwei Nachfol-
gern. Einer dieser Nachfolger habe den Wert
’
’
,
R
bekommen. Falls nun der zweite
Nachfolger einen Wert
’
’
,
Q
(Abb. 2.10c), oder
’
’
,
R
(Abb. 2.10d) zugewiesen
bekommt oder gar nicht bewertet worden ist (Abb. 2.10b), bleibt der Wert von
un-
ver¨andert (wegen Z.6). Wenn jedoch der zweite Nachfolger den Wert
’
’
,
R
bekommt
(Abb. 2.10a), wird der neue Wert von
mit Hilfe der Zeilen 9 und 10 ermittelt, und
bekommt den Wert
’#’
,
R
.
Andere UpdateValue Operationen sind intuitiv einfach nachzuvollziehen: Sei z.B. der
Wert eines MAX-Knotens
’
’
,
. Einer derNachfolger bringe aber einen Wert
’
’
,
ein. Dann bekommt auch
den Wert
’
’
,
.
Es gibt ein paar Eigenschaften der so erzeugten Werte, die die so gebildeten Werte zu
mehr als einer willk¨urlichen Heuristik machen und Korrektheits- und Terminierungsargu-
mentationen vereinfachen.
36 Das Cc2s-Verfahren
≤
S
(’ ’,3)
≥
T
(’ ’,5)
≥
T
(’ ’,3)
≥
T
(’ ’,5)
≥
T
(’ ’,5)
≤
S
(’ ’,3)
≥
T
(’ ’,5)
≤
S
(’ ’,7)
≥
T
(’ ’,5)
≤
S
(’ ’,3)
≥
T
(’ ’,5)
≥
T
(’ ’,5)
≤
S
(’ ’,3) ≤
S
(’ ’,3)
(’#’,3)
a) b)
c) d)
Abb. 2.10: Widerspruchsaufl¨osung (2)
Satz 2.1-2 (Eigenschaften des Update-Operators)
Wenn alle inneren Knotenwerte, von den Bl¨attern startend zur Wurzel hin, mit Hilfe von
UpdateValue gebildet werden, k¨onnen wir folgendes beweisen:
(a) Aus
þ
¡
$;
’
’
,
"
folgt, daß es eine H¨ulle unter
gibt, deren Minimaxwert
¢
ist,
(b) Aus
þ
¡
$ú
’
’
,
"
folgt, daß es eine H¨ulle unter
gibt, deren Minimaxwert
ist, und (c)
þ
¡
$O
’#’
,
"
impliziert, daß es eine H¨ulle unter
gibt, deren Wert
ë
ist,
und daß es eine (m¨oglicherweise ganz andere) H¨ulle unter
gibt, deren Wert
Ô
ist. Die
beiden H¨ullen sind nicht notwendigerweise identisch.
Dar¨uberhinaus gelten dann folgende wichtige Eigenschaften: (d) Sei
þ
X
die Wertkompo-
nente eines Targets
W
, die von
þ
¡
(einem Wert eines Knotens
) unterst¨utzt wird. Wenn
durch
W
zu einem ALL-Knoten wird, widerspricht kein Wert der Nachfolger von
dem
Wert
þ
X
. Wenn
durch
W
zu einem CUT-Knoten wird, gibt es einen Nachfolger von
,
dessen Wert dem Wert
þ
X
nicht widerspricht.
Mit Hilfe der ersten drei Eigenschaften ist es m¨oglich zu zeigen, daß Ergebnisse des
Cc2s-Algorithmus letztendlich immer auf H¨ullen und deren Minimaxwerten basieren.
Aufgrund der letzten beiden Eigenschaften wird folgendes gesichert: Wenn die Prozedur
Cc2s(
01010
) einen Knoten
besucht, gibt es entweder noch Nachfolger von
, von denen
nicht gekl¨art ist, ob sie dazu beitragen k¨onnen (dann werden solche Nachfolger bewertet;
Abb. 2.7,Z.4),
W
¡
auf die Nachfolger von
zu verteilen, oder die Prozedur Split(
01010
) (Abb.
2.7,Z.6) kann das Target
W
¡
, wie im n¨achsten Abschnitt beschrieben, auf die Nachfolger
von
aufteilen. Es kann nicht passieren, daß die Prozedur Cc2s(
01010
) aufgrund von Zei-
2.1 Beschreibung des Cc2s-Algorithmus 37
le 5 verlassen wird, ohne daß vorher ein Knoten bewertet wurde. Damit ist es m¨oglich
zu zeigen, daß der Cc2s-Algorithmus nicht in eine Endlosschleife laufen kann, ohne den
Suchbaum zu ver¨andern.
Die Form einer H¨ulle und die Handhabung von Sicherheit
Um an einem MAX-Knoten
eine untere Schranke f¨ur seinen Wert zu bestimmen (bzw.
um eine obere Schranke an einem MIN-Knoten zu zeigen) braucht man lediglich einen
Nachfolger von
zu finden, dessen Wert die Schranke einh¨alt. So einen Knoten nennen
wir einen CUT-Knoten (engl. cutnode). Wenn man eine obere Schranke an einem MAX-
Knoten
beweisen m¨ochte, m¨ussen alle Nachfolger von
diese Schranke einhalten und
einen Minimaxwert haben, der h¨ochstens so groß ist wie der von
. Deshalb nennen wir
so einen Knoten ALL-Knoten. Die Targets bestimmen, ob ein Knoten als ALL-Knoten
oder als CUT-knoten zu betrachten ist (Abb. 2.11).
bool Allnode(node
Y
, target
$
¡
`rdzdxZ
¡
\[
¡
g\
DC
¡
\
FE
¡
))
if
Y
ist ein MAX-Knoten and
Z
¡
`
’
>
’then return true;
else if
Y
ist ein MIN-Knoten and
Z
¡
`
’
{
’then return true;
else return false;
bool Cutnode(node
Y
, target
$
¡
`rdzdxZ
¡
\[
¡
g\
DC
¡
\
FE
¡
))
return
U
Allnode(
Y\
$
¡
);
Abb. 2.11: ALL- und CUT-Knoten
Wenn z.B.
ein MAX-Knoten ist und das Target einen Wert der Form
’
’
,
"
fordert,
wird
zu einem CUT-Knoten.
v.1.1.1
v.1.1 ((’≤
V
((’≤
V
ALL−Knoten: CUT−Knoten
gegeben:
((’≤
V
’,7),0,2)’,7),0,2)
’,7),1,2)
((’≤’,7),0,2)
gegeben:
((’≤((’≤
’,7),0,1) ’,7),0,1)
’,7)
≤
(’
’,7)
≤
(’ ’,7)
≤
(’
(’#’,6)
(’#’,5)
(’#’,6)
(’#’,5)
neue Teiltargets
neue Teiltargets
Abb. 2.12: Aufteilung von Targets an CUT- bzw. ALL-Knoten
Wenn
ein Knoten mit Target
W
¡
ist, definieren wir Teiltargets f¨ur die Nachfolger von
mit Hilfe folgender Beobachtung: ObdA sei
ein MAX-Knoten. Sei
eine geforderte
38 Das Cc2s-Verfahren
obere Schranke des Minimaxwertes von
bez¨uglich einer H¨ulle, die durch
W
¡
n¨aher be-
schrieben wird. Dann muß
eine obere Schranke f¨ur die Minimaxwerte aller Nachfolger
y
,
W
áI<
*
01010V
¡
A
von
sein. Falls es
Ë
blattdisjunkte Strategien unter jedem einzelnen
Sohn von
gibt, die die Schranke
beweisen, so gibt es auch
Ë
blattdisjunkte Beweis-
strategien f¨ur den Minimaxwert
bei
. Allgemein gilt: Wenn
Ë
y
die Anzahl blattdisjunk-
ter Beweisstrategien unter den Knoten
y
(f¨ur alle Nachfolger
y
von
) ist, dann ist die
Anzahl blattdisjunkter Beweisstrategien (die alle die Schranke
zeigen) unter
gleich
min
3
X
y
Y
Ë
y
.
Jetzt betrachten wir einen MAX-Knoten
, f¨ur dessen Minimaxwert
eine untere Schran-
ke ist. Sei
die Anzahl derjenigen Nachfolger von
, die ebenfalls einen Minimaxwert
haben. (Wegen der Minimaxregel gibt es mindestens einen solchen Nachfolger.) Sei
Ë
y
,
W
áÍ<
*
0m0106ÓA
die Anzahl der blattdisjunkten Beweisstrategien unter
y
, die die Schran-
ke
am Knoten
y
beweisen. Dann ist die Anzahl der Beweisstrategien unter dem Knoten
, die die Schranke
am Knoten
beweisen, gleich der Summe
y
Y
Ë
y
.
Split(node
Y
, target
$
`ÔdzdxZ \[jg \
DC
B\
FE
g
, nodes
Y]]] Y
A
¥
¡
A
ilk
Nachfolger von
Ykmi
)
1if Cutnode(
Y\
$
)then
v
2
ilk
Seien
%
`rd
2
CB\
6
g]]]
%
A
¥
¡
A
`rd
2
A
¥
¡
A
\
6
A
¥
¡
A
g
die Werte der
3Knoten
Y]]] Y
A
¥
¡
A
. Wenn diese Zeile erreicht wird, gibt es mindestens
4einen Index
n
mit
6
y{ù[
und
2
y
Z*
v
’
{
’
\
’#’
, falls
Y
ein MAX-Knoten ist,
5bzw. ein
n
mit
6
y
>
}[
und
2
y
[*
v
’
>
’
\
’#’
, falls
Y
ein MIN-Knoten ist.
6Falls es noch einen weiteren solchen Index gibt, sei
\
der kleinste dieser
7Indizes mit
\]G
` n
. Andernfalls setzen wir
\
No@`
-
q
.
kmi
8if
\
`
-
q
or
E>
êq
then
v
9
$
yo@`rdzdxZ \[jg \
DC^-
q\
FE
g
08
ilk
=$
y
sei das Target von
Yy
.
kmi
10
$
©o@`rdzdxZ \[jg \a\alg
:`_
*
vlq ]]]
? #
dfYg
?
with
n
aG
`
_
;
11
else
v
12
$
yo@`
b$Fc
Uo@`rdzdxZ \[~g \
DCH-
q\qug
08
13
$
©
o@`rdzdxZ \[jg \a\alg
:`_
mit
n
dG
`
_
und
\eG
`
_
;
14
15
else
$
yo@`rdzdxZ \[~g \
DCH-
q\
FE
g
:
n
*
vlq ]]] _u
16
ilk
=$
y
sei dabei das Target des Knotens
Yykmi
Abb. 2.13: Die Splitprozedur
Schließlich gilt noch, daß es unter
genau dann eine Strategie gibt, die eine Schranke
beweist und deren Bl¨atter eine Entfernung von
ü
zu
haben, wenn es entsprechende
Strategien unterhalb der Nachfolger von
gibt, deren Bl¨atter eine Entfernung von
ü
.
*
zu den Nachfolgern von
haben.
2.1 Beschreibung des Cc2s-Algorithmus 39
Wenn unser Algorithmus einen Knoten
mit Target
W
besucht, wird zun¨achst entschieden,
ob
als CUT-Knoten oder als ALL-Knoten angesehen werden muß. Dann erzeugt er
Teiltargets f¨ur die Nachfolger von
in der Art, daß das Target von
erf¨ullt ist, wenn alle
Teiltargets aller Nachfolger von
erf¨ullt sind (Abb. 2.13).
Wenn ein Target an einem CUT-Knoten mehr als eine blattdisjunkte Beweisstrategie for-
dert, versuchen wir diese Aufgabe auf zwei geeignete Nachfolger zu verteilen (Abb. 2.13,
Z. 12). Cc2s(
010m0
) verwaltet Sicherheitsinformationen allein durch die Targets, die top-
down im Suchbaum verteilt werden.
Mit Hilfe der hier vorgestellten Prozedur Split(
01010
) kann die Prozedur Cc2s(
01010
) (s. Abb.
2.7) sicher sein, daß ein Knoten
selber sein Target erf¨ullt hat, wenn alle Nachfolger von
ihre Teiltargets erf¨ullt haben.
Anstatt in den Zeilen 12 und 13 (Abb. 2.13) die Anforderung von zwei blattdisjunkten
Strategien auf den i-ten und k-ten Nachfolger aufzuteilen, kann man nat¨urlich auch leicht
h¨ohere Conspiracy Numbers aufteilen, auch auf m¨oglicherweise mehr als zwei st¨utzende
Nachfolger von
.
Expansionen und Bewertungen
Zu einer vollst¨andigen Beschreibung unseres neuen Algorithmus fehlen noch die Be-
schreibungen der Prozeduren PartialExpansion(
01010
), Evaluate(
0m010
) und OnTarget(
01010
).
Eine Teilerweiterung des Spielbaums (PartialExpansion) ist die Erzeugung und Bewer-
tung eines einzelnen Knotens.
Wenn
ein CUT-Knoten sein soll (aufgrund des Wertes
þ
¡
und des Targets
W
¡
), muß
wegen der Definition einer Beweisstrategie mindestens ein Nachfolger den Wert von
st¨utzen. Wenn also PartialExpansion(
01010
) bereits
¡
-viele solcher Nachfolger gefunden
hat, werden keine weiteren Knoten unter
erzeugt und bewertet (Abb. 2.14, Z. 24). Wenn
scheinbar keiner der neu erzeugten Nachfolger von
dabei helfen kann, das Target
W
¡
zu
erf¨ullen, ¨andert sich der Wert von
(Z. 23). Um in diesem Fall einen m¨oglichst genauen
Eindruck davon zu erhalten, wo der Wert von
anzusiedeln ist, werden die Nachfolger
von
mit exakten Werten versehen und gegebenenfalls noch einmal bewertet (Z. 27-31).
Zum einen f¨uhrt dieses Vorgehen zu genauerem Wissen ¨uber heuristische Werte an Kno-
ten, an denen Bewertungen zu unvorhergesehenen Ver¨anderungen innerhalb des Such-
baums gef¨uhrt haben, zum anderen vereinfacht es die Analyse des Cc2s-Algorithmus.
Wenn
ein ALL-Knoten ist, m¨ussen alle Nachfolger den Wert von
st¨utzen. Wenn es
dazu kommt, daß ein Wert eines neu generierten Nachfolgers dem Wert
þ
¡
von
wi-
derspricht, werden keine weiteren Nachfolger unterhalb von
erzeugt oder bewertet (Z.
11-14).
40 Das Cc2s-Verfahren
PartialExpansion(node
Y
, target
$
¡
`rdzdxZ
¡
\[
¡
g\
DC
¡
\
FE
¡
g
)
1
ilk
Seien
Y
]]] Y3
die Nachfolger von
Y
2
%
]]]
%
3
die Werte der Knoten
Y]]] Y3kmi
3if Allnode(
Y\
$
¡
)then
v
4for
npo@`Ôq
to
_
do
v
5if
Yy
G
*#
dfYg
then
#
dfYhg9o@`
I#
dfYhg
,f
MvBY y
;
6if ExaminationUseful(
Yy
\
$
¡
)then
v
7if
Y1y
ist noch nie bewertet worden then
v
if
Y
ist MAX-Knoten then
%
9y
:= Evaluate(
Ymy \[
¡
\[
¡
hg
q
);
else
%
y
:= Evaluate(
Yy
\[
¡
-
q\[
¡
);
8
else
%
y
:= Evaluate(
Yy
\
-/.
\
0.
);
9
10
%
¡
:= UpdateValue(
Y
);
11 if not OnTarget(
Y\
$
¡
)then
v
12 if
2
y
=G
`
’#’ then
%
9y
:= Evaluate(
Y\
-/.
b\
0.
);
13
%
¡
:= UpdateValue(
Y
);
14 return ;
15
16
%ilk
for
]]] kmi
17
else
ilk
Cutnode(
Y\
$
¡
)
kmilv
18 for
npo@`Ôq
to
_
do
v
19 if
Yy
G
*#
dfYg
then
#
dfYhg9o@`
I#
dfYhg
,f
MvBY y
;
20 if ExaminationUseful(
Yy
\
$
¡
)then
v
21 if
Yy
ist noch nie bewertet worden then
v
if
Y
ist MIN-Knoten then
%
y
:= Evaluate(
Yy
\[
¡
\[
¡
g
q
);
else
%
y
:= Evaluate(
Yy
\[
¡
-
q\[
¡
);
22
else
%
9y
:= Evaluate(
Y1y \
-/.
\
0.
);
23
%
¡
:= UpdateValue(
Y
);
24 if (die Anzahl der Nachfolger
Y
ic
von
Y
mit OnTarget(
Y
jc
\
$
¡
) und nicht
25 ExaminationUseful(
Y
jc
\
$
¡
))
kE
¡
then return
26
%ilk
for
]]] kmi
27 if not OnTarget(
Y\
$
¡
)then
28 for all
Y1y
*#
dfYhg
l
)`
(#
dfYhg
nm
do
v
29 if
2
y
=G
`
’#’ then
%
9y
:= Evaluate(
Y1y \
-/.
\
0.
);
30
%
y
:= UpdateValue(
Yy
);
31
Abb. 2.14: Teil-Expansion
2.1 Beschreibung des Cc2s-Algorithmus 41
Bemerkung: Man beachte noch einmal, daß wir eine Unterscheidung zwischen billigen
Schrankenbewertungen und teuren Punktbewertungen machen. Wenn ein Knoten zum
ersten Mal bewertet wird, sind die Bewertungskosten niedrig. Die vorzugebende Schranke
f¨ur diese Bewertung l¨aßt sich vom Target des Vaterknotens herleiten. Wenn ein Knoten
vorher schon einmal bewertet wurde, wird er mit einer teuren Bewertung noch einmal
bewertet. Knoten, die einen Punktwert besitzen, werden nie wieder bewertet.
bool ExaminationUseful(node
oqpsrut5vxwzy7v|{
, target
}Op~rruwZ{0wD7wF{
)
if
o
ist noch nie bewertet worden then return true;
else
if
tv
’
’
w
’#’
and
yvN
and
]p
’
’then return false;
if
txv
’
’
w
’#’
and
y7vN
and
]p
’
’then return false;
x
o
kann sicher ein Target bekommen.
|
if not OnTarget(
oBw}
)then return false;
x
o
scheint nicht f¨ur ein Teiltarget von
}
geeignet.
|
return true;
x
Man kann nicht sagen, ob
o
ein Kandidat f¨ur ein Target ist
|
Abb. 2.15: Soll man
bewerten?
Die Prozedur ExaminationUseful(
|i
) informiert PartialExpansion dar¨uber, ob ein Kno-
ten bewertet werden sollte oder ob schon gen¨ugend Informationen ¨uber den Knoten vor-
liegen. PartialExpansion(
ii
) braucht nur diejenigen Knoten zu bewerten, bei denen der
Wert weder dem Target des Vorg¨angers widerspricht noch ihn unterst¨utzt. Die Nach-
folger mit solch ungekl¨artem Zustand aufzusp¨uren, ist die Aufgabe von der Prozedur
ExaminationUseful(
ii
).
value Evaluate(node
o
, int
Z
, int
[
)
y7v
= EvaluatePosition(
oBwz+w[
)
x
F¨uhre eine konventionelle Bewertung aus,
|
if
yv^9
then
txvp
’
’
else if
y7v^9
then
txv^p
’
’
else
t5vp
’#’ ;
return
rut5vxwzyvi{
;
x
und transferiere das Ergebnis in einen Wert
hv/psrut5vPwzy7vi{
.
|
Abb. 2.16: Bewertung eines Knotens
Die Bewertungsprozedur Evaluate(
ii
) nutzt zun¨achst eine konventionelle Bewertungs-
funktion, die eine Zahl
liefert. Ein Fenster [
,
] bestimmt, innerhalb welchen Inter-
42 Das Cc2s-Verfahren
valls der genaue Zahlwert von
interessant ist. Abh¨angig von
,
und
wird ein Wert
gebildet.
bool OnTarget(node
o
, target
}v
)
x
let
}vpsrru vw v{0wD vwF v{
sei das Target und
hvHpsrutxvxwzyv|{
der Wert des Knotens
o
.
|
if
vHp
’
’and
Bv9y7v
and
txv
’#’
w
’
’
return false;
else if
[v/p
’
’and
Lvyv
and
t5v
’#’
w
’
’
return false;
else return true;
Abb. 2.17: OnTarget
Wenn die Prozedur Cc2s(
ii
) beginnt, einen Knoten
zu untersuchen, ist immer ein Tar-
get
v
mit diesem Knoten assoziiert. Ein Target stellt eine Anforderung an einen Knoten
dar, die etwas mit dem Wert des Knotens
zu tun hat. Wenn z.B. der Wert von
’#’
¡
"
ist und das Target einen Wert
¢ ¡
fordert, passen Anforderung und Wirklichkeit zu-
sammen. Wir gehen dann optimistisch davon aus, daß eine Erweiterung des Suchbaums
unterhalb von
die Sicherheit erh¨ohen wird, mit der der Wert von
£¢¤¡
ist. Wir ge-
hen außerdem davon aus, daß es sinnvoll ist, unter
weitere Knoten zu erzeugen, und
daß deshalb unser Algorithmus auf dem richtigen Wege (engl. on target) ist, wenn er
untersucht.
Wenn aber der Wert von
in diesem Beispiel
’
¥
’
0¡§¦©¨
Ó
ist oder wird, sehen wir wenig
Chancen, daß das Target
v
erf¨ullt werden kann. In diesem Fall steht n¨amlich der Wert
von
im Widerspruch zu der Wertkomponente von
v
, und Cc2s orientiert sich um.
2.1 Beschreibung des Cc2s-Algorithmus 43
2.1.5 Komplexes Beispiel
Ausgangspunkt der folgenden Beispiele ist wiederum die Spitze des Spielbaums aus Ab-
bildung 2.2.
Erste Hypothese
Wir starten damit, daß uns der Algorithmus eine Entscheidung liefern soll, die auf Strate-
gien beruht, deren Bl¨atter mindestens in Tiefe drei liegen (Conspiracy Number
Ë
ǻ¬
). In
der DetermineMove Prozedur werden die Knoten
¨
und
,¯®
erzeugt und mit einem Fen-
ster (
°²±³±
) bewertet. Daraufhin h¨alt der Algorithmus den Zug
´,,µ¨
¹
f¨ur den besten,
da
¶v·¹¸ ªº
’#’
»
h
und
¶v·¹¸ ª¬
’#’
¼
ist. (Genau, wie in Abschnitt 2.1.3).
Aufbau von H¨ulle und Strategien unter
,¨
In der Prozedur DetermineMove wird
¨
das Target
0
’
¥
’
»
?
7®½|¨
¹
und
,¯®
das Target
’
¢
’
»
h
7®Bi¨
¹
zugewiesen. Cc2s(
ii
) wird mit dem Knoten
,¨
aufgerufen. Dort wird
erstmal nach geeigneten Nachfolgern Ausschau gehalten. In PartialExpansion(
ii
) wer-
den die Knoten
,¨¾µ¨
und
,µ¨®
erzeugt und bewertet. Beide Nachfolger bekommen den
Wert
¶v·¹¸·¹¸ ª ¶ v·¹¸· ¿ ª
’
¥
’
»
h
. Die Knoten
,µ¨µ¨
und
¨¾¯®
bekommen die Targets
’
¥
’
»
?
7i¨¾|¨
¹
. Es folgt ein Aufruf von Cc2s(
i|
) mit dem Knoten
,µ¨µ¨
. Mit Hilfe von
PartialExpansion(
ii
) wird der Knoten
,¨¾µ¨µ¨
aufgedeckt. Er erh¨alt ebenfalls den Wert
’
¥
’
»
?
. Nach dem Cc2s(
ii
)-Aufruf mit diesem Knoten, der sofort mit OK zur¨uckkehrt,
kehrt Cc2s(
i|
) auch beim Knoten
¨¾¨
mit OK zu seinem Vorg¨anger zur¨uck. Die Kno-
ten
,µ¨®
,
,µ¨®½¨
und
¨®½¯®
werden analog den Knoten
,µ¨¾¨
,
,µ¨¾¨¾¨
und
¨µ¨¾¯®
erzeugt
und bewertet. Damit ergibt sich folgender Suchbaum, nachdem Cc2s(
i|
) auch f¨ur den
Knoten
,¨
beendet worden ist:
v
v.1 v.2
v.1.1 v.1.2
v.1.1.1 v.1.2.1
(’#’,4)
≥’,5)(’
(’#’,5)
≥’,5)(’
≥’,5)(’
≥
À
’,5)(’
(’#’,5)
(’≤
Á
’,5,2)
Abb. 2.18: Schnappschuß vom Suchbaum (1)
44 Das Cc2s-Verfahren
Fehlhypothesen beim Aufbau von H¨ulle und Strategien unter
,¯®
Der linke Teilbaum ist abgearbeitet, Knoten
,®
muß noch das Target
’
¢
’
»
h
®½i¨
Ó
erf¨ullen. Cc2s(
ii
) wird nun also mit dem Knoten
,¯®
und dem Target
’
¢
’
»
h
®½i¨
Ó
aufgerufen.
,¯®
ist ein CUT-Knoten, und es gen¨ugt, einen Nachfolger zu finden, dessen
Minimaxwert kleiner oder gleich 5 ist. Deshalb wird zun¨achst der Knoten
,¯®½¨
erzeugt
und bewertet. Er erh¨alt den Wert
’
¢
’
»
h
. Der Algorithmus verzweigt zu
,¯®½¨
. Von
dort aus wird der Knoten
,®½¨¾¨
erzeugt und bewertet. Da dieser einen Wert gr¨oßer oder
gleich 5 anzeigt, wird
,®Bµ¨¾¨
in PartialExpansion(
|i
) sofort nochmal genauer bewertet.
Der Knoten erh¨alt den Wert
’#’
Â
. Dann wird am Knoten
,®½¨
UpdateValue(
|i
) auf-
gerufen.
,®½¨
hat den Wert
’
¢
’
»
?
, aber ein Sohn hat einen gr¨oßeren Wert. Der Wert
¶v· ¿·¹¸
wird zu
’#’
Â
gesetzt. Der Knoten
,¯®½µ¨
kann sein Target scheinbar nicht mehr
erf¨ullen, deshalb kehrt Cc2s(
ii
) mit NOT OK zu
,®
zur¨uck. An
¯®
wird der n¨achste
Sohn voruntersucht. Er sieht ebenfalls vielversprechend aus.
,®½¯®
bekommt ein Target
’
¢
’
»
h
7|¨¾i¨
¹
, und Cc2s(
ii
) verzweigt zu
,®½¯®
. Auch hier wird zun¨achst der Sohn
,®B®½¨
erzeugt und bewertet. Er wird im zweiten Anlauf mit
’#’
Ã
h
bewertet. Cc2s(
i|
)
ruft UpdateValue(
ii
) mit dem Knoten
,¯®½¯®
auf, und
,®½¯®
bekommt den Wert
’#’
Ã
h
.
Cc2s(
ii
) springt zu
,¯®
und stellt fest, daß auch Knoten
¯®½¯®
mit NOT OK zur¨uckge-
kehrt ist und daß
,®
kein vielversprechender Kandidat mehr ist, sein Target zu erf¨ullen.
UpdateValue(
|i
) liefert f¨ur den Knoten
,¯®
den Wert
’#’
Ã
?
, im Anschluß bekommt
auch die Wurzel den Wert
’#’
Ã
h
. Die Prozedur DetermineMove(
|i
) konnte also den
Zug
n,,¨
¹
nicht als den besten nachweisen, sondern es sieht so aus, als sei der andere
Zug der bessere. Es stellt sich folgende Situation dar:
v
v.1 v.2
v.1.1 v.1.2
v.1.1.1 v.1.2.1
≥’,5)(’
(’#’,5)
≥’,5)(’
≥’,5)(’
≥
Ä
’,5)(’
v.2.1.1 v.2.2.1
v.2.1 v.2.2
(’#’,7)
(’#’,7)
(’#’,7)
(’#’,7)
(’#’,8)
(’#’,8)
Abb. 2.19: Schnappschuß vom Suchbaum (2)
Neue Orientierung
Die Prozedur DetermineMove(
ii
) gibt nun an
,¯®
das Target
’
¥
’
Ã
?
7®½|¨
¹
und an
,µ¨
das Target
’
¢
’
Ã
h
®½i¨
¹
.
,®
wird zuerst bearbeitet. Im folgenden bekommen
½®½¨
,
2.1 Beschreibung des Cc2s-Algorithmus 45
½®½®
,
Å®Bµ¨¾¨
und
½®½¯®½¨
die Targets
’
¥
’
Ã
h
i¨¾i¨
Ó
,
0
’
¥
’
Ã
h
7i¨i¨
¹
,
’
¥
’
Ã
h
7ÆÅÆ
und
’
¥
’
Ã
?
7ÆÅÆ
, die alle erf¨ullt werden. Cc2s(
ii
) bearbeite also wieder den Knoten
,¨
,
dem immer noch das Target
v·¹¸ ª
’
¢
’
Ã
h
®½i¨
¹
zugeordnet ist. Es werden offenbar
Nachfolger von
,¨
ben¨otigt, die helfen k¨onnen,
0
’
¢
’
Ã
?
7i¨¾|¨
¹
zu erf¨ullen. Es bieten
sich
¨¾¨
und
,µ¨®
an. Von beiden weiß man nur, daß es Teilb¨aume unter ihnen gibt mit
Minimaxwerten gr¨oßer oder gleich 5. PartialExpansion(
i|
) wird bem¨uht,
,µ¨µ¨
nochmals
genauer zu bewerten. Da
,¨¾¨
schon mal bewertet wurde, wird eine teure Bewertung be-
nutzt, die sicherstellt, daß
v·¹¸·¹¸
das Attribut ’#’ bekommt und danach nie wieder bewer-
tet werden wird. Nach einem weiteren Aufruf von UpdateValue(
ii
) f¨ur
,µ¨¾¨
hat dieser
Knoten den Wert
’#’
Ç
. Damit wurde ein Sohn gefunden, der geeignet erscheint, das
Target
v·¹¸·¹¸ ªÈ
’
¢
’
Ã
?
7i¨¾|¨
¹
zu erf¨ullen. Cc2s(
|i
) springt zu
,µ¨µ¨
. Beide Nachfolger
m¨ussen einen Zahlwert
¢ÉÃ
haben, damit
v·¹¸·¹¸
erf¨ullt wird. PartialExpansion(
i|
) sorgt
im Zusammenspiel mit Evaluate(
ii
) daf¨ur, daß
,µ¨¾¨¾¨
den Wert
’#’
»
h
und
,µ¨µ¨¾¯®
den
Wert
’
¢
’
Ã
h
bekommen. Cc2s(
ii
) wandert noch einmal zur Wurzel hoch, immer mit
der R¨uckgabe OK. Die Routine DetermineMove(
ii
) bekommt best¨atigt, daß es unter
,¨
eine Strategie gibt, deren Bl¨atter in Tiefe 3 liegen, und deren Minimaxwert
¢ÊÃ
ist. Damit
ist der Zug
´,,®
h
der Beste. Der endg¨ultige Suchbaum sieht folgendermaßen aus:
v
v.1 v.2
v.1.1 v.1.2
v.1.1.1 v.1.1.2 v.1.2.1
≥
Ä
’,5)(’
(’#’,5)
≥
Ä
’,5)(’
v.2.1.1 v.2.2.1
v.2.1 v.2.2
(’#’,7)
(’#’,7)
(’#’,7)
(’#’,7)
(’#’,8)
(’#’,8)
(’
(’#’,5) ≤
Ë
(’#’,6)
’,7)
Abb. 2.20: Endg¨ultiger Suchbaum
Blattdisjunkte Strategien
Bisher haben wir unser neues Verfahren nur aufH¨ullen mit konstanter Tiefe
angewendet.
Wir m¨ochten nun aber auch nicht rein tiefenorientierte Strategien betrachten, sondern wir
fordern zus¨atzlich eine weitere, die Entscheidung unterst¨utzende Strategie, die im Such-
baum enthalten sein sollen.
Wir starten bei der Wurzel des Suchbaums von Abbildung 2.18.
,µ¨
bekommt das Target
v·¹¸ ª
’
¢
’
Ã
h
®½®
?
,
,¯®
bekommt
v· ¿ ª 0
’
¥
’
Ã
h
7®B®
h
. Da
¯®
den h¨oheren Wert
hat, wird dort zuerst gearbeitet. Die Prozedur Cc2s(
ii
) l¨auft zu
,®Bµ¨
, und dort stellt
46 Das Cc2s-Verfahren
die Prozedur PartialExpansion(
ii
) fest, daß ein weiterer Nachfolger von
¯®½¨
mit ei-
nem Wert
¥ÌÃ
n¨utzlich w¨are, um das Target
v· ¿·¹¸ ª 0
’
¢
’
Ã
?
7i¨¾®
h
zu erf¨ullen. Eine
Bewertung von
,¯®½µ¨®
liefert das gew¨unschte Ergebnis. Ebenso wird an
½®½¯®
verfahren
und die Cc2s(
ii
) Routine l¨auft bis zur Wurzel zur¨uck. Sie wird nun auf
,¨
angesetzt
und l¨auft bis zum Knoten
,¨¾µ¨µ¨
herunter, der dabei das Target
v·¹¸·¹¸·¹¸ ªÍ
’
¥
’
Ã
h
ÆÅ®
?
zugewiesen bekommt. Die Mindestsuchtiefe ist also erreicht, aber es m¨ussen zwei blatt-
disjunkte Strategien gefunden werden, die den Wert
’
¥
’
Ã
h
am Knoten
¨µ¨¾¨
belegen.
Deshalb werden
,¨¾µ¨µ¨¾¨
und
¨¾¨¾¨¾®
erzeugt und bewertet. An
¨¾¨¾¯®
wird analog wie
bei Knoten
,µ¨µ¨¾¨
verfahren, so daß wir folgenden besuchten Spielbaum erhalten:
v
v.1 v.2
v.1.1 v.1.2
v.1.1.1
v.1.2.1
≥
Î
’,5)(’
(’#’,5)
≥
Î
’,5)(’
v.2.1.1 v.2.2.1
v.2.1 v.2.2
(’#’,7)
(’#’,7)
(’#’,7)
(’#’,7)
(’#’,8)
(’#’,8)(’#’,5)
(’#’,6)
(’≤
Ï
’,7) ≥
Î
(’ ’,7) ≥
Î
(’ ’,7)
(’≤
Ï
’,7)(’≤
Ï
’,7)(’≤
Ï
’,7)(’≤
Ï
’,7)
v.1.1.1.1 ... ... v.1.1.1.2
Abb. 2.21: Zwei blattdisjunkte Entscheidungsstrategien
2.2 Hergeleitete Eigenschaften
2.2.1 Vergleich zwischen der Cc1s und dem
Ð`Ñ
-Algorithmus
Wir versuchen nun, unseren Algorithmus mit dem bislang erfolgreichsten Spielbaum
Suchalgorithmus, dem
Ò
-Algorithmus zu vergleichen. Weil der nicht mit Sicherheits-
aspekten wie Conspiracy Numbers umgehen kann, beschr¨anken wir uns bei der Analyse
auf H¨ullen, deren Bl¨atter alle die gleiche Entfernung zur Wurzel aufweisen (sog. fixed-
depth H¨ullen). Wir verzichten auf die Forderung, mehrere blattdisjunkte Beweisstrategien
herauszuarbeiten, und nennen diese Variante ’Controlled Conspiracy Number 1 Search’
(Cc1s).
Ferner ist die Analyse des
Ò
-Algorithmus f¨ur gew¨ohnlich auf fixed-depth full-width
Spielb¨aume mit einem uniformen Verzweigungsgrad beschr¨ankt. Wir ¨ubernehmen auch
diese Einschr¨ankung.
2.2 Hergeleitete Eigenschaften 47
Sei nun
Ó
ein fixed-depth full-width Spielbaum mit Tiefe
Ô
und Breite
Õ
. Um den besten
Zug zu bestimmen, berechnet der
-Algorithmus den Minimaxwert der Wurzel von
Ó
.
Dazu muß er mindestens
Õ¾Ö´× ØÙO¦©Õ¾Ú´× ØÛ=°Ü¨
Bl¨atter bewerten [KM75].
Satz 2.2-3 (Aufwand)
Der Cc1s-Algorithmus muß mindestens
Õ
Ú
ÝÞ ¸ßàF¿
Û
¦~Õd°á¨
¹
ãâiÕ
Ö
ÝÞ ¸ßàF¿
Ù
Bl¨atter von
Ó
be-
werten, um den besten Zug zu finden. Im besten Fall wird diese Schranke auch erreicht.
Bez¨uglich der Anzahl der zu bewertenden Bl¨atter ist dies optimal.
ä
Satz 2.2-4 (Terminierung)
Wenn
Ó
endlich ist (insbesondere, wenn
Ó
ein fixed-depth full-width Spielbaum ist),
terminiert der Cc1s-Algorithmus in endlicher Zeit.
ä
Wegen der Schleife in Zeile 3 in Abb. 2.7 ist der Nachweis der Terminierung nicht trivial.
Satz 2.2-5 (Korrektheit)
Der Entscheidungszug, den die Cc1s findet, basiert auf dem Minimaxwert von
Ó
, d.h.,
jeder minimax-basierte Suchalgorithmus kommt in folgendem Sinne zu dem gleichen Er-
gebnis: Sei
å ªæ´,Mç
der vom Cc1s-Algorithmus ermittelte beste Zug,
åèçéªên,Mç ç
ein von einem anderen minimax-basierten Verfahren ermittelter bester Zug. Dann sind
die Minimaxwerte von
ç
und
ç ç
gleich. Wenn der beste Zug eindeutig ist, sind
å
und
åç
gleich.
ä
Die entsprechenden Beweise befinden sich am Ende dieses Kapitels.
2.2.2 Cc2s im Vergleich zu Auswahl-Expansion-Aktualisierung ba-
sierten Algorithmen
Satz 2.2-6 (Partielle Korrektheit)
Wenn der Algorithmus seine Arbeit beendet hat, basiert das Ergebnis auf einer H¨ulle, die
nach dem Minimax-Prinzip ausgewertet wurde.
ä
Sofern sie die gleiche H¨ulle auswerten, ist damit sichergestellt, daß unser Algorithmus
und ein Algorithmus, der f¨ur jede Spielbaumerweiterung die drei Phasen Auswahl, Ex-
pansion und Aktualisierung durchf¨uhrt, zu dem gleichen Ergebnis kommen (vgl. Ab-
schnitt 1.5).
Unsere neue Technik hat zwei Vorteile gegen¨uber Algorithmen, die ein Blatt expandieren,
48 Das Cc2s-Verfahren
indem alle Nachfolger angeh¨angt werden. Deren neu erzeugte Nachfolger wissen n¨amlich
nicht, zu welchem Zweck sie erzeugt wurden. In der Praxis ist es oft wesentlich schneller
zu entscheiden, ob der heuristische Wert eines Knotens gr¨oßer oder kleiner einer vorge-
gebenen Zahl ist, als einen punktgenauen Wert zu bestimmen. Dar¨uber hinaus brauchen
wir nicht immer alle Nachfolger eines Knotens zu erzeugen.
Die gesteigerte Effizienz unseres Verfahrens h¨angt zum einen vom Verzweigungsgrad
des Spiels, zum anderen davon ab, wievielmal schneller die Bewertungsprozedur eine
Aussage ¨uber eine Wertschranke machen kann, als den heuristischen Punktwert zu liefern.
Es ¨uberrascht nun nicht mehr, daß es kein konkurrenzf¨ahiges Schachprogramm gibt, das
auf der Auswahl-Expansions-Aktualisierungs Technik basiert.
Satz 2.2-7 (Terminierung und Fortschritt beim Cc2s-Algorithmus)
In unendlich großen Spielb¨aumen kann es passieren, daß der Cc2s-Algorithmus nicht ter-
miniert, da es nat¨urlich beliebig große Spielb¨aume gibt, die nicht die erforderlichen blatt-
disjunkten Strategien enthalten. In diesem Fall ist aber Fortschritt in dem Sinne gew¨ahr-
leistet, daß der Suchbaum w¨achst. Der Algorithmus kann also nicht in eine Endlosschleife
geraten. Die Argumentation ist analog zu der von Satz 2.2-4.
In einem beliebigen, endlich großen Spielbaum
Ó
terminiert der Cc2s-Algorithmus zwar
immer (analog zu Satz 2.2-4), es kann aber passieren, daß das Ergebnis rein formal nicht
den vorgegebenen Sicherheitsanforderungen (bzgl. Entfernung der Bl¨atter zur Wurzel und
bzgl. der Conspiracy Number) entspricht. Da das aber nur dadurch passieren kann, daß
Teilergebnisse auf Werten von nichtexpandierbaren Bl¨attern von
Ó
beruhen, bei denen
man die spieltheoretischen Werte kennt, nehmen wir das gerne in Kauf.
ä
2.3 Heuristiken zur Beschleunigung
Der Vollst¨andigkeit halber stellen wir nun noch einige Heuristiken zur Beschleunigung
und Verbesserung des Verfahrens vor, wie sie im Schachprogramm ConNerS eingesetzt
werden. Es handelt sich um Heuristiken, die entweder aus Ver¨offentlichungen ¨uber Va-
rianten des
Ò
-Algorithmus ¨ubernommen wurden, oder um Heuristiken, die durch Pro-
bieren und einfache Programmoptimierung auf kleinen Benchmarks zustande gekommen
sind. Sie fallen somit aus dem Rahmen dieser Arbeit heraus. Trotzdem sind sie f¨ur den
Erfolg unseres Schachprogramms P.ConNerS unverzichtbar.
2.3 Heuristiken zur Beschleunigung 49
Mehrmaliges Bewerten von Knoten
Im vorigen Kapitel war es eine wichtige Eigenschaft der Prozedur PartialExpansion, daß
sie daf¨ur sorgt, daß jeder Knoten h¨ochstens zweimal bewertet wird. Dadurch war eine
Terminierungsargumentation f¨ur den Gesamtalgorithmus erst m¨oglich geworden.
Sei nun
ein Knoten, dessen heuristischer Wert bisher
’
¥
’
v
war. Wenn diese In-
formation f¨ur vern¨unftigen Fortschritt der Cc2s-Prozedur nicht mehr ausreicht, wird
neu bewertet. Anstatt den Wert aber sofort in einen ’#’ -Wert umzuwandeln, ist es auch
m¨oglich,
erstmal im Fenster
n v v¦Üë
?
(
ëeìîíí
) neu zu bewerten. Liefert die Bewer-
tungsfunktion eine Zahl
zwischen
v
und
v¦ë
, ist der neue Wert von
gleich
’#’
ï
8
mit
ïèìîðñ v v¦NëPò
; liefert sie eine Zahl gr¨oßer als
v¦9ë
, wird der Wert zu
’
¥
’
v¦Në
.
Die Terminierung des Gesamtalgorithmus ist nat¨urlich nach wie vor gesichert, allerdings
verschlechtert sich das Worstcase-Verhalten.
F¨ur unser Schachprogramm ConNerS hat sich
ëóªÈ¾Æ
als gut erwiesen. 80 Punkte ent-
sprechen
ÆÅÂ
Bauerneinheiten.
Vorsortierung
Wenn ein Blatt
des Suchbaums expandiert werden muß und das zu
geh¨orige Target
v
zu einem Cut-Knoten macht, gen¨ugt es oft, nur ein oder zwei Nachfolger
’s zu
bewerten. Hierbei ist eine heuristische Vorsortierung der neu generierten Z¨uge n¨utzlich.
Da sich die vom Cc2s-Verfahren erzeugten Knoten nahe der Suchbaumwurzel befinden,
ist die Geschwindigkeit, mit der solch eine Vorsortierung geschieht, nur minder relevant.
Alle neu erzeugten Z¨uge werden mit Hilfe einer kleinen
Ò
-Ruhesuche vorbewertet und
sortiert.
Fenster an der Wurzel
Bisher bestimmt die Prozedur DetermineMove zu Beginn einer Iteration denjenigen Zug
mit dem h¨ochsten
¸
-Wert als den mutmaßlich auch in Zukunft besten Zug und erzeugt ein
Target
¸`ô ªõ
’
¥
’
¸Ôö°s¨
ËQ
f¨ur den besten Nachfolger und
÷ ôªÉ
’
¢
’
¸Ôö°~¨¾
Ëà
f¨ur die anderen Nachfolger der Spielbaumwurzel. Es hat sich f¨ur den praktischen Ge-
brauch als sehr n¨utzlich erwiesen, diese Targets aufzuweichen, so daß (f¨ur ein
ëì«íí
)
¸øô ªÌ
’
¥
’
¸°ÜëjÔ3°ù¨¾
Ëà
und
÷ ôªÌ
’
¢
’
¸¦~ëPÔ°ù¨
ËQ
f¨ur
úüûõ¨
gesetzt wird.
Dadurch wird ein Zug auch dann als bester akzeptiert, wenn sein Wert w¨ahrend der Be-
rechnung ein wenig absinkt oder der Wert eines anderen Nachfolgers ein wenig ansteigt.
Kleine Schwankungen kann man i.allg. vernachl¨assigen. Im Schachprogramm ConNerS
hat sich
ëªýÃ
, was sieben hundertstel Bauerneinheiten entspricht, als vern¨unftiger Wert
50 Das Cc2s-Verfahren
herausgestellt.
Die Einf¨uhrung von Hauptvarianten
Wir haben im Schachprogramm ConNerS die M¨oglichkeit vorgesehen, nicht nur nach
einer bestm¨oglichen Entscheidung zu suchen, sondern auch eine Hauptvariante zu ermit-
teln. Obwohl das ein wenig zus¨atzliche Rechenzeit kostet und auch kein Spielst¨arkezu-
wachs beobachtet werden konnte, bieten sich drei Vorteile:
þ
Der wichtigste Vorteil besteht darin, daß man nicht nur einen guten Zug an der
Wurzel erh¨alt, sondern auch einen Folgezug f¨ur den Gegner, den man dann als
Ratezug einsetzen kann. Auf diese Weise l¨aßt sich auch die Zeit, in der der Gegner
am Zug ist, sinnvoll nutzen.
þ
Mit Hilfe der Hauptvarianten erh¨alt man als Beobachter eines Spiels bessere Ein-
blicke in die internen Rechenvorg¨ange. Das Aufsp¨uren von Fehlern ist auf diese
Weise wesentlich einfacher.
þ
Manchmal konnten wir beobachten, daß das Schachprogramm ConNerS zwar die
richtigen Z¨uge vorschlug,aber mit einer aus schachlicherSicht falschen Begr¨undung.
Das f¨uhrte in Einzelf¨allen dazu, daß das Programm viel Rechenzeit in Teilb¨aume
investierte, die anders besser h¨atte eingesetzt werden k¨onnen.
Wir erreichen das Herausbilden von Hauptvarianten dadurch, daß wir erweiterte Targets
einf¨uhren, sog. ’#’ -Targets. Sie haben die Form
dªý
’#’
Åëjÿ
ç
ë
ç
ÿ
ç
7
Wie normale Targets auch formulieren sie eine Anforderung an den Knoten, nur daß sie
in der Lage sind, von einem Knoten zu fordern, daß sein Minimaxwert
¡£¥~5ç
und gleich-
zeitig
¢
ist. Dabei soll die obere Schranke sicher sein mit Conspiracy Number
ÿ
und
Resttiefe
ë
. Die untere Schranke soll auf die gleiche Weise mit
ÿ,ç
und Resttiefe
ëjç
gesi-
chert werden.
Transpositionstabellen
Eine Transpositionstabelle ist eine Hashtabelle f¨ur Knoten. Sie dient dazu, Teilergebnisse,
die in einem Teilbaum errechnet wurden, in einem anderen Teilbaum nicht neu berechnen
zu m¨ussen. Ein Eintrag in eine Transpositionstabelle besteht aus einem Tupel
. Da-
bei ist die Komponente
ein 32-Bit Schl¨ussel, der zur Identifikation eines Eintrags dient.
Die Tatsache, daß der Schl¨ussel nicht eindeutig ist, wird wie z.B. beim Computerschach
2.3 Heuristiken zur Beschleunigung 51
¨ublich, ignoriert. Die Komponente
enth¨alt dasjenige Target, das zuletzt am Knoten
,
dessen Hashschl¨ussel
ist, erf¨ullt wurde. Der Effekt, den eine Transpositionstabelle beim
Cc2s-Verfahren hat, ist bei weitem nicht so groß wie z.B. beim
-Verfahren. Bei letz-
terem kann die Tabelle auch zur Zugsortierung herangezogen werden. Da beim Cc2s-
Verfahren der Suchbaum komplett vorliegt, ist die Transpositionstabelle f¨ur die Zugsor-
tierung unerheblich.
Die Hashfunktion wurde folgendermaßen konstruiert:
F¨ur jede m¨ogliche Figur auf jedem m¨oglichen Feld wurden zwei 32-Bit Zufallszahlen
ermittelt. Die XOR-Operation ¨uber alle auf dem Brett befindlichen Figuren liefert dann
zwei verschiedene 32-Bit Schl¨ussel. Der eine wird zur Identifikation in den Hashtabellen-
eintrag mit hineingeschrieben, der andere liefert durch Modulobildung einen Index in die
Tabelle.
Wir benutzen drei verschiedene Transpositionstabellen: Je eine f¨ur ’#’ -Targets, f¨ur ’
¢
’
-Targets und f¨ur ’
¥
’ -Targets. Die Tabellen f¨ur ’
¢
’ - und ’
¥
’ -Targets enthalten 10000
Elemente, die f¨ur ’#’ -Targets enth¨alt 5000 Elemente. Die Operationen ’read’ und ’write’
und ’remove’ sehen jeweils folgendermaßen aus:
Wenn an einem Knoten
ein Target
v
erf¨ullt werden konnte, wird dies in die zu
v
geh¨ori-
ge Transpostionstabelle eingetragen.
void write(Index
ú¡
, Eintrag (Schl¨ussel s, Target
dªº0a
7ëjÿ
j
))
1
Seien
der Hashschl¨ussel und
die Transpositionstabellen f¨ur
2die entsprechenden Targets,
÷
sei der i-te Eintrag von
.
3
ç
Hç
sei f¨ur Targets
dªý0)
ëjÿ
j
und
ç ªºãç ãç
7ëjçu0ÿç
so definiert:
4
©ç
ÿ
áÿ,ç
ÿ ª~ÿ,ç
! #"%$
óë
&
Üëjç
6
5if (
ist ein
¢
-Target oder ein #-Target
'
also
Iì
)(
’
¢
’
’#’
*
)
6if (
÷
!+
ist leer oder
/¥
,
÷
!+
ñ
)
'
Targetkomponente
then
7
÷
!+
ôªº
;
8if (
ist ein
¥
-Target oder ein #-Target)
9if (
÷
!+
ist leer oder
/¥
,
÷
!+
ñ
)then
÷
!+
ôªý
;
10 if (
ist ein #-Target)
11 if (
÷
!+
ist leer oder
/¥
,
÷
!+
)then
÷
+
ôªý
;
Abb. 2.22: Schreibe Hash-Tabelleneintrag
Bevor die Suche unter einem inneren Knoten
gestartet wird, sieht der Suchalgorithmus
in den Transpositionstabellen nach, ob das Target
v
, oder ein h¨oherwertiges schon ein-
mal an anderer Stelle erf¨ullt werden konnte. Wenn das der Fall ist, wird
sofort wieder
52 Das Cc2s-Verfahren
boolean read(Index
ú¡
, Anfrage (Schl¨ussel
, Target
dªº0a
7ëjÿ
j
))
'
Seien
der Hash-Schl¨ussel und
-
’
¢
’
’
¥
’
’#’
die Transpositionstabellen
f¨ur die entsprechenden Targets,
÷
sei der i-te Eintrag von
.
if (
ist ein
¢
-Target)
(
if (
÷
!+
ª
)and (
ist schon erf¨ullt, wegen
÷
!+
ñ
)then return true;
*
else if (
ist ein
¥
-Target)
(
if (
÷
!+
ª
)and (
ist schon erf¨ullt, wegen
÷
!+
ñ
)then return true;
*
else if (
ist ein
.
-Target)
(
if (
÷
!+
ª
)and (
ist schon erf¨ullt, wegen
÷
!+
)then return true;
*
return false;
Abb. 2.23: Lese Hash-Tabelleneintrag
verlassen, mit der Meldung an den Vorg¨anger von
, daß das Target
v
erf¨ullt werden
konnte.
Wenn ein Target
v
an einem Knoten
nicht erf¨ullt werden konnte, ist es nicht klar, was
sinnvollerweise in die Transpositionstabelle eingetragen werden kann.
≥ x
≥ x
≥
v
≥
≥
v
<x
<x
<x
t=((’t=((’ ’,x), 1, 4) ’,x), 2, 4)
((’ ’x), 1, 4)
wird in die
Transpositionstabelle
eingetragen
kein sinnvoller Eintrag
vorhanden
Abb. 2.24: Verwertbarkeit von fehlgeschlagenen Suchen
Sehen wir unsdazu das Beispiel aus Abbildung 2.24 an. Dortwurde am Knoten
zun¨achst
einmal das Target
^ª
’
¥
’
¡
"
i¨¾¼
erf¨ullt. In einer sp¨ateren Phase des Suchens sollte
ein Target
’
¥
’
¡
"
®½¼
erf¨ullt werden. Das ist jedoch fehlgeschlagen, und es wurde
vom Suchalgorithmus ein neuer Wert f¨ur
hochgereicht, der kleiner als der alte Wert ist.
Nachdem die Suche fehlgeschlagen ist, haben wir mehrere M¨oglichkeiten: Z.B. k¨onnen
wir den alten Eintrag in der Transpositionstabelle stehen lassen. Das ist allerdings riskant,
da ja gerade zuvor gezeigt wurde, daß sich das in der Transpositonstabelle stehende Er-
2.3 Heuristiken zur Beschleunigung 53
gebnis nicht halten l¨aßt. Mit welcher Sicherheit man die neuen Erkenntnisse abspeichern
sollte, ist aber auch nicht zu sehen. Deshalb l¨oschen wir in solchen F¨allen den entspre-
chenden Eintrag in der Transpositionstabelle.
void remove(Index
/10
, Eintrag (Schl¨ussel s, Target
}ãpsrruÒwZ{0wDwF,{
))
if (
}
ist ein
-Target)
if (
2
÷
!+4365
p
5
)then l¨osche
2
÷
+
;
if (
}
ist ein ’
’ -Target)
if (
2
÷
!+
365
p
5
)then l¨osche
2
÷
+
;
if (
}
ist ein ’#’ -Target)
if (
2
÷
!+ 365
p
5
)then l¨osche
2
÷
!+
;
Abb. 2.25: L¨osche Hash-Tabelleneintrag
Stabilit¨
at von Bewertungen
Damit der Cc2s-Algorithmus zielgerichtet arbeiten kann, m¨ussen die Bewertungen an den
Bl¨attern neben einer gewissen Qualit¨atauch Stabilit¨atbesitzen. Da die Suche haupts¨achlich
durch die Bewertungen gesteuert wird, f¨uhrt eine instabile Bewertung zu Terminierungs-
schwierigkeiten. F¨ur das Schachprogramm P.ConNerS haben sich Tiefe-2
-Suche ein-
schließlich Ruhesuchen, Verk¨urzungen und den ¨ublichen Spielbaumerweiterungstechni-
ken als gut erwiesen. Reine Ruhesuchen f¨uhren die Suche zu oft in eine falsche Richtung,
w¨ahrend Tiefe-3
-Suchen zu teuer sind.
Aufteilung von Targets erst in der N¨
ahe von Bl¨
attern
F¨ur unser Schachprogramm hat es sich als besonders wirkungsvoll erwiesen, das Auf-
teilen der Conspiracy-Zahlen auf mehrere Nachfolger erst in der N¨ahe von Bl¨attern zu
gestatten. Aufgeteilt wird demnach ein Target erst, wenn der Resttiefenanteil des Targets
kleiner als 2 ist.
Nullmoves und Fail-High Reduktionen
Nullmoves und Fail-High Reduktionen werden, wie in der Literatur [Don93] [Fel96] f¨ur
Ò
-Suchen ver¨offentlicht, eingesetzt.
Sicherheit von Z¨ugen an der Wurzel
Sei
87
der Zahlwert der Wurzel und Paare (
9
,Õ
) seien Anforderungstupel, die besagen, daß
der Zug an der Wurzel mit Tiefe
9
und Conspiracy Number
Õ
sicher sein soll. ConNerS
54 Das Cc2s-Verfahren
versucht, im Mittelspiel die Z¨uge mit der Anforderungsfolge (1,1), (2,1), (3,1), (4,1),
(4,2), (5,2), (
|i
,2) sicher zu machen und in elementaren Endspielen (Endspiele, bei denen
nur noch Bauern und maximal je ein L¨aufer oder ein Springer auf dem Brett sind) mit der
Anforderungsfolge (1,1), (2,1), (3,1), (4,1), (4,2), (4,3), (5,3), (6,3), (7,3), (8,3), (8,4),
(8,5), (9,5), (
i|
,5).
2.4 Experimentelle Ergebnisse
Wir beginnen mit einer Leistungsbeurteilung, die zum einen aus der Auswertung einer
Serie von Teststellungen besteht (dem BT2630 Test) und zum anderen aus einer Serie von
Spielen gegen Cheiron’97. Die ¨ubrigen Abschnitte besch¨aftigen sich mit technischen Fra-
gen. Wir zeigen, daß der Geschwindigkeitsgewinn unseres Target-gesteuerten Verfahrens
gegen¨uber Verfahren, die bei jeder Expansion alle Nachfolger mit Punktwerten auswer-
ten, praxisrelevant ist. (Zur Erinnerung: einen Wert der Form
¶ ª
’#’
nennen wir
auch Punktwert;
¶æª
’
¢
’
oder
¶ ª
’
¥
’
nennen wir auch Schrankenwert;)
Außerdem besch¨aftigen wir uns mit der Frage, inwieweit sich die bei ConNerS entste-
henden Suchb¨aume von Suchb¨aumen mit ’fester Suchtiefe’ (aber durchaus unter Einfluß
von Nullmoves und Fail-High Reduktionen) unterscheiden.
Der BT2630 Test
Der erste Teil besteht aus Stellungen des sogenannten BT2630 Tests [BT94]. Er besteht
aus 30 Stellungen (vgl. auch Anhang A). Jede ist mit einer großmeistergerechten L¨osung
versehen. Ein Programm bekommt exakt 15 Minuten Zeit, um einen Zug auszurechnen.
F¨ur Stellungen, die nicht gel¨ost werden, gibt es 900 Strafpunkte. F¨ur solche, die gel¨ost
werden, gibt es die Anzahl der Sekunden bis zur L¨osung als Strafpunkte. Findet und ver-
liert ein Programm den richtigen L¨osungszug w¨ahrend der erlaubten 15 Minuten mehr-
fach, z¨ahlt der letzte Zeitpunkt, an dem die L¨osung entdeckt und bis zum Abbruch beibe-
halten wurde.
Der Test weist dem Ergebnis des Rechners eine Pseudo-ELO-Zahl zu. (Das ELO System
ist ein statistisches Maß, um relative Spielst¨arke von Schachspielern zu messen. Es hat
sich zur Bewertung der Spielst¨arke von Schachspielern durchgesetzt.) Den BT2630 Test
betreffend h¨alt ConNerS dem Vergleich mit Topprogrammen wie Fritz und Hiarcs stand.
Die Meßergebnisse der fremden Programme wurden von uns auf uns zur Verf¨ugung ste-
hender Hardware ermittelt. Man muß hier fairerweise hinzuf¨ugen, daß eine Einprozessor-
version von ConNerS im Spiel keineswegs mit Programmen wie Fritz oder Hiarcs mithal-
ten kann. Daf¨ur ist auch der investierte Zeitaufwand zur Erstellung und Feinoptimierung
der Programme nicht vergleichbar.
2.4 Experimentelle Ergebnisse 55
Ergebnis auf dem BT2630-Test
Programm auf Maschine Pseudo-ELO
ConNerS auf Sparc 144 MHz 2375
ConNerS auf Sparc 300 MHz 2408
ConNerS auf Pentium II 450 MHz 2444
Cc1s-Suche auf Pentium II 450 MHz 2403
Cheiron’97 auf Sparc 144 MHz 2331
Fritz 4.0 auf 200Mhz Pentium 2373
Hiarcs 6.0 auf 200Mhz Pentium 2403
Abb. 2.26: Testergebnis
Obwohl der Schwerpunkt des Tests auf taktischer Spielst¨arke liegt, ist entscheidend, daß
ConNerS die taktischen L¨osungen findet, obwohl es eine fein-granulare Bewertungsfunk-
tion besitzt. Hier hebt sich das Cc2s-Verfahren deutlich von den Ergebnissen der konven-
tionellen CNS ab [Sch90].
Testspiele
Der zweite Teil des Testens beruht auf Spielen. Wir wollten uns der Herausforderung stel-
len, unser auf Cc2s beruhendes Schachprogramm mit Programmen zu vergleichen, die
den
-Algorithmus benutzen einschließlich der allgemein anerkannten Verbesserungen:
Transpositiontables, diverse Sortierheuristiken [Sch83], Fail High Reduktionen, Nullmo-
ves u.s.w.
Wie schon bei anderen Gelegenheiten [Fel96] [ADLR93] haben wir 25 Startstellungen
vorgegeben. Wir ließen ConNerS zwei Spielserien von je 50 Spielen gegen das Programm
Cheiron’97 machen. Cheiron’97 benutzt den Negascout-Algorithmus [Rei89], Fail High
Reduktionen, Transpositiontables, Killerheuristiken, R¨uckschlag- und Schacherweiterun-
gen. Das Programm und seine Vorg¨anger haben gute Ergebnisse bei Computerschachtur-
nieren erzielt. Der Vorg¨anger Ulysses wurde z.B. Neunter bei der Computerschachwelt-
meisterschaft 1992. Der Hauptvorteil, Cheiron’97 als Gegner einzusetzen war jedoch, daß
wir eine Tiefe-2 Suche des Programms als Bewertung von ConNerS nehmen konnten. Da-
mit war es m¨oglich, einen Vergleich der Suchalgorithmen zu erreichen.
Die erste Serie fand auf einer Sparc 144 Mhz Maschine statt, und die Programme be-
kamen 8 Stunden Zeit f¨ur je 40 Z¨uge. Der Vergleich endete 26.5 zu 23.5 zugunsten von
Cheiron’97. Obwohl sichdie Einzelergebnisse einer zweiten Serie,bei der die Programme
4 Stunden f¨ur 40 Z¨uge Zeit hatten (Turnierzeitmodus), unterscheiden, endete auch diese
56 Das Cc2s-Verfahren
Serie mit 26.5 zu 23.5. Beide Serien zusammen f¨uhren also zu einem Ergebnis von 53 zu
47. Wir interpretieren dieses Ergebnis so, daß Cheiron’97 und ConNerS ungef¨ahr gleich
stark sind, auch wenn diese 100 Spiele keine statistisch signifikante Aussage zulassen.
2.4.1 Baumbeschneidungen und schnelle Bewertungen
Nr. Zeit(sec)
;:
¸
#Knoten Zeit
;:
¿
#Knoten Zeit
<:=
B
#Knoten
1 36 4613 115 4322 889 32382
2 7 5695 29 6548 203 47837
5 58 30230 424 29628 420 35403
6 40 8658 200 7223 892 33992
7 20 7576 110 5106 446 25875
8 12 4498 42 4245 231 20064
9 30 13288 128 11439 669 63248
11 12 2461 38 2474 324 16433
12 67 7134 220 4763 652 15851
13 14 3165 75 2614 391 11362
14 25 6690 70 6301 430 41579
15 23 6496 124 6177 573 30218
17 9 2380 17 2249 163 11555
18 72 38632 188 16844 660 53347
19 80 13400 121 7573 859 49707
20 3 1542 12 1464 127 12124
21 138 4294 182 3677 628 14391
22 3 972 13 945 107 6817
23 69 5256 258 5119 733 14839
24 11 2490 100 2645 301 9626
25 48 11979 101 7065 635 43446
26 6 3657 29 3052 371 26285
27 15 3343 36 2300 858 64954
29 17 2771 87 3001 551 16824
30 132 23790 194 11318 585 38188
>
947 215010 2913 158092 12698 736347
Abb. 2.27: Nutzen der Targets
Es wurde bereits mehrfach erw¨ahnt, daß wir der ¨
Uberzeugung sind, einer der Hauptvor-
2.4 Experimentelle Ergebnisse 57
teile der mit Hilfe von Targets top-down kontrollierten Suche gegen¨uber herk¨ommlicher
Auswahl-Expansions-Aktualisierungs-Suche sei, daß man mit Hilfe der Targets nicht im-
mer alle Nachfolger eines Knotens bewerten muß und außerdem noch schnelle Bewertun-
gen einsetzen kann, die statt Punktwerten lediglich Schranken zur¨uckliefern.
Um den Nutzen der Targets f¨ur unser Schachprogramm sichtbar zu machen, haben wir
drei verschiedene Versionen von ConNerS erzeugt und auf dem BT2630 Test einander
gegen¨ubergestellt. Version
:
¸
entspricht der normalen Version von ConNerS.
:
¿
bewertet
jeden Knoten, der bewertet werden soll, sofort mit einem heuristischen Punktwert (d.h.,
jeder Knoten wird mit einer Tiefe-2
Ò
-Suche mit dem Startfenster
ð°²±³±©ò
bewertet),
und
:=
erzeugt bei jedem Expansionsschritt alle Nachfolgeknoten und weist ihnen einen
heuristischen Punktwert zu.
Auf jeder Teststellung mußte jede der drei Versionen nach einer Entscheidung mit vorge-
gebener Sicherheit suchen. F¨ur jede einzelne Stellung war die geforderte Sicherheit f¨ur
alle Versionen gleich. Die jeweils verbrauchte Zeit und die jeweilige Anzahl der Such-
knoten (ohne diejenigen Knoten, die von der Bewertungsprozedur, die aus einer Tiefe-2
Ò
-Suche besteht, erzeugt werden) wurden dann miteinander verglichen. Die Stellungen
3,4,10, 16 und 28 wurden aus dem Test herausgenommen, weil
:?=
zu langsam ist, um dort
vern¨unftig meßbare Vergleichsergebnisse zu liefern.
In der Summe (s. Abb. 2.27) ben¨otigte
:?=
mit 12698 Sekunden 13,4 mal so lange wie
:
¸
.
Mit 2913 Sekunden brauchte
:
¿
immerhin 3,1 mal solange wie
:
¸
. Zus¨atzlich erw¨ahnt sei,
daß die Suchergebnisse nur in den Stellungen 2, 25, 27 und 29 voneinander abweichen.
Innerhalb dieser kleinen Untermenge von Stellungen hat lediglich
:
¸
in Stellung 25 die
richtige L¨osung gefunden. Man kann also davon ausgehen, daß die Entscheidungsqualit¨at
der drei Versionen ¨ahnlich ist, wenn sie nach Entscheidungen mit derselben Sicherheit
suchen.
Interessant ist, daß
:
¿
wenigerKnoten(74%) als
:
¸
erzeugthat.Das liegtsicher daran, daß
:
¿
dadurch daß diese Version immer mit Punktwerten arbeitet, ab und an einen genaueren
Eindruck der Situation besitzt als
:
¸
. Die Punktwerte sind genauer und erlauben eine
bessere heuristische Steuerung der Suche.
2.4.2 Form der Suchb¨
aume
Weiterhin stellt sich die Frage, wiedie Suchb¨aume aussehen, dievom Programm ConNerS
durchsucht werden. Allgemein ist das schwer zu beantworten, da sich die Suche den Ge-
gebenheiten des Spiels anpaßt. Einen Eindruck sollen aber die folgenden ¨
Uberlegungen
geben:
58 Das Cc2s-Verfahren
Wir betrachten dazu die Anzahl der untersuchten Knoten pro Ebene nach einer l¨angeren
Berechnungszeit. Bei einem Tiefe-
-Suchalgorithmus d¨urfte man einen exponentiellen
Anstieg der Knoten mit einem Faktor sechs pro Ebene erwarten. Bei einer Tiefe-
Suche
mit Nullmoves und Fail-High-Reduktionen sieht die Sache schon anders aus. Abb. 2.28
zeigt die jeweilige Knotenanzahl einer mit unserem Verfahren durchgef¨uhrten Tiefe-
Su-
che. Wir hatten diese Version auch schon als Cc1s-Suche bezeichnet. Allerdings haben
wir hier alle in Abschnitt 2.3 vorgestellten Verbesserungen mit einbezogen. Gez¨ahlt wur-
den nur die Knoten, die vom Cc1s-Algorithmus erzeugt wurden. Die Knoten der Tiefe-2
Ò
-Suchen und der dazugeh¨origen Ruhesuchen sind darin nicht enthalten. Gezeigt wer-
den die Stellungen 1,5,9,13,17,21 und 25 des BT2630 Tests (Abb. 2.28). Der Meßzeit-
punkt ist jeweils derjenige, an dem zum letzten Mal eine Iteration beendet wurde, bei
einer maximalen Laufzeit von 15 Minuten.
1
4
16
64
256
1024
4096
16384
65536
262144
1.04858e+06
0 5 10 15 20 25 30
Anzahl Knoten
Tiefe
BT2630,1
BT2630,5
BT2630,9
BT2630,13
BT2630,17
BT2630,21
BT2630,25
BT2630,29
Abb. 2.28: Anzahl der Knoten pro Ebene des Cc1s-Verfahrens
Man sieht deutlich die Wirkung der vorgenommenen Variantenverk¨urzungen. Das Wachs-
tum der Knotenzahlen ¨uber die Ebenen 1 bis 15 ist nicht exponentiell. Zum Ende werden
die Knoten pro Ebene sogar wieder weniger (Ebenen 10-15). Trotzdem kann sich ein Ver-
fahren, das auf Verk¨urzungen beruht, dem exponentiellen Wachstum der Strategien in der
N¨ahe der Wurzel nicht entziehen (Ebenen 1-8), da dort immer alle Nachfolger betrachtet
werden.
Bei Cc2s-Suchen werden zumindest einige Varianten wesentlich tiefer untersucht als bei
der Cc1s-Variante (teilweise mehr als 10 Halbz¨uge). Das Diagramm 2.29 vermittelt einen
visuellen Eindruck davon, wie die Zahl der Knoten ¨uber die verschiedenen Ebenen von
Cc2s-Suchb¨aumen verteilt ist.
2.4 Experimentelle Ergebnisse 59
1
4
16
64
256
1024
4096
16384
65536
262144
0 5 10 15 20 25 30
Anzahl Knoten
Tiefe
BT2630,1
BT2630,5
BT2630,9
BT2630,13
BT2630,17
BT2630,21
BT2630,25
BT2630,29
Abb. 2.29: Anzahl von Knoten pro Ebene des Cc2s-Verfahrens
Da die Anzahl der Knoten pro Ebene mit fortschreitender Tiefe stark sinkt, kann es sich
nur um wenige, vereinzelte Varianten handeln, die der Cc2s-Algorithmus in den Tiefen
15 bis 27 verbringt. Auf einem Pentium 450 Mhz ist die Performance der Cc2s-Variante
trotzdem um 41 Pseudo-Elo Punkte besser, als die der Cc1s-Variante. Es werden also
Varianten verl¨angert, die (zumindest) das BT2630 Testergebnis merklich verbessern.
60 Das Cc2s-Verfahren
2.5 Beweise zu Kap. 2
Satz 2.1-2: Sei
Ó ªý
;:
d
A@
ù
CB
ein Spielbaum, und sei
ö
ein Suchbaum, also ein Teil-
baum von
Ó
, der von einem Suchalgorithmus
D
zu einem Zeitpunkt
untersucht wurde.
Ó
und
ö
sollen die gleiche Wurzel haben. Bezeichne außerdem
v´
den Teilbaum
von
ø
, der
als Wurzel besitzt.
Evaluate(
ii
) sei die oben gegebene Prozedur, die Knoten statische Werte zuordnet. Sol-
che statischen Werte brauchen zun¨achst nicht dem Minimax-Prinzip zu gehorchen. Evalu-
ate(
i|
) kann gefragt werden, wie sich der heuristische statische Zahlwert
¡
eines Knotens
zu einer vorgegebenen Zahl
9
ì~íí
verh¨alt. Falls
¡(ª
E9
ist, wird
der Wert
’#’
A9
C
zugewiesen. Falls
¡
,F9
ist, wird
’
¢
’
G9
°ù¨
¹
zugewiesen, und wenn
¡sû
F9
ist, be-
kommt
den Wert
’
¥
’
A9
3¦ý¨
¹
. Dar¨uber hinaus kann Evaluate(
|i
) auch gezwungen
werden, einen ’punktgenauen’, heuristischen Wert von
(also
B
ãn
) zur¨uckzuliefern. Der
Wert von
ist dann
’#’
¡
"
, f¨ur einen Zahlwert
¡
.
D
soll UpdateValue(
ii
) und Evaluate(
ii
) in folgender Weise gebrauchen: Wenn
D
den
Spielbaum erweitert, bewertet er das neue Blatt mit Hilfe von Evaluate(
i|
). Zu jedem
Zeitpunkt
ç
ist es
D
dar¨uberhinaus erlaubt, Werte von Evaluate(
|i
) beliebigen Knoten
zuzuweisen. Wann immer
D
zur Zeit
ç
Evaluate(
i|
) aufruft, wendet er den Operator
UpdateValue(
|i
) auf alle Knoten des Pfades von
zur Wurzel von
ö´ç
(das ist auch die
Wurzel von
Ó
) an. Er geht dabei bottom-up vor.
Wenn
D
die Wurzel von
ö´
erreicht, gelten folgende Eigenschaften f¨ur alle Knoten von
ö´
.
/1
¶vª
’
¢
’
¡
"
impliziert, daß es eine H¨ulle unterhalb von
gibt, deren Minimax-
wert
¢Ü¡
ist.
/2
¶vª
’
¥
’
¡
"
impliziert, daß es eine H¨ulle unterhalb von
gibt, deren Minimax-
wert
¥Ü¡
.
/3
¶vªÈ
’#’
¡
"
impliziert, daß es eine H¨ulle unterhalb von
gibt, deren Minimax-
wert
¢É¡
ist, und daß es eine m¨oglicherweise andere H¨ulle unterhalb von
gibt,
deren Minimaxwert
¥Ü¡
ist. Die beiden H¨ullen brauchen nicht dieselben zu sein.
/4 Sei
¶
IH
die Wertkomponente eines Targets
, die von
¶v
(einem Wert eines Knotens
) unterst¨utzt wird. Wenn
durch
zu einem ALL-Knoten wird, widerspricht kein
Wert der Nachfolger von
dem Wert
¶
IH
. Wenn
durch
zu einem CUT-Knoten
wird, gibt es einen Nachfolger von
, dessen Wert dem Wert
¶
IH
nicht widerspricht.
Beweis: Wir untersuchen die Entstehung eines Wertes
¶v
r¨uckw¨arts in der Zeit. Daf¨ur be-
trachten wir einen Knoten
zu einem Zeitpunkt
. Wir betrachten weiterhin alle M¨oglich-
keiten, wie dieser Wert von
zustande gekommen sein kann, wie also
¶v
vor dem letzten
2.5 Beweise zu Kap. 2 61
Aufruf von UpdateValue(
|i
) beim Knoten
ausgesehen haben kann. Wir nehmen dabei
an, daß Satz 2.1-2/1 bis 2.1-2/3 vor dem letzten Aufruf des UpdateValue(
i|
) Operators
f¨ur den Knoten
und den unter ihm h¨angenden Teilbaum g¨ultig war.
Es ist offensichtlich, daß Satz 2.1-2 f¨ur Bl¨atter von
ø
immer gilt.
Sei nun
der gegenw¨artige Zeitpunkt, kurz nachdem UpdateValue(
|i
) am Knoten
be-
endet wurde. Sei
der Zeitpunkt genau vor dem Aufruf von UpdateValue(
|i
). Nehmen
wir an, daß Satz 2.1-2 zur Zeit
f¨ur alle Knoten unterhalb von
g¨ultig ist und daß es f¨ur
alle Knoten g¨ultig ist, die nicht auf dem Pfad von
zur Wurzel liegen. Außerdem neh-
men wir an, daß Satz 2.1-2/1,2.1-2/2 und 2.1-2/3 zum Zeitpunkt
auch f¨ur den Knoten
g¨ultig war.
Im folgenden beziehen sich Zeilennummern auf den Updateoperator der Abbildung 2.8
auf Seite 34.
IJ
: Sei oBdA.
ein MAX-Knoten. Sei
¶
H
v
der Wert von
zum Zeitpunkt
.
1.
¶
H
v
ªº
’
¥
’
¡
"
Wenn
ein neues Blatt ist, ist Satz 2.1-2/2 wahr, wegen der Defi-
nition eines Wertes und wegen des Verhaltens von Evaluate(
i|
). Ansonsten war
das Attribut
9
v
des Wertes von
auch ’
¥
’ zum Zeitpunkt
(weil sich Attribute
nur von ’
¢
’ nach ’#’ oder von ’
¥
’ nach ’#’ ¨andern k¨onnen). Wegen Zeile 8 ist
¶
H
v
durch Zeile 6 entstanden, da sonst
9
H
v
’#’ w¨are. Weil in Zeile 6 der alte Zahlwert
eines Knotens in den neuen mit einfließt, kann
¡
durch die letzte Ausf¨uhrung von
UpdateValue(
|i
) nicht abgesenkt worden sein. Offensichtlich war zum Zeitpunkt
der Wert
’
¥
’
ï
D
mit einem
ïe¢Ü¡
.
(a) Einer der Nachfolger hat den Wert
’
¥
’
¡
"
und bestimmt
H
v
. Weil wir anneh-
men, daß Satz 2.1-2/2 zur Zeit
f¨ur alle Knoten unterhalb von
wahr war,
folgt, daß Satz 2.1-2/2 auch zum Zeitpunkt
wahr ist.
(b)
¶
HLK
v
bestimmt
¶
H
v
: Falls der Zahlwert
HLK
v
des Knotens
è
’
¥
’
¡
"
war, w¨ahlen
wir f¨ur Satz 2.1-2/2 denselben Teilbaum mit Wurzel
aus, wie schon zum
Zeitpunkt
. Man beachte: Wenn
gerade zuvor bewertet wurde und die ak-
tuelle UpdateValue-Phase verursacht hat, besteht der gesuchte Teilbaum nur
aus dem Knoten
selber.
2.
¶
H
v
ªº
’
¢
’
¡
"
Wenn
ein neues Blatt ist, ist Satz 2.1-2 wahr, wegen der Definition eines Wertes
und wegen der Prozedur Evaluate(
|i
). Sonst war das Attribut
9
v
zum Zeitpunkt
auch schon ’
¢
’ (weil Attribute sich nur von ’
¢
’ zu ’#’ oder von ’
¥
’ zu ’#’ ¨andern
k¨onnen).
(a)
M
ª
NM
Oç
und alle Nachfolger von
haben Werte mit Attributen ’
¢
’ oder ’#’
und
H
v
= maximum
(
x
H
v· ÷
údì
)(
L¨dii0Õ
8*O*
: F¨ur alle Teilb¨aume, deren Wurzeln
62 Das Cc2s-Verfahren
die S¨ohne von
sind, ist Satz 2.1-2/1 wahr. Wegen der Definition einer Be-
weisstrategie h¨alt die Behauptung auch f¨ur
.
(b)
¶
H
v
ªÊ¶
HLK
v
: Entweder wurde
¶
H
v
durch eine direkte Bewertung bestimmt, so daß
selber verantwortlich f¨ur die aktuelle UpdateValue-Phase ist. Dann erf¨ullt
der Spielbaum, der nur aus dem Knoten
besteht, den Satz. Ansonsten ist
Satz 2.1-2/1 erf¨ullt, weil wir den gleichen Teilbaum wie zum Zeitpunkt
nehmen k¨onnen.
3.
¶
H
v
ªý
’#’
¡
"
(a)
9
H
K
v
ª
’#’
ô
i.
¶
H
v
ª ¶
HK
v
: Satz 2.1-2/3 ist mit derselben Argumentation wie zum Zeit-
punkt
g¨ultig.
ii.
H
v
Ü
HK
v
:
H
v
k¨onnte zum einen durch eine direkte Bewertung abgesenkt
worden sein. Weil wir annehmen, daß
9
HK
v
ª
’#’ ist, liefert uns die Be-
wertung die G¨ultigkeit von Satz 2.1-2/3, n¨amlich durch den Spielbaum,
der nur aus dem Knoten
und sonst nichts besteht. Zum anderen kann
H
v
nur noch durch Zeile 10 abgesenkt worden sein. Das bedeutet, daß
M
£ª
PM
+ç
ist und alle Attribute der Nachfolger von
entweder ’
¢
’ oder ’#’
sind und daß
v
das Maximum
v· ÷Fú§ì
Q(
L¨dii0Õ
*
der
,µ¨di|0,Õ
ist. Weil
wir annehmen, daß Satz 2.1-2 f¨ur alle Knoten unterhalb von
gilt, gibt es
eine Teilh¨ulle unter
, deren Minimaxwert kleiner oder gleich
H
v
ist. Wir
wissen aber auch, daß es eine Teilh¨ulle geben muß, deren Minimaxwert
gr¨oßer oder gleich
H
K
v
ist, und somit erst recht
¥
H
v
ist, da
H
K
v
¥
H
v
ist.
Satz 2.1-2/3 gilt also auch f¨ur diesen Fall.
iii.
H
v
ûÜ
HLK
v
: Die Teilh¨ulle
v
des Suchbaums mit minimax(
v
)
¢Í v
ist
dieselbe wie zum Zeitpunkt
. Wir bekommen den anderen Teilbaum,
den wir noch brauchen, durch den Nachfolger, der den Wert von
domi-
niert, oder dadurch, daß
direkt bewertet worden war.
(b)
9
HLK
v
ª
’
¢
’
ô
i. Zeile 9 verursachte, daß
9
H
v
ª
’#’ ist: Wegen der Zeilen 2, 3 und 8 ist
M
³ª
RM
ç
, und alle Nachfolger von
haben Attribute
ì
S(
’
¢
’
’#’
*
, und
nur Nachfolger mit Attributen ’#’ haben Zahlwerte gr¨oßer oder gleich
HK
v
. Der gesuchte Teilbaum f¨ur Satz 2.1-2/1 zum Zeitpunkt
(bzw. falls
eine Bewertung von
die aktuelle UpdateValue-Phase ausgel¨ost hat, die
direkte Bewertung) liefert uns einen gew¨unschten Teilbaum. Derjenige
Nachfolger, der
H
v
bestimmt, liefert den anderen Teilbaum.
2.5 Beweise zu Kap. 2 63
ii. Zeile 5 hat verursacht, daß
9
H
v
ª
’#’ ist: Zeile 6 liefert einen Nachfolger
von
, der
H
v
bestimmt. Durch diesen Nachfolger bekommen wir den
einen Teilbaum. Weil es sogar einen Teilbaum unter
gibt, dessen Mi-
nimaxwert
¢¤
H
v
war und immer noch ist (so ein Teilbaum existiert ja
weiter), gibt es einen gew¨unschten Teilbaum, dessen Minimaxwert
¢
H
v
ist.
(c)
9
HK
v
ª
’
¥
’
ô
Dies impliziert, daß
9
H
v
durch Zeile 9 zu ’#’ gesetzt worden ist.
Außerdem folgt daraus, daß
M
ª
TM
ç
sein muß, daß es nur Nachfolger mit den
Attributen’
¢
’ und ’#’ geben kann und daß alle Nachfolger von
, die Zahlwer-
te
¢
H
K
v
haben, das Attribut ’
¢
’ besitzen. Alle Nachfolger zusammen stellen
sicher, daß ein Teilbaum
v
des Suchbaums existiert, dessen Minimaxwert
¢~
H
v
ist. Wir leiten den anderen Teilbaum vom Zeitpunkt
ab.
Zu Satz 2.1-2/4: Sei
ein beliebiger MAX-Knoten,
¶v
sein Wert. Sei
¶
IH
die Wertkomo-
nente eines Targets
, die von
¶v
unterst¨utzt wird.
Angenommen, der Knoten
werde durch
zu einem ALL-Knoten, und es gebe einen
Nachfolger von
, dessen Wert
¶
IH
widerspricht. Dann hat
¶
IH
die Form
’
¢
’
¡
"
. Der
Nachfolger, der
¶
IH
widerspricht hat die Form
’
¥
’
ï
8
oder
’#’
ï
8
mit
ïeû©¡
. In diesem
Fall w¨are aber
¶v
in den Zeilen 4-6 des Update-Operators (Abb. 2.8 auf Seite 34) auf
’#’
ï
8
gesetzt worden. Damit w¨urde
¶v¶
IH
nicht unterst¨utzen. Das ist ein Widerspruch
zur Annahme.
Nehmen wir nun an,
werde durch
zu einem CUT-Knoten, und die Werte aller Nachfol-
ger von
widersprechen
¶
IH
. Dann hat
¶
IH
die Form
’
¥
’
¡
"
und die Werte der Nachfolger
von
haben die Form
’
¢
’
ï
8
, oder
’#’
ï
8
mit
ï
U
¬¡
. Dann h¨atte aber UpdateValue
den Wert f¨ur
mit Hilfe der Zeilen 8-10 (Abb. 2.8) ermittelt. Dann h¨atte
¶v
den Wert
’#’
v
oder
’
¢
’
v
mit
v¢«ï
bekommen. Dann widerspr¨ache
¶
IH
aber
¶v
, was ein
Widerspruch zu der Annahme ist, daß
¶v¶
IH
unterst¨utzt. F¨ur MIN-Knoten gilt alles ana-
log.
Wenn die aktuelle UpdateValue-Phase die Wurzel von
Ó
erreicht, gilt Satz 2.1-2 f¨ur alle
Knoten.
Satz 2.2-6: Wenn unser Algorithmus terminiert, basiert das Ergebnis an der Wurzel auf
einer H¨ulle, die nach dem Minimax-Prinzip ausgewertet wurde. Ein beliebiger Minimax-
Algorithmus k¨ame zu dem gleichen Ergebnis, wenn er die gleiche H¨ulle untersuchte.
Beweis: Wir nehmen an, daß die Prozedur DetermineMove(
ii
) beendet worden ist. Das
bedeutet, daß alle Targets der Wurzelnachfolger erf¨ullt wurden. Die Targets der Nach-
64 Das Cc2s-Verfahren
folger der Nachfolger ebenfalls, u.s.w. Letztendlich gibt es eine Menge
V
von Knoten,
die durch Zeile 1 der Prozedur Cc2s(
|i
) erf¨ullt worden sind. Sei
ein Knoten aus
V
. Der Wert von
unterst¨utzte offenbar die Wertkomponente des dazugeh¨origen Tar-
gets, als Cc2s(
|i
)
zuletzt besucht hat. Der Wert von
ist entweder durch die Pro-
zedur Evaluate(
i|
) oder durch UpdateValue(
ii
) entstanden. In beiden F¨allen gibt es
einen Teilbaum unter
, dessen Minimaxwert den Wert von
rechtfertigt. Das garantiert
n¨amlich gerade Satz 2.1-2.
Satz 2.2-3: Wir nehmen an, daß der Spielbaum
Ó
, in dem wir einen besten Zug bestim-
men wollen, uniform in Tiefe und Breite ist. Dies bedeutet, daß alle Bl¨atter von
Ó
eine
Entfernung
Ô
zur Wurzel haben und daß alle inneren Knoten genau
Õ
Nachfolger besitzen.
Der Cc1s-Algorithmus muß mindestens
ÕMÚ
¯ÝÞ ¸ßµàF¿
Ûq¦ nÕö° ¨
¹
²â,Õ¾Ö
ÝÞ ¸ßàF¿
Ù
Bl¨atter von
Ó
bewerten, um den besten Zug zu ermitteln. Was die Anzahl zu bewertender Bl¨atter angeht,
ist dies offensichtlich optimal.
Beweis: Der g¨unstigste Fall tritt bei Cc1s(
i|
) ein, wenn alle Teilhypothesen ohne Fehler
verifiziert werden konnten. Das ist wegen der Konstruktion von Targets offensichtlich. In
diesem Fall spannt der Cc1s-Algorithmus gerade eine MAX-Strategie der Tiefe
Ô§°©¨
f¨ur
den besten Nachfolger auf und
Õa°s¨
MIN-Strategien f¨ur die ¨ubrigen.
Satz 2.2-5 Der Entscheidungszug, den Cc1s(
|i
) findet, basiert auf dem Minimaxwert
von
Ó
. D.h., jeder Minimax-Algorithmus kommt zu demselben Ergebnis.
Beweis: Wegen der Art und Weise, wie Targets aufgeteilt werden, liegen alle Bl¨atter der
endg¨ultigen Strategien mindestens in Ebene
Ô
. Weil
Ó
keine Knoten unterhalb der Tiefe
Ô
besitzt, befinden sich die Bl¨atter der von Cc1s(
i|
) erarbeiteten Strategien auch h¨ochstens
in Tiefe
Ô
. Satz 2.2-5 gilt dann wegen Satz 2.2-3.
Satz 2.2-4 Wenn
Ó
endlich ist (also insbesondere, wenn
Ó
ein Spielbaum mit fester Tiefe
und konstantem Verzweigungsgrad ist), beendet Cc1s(
ii
) seine Arbeit in endlicher Zeit.
Beweis: Nehmen wir an, DetermineMove(
ii
) habe eine Verifikationsphase initiiert und
Cc1s(
ii
) gibt das Ergebnis NOT OK zur Wurzel zur¨uck. Wenn ein Knoten
zu seinem
Vorg¨anger mit NOT OK zur¨uckkehrt, kann das nur zwei Gr¨unde haben. Entweder wurde
ein Sohn von
bewertet, oder einer der Nachfolger von
hat das Ergebnis NOT OK zu
zur¨uckgeliefert. Das kommt durch die Konstruktion von Targets zustande und dadurch,
daß die Prozedur Split(
ii
) nur gut geeigneten Knoten ein Target zuweist.
Weil jeder Knoten nur zweimal bewertet werden kann und weil es an den Bl¨attern von
Ó
keine Nachfolger gibt, die ein NOT OK zur¨uckliefern k¨onnen, terminiert Determine-
Move(
i|
) sp¨atestens, wenn alle Knoten von
Ó
zweimal bewertet wurden. F¨ur den Fall,
daß
Ó
uniform ist mit Tiefe
Ô
und dem Verzweigungsgrad
Õ
, terminiert DetermineMove()
nach h¨ochstens
®qâ
>
Ý
¸
Õ
H
Bewertungen und einer anschließenden Verifikationsphase.
Kapitel 3
Der Parallele Cc2s-Algorithmus
Im folgenden werde ein (Teil-)Problem durch einen Tupel (
,
v
) repr¨asentiert , bei dem
ein Knoten des Spielbaums
Ó«ªý0
<:
h
AW
N
CB
und
v
ein zu
geh¨origes Target ist. Gesucht
wird dabei ein Teilbaum von
Ó
mit Wurzel
, der die Anforderungen erf¨ullt, die durch
das Target
v
beschrieben werden.
Ein Aufruf der Prozedur Cc2s(
0 v
) liefert entweder einen solchen Teilbaum oder meldet,
daß kein solcher Teilbaum gefunden wurde.
In diesem Kapitel beschreiben wir die Parallelisierung des Cc2s-Algorithmus. Dabei nut-
zen wir aus, daß wir, ohne gegen¨uber der sequentiellen Variante unn¨otige Mehrarbeit zu
erzeugen, sehr viele Teilprobleme gleichzeitig bearbeiten k¨onnten, wenn jedes gebildete
Target erf¨ullt w¨urde. Das entspricht zwar nicht der Realit¨at, aber immerhin werden in der
Praxis die meisten Targets erf¨ullt.
?
≥
X
v
t = ((’ ’,3) ≤
Y
v
t = ((’ ’,3)
vv
v.1v.1 v.2v.2 v.3v.3
CUT−Knoten ALL−Knoten
v.1 ≥
X
t = ((’
≥
X
t = ((’
v.2
t = ((’
v.3
t = ((’
v.2
t = ((’
v.1 ’,3),2,2)
≤
Y
’,3),2,2)
≤
Y
’,3),2,2)
≤
Y
,3,2)
’,3),2,1)
’,3),2,1)
,3,2)
’,3)
≥
(’
’,3)
≥
(’
’,3)
≥
(’ ’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤
a) b)
Abb. 3.1: Parallelit¨at
Um in Abbildung 3.1b) das Target
v
zu erf¨ullen, m¨ussen offenbar die Targets
v·¹¸ ii v·
=
66 Der Parallele Cc2s-Algorithmus
alle erf¨ullt werden. Diese Targets
v·¹¸ ii0 v·
=
werden zur parallelen Verarbeitung freigege-
ben. CUT-Knoten bieten ebenfalls Parallelit¨at, wenn zwei oder mehr Nachfolger Targets
bekommen (Abbildung 3.1a)).
3.1 Hardware
F¨ur die Experimente, die wir mit dem parallelen Cc2s-Verfahren in der Anwendung
Schach gemacht haben, konnten wir verschiedene Rechnernetze und Parallelrechnerar-
chitekturen nutzen.
þ
Die Zukunft der Parallelrechner verschmilzt mit der der Workstationcluster. Die ra-
sante Entwicklung der Standardprozessoren bei PCs und Workstations machen es
erforderlich, auch beim Bau von Parallelrechnern auf Standardprozessoren wie z.B.
Pentiumprozessoren zur¨uckzugreifen.
Abb. 3.2: Die Topologie des hpcLine-Rechners
3.1 Hardware 67
Der hpcLine-Rechner der Universit¨at Paderborn besteht aus 96 Siemens Primergy
Rechnerknoten, die durch ein SCI-Netzwerk als 2D-Torus verbunden sind. Jeder
einzelne Knoten besitzt 512 MByte Hauptspeicher, eine lokale 4 GByte Festplatte
und zwei Intel Pentium II Prozessoren mit je 450MHz.
Mit Hilfe von 96 Scali/Dolphin PCI/SCI Interfacekarten mit 500 MByte/s SCI-Link
Bandweite erreicht der Gesamtrechner 86.4 GFlop/s Peakperformance. SCI (Sca-
lable Coherent Interface) ist ein IEEE Standard (IEEE Std. 1596-1992,[HH99]),
der es erm¨oglichen soll, Rechnernetze mit sehr niedriger Latenz und sehr hohen
Bandbreiten zu realisieren. Die Basiseinheiten eines SCI-Netzwerkes sind gerich-
tete Ringe (Abb. 3.3a)) und Rechenknoten. Ein Ring verbindet mehrere Rechenk-
noten durch unidirektionale Verbindungsst¨ucke.
Mittlerweile gibt es auch f¨ur die SCI-Technologie Router (Abb. 3.3c)), die den Auf-
bau gr¨oßerer Netze mit besseren Topologien erm¨oglichen. Der hpcLine-Cluster der
Universit¨at Paderborn besteht aus einem zweidimensionalen 12x8 Torus, bei dem
die horizontalen und die vertikalen Verbindungen die erw¨ahnten Ringe sind.
Sende−
Queue
Em−
pfangs−
queue
Bypass FIFO
a) Ring b) Interface c) Router
Abb. 3.3: SCI-Elemente
Eine Kommunikationstransaktion besteht aus zwei Teilen. Zum einen aus der Nach-
richt, die von einem Prozessor
Z
¸
zu einem Prozessor
Z
¿
geschickt werden soll, und
aus einer R¨uckmeldung von Prozessor
Z
¿
an
Z
¸
, daß die Nachricht auch wirklich
angekommen ist. D.h., jede Nachricht muß einmal im Kreis wandern. Es gibt kei-
ne direkte Flußkontrolle zwischen benachbarten Prozessoren. Wollen mehrere Paa-
re von Rechnern gleichzeitig kommunizieren, m¨ussen sie sich die Bandbreite des
68 Der Parallele Cc2s-Algorithmus
Rings teilen. Durch die Einfachheit des Ansatzes, die den Einsatz von sehr schnel-
ler Verbindungshardware und sehr einfachen Protokollen erm¨oglicht, k¨onnen SCI
Workstations im Rechnerverbund Leistungsdaten erreichen, wie sie bisher Parallel-
rechnern vorbehalten waren.
Wir haben f¨ur unsere Experimente fast ausschließlich diesen hpcLine-Workstation-
cluster verwendet.
þ
Der CC-48 Rechner besitzt 48 Rechenknoten, jeder davon ist mit einem PowerPC
Prozessor MPC604 mit 133 MHz ausgestattet. Das Verbindungsnetzwerk besteht
aus einem sogenannten ’fat mesh of clos’, wie es in Abbildung 3.4 zu sehen ist. Die
maximale Linkgeschwindigkeit betr¨agt 1Gbit/s. Auch bei diesem Rechner bildet
jede Verbindung zwischen Prozessoren und Routern eine Punkt-zu-Punkt Verbin-
dung.
Routermodule
Rechenprozessoren
Abb. 3.4: Die Topologie des CC-48 Rechners
þ
Der GCel ist der ¨alteste Rechner, den wir f¨ur Experimente benutzt haben. Es handelt
sich dabei um 1024 T805 Prozessoren (30MHz), die als zweidimensionales Gitter
angeordnet sind. Ein Gitter
Óe
1[
å
ª
;Z
Ò
A\
%e
ist definiert durch eine Menge
Z
von Prozessoren und einer Menge
\
%
von Links (Leitungen), f¨ur die folgender
Zusammenhang gilt:
Z
ª
T(
½nú0
^]
C
-_
¹Æ ¢sú
`a[
ÒÆ3¢
b]c
áå
*
3.2 Bekannte parallele Spielbaumsuchverfahren 69
und
\
%
óª
S((
½nú0
^]
C
7P´ú
ç
^]
ç
C*__
úO°(ú
ç
_
<¦
T_ ]
°
]
ç
_
5ª¬¨
*
L
(0,0) (0,1) (0,2)
(1,0) (1,1,) (1,2)
(2,0) (2,1) (2,2)
Abb. 3.5: Ein 3x3 - Gitter
Zwei Prozessoren, die durch einen Link verbunden sind, haben eine Punkt-zu-
Punkt Verbindung zur Verf¨ugung. Die Links erm¨oglichen eine Kommunikations-
geschwindigkeit von 20 MBit/s.
3.2 Bekannte parallele Spielbaumsuchverfahren
3.2.1 Schnelle Zugerzeugung und Bewertung
Bei Schachmaschinenwie BELLE [CT82] oderDEEP THOUGHT [Hsu90] (sp¨ater DEEP
BLUE) findet man feingranulare Parallelit¨at, die auf Hardwareebene realisiert wird. Man
kann verschiedene Kriterien einer Stellungsbewertung gleichzeitig ausf¨uhren oder mehre-
re Z¨uge auf einmal erzeugen. Da diese beiden Aufgaben einen großen Anteil der Gesamt-
rechenzeit verbrauchen, wird eine erhebliche Beschleunigung des Schachprogramms er-
reicht. Das Programm CRAY BLITZ nutzte die Vektoreigenschaften des Cray-Prozessors
zur schnellen Zugerzeugung und Bewertung aus [HGN85].
3.2.2 Parallele Fenstersuche
Baudet beschreibt eine Suche [Bau78], bei der verschiedene Prozessoren den gegebenen
Spielbaum mit verschiedenen
-Startfenstern durchlaufen. Er ermittelte eine maximale
Beschleunigung von 5 bis 6 auf zuf¨allig generierten B¨aumen. Wenn man bedenkt, wie
nah z.B. beim Schach die tats¨achlich durchsuchten B¨aume an den sog. minimalen B¨au-
men (das sind die Teilb¨aume, die jedes Spielbaumsuchverfahren mindestens durchsuchen
muß) liegen, wird klar, daß f¨ur Spielb¨aume von Anwendungen mit dieser Technik keine
Beschleunigung erreicht werden kann:
70 Der Parallele Cc2s-Algorithmus
Im bestm¨oglichen Fall besucht ein
-Algorithmus in einem Spielbaum mit konstantem
Verzweigungsgrad
Õ
und Tiefe
Õ
Ú
H
àF¿
Û
¦ Õ
Ö
H
àF¿
Ù
°s¨
Bl¨atter des Spielbaums. Eine parallele Fenstersuche mit
[
Prozessoren und
[
verschiede-
nen Fenstern besucht mindestens
d[
°Ü¨
¹
âPÕ
Ö
H
àF¿
Ù
e fhg i
j
Þ¸
fehlschlagende Suchen
¦ Õ
Ú
H
àF¿
Û
¦ Õ
Ö
H
àF¿
Ù
°s¨
e fhg i
bestm¨oglicher Aufwand des
[
-Algorithmus
Bl¨atter.
3.2.3 Spielbaumzerlegung
Alle erfolgreichen, vor dieser Arbeit bekannten parallelen Spielbaumsuchverfahren beru-
hen auf Varianten des
Ò
-Algorithmus und einer Zerlegung des Spielbaums.
Die ersten Versuche, den zu durchsuchenden Spielbaum zu zerlegen, bestanden darin, den
Spielbaum in einen Prozessorbaum einzubetten. Mit 27 Prozessoren erreichten Finkel und
Fishburn 1982 [FF82] einen Speedup von 5.31 in einem Prozessorbaum der Tiefe 3 und
Breite 3.
1982 ver¨offentlichten Marsland und Campbell [MC82] den PV-Split-Algorithmus. Dabei
werden rekursiv entlang der ¨außerst linken Variante erst alle Prozessoren im Teilbaum
unter der linken Variante eingesetzt, bevor nach Abarbeitung dieses linken Teilbaums al-
le Prozessoren in allen rechten Teilb¨aumen gleichzeitig eingesetzt werden. Der PV-Split-
Algorithmus fand breites Interesse in der Forschung [Sch89a] [HS89] und bildet die Basis
f¨ur die meisten tats¨achlichen Implementierungen paralleler Spielbaumsuchen. Das Fehlen
dynamischer Lastverteilung f¨uhrte dazu, daß die maximal erreichte Beschleunigung von
5 bis 6 nicht ¨uberschritten werden konnte. Newborn [New88] erreichte aber immerhin
auf 8 Prozessoren eine Beschleunigung von 5.03 und Marsland, Olafsson und Schaeffer
[MOS86] erreichten in ihrem Schachprogramm PHOENIX eine Beschleunigung von 3.75
auf 4 Prozessoren.
Den entscheidenden Durchbruch f¨ur die Spielbaumzerlegung brachte die dynamische
Lastverteilung. 1988 stellen Ferguson und Korf [FK88] einen Algorithmus vor, der dy-
namische Lastverteilung erm¨oglicht, indem der Einsatz von Parallelit¨at an allen Knoten
erlaubt wird, an denen schon eine Grenze errechnet wurde. Sie haben das Verfahren in
einem Dameprogramm implementiert.
Gleichzeitig wurde von Feldmann und anderen [FMMV90] das Young-Brothers-Wait-
Concept (YBWC) entwickelt und in einem Schachprogramm ohne moderne Zugsortie-
3.2 Bekannte parallele Spielbaumsuchverfahren 71
rungsheuristiken eingesetzt. Beim YBWC wird an jedem Knoten der Einsatz von Paral-
lelit¨at so lange verboten, bis der erste Nachfolger fertig bearbeitet ist. Dieser Nachfolger
liefert entweder einen Cutoff, oder man geht davon aus, daß es sich um einen Knoten
handelt, an dem kein Cutoff stattfinden wird und erlaubt die parallele Bearbeitung der
restlichen Nachfolger. Das eigentliche Loadbalancing wird durch einen Workstealing-
Mechanismus erreicht.
In den folgenden Jahren wurde das YBWC weiterentwickelt und im Schachprogramm
ZUGZWANG eingesetzt. Das Programm besaß eine sehr gute Zugsortierungsheuristik,
und es wurden damit Speedups von 126 auf 256 Prozessoren und 344 auf 1024 Prozesso-
ren erreicht [FMM91] [Fel93].
In der Zwischenzeit implementierten Otto und Felten [FO88] einen dynamischen Spiel-
baumsuchalgorithmus im Schachprogramm WAYCOOL. Ihr Algorithmus setzt Paralle-
lit¨at in Abh¨angigkeit von Eintr¨agen der Transpositionstabellen ein. Parallelit¨at darf an
Knoten, f¨ur die es einen Transpositionstabelleneintrag gibt, erst eingesetzt werden, wenn
die Suche unter dem Zug aus der Tabelle fertig ist. Im Prinzip handelt es sich hierbei um
eine spezielle Variante des YBWC.
1990 stellte Hsu [Hsu90] einen zentralistischen Ansatz vor, den Spielbaum zu zerlegen.
Ein sehr schneller Server bearbeitet einen Spielbaum bis zu einer recht geringen Such-
tiefe
. Alle Knoten aus Ebene
werden aufgeteilt in Knoten des minimalen Baums (das
sind die Knoten, die vom
-Algorithmus auf jeden Fall abgesucht werden m¨ussen) und
die restlichen. Daraus werden Priorit¨aten abgeleitet, in welcher Reihenfolge die Knoten
zu untersuchen sind. Jeder Knoten wird dann von der Deep Blue Hardware mit einer
weiteren Tiefe
ç
untersucht. In Simulationen gelang Hsu eine Beschleunigung von 350
auf 1000 Prozessoren. Leider ist nie ¨offentlich bekannt geworden, wie gut die tats¨achli-
chen Speedups bei dem Schachprogramm Deep Blue gewesen sind. Immerhin muß man
ber¨ucksichtigen, daß das Programm bereits 1997 den zu der Zeit als st¨arksten Spieler der
Welt geltenden G. Kasparov in einem 6-Spiele Turnier besiegt hat.
Seit Anfang der neunziger Jahre wird am Massachusetts Institute of Technology (MIT) die
auf ANSI-C basierende Programmiersprache CILK [BJK
k
95] entwickelt. CILK wurde zu
dem Zweck entwickelt, die Programmierung von verteilten Anwendungen zu erleichtern.
Sie nutzt Parallelit¨at auf der Ebene von Prozeduraufrufen und Threads, und die Lastver-
teilung wird durch Workstealing realisiert. Im Zuge der Bewertung von CILK wurden
drei sehr gute Schachprogramme entwickelt: StarTech,
Sokrates und Cilkchess. Letzte-
res verwendet eine parallele Version des von A. Plaat vorgestellten MTD(f)-Algorithmus
[Pla93]. Dieser wiederum verwendet bei der Suche Aufrufe eines
Ò
-Algorithmus mit
72 Der Parallele Cc2s-Algorithmus
minimalem Startfenster. Die Parallelisierung des MTD(f)-Algorithmus reduziert sich so-
mit auf die Parallelisierung eines
Ò
-Algorithmus.
3.3 Spielbaumzerlegung beim Cc2s-Algorithmus
3.3.1 Verwertung von Parallelit¨
at
Die im Prinzip zur Verf¨ugung stehende Rechenleistung eines Parallelrechners oder eines
Rechnerverbundes l¨aßt sich nur in eine h¨ohere Leistung und somit in eine verbesserte
Entscheidungsqualit¨atumm¨unzen, wenn es gelingt, die im Cc2s-Algorithmus vorhandene
Parallelit¨at sinnvoll zu nutzen.
Wenn beim Cc2s-Algorithmus das Target
v
eines Knotens
auf mehrere Nachfolger auf-
geteilt wird, entstehen neue Teilprobleme, die im Prinzip gleichzeitig bearbeitet werden
k¨onnen. Diese neuenTeilprobleme werdeninderparallelen Versiondes Cc2s-Algorithmus
an entfernte Prozessoren gesendet und dort verarbeitet. (Ein Prozessor
Z
÷
ist entfernt von
einem Prozessor
Zml
, wenn
ú
on
ª
a]
ist.)
Auf diese Weise bekommen wir einen parallelen Algorithmus, dessen Effizienz von den
folgenden Faktoren abh¨angt:
1. Suchoverhead, der dadurch entsteht, daß Targets nicht erf¨ullt wurden:
Das folgende Beispiel zeigt, daß eine parallele Bearbeitung von Teilproblemen dazu
f¨uhren kann, daß der parallele Suchalgorithmus andere Ergebnisse als der sequen-
tielle erzielt.
a) b) c)v
v.1 v.2
v.1.1 v.1.2
v.1.3 v.1.3 v.1.3
v.1.2 v.1.2
v.1.1v.1.1
v.2
v.2 v.1v.1
v v
’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤
’,3) (’≤ ’,3) (’≤
’,3) (’≤
(’#
’,8)
(’#
’,4) (’#
’,5)
(’≤
’,4)
(’≤
’,4) (’≤
’,4) (’#
’,4) (’#
’,5) (’#
’,8)
(’#
’,8)
Abb. 3.6: Berechnungsausschnitt
3.3 Spielbaumzerlegung beim Cc2s-Algorithmus 73
Betrachten wir dazu folgendes Szenario: Sei
der Knoten in Abbildung 3.6a), der
ein Target
vªÌ
’
¢
’
Ap
Resttiefe
ƽ
Conspiracy Number
®
h
bekommen hat. Der
einzige Nachfolger von
, der dazu beitragen kann, daß
v
erf¨ullt wird, ist
,µ¨
. Dort
werden die Targets
v·¹¸·¹¸ ªb v·¹¸· ¿ ªb v·¹¸·
=
Oªý
’
¢
’
Ap
ÆÅ®
?
erzeugt. Der Algorithmus
untersucht als erstes den Knoten
¨¾¨
und er weise aufgrund weiterer Berechnun-
gen unter
¨¾¨
dem Knoten
,µ¨¾¨
den Wert
’#’
¼
zu. Es ist nun so, daß
v·¹¸·¹¸
und
damit
v
nicht erf¨ullt werden k¨onnen. Außerdem bekommt
,µ¨
den Wert
’#’
¼
und
beh¨alt den Wert
’
¢
’
Ap
. Wir haben die Situation von Abbildung 3.6b) er-
reicht. Der Cc2s-Algorithmus versucht nun, das Target
v
mit Hilfe des Knotens
,¯®
zu erf¨ullen. Wenn eine Bewertung von
,®
aber zu dem Wert
¶v· ¿ ª
’#’
¼
f¨uhrt,
wird auch
¶v
zu
’#’
¼
. Es ist nat¨urlich im folgenden Verlauf der Berechnungen
m¨oglich, daß der Knoten
das Target
vª
’
¢
’
¼
ÆÅ®
?
zugewiesen bekommt.
Die Knoten
¨
und
,¯®
sorgen dann daf¨ur, daß
v
erf¨ullt wird.
Etwas ganz anderes kann der parallelen Version des Cc2s-Algorithmus passieren:
Gehen wir wieder von der Situation der Abbildung 3.6a) aus. Alles l¨auft wie ge-
habt ab, bis die Targets
v·¹¸·¹¸
,
v·¹¸· ¿
und
v·¹¸·
=
den Knoten
,¨¾µ¨
,
,¨¾®
und
¨¾
qp
zugewiesen worden sind. Der Algorithmus versuche nun gleichzeitig
v·¹¸·¹¸
und
v·¹¸· ¿
zu erf¨ullen. Die Arbeit, die unterhalb von
,¯®
geleistet wird, kann aber dazu
f¨uhren, daß
,¨¾¯®
und damit auch
¨
den Wert
’#’
»
h
erhalten (Abbildung 3.6c)).
Wenn unter diesen Vorbedingungen
im Verlauf weiterer Berechnungen das Target
vª 0
’
¢
’
¼
7ÆÅ®
h
bekommt, steht der Knoten
,®
nicht mehr als Helfer bei der
Erf¨ullung des Targets
v
zur Verf¨ugung.
Im Extremfall kommt der der sequentielle Cc2s-Algorithmus schnell zu einem Er-
gebnis, w¨ahrend die parallele Version erst das gesamte Spiel untersucht. Letzteres
heißt f¨ur die Praxis, daß m¨oglicherweise keine selbst¨andige Terminierung in akzep-
tabler Zeit stattfindet. Es kann allerdings auch der umgekehrte Fall eintreten, daß
die parallele Verarbeitung den Rechenprozeß verk¨urzt. In dem Spezialfall, daß bei
einer sequentiellen Berechnung alle Targets erf¨ullt werden, untersuchen sequentiel-
ler und paralleler Cc2s-Algorithmus dieselben Knoten.
Anmerkung: Solch große Laufzeitunterschiede zwischen der sequentiellen und der
parallelen Version treten bei den bisher bekannten Varianten paralleler Spielbaum-
suche nicht auf. Im schlimmsten Fall allerdings durchsucht jeder bisher bekannte
parallele
-Algorithmus alle Knoten bis zur vorgegebenen Tiefe, w¨ahrend der se-
quentielle
-Algorithmus lediglich den f¨ur ihn n¨otigen minimalen Baum (der be-
steht aus den Knoten, die jeder Algorithmus mindestens untersuchen muß) durch-
sucht. F¨ur Anwendungen bedeutet das dann aber ebenfalls, daß eine selbst¨andige
Terminierung in vern¨unftiger Zeit nicht zustande kommt.
74 Der Parallele Cc2s-Algorithmus
2. Verf¨ugbarkeit von gleichzeitig bearbeitbaren Teilproblemen:
Wenn nicht zu jedem Zeitpunkt gen¨ugend parallel verarbeitbare Teilprobleme zur
Verf¨ugung stehen, sinkt die Prozessorauslastung.
3. Kommunikationsgeschwindigkeit:
Eine wichtige Rolle wird es spielen, wieviel Zeit eine Nachricht ben¨otigt, um von
einem zu einem anderen Prozessor zu gelangen. Die Zeit, die die Beschreibung
eines Teilproblems braucht, um zu einem arbeitslosen Prozessor zu gelangen, senkt
die Prozessorauslastung. Die Zeit, die eine Nachricht braucht, um einen Prozessor
davon zu unterrichten, daß seine derzeitige Arbeit ¨uberfl¨ussig ist, erh¨oht den Such-
overhead.
4. Zeit, die f¨ur die Verarbeitung von Nachrichten ben¨otigt wird:
Nachrichten, die im Prozessornetz ausgetauscht werden, m¨ussen auch verarbeitet
werden. Die Zeit, die daf¨ur ben¨otigt wird, steht der eigentlichen Anwendung nicht
mehr f¨ur eigene Berechnungen zur Verf¨ugung.
5. Scheduling Zeiten:
Wir werden daf¨ur sorgenm¨ussen, daß jeder Prozessor mehrereTeilprobleme gleich-
zeitig halten und verwalten kann. Die Verwaltung der Teilprobleme kostet ebenfalls
Zeit.
3.3.2 Designentscheidungen bei der Lastverteilung
Ausnutzung vs. Zerschlagung der Problemstruktur
Um die Gesamtlast im Prozessornetzwerk zu verteilen, gibt es zwei grunds¨atzlich ge-
gens¨atzliche Ans¨atze. Zum einen kann man versuchen, die im jeweiligen Problem vorhan-
dene Struktur auszunutzen. In unserem Fall hieße das, man kann versuchen, die Baum-
struktur des Zweipersonen-Spiels zu nutzen und eine Einbettung des Baumes in das Pro-
zessornetzwerk zu berechnen.Allerdings ist der entstehende Spielbaumsehr unregelm¨aßig
und seine Form nicht vorhersehbar.
Aussichtsreicher erscheint es, die Struktur desProblems zu zerschlagen. Zudiesem Zweck
l¨aßt man eine mehr oder weniger zuf¨allige Einbettung der Spielbaumknoten auf Prozes-
soren zu. Das ist zum einen durch Workstealing m¨oglich, bei dem sich arbeitslose Pro-
zessoren um Arbeit eines zuf¨allig ausgew¨ahlten Arbeitgeberkandidaten bem¨uhen. Zum
anderen kann ein mit Arbeit gut ausgelasteter Prozessor Teilprobleme an zuf¨allig aus-
gew¨ahlte Auftragnehmer versenden. Statt Arbeitnehmer zuf¨allig auszuw¨ahlen, kann man
die Arbeitnehmer auch anhand einer Hashfunktion bestimmen.
3.3 Spielbaumzerlegung beim Cc2s-Algorithmus 75
Der Nachteil dieser Methode ist, daß Baumkanten ¨uber mehrere Hardwarekanten ge-
streckt werden. Man gewinnt allerdings im allgemeinen eine f¨ur die Praxis ausreichende,
gleichm¨aßige Auslastung der Prozessoren.
Migration vs. feste Plazierung von Knoten
Auch bei einer vom Zufall beeinflußten oder bei einer von einer Hashfunktion gesteu-
erten Lastverteilung muß man einige Cc2s-spezifische Besonderheiten ber¨ucksichtigen.
Eine der auffallendsten und unangenehmsten Eigenschaften des Cc2s-Algorithmus ist es,
daß Knoten, die erzeugt und untersucht worden sind, im Speicher des Rechners abgelegt
werden m¨ussen und nicht ’vergessen’ werden d¨urfen. Andernfalls w¨urde die im vorigen
Kapitel vorgestellte Terminierungsargumentation nicht mehr gelten. D.h. aber auch, daß
man sich beim verteilten Cc2s-Algorithmus entscheiden muß, ob Knoten, die von einem
Prozessor
Z
erzeugt wurden, auch dort bleiben sollen, oder ob man erlaubt, daß Knoten
von einem Prozessor auf einen anderen verlegt werden. Man spricht dann von ’Migrati-
on’. Auf jeden Fall m¨ussen Prozessoren, die auf einen Knoten des Prozessors
Z
zugreifen
wollen, das ¨uber
Z
erledigen.
M¨ochte man Migration in ein paralleles Cc2s-Verfahren implementieren, bieten sich zwei
M¨oglichkeiten an. Entweder migriert man ganze Teilb¨aume, oder man migriert einen ein-
zelnen Knoten
und muß dann die Baumstruktur, in die
integriert war, wieder herstel-
len. Wir sind zu dem Schluß gekommen, daß beide Varianten der Migration zu kostspielig
sind und haben uns deshalb entschlossen, auf Migration komplett zu verzichten.
Senderinitiierte Lastverteilung vs. Workstealing
Eine andere Entscheidung, die gef¨allt werden muß, betrifft die Frage, wie eine Arbeitge-
ber/Arbeitnehmer-Beziehung aufgebaut wird. Wir hatten uns zun¨achst daf¨ur entschieden,
einen Workstealing Algorithmus zu implementieren. Beim Workstealing m¨ussen sich Pro-
zessoren, die keine sinnvolle Arbeit leisten, um Arbeit bem¨uhen. ¨
Ublicherweise senden
zu dem Zweck arbeitslose Prozessoren Bitten um Arbeit in der Hoffnung ins Netz, daß ein
arbeitender Prozessor die Nachricht auff¨angt und ein Teilproblem zur¨ucksendet. Dieses
Vorgehen bietet den enormen Vorteil, daß Prozessoren, die unter Last laufen, wenig kom-
munizieren m¨ussen, und diejenigen Prozessoren, die leer laufen, viel kommunizieren. In
einer fr¨uhen Implementierung des Controlled Conspiracy Number Verfahrens in einem
Schachprogramm minderer Qualit¨at erreichten wir zwar gute Speedups auf dem GCel-
Rechner, mußten aber schon damals erkennen, daß es leider zu Problemen bez¨uglich der
Verf¨ugbarkeit verteilbarer Arbeit [LR96] kommt.
76 Der Parallele Cc2s-Algorithmus
Eine andere M¨oglichkeit, eine Arbeitnehmer/Arbeitgeber-Beziehung aufzubauen besteht
darin, verteilbareTeilaufgaben an zuf¨allig ausgew¨ahlte Prozessoren zu senden.Man spricht
hier von senderinitiierter Lastverteilung. In Zeiten, in denen wenig Last im Netz vorhan-
den ist, werden die zuf¨allig verschickten Teilprobleme mit hoher Wahrscheinlichkeit zu
einem arbeitslosen Prozessor gesendet. Der Vorteil dieser Methode ist, daß sich die vor-
handene Gesamtlast gleichm¨aßig im Netzwerk verteilt und ein Prozessor
Z
keine Pro-
bleme bei der Lastverteilung damit bekommt, daß viele Teilprobleme, die eigentlich f¨ur
externe Bearbeitung geeignet w¨aren nicht abgegeben werden k¨onnen, weil die potentiell
abgebbaren Knoten schon einmal auf
Z
untersucht worden sind und bereits
Z
fest zu-
geordnet sind [LR96]. Nachteilig ist die Tatsache, daß bei hoher Gesamtlast weiterhin
Teilprobleme abgespalten werden (was Zeit kostet), und deren Ortswechsel das Netzwerk
belasten.
3.4 Senderinitiierte parallele Cc2s-Suche
3.4.1 Grundversion
Datenstrukturen und Speicherverwaltung
Unser paralleler Cc2s-Algorithmus braucht die M¨oglichkeit, Teilproblemeabzugeben und
Ergebnisse, die auf entfernten Prozessorknoten berechnet wurden, zu integrieren. Zu die-
sem Zweck wird die Rekursion, deren Verwaltung im sequentiellen Fall (Abb. 2.7, Seite
32) im wesentlichen vom Systemstack ¨ubernommen wurde, aufgehoben. Die parallele
Variante wird die Verwaltung der Rekursion selber vornehmen.
Definition 3.4-12 (Aktuelle Variante)
Die Prozedur Cc2s(
, v
) bearbeite einen Knoten
èì
r:
eines Spielbaums
Ó ª¬
;:
,
W
N
,
s
~
mit Wurzel
t
. Dann gibt es einen Pfad von der Wurzel
t
zum Knoten
. Diese Folge von
Knoten
;t
)ªÊ
¸
¿
i|i|
Ý
ª
nennen wir die aktuelle Variante der Prozedur Cc2s(
i|
)
zu einem Zeitpunkt
u
.
Ô
nennen wir die Ebene, in der sich der Suchalgorithmus befindet.
ä
Definition 3.4-13 (Bearbeitungszustand eines Problems)
Sei
Ó ª
;:
d
GW
N
7
As
~
ein Spielbaum, und sei die Knotenfolge
n
¸
¿
iii<
Ý
eine aktu-
elle Variante der Prozedur Cc2s(
ii
). Sei
v
die Menge der m¨oglichen Werte und
die
Menge der Targets. Dann beschreibt die Folge
´
¸
¸
¸
iii7P´
Ý
0
Ý
Ý
6
/ìî
;v wxNw
(
START, REKURSION, WARTET,KEINE ADRESSE
*
Ý
denaktuellen Bearbeitungszu-
stand des Problems, das gerade vom Cc2s-Algorithmus untersucht wird. Dabei sind
¸
3.4 Senderinitiierte parallele Cc2s-Suche 77
ii<x
Ý
Knoten,
¸
i|i|
Ý
dazugeh¨orige Targets und
¸
iii<
Ý
Zust¨ande (im Grunde Pro-
grammzeilennummern), in denen sich der Cc2s-Algorithmus in den Ebenen
¨
bis
Ô
befin-
det.
ä
Task
Teilbaum
Liste von Tasks
Code Zustand
Abb. 3.7: Datenstrukturen
Jeder Prozessor ist in der Lage, viele Probleme zur gleichen Zeit zu verwalten. Um Dead-
locks zu vermeiden bzw. beheben zu k¨onnen, speichert ein Prozessor nicht nur die Pro-
blembeschreibungen selber ab, sondern auch deren Bearbeitungszustand.
Eine Kombination
;Z
H
Ay
e
Az
P
CV
%
von Problembeschreibung
Z
, Bearbeitungszustand
y
, ei-
nem Erkennungscode
z
und einem Spielbaum
Ó
, dessen Wurzel dem Knoten der Pro-
blembeschreibung entspricht, nennen wir einen ’Task’. Mehrere Tasks werden in einer
Liste verwaltet (Abbildung 3.7).
Bearbeitung eines Tasks
Es darf immer nur ein Task aktiv sein, d.h. gerade von einem Prozessor bearbeitet wer-
den. Ein Scheduler verwaltet eine Liste von Tasks, die er zu bestimmten Zeitpunkten
auswechseln darf. Er darf dies zu Beginn und zum Ende eines Cc2s-Schrittes, weil sich
der Cc2s-Algorithmus des aktiven Tasks zu diesen Zeitpunkten in einem wohldefinierten
Zustand befindet. Damit ergibt sich die in Abbildung 3.8 gezeigte Prozeßstruktur. Beim
parallelen Cc2s-Algorithmus werden Tasks normalerweise nicht deaktiviert. Nur, wenn
ein Task nicht weiterarbeiten kann, weil er nur noch auf Antworten anderer Prozessoren
wartet, wird er ausgegliedert, und es wird der vorderste in der Taskliste gefundene, nicht
wartende Task aktiviert.
Ein Prozessor, der ein Teilproblem zur Bearbeitung erhalten hat, ist f¨ur die korrekte Be-
arbeitung dieses Teilproblems verantwortlich. Er initialisiert sein Teilproblem (Abb. 3.9,
78 Der Parallele Cc2s-Algorithmus
Arbeite:
solange nicht terminiert
begin
end;
Taskwahl
Kommunikation
Cc2s−Schritt
Message Passing (MPI/PVM)
Abb. 3.8: Prozeßstruktur
Z. 1ff) und beginnt, wie im sequentiellen Fall eine Suche auf dem erhaltenen Knoten des
Spielbaums.
bool pCc2s(node
o
, target
};v/psrru[vPwLvi{0wDv5wF5vj{
)
x
Pseudorekursiver Cc2s-Algorithmus
|
0int
{
;
3A3A3
1
{
:= 0;
2
o
¸
:= v;
x
Wurzel
|
des Spielbaums
|
3
}
¸
v
pb};v
;
4
y
¸
:= START;
5
x
Iteriere bis Wurzelstellung gel¨ost.
|
6while
{
~}
do
7Cc2s step();
6return
;
Abb. 3.9: Iterationsschleife des parallelen Cc2s-Algorithmus
Die in Abb. 3.9 (Z. 6ff) dargestellte Kontrollschleife ersetzt zusammen mit den Zeilen
0a-0c,8a-8c,10b und 14a der Cc2s step(
ii
)-Prozedur (Abb. 3.10) die vom System ver-
waltete Rekursion des sequentiellen Cc2s-Algorithmus. Die fett dargestellten Zeilen sind
zur sequentiellen Suchprozedur hinzugekommen.
Geschwisterknoten
¸iii<
j
der aktuellen Variante werden von der Prozedur Split(
ii
)
in Zeile 6 (Abb. 3.10) mit Targets versehen. Diese Knoten mitsamt den dazugeh¨origen
3.4 Senderinitiierte parallele Cc2s-Suche 79
Cc2s step()
x
Es sei
r o
¸
w
3A3A3
wo
Ý
{
die aktuelle Variante,
|
x
es seien
}
l
v
w
d
iw
3A3A3
w
{
M
die Targets in den Ebenen
und
|
x
es seien
l
w
^/
l
w
d
}
¾w
3A3A3
w
{
M
Hilfsvariablen,
die Anzahl der Prozessoren
|
0a if
y
Ý
= REKURSION springe zu Zeile 9.
0b if
y
Ý
= KEINE ADRESSE springe zu Zeile 6f.
0c if
y
Ý
= WARTET springe zu Zeile 12b.
0d Behandle Inkonsistenzen(
,
);
1if (
v
×
p
U}
and
v
×
) or
r o
Ý
{
A
Pp
}
^
ÝÞ ¸
p
OK;
{
qp
U{~
; return;
2
Ý
:= NOT OK;
3while
Ý
= NOT OK do
3b befreie alle Nachfolger von
o
von ihren Aufgaben;
4PartialExpansion(
o
Ý
w}
Ý
v
);
5if not OnTarget(
o
Ý
w}
Ý
v
)
ÝÞ ¸
p
NOT OK;
{
²p
U{~
; return;
6Split(
o
Ý
w}wo
Ý
¸
3A3A3
o
8
v
×
ß
);
x
weist den Nachfolgern Targets zu
|
6a for
Zp
,
to
Òr
B{
ç
do
x
eigentlich
/
Ý
statt
/
|
6b if (
p
Hashschl¨ussel(
o
Ý
÷
) mod N)
p
MYID then do
6c Sende PROBLEM(MYID,
,
Ý
÷
,
Ý
÷
,
Ý
÷
,
);
6d
¡
Sei dabei
¢
£
, falls vorhanden, die Adresse
¡h
6e
¡
von
¤¢
£
auf Prozessor
¥
, sonst sei
¢
£
= -1
¡h
6f
¦
6g falls es ein
§
gibt mit
¢
£¨a©ª`«¬
¢¯®
¨
KEINE ADRESSE; return
¦
7for
§®
¨°ª
to
± ²%³ ¢µ´;¶ ±
do
«
¡
eigentlich
§¢
statt
§^¡h
7b if Hashschl¨ussel(
¢
£
) mod N = MYID then do
«
8a
¤¢·¸
:=
¤¢
£
;
¹¢·¸
º
:=
¹¢
£
;
8b
¬
¢®
¨
REKURSION;
¬
¢·¸ ®
¨
START;
8c
»
¨
»¯¼
ª
;return ;
9
½¢
º
:= UpdateValue(
¢
);
9a if
¾¢
¨
NOT OK befreie alle Nachfolger von ihren Aufgaben;
10a if not OnTarget(
¤¢¿^<¢
º
)
10b
«
¾¢AÀ¸
¨
NOT OK;
»
¨
»
©Áª
;return;
¦
11 if
¾¢
= NOT OK break;
¡
springe zu Z.3
¡h
11a
¦
12
¦
12b if
¾¢
:= Ergebnisse stehen aus()
«¬
¢¯®
¨
WARTET; return ;
¦
13
¦Â¡
while ...
¡h
;
14a
¾¢GÀ¸
¨
OK;
»
¨
»
©~ª
; return;
Abb. 3.10: Pseudo-Rekursion des parallelen Cc2s-Algorithmus
80 Der Parallele Cc2s-Algorithmus
Targets beschreiben Teilprobleme, die gleichzeitig bearbeitet werden k¨onnen. Bearbeite
nun ein Prozessor
Ã
einen Task
Ä
. In den Zeilen 6a bis 6f der Prozedur Cc2s step(
Å8ÅhÅ
)
(Abb. 3.10) werden Teilprobleme als Arbeitspakete verschickt, wobei der jeweilige Ziel-
prozessor gem¨aß einer Hashfunktion bestimmt wird. Dabei liefert der Hashschl¨ussel eines
Knotens
Æ
£
(
ÇÈÊÉ&ÈÊË
) modulo der Prozessoranzahl den Zielprozessor. Falls der Ziel-
prozessor eines Arbeitspaketes mit
Ã
identisch ist, wird dieses Paket nicht verschickt,
sondern in den Zeilen 7-12 der Cc2s step-Prozedur auf Prozessor
Ã
weiterverarbeitet.
In Zeile 12b (Abb. 3.10) wartet der Algorithmus auf ausstehende Ergebnisse. Die Pro-
zedur Ergebnisse stehen aus() liefert OK zur¨uck, wenn alle bis zu dem Zeitpunkt des
Aufrufs eingegangenen Teilergebnisse OK waren, andernfalls gibt sie NOT OK zur¨uck.
Zu bemerken ist noch, daß Knoten, die verschickt werden, im Gesamtsystem doppelt vor-
liegen, einmal auf der Empf¨angerseite als vollst¨andiger Knoten mitsamt Nachfolgerlisten
etc. und einmal als ’kleiner’ Knoten auch auf der Senderseite. Dort ist zum einen ver-
merkt, wo sich der entfernte Knoten befindet, zum anderen ist dort aber auch sein Wert
ge-cached. Dadurch wird Kommunikation eingespart.
Beginn von Auftraggeber/Auftragnehmer-Beziehungen
Im initialen Zustand sind alle Prozessoren arbeitslos. Ein ausgezeichneter Prozessor
Ã%Ì
bekommt die Wurzelstellung. Er f¨uhrt die Prozedur DetermineMove(
Å8Å8Å
) aus, wobei er
die Teilprobleme, die er an Nachfolgern der Wurzel generiert, nicht selber bearbeitet,
sondern sie an andere Prozessoren verschickt. Die Zielprozessoren werden mit Hilfe einer
Hashfunktion ausgew¨ahlt.
Erh¨alt ein Prozessor
Í
eine Teilproblem-Nachricht PROBLEM=(
Î
,
Í
,
Æ
,
Ï
º
,
Ð
,
Ñ
), f¨uhrt er die
in Abbildung 3.9 (Zeilen 1-4) beschriebene Initialisierung durch und erzeugt einen neu-
en Task. Dabei ist
Î
der Sender des Problems und
Í
der Empf¨anger. Der Knoten
Æ
ist die
Wurzel des zu durchsuchenden Spielbaums,
Ï
º
das dazugeh¨orige Target. Falls bereits fest-
gelegt, ist
Ð
die Adresse von
Æ
beim Empf¨anger
Í
. Der Code
Ñ
erm¨oglicht eine eindeutige
Identifizierung des Problems und eine eindeutige Identifizierung des Tasks auf Prozessor
Î
, aus dem das Teilproblem (
Æ?ÒÓÏ
º
) entstanden ist.
Falls
Æ
zum ersten Mal von
Í
bearbeitet wird, schickt
Í
eine Nachricht ADRESSE=(
Í
,
Î
,-
Ñ
,
Ð
) an
Î
zur¨uck, damit sich
Î
bei sp¨ateren Bearbeitungen des Knotens
Æ
auf die Adresse
Ð
beziehen kann. Im Gegensatz zum Code
Ñ
bleibt
Ð
immer konstant. Es ist eine neue
Auftraggeber/Auftragnehmer-Beziehung entstanden.
Da Teilprobleme des Gesamtproblems senderiniitiert verschickt werden (Abb. 2.7, Z.6a-
6f), kann es passieren, daß Prozessoren mehrere Teilprobleme gleichzeitig zugesendet be-
kommen. Es kann dabei auf einem beliebigen Prozessor
Ã
zu keinen Deadlocks kommen,
3.4 Senderinitiierte parallele Cc2s-Suche 81
weil Spielb¨aume keine Kreise haben und Tasks, bei denen sich der Cc2s-Algorithmus in
der letzten Ebene im Zustand WARTET befindet, der Prozessor entzogen wird. Zu wel-
chem Zeitpunkt ein Teilproblem bearbeitet wird, h¨angt allerdings von den ¨ubrigen sich
auf
Ã
befindlichen Tasks ab.
Kommunikation
1
¡
Empfange Botschaften
¡h
2
¡ÕÔ
sei die eigene Prozessornummer
¡h
3while Botschaft mit Identifizierungscode
empfangen
«
4if PROBLEM(
Ö
,
Ô
,
,
,
,
) empfangen
«
5erzeuge neuen Task;
6initialisiere Problem gem¨aß Abb. 3.9, Z. 1-4;
7merke
Ö
,
,
;
8if
¨a©ª
sende ADRESSE(
Ô
,
Ö
,
,
¶
);
¡ ¶
Adresse von
'¡h
9
¦
10 if ADRESSE(
¥
,
Ô
,
,
) empfangen
«
11 finde Task
×
und Knoten
, die zu
geh¨oren;
12 Ordne die Adresse
von
auf
¥
dem Knoten
auf Prozessor
Ô
zu;
13
¦
14 if ANTWORT=(
Ö
,
¥
,
Ø
,
Ù8Ú
,
) empfangen
«
15 finde Task
×
, Knoten
und Ebene
»
, die zu
geh¨oren;
16 setze den Wert von
zu
Ø
; UpdateValue(
);
17 if
ÙÚ
=true
18 markiere
in Task
×
, Ebene
»
mit OK;
19 else
20 markiere
in Task
×
, Ebene
»
mit NOT OK;
21 von Ebene
»
bis zur Ebene
Ȧ
, in der sich
×
befindet,
22 befreie alle Nachfolger von ihren Aufgaben und setze
»¶ ®
¨
»
.
23
¦
24 if STOP=(
Ö
,
¥
,
) empfangen
«
25 finde Task
×
, der zu
geh¨ort;
26 f¨ur alle Knoten der aktuellen Variante des Tasks
×
27 befreie alle Nachfolger von ihren Aufgaben;
28 beende Task
×
;
29
¦
30
¦
Abb. 3.11: Kommunikation
82 Der Parallele Cc2s-Algorithmus
Ende einer Auftraggeber/Auftragnehmer-Beziehung
Es gibt zwei grunds¨atzlich verschiedene Arten, auf die eine Auftraggeber/Auftragnehmer-
Beziehung beendet werden kann.
Zum einen kann sie vom Auftragnehmer beendet werden. In diesem Fall hat der Auftrag-
nehmer
Î
seine Arbeit an einem Task
Ä
beendet und sendet eine ANTWORT=(
Î
,
Í
,
Û
,
ÜÝ
,
Ñ
)
an seinen Arbeitgeber
Í
. Er teilt ihm mit, ob das Target, das er zugewiesen bekommen hat,
erf¨ullt wurde (
ܤÝxÞTÏßàÍ
), den m¨oglicherweise ver¨anderten Wert
Û
des Startknotens und
denCode
Ñ
, mit dessen Hilfe der Arbeitgeber die Antwort einordnen kann. Der Empf¨anger
der Antwort (also der Arbeitgeber) muß zum einen den Ort wiederfinden, an dem die Ant-
wort eingef¨ugt werden muß (d.h. die Knotenadresse im Speicher), und er muß mit Hilfe
des Wiedererkennungscodes
Ñ
herausfinden, zu welchem Task die Antwort von
Í
geh¨ort.
Schlimmstenfalls gibt es den zur Antwort geh¨orenden Task gar nicht mehr. Die empfan-
gene Antwort wird dann ignoriert.
Auch ein Arbeitgeber kann eine Auftraggeber/Auftragnehmer-Beziehung beenden. Wenn
in Zeile 8 der Cc2s step-Prozedur (die einen Task
Ä
bearbeite) ein Nachfolger eines Kno-
tens
Æ
mit NOT OK antwortet, werden die aktiven Teilprobleme unterhalb von
Æ
abgebro-
chen (entweder in Zeile 3 oder in Zeile 11). Entweder beendet Cc2s step(
Å8Å8Å
) dann die
Arbeit an
Æ
(zumindest vorl¨aufig), oder
Ï
º
wird neu gesplittet. In beiden F¨allen wird f¨ur
jeden Nachfolger von
Æ
je eine STOP=(
Î
,
Í
,
Ñ
) Nachricht an die Prozessoren versendet, die
die Teilprobleme bearbeiten, deren Wurzeln die Nachfolger von
Æ
sind. F¨ur den Fall, daß
Cc2s step(
Å8ÅhÅ
) den Knoten
Æ
nicht verl¨aßt, werden m¨oglicherweise einige gerade deakti-
vierte Teilprobleme sofort wieder neu aufgesetzt. Aufgrund von Nachrichtenverz¨ogerun-
gen kann es dabei vorkommen, daß eine der Adressen der Nachfolger von
Æ
noch nicht
beim Arbeitgeber angekommen ist. Die Weiterbearbeitung des Tasks
Ä
muß dann warten,
bis die ADRESSE-Nachricht angekommen ist (Zeile 6g, Abb. 3.10).
Auftretende Inkonsistenzen von Werten
In Abschnitt 1.8 auf S.22ff wurden die Begriffe ’ungekl¨art’, ’widerspr¨uchlich’ und ’un-
terst¨utzend’ f¨ur zwei Werte eingef¨uhrt. Sei ein Knoten
Æ
gegeben. Seien
á
º
dessen Wert
und
áIâ
die Wertkomponente eines Targets
Ï
º
, das f¨ur
Æ
gebildet wurde. Beim sequentiel-
len Cc2s-Algorithmus ist nach einer Splitoperation an einem Knoten garantiert, daß der
Wert dieses Knotens den Werten der Nachfolger des Knotens nicht widerspricht. Wenn
der Cc2s-Algorithmus einen Knoten
Æ
mit Target
Ï
º
besucht, ist außerdem garantiert, daß
der Wert
á
º
von
Æ
die Wertkomponente
áIâ
des Targets
Ï
º
unterst¨utzt. Diese Eigenschaften
machten im vorigen Kapitel dieser Arbeit unsere Korrektheits- und Terminierungsbewei-
3.4 Senderinitiierte parallele Cc2s-Suche 83
se m¨oglich.
Sei
Ã
£
nun der Prozessor, der f¨ur die Bearbeitung eines Knotens
Æ
zust¨andig ist. Sei
á
º
Þäã;Ð
º
ÒAå
ºhæ
der Wert von
Æ
auf
Ã
£
. Ferner sei
Ï
º
ÞçãÓãdè
º
ÒGé
ºhæ
ÒÓê
º
ÒAë
ºhæ
das Target, das
ein Prozessor
Ãmì
an
Ã
£
f¨ur den Knoten
Æ
gesendet hat. Wir gehen, wie weiter vorne be-
schrieben, davon aus, daß auf
Ãì
eine (kleine) Kopie des Knotens
Æ
vorliegt. In dieser
Kopie stehen lediglich ein Verweis auf
Æ
auf
Ã
£
und ein Wert. Der Wert wird in erster Li-
nie ben¨otigt, um am Vorg¨anger von
Æ
die Splitprozedur ausf¨uhren zu k¨onnen. M¨ußte man
f¨ur jeden Aufruf der Splitprozedur erst die Werte aller Nachfolger einsammeln, w¨urde
das zu unn¨otiger Belastung des Netzwerkes f¨uhren. Im Prinzip handelt es sich bei dem
Speicherplatz, der f¨ur die Kopie von
Æ
auf
Ãmì
ben¨otigt wird um einen kleinen Cache. Im
parallelen Fall kann es nun passieren, daß bei
Ã
£
ein Arbeitsauftrag ankommt, bei dem
das Target des zugesendeten Teilproblems nicht von dem Wert von
Æ
unterst¨utzt wird.
Der Grund ist dann nat¨urlich, daß
Ã
£
und
Ãmì
unterschiedliche Bewertungen von
Æ
zugrun-
de gelegt haben. Wir sprechen in diesem Fall von einer aufgetretenen ’Inkonsistenz’. Im
folgenden untersuchen wir alle prinzipiell m¨oglichen Inkonsistenzen zwischen der Wert-
komponente
áIâ%í!Þîãdè
º
ÒÓé
º8æ
des Targets
Ï
º
und dem Wert
á
º
. Gl¨ucklicherweise kann man,
wenn man einen Knoten
Æ
besucht, alle Inkonsistenzen zwischen
Æ
und seinen Nachfol-
gern lokal beseitigen.
Folgende F¨alle, die wir oBdA. wieder nur f¨ur MAX-Knoten betrachten, k¨onnen beim
Besuch eines Knotens
Æ
auftreten:
1. Das Target
Ï
º
fordert, ausgedr¨uckt durch seine Wertkomponente
áIâ
, eine sch¨arfere
Schranke, als
á
º
zum Ausdruck bringt.
(a) Es sei
Æ
ein MAX-Knoten mit dem Wert
á
º
Þïã
’
ð
’
ÒAå
ºhæ
auf Prozessor
Ã
£
.
Dann ist
áIâÕÞñã
’
ð
’
ÒÓé
º8æ
mit
é
ºóò
å
º
. Wir wissen nun, daß das Attribut
Ð
º
von
Æ
immer schon ’
ð
’ gewesen ist, und daß Nachfolger von
Æ
den Wert (genauer
den Zahlwert
å
º
von
Æ
) von
Æ
allenfalls gr¨oßer gemacht haben k¨onnen. Also
wurde
Æ
auf
Ãmì
direkt bewertet, und
Ãì
ist lokal zu dem Schluß gekommen,
daß der Wert von
Æ~ã
’
ð
’
ÒÓé
º8æ
mit
é
ºÁò
å
º
sein muß. Deshalb hat
Ã
£
f¨ur
Æ
ein Target
Ï
º
ÞôãÓã
’
ð
’
ÒGé
ºhæ
Ò8ÅhÅ8ÅhÒ8ÅhÅ8Å
æ
bekommen. Wenn
Æ
nun auf
Ã
£
bewertet
w¨urde, bek¨ame
Æ
nat¨urlich dort dieselbe direkte Bewertung, die dann noch
den Werten der Nachfolger von
Æ
angepaßt werden m¨ußte. Es gen¨ugt deshalb,
den Zahlwert von
Æ
auf
é
º
hochzusetzen (d.h.,
Æ
bekommt auch auf
Ã
£
den
Wert
ã
’
ð
’
ÒGé
ºhæ
) und auf
Ã
£
UpdateValue(
Æ
) aufzuf¨uhren.
(b) Auf ¨ahnliche Weise kann es passieren, daß ein MAX-Knoten
Æ
auf einem
Prozessor
Ã
£
einen Wert
ã
’
È
’
ÒAå
ºhæ
besitzt und das Target
Ï
º
ÞäãÓã
’
È
’
ÒGé
ºhæ
,-
84 Der Parallele Cc2s-Algorithmus
ÅhÅ8Å
,
Å8Å8Å
æ
mit
å
ºaò
é
º
zugesendet bekommt. Dann wurde vorher die kleine
Kopie von
Æ
auf dem Prozessor
Ãì
, von dem aus
ã1Æ?ÒÓÏ
ºhæ
gesendet wurde, mit
einem Wert der Form
ã
’#’
ÒGé
ºhæ
versehen, und es reicht nun aus, entweder auf
dem Prozessor
Ã
£
auch eine direkte Bewertung von
Æ
durchzuf¨uhren, so daß
Æ
danach einen Wert der Form
ã
’#’
ÒÓé
º8æ
hat, oder auf
Ã
£
den Wert von
Æ
von
Ãì
zu ¨ubernehmen. Nat¨urlich muß auch hier wieder UpdateValue(
Æ
) aufgerufen
werden.
In beiden F¨allen kann der Cc2s-Algorithmus weiterarbeiten, als h¨atte es keine In-
konsistenzen gegeben.
2. Die Werte
áIâ
und
á
º
sind widerspr¨uchlich:
(a) Sei
á
º
Þ ã
’#’
ÒAå
ºhæ
. Dann senden wir eine Antwort mit dem Wert
á
º
und
NOT OK an
Ãmì
.
Ãì
wird sich
á
º
merken. Der Fall, daß
ÃìÏ
º
verschickt hatte,
weil
ÃmìÆ
direkt bewertet hatte, kann nun nicht mehr vorkommen. Falls
Ãmì`Ï
º
verschickt hatte, weil sich
á
º
auf
Ã
£
ge¨andert hatte, aber
Ãmì
dies nicht schnell
genug mitbekommen hatte, wird
Ãmì
nach endlicher Zeit den richtigen Wert
von
Æ
erfahren und danach nicht mehr das unpassende Target
Ï
º
versenden.
(b) Seien
á
º
Þñã
’
ð
’
ÒGå
º8æ
und
áIâÕÞîã
’
È
’
ÒÓé
ºµæ
mit
é
ºóõ
å
º
.
Da
á
º
das Attribut ’
ð
’ besitzt, muß sein erster Wert
ã
’
ð
’
ÒAå
æ
mit
å°Èöå
º
gewesen sein. Der Wert
á
º
(genauer sein Zahlwert
å
º
) kann durch die Nach-
folger von
Æ
n¨amlich allenfalls gr¨oßer gemacht worden sein. Wenn
Ãì
also
ein Target mit Wertkomponente
áIâ
verschickt hat, muß
Æ
auf
Ãmì
bereits einen
Wert
ã
’#’
ÒAå
¶
º
æ
mit
å
¶
º
õ
é
º÷õ
å
º
besitzen. Man kann also schließen, daß ei-
ne direkte Bewertung von
Æ
den Wert
ã
’#’
ÒAå
¶
º
æ
liefert und daß mindestens 1
Nachfolger von
Æ
zeigt, daß es eine H¨ulle unter
Æ
gibt, deren Minimaxwert
ðøå
º
ist. Wir setzen deshalb
á
º
auf
Ã
£
zu
ã
’#’
ÒAå
ºhæ
(das ist das, was auch eine
direkte Bewertung plus UpdateValue(
Æ
) liefern w¨urde) und senden an
Ãì
eine
Antwort mit dem Wert
á
º
f¨ur
Æ
und NOT OK. Sobald die Antwort
Ãì
erreicht,
ist die Widerspr¨uchlichkeit der Werte von
Æ
auf
Ã
£
und
Ãmì
beseitigt.
(c) Seien
á
º
Þñã
’
È
’
ÒGå
º8æ
und
áIâÕÞîã
’
ð
’
ÒÓé
ºµæ
mit
é
ºóò
å
º
.
Da
áIâ
nur aus ¨alteren Werten von
Æ
(auf
Ã
£
) und einer zus¨atzlichen direkten
Bewertung von
Æ
auf
Ãmì
zustande gekommen sein kann und
á
º
durch die
Nachfolger von
Æ
(auf
Ã
£
) nur gr¨oßer geworden sein kann, kann dieser Fall
nicht eintreten.
3.
áIâ
ist ungekl¨art zu
á
º
, und
á
º
ist ungekl¨art zu
áIâ
:
3.4 Senderinitiierte parallele Cc2s-Suche 85
(a) Sei
á
º
von der Form
ã
’#’
ÒAå
ºhæ
. Da ein ’#’ -Wert nicht ungekl¨art sein kann zu
einem anderen Wert, kann dieser Fall nicht eintreten.
(b) Seien
á
º
Þùã
’
È
’
ÒAå
ºhæ
und
áIâÞùã
’
ð
’
ÒGé
ºhæ
mit
é
ºúõ
å
º
. In diesem Fall kann
nur eine direkte Bewertung von
Æ
auf
Ãmì
auf
Ãì
zu einem Wert
ã
’#’
ÒGå
æ
mit
åûð,é
º
gef¨uhrt haben. Wie groß der Wert von
Æ
auf
Ãmì
ist, kann man aus dem
Target nicht erkennen. Die Inkonsistenz wird beseitigt, indem man entweder
Æ
auf
Ã
£
ebenfalls direkt bewertet, oder indem man den Wert von
Æ
, der auf
Ãmì
ermittelt wurde, in
á
º
auf
Ã
£
einsetzt und danach UpdateValue(
Æ
) aufruft.
(c) Sei
á
º
Þüã
’
ð
’
ÒAå
ºhæ
und
áIâÞýã
’
È
’
ÒGé
ºhæ
mit
é
ºþò
å
º
. Auch in diesem Fall
kann nur eine direkte Bewertung von
Æ
auf
Ãmì
zu einem Wert
ã
’#’
ÒAå
æ
mit
åûÈ,é
º
gef¨uhrt haben. Wie groß der Wert von
Æ
auf
Ãmì
ist, kann man aus dem
Target nicht erkennen. Die Inkonsistenz wird beseitigt, indem man entweder
Æ
auf
Ã
£
ebenfalls direkt bewertet, oder indem man den Wert von
Æ
, der auf
Ãmì
ermittelt wurde, in
á
º
auf
Ã
£
einsetzt und danach UpdateValue(
Æ
) aufruft.
Behandle Inkonsistenzen
¡
Sei
ÿ
im folgenden ein MAX-Knoten. Sei
½
º
¨
º
¿
¬
º
der Wert von
ÿO¡h
¡
und
½â
die Wertkomponente des Targets
º
¨
³^³
º
¿
º
´
º
¿
º
´
.
¡h
1if (
½
º
¨
³
’
’
¿
¬
º
´
and
º
¨
³^³
’
’
¿
º
´¿
¿
´
mit
º
¬
º
)
¬
º
®
¨
º
;
2if (
ÿ
ist ein MAX-Knoten and
½
º
¨
³
’
’
¿
¬
º
´
and
3
º
¨
³^³
’
’
¿
º
´¿
µ¿
´
mit
º
¬
º
)
4
«
½
º
:= Evaluate(
ÿ¿
©
¿
º
);
º
:= ’#’ ;
¦
5if die Wertkomponente
½â
von
º
widerspricht
½
º
«
6if
½
º
¨
³
’
’
¿
¬
º
´
und
½â
¨
³
’
’
¿
º
´
mit
º
¬
º
7
½
º
®
¨
³
’#’
¿
¬
º
´
;
8
¦
9if
½
â
ist ungekl¨art zu
½
â
und
½
â
ist ungekl¨art zu
½
º
«
10
«
½
º
:= Evaluate(
ÿ¿
¬
º
¿
);
º
:=’#’ ;
¦
11 UpdateValue(
ÿ
);
12 if (Splitoperation nicht m¨oglich)
13 verlasse Cc2s step(
);
14 Sende Antwort mit NOT OK und
½
º
;
analog f¨ur MIN-Knoten
Abb. 3.12: Behandlung von Inkonsistenzen
Außerdem gibt es rein tempor¨are Inkonsistenzen, die dadurch auftreten, daß Nachrichten
ihr Ziel nicht zeitgerecht erreichen. Diese braucht man aber nicht weiter zu betrachten,
da sie, sofern sie sich nicht sowieso als irrelevant erweisen, nach endlicher Zeit aufgel¨ost
werden.
86 Der Parallele Cc2s-Algorithmus
Beispiele f¨ur Kommunikation
Abbildung 3.13 zeigt die parallele Bearbeitung zweier Knoten
Æ?Å
und
Æ?Å
. Der Wert
von
Æ
ist
ã
’
È
’
Ò
æ
, und es soll gezeigt werden, daß dies auch mit der Sicherheit einer
Resttiefe vier und einer Conspiracy Number zwei so ist. Alle Nachfolger von
Æ
bekom-
men deshalb das Target
ãÓã
’
È
’
Ò
æ
Ò
4Ò
æ
. Da f¨ur
Æ?Å Ç
schon feststeht, daß er das Target
erf¨ullt, sind noch die Berechnungen f¨ur
Æ?Å
und
Æ?Å
zu erledigen. Der Hashschl¨ussel
von
Æ?Å
zeige, daß
ÆÅ
auf den Prozessor
Ã
geh¨ort.
à Ç
sendet deshalb das Teilproblem
ã;ÃúÇÒAÃ
Ò-ãã
’
È
’
Ò
æ
Ò
4Ò
æ
Ò
ÇÒAÑ
æ
an
Ã
. Da auf
Ã
der Knoten
Æ?Å
zuvor noch nicht un-
tersucht worden ist, wird
ÆÅ
angelegt und bekommt eine Adresse
Ð
. Diese Adresse wird
sofort an
à Ç
zur¨uckgeschickt. Dadurch kann der Knoten
ÆÅ
bei einer weiteren, sp¨atere-
ren Bearbeitung wiedergefunden werden. Nach Abarbeitung des Teilbaums mit Wurzel
Æ?Å
sendet
Ã
den ermittelten Wert
Û
und OK an
ÃúÇ
zur¨uck. Das Target
Ï
º
wurde also
erf¨ullt.
P1 P2
v
v.1 v.2 v.3
v
v.1 v.2 v.3
v
v.1 v.2 v.3
v.2
P2
P1
v.2
P2,a
Zeit
v.2
w= (≤5)
w= (≤5)
v.3
w= (≤5)
v.1
fertig
w= (≤5)
v
v
t = ((≤5),4,2)
PROBLEM p = (P1,P2,v.2, ((≤5),3,2)
!
w= (≤5)
v
v
t = ((≤5),4,2)
fertig
w= (≤5)
v.1 aktiv
Adresse a; aktiv
w= (≤5)
t = ((≤5),3,2)
v.2
v.2
w= (≤5)
t = ((≤5),3,2)
v.3
v.3
w= (≤5)
t = ((≤5),3,2)
v.3
v.3
w= (≤5)
t = ((≤5),3,2)
v.2
v.2
v.2
w= (≤4)
fertig aktiv (≤4)
!
,OK,c)
UpdateValue(v)
fertig
,−1,c)
ADRESSE b = (P2,P1,c,a)
ANTWORT q = (P2,P1,
Abb. 3.13: Parallelit¨at
3.4 Senderinitiierte parallele Cc2s-Suche 87
In Abbildung 3.14 haben die Knoten
Æ?Å Ç
und
Æ?Å
ein Target
ãÓã
’
ð
’
Ò
#"
æ
Ò
Ò
æ
erhalten.
Æ?Å
muß von Prozessor
Ã
bearbeitet werden und wurde dort auch schon fr¨uher einmal un-
tersucht. Deshalb wird das Problem
ãdà ÇÒGÃ
ÒãÓã
’
ð
’
Ò
#"
æ
Ò
Ò
æ
ÒAÐÒAÑ
æ
an
Ã
gesendet. Dabei
ist
Ð
die Adresse, wo sich bei
Ã
der Knoten
Æ?Å
befindet.
Ã
f¨angt an,
ÆÅ
zu bearbei-
ten. Gleichzeitig arbeitet
à Ç
unterhalb von
ÆÅ Ç
.
ÃúÇ
kommt recht schnell zu dem Schluß,
daß
Ï
º
¸
nicht erf¨ullt werden kann und daß der Wert von
ÆÅ Ç ã
’#’
Ò
æ
ist. Deshalb sendet
à Ç
eine Stopnachricht an
Ã
, um
Ã
mitzuteilen, daß er ein m¨oglicherweise nicht mehr
wichtiges Teilproblem bearbeitet. Nachdem
Ã
seine Arbeit an
Æ?Å
abgebrochen hat und
à Ç
ein neues Target f¨ur
Æ?Å
erzeugt hat, sendet
à Ç
eine neue Arbeitsaufforderung an
Ã
.
P1 P2
v
v.1 v.2 v.3
v
v.1 v.2 v.3
v.2
v
v.1 v.2 v.3
v.2
P2,a
P2,a
P2,a
Zeit
neue Teiltargets
= ((≥ 4),5,2)
tv.2
v.2
w= (≥5) = (#,3)
wv.3
= (#,3)
wv.1
= (#,3)
wv.1
v.2
w= (≥5) w= (#,3)
v.3
fertig
fertig
tv
wv= (≥5)
tv
wv= (≥5)
tv
wv= (≥5)
w= (#,3)
v.3
v.2
w
tv.2
= (≥5)
= ((≥ 4),5,1)
t= (≥5)
wv.1
= ((≥ 4),5,1)
v.1 v.2
w
tv.2
= (≥5)
= ((≥ 4),5,1)
tv.2
v.2
w= (≥5)
PROBLEM p = (P1,P2,v.2, ((≥ 4),5,1),a,c)
PROBLEM p = (P1,P2,v.2, ,a,c)
((≥ 4),5,2)
aktiv
aktiv
= ((≥ 4),6,2)
= ((≥ 4),6,2)
= ((≥ 4),6,2)
STOP s = (P1,P2,c)
= ((≥ 4),5,1)
Abb. 3.14: Parallelit¨at
3.4.2 Abgaben von Bewertungen
Bisher haben wir nur solche Knoten extern bearbeiten lassen, die von der Prozedur Cc2s-
step(
Å8Å8Å
) besucht werden. In der Prozedur PartialExpansion(
Å8Å8Å
) ist noch Potential zur
88 Der Parallele Cc2s-Algorithmus
Parallelisierung vorhanden, das wir ebenfalls nutzen.
Wenn die Prozedur PartialExpansion(
Å8Å8Å
) einen Knoten
Æ
expandiert und wenn
Æ
ein
ALL-Knoten ist, m¨ussen alle Nachfolger bewertet werden. Auch diese Knoten kann man
gleichzeitig bewerten lassen, indem man sie entsprechend ihrer Hashwerte ins Netzwerk
verschickt.Ebenso kann man anCUT-Knoten alleNachfolger gleichzeitig bewerten, wenn
man schon weiß, daß der Knoten
Æ
sein Target
Ï
º
nicht erf¨ullt. Sei
É
die Anzahl der Nach-
folger von
Æ
, die schon bewertet worden sind (vgl. Abb. 2.14 Zeile 4, bzw. Zeile 18 auf S.
40).
Unter folgenden Bedingungen verschickt der parallele Cc2s-Algorithmus einen Knoten
Æ
mit Target
Ï
º
ÞñãÓãdÐ
º
ÒGå
º8æ
ÒAë
º
ÒÓê
ºµæ
:
$
falls
Æ
ein ALL-Knoten ist und
É
ò
ist (d.h. die ersten drei Nachfolger von
Æ
schon
bewertet wurden),
oder
falls
Æ
ein CUT-Knoten ist und der Algorithmus sich in den Zeilen 27-31 der Pro-
zedur PartialExpansion(
Å8ÅhÅ
) befindet
oder
falls
Æ
ein CUT-Knoten ist und
É
ò
ê
&%'
ist (d.h., es wurden schon 3 Nachfolger
mehr bewertet, als mindestens zur Erf¨ullung von
Ï
n¨otig waren )
$
und falls die Anzahl der Tasks
õ
200 ist
$
und falls
Æ
bewertet werden muß (vgl. Abb. 2.15, S.41).
Da die Teilb¨aume unter den Nachfolgern von
Æ
jeweils nur aus einem Knoten bestehen,
gibt es keinen Grund, sie schon auf den entfernten Prozessoren zu fixieren. Damit erhalten
wir einen n¨utzlichen Freiheitsgrad: Wenn die Gesamtlast im Netzwerk groß ist, kann ein
Nachfolger des Knotens
Æ
von dem Prozessor bearbeitet werden, bei dem
Æ
liegt, sonst
kann der Knoten auch verschickt werden. Um lokal auf einem Prozessor
Ã
die Last des
Gesamtnetzes abzusch¨atzen, benutzen wir eine einfache Heuristik: Wir gehen bei einem
Prozessor
Ã
davon aus, daß die Gesamtlast im Netz groß ist, wenn die Anzahl der Tasks
lokal bei
Ã
gr¨oßer oder gleich 200 ist.
3.4.3 Verteilte Transpositionstabelle
Der sequentielle Algorithmus bedient sich einer Transpositionstabelle, also einer Hash-
tabelle f¨ur Knoten, in der zu bereits besuchten Stellungen des Spielbaums die dazugeh¨ori-
gen Ergebnisse eingetragen werden. Auf diese Weise verhindert man in vielen F¨allen, daß
3.5 Experimentelle Leistungsbewertung 89
Stellungen, die durch Zugumstellungen im Suchbaum entstehen, doppelt untersucht wer-
den.
Jeder Prozessor im verteilten System von
(
Prozessoren h¨alt eine Transpositionstabelle
der gleichen Gr¨oße
)
. Diese lokalen Teiltabellen werden logisch als eine große Tabelle
mit
)+*,(
Eintr¨agen betrachtet. Die Hashfunktion liefert also einen Index
ÉAã1Û
æ
.-0/1
Å8ÅhÅ
#(2*
)
,Ç
43
. Hat eine Stellung
Æ
im Spielbaum den Hashwert
5
ã1Æ
æ
Þ ãdÉAã1Æ
æ
Ò
6
ãdÆ
ææ
-0/1
Å8Å8Å
#(7*)
,Ç
839
/1
Ò8Ç
43;:
Ò
so wird der Index i(v) aufgespalten in eine Prozessornummer
<
ãdÆ
æ
í!ÞøÉAãdÆ
æ
mod
(
und einen Index in die lokale Hashtabelle von
<
ãdÆ
æ
É
,=
1
º
?>
íÞ
A@
ÉAãdÆ
æ
(
B
mod
)
NÅ
Da jeder Prozessor gem¨aß seines Hashwertes in das Prozessornetzwerk eingebettet wird,
ist es leicht, globale Zugumstellungen zur Stellung
Æ
mit Hilfe der globalen Transpositi-
onstabelle zu finden. Man ben¨otigt lediglich Zugriffe auf die lokale Hashtabelle desjeni-
gen Prozessors, der
Æ
bearbeitet.
3.5 Experimentelle Leistungsbewertung
Dieses Kapitel besteht aus vier Teilen. Zun¨achst versuchen wir die Leistung des Gesamt-
systems einzuordnen, indem wir Ergebnisse des parallelen Algorithmus in der Praxis, d.h.
auf Schachturnieren, und sein Verhalten auf dem BT2630 Test pr¨asentieren.
Danach stellen wir die n¨otigen Begriffe vor, die wir brauchen, um die Effizienz unseres
verteilten Algorithmus zu beurteilen. Den vierten Abschnitt bilden die Effizienzmessun-
gen selber.
3.5.1 Turniere
Im Juli 2000 gewann P.ConNerS (die parallele Version von ConNerS) das 10. Lippst¨adter
Großmeisterturnier, das im Jahr 2000 drittst¨arkste Turnier Deutschlands. Zum allerer-
sten Mal weltweit konnte damit ein Computerprogramm ein internationales FIDE Groß-
meisterturnier (Kategorie 11) gewinnen. In einem Teilnehmerfeld von 11 menschlichen
Schachmeistern mußte sich P.ConNerS nur dem ehemaligen Jugendweltmeister Slobod-
jan und dem erfahrenen englischen Großmeister Speelman geschlagen geben. P.ConNerS
gewann das Turnier mit 6 Siegen, 3 Unentschieden und 2 Niederlagen.
90 Der Parallele Cc2s-Algorithmus
Die Gegner des Programms hatten eine durchschnittliche ELO-Zahl von 2522, und P.Con-
NerS erspielte sich eine Turniererfolgszahl von 2660 ELO-Punkten. Das Programm hat
sich damit den Ruf eines Weltklasseprogramms erworben.
Zwar hatten auch in fr¨uheren Jahren immer mal wieder Programme menschliche Schach-
großmeister geschlagen, es handelte sich aber immer entweder um einzelne Partien oder
Schnell- oder Blitzschachturniere. In Lippstadt spielten die menschlichen Gegner von
P.ConNerS unter f¨ur sie optimalen Bedingungen.
Eine ganze Reihe von Zeitungs- und Fachzeitschriftenartikeln belegen, daß es sich bei
diesem Erfolg f¨ur die Schachspieler um eine zu diesem fr¨uhen Zeitpunkt unerwartete
Sensation handelte [BILD00] [CSS00] [HS00] [ICC00] [IX00] [LS00] [NW00] [PAT00]
[S00] [SCHM00] [CB00] [WT00].
Davor war P.ConNerS erst viermal auf offiziellen Turnieren aufgetreten. Bei seinem er-
sten Auftritt 1998 wurde das Programm vierter auf dem 7. Internationalen Paderborner
Computerschachturnier, 1998 konnte P.ConNerS das 8. Internationale Paderborner Com-
puterschachturnier sogar gewinnen, wobei es sich dabei gegen Weltklasseprogramme wie
Nimzo und Shredder (Weltmeister 1999, PC-Weltmeister 1998+2000) durchsetzen konn-
te. Entt¨auschend war lediglich der Auftritt bei dem Computerschach-Weltmeisterschaft
1999. Programmfehler bei der Portierung auf einen neuen Rechner und Fehler in der
Hardware machten zu diesem Zeitpunkt ein gutes Abschneiden unm¨oglich. Der vierte
Platz beim 9. Int. Paderborner Computerschachturnier ist ¨ahnlich hoch zu bewerten, wie
der 1. Platz 1999.
Jahr Turnier Rang
2000 10. Lippst¨adter Großmeisterturnier Kat.11/12 1
2000 9. Int. Paderborner Computerschachturnier 4
1999 9. Computerschach-Weltmeisterschaft 18
1999 8. Int. Paderborner Computerschachturnier 1
1998 7. Int. Paderborner Computerschachturnier 4
Tab. 3.1: Alle Turnierteilnahmen von P.ConNerS
3.5.2 BT2630
Eine weitere M¨oglichkeit, einen Eindruck von der Spielst¨arke eines Programms zu be-
kommen, sind Testreihen mit ausgew¨ahlten Teststellungen. Auf dem von uns bevorzugten
BT2630 Test erreicht P.ConNerS mit 2589 (Pseudo)-ELO-Punkten ebenfalls ein von an-
deren Programmen unerreichtes Ergebnis. Erl¨auterungen zum BT2630-Test siehe Kap.2.4
3.5 Experimentelle Leistungsbewertung 91
#Prozessoren BT2630-Elo
159 2586
79 2589
39 2565
19 2541
9 2470
3 2427
2 2400
1 2402
Tab. 3.2: Ergebnisse auf dem BT2630-Test
3.5.3 Definitionen
Um die G¨ute eines parallelen Algorithmus zu bewerten, sollte er mit der bestm¨oglichen
sequentiellen Methode verglichen werden. Man betrachtet den Speedup (die Beschleu-
nigung), die das parallele Verfahren gegen¨uber dem sequentiellen Verfahren erreicht.
Weil der beste Spielbaumsuchalgorithmus nicht bekannt ist, beschr¨anken wir uns darauf,
den parallelen Cc2s-Algorithmus mit dem sequentiellen, im vorigen Kapitel vorgestell-
ten Cc2s-Algorithmus zu vergleichen. Immerhin handelt es sich dabei sicherlich um den
bestbekannten Conspiracy Number Suchalgorithmus.
Der Speedup eines Problems
Ã
ergibt sich aus der Bearbeitungszeit
Ï
¸
ã;Ã
æ
des sequentiel-
len Algorithmus geteilt durch die Bearbeitungszeit
Ï
DC
ãdÃ
æ
des parallelen Algorithmus mit
Ë
Prozessoren.
F¨ur eine Menge
E
von Problemen definieren wir den Speedup folgendermaßen:
F
Ã
HG
÷ãdË
æ
Þ
I
=J
E
Ï
¸
ãdÃ
æ
I
=J
E
Ï
DC
?ãdÃ
æ
Å
Mit Hilfe des Speedups ist auch die Effizienz EFF(n) definiert:
GKHK
ûãdË
æ
Þ
F
Ã
HG
÷ã1Ë
æ
ML
ËÅ
Sei
á
.C
#ã;Ã
æ
die Summe der Zeiten, die
Ë
Prozessoren ben¨otigen, um Tasks auszuw¨ahlen
und um alle Aufrufe ihrer Baumsuchprozesse ’pCc2s’ durchzuf¨uhren. Die Zeiten, in de-
nen Prozessoren nichts anderes tun, als auf Antworten zu warten, seien in
á
.C
#ã;Ã
æ
nicht
enthalten. Dann ist die durchschnittliche Auslastung definiert als
NPOQSR
ãdË
æ
Þ Ç
1T1
*
¸
C
*
I
=J
E
á
.C
4ã;Ã
æ
I
=J
E
Ï
DC
#ã;Ã
æ
Å
92 Der Parallele Cc2s-Algorithmus
Die Prozessorauslastung gibt also das Verh¨altnis von reiner Arbeitszeit zur Gesamtbear-
beitungszeit an. Allerdings kann sich darin auch vom Betriebssystem verbrauchte Zeit, so-
wie Nachrichtenverarbeitungszeit und Task-Schedulingzeit verstecken. Eine gute durch-
schnittliche Prozessorauslastung garantiert nur, daß die Prozessoren selten arbeitslos sind.
Sie gibt auch nicht an, wie sinnvoll die durchgef¨uhrten Arbeiten waren.
Um letzteres absch¨atzen zu k¨onnen, definieren wir den Suchoverhead.
F
OVUWR
ã1Ë
æ
ÞSÇ
181
*
ã
I
=J
E
Ý
8C
ãdÃ
æ
I
=J
E
Ý
¸
ã;Ã
æ
,Ç
æ
Der Suchoverhead gibt an, wieviele Knoten der parallele Algorithmus im Verh¨altnis zur
sequentiellen Version untersucht hat. Hierbei z¨ahlen wir die Gesamtknotenzahlen, also
auch diejenigen Knoten, die von den Tiefe-2
è%é
-Suchen erzeugt werden, die in der Cc2s-
Routine als Bewertung eingesetzt werden.
Zus¨atzlich definieren wir die Leistung wie folgt;
N
F
Ä
YX
cã1Ë
æ
Þ
I
=J
E
Ý
8C
4ã;Ã
æ
I
=ZJ
E
Ï
DC
?ã;Ã
æ
Die Leistung gibt an, wieviele Knoten der parallele Algorithmus im Durchschnitt ¨uber
alle Probleme pro Sekunde erzeugt. Wir haben uns f¨ur diese Definition entschieden, weil
dadurch der Speedup in zwei Komponenten aufgeteilt wird.
Der Speedup SPE(n) ist gleich
Ç
181
*
ã
N
F
Ä
SX
ûãdË
æ
N
F
Ä
SX
ûãÇ
æ
L
ã
F
OVUWR
ãdË
æ
%
øÇ
1T1
æÓæ
Å
Wenn der Suchoverhead niedrig ist und die Leistung von
Ë
Prozessoren ungef¨ahr der n-
fachen Leistung eines Prozessors entspricht, ist auch der Speedup hoch. Wenn der Speed-
up niedrig ist, kann es daf¨ur im folgenden zwei Gr¨unde geben. Zum einen kann es sein,
daß die Auslastung der Prozessoren niedrig ist, oder der parallele und der sequentielle
Algorithmus generieren unterschiedlich viele Knoten. Wir werden beide Probleme einge-
hender betrachten.
Erzeugung von Testinstanzen
Um eine Geschwindigkeitssteigerung von
Ë
Prozessoren gegen¨uber einem einzelnen zu
messen, ist es erforderlich, die Zeiten zu messen, die die Algorithmen brauchen, um ein
fest vorgegebenes Arbeitspaket abzuarbeiten. Die Arbeit, die ben¨otigt wird, um auf einer
vorgegebenen Schachstellung eine fest vorgegebene Sicherheit zu garantieren, bietet sich
als ein Arbeitspaket an. Nun ist die Bearbeitungszeit, die der Cc2s-Algorithmus ben¨otigt,
3.5 Experimentelle Leistungsbewertung 93
um eine fest vorgegebene Sicherheit zu erreichen von Stellung zu Stellung sehr unter-
schiedlich. Deshalb geben wir f¨ur jede einzelne Stellung eine zu erreichende Sicherheit
vor. Dadurch besteht eine Menge
E
von Teststellungen aus dem Produkt
F
9
)Ä
, einer
Menge von Stellungen
F
und einer Menge von Sicherheiten
Ä
. Die Sicherheiten werden
so gew¨ahlt, daß das parallele Programm eine Sicherheit in einem vorgegebenem Zeit-
rahmen erbringt und daß das sequentielle Vergleichsprogramm (mit seinem begrenzten
Speicherplatz) diese Sicherheit auch noch erreichen kann.
Beispiel: F¨ur eine maximale parallele Rechenzeit von 480 Sekunden ergibt sich f¨ur die
Speedupmessung von 159 Prozessoren die folgende Menge von Stellungs-Sicherheits-
Tupeln
ã
F
ÒÓÄ Þîã
Tiefe
ÏCÒ
Conspiracy Number
Ñ
æÓæ
:
E
Þ
/
ãÇÒ-ãÇ
1
Ò
ææ
,
ã
[
Ò-ãÇ
;
Ò
æÓæ
,
ã
\
Ò-ãÇ
Z
Ò
æÓæ
,
ã
]"
#Ò-ãÇÇÒ
ææ
,
ã
[
ÒãÇ
;
Ò
æÓæ
,
ã
^
4Ò-ãÇ
Z
Ò
ææ
,
ã
[_
Ò-ãÇ
Z
4Ò
æÓæ
,
ã
\`
4ÒãÇ
Z
4Ò
æÓæ
,
ã
a
4Ò-ãÇ
Z
Ò
ææ
,
ãÇ
1
ÒãÇ
Z
4Ò
æÓæ
,
ãÇÇÒ-ãÇ
;
Ò
ææ
,
ãÇ
;
Ò-ãÇ
;
Ò
ææ
,
ãÇ
Z
4Ò-ãÇ
1
Ò
ææ
,
ãÇ
"
4Ò-ãÇ
"
4Ò
æÓæ
,
ãÇ
;
Ò-ãÇÇÒ
æÓæ
,
ãÇ
Z^
4Ò-ã
a
4Ò
ææ
,
ãÇ
;_
Ò-ãÇ
"
4Ò
æÓæ
,
ãÇ
Z`
4Ò-ã
\
ÇÒ
æÓæ
,
ãÇ
a
4Ò-ãÇÇÒ
ææ
,
ã
[
1
ÒãÇ
1
Ò
æÓæ
,
ã
\
ÇÒ-ãÇ
"
#Ò
ææ
,
ã
[T
Ò-ãÇÇÒ
æÓæ
,
ã
\8
4Ò-ãÇ
;
Ò
æÓæ
,
ã
["
#Ò-ãÇ
Z
Ò
ææ
,
ã
[T
ÒãÇ
Z^
4Ò
æÓæ
,
ã
\8^
4Ò-ãÇ
1
Ò
ææ
,
ã
[T_
Ò-ãÇ
Z
Ò
æÓæ
,
ã
[8`
4ÒãÇ
1
Ò
æÓæ
,
ã
[8a
Ò-ãÇ
1
Ò
æÓæ
,
ã
\
1
Ò-ãÇ
Z
Ò
ææ
3
'Å
Auf z.B. der ersten Stellung des BT2630-Tests werden also
die Rechenzeiten einer Suche mit Tiefe 8 und Conspiracy Number 2 ermittelt. Rechen-
zeitschranken f¨ur parallele Rechenzeiten waren 20, 45, 90, 180, 240, 480, 720, 900 und
10000 Sekunden.
Bei einer vorgegebenen Rechenzeitschranke (z.B. 480 Sekunden) ergibt der durchschnitt-
liche Speedup aller 30 Stellungen des BT-Tests einen Meßpunkt. Verschiedene Meßpunk-
te, die durch verschiedene Beschr¨ankungen der parallelen Rechenzeit erzeugt werden,
werden durch lineare Interpolation miteinander verbunden.
Es gibt aber noch ein weiteres meßtechnisches Problem: Der Speicher der Prozessoren
des HPCLine-Rechners ist auf 256 MByte begrenzt, wobei davon ca. 100 MByte vom
Betriebssystem verbraucht werden. Um sequentielle Daten aufzunehmen, ist diese ge-
ringe Speichermenge nicht geeignet. Wir haben deshalb die sequentiellen Daten auf ei-
ner SUN Workstation mit 2 GByte Speicher durchgef¨uhrt, dem Rechner Quattro. Eine
Umrechnung ist nicht trivial. Durch verschieden schnelle Hauptspeicher, verschiedene
Cache-Strategien und letztendlich durch unterschiedliche Befehlss¨atze der Prozessoren
ist die Geschwindigkeitsdifferenz von einem System zum anderen von der Anwendung
abh¨angig. Der von uns gemessene Umrechnungsfaktor betr¨agt 1.31. Wie man in Ab-
bildung 3.15 sieht, ist dieser Faktor aber selbst innerhalb unserer Anwendung Schwan-
kungen unterworfen. Um das Verh¨altnis der Rechengeschwindigkeiten der unterschiedli-
chen Plattformen abzusch¨atzen, haben wir eine Vergleichsmessung auf dem BT2630-Test
durchgef¨uhrt. F¨ur lange Rechnungen sind wir zu dem Schluß gekommen, daß ein Um-
rechnungsfaktor von 1.31 angemessen ist. Abbildung 3.15 zeigt das Verh¨altnis der Ge-
94 Der Parallele Cc2s-Algorithmus
0.9
0.95
1
1.05
1.1
0 200 400 600 800 1000 1200 1400 1600 1800
Speedup (1 P/ (1,31 Q))
Zeit (sec)
1 Prozessor
Abb. 3.15: HPCLine vs. Quattro
schwindigkeit eines Pentiumprozessors zum 1,31-fachen der Geschwindigkeit des Rech-
ners Quattro. Zu Beginn einer Rechnung ist ein Pentiumprozessor des HPC-Line Worksta-
tionclusters mehr als 1,31 mal schneller, als der Rechner Quattro (ca. 7%). Zwischen 600
und 1200 Sekunden Berechnungsdauer ist der Umrechnungsfaktor 1,31 passend, danach
scheint sich das Geschwindigkeitsverh¨altnis noch weiter zugunsten der SUN-Workstation
zu entwickeln. Aufgrund des begrenzten Speichers konnten wir die Entwicklung nicht
weiter beobachten. Wir gehen davon aus, daß sich das Geschwindigkeitsverh¨altnis allen-
falls noch in einem kleinen Bereich ¨andert (
õ
5%). Falls die Leistung des Pentiumprozes-
sors wider Erwarten weiter relativ zu der des Sparcprozessors fallen sollte, bedeutete das
lediglich, daß die von uns gemessenen Speedups des parallelen Verfahrens besser sind als
im folgenden dargestellt.
3.5.4 Speedupmessungen f¨ur senderinitiierte Cc2s
In diesem Kapitel betrachten wir das Verhalten unseres verteilten Algorithmus auf ver-
schiedenen Maschinen mit bis zu 159 Prozessoren. Alle Ergebnisse wurden auf den Stel-
lungen des Bednorz-T¨onnissen Tests BT2630 ermittelt. Das Programm benutzt dabei alle
bisher beschriebenen Methoden und Heuristiken zur Beschleunigung der Suche (vgl. Ab-
schnitte 2.1 bis 2.3 und 3.4.2). Wir betrachten zuerst Messungen auf dem HPCLine Rech-
ner, bei denen wir die MPI-Version der Firma SCALI benutzen. Diese MPI-Version ver-
wendet die in Abschnitt 3.1 beschriebene SCI-Netzwerktechnologie. Danach pr¨asentieren
wir noch einmal Messungen vom HPCLine-Rechner, bei denen dann aber die Standard-
bibliothek MPICH f¨ur Ethernettechnologie eingesetzt wird. Zum Abschluß pr¨asentieren
wir Speedupergebnisse des CC48 Rechners.
System: HPCLine mit ScaMPI
In Abbildung 3.16 sieht man, wie sich die Speedups f¨ur unterschiedliche Prozessorzahlen
bei wachsenden Rechenzeiten entwickeln. Es f¨allt auf, daß die Speedups f¨ur alle Pro-
zessorzahlen in den ersten 100 Sekunden ansteigen und danach mehr oder weniger kon-
3.5 Experimentelle Leistungsbewertung 95
stant bleiben. Wie man in den Abbildungen 3.18 und 3.17 erkennen kann, steigt in den
0
10
20
30
40
50
60
0 100 200 300 400 500 600 700 800 900
Speedup (1 P/1 Q)
Zeit (sec)
1 Prozessor
2 Prozessor
3 Prozessoren
9 Prozessoren
19 Prozessoren
39 Prozessoren
79 Prozessoren
159 Prozessoenr
Abb. 3.16: Speedups auf dem HPCLine System
0
20
40
60
80
100
0 100 200 300 400 500 600 700 800 900
Suchoverhead
b
Zeit (sec)
2 Prozessor
3 Prozessoren
9 Prozessoren
19 Prozessoren
39 Prozessoren
79 Prozessoren
159 Prozessoren
Abb. 3.17: Searchoverhead auf dem HPCLine System
ersten 100 Sekunden die Auslastung an, w¨ahrend der Suchoverhead gleichzeitig f¨allt.
Der Grund daf¨ur ist, daß die zu Beginn einer Berechnung zu l¨osenden Teilprobleme zu
klein sind, um alle Prozessoren mit sinnvoller Arbeit zu versorgen. So werden z.B. von
DetermineMove(
Å8Å8Å
) zuerst einmal alle Z¨uge an der Wurzel erzeugt und bewertet. Das
Prozessornetzwerk ist in dieser Zeit schlecht ausgelastet.
96 Der Parallele Cc2s-Algorithmus
Erst wenn der zu untersuchende Spielbaum eine gewisse Gr¨oße erreicht hat, finden alle
Prozessoren sinnvolle Arbeit. Damit w¨ahrend dieser ersten kritischen Phase nicht zu viele
Prozessoren arbeitslos sind, werden auch Teilexpansionen von Knoten parallel (Abschnitt
3.4.2) bearbeitet. Die Vorhersagen, welche dieser Spielbaumexpansionen tats¨achlich ge-
braucht werden, sind seltener erfolgreich, als dies bei der Aufteilung von Targets an in-
neren Knoten der Fall ist. Gleichzeitig bewertete Knoten bei einer Spielbaumerweiterung
f¨uhren deshalb zu unvorsichtigem Einsatz von Parallelit¨at und damit zu mehr Suchover-
head.
F¨ur Prozessorzahlen bis 39 werden (ab ca. 150 Sekunden paralleler Rechenzeit) Effizien-
zen von 50% (H¨ochstwert bei 39 Prozessoren: 53%), f¨ur 79 Prozessoren eine Effizienz
von 38%, und f¨ur 159 Prozessoren eine Effizienz von 32% erreicht.
Die Suchoverheadmessungen (vgl. Abb. 3.17) geben keinen endg¨ultigen Aufschluß da-
r¨uber, ob eine steigende Prozessorzahl auch zu steigendem Suchoverhead f¨uhrt. Zwar
entspr¨ache das unseren Erwartungen, und 2,3 und 9 Prozessoren ben¨otigen auch sichtbar
weniger Suchoverhead als 79 oder 159 Prozessoren, aber auch 19 Prozessoren untersu-
chen mit ¨uber 40% Suchoverhead sehr viele Knoten. Erfreulich ist, daß sich der Sucho-
verhead im Laufe der Zeit nicht erh¨oht, sondern nahezu gleich bleibt. Der Grund daf¨ur,
0
0.2
0.4
0.6
0.8
1
0 100 200 300 400 500 600 700 800 900
Auslastung
c
Zeit (sec)
2 Prozessoren
3 Prozessoren
9 Prozessoren
19 Prozessoren
39 Prozessoren
79 Prozessoren
159 Prozessoren
Abb. 3.18: Auslastung auf dem HPCLine System
daß sich die Effizienz mit zunehmender Prozessorzahl verschlechtert, ist eher in der be-
grenzten Auslastung zu sehen (vgl. Abb. 3.18). Die entstehenden Suchb¨aume sind sehr
unregelm¨aßig und schmal. Deshalb gibt es immer wieder mal Zeitabschnitte, in denen
kleine Teilprobleme erst zu Ende gerechnet werden m¨ussen, bevor deren Ergebnisse neue
3.5 Experimentelle Leistungsbewertung 97
kleine Teilprobleme initiieren, bei denen der Cc2s-Algorithmus auch wieder nur weni-
ge Prozessoren bei der Auswertung zum Einsatz bringen kann (vgl. [LR96]). Wenn der
Cc2s-Algorithmus ein Teilproblem bearbeitet, bei dem er maximal (sagen wir) 5 Prozes-
soren einsetzen kann, wirkt sich das in einem großen Prozessornetzwerk mit 159 Prozes-
soren nat¨urlich wesentlich st¨arker aus als in einem kleinen mit nur 9 Prozessoren. Der
hier vorgestellte Algorithmus arbeitet in diesen Phasen nicht feingranular genug, um die
vorhandene Last verteilen zu k¨onnen.
Die Maschine, auf der P.ConNerS l¨auft, begrenzt ebenfalls die maximal m¨ogliche Aus-
lastung: Wenn die Ringe, auf denen die Nachrichten wandern m¨ussen, saturiert werden,
f¨uhrt das zu Verz¨ogerungen von Nachrichten. Wir werden im n¨achsten Abschnitt sehen,
daß langsamerer Nachrichtenaustausch die Auslastung des Systems deutlich verschlech-
tert.
Kaum relevant sind andere Einfl¨usse, wie z.B. die Schedulingzeiten, in denen Tasks aus-
getauscht werden. Die sind bei den Messungen schon in der Auslastung enthalten.
Im Bereich ab 100 Sekunden paralleler Laufzeit befinden sich die Lastkurven (Abbildung
3.18) zwischen 45 und 70 Prozent. Daß die Auslastungen bei 19 und 39 Prozessoren
mit Abstand besser sind als bei den ¨ubrigen Prozessoreanzahlen, liegt unseres Erachtens
nach nur daran, daß uns zu Testzwecken meistens Partitionen mit bis zu 39 Prozessoren
zur Verf¨ugung standen. Ohne es zu beabsichtigen haben wir das Gesamtsystem auf diese
Partitionsgr¨oßen optimiert.
System: HPCLine mit MPICH
Wir zeigen nun, wie wichtig und f¨ur eine Parallelisierung und f¨ur unseren verteilten Cc2s-
Algorithmus entscheidend die Kommunikationsgeschwindigkeit eines Parallelrechners
ist. Wir messen dazu das Verhalten unseres Schachprogramms auf bis zu 79 Prozesso-
ren, verzichten aber auf den Einsatz der SCI unterst¨utzten MPI-Library der Firma SCALI
und benutzen stattdessen eine Fastethernet-Verbindung und die MPICH-Standardlibrary.
Interessanterweise erhalten wir auch hier nach ca. 150 bis 200 Sekunden den maximalen
Speedup (Abb. 3.19). Allerdings ist er wesentlich niedriger als unter dem SCI-Verbin-
dungsnetzwerk. Mit 79 Prozessoren kommt der Algorithmus nicht ¨uber einen Speedup
von 12 hinaus. Erreicht das Programm mit 9 Prozessoren noch eine Effizienz von ca.
40% (nach 200 Sekunden paralleler Laufzeit), liegt diese bei 79 Prozessoren nur noch
bei 15% (nach 200 Sekunden paralleler Laufzeit). Aufgrund unserer Vor¨uberlegungen in
Abschnitt 3.3.1 hatten wir erwartet, den Grund f¨ur die niedrigen Effizienzen sowohl in
niedriger Auslastung als auch in hohem Suchoverhead zu finden.
98 Der Parallele Cc2s-Algorithmus
0
2
4
6
8
10
12
14
0 100 200 300 400 500 600 700 800 900
Speedup (1 P/1 Q)
Zeit (sec)
1 Prozessor
2 Prozessor
3 Prozessoren
9 Prozessoren
19 Prozessoren
39 Prozessoren
79 Prozessoren
Abb. 3.19: Speedups auf dem HPCLine System unter MPICH
0
20
40
60
80
100
0 100 200 300 400 500 600 700 800 900
Suchoverhead
b
Zeit (sec)
2 Prozessor
3 Prozessoren
9 Prozessoren
19 Prozessoren
39 Prozessoren
79 Prozessoren
Abb. 3.20: Searchoverhead auf dem HPCLine System unter MPICH
Interessanterweise ist derSuchoverheadnahezugleich dem Suchoverheadder SCI-Version
(Abb. 3.20). (Die einzige Ausnahme bildet hier der Lauf mit 39 Prozessoren, der teilwei-
se ¨uber 70% Suchoverhead erzeugte.) Der eigentliche Grund f¨ur die schlechten Speedups
bei der Verwendung der MPICH-Programmbibliothek liegt wieder in der niedrigen Aus-
lastung (Abb. 3.21) des Prozessornetzwerkes. Schon bei kleinen Prozessorzahlen (z.B. 3
und 9) liegt sie unter 40%. Bei 79 Prozessoren sinkt sie sogar auf 20% ab. Da aber die
Anzahl der vorhandenen Teilprobleme in etwa gleich hoch ist wie bei der SCI gest¨utzten
3.5 Experimentelle Leistungsbewertung 99
Version (da der Suchoverhead weitestgehend konstant bleibt und er auch nicht von der
Kommunikationsgeschwindigkeit abzuh¨angen scheint, gehen wir davon aus, daß die An-
zahl der insgesamt zu erzeugenden Teilprobleme in erster Linie von der Ausgangsstellung
und der geforderten Ergebnissicherheit an der Wurzel abh¨angt), kann die Granularit¨at der
Parallelisierung hier nicht als Grund f¨ur die niedrige Auslastung angef¨uhrt werden.
0
0.2
0.4
0.6
0.8
1
0 100 200 300 400 500 600 700 800 900
Auslastung
c
Zeit (sec)
2 Prozessoren
3 Prozessoren
9 Prozessoren
19 Prozessoren
39 Prozessoren
79 Prozessoren
Abb. 3.21: Auslastung auf dem HPCLine System unter MPICH
Beobachtung 3.5-5
Die Effizienz des parallelen Cc2s-Algorithmus h¨angt in erster Linie von der erreich-
ten Auslastung des Prozessornetzwerkes ab. Beim Vergleich der SCI- und Fastethernet-
Netzwerke stellt man fest, daß die erreichte Auslastung entscheidend von der zugrunde
liegenden Hardware abh¨angt.
d
CC48
Die Meßergebnisse, die wir auf dem CC-48 Rechner erhalten haben, sind s¨amtlichst aus
dem Jahr 1997 und somit wesentlich ¨alter als die Ergebnisse des HPCLine Rechners. Lei-
der existiert der CC-48 nicht mehr, so daß wir auch keine neueren oder genaueren Ergeb-
nisse vorzeigen k¨onnen. Aufgrund seiner Topologie und dem damit erreichten Verh¨altnis
von Kommunikationsgeschwindigkeit zu Rechengeschwindigkeit der Prozessoren konn-
ten dort, auch ohne die Parallelit¨at der letzten Ebene zu nutzen (Abschnitt 3.4.2), Effizi-
enzen von ca. 50% erreicht werden.
100 Der Parallele Cc2s-Algorithmus
# Speedup Suchoverhead
5 3.0 24%
9 5.9 41%
19 12.3 33%
39 19.8 48%
Tab. 3.3: Ergebnisse auf dem CC48 Rechner
3.5.5 Streuungsmessungen auf der HPCLine
Die im vorigen Kapitel vorgestellten Ergebnisse beruhen auf jeweils einem festen Test-
lauf. Wir untersuchen nun das Streuungsverhalten von Speedup Testl¨aufen mit 39 Prozes-
soren unter Verwendung des SCI-Netzwerkes.
0
5
10
15
20
25
30
35
40
45
50
0 5 10 15 20 25 30
Speedup
e
Stellung
Lauf 1
Lauf 2
Lauf 3
Lauf 4
Lauf 5
Lauf 6
Abb. 3.22: Streuung bei 39 Prozessoren
Der in dieser Arbeit vorgestellte Cc2s-Algorithmus arbeitet in hohem Maße nichtdetermi-
nistisch, wenn er auf mehr als einem Prozessor eingesetzt wird. Der Nichtdeterminismus
entsteht dadurch, daß wir nicht spezifiziert haben, zu welchen Zeitpunkten und in welcher
Reihenfolge Nachrichten bei einem Prozessor eintreffen. In der Tat ist das genau die Si-
tuation, die wir auf einem lose gekoppelten Prozessornetzwerk im allgemeinen vorfinden.
Asynchrone Kommunikationsmechanismen, z.B. unter MPI, zeichnen sich dadurch aus,
daß zwar garantiert wird, daß eine Nachricht, die von einem Prozessor abgeschickt wurde,
sein Ziel irgendwann erreicht, aber es werden keine Angaben gemacht, zu welchem Zeit-
punkt genau die Nachricht ankommt. Kleinste Ver¨anderungen der Luftfeuchtigkeit, der
Raumtemperatur, der Ausgangskonfiguration etc. sorgen f¨ur erhebliche Ver¨anderungen.
3.5 Experimentelle Leistungsbewertung 101
Um Streuungen in der parallelen Laufzeit zu untersuchen, haben wir beispielhaft f¨ur 39
Prozessoren jeweils sechs Testl¨aufe durchgef¨uhrt. Jeder einzelne Testlauf wurde wie im
vorigen Abschnitt beschrieben erstellt. Die Speedupergebnisse jeder einzelnen Stellung
aller sechs Testl¨aufe sind in Abbildung 3.22 dargestellt. Dabei ergeben sich teilweise er-
hebliche Streuungen bei einzelnen Teststellungen. Die st¨arksten Streuungen ergeben sich
bei den Stellungen BT2 und BT9.
Bei Stellung BT2 ergibt sich ein Mittelwert von
4"
#Ò
f%2"
1
Ò
^Tg%hT
Ò
#af%
øÇ
Za
4Ò
#`f%h8
4Ò
1
f%i
4ÇÒ8ÇÇ
^
Þ
j8^
Ò
ak_
Å
Die maximale Abweichung vom Mittelwert in Prozent, bezogen auf den Mittelwert be-
tr¨agt somit
"
1
Ò
^kS28^
Ò
ak_
8^
Ò
ak_
*
Ç
1T1Tl
Þ
m
1
Ò
_
l
Å
Bei BT9 ist der Mittelwert 16,43 und die prozentuale Abweichung sogar 63%.
Bei anderen Stellungen, wie z.B. BT23 beobachtet man wesentlich geringere Abweichun-
gen. Dort betr¨agt der Mittelwert
1
Ò8ÇÇ
P%
Ç
Za
4Ò
"%h
1
Ò
#T`f%
øÇ
Za
Ò
kg%h
1
Ò
#"ng%i
1
Ò8Ç
Za
^
Þ Ç
Za
4Ò
ak
Å
und die maximale Abweichung vom Mittelwert in Prozent, bezogen auf den Mittelwert
Ç
Za
4Ò
akS
1
Ò
_
Ç
Ç
a
4Ò
ak
Þ
j
4Ò
#^
l
Å
Die Schwankungen des Speedups auf der gesamten Reihe sind gering. Der durchschnitt-
liche Speedup schwankt zwischen 18,92 und 19,95. Das aritmethische Mittel ergibt
Ç
`
4Ò
ak.%
Ç
Za
4Ò
^8af%
øÇ
Za
4Ò
#akg%
øÇ
Za
Ò
8`f%
øÇ
a
4Ò
8`f%
Ç
Za
4Ò
#"n
^
Å
Damit ist die maximale Abweichung des durchschnittlichen Speedups vom Mittelwert
lediglich 2,87%.
Beobachtung: Die Streuungsmessungen zeigen, daß die ausgew¨ahlte Testreihe BT2630,
bestehend aus 30 Einzelstellungen, ausreichend viele Stellungen enth¨alt, so daß die ein-
zelnen, auftretenden Schwankungen der gemessenen Speedups den durchschnittlichen
Speedup ¨uber alle 30 Stellungen nicht zu stark beeinflussen.
F¨ur eine Beurteilung verschiedener Programmversionen gen¨ugt es diese auf einen einzel-
nen Testlauf ¨uber 30 Stellungen zu st¨utzen.
102 Der Parallele Cc2s-Algorithmus
Kapitel 4
Spielbaumsuche mit Fehlern
Spielbaumsuche greift, wie schonim ersten Kapitel erl¨autert, die Probleme auf,die entste-
hen, wenn wir Computer z.B. dazu bringen m¨ochten, Zweipersonen-Nullsummenspiele
wie Schach, Dame, Othello u.s.w. zu spielen. Der bisher gr¨oßte Erfolg von Spielbaumsu-
che war der Sieg von der Schachmaschine ’Deep Blue’ gegen den Weltmeister und besten
menschlichen Schachspieler der Welt, Garry Kasparov.
Trotz der großen Popularit¨at von Computerschach, das geradezu als Inbegriff von k¨unst-
licher Intelligenz angesehen wird, gibt es bislang kein allgemein anerkanntes Modell, das
diese Erfolge erkl¨aren kann oder in dem man gar in der Lage ist, n¨utzliche Anleitungen
herzuleiten, wie man (selektive) Spielbaumsuche einsetzen kann.
In diesem letzten Kapitel stellen wir ein kombinatorisches Modell vor, das Fehler einer
heuristischen Bewertungsfunktion mit Hilfe von W¨urfelexperimenten modelliert. Unter
der Annahme, daß man eine Bewertungsfunktion zur Verf¨ugung hat, deren Fehlerwahr-
scheinlichkeit zwar gr¨oßer als Null, aber doch beliebig nahe an Null ist, wird das Ergeb-
nis sein, daß eine Spielbaumsuche auf einem fest vorgegebenen Spielbaum
X
genau dann
sinnvoll ist, wenn es in dem zu untersuchenden Spielbaum
X
wenigstens zwei blattdis-
junkte Strategien gibt, die den Wert an der Wurzel begr¨unden. Außerdem werden wir f¨ur
eine solch gute Bewertungsfunktion zeigen, daß in einem beliebigen, aber fest gew¨ahlten
Spielbaum
X
die Anzahl blattdisjunkter Strategien, die den Wert der Wurzel begr¨unden,
qualitativ die G¨ute eines heuristischen Minimaxwertes bestimmt. Wie klein die Fehler-
wahrscheinlichkeit der Bewertungsfunktion gew¨ahlt werden muß, damit unsere Aussagen
gelten, h¨angt vom jeweiligen Spielbaum ab.
Alles das f¨uhrt zu einer zumindest intuitiven Erkl¨arung daf¨ur, weshalb der Einsatz von
Conspiracy Number Search sinnvoll ist.
104 Spielbaumsuche mit Fehlern
4.1 Einleitung
4.1.1 Das Vorgehen der Anwender
Wenn ein Spielbaum so groß ist, daß er nicht vollst¨andig durchsucht werden kann und
es somit nicht m¨oglich ist, einen tats¨achlich besten Zug zu bestimmen, benutzen Compu-
ter die folgende Methode, um zu Entscheidungen zu gelangen: Zun¨achst wird ein Teil-
baum des Gesamtspielbaums herausgesucht. Dies kann ein beliebiger Teilbaum sein, der
die Wurzelstellung des Gesamtspielbaums als Wurzel hat. Z.B. kann es sich um einen
Spielbaum handeln, bei dem alle Bl¨atter eine bestimmte Entfernung zur Wurzel haben.
Wir haben diesen ausgew¨ahlten Teilbaum bereits als H¨
ulle bezeichnet. Dann weist ein
Suchalgorithmus jedem Blatt der H¨ulle einen heuristischen Wert zu und rechnet den Mi-
nimaxwert dieser Zahlen zur Wurzel hoch. Meistens wird zu diesem Zweck der sog.
è%é
-Algorithmus [KM75] herangezogen. Was Fehlerh¨aufigkeiten an der Wurzelstellung
angeht, macht es allerdings keinen Unterschied, ob der
è é
-Algorithmus oder ein einfa-
cher Minimax-Algorithmus verwendet wird. Das Ergebnis ist immer das gleiche, nur im
Aufwand, um das Ergebnis auszurechnen, unterscheiden sich die Algorithmen erheblich.
Folgende Beobachtung kann man als gesichert ansehen:
Beobachtung 4.1-6
Das Minimax-Auswerten von Spielb¨aumen, bei dem Spielbaumbl¨atter heuristisch bewer-
tet werden, f¨uhrt in vielen Spielen (insbesondere beimSchachspiel) zu besseren Absch¨atz-
ungen an der Wurzel des Spielbaums als eine direkte heuristische Bewertung der Wurzel.
d
Es stellt sich nun die Frage, ob dieser Effekt naturgegeben ist oder ob m¨oglicherweise be-
stimmte strukturelle Gegebenheiten der Spielb¨aume zu dem beobachteten Effekt f¨uhren.
4.1.2 Fehlermodelle anderer Autoren
Pearl [Pea84] untersuchte Spielb¨aume, bei denen den Bl¨attern die Werte GEWINN und
VERLUST zuf¨allig zugeordnet werden. Das Ergebnis ist, daß in so einem Modell der Mi-
nimaxwert nicht von der inneren Baumstruktur, sondern nur von der Wahrscheinlichkeit
abh¨angt, mit der ein Blatt ein GEWINN-Blatt ist.
Das meistbenutzte Modell zur Fehleranalyse [Pea83], [Nau79], [Nau82], [BG82] geht da-
von aus, daß Bl¨atter eines Spielbaums fehlerhaft mit einer Wahrscheinlichkeit
<
¶
bewertet
werden. Fehlbewertungen geschehen dabei voneinander unabh¨angig.
4.1 Einleitung 105
Schr¨ufer [Sch86] schlug ein Modell vor, in dem er Klassen von Spielb¨aumen top-down
konstruiert. F¨ur bestimmte Spielbaumklassen konnte er nachweisen, daß Spielbaumsu-
che bis zu einer m¨oglichst großen, festen Tiefe n¨utzlich ist. Außerdem konnte er f¨ur
ein spezielles stochastisches Spielbaummodell (das sogenannte S-Baummodell) angeben
[Sch88], unter welchen Bedingungen ein Spiel vertiefungsfreundlichist. Das Modell wird
durch folgende Parameter bestimmt:
$io
aus
p(
, mit
o
ð
q
ist der Branchingfaktor der Spielb¨aume.
$
Echte Werte sind aus
/1
ÒhÇ
83
und gehorchen dem Minimaxprinzip. Man kann dabei
zwei Knotentypen unterscheiden: Nennen wir sie ALL-Knoten (das sind die, an
denen wegen des Minimaxprinzips alle Nachfolger den Wert des Vaters annehmen
m¨ussen) und CUT-Knoten.
$
ÎúÞ
<
¸
Ò8Å8Å8ŵÒ
<sr
sind Wahrscheinlichkeiten daf¨ur, dass
ÇÒ
, oder
o
viele Nachfolger
den Wert eines CUT-Knotens annehmen.
$
Í
·
ist die Wahrscheinlichkeit daf¨ur, daß ein ALL-Knoten falsch eingesch¨atzt wird.
$
Í
À
die Wahrscheinlichkeit daf¨ur, daß ein CUT-Knoten falsch eingesch¨atzt wird.
Sei nun
F
ein Spiel
ã
o
Ò
<
¸
ÒhÅLÅ Ò
<sr
ÒGÍ
À
ÒAÍ
·
æ
, und bezeichnen
Í
·
ã Ï
æ
und
Í
À
ã Ï
æ
die Wahrschein-
lichkeiten f¨ur falsche Einsch¨atzungen von auf Tiefe
Ï
eingeschr¨ankten Teilspielen.
F
sel-
ber l¨aßt sich als Wahrscheinlichkeitsverteilung ¨uber alle m¨oglichen im Modell enthaltenen
Spielb¨aume mit Branchingfaktor
o
interpretieren.
Ein Spiel
F
heißt vertiefungsfreundlich, wenn es
Û
·
,
Û
À
aus dem Intervall
t
1
ÒhÇ
u
gibt, so
daß f¨ur alle
Ï
aus
p(
gilt:
Í
·
ã1Ï
æ õ
Û
·
und
Í
À
ã1Ï
æ õ
Û
À
wv
Í
·
ã Ï
x%'
æ õ
Í
·
ã Ï
æ
und
Í
À
ã Ï
x%q
æ õ
Í
À
ã Ï
æ
. Der Begriff
vertiefungsfeindlich ist analog definiert.
Als Ergebnis bekommt Schr¨ufer heraus:
a)
o
*
<
¸
õ
Ç
v
F
ist vertiefungsfreundlich und
b)
o
*
<
¸
ò
Ç
v
F
ist vertiefungsfeindlich.
F¨ur dieses Modell wurden weitere interessante Ergebnisse pr¨asentiert [Alt88] [Alt90a].
Beal benutzt ebenfalls ein Grundmodell, bei dem Blattwerte mit einer gewissen Wahr-
scheinlichkeit
<
¶
falsch eingesch¨atzt werden. Er schr¨ankt sich aber auf Spielb¨aume ein,
bei denen sich die Blattwerte des Spielbaums clustern [Bea80], da er der Meinung ist,
daß das Ausgangsmodell zu einfach sei,um tiefgreifende Aussagen ausrechnen zu k¨onnen
[Bea82] [Bea99].
106 Spielbaumsuche mit Fehlern
Wir erarbeiten in dieser Arbeit zwei sehr einfache Modelle, von denen das zweite eben-
falls davon ausgeht, daß Bewertungsfehler an Bl¨attern eines Spielbaums zuf¨allig gemacht
werden und daß diese Bewertungsfehler voneinander unabh¨angig sind. Es liefert uns sehr
starke Aussagen, die f¨ur alle Spielb¨aume (also f¨ur jeden einzelnen) und nicht nur f¨ur eine
eingeschr¨ankte Klasse von Spielb¨aumen oder im Durchschnitt ¨uber alle Spielb¨aume gel-
ten.
Wegen der PSPACE-Schwere einiger Zweipersonen-Nullsummenspiele k¨onnen wir nicht
erwarten, daß es uns gelingt, eine einfache Formel zu finden, die uns eine Aussage dar¨uber
gibt, ob ein heuristischer Minimaxwert mit dem echten ¨ubereinstimmt, zumindest nicht
f¨ur alle Spiele, alle Spielsituationen und alle Spielb¨aume, die zu diesen Spielsituationen
geh¨oren. Solch eine Formel w¨urde uns erlauben, den echten Wert der Wurzel schnell zu
berechnen.
Deshalb versuchen wir, die Beschreibung von Fehlern und deren Fortpflanzung in Spiel-
b¨aumen zu vereinfachen. Wir unterscheiden zwischen der Fehleranzahl (Fehlerrate) und
den Fehlerpositionen. Auf diese Weise kann man die Fehler z.B. in folgende drei Klassen
unterteilen: Eine bestimmte Menge von Fehlern kann b¨osartig, gutartig oder auf neutrale
Art positioniert werden. ’Neutrale Art’ soll hier nicht heißen, daß die Fehler so positio-
niert werden, daß sie keine Auswirkung auf das Wurzelergebnis haben (das w¨are eine
gutartige Positionierung), sondern mit ’neutral’ meinen wir, ohne es genauer spezifizie-
ren zu wollen, so etwas wie durchschnittlich oder zuf¨allig. Da die Analyse der ersten
beiden F¨alle trivial ist (vgl. Modell 1) und im allgemeinen auch eine neutrale Fehlerposi-
tionierung am realistischsten ist, konzentrieren wir uns auf den letzten Fall (vgl. Modell
2). Diese Art der Positionierung modellieren wir durch zuf¨allige Fehler, bei vorgegebener
Fehlerwahrscheinlichkeit.
Wir stellen in den folgenden Abschnitten unsere Modelle vor. Begriffe wie ’Spielbaum’,
’Strategie’, ’Minimax’ u.s.w. wurden bereits in Kapitel 1.8 erl¨autert.
4.2 Spielbaumsuche ¨uber Bewertungen mit Fehlern
Modell 1: Es sei ein beliebiger, endlicher Spielbaum
X
ñÞôãÓã
U
Ò
G
æ
Ò
y
æ
vorgegeben. Jeder
seiner Knoten habe entweder den Wert 0 oder 1 (durch
y
bestimmt), und diese ’echten’
Werte gehorchen dem Minimax-Prinzip. Außerdem soll es eine Bewertungsfunktion
5
geben, die die Knoten des Spielbaums auf sogenannte ’heuristische’ Werte abbildet.
5
ist also wie
y
eine Funktion von Knoten in die Menge der m¨oglichen Werte:
5
í
U{z
/1
Ò8Ç
43
.Wenn
y
ã1Æ
æ
ungleich
5
ã1Æ
æ
ist (echter und heuristischer Wert nicht ¨ubereinstimmen),
sprechen wir davon, daß
5
am Knoten
Æ
einen Bewertungsfehler macht.
4.2 Spielbaumsuche ¨uber Bewertungen mit Fehlern 107
Auch wenn es inkonsequent erscheinen mag, daß wir die Funktion
y
als Teil der Spiel-
baumdefinitionen schreiben und
5
nicht, erschien uns eine Umdefinition des Spielbaum-
begriffs nicht sinnvoll. Die Funktion
5
ist lediglich eine Hilfskonstruktion, die es uns
erm¨oglichen soll, mit den einfachen formalen Mitteln von kombinatorischen Modellen
auszukommen.
Weiterhin ist uns klar, daß man in der Praxis eher mit heuristischen Bewertungsfunktionen
arbeiten wird, die einen gr¨oßeren Wertebereich als
/1
Ò8Ç
83
haben. Zum einen erleichtert
diese Einschr¨ankung aber unsere Analysen, zum anderen reicht diese Wertemenge aus,
um die von uns als wichtig erachteten Effekte zu beschreiben.
Die heuristischen Werte gen¨ugen nicht unbedingt dem Minimaxprinzip. Man kann al-
lerdings einen heuristischen Minimaxwert f¨ur die Wurzel eines Spielbaums ausrechnen,
indem man die heuristischen Blattwerte nach dem Minimaxprinzip zur Wurzel hochpro-
pagiert. Wir benutzen bei der Analyse das Minimaxprinzip, weil es dasjenige Prinzip ist,
das sich in der Praxis durchgesetzt hat (s.o). Man kann sich aber auch andere Verfahren
zur Wertbildung innerer Knoten vorstellen [Alt90b].
Rufen wir uns noch einmal den Begriff der blattdisjunkten Strategien ins Ged¨achtnis:
v1
v4 v5 v6 v7 v8
v9 v10
v11 v12 v13 v14
v2 v3
0
0
0
0
1 10
0 0
000 0
0
Abb. 4.1: Spielbaum
X
Um in dem hier gegebenen Beispiel (Abb. 4.1) zu zeigen, daß der Wert der Wurzel von
X
den Wert 0 hat, brauchen wir nur den Teilbaum auszuwerten, der aus den Knoten
F
¸
í!Þ
/
Æ?ÇÒGÆ
|
ÒÓÆ
|
ÒGÆ
|
ÒGÆ
}`
4ÒGÆ
}a
4ÒGÆ?Ç
1
ÒGÆ?Ç
Z
ÒGÆ?Ç
~"3
besteht. Wir nennen diesen Teilbaum, der
den Wert 0 als obere Schranke beweist, eine belegende (Beweis)-Strategie. Die Knoten
F
íÞ
/
Æ?Ç
,
Æ
|
,
Æ
}
,
Æ
|
,
Æ
}`
,
Æ
}a
,
Æ?Ç
1
,
Æ?ÇÇ
,
Æ?Ç
"|3
bilden ebenfalls eine Beweisstrategie f¨ur den
Wert 0. Im Gegensatz zu
F
:
í!Þ
/
ÆÇ
,
Æ
,
Æ
|
,
Æ
,
Æ
_
,
Æ
|a
,
ÆÇ
1
,
Æ?ÇÇ
,
Æ?Ç
Z|3
ist sie jedoch nicht
blattdisjunkt zu
F
¸
.
F
¸
und
F
:
sind blattdisjunkte Strategien, die beide den Wert 0 an der
Wurzel beweisen.
108 Spielbaumsuche mit Fehlern
Folgende zwei Aussagen sind einfach einzusehen:
Wenn
X
Ë
blattdisjunkte Strategien enth¨alt, die alle den Wurzelwert belegen, darf
5
min-
destens
Ë
QÇ
viele Bl¨atter falsch bewerten, ohne daß der heuristische Minimaxwert der
Wurzel von
X
falsch wird.
Wenn
X
genau
Ë
solcher blattdisjunkte Strategien enth¨alt und
5
Ë
Fehler macht, kann
man durch eine b¨osartige Positionierung dieser Fehler erreichen, daß auch der Wurzelwert
falsch wird.
4.3 Spielbaumsuche ¨uberBewertungenmitzuf¨
alligenFeh-
lern
Im Normalfall wird nicht gerade unser Gegner die Fehler unserer Bewertungsfunktion
positionieren! Insofern ist die obige Aussage unbefriedigend. Man ist doch eher daran
interessiert, was passiert, wenn die Fehler irgendwie, neutral verteilt werden. Wenn man
also z.B. zus¨atzlich annimmt,
X
habe
viele Bl¨atter, und
5
mache
Ý
viele Fehler, m¨ochte
man wissen, in wievielender
Ý
+
m¨oglichen F¨alle,
Ý
Fehler auf
Bl¨atter zu verteilen,
der heuristische Minimaxwert richtig ist und mit dem echten Wert ¨ubereinstimmt.
Diese Fragestellung scheint f¨ur alle m¨oglichen Spielb¨aume nur schwerlich analysierbar
zu sein.
Man kann die Fragestellung aber leicht abwandeln: Was l¨aßt sich aussagen, wenn man
davon ausgeht, daß
X
viele Bl¨atter besitzt und
5
ungef¨ahr
ãÇ
<
æ
*}
viele Fehler
macht, wobei
<
-
ã
1
ÒhÇ
æ
ist? Diese Frage f¨uhrt direkt zu Modell 2:
Modell 2: Es sei ein beliebiger, endlicher Spielbaum
X
üÞçãã
U
Ò
G
æ
Ò
y
æ
vorgegeben. Je-
der seiner Knoten habe entweder den Wert 0 oder 1, und diese ’echten’ Werte gehorchen
dem Minimax-Prinzip. Wir f¨uhren M¨unzw¨urfe an den Bl¨attern durch, so daß ein Blatt mit
Wahrscheinlichkeit
<
seinen Wert beh¨alt und mit Wahrscheinlichkeit
Ç
<
den komple-
ment¨aren Wert zugewiesen bekommt. Der Einfachheit halber gehen wir davon aus, daß
<
f¨ur alle Bl¨atter gleich ist. An den inneren Knoten von
X
bilden wir die Minimaxwerte der
verf¨alschten ’heuristischen’ Werte. Nachdem alle heuristischen Blattwerte ausgew¨urfelt
sind, beschreibe eine Funktion
5
die Abbildung der Knoten in die heuristischen Werte.
Die zu untersuchende Fragestellung ist, mit welcher Wahrscheinlichkeit der echte und
der heuristische Minimaxwert der Wurzel von
X
gleich sind.
Wir werden zeigen, daß der Begriff der ’blattdisjunkten Strategien’ auch in diesem Mo-
dell eine ganz zentrale Bedeutung besitzt. Unter derAnnahme, daß die Wahrscheinlichkeit
daf¨ur, daß
5
einen fehlerhaften Wert liefert, nahe genug bei Null ist, werden wir beweisen,
daß die Anzahl der blattdisjunkten Beweisstrategien, die alle den Wurzelwert beweisen,
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 109
bestimmt, wie gut der Wurzelwert durch einen heuristischen Minimaxwert approximiert
wird. Wenn nicht wenigsten 2 solcher blattdisjunkten Strategien vorhanden sind, f¨uhrt
(bei Verwendung einer fast perfekten Bewertungsfunktion
5
) eine Minimaxauswertung
des gegebenen Spielbaums zu einer schlechteren L¨osung als eine direkte heuristische Be-
wertung der Wurzel.
Man beachte, daß unsere Ergebnisse f¨ur alle(!) Spielb¨aume gelten. Sie sind weder einge-
schr¨ankt auf Spielb¨aume mit fester Tiefe noch auf Spielb¨aume, bei denen sich die Werte
in irgendeiner Weise clustern. Dar¨uberhinaus werden lediglich die Fehler an den Bl¨attern
als zuf¨allig angenommen, nicht die Spielb¨aume selber.
4.3.1 Analyse
Sei ein beliebiger, aber endlicher Spielbaum
X
in Modell 2 gegeben. Im folgenden be-
zeichne
die Wurzel von
X
. Wie groß ist die Wahrscheinlichkeit, daß h(
) = f(
) in
Abh¨angigkeit von der Nichtfehlerwahrscheinlichkeit
<
an den Bl¨attern von
X
ist, wenn
wir davon ausgehen, daß einzelne Fehler vollst¨andig voneinander unabh¨angig gemacht
werden? (Wir k¨onnen uns z.B. vorstellen, daß die Fehler durch M¨unzw¨urfe erzeugt wer-
den.)
Wegen der Baumstruktur von
X
sind dann Nichtfehlerwahrscheinlichkeiten von blattdis-
junkten Teilb¨aumen ebenfalls voneinander vollst¨andig unabh¨angig. Die Wahrscheinlich-
keit, an der Wurzel eine richtige heuristische Bewertung zu bekommen, ist ein Polynom
in der Nichtfehlerwahrscheinlichkeit
<
.
Sei
Æ
exemplarisch ein MAX-Knoten. Die folgenden Skizzen verdeutlichen, wie man jene
Polynome rekursiv berechnen kann.
1.
Æ
besitze den echten Wert 1:
...
...
...
b−mal
1
11
m−mal
0 0
Wurzel v
Spielbaum G
v1vb
Seien
Æ
¸
Ò8ÅhÅ8ŵÒÓÆ
r
die Nachfolger der Wurzel
Æ
der Beispielsituation in Abbildung
1. Seien
¸
ã
<
æ
Ò8Å8ÅhŵÒ
?
r
ã
<
æ
vollst¨andig unabh¨angige Wahrscheinlichkeiten daf¨ur, daß
die heuristischen Werte
5
ãdÆ
;
æ
ÒGÉ
-m/
Ç ÅhÅ8Å
o
3
mit den echten Werten
y
ã1Æ
¸
æ
ÅhÅ8Å
#y
ãdÆ
r
æ
an den Knoten
Æ
¸
Å8Å8ÅÆ
r
korrespondieren. Wir k¨onnen dann die Wahrscheinlichkeit
110 Spielbaumsuche mit Fehlern
º
ã
<
æ
, daß der heuristische Minimaxwert von
Æ
mit dem echten Wert von
Æ
korre-
spondiert, folgendermaßen berechnen:
º
ã
<
æ
ist gleich der Wahrscheinlichkeit, daß nicht alle Nachfolger von
Æ
den heuri-
stischen Wert 0 zugewiesen bekommen.
º
ã
<
æ
Þ Ç
f
ã
¸
ãÇ
f0
ã
<
æÓæ
*
r
·¸
ã
<
æÓæ
Im folgenden sei
p(
die Menge der nat¨urlichen Zahlen (ohne 0) und IR bezeichne
die Menge der reellen Zahlen.
2.
Æ
besitzt den echten Wert 0:
...
...
...
b−mal
0
0 0 0 0
Spielbaum G Wurzel v
vv
1b
Seien
Æ
¸
Ò8Å8Å8ŵÒGÆ
r
wieder die Nachfolger des Knotens
Æ
, wobei
Æ
die Wurzel der
Beispielsituation der Abbildung 2 sein soll. Wenn wir die Wahrscheinlichkeiten
¸
ã
<
æ
Ò8Å8ÅhÅhÒ
?
r
ã
<
æ
kennen, daß ein heuristischer Wert
5
ã1Æ
æ
ÒGÉ
-A/
Ç`Å8ÅhÅ
o
3
mit dem
echten Wert
y
ãdÆ
;
æ
Þ
1
des Knotens
Æ
;
korrespondiert, k¨onnen wir die Wahrschein-
lichkeit
º
ã
<
æ
daf¨ur ausrechnen, daß der heuristische Wert
5
gleich dem echten
Wert von
Æ
ist. Sie ist
º
ã
<
æ
Þ
r
¸
4
^ã
<
æ
.
Das f¨uhrt uns zu folgender formalen Begriffsbildung:
Definition 4.3-14 (Qualit¨
atspolynom)
Es sei
<
-
t
1
ÒhÇ
u
die Nichtfehlerwahrscheinlichkeit der heuristischen Bewertungsfunktion
am Blatt, es sei
X
Þ ãã
U
Ò
G
æ
Ò
y
æ
Spielbaum mit Wurzel
, und es sei
Æ
-
U
. F¨ur einen
Knoten
Æ
gebe
~ã1Æ
æ
an, wieviele Nachfolger von
Æ
den gleichen echten Wert wie
Æ
haben.
Das Qualit¨
atspolynom
º
ã
<
æ
ist definiert durch
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 111
º
ã
<
æ
Þ
<
, falls
Æ
Blatt ist
º
ã
<
æ
Þ
r
¸
º
D
ã
<
æ
, falls
Æ
innerer MAX-Knoten mit Wert 0
oder innerer MIN-Knoten mit Wert 1 ist.
º
ã
<
æ
Þ Ç
f
øã
º
?>
¸
ãÇ
f
º
D
ã
<
æÓæ
*
r
º
M>
·¸
º
D
ã
<
æÓæ
Ò
falls
Æ
innerer MAX-Knoten mit Wert 1
oder innerer MIN-Knoten mit Wert 0 ist.
H
ã
<
æ
nennen wir das Qualit¨atspolynom von
X
.
d
Wir k¨onnen formal einige interessante S¨atze mit Hilfe einer neuen, sehr eleganten Tech-
nik beweisen (Beweise siehe n¨achstes Unterkapitel):
Sei
W
ã
<
æ
das Qualit¨atspolynom eines Spielbaums
X
mit Wurzel
. Bezeichne ferner
¶
ã
<
æ
bzw.
¸
>
ã
<
æ
die erste Ableitung von
H
ã
<
æ
.
Lemma 4.3-1
F¨ur alle Spielb¨aume gilt
¶
ãÇ
æ
Þ
1
oder
¶
ãÇ
æ
ðTÇ
.
d
Beobachtung 4.3-7
Schaut man in den Beweis von Satz 4.3-1, so sieht man auch die folgenden Eigenschaf-
ten des Qualit¨atspolynoms sofort ein:
¶
ãÇ
æ
ist immer ganzzahlig und nichtnegativ.
¶
ãÇ
æ
z¨ahlt, wieviele kritische Bl¨atter der Spielbaum hat. (Dabei heißt ein Blatt kritisch, wenn
eine ¨
Anderung seines echten Wertes bis zur Wurzel durchschlagen w¨urde. [Alt00])
d
Satz 4.3-8
¶
ãÇ
æ
Þ
1
genau dann, wenn der Spielbaum
X
wenigstens zwei blattdisjunkte Beweis-
strategien enth¨alt, die den Wurzelwert von
X
beweisen.
d
Sei
X
wieder ein beliebiger, endlicher Spielbaum und
seine Wurzel. Mit
C
>
bezeichnen
wir die n-te Ableitung von
W
. Durch Induktion k¨onnen wir folgenden neuen, zentralen
Satz beweisen:
112 Spielbaumsuche mit Fehlern
Satz 4.3-9
C
>
ãÇ
æ
Þ
C
À¸
>
ãÇ
æ
Þ
*Z*Z*
Þ
¸
>
ãÇ
æ
Þ
1
Es gibt
Ë
%
NÇ
blattdisjunkte Beweisstrate-
gien unter
, die den echten Wert von
beweisen.
d
4.3.2 Interpretation der Ergebnisse
Abbildung 4.2 zeigt drei m¨ogliche Kurvenverl¨aufe von
W
ã
<
æ
und zus¨atzlich die Iden-
tit¨atsfunktion. Wegen des folgendes Lemmas und wegen Lemma 4.3-1 sind diese in der
N¨ahe von
<
Þ Ç
auch alle Verl¨aufe von Interesse.
Lemma 4.3-2
Sei
H
ein Qualit¨atspolynom des Spielbaums
X
. Dann gibt es ein
ë
ò
1
, so daß
W
ã
<
æ
im
Intervall
<
-
t
Ç
f
ëÒ8Ç
~u
streng monoton steigt.
Grund:
H
ist ein Polynom. Sei
Ë
der endliche Grad dieses Polynoms. Damit hat
¶
h¨ochstens
Ë
Ç
verschiedene Nullstellen und
H
somit h¨ochstens
Ë
0
SÇ
verschiedene
lokale Extrema. Wir wissen ¨uber
W
, daß es f¨ur alle
ë
-
ã
1
Ò8Ç
æ
ein
<
-
t
Ç
NëÒ8Ç
~u
gibt
mit
W
ã
<
æõ
Ç
. (Sonst w¨are
W
ã
<
æ
.
Ç
, was aufgrund der Konstruktion von Qualit¨atspo-
lynomen ausgeschlossen werden kann, oder es g¨abe ein
<
-
t
1
ÒhÇ
u
mit
W
ã
<
æûò
Ç
, was
ebenfalls ausgeschlossen werden kann, weil
W
eine Wahrscheinlichkeit ist.) Wir sortieren
nun die lokalen Extrema von
W
und nehmen uns das der 1 am n¨achsten liegende lokale
Minimum heraus. Liege dieses an der Stelle
ë
mit
ë
õ
Ç
. F¨ur alle
<
-
ãÇ
f
bë-ÒhÇ
æ
gilt nun,
daß
¶
ã
<
æ
&
Þ
1
ist, und damit in diesem Fall, daß
¶
ã
<
æ ò
1
ist. Damit ist
W
ã
<
æ
streng
monoton steigend auf dem Intervall
ãÇ
f
ëÒ8Ç
æ
.
d
F¨ur den Fall, daß
W
ã
<
æ
È
<
, bietet eine direkte Bewertung offenbar eine bessere Chance,
den wahren Wert der Wurzel von
X
zu erkennen, als die Minimax-Auswertung von
X
.
Das heißt, es ist nur dann sinnvoll einen Suchbaum auszuwerten, wenn gilt, daß
W
ã
<
æIò
<
. Sonst w¨are es besser, die Wurzel
mit Hilfe der heuristischen Bewertungsfunktion di-
rekt zu bewerten.
Beobachtung 4.3-8
Wenn
H\
ã
<
æ
und
W
ã
<
æ
Qualit¨atspolynome von zwei Spielb¨aumen
X
und
sind und
wenn gilt, daß
¶
ãÇ
æ
Þ
1
und
¶
ãÇ
æ
ðEÇ
ist, gibt es immer ein
ë
ò
1
, so daß f¨ur alle
<
-
t
Ç
f
ëÒ8Ç
æ
gilt, daß
H\
ã
<
æIò
H
ã
<
æ
ist.
Wenn unsere Bewertungsfunktion gut genug ist, wird
X
zu besseren Erkennungsergeb-
nissen f¨uhren als
. Man beachte, daß dies f¨ur alle Paare von Spielb¨aumen mit den ge-
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 113
1
1
Q (p)
ε
p, Güte einer direkten Bewertung
Abb. 4.2: Skizze m¨oglicher Kurvenverl¨aufe von
H
ã
<
æ
.
nannten Eigenschaften gilt! Dabei k¨onnte
X
eine H¨ulle sein, die dem Schach-Mittelspiel
entnommen ist, und
k¨onnte gleichzeitig vom Damespiel entnommen worden sein.
d
Nach diesen ¨
Uberlegungen veranlassen uns Lemma 4.3-1 und Satz 4.3-8 zur folgenden
Definition:
Definition 4.3-15 (N¨utzlichkeit)
¶
ã
<
æ
bzw.
¸
>
ã
<
æ
bezeichnen die erste Ableitung von
W
ã
<
æ
. Wir nennen einen Spiel-
baum
X
n¨
utzlich, wenn
¶
ãÇ
æ
Þ
1
. (Weil außerdem f¨ur alle Qualit¨atspolynome gilt, daß
¶
ãÇ
æ
Þ
1
oder
¶
ãÇ
æ
ðSÇ
ist (Satz 4.3-1), liefert uns diese Definition ein deutliches Un-
terscheidungskriterium zwischen ’guten’ und ’schlechten’ Spielb¨aumen, wenn nur unsere
Bewertungfunktion gut genug ist.)
d
Folgerung: Ein Spielbaum
X
ist somit genau dann n¨utzlich, wenn
X
mindestens zwei
blattdisjunkte Strategien enth¨alt, die den echten Wert der Wurzel von
X
belegen.
Wenn wir nun einmal eine Taylorreihenentwicklung unserer Qualit¨atsploynome betrach-
ten, stellen wir fest, daß die Reihenentwicklung
y
ã
<
æ
Þ
y
ãÇ
æ
%¡y
¶
ãÇ
æ
ã
<
SÇ
æ
%¢*Z*Z*|%
£¤¦¥#§
¸
>
C4¨
ã
<
,Ç
æ
C
%ª©YC
·¸
ã
<
æ
dazu f¨uhrt, daß
«
W
ã
<
æ
W
ãÇ
æ
«
Þ
O
ããÇ
g
<
æ
C
·¸
æ
genau dann
gilt, wenn die ersten
Ë
Ableitungen von
H
ã
<
æ
an der Stelle 1 gleich 0 sind. Mit Satz 4.3-9
114 Spielbaumsuche mit Fehlern
wissen wir, daß das genau dann der Fall ist, wenn
X
Ë
¬%
xÇ
blattdisjunkte Strategien enth¨alt.
Folgerung: In der N¨ahe der Stelle
<
ÞFÇ
bestimmt die Anzahl der vorhandenen Beweis-
strategien gr¨oßenordnungsm¨aßig die Qualit¨at der Minimax-Auswertung.
Wenn also ein Spielbaum
X
mehr blattdisjunkte Beweisstrategien enth¨alt als ein anderer
Spielbaum
und wenn
<
nahe genug bei 1 liegt, ist die Wahrscheinlichkeit daf¨ur, daß
der heuristische Minimaxwert von
mit dem Wurzelwert ¨ubereinstimmt, kleiner als die
entsprechende Wahrscheinlichkeit bei
X
. Dies ist unabh¨angig von der Anzahl der Kno-
ten, die
X
und
enthalten, unabh¨angig davon, von welchen Spielen
X
und
entnommen
wurden und unabh¨angig von weiteren Struktureigenschaften wie z.B. dem Verzweigungs-
grad in
X
und
.
Wir kommen dadurch zu folgenden Vermutungen f¨ur die Praxis:
$
Normalerweise werden wir nicht wissen, wieviele blattdisjunkte Beweisstrategien
eine von uns ausgew¨ahlte H¨ulle enth¨alt, da wir die echten Werte der Knoten nicht
kennen. Man kann als Heuristik allerdings die blattdisjunkten Strategien z¨ahlen, die
entstehen, wenn man die heuristischen Blattwerte auswertet. Man kann darauf hof-
fen, daß die durch die heuristischen Werte entstehende Struktur des Spielbaums die
Struktur der echten Werte gut nachbildet. Genau das wird von der schon erw¨ahnten
Conspiracy Number Search gemacht. Sie maximiert die Anzahl der Bl¨atter, die ih-
ren heuristischen Wert ¨andern m¨ussen, damit sich der heuristische Wert der Wurzel
¨andert. (Zum Zusammenhang von blattdisjunkten Strategien und Conspiracy Num-
bers siehe Satz 2.1-1.)
$
Die Anzahl der den Wurzelwert beweisenden Strategien, die in einem Spielbaum
X
enthalten sind, ist nicht der Schl¨ussel zur Qualit¨at von Spielbaumsuche, sondern
die Anzahl der blattdisjunkten Beweisstrategien. Es kann durchaus Tausende von
Beweisstrategien geben, aber zwei blattdisjunkte sind trotzdem nicht vorhanden.
$
Der Verzweigungsgrad ist nicht Teil unserer Ergebnisse. Wir gehen deshalb davon
aus, daß seine Bedeutung grob ¨ubersch¨atzt wird, wenn es um die approximative
Auswertung von Spielb¨aumen geht. Insbesondere f¨ur das Go-Spiel halten wir es
zwar f¨ur denkbar, daß Spielbaumsuche in dem Spiel auch weiterhin nicht zu durch-
schlagendem Erfolg f¨uhren wird, man sollte aber den hohen Branchingfaktor des
Spiels nicht als Grund anf¨uhren.
$
Beim Schachspiel gibt es einige heuristik-basierte Ideen, wie man eine H¨ulle for-
men sollte. Wir glauben, daß der Effekt von H¨ullen formenden Heuristiken, wie den
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 115
Fail High Reduktionen oder den Singular Extensions der ist, daß sie helfen, die An-
zahl der blattdisjunkten Beweisstrategien bez¨uglich der echten Werte zu erh¨ohen.
Beispiele: Sei
X
der Spielbaum aus Abb. 4.1 (Seite 107). Sei
ein Spielbaum, der sich
von
X
nur dadurch unterscheidet, daß der echte Wert des Knotens
Æ?ÇÇ
eins ist. Dann gibt
es keine zwei blattdisjunkten Strategien in
, die zeigen, daß der Wert der Wurzel von
null ist. F¨ur
<
Þ
1
Å
a
ergibt sich nun
>
ã
<
æ
Þ
1
Å
`k
(auf 2 Stellen gerundet) und
H
>
ã
<
æ
Þ
1
Å
aT_
. Abb.4.3 zeigt die jeweiligen Qualit¨atspolynome in Abh¨angigkeit von
<
.
0
0.2
0.4
0.6
0.8
1
0.2 0.4 0.6 0.8 10
0.2
0.4
0.6
0.8
1
0.2 0.4 0.6 0.8 1
Abb. 4.3:
W
>
ã
<
æ
(links),
W
>
ã
<
æ
(rechts)
F¨ur Tiefe-2-Spielb¨aume mit Verzweigungsgrad 100, die 10 blattdisjunkte (den Wurzel-
wert belegende) Strategien enthalten, oder f¨ur Tiefe-2-Spielb¨aume mit Verzweigungsgrad
30, die 3 blattdisjunkte Strategien enthalten, kann man sich eine Fehlerwahrscheinlichkeit
von ungef¨ahr 0,5% erlauben, ohne daß die Fehlerwahrscheinlichkeit einer Spielbaumaus-
wertung schlechter wird als die einer direkten Bewertung.
Beweise f¨ur Lemma 4.3-1 und Satz 4.3-8
Definition 4.3-16 (Tiefe eines Spielbaums)
Die Tiefe eines Spielbaums
®
ist die maximale Distanz zwischen der Wurzel von
®
und
seinen Bl¨attern.
¯
Sei im folgenden
°W±²³µ´
das Qualit¨atspolynom eines Spielbaums
®
mit Wurzel
¶
. Bezeich-
ne ferner
°¸·
±
²³µ´
bzw.
°º¹¼»\½
±
²³µ´
die erste Ableitung von
°W±²³µ´
.
116 Spielbaumsuche mit Fehlern
Lemma 4.3-1
F¨ur alle Spielb¨aume gilt:
°¸·
±
²¿¾;´ÁÀjÂ
oder
°¸·
±
²¿¾;´.Ãľ
.
Satz 4.3-8
°·
±
²¾Z´ÀAÂ
gilt genau dann, wenn der Spielbaum
®
wenigstens zwei blattdisjunkte Be-
weisstrategien enth¨alt, die beide den echten Minimaxwert der Wurzel von
®
beweisen.
Die entsprechenden Beweise werden ¨uber Induktion ¨uber die Tiefe von Spielb¨aumen
gef¨uhrt. Ohne Verlust von Allgemeing¨ultigkeit bef¨urchten zu m¨ussen, betrachten wir
Spielb¨aume, deren Wurzel ein MAX-Knoten ist. F¨ur die anderen Spielb¨aume sind die
Rechnungen analog. Bevor wir jedoch die Beweise f¨uhren, formulieren wir, um uns die
Arbeit zu erleichtern, die ersten Ableitungen von Qualit¨atspolynomen in Abh¨angigkeit
der Qualit¨atspolynome der Wurzelnachfolger. Wir unterscheiden dabei drei F¨alle.
0
000
G
a)
1
1 0 0
G
b)
1
1100
G
c)
1
b
m+1
.......
b−1 mal
b mal m mal b−m mal
2
1 3
ε1
ε2
ε3
b
1
v ... v
vb
2
v .... v
1 m
v ... v v ... v
Abb. 4.4: M¨ogliche Konfigurationen an Spielbaumwurzeln
Abbildung 4.4a) zeigt einen Spielbaum mit einem MAX-Knoten als Wurzel und dem
Wert 0. Wegen des Minimax-Prinzips haben auch alle Nachfolger den Wert 0. In Abbil-
dung 4.4b) hat ein MAX-Knoten den Wert 1, und genau ein Nachfolger der Wurzel hat
ebenfalls den Wert 1. In Abbildung 4.4c) gibt es mehr als einen Nachfolger, der wie der
Wurzelknoten selber einen Wert 1 hat. Mit Hilfe der ¨
Uberlegungen des vorangegangenen
Abschnitts erhalten wir die Qualit¨atsploynome
°W±
»
,
°W±Å
und
°H±Æ
f¨ur die drei Typen von
Situationen, wie sie durch
®
»
,
®HÅ
und
®HÆ
(Abbildung 4.4) aufgezeigt werden:
°W±
»
²³Ç´ÈÀq°WÉMʲ³µ´*T*k*;°¸ÉDË~²³Ç´
°W±Å;²³Ç´ÈÀ¡¾fÌq²¾fÌÍ°¸É ʲ³µ´M´*Z°¸É¿Î;²³µ´*k*8*;°WÉDË~²³µ´
°W±Æ;²³Ç´ÈÀ¡¾fÌq²¾fÌÍ°¸É?ʲ³µ´M´*T*k*}²¾fÌÍ°¸ÉÐϲ³µ´M´*;°WÉ ÏÑ Ê*k*k*°WÉD˲³Ç´
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 117
Die Ableitungen dieser drei Polynome lassen sich leicht angeben:
°W·
±
»
²³µ´PÀÒÄÓ
ÔÕ
»
°¸É ʲ³µ´*k*k*Z°¸·
ÉDÖ
²³µ´x*k*k*×
Ó
²³µ´
°W·
±,Å
²³µ´PÀ¡ÌV²¿¾ØÌÙ°WÉ Ê²³µ´M´¿·*[°¸É¿ÎZ²³µ´k*M**×
Ó
²³µ´ÚÛÒ
Ó
ÔÕ
Å
²¾ØÌÙ°¸É ʲ³µ´?´k*[°¸É¿Î~²³µ´k**M*\°W·
ÉÐÖ
²³µ´k**M*\°WÉ Ë²³Ç´
°·
±,Æ
²³µ´PÀ¡ÌÜÒjÝ
ÔÕ
»
²¾ÞÌw°WÉ Ê²³µ´?´ß*;*4*8²¾ÞÌw°WÉDÖM²³µ´?´ß*4**8²¾ÈÌ0°¸É ϲ³µ´M´à*á°¸ÉDâ
Ñʲ³µ´ß*;*4*~°WÉÐ˲³µ´ßÌ
ÒÓ
ÔÕäãå
»
²¾fÌ2°¸É ʲ³µ´?´*k*k*n²¿¾fÌ2°WÉ Ï²³Ç´?´*Z°¸É
ÏÑ Ê²³µ´*k*k*;°W·
ÉÐÖ
²³µ´*T*k*;°¸É ˲³µ´
Weil
°WÉDÖM²¿¾;´ÁÀ¾
f¨ur alle
æ
ist, folgt:
°W·
±
»
²¾;´PÀq°W·
ÉÊ
²¿¾;´çÚè*Z*Z*;Úi°¸·
ÉDË
²¾;´
°·
±,Å
²¾;´PÀq° ·
É?Ê
²¿¾;´
°·
±,Æ
²¾;´PÀqÂ
Der eigentliche Induktionsbeweis ist nun einfach (hier f¨ur Lemma 4.3-1 und Satz 4.3-8
gleichzeitig):
(IA)
éêÀëÂ0ì °W·
±
²³µ´êÀ³hì °W·
±
²¾;´ºÀ¾
. Nat¨urlich gibt es keine zwei blattdisjunkten
Strategien in
®
.
(IV) Es gelte (
°W·
±
²¾;´WÀíÂ
oder
°¸·
±
²¾Z´ºÃA¾
), und es gelte (
°W·
±
²¾;´WÀ7Âïî ®
enth¨alt min-
destens zwei blattdisjunkte Strategien, die beide den Wert der Wurzel belegen) f¨ur alle
Spielb¨aume der Tiefe
é·ñð é
mit Wurzel
¶
.
(IS) Es sei
®ÀA²?²\òPó#ôV´áóõç´
ein Spielbaum mit Wurzel
¶
und Tiefe
é
. Es seien
ö
»
ó÷÷÷~ó#ö
Ó
die Nachfolger von
¶
in
®
. Dann unterscheiden wir drei F¨alle, (wobei oBdA.
¶
ein MAX-
Knoten ist):
1. f(
¶
) = 0. Dann sind die
õ¬²]ö
Ô
´ÛÀøÂ
f¨ur alle
æ
-úù
¾Tó÷÷÷óûü
und mit Hilfe unserer
Vor¨uberlegungen gilt
°·
±
²¾;´ÁÀq° ·
É?Ê
²¿¾;´Úý*Z*Z*Úþ° ·
ÉDË
²¾;´
. Mit der Induktionsvorausset-
zung folgt sofort, daß
°¸·
±
²¿¾;´À¢Â
oder
°¸·
±
²¾Z´HÃí¾
ist. Damit ist
°¸·
±
²¾Z´
genau dann
0, wenn alle Summanden
°·
ÉDÖ
²¾;´
gleich 0 sind. Nach Induktionsvoraussetzung ist
das genau dann der Fall, wenn es unter jedem Nachfolger von
¶
zwei blattdisjunkte
Strategien gibt, die den Wert des jeweiligen Nachfolgers belegen. Das wiederum ist
genau dann der Fall, wenn es unter
¶
mindestens zwei blattdisjunkte Strategien gibt,
die den Wert 0 belegen.
2. Es sei
õ¬²¶´ÁÀ¾
, und es gebe genau einen Nachfolger
ö
Ô
von
¶
, f¨ur den
õ²ö
Ô
´PÀ¾
ist.
Dann ist
°·
±
²¿¾;´ÀÄ° ·
ÉDÖ
²¾;´
. Auch hier ist sofort klar, daß
°·
±
²¿¾;´ÀÄÂ
oder
°·
±
²¿¾;´Ã¾
ist. Zwei oder mehr blattdisjunkte Strategien, die belegen, daß die Spielbaumwurzel
den Wert 1 hat gibt es genau dann, wenn es zwei oder mehr blattdisjunkte Strategien
118 Spielbaumsuche mit Fehlern
unter
ö
Ô
gibt, die belegen, daß der Wert von
ö
Ô
gleich 1 ist. Also gilt auch in diesem
Fall die Aussage von Satz 4.3-8.
3. Falls
õ¬²\¶#´ÿÀ ¾
ist und es mehrere Nachfolger der Wurzel von
®
gibt, die eben-
falls den Wert 1 haben, gilt f¨ur das Qualit¨atspolynom von
®
:
°¸·
±
²¾Z´À Â
. Es gibt
in diesem Fall auch mindestens zwei blattdisjunkte Strategien in
®
, die den Wert
õ¬²¶´PÀ ¾
der Wurzel von
®
belegen.
Beweis von Satz 4.3-9
Sei
®
wiederum ein beliebiger Spielbaum, und sei
¶
seine Wurzel.
°V¹
½
±
bezeichne von
nun an die
-te Ableitung von
°W±
.
Vor¨uberlegungen
Lemma 4.3-3
Es sei
û
-
, es seien
õ
»
²
ñ´áó÷÷÷óõ
Ó
²
ñ´
-mal stetig differenzierbare Funktionen IR
IR. Dann l¨aßt sich die
-te Ableitung des Produkts der Funktionen darstellen als
²
Ó
ÔÕ
»
õ
Ô
²
ñ´?´
¹
½
À
Ê
å
å
Ë
Õ
²
»
ó÷÷÷~ó
Ó
´*õ ¹
Ê
½
»
²
ñ´*k*k*õ ¹
Ë
½
Ó
²
ñ´
mit passenden
²
»
ó÷÷÷~ó
´
-
÷
Die Koeffizienten der Form
²\Âó÷÷÷óÂ|ó
óÂ|ó÷÷÷áóÂk´
sind alle gleich 1. (ohne Beweis)
¯
Zu Satz 4.3-9:
°¹
½
²¿¾;´.À¡° ¹
»\½
²¾;´À+*Z*Z*À° ¹ »\½
²¾Z´.À ÂVî
Es gibt
Új¾
blattdisjunkte Beweisstrate-
gien unter
ö
, die alle den echten Wert von
ö
beweisen.
Im Endeffekt m¨ochten wir auch diesen Satz mit Hilfe von Induktion ¨uber die H¨ohe der
Ableitungen
und der Tiefe
é
des Spielbaums
®
beweisen. Bevor wir uns jedoch daran
wagen, untersuchenwir analog zum vorigen Abschnitt die
-ten Ableitungen von
°W±
»
ó°W±Å
und
°W±Æ
(vgl. Abbildung 4.4).
Wir berechnen
°V¹
½
±
»
ó°V¹
½
±Å
und
°º¹
½
±,Æ
unter folgenden drei Voraussetzungen:
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 119
(
ò
)F¨ur jeden Spielbaum
®
mit Wurzel
¶
und f¨ur alle
æ
gilt:
°¹
Ô
»\½
±
²¾Z´&À *Z*Z*.À
°º¹¼»\½
±
²¿¾;´ÀmÂî
Es gibt
æ
blattdisjunkte Strategien unter
¶
, die den echten Wert
õ¬²¶´
bele-
gen.
(
ò
Ó
)F¨ur alle
-0ù
¾Tó
|ó
!
|ü
gilt
°V¹
"
»\½
±
$#
²¿¾;´ÁÀ*Z*Z*nÀq°º¹¼»\½
±
#
²¿¾;´ÁÀjÂ
, und es gibt
blattdisjunkte
Strategien unter
¶
%
, die
õ¬²¶
&
}´
belegen.
(
ò
ã
)F¨ur jeden Spielbaum
®
mit Wurzel
¶
und f¨ur alle
æ
-0ù
¾P÷÷÷
Ì'¾8ü
gilt
°
¹
Ô
½±
²¾;´
('
ÀjÂHì
sgn
²\°
¹
Ô
½±
²¿¾;´?´ÁÀ²ÌH¾;´
Ô
»
÷
Bemerkung: Wenn wir sp¨ater den Induktionsschluß durchf¨uhren, werden (
ò
) und (
ò
ã
) die
Induktionsvoraussetzung bilden. Den Induktionsschritt werden wir durchf¨uhren, indem
wir die beiden Folgerungsrichtungen von Theorem 4.3-9 getrennt beweisen. (
ò
Ó
) wird sich
aus der jeweiligen Voraussetzung herleiten lassen: Entweder werden wir voraussetzen
k¨onnen, daß f¨ur jeden Spielbaum
®7°º¹
½
±
²¾;´À *Z*Z*¸À °º¹¼»\½
±
²¿¾;´ À Â
gilt, oder daß es
Úq¾
blattdisjunkte Beweisstrategien unter
¶
gibt, die den echten Wert
õ²\¶´
belegen. Die
Ableitungen der Qualit¨atspolynome, die wir beim Beweis betrachten m¨ussen, sind bei
beiden Richtungen gleich.
Die
-ten Ableitungen von Qualit¨
atspolynomen
Seien die drei Voraussetzungen
ò
)
óò
Ó
und
ò
ã
erf¨ullt.
1. Allgemein ist
°V¹
½
±
»
²³µ´ÁÀ
Ê
å
å
Ë
Õ
*
²
»
ó÷÷÷ó
Ó
´*;°
¹
Ê
½É Ê
²³µ´*k*k*°
¹
Ë
½ÉDË
²³Ç´
mit passenden
²
»
ó÷÷÷ó
+
Ó
´
-
,
nach Lemma 4.3-3.
Aufgrund von Voraussetzung (
ò
Ó
) sind alle Summanden, die eine Ableitung enthal-
ten, die kleiner als
ist, an der Stelle
³ÛÀ¾
gleich Null. Weil f¨ur alle
æß°¸ÉDÖM²¾;´ÈÀ¾
ist, schließen wir, daß
°V¹
½
±
»
²¿¾;´PÀjÒjÓ
»
°º¹
½
ÉÐÖ
²¾Z´
2.
°¹
½
±,Å
²³Ç´ÈÀ
²¿Ì¾Z´*
Ê
å
å
Ë
Õ
*
²
»
ó÷÷÷~ó
´*}²¾fÌÍ°¸É ʲ³µ´?´
¹
Ê
½
*;°
¹
Î
½É¿Î
²³µ´*k*T*;°
¹
Ë
½ÉDË
²³µ´
120 Spielbaumsuche mit Fehlern
mit passenden
²
»
ó÷÷÷~ó
´
-
.
Aufgrund von Voraussetzung
ò
Ó
gilt, daß an der Stelle
³ïÀ¾
nur ein Summand der
Summe ungleich Null ist. Wir schließen daraus, daß gilt:
°V¹
½
±Å
²¿¾;´ÁÀj°V¹
½
ÉÊ
²¿¾;´
3. Die n-te Ableitung von
°V¹
½
±Æ
²³µ´
ist etwas komplizierter auszurechnen.
°V¹
½
±Æ
²³µ´ÁÀ ²¿Ì¾;´*Ò
Ê
å
å
Ë
Õ
²
»
ó÷÷÷~ó
Ó
´*
²¾fÌ2°WÉ Ê²³µ´M´
¹
Ê
½
*T*k*}²¿¾Ìý°WÉ â²³µ´M´
¹
â
½
*;°
¹
â
ÑÊ
½
ÉDâ
ÑÊ
²³µ´*k*k*°
¹
Ë
½
ÉË
²³Ç´
- .0/ 1
Õ
2 354
Ê
%6 7 7 7 6
4
Ë
¹
8
á½
mit nach Lemma 4.3-3 passenden
²
»
ó÷÷÷~ó
Ó
´
-
9
.
Zur Berechnung von
°¹
½
±,Æ
²¾Z´
unterscheiden wir drei F¨alle:
(a) Es sei
ð
;:
.
Dann gibt es in jedem Summanden
<
Ê
&=>>> =
Ëá²³µ´
mindestens einen Faktor der
Form
²¿¾VÌm°¸É ʲ³Ç´?´
¹
?
¿½
. An der Stelle
³¡À ¾
ist also jeweils mindestens ein
Faktor jedes Summanden gleich Null. Dann ist
°V¹
½
±Æ
²¿¾;´ÁÀjÂ
.
(b) Es sei
À
:
.
Sei
<
Ê
&=>>> =
˲³µ´
ein beliebiger Summand von
°V¹
½
±Æ
²³µ´
an der Stelle
³ÛÀ ¾
.
Ist
A@
çÀÂ
f¨ur ein
B
-hù
¾8ó÷÷÷áó
:
ü
, so ist
<
Ê
&=>>> =
˲¿¾;´gÀÂó
CED
æ
&B
D¾Ìh°¸É
GF
¿²¿¾;´gÀÂ
ist.
Ist
@IH
7¾
f¨ur ein
B
-jù
¾P÷÷÷
:
ü
, so gibt es ein
B
·
-jù
¾Tó÷÷÷ó
:
ü
mit
A@KJ
ÈÀ7Â
.
Damit gilt ebenfalls
<
Ê
=>>> =
Ëá²¾;´ÁÀjÂ
.
Ist
A@H
Â
f¨ur ein
B
-0ù
:
Ú¾Tó÷÷÷óûü
, so existiert ebenfalls ein
B
·
-0ù
¾Tó÷÷÷~ó
:
ü
mit
A@KJ
µÀÂ
. Also ist
<
Ê
=>>> =
Ëá²¾;´ÁÀjÂ
.
F¨ur alle anderen Summanden gilt:
<
Ê
G=>>> =
˲¾;´PÀ²¿Ì¾Z´
Ý
*
"L
wÝ
ÔÕ
»
°V¹¼»\½
ÉDÖ
²¿¾;´
Mit
À
:
bekommen wir also heraus, daß es ein
M
-
N
gibt, so daß
°V¹
½
±Æ
²¿¾;´ÁÀ²¿Ì¾Z´Á*}²¿Ì¾Z´
*
"M
V*
"L
ÔÕ
»
°V¹ »\½
ÉDÖ
²¾Z´á÷
Das Vorzeichen von
°V¹
½
±Æ
²¾;´
er-
gibt sich unter zu Hilfenahme von Voraussetzung
ò
ã
als
²ÌH¾;´
å
»
.
(c) Sei
H:
.
Sei
<
Ê
=>>> =
Ëá²³µ´
wieder ein beliebiger Summand von
°¹
½
±,Æ
²³Ç´
.
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 121
i. Falls es ein
B
gibt mit
BO :
und
A@
ñÀ¡Â
, wissen wir, daß
<
Ê
&=>>> =
˲¿¾;´À¡Â
ist (vgl. 3b).
ii. Falls es ein
B
gibt mit
BIH :
und
A@PH
¡Â
, erhalten wir
ÒjÝ
ÔÕ
»
Ô
Ìq¾
.
<
Ê
G=>>> =
ËᲳǴ
hat in diesem Fall die Form
²¾kÌS°WÉ Ê²³Ç´?´
¹
Ê
½
***]²¿¾kÌ°¸É â²³µ´M´
¹
â
½
*
Q
ó
f¨ur ein
Q
-
IR. Wegen Voraussetzung
ò
Ó
gibt es
blattdisjunkte Stra-
tegien unter
¶
+!
, die
õ¬²\¶
!
T´
belegen.Aufgrund der Definition von Strategien
wissen wir, daß die Summe aller Beweisstrategien unterhalb der Knoten
ö
»
÷÷÷Mö
Ý
ebenfalls
ist. Weil
ÒÝ
ÔÕ
»
Ô
Ìľ
ist, k¨onnen wir schlie-
ßen, daß es einen Nachfolger
ö
Ô
ó#æ
-ù
¾P÷÷÷
:
ü
gibt, unter dem mehr als
Ô
-viele blattdisjunkte Strategien h¨angen, die
õ¬²ö
Ô
´
belegen. Mit Hilfe der
Voraussetzung
ò
)
wissen wir somit, daß es zumindest ein
æ
-qù
¾P÷÷÷
:
ü
gibt, so daß
²¿¾Ì2°V¹
Ö
½
ÉDÖ
²³Ç´?´
an der Stelle
³&À¾
Null wird.
iii. Zu guter Letzt m¨ussen wir noch den Fall abdecken, daß
ÒjÝ
ÔÕ
»
Ô
ist und
L
Ý
ÔÕ
»
Ô
H
Â
ist. In diesem Fall bekommen wir f¨ur passende
²
»
Úq*Z*Z*ZÚ
R
Ý
óÂg÷÷÷~óÂT´
-
°¹
½
±Æ
²¿¾;´ÁÀ
Ì
Ê
å
å
â
Õ
²
»
ó÷÷÷ó
+
Ý
óÂg÷÷÷áóÂk´~²¾äÌ°WÉ Ê´
¹
Ê
½
²¾;´;*[*[*в¾äÌ°¸É
â
´
¹
â
½
²¾;´PÀ
²ÌH¾;´
Ý
å
»
Ò
Ê
å
å
â
Õ
²
»
ó÷÷÷ó
Ý
óÂg÷÷÷áóÂk´M°V¹
Ê
½
ÉÊ
²¿¾;´*k*T*;°V¹
â
½
Éâ
²¿¾;´
.
Sei nun
<
Ê
&=>>> =
˲¾;´
9'
ÀëÂ
. Dann gilt f¨ur alle
æ
-ù
¾Tó÷÷÷áó
:
ü
S
Ô
'
À Â
und
ÒÝ
ÔÕ
»
Ô
À
. Es folgt
T
×
²
U<
Ê
&=>>> =
˲¿¾;´?´PÀ²ÌH¾;´²¿Ì¾;´
Ý
Ý
ÔÕ
»
T
×
²°
¹
Ö
½ÉDÖ
´÷
Nach Voraussetzung
ò
ã
ist
T
×
²\°V¹
Ö
½
ÉDÖ
²¾;´M´ÁÀ ²ÌH¾;´
Ö
»
.
Damit ist
T
×
²
U<
Êó÷÷÷ó
<
Ë´ À ²¿Ì¾Z´
Ý
å
»
*
Ý
ÔÕ
»
²ÌH¾;´
Ö
»
À ²¿Ì¾Z´
Ý
å
»
å
V
â
Ö
W
Ê
¹
Ö
»\½
À ²¿Ì¾Z´
»
å
V
â
Ö
XW
Ê
Ö
À ²¿Ì¾Z´
å
»
Also ist auch
°¹
½
±Æ
²¾;´PÀ²ÌH¾;´
å
»
.
122 Spielbaumsuche mit Fehlern
Induktionsbeweis
Nach diesen Vor¨uberlegungen k¨onnen wir Theorem 4.3.1-9 durch Induktion beweisen.
(IA) Den Induktionsanfang f¨ur
À¾
haben wir durch Satz 4.3-1 bereits gemacht.
(IV) Die Induktionsvoraussetzung sei die folgende:
F¨ur alle
æ
Y
gilt:
°º¹
Ô
»\½
±
²¾;´gÀ+*Z*Z*ÇÀ°V¹¼»\½
±
²¾Z´gÀºî
Es gibt
æ
blattdisjunkte
õ²\¶´
bele-
gende Strategien unter der Wurzel
¶
von
®
. Außerdem gilt f¨ur die Vorzeichen der
°º¹
Ô
½
±
²¾;´
:
°V¹
Ô
½
±
²¾Z´
Z'
ÀqÂì °V¹
Ô
½
±
²¾Z´ÈÀ²ÌH¾;´
Ô
»
.
(IS) (
Ì'¾
[
)
Wir beginnen den Induktionsschritt (
Úq¾
) mit ’
\
’.
Es gebe
Ú ¾
blattdisjunkte Beweisstrategien unter
¶
, der Wurzel eines Spielbaums
®
.
Es ist klar, daß es auch
blattdisjunkte Strategien gibt. Mit Hilfe der Induktionsvoraus-
setzung wissen wir, daß die Voraussetzungen
²\ò
)
~´
,
²[ò
Ó
´
und
²\ò
ã
´
erf¨ullt sind.
F¨ur die Wurzel
¶
k¨onnen die drei F¨alle eintreten, die
¶¾Tó#¶
]
|ó¶
!
des vorigen Abschnitts
entsprechen. Man sieht dort auch leicht, daß
°¹
½
±
'
ÀjÂHì
T
×
²° ¹
½
±
´PÀ²¿Ì¾;´
å
»
.
Durch Induktion ¨uber die H¨ohe
^
von
®
erh¨alt man:
1.
°
¹
½±
À
Ó
ÔÕ
»
°
¹
½ÉÐÖ
-".0/"1
Õ
?
ÀqÂó
denn f¨ur jeden Nachfolger
ö
Ô
von
¶
gibt es
Úÿ¾
blattdisjunkte Strategien, die
õ¬²\¶#´ÁÀ
¾
belegen.
2. Es gebe genau einen Nachfolger der Wurzel
¶
, der wie
¶
selber den Wert 1 habe.
ObdA sei dieses
ö
»
.
°
¹
½±
Àj°
¹
½É Ê
-".0/"1
Õ
?
ÀqÂó
3. (a)
°V¹
½
±
²¿¾;´ÁÀÂ
.
(b)
°
¹
½±
²¿¾;´ÁÀ ²¿Ì¾;´
¹
å
»\½
*
"M
V*
Ý
ÔÕ
»
°
¹ »\½ÉDÖ
²¾;´PÀqÂó
denn werden
Úľ
blattdisjunkte Strategien auf
:
À
Nachfolger verteilt,
so ex. ein Nachfolger
ö
Ô
, dessen Wert
õ¬²]ö
Ô
´
durch 2 blattdisjunkte Strategien
belegt wird. Dann ist aber
°¹ »\½
ÉDÖ
²¾;´ÁÀqÂ
.
4.3 Spielbaumsuche ¨uber Bewertungen mit zuf¨
alligen Fehlern 123
(c)
°
¹
½±
²¾;´ÁÀ²ÌH¾;´
Ý
å
»
*
Ê
å
å
â
Õ
*
²
»
ó÷÷÷~ó
Ý
´M°
¹
Ê
½É Ê
²¾;´*k*Z*Z*4*;°
¹
â
½É â
²¾;´ÁÀÂó
denn es ist
ÒÝ
ÔÕ
»
Ô
À
. Werden nun
Ú¡¾
blattdisjunkte Strategien auf
:
Nachfolger verteilt, so ex. ein Nachfolger
ö
Ô
, dessen Wert
õ¬²ö
Ô
´
durch
Ô
H_
Ô
blattdisjunkte Strategien belegt wird. Dann ist aber
°V¹
Ö
½
ÉDÖ
²¾;´PÀÂ
.
Ganz ¨ahnlich ist es f¨ur die andere Richtung ’
ì
’:
Sei
°H±
das Qualit¨atspolynom eines Spielbaums
®
. Seien
°V¹
½
±
À*Z*Z*ÈÀ °V¹ »\½
±
À Â
. Of-
fensichtlich gilt erst recht, daß
°º¹
»\½
±
Àë*Z*Z*ßÀ°º¹¼»\½
±
À+Â
. Der Induktionsvoraussetzung
k¨onnen wir entnehmen, daß es
blattdisjunkte Beweisstrategien unter der Wurzel
¶
von
®
gibt, die alle den Wurzelwert von
®
beweisen. Deshalb sind die Voraussetzungen
²[ò
´
,
²[ò
Ó
´
, und
²[ò
ã
´
erf¨ullt.
Damit ist auch hier klar, daß
°º¹
½
±
'
ÀÂì
T
×
²\°V¹
½
±
´ÈÀ²ÌH¾;´
å
»
.
F¨ur die Wurzel k¨onnen die drei F¨alle eintreten, die
¶¾Tó#¶
]
|ó¶
!
des vorigen Abschnitts ent-
sprechen. Durch Induktion ¨uber die H¨ohe
^
von
®
erh¨alt man:
1.
ÂÀ°
¹
½
±
²¿¾;´PÀ
Ó
ÔÕ
»
°
¹
½
ÉÐÖ
²¾Z´ÁÀjÂ
Wegen
°¹
½
ÉDÖ
²¾;´ÜÀ Â
oder
T
×
²° ¹
½
ÉÐÖ
²¿¾;´?´wÀ ²ÌH¾;´
»
folgt
°¹
½
ÉÐÖ
²¾Z´wÀ Â
f¨ur alle
æ
-Aù
¾Tó÷÷÷~ó#ûZü
. Dann gibt es
Ú¢¾
blattdisjunkte Strategien, die
õ¬²]ö
Ô
´
belegen,
¾
`
'æ
a
èû
. Damit gibt es
Úq¾
blattdisjunkte Strategien, die
õ¬²¶´
belegen.
2. Es gebe genau einen Nachfolger der Wurzel
¶
, der wie
¶
selber den Wert 1 habe.
ObdA sei dieses
ö
»
.
ÂÀ°
¹
½±
²¾;´ÁÀ°
¹
½É Ê
²¾;´÷
Dann gibt es
Ú2¾
blattdisjunkte Strategien, die
õ¬²]ö
»
´
belegen. Damit gibt es
Ú2¾
blattdisjunkte Strategien, die
õ¬²\¶#´
belegen.
3. (a)
ð
;:
. Dann gibt es mindestens
:
blattdisjunkte Strategien, die
õ¬²\¶´
belegen.
Damit gibt es
Úq¾
blattdisjunkte Strategien, die
õ¬²¶´
belegen.
(b)
À
:
.
ÂÀq°
¹
½±
²¾;´PÀ²ÌH¾;´
å
»
*
"M
V*
Ý
ÔÕ
»
°
¹ »\½ÉDÖ
²¾Z´á÷
124 Spielbaumsuche mit Fehlern
Dann ex. ein
æ
-2ù
¾Tó÷÷÷ó
:
ü
mit
°
Ö
ÉDÖ
²¿¾;´.À¡Â
, somit ex. ein Nachfolger, unter
dem sich zwei blattdisjunkte Strategien befinden, die
õ¬²ö
Ô
´~²[À¢õ¬²¶´?´
belegen.
Die ¨ubrigen
:
Ì'¾
Nachfolger liefern uns
:
Ìè¾
weitere Strategien, die
õ¬²¶´
belegen. Damit gibt es
:
Ìi¾ÁÚ
b
À
:
Ú'¾YÀ
Úh¾
blattdisjunkte Strategien,
die
õ¬²¶´
belegen.
(c)
H:
.
ÂÀq°
¹
½±
²¾Z´ÈÀ²ÌH¾;´
Ý
å
»
*
Ê
å
=>>> =
å
â
Õ
c
²
»
ó÷÷÷ó
+
Ý
´
Ý
ÔÕ
»
°
Ö
ÉDÖ
²¾;´
- .0/ 1
34
Ê
&6 7 7 7 6
4
â
¹¼»\½
÷
Es ist
<
Ê
&=>>> =
â²¾;´ÁÀjÂ
oder
T
×
²
U<
Ê
&=>>> =
â²¾;´M´ÁÀ²¿Ì¾;´
å
»
,also
<
Ê
&=>>> =
ⲿ¾;´ÁÀjÂ
f¨ur alle
»
ó÷÷÷ó
Ý
. Dann ex. f¨ur jedes
<
Ê
=>>> =
â
²¾;´
ein
æ
- ù
¾Tó÷÷÷ó
:
ü
mit
°V¹
Ö
½
ÉDÖ
²¾;´wÀ Â
. Also ex.
Ô
Ú¾
blattdisjunkte Strategien unter
ö
Ô
, die
õ²ö
Ô
´
belegen. Damit gibt es
¾àÚ
ÒÝ
ÔÕ
»
Ô
À
Úý¾
blattdisjunkte Strategien, die
õ¬²¶´
belegen.
4.4 Zusammenfassung
Wir haben ein kombinatorisches Spielbaummodell pr¨asentiert, welches Fehler einer heu-
ristischen Bewertungsfunktion mit Hilfe von M¨unzw¨urfen modelliert. Die Nicht-Fehler-
wahrscheinlichkeit eines heuristischen Minimaxwertes ist dann an der Wurzel
¶
eines
Spielbaums
®
ein Polynom
°W±
. Wir konnten einen 1:1-Zusammenhang zwischen der An-
zahl blattdisjunkter Beweisstrategien in
®
und den Ableitungen von
°W±²¿¾;´
beweisen. Wir
konnten dadurch zeigen, daß die Anzahl der blattdisjunkten Beweisstrategien, die in ei-
nem Spielbaum
®
enthalten sind, gr¨oßenordnungsm¨aßig die G¨ute des heuristischen Mi-
nimaxwertes bestimmt. Der Nutzen von Spielbaumsuche mit heuristischen Blattwerten
wird einfach verstehbar. Das Modell ermutigt außerdem zu Conspiracy Number Suchen.
4.5 Nachtrag: Modell und Wirklichkeit
Eines der gr¨oßten Geheimnisse unserer Welt ist der Zusammenhang von Modellen und
der Wirklichkeit. Konsens gibt es lediglich dar¨uber, daß ein von Menschen geschaffe-
nes Modell generell nicht die Wirklichkeit beschreibt, sondern einen speziellen Aspekt
4.5 Nachtrag: Modell und Wirklichkeit 125
derselben. Somit kann ein nichtdeterministisches Modell durchaus Aspekte einer deter-
ministischen Realit¨at gut beschreiben. Z.B. ist ein Pseudo-Zufallszahlen-Generator ein
deterministischer Algorithmus, aber er kann benutzt werden, um Effekte auszunutzen,
die auch ein echter Zufallszahlen-Generator hervorrufen w¨urde.
Bei probabilistischen Modellen, die versuchen, Unwissen durch die Annahme von Wahr-
scheinlichkeiten auszugleichen, ist es besonders schwer, ihren Wahrheitsgehalt zu pr¨ufen.
Nehmen wir uns einmal zwei Spieler
d
und
e
her. Spieler
d
f¨uhrt M¨unzw¨urfe durch.
Beide Spieler geben verdeckt einen Tip ab, ob Wappen oder Zahl kommt. Falls sie den
gleichen Tip abgeben, ist die Runde ung¨ultig. Geben beide Spieler erst ihren Tip ab, und
wirft Spieler
d
dann die M¨unze, wird dieses Spiel von der Mehrzahl von Befragten si-
cherlich als fair bezeichnet werden. Nun wirft
d
die M¨unze erst, dann geben die Spieler
ihren Tip ab. Im Moment des Tippens ist das Ergebnis nicht mehr zuf¨allig. Oder doch?
Ob es f¨ur Spieler
e
gut oder schlecht ist, die M¨unzw¨urfe auch weiterhin als zuf¨allig an-
zunehmen, h¨angt davon ab, ob
d
Wissen ¨uber die gefallene M¨unze hat.
So ¨ahnlich ist es auch in unserem Fall mit den heuristischen Bewertungen von Spielsi-
tuationen. Solange wir (und alle anderen) zwar eine Vorstellung davon haben, wieviele
Fehler unsere Bewertungsfunktion enth¨alt, aber niemand weiß, an welchen Stellen diese
auftreten, ist eine probabilistische Modellierung nicht anfechtbar.
Eine Erweiterung des Modells der Art, daß man fragt, mit welcher Wahrscheinlichkeit der
echte Wert eines Spielbaums 1 ist, wenn man eine 1 als heuristischen Wert errechnet hat,
ist aber unseres Erachtens nach schon fragw¨urdig und macht wohl keinen Sinn mehr:
Wir sind bisher immer davon ausgegangen, daß ein konkreter Baum gegeben ist, dessen
Wert es zu erkennen gilt. Die Wahrscheinlichkeit, daß der Wert 1 ist, ist entweder 1 oder 0.
Die W¨urfel sind diesbez¨uglich schon gefallen. Um das Experiment wie angedeutet zu er-
weitern, m¨ußte man von einem erweiterten stochastischen Modell ausgehen, in dem eine
Verteilung ¨uber die Menge der m¨oglichen Spielb¨aume gegeben ist. Wenn man dann davon
ausgeht, daß eine Wahrscheinlichkeit daf¨ur gegeben ist, daß der tats¨achliche Wert eines
Blattes 1 ist, wenn die heuristische Bewertung eine 1 erkennt, kann man nur dann wei-
terrechnen, wenn man die entstehenden Abh¨angigkeiten der Wahrscheinlichkeiten kennt.
Außerdem widerstrebt es uns, den Wurzelwert eines konkreten Spielbaums, den wir un-
tersuchen wollen, als noch nicht konkret vorhanden anzusehen.
Wir gehen davon aus, daß die von uns beschriebenen Struktureffekte (d.h., daß sich Be-
wertungsfehler dort h¨aufen, wo man von einer konkreten Position startend in großen
Suchb¨aumen nur wenige blattdisjunkte belegende Strategien findet) tats¨achlich auftre-
ten und pr¨asentieren daf¨ur Beispiele aus dem Bereich der Schachendspiele:
126 Spielbaumsuche mit Fehlern
f
g
Abb. 4.5: Schachstellung
Im folgenden soll es unsere Aufgabe sein, den echten Wert einer Beispielstellung zu fin-
den. (Es ist klar, daß man auch in der Lage ist, richtige Entscheidungen zu f¨allen, wenn
man in der Lage ist, Werte von Stellungen richtig einzusch¨atzen.) Außerdem soll der
heuristische Wert einer Stellung so berechnet werden, wie es im Computerschach ¨ublich
ist: Wir werten einen die Wurzel des Spielbaums enthaltenden Teilbaum mit Hilfe des
Minimax-Prinzips aus. Die Werte der Bl¨atter werden durch eine heuristische Bewertungs-
funktion bestimmt, und die Werte von inneren Knoten sind die Minimaxwerte der Nach-
folgestellungen.
Betrachten wir die Stellung von Abbildungen 4.5. Weiß ist dort am Zug, und wir w¨urden
gerne wissen, ob der echte Wert dieser Stellung remis ist oder ob Weiß gewinnen kann.
Unsere heuristische Bewertung soll ein Endspiel der Form Turm gegen L¨aufer als remis
einsch¨atzen. Ein Endspiel Turm gegen nichts wird als Gewinnstellung f¨ur die Seite ge-
wertet, die den Turm besitzt. Die Endspiele L¨aufer gegen nichts und K¨onig gegen K¨onig
werden als remis bewertet. Das ist eine durchaus sinnvolle Art der Einsch¨atzung und wird,
sofern keine Endspieldatenbank zur Verf¨ugung steht, auch von unserem Schachprogramm
P.ConNerS als erste N¨aherung f¨ur einen heuristischen Wert benutzt.
Nun f¨ugen wir Suche hinzu. Nach 1.Kf2 Kh3 2. Kf3 Kh4 3. Tc5 Lg6 [a) 3. ... La2 4. Kf4
Lb3 5. Tb5 Lc4 6. Tb4 Lf7 oder b) 3. ... Lh7 4. Kf4 Ld3 5. Td5 Lc4 6. Td4 Lb3 usw.] 4.
Kf4 Kh3 5. Tg5 Lf7 6. Tg3+ Kh2 7. Tg3+ Kh2 8. Kf3 Lb3 9. Kf2 Lc2 10. Tc3 und einigen
Verfeinerungen, die man mit Hilfe eines Schachprogramms schnell nachvollziehen kann,
kommen wir zu dem Schluß, daß die Startstellung wohl doch f¨ur Weiß gewonnen ist. Die
Kombination unserer Bewertungsfunktion plus der ausgew¨ahlte Suchbaum f¨uhrt uns also
zu der richtigen Einsch¨atzung. Da die Beispielstellung aus einem Endspiel entnommen
ist, f¨ur das es mittlerweile vollst¨andige Datenbanken gibt, k¨onnen wir best¨atigen, daß der
4.5 Nachtrag: Modell und Wirklichkeit 127
Wert der Stellung in Abbildung 4.5 tats¨achlich ein Gewinn f¨ur Weiß ist.
Um gemeinsam mit der vorausgesetzten heuristischen Bewertungsfunktion zu dem rich-
tigen Ergebnis zu kommen, muß man einige sehr tiefe Varianten mitber¨ucksichtigen. Be-
trachtet man die Verteilung der echten Werte, ausgehend von der gezeigten Startstellung,
f¨allt auf, daß man die oben ausgef¨uhrten Varianten in den Suchbaum aufnehmen muß,
wenn man zwei blattdisjunkte Strategien, die den Wert der Wurzel belegen, im Suchbaum
haben m¨ochte.
Betrachten wir zum Schluß noch das Endspiel K¨onig
Ú
Turm vs. K¨onig
Ú
L¨aufer (KT-
KL: am Zug ist der Spieler mit dem Turm) unter quantitativeren Gesichtspunkten: F¨ur
einige Endspiele (z.B. KTKL) haben wir eine Komplettdatenbank erzeugt. Unsere KTKL-
Datenbank enth¨alt 5390364Stellungen. Man kann dieDatenbank sicherlich besser packen,
indem man weitere Spiegelungen beachtet; die absolute Gr¨oße der Datenbank ist aber f¨ur
die folgenden Untersuchungen ohne Belang. Wir haben auf allen 5390364 Einzelstellun-
gen Tiefe-
é
-Suchen (
é
-jù
Â|ó÷÷÷áó
h
}ü
) gestartet. Die Suchen wurden danach unterteilt, ob
sie zwei blattdisjunkte Strategien (bzgl. der echten Werte, die aus der Datenbank bekannt
sind) enthalten, die den jeweiligen Stellungswert belegen, oder ob sie sie nicht enthalten.
Auch wenn hier ein Endspiel ’vollst¨andig’ ausgewertet wird, handelt es sich auch bei die-
sen Betrachtungen um ein Beispiel: Es gibt viele Bewertungsfunktionen, die man nutzen
kann, und es gibt viele Arten, Suchb¨aume aufzuspannen. Allerdings w¨are es doch sehr
schade, wenn man sich die erstbeste Bewertungsfunktion hernehmen k¨onnte, und auf der
gegebenen Datenbank w¨urden die Suchergebnisse besser ausfallen, wenn die Suchb¨aume
keine zwei blattdisjunkte Strategien enthalten.
Bei einer Tiefe-
Â
-Suche handelt es sich um eine direkte Bewertung (s.o.), und es gibt
nur eine belegende Strategie. Die direkte heuristische Bewertung gibt 64,9% richtige
Einsch¨atzungen. Tabelle 4.6 zeigt den Prozentsatz der richtigen Einsch¨atzungen der Tiefe-
é
-Suchen, jeweils unterteilt inTiefe-
é
-Suchb¨aume, die mindestens zwei blattdisjunkte, den
echten Wert belegende Strategien enthalten (2 bdS), und in Tiefe-
é
-Suchb¨aume, die keine
solchen blattdisjunkten Strategien enthalten (keine 2 bdS).
Wie man sieht, sind die Suchb¨aume, die blattdisjunkte Strategien enthalten, immer erfolg-
reicher als diejenigen ohne blattdisjunkte Strategien. Nat¨urlich ist es so, daß mit steigen-
der Suchtiefe die Erfolgsquote der Tiefe-
é
-Suchen insgesamt steigt. Das wird in diesem
Fall z.B. auch dadurch verursacht, daß der Zieher Strategien finden kann, die entweder in
das Endspiel KTK oder KKL umlenken. Diese Endspiele werden nahezu perfekt von der
hier vorgestellten heuristischen Bewertungsfunktion eingesch¨atzt. Allerdings steigt eben
128 Spielbaumsuche mit Fehlern
Erfolgsquoten von Tiefe-
é
-Suchen im Endspiel KTKL
Suchtiefe keine 2 bdS 2 bdS Gesamt
0 64,9% - 64,9%
1 72,4% 95,2% 90,0%
2 72,6% 98,4% 92,0%
3 90,0% 92,6% 92,0%
4 88,2% 98,7% 98,0%
5 67,7% 97,6% 97,4%
Abb. 4.6: Wirkung blattdisjunkter Strategien (bdS)
auch der Anteil derjenigen Tiefe-
é
-Suchb¨aume, die zwei oder mehr blattdisjunkte Strate-
gien enthalten. ¨
Ahnliche Ergebnisse (wenn auch nicht immer ganz so deutlich) bekommt
man auch, wenn man die Seite mit dem L¨aufer zuerst ziehen l¨aßt oder wenn man z.B. die
Endspiele K¨onig
Ú
Springer vs. K¨onig
Ú
Turm betrachtet.
Erfolgsquoten von Tiefe-
é
-Suchen im Endspiel KLKT
Suchtiefe keine 2 bdS 2 bdS Gesamt
0 96,7% - 96,7%
1 41,4% 99,9% 97,0%
2 86,4% 98,2% 98,0%
3 85,6% 99,6% 99,0%
4 44,4% 99,0% 99,0%
5 36,2% 99,5% 99,4%
Erfolgsquoten von Tiefe-
é
-Suchen im Endspiel KTKS
Suchtiefe keine 2 bdS 2 bdS Gesamt
0 51,6% - 51,6%
1 56,2% 82,0% 77,2%
2 56,0% 84,8% 79,3%
3 60,0% 82,0% 80,3%
4 59,4% 88,8% 86,5%
5 31,3% 99,5% 89,4%
Kapitel 5
Zusammenfassung und offene Probleme
Der zentrale Begriff dieser Arbeit ist der der blattdisjunkten Strategien. Die vorgestellten
Algorithmen und Analysen geben aus verschiedenen Blickwinkeln Hinweise darauf, daß
blattdisjunkte Strategien eine zentrale Bedeutung in der Spielbaumsuche haben.
1. Der vorgestellte ’Controlled Conspiracy Number Search Algorithmus’ ist in der
Lage, effizient Spielb¨aume aufzubauen und zu durchsuchen. Er sucht nach Spiel-
b¨aumen und wertet diese aus, in denen die untere Schranke f¨ur den Wert des besten
Wurzelnachfolgers sowie obere Schranken f¨ur die Werte der ¨ubrigen Wurzelnach-
folger jeweils durch mehrere blattdisjunkte Strategien belegt werden. Die Bl¨atter
dieser Strategien m¨ussen zus¨atzlich eine vorgegebene Mindestentfernung zur Wur-
zel haben.
2. Der ’Parallel Controlled Conspiracy Number Search Algorithmus’, den wir vor-
gestellt haben, bettet seinen Spielbaum in ein Prozessornetzwerk ein. Auf einem
SCI-Workstationcluster wurden mit 160 Prozessoren Effizienzen von ¨uber 30% er-
reicht. In Anbetracht der Tatsachen, daß es sich dabei um einen Workstationcluster
und nicht um einen klassischen Parallelrechner handelt und daß nicht nur die Last,
sondern auch der Speicher verteilt werden muß, ist das Ergebnis beachtlich.
3. In einem Spielbaummodell, in dem Fehler einer nicht perfekten Bewertungsproze-
dur durch Zufallsereignisse modelliert werden, konnten wir zeigen, daß die Fehler-
wahrscheinlichkeit einer Minimaxauswertung eines Spielbaums gr¨oßenordnungs-
m¨aßig von der Anzahl blattdisjunkter Strategien abh¨angt, die im Spielbaum bez¨ug-
lich seiner echten Werte enthalten sind und den Wert der Wurzel belegen.
Diese Arbeit erh¨alt besondere Bedeutung dadurch, daß sich die hier beschriebenen Algo-
rithmen im Schachprogramm P.ConNerS bew¨ahrt haben. Der vielbeachtete Gewinn des
10. Lippst¨adter Großmeisterturniers zeigt, daß der Controlled Conspiracy Number Search
130 Zusammenfassung und offene Probleme
Algorithmus eine sehr gute Alternativezu den reinen Tiefensuchalgorithmen wie dem
ikj
-
Algorithmus darstellt.
Offene Probleme:
a) Beim parallelen
ikj
-Algorithmus wurden auch f¨ur 256 Prozessoren noch Effizienzen
von 49% erreicht. Lassen sich solche Effizienzen auch beim Controlled Conspiracy Num-
ber Search Algorithmus erreichen?
b) Bei unseren Fehleranalysen in Spielb¨aumen h¨angen Bewertungsfehler der Wurzel im-
mer von der Struktur der Spielb¨aume bez¨uglich der echten Werte dieser Spielb¨aume ab.
In der Praxis kennt man diese Werte nicht, und wir haben Conspiracy Number Search
deshalb als Suchheuristik eingestuft. Kann man das Modell so erweitern, daß man den
Nutzen von Conspiracy Number Search direkt nachweisen kann? Kann man vielleicht
auch nachweisen, daß es von Vorteil sein kann, an ALL-Knoten nicht immer alle Nach-
folger zu betrachten?
c) Die in dieser Arbeit vorgestellten Verfahren und Analysen beziehen sich alle auf Zwei-
personen-Nullsummenspiele. Lassen sie sich auch auf Mehrpersonenspiele, (m¨oglicher-
weise) ohne Nullsumme erweitern und ¨ubertragen?
Danksagung:
An dieser Stelle m¨ochte ich mich bei meinem Betreuer Prof. Dr. Burkhard Monien bedan-
ken, der durch seine lang¨ahrige Unterst¨utzung sowohl diese Arbeit als auch das Schach-
programm ’P.ConNerS’ erst m¨oglich gemacht hat.
In gleicher Weise gilt mein Dank meinem Kollegen Dr. Rainer Feldmann, der in unz¨ahli-
gen Diskussionen und Gespr¨achen mit hilfreichen Kommentaren zum Erfolg beigetragen
hat.
Des weiteren bedanke ich mich bei Prof. Dr. Ingo Alth¨ofer f¨ur seine wertvollen Anregun-
gen und Korrekturen, sowie bei meinen Eltern f¨ur einige sprachliche Hinweise.
131
Der BT2630-Test
BT01
lam n_lon9pqn
n n nsrut
run n n n
n n vw`x
t nsyOn x
n n n{zSn
yux n n9|qn
n n n;}on;}
ÌÌ
f5g7
ÌHÌ
BT02
n n np`n
n v nsrOn~r
rOt~yOn nsrun
n n t n
yOx n n
n n nsyOx
nnnx
n n n n9|
ÌHÌ
d4b6
ÌÌ
BT03
n n
t m n~rOt
tEn n t
n {z
n n n x
n nn~yOn
nsyun nsyOn
n n n n|
ÌÌ
e5e6
ÌHÌ
BT04
n n
n~yOn n tsr
n x t n
nntn
x n n x
n nn x
zSn v n9|qn
nn
ÌHÌ
a2f7
ÌHÌ
BT05
n n n
nnnn
n(n n n
n9|qn n n
n n n n
nnnn
n t n n
n n9pqn n
ÌÌ
b5a6
ÌHÌ
BT06
nn
nsrut n n~r
n9qn n n
x n n n}
n}n~rOn_lan
n x nsrOn
x~yOn x
n n n
ÌÌ
e4e3
ÌÌ
BT07
n n npqn
t n m nsr
lan nsrO
n n n n
n x n
n n n x
yOx n n x
n n}n
ÌHÌ
c6d6
ÌÌ
BT08
np`_lon n
n~rOn n tsr
runEsrOt
ntnn
yun(nsyOx n
nnnn
xsyun n~yOx
n
ÌÌ
d6c6
ÌHÌ
BT09
lan n n9pqn
t~rOn t vsr
n n n~rOn
txn
n{Sx ~yOn
n xz n
yun n n~yOx
n n|`n
ÌHÌ
g6g5
ÌHÌ
BT10
n;lon np`n
n{S v t
rOn t~y
n
rutsyut n
nnnn
nsyux n~y
yOn x n
n n n|q}
ÌHÌ
g1g7
ÌÌ
BT11
v_lan npqn
t n n~rOn
nsrun_lan n
n n~rOn(n
n `nsrOn
nsyOn x x{
yOn n{zSnx
n }
ÌÌ
h3h2
ÌHÌ
BT12
n n n n
t~rOn np`n
nsrun{t n
nxnn
n n x n
n}n t sr
yux n;}n n
n n n{z
ÌHÌ
e6e4
ÌHÌ
132 Zusammenfassung und offene Probleme
BT13a
nEm n
n t n nsr
rOn t n n
n n n nsy
(xsyusyOn
t n n
n n n n
n|qn}n
ÌHÌ
c8e6
ÌHÌ
BT14
n 9pqn
n~rOn nsr
r
run n~rO~rOn
nxsrux n
x x n}n
x n{zSn n;}
n n n~yOx
nnn
ÌHÌ
h3h7
ÌÌ
BT15a
n(nn n
t n n n
t t np`v
yutw`n n~r
yOn~yOn~yOn x
n n n x
nn
n n n{zn
ÌÌ
e4e5
ÌÌ
BT16a
np`_lan n
tsrOt(n~rOtsr
n v n n
n nn n
nxn
n x n9wqnsy
yOx n(nsyOn
zn}
ÌHÌ
h4g2
ÌHÌ
BT17
n n_lanpqn
t m;lon~rOn
nsruv srOn
nsrOn n nsr
n x
n nn~yOn
yOx n x|qn
n n n;}
ÌHÌ
c1f4
ÌHÌ
BT18
n n n n
nntn
n n n n
n nsyun nsr
yun t9|qn n
nnnx
n n n v
n np`n n
ÌHÌ
d5d6
ÌÌ
BT19
n np`n
tsrun n
n n nsrut
xsyunw`t n9
n~yOt t n
n nsyun x
n ~yOxEx
n n;}
ÌÌ
f4f3
ÌÌ
BT20
lon n pqn
n n n~rOn
n nsrO
n t n n
rOn n nsyOn
x n n9wqn
mEn(x x
n
ÌHÌ
a1a2
ÌHÌ
BT21a
pqn n n n
n n n n
yOx v nsyOn
n~y
nsy
n n;}on n
n n n n
n n nqt
n n n n
ÌHÌ
e4e1
ÌHÌ
BT22
l
(n9pqn
t~rOn msrutsr
n t
n
n tsrun
vsyOn n n
nxn
yux n9wqx~yOx
n{zS(n;}
ÚWÚ
a2a3
ÚWÚ
BT23a
nnnn
n n n n~r
nnnn
t n nsrOn
nnn
sru n x
n n~yOn x
n n n n
ÌÌ
g3g4
ÌHÌ
BT24
}n n n n
n n~rOn nsr
n n n n
n n~yOn x
n n n
nsrOn n nsr
x |`x x
n n n n{
ÌHÌ
g5g6
ÌHÌ
BT25
n n n n
n n n n
n t n
t n
yOn
n nsyu n
nsyOn t
n n n n
n n n(n
ÌHÌ
e5d3
ÌÌ
BT26
n_lon n9pqn
t( m nsr
t n~r
rOn
n nsrun n
n x x n
n~yOn( n
yu n~yOx
n n n;}o
ÌHÌ
f4f5
ÌÌ
BT27
n np`n
t n_lan t
t nsyut
n n x{zn~y
n(n~rOn n
x n x n
nnn
n n n n
ÌÌ
e5e6
ÌÌ
BT28a
l
Enp`nq
t n~rOn~rOtsr
n n n
nsrOn9wqn9wqnsy
n nsyunsyOn
n n~yOnzn
yOmsyun n n
n n9|qv
ÌHÌ
e4e5
ÚWÚ
133
BT29a
lanEnpqv
t~rOn9qnsrutsr
n{Sn n n
ntn
zSn(n n n
n t nw`n
yux n x~yOx
n n;}
ÚHÚ
e1c1
ÚWÚ
BT30
n9pqn n n
n t n ~r
rOn~rOv n n
nsrun t n
n n~yOn n
xw`nsyunsyOn
x n9|qx
n n n n
ÌÌ
f3f4
ÌÌ
134 Zusammenfassung und offene Probleme
Literaturverzeichnis
[AD87] G. M. Adelson-Velsky, V. L. .Arlazarov, M. V. Donskoy. Algorithms for Ga-
mes. Springer, (1987).
[ADLR93] I. Alth¨
ofer, C. Donninger, U. Lorenz, and V. Rottmann. On Timing, Perma-
nent Brain and Human Intervention. Advances in Computer Chess 7 (ed
J. van den Herik), (1993).
[All94] L. V. Allis. Searching for Solutions in Games and Artificial Intelligence.
(1994). Doctoral-Thesis, University of Limburg, Maastricht, The Nether-
lands.
[Alt88] I. Alth¨
ofer. Root Evaluation Errors: How They Arise and Propagate.
ICCA Journal, 11(3):55–63, (1988).
[Alt90a] I. Alth¨
ofer. Generalized Minmax Algorithms are no better Error Cor-
rectors than Minmax Itself. In D.F. Beal, editor, Advances in Computer
Chess 5, pages 265–282. North-Holland, (1990).
[Alt90b] I. Alth¨
ofer. An Incremental Negamax Algorithm. Artificial Intelligence,
43(1):57–65, (1990).
[Alt00] I. Alth¨
ofer. Email-Korrespondenz. (2000).
[Ana91] T.S. Anantharaman. Extension Heuristics. ICCA Journal, 14(2):47–63,
(1991).
[Bau78] G.M. Baudet. The Design and Analysis of Algorithms for Asynchronous
Multiprocessors. PhD thesis, Carnegie Mellon University, Pittsburgh, PA,
(1978).
[Bea80] D.F. Beal. An Analysis of Minimax. In M.R.B. Clarke, editor, Advances in
Computer Chess 2, pages 103–109. Edinburgh University Press, (1980).
136 Literaturverzeichnis
[Bea82] D.F. Beal. Benefits of Minimax Search. In M.R.B. Clarke, editor, Advances
in Computer Chess 3, pages 17–24. Pergamon Press, (1982).
[Bea89] D.F. Beal. Experiments with the Null Move. Advances in Computer Chess
5 (ed. Beal, D.F.), pages 65–79, (1989).
[Bea99] D. F. Beal. The Nature of Minimax Search. (1999). Doctoral-Thesis,
University of Maastricht, The Netherlands.
[Ber79] H. Berliner. The B* Tree Search Algorithm: A Best-first Proof Procedu-
re. Artificial Intelligence, 12(1):23–40, (1979).
[BG82] I. Bratko and M. Gams. Error Analysis of the Minimax Principle. In
M.R.B. Clarke, editor, Advances in Computer Chess 3, pages 1–15. Perga-
mon Press, (1982).
[BJK
å
95] R. D. Blumofe, C. F. Joerg, B. C. Kuszmaul, C. E. Leiserson, K. H. Randall,
A. Shaw, and Y. Zhou. Cilk: An Efficient Multithreaded Runtime System.
Proceeding of the 5th ACM SIGPLAN Symposium on Principles and Prac-
tice of Parallel Programming, PPOPP, (1995).
[BT94] H. Bednorz and F. T¨
onissen. Der neue Bednorz-T¨
onissen-Test. Computer
Schach und Spiele, 11(2):24–27, (1994).
[CT82] J.H. Condon and K. Thompson. Belle Chess Hardware. Advances in
Computer Chess III, M.R.B. Clarke (Editor), Pergamon Press, pages 44–54,
(1982).
[Don93] C. Donninger. Null Move and Deep Search. ICCA Journal, 16(3):137–143,
(1993).
[Don95] C. Donninger. Pers¨onliches Gespr¨ach. (1995).
[Don00] C. Donninger. Die Wissenschaft kehrt zur¨uck. Computer-Schach & Spiel,
Heft 2, Seite 40, (2000).
[EBG82] J. H. Conway E. Berlekamp and R. K. Guy. Winning Ways for Your Ma-
thematical Plays. Academic Press, London, England, (1982).
[Fel93] R. Feldmann. Spielbaumsuche mit massiv parallelen Systemen. (1993).
Doctoral-Thesis, University of Paderborn, Germany.
[Fel96] R. Feldmann. Fail High Reductions. Advances in Computer Chess 8 (ed. J.
van den Herik), (1996).
Literaturverzeichnis 137
[FF82] R.A. Finkel and J.P. Fishburn. Parallelism in Alpha-Beta Search. Artificial
Intelligence, 19(1):89–106, (1982).
[FK88] C. Ferguson and R.E. Korf. Distributed Tree Search and Its Application
to Alpha-Beta Pruning. In Proceedings of the Seventh National Confe-
rence Artificial Intelligence (AAAI-88), pages 128–132, Minneapolis, MN,
August (1988).
[FMM91] R. Feldmann, P. Mysliwietz,and B. Monien. Distributed Game Tree Search
on a Massively Parallel System. In B. Monien and Th. Ottmann, editors,
Data structures and efficient algorithms: Final report on the DFG special
joint initiative, volume LNCS 594, pages 270–288. Springer-Verlag, Sep-
tember (1991).
[FMMV90] R. Feldmann, B. Monien, P. Mysliwietz, and O. Vornberger. Distributed
Game Tree Search. In L.N. Kanal V. Kumar, P.S. Gopalakrishnan, edi-
tor, Parallel Algorithms for Machine Intelligence and Vision, pages 66–101.
Springer-Verlag, (1990).
[FO88] E.W. Felten and S.W. Otto. Chess on a Hypercube. In G. Fox, editor, The
Third Conference on Hypercube Concurrent Computers and Applications,
volume II-Applications, pages 1329–1341, Passadena, CA, (1988).
[Fra95] A. S. Fraenkel. Combinatorial Games: Selected Bibiliography with a
Succinct Gourmet Introduction. MSRI Publications, 29, (1995).
[Gas95] R. U. Gasser. Harnessing Computational Recources for Efficient Exhau-
stive Search. (1995). Doctoral-Thesis, Swiss Federal Institute of Technolo-
gy Z¨urich, Swiss.
[GEIC67] R.D. Greenblatt, D.E. EastlakeIII, and S.D. Crocker. The Greenblatt Chess
Program. Proceeding of the Fall Joint Computing Conference, San Fran-
cisco, pages 801–810, (1967).
[Hei99] E. A. Heinz. Scalable Search in Computer Chess. (1999). Doctoral-Thesis,
University of Karlsruhe, Germany.
[HGN85] R.M. Hyatt, B.E. Gower, and H.L. Nelson. Cray Blitz. Advances in Com-
puter Chess IV, D.F. Beal (Editor), Pergamon Press, pages 8–18, (1985).
[HH99] H. Hellwagner and A. Reinefeld . SCI:ScalableCoherent Interface: Archi-
tecture and Software for High-Performance Compute Clusters. Lecture
Notes in Computer Science 1734, (1999).
138 Literaturverzeichnis
[HS89] R. M. Hyatt and B. W. Suter. A Parallel Alpha/Beta Tree Searching Algo-
rithm. Parallel Computing, 10:299–308, (1989).
[Hsu90] F-H. Hsu. Large Scale Parallelization of Alpha-Beta Search: An Al-
gorithmic and Architectural Study with Computer Chess. PhD thesis,
Carnegie Mellon University, Pittsburgh, PA, February (1990).
[JS97] A. Plaat J. Schaeffer. Kasparov versus Deep Blue: The Rematch. ICCA
Journal, pages 95–101, (1997).
[KM75] D.E. Knuth and R.W. Moore. An Analysis of Alpha-Beta Pruning. Artifi-
cial Intelligence, 6(4):293–326, (1975).
[LN91] D. Levy and M. Newborn. How Computers Play Chess. (1991).
[LR96] U. Lorenz and V. Rottmann . Parallel Controlled Conspiracy Number
Search. Advances in Computer Chess 8 (ed J. van den Herik), (1996).
[Lor00] U. Lorenz. Controlled Conspiracy-2 Search. Proceedings of the 17th An-
nual Symposium on Theoretical Aspects of Computer Science (STACS), (H.
Reichel, S.Tison eds), Springer LNCS, pages 466–478, (2000).
[LRFM95] U. Lorenz, V. Rottmann, R. Feldmann, and P. Mysliwietz. Controlled Con-
spiracy Number Search. ICCA Journal, 18(3):135–147, (1995).
[LVAvdH89] M. van der Meulen L. V. Allis and H. J. van den Herik. A Knowledge-
Based Approach to Connect-Four: The Game is over: White To Move
Wins. Heuristik Programming in Artificial Intelligence I, The First Compu-
ter Olympiad, (1989).
[MC82] T.A. Marsland and M.S. Campbell. Parallel Search of Strongly Ordered
Game Trees. ACM Computing Surveys, 14(4):533–551, December (1982).
[McA88] D.A. McAllester. Conspiracy Numbers for Min-Max Searching. Artificial
Intelligence, 35(1):287–310, (1988).
[MOS86] T.A. Marsland, M. Olafsson, and J. Schaeffer. Multiprocessor Tree-Search
Experiments. In D.F. Beal, editor, Advances in Computer Chess 4, pages
37–51. Pergamon Press, (1986).
[MRS87] T.A. Marsland, A. Reinefeld, and J. Schaeffer. Low Overhead Alternatives
to SSS*. Artificial Intelligence, 31(1):185–199, (1987).
Literaturverzeichnis 139
[Mys94] P. Mysliwietz. Konstruktion und Optimierung von Bewertungsfunktio-
nen beim Schach. (1994). Doctoral-Thesis, University of Paderborn, Ger-
many.
[Nau79] D.S. Nau. Quality of Decision versus Depth of Search on Game Trees.
PhD thesis, Duke University, Durham, NC, (1979).
[Nau82] D.S. Nau. An Investigation of the Causes of Pathology in Games. Artifi-
cial Intelligence, 19(3):257–278, (1982).
[New88] M. Newborn. Unsynchronized Iteratively Deepening Parallel Alpha-Beta
Search. IEEE Transactions on Pattern Analysis and Machine Intelligence,
PAMI-10(5):687–694, (1988).
[Pal85] A.J. Palay. Searching with Probabilities. (1985).
[Pea83] J. Pearl. On the Nature of Pathology in Game Searching. Artificial Intel-
ligence, 20(4):427–453, (1983).
[Pea84] J. Pearl. Heuristics – Intelligent Search Strategies for Computer Pro-
blem Solving. Addison-Wesley Publishing Co., Reading, MA, (1984).
[Pla93] A. Plaat. RESEARCH, RE:SEARCH & RE-SEARCH. (1993). Doctoral-
Thesis, University of Rotterdam, Netherlands.
[Rei89] A. Reinefeld. Spielbaum - Suchverfahren. Springer, (1989).
[Riv87] R.L. Rivest. Game Tree Searching by Min/Max Approximation. Artificial
Intelligence, 34(1):77–96, (1987).
[Sch83] J. Schaeffer. The History Heuristic. ICCA Journal, 6(3):16–19, (1983).
[Sch86] G. Schr¨
ufer. Presence and Absence of Pathology on Game Trees. In
D. F. Beal, editor, Advancesin Computer Chess 4, pages 101–112. Pergamon
Press, (1986).
[Sch88] G. Schr¨
ufer. Minimax-Suchen Kosten, Qualit¨
at und Algorithmen.
Doctoral-Thesis, University of Braunschweig, Germany, (1988).
[Sch89a] J. Schaeffer. Distributed Game-Tree Searching. Journal of Parallel and
Distributed Computing, 6:90–114, (1989).
[Sch89b] J. Schaeffer. The History Heuristic and Alpha-Beta Search Enhance-
ments in Practice. IEEE Transactions on Pattern Analysis and Machine
Intelligence, PAMI-11(1):1203–1212, November (1989).
140 Literaturverzeichnis
[Sch90] J. Schaeffer. Conspiracy Numbers. Artificial Intelligence, 43(1):67–84,
(1990).
[Sei97] Y. Seirawan. The Kasparov - Deep Blue Games. ICCA Journal, pages
102–125, (1997).
[Sel91] Reinhard Selten. Game Equilibrium Models III. Springer-Verlag Berlin
Heidelberg, (1991).
[Sha50] C.E. Shannon. Programming a Computer for Playing Chess. Philosophi-
cal Magazine, 41:256–275, (1950).
[Sto79] G.C. Stockman. A Minimax Algorithm Better thanAlpha-Beta? Artificial
Intelligence, 12(2):179–196, (1979).
[Tur53] A.M. Turing. Digital Computers Applied to Games. B.V. Bowden: Fa-
ster than Thought: A Symposium on Digital Computing Machines, Pitman,
pages 286–310, (1953).
[vdM90] M. van der Meulen. Conspiracy Number Search. ICCA Journal, 13(1):3–
14, March (1990).
[vNM43] J. von Neumann and O. Morgenstern. Theory of Games and Economic
Behaviour. Princeton University Press, (1943).
[WE96] J.-C. Weill. The ABDADA Distributed Minimax-Search Algorithm. ,
ICCA Journal, 19(1):3–14, (1996).
[Zus84] K. Zuse. Der Computer — Mein Lebenswerk. Springer Verlag, (1984).
Zeitungsartikel
[BILD00] K. Wessels. Das Schachmonster. BILD-Zeitung, 20. Juli (2000).
[CB00] K. M¨
uller. P.Conners gewinnt als erster Rechner ein GM-Turnier.
http://www.chessbase.de/Nachrichten/Current/juli2000/dortmund 1907.htm
[CSS00] Bums - da krachte es. Computer-Schach & Spiele, Heft 4, (2000).
[CW99] Schwerpunkt Unternehmenssteuerung. Computerwoche, Nr. 25, 25. Juni
(1999).
[HS00] Schachprogramm schl¨
agt Großmeister.
http://www.heise.de/newsticker/data/rh-20.07.00-000/
[ICC00] P.ConNers wins the 10
Grandmaster Tournament in Lippstadt. ICGA
Journal, Vol. 23, No. 3., September (2000)
[IX00] Schachprogramm schl¨
agt Großmeister. IX, Heft 9/(2000).
[LS00] Computer gewinnt Turnier. Lippstadt am Sonntag, 23. Juli (2000).
[NW00] Uni-Programm schreibt Schachgeschichte. Neue Westf¨alische, 19. Juli
(2000).
[PAT00] Sensations-Coup perfekt. Der Patriot, 17. Juli (2000).
[S00] K. M¨
uller. Computer gewinnt Kategorie XI-Turnier. Schach, 8/(2000)
[SCHM00] A. Brenke, S. Wehmeier. Der Anfang vom Ende? Schach Magazin 64,
15/(2000).
[WT00] Computer siegt. Wochentip, 19. Juli (2000).
