Schachprogramm

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Solid white.svg a b c d e f g h Solid white.svg
8 Chess rdl45.svg Chess ndd45.svg Chess bdl45.svg Chess qdd45.svg Chess kdl45.svg Chess bdd45.svg Chess ndl45.svg Chess rdd45.svg 8
7 Chess pdd45.svg Chess pdl45.svg Chess pdd45.svg Chess pdl45.svg Chess pdd45.svg Chess pdl45.svg Chess pdd45.svg Chess pdl45.svg 7
6 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg 6
5 Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg 5
4 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg 4
3 Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg 3
2 Chess pll45.svg Chess pld45.svg Chess pll45.svg Chess pld45.svg Chess pll45.svg Chess pld45.svg Chess pll45.svg Chess pld45.svg 2
1 Chess rld45.svg Chess nll45.svg Chess bld45.svg Chess qll45.svg Chess kld45.svg Chess bll45.svg Chess nld45.svg Chess rll45.svg 1
a b c d e f g h
Zweidimensionales Schachbrett, wie es viele Schach-Frontends auf dem Bildschirm ausgeben

Ein Schachprogramm ist ein Computerprogramm zum Spielen von Schach. Es läuft entweder auf Allzweckcomputern wie PCs als ein Programm unter vielen oder in speziell zum Schachspielen angefertigten Schachcomputern. Die Entwicklung von Schachprogrammen ist eine Disziplin des Computerschachs.

Im engeren Sinne wird unter dem Schachprogramm nur die sogenannte Engine für die Berechnung der Züge verstanden. Ein Schach-Frontend übernimmt dann deren Darstellung und die Benutzerinteraktion. Für die Kommunikation zwischen Schachengine und Frontend gibt es zwei weit verbreitete offene Schach-Kommunikationsprotokolle. Einmal das XBoard-Protokoll und das neuere Universal Chess Interface (UCI). Die Stellungen und Partien werden in proprietären Formaten oder auch im offenen Portable Game Notation (PGN)-Format gespeichert.

Aktuelle Programme[Bearbeiten]

Als eines der bekanntesten kostenlos erhältlichen Schachprogramme gilt das Open-Source-Projekt Crafty von Robert Hyatt. Ein weiteres spielstarkes Schachprogramm ist Fruit, das bei der Weltmeisterschaft im Computerschach 2005 den zweiten Platz belegte. Bis zur Version 2.1 ist Fruit ebenfalls unter einer Open-Source Lizenz erhältlich, genauso wie das ungefähr gleich starke Glaurung 2.1. Eine Vorversion des Programmes Zappa, das die Weltmeisterschaft 2005 überlegen gewinnen konnte, steht lediglich als Freeware im Internet zur Verfügung.

Das derzeit stärkste (und zudem kostenlos erhältliche) Programm ist Houdini.[1] Allerdings ist das Programm Houdini umstritten. Der Programmierer des Schachprogramms Rybka behauptet, ihm sei Quelltext gestohlen worden und auf dieser Basis seien diverse, sehr spielstarke Schachprogramme (IPPOLIT-Familie) entstanden, darunter auch Houdini. Ein Beleg für diese Behauptung wurde - zumindest öffentlich - nicht erbracht. Dem Programmierer des Schachprogramms Rybka wiederum wird nachgesagt, dass sein Programm Rybka auf Fruit basieren würde.[2] Aufgrund dieser Kontroversen wurde Houdini - ebenso wie einige andere Programme der Ippolit-Familie - von diversen Ranglistenbetreibern zeitweilig nicht gelistet. Im weiteren Verlauf wurde das Programm Rybka als Plagiat von Fruit eingestuft, wodurch Rybka alle vorherigen Titel und Erfolge aberkannt wurden. Der Programmierer von Rybka wurde auf Lebenszeit für alle Computerschachturniere gesperrt. Houdini hingegen, welches wiederum auf Rybka basieren soll, war dann anerkannt die stärkste Schach-Engine und wurde zusammen mit dem Frontend Aquarium bei den Schachweltmeisterschaften zur Analyse genutzt. Inzwischen werden die Ratinglisten aber vom kommerziellen Programm Komodo und der unten beschriebenen Open-Source-Entwicklung Stockfish Kopf an Kopf angeführt.

Ein weiteres Open-Source Programm ist Stockfish, das auf einem Betriebssystem mit 64-Bit-Architektur und einem Prozessor stärker als fast alle anderen Programme (auch kommerzielle) spielt. Auf aktuellen Rankinglisten, die aus Computer-vs.-Computer-Spielen errechnet werden, liegt die aktuelle Version auf Rang 2 (oder 3), je nach genauen Austragungsbedingungen.[3][4][5][6][7][8] Stockfish wird nicht verdächtigt, ein Plagiat zu sein, und es ist kostenlos erhältlich.

Für Anfänger bietet sich eine skalierbare Engine an, die man in der Elo-Stärke begrenzen kann wie Ufim.[9]

José-Schachdatenbank und Schach-Frontend

Zur komfortablen Bedienung wird noch eine als Schach-Frontend bezeichnete Benutzeroberfläche benötigt. Hierzu kann beispielsweise das Programm XBoard genutzt werden. Es läuft unter den Betriebssystemen Microsoft Windows (unter dem Namen WinBoard), Unix/Linux und Amiga und wird zusammen mit GNU Chess ausgeliefert. Ein graphisches java-basierendes Schach-Frontend mit Datenbankfunktionen ist das ebenfalls unter der GPL veröffentlichte José. Eine weitere beliebte Benutzeroberfläche unter Windows für mehr als 250 Schachprogramme ist Arena, die als Freeware verfügbar ist. Es gibt auch weitere Freeware, die sich für den Einsteiger eignet, so beispielsweise Arasan.[10] Das Schach-Frontend von KDE ist Knights.[11]

Ambitionierte Spieler greifen oft zu kommerziellen Programmen, die neben dem reinen Schachspiel auch viele Zusatzmöglichkeiten bieten, wie beispielsweise Partieanalyse und Schachtraining. Sehr bekannt dürften die Programme Shredder und Fritz sein. Diese Programme werden unter anderem von der Hamburger Firma ChessBase vertrieben, die den (europäischen) Markt für professionelle Schachsoftware zunehmend beherrscht. Seit 2005 sorgte das Programm Rybka für Schlagzeilen in Fachzeitschriften und Computerforen. Rybka hat ausgeprägte Fertigkeiten auf positionellem beziehungsweise schachstrategischem Terrain und ist damit der menschlichen Spielweise näher gekommen als die meisten anderen Schachprogramme. Rybka führte die wichtigsten Computerschach-Ranglisten - in denen Houdini nicht gelistet war - mit 50−150 Punkten Vorsprung an. Schachgroßmeister wie Anand, Topalov oder Morozevich nutzten Rybka zur Analyse, inzwischen wird häufiger Stockfish, Critter oder Houdini eingesetzt.

Inzwischen kann man hochklassiges Schach auch auf Mobiltelefonen, PDAs und sonstigen Handhelds spielen. Auf Palm-OS-basierten Geräten steht beispielsweise mit OpenChess ein freies Schachprogramm zur Verfügung, das die Auswahl zwischen mehreren Schachengines bietet.

Um Schachvarianten einmal auszuprobieren, kann das freie Programm ChessV benutzt werden.

Aufbau[Bearbeiten]

Die Hauptbestandteile eines Schachprogramms sind der Zuggenerator, die Bewertungsfunktion und ein Programmteil zur Steuerung der Suche und der Auswahl des nächsten Zuges. Von der aktuellen Stellung (Spielsituation) ausgehend, führt das Programm eine Iterative Tiefensuche durch. In jeder Iteration führt es verschiedene Zugfolgen der Reihe nach aus, bewertet die erreichten Stellungen (Blätter des Suchbaums) mit der Bewertungsfunktion, und von diesen Blattwerten ausgehend bewertet es nach dem Minimax-Prinzip die inneren Knoten des Suchbaums und damit auch die Züge, die jeweils zu einem Knoten führen. Nach der letzten Iteration spielt es den höchstbewerteten Zug im Wurzelknoten (der die aktuelle Stellung repräsentiert).

Eine der wichtigsten Unterscheidungsmöglichkeiten von Schachprogrammen ist die Art der internen Brettdarstellung, derer sich alle anderen Bestandteile des Programms bedienen.

Zuggenerator und interne Brettdarstellung[Bearbeiten]

Solid white.svg a b c d e f g h Solid white.svg
8 Chess rdl45.svg Chess ndd45.svg Chess bdl45.svg Chess qdd45.svg Chess kdl45.svg Chess bdd45.svg Chess ndl45.svg Chess rdd45.svg 8
7 Chess pdd45.svg Chess pdl45.svg Chess pdd45.svg Chess pdl45.svg Chess d45.svg Chess pdl45.svg Chess pdd45.svg Chess pdl45.svg 7
6 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg 6
5 Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess pdd45.svg Chess l45.svg Chess d45.svg Chess l45.svg 5
4 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess pll45.svg Chess d45.svg Chess l45.svg Chess d45.svg 4
3 Chess d45.svg Chess l45.svg Chess nld45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg 3
2 Chess pll45.svg Chess pld45.svg Chess pll45.svg Chess pld45.svg Chess l45.svg Chess pld45.svg Chess pll45.svg Chess pld45.svg 2
1 Chess rld45.svg Chess l45.svg Chess bld45.svg Chess qll45.svg Chess kld45.svg Chess bll45.svg Chess nld45.svg Chess rll45.svg 1
a b c d e f g h
Das in allen folgenden Darstellungen verwendete Beispiel
Spielstellung nach: 1. e4 e5 2. Sc3

Der Zuggenerator erzeugt eine Liste aller in einer bestimmten Stellung legalen (regelkonformen) Züge (mögliche Bewegungen der Spielfiguren). In der Anfangsstellung sind 20 Züge möglich (16 Bauernzüge, 4 Springerzüge), im weiteren Spielverlauf kann man im Mittel mit etwa 40 legalen Zügen in jeder Stellung rechnen (im Endspiel weniger). Der Zuggenerator muss auch komplizierte Züge wie Rochaden, Bauernumwandlungen und En-passant-Schläge berücksichtigen.

Zur Kodierung der Figuren werden hier in den Beispielen folgende ganzen Zahlen verwendet:
Figur Kodierung
Weiß Schwarz
leeres Feld 0 0
Bauer 1 2
Turm 11 21
Springer 12 22
Läufer 13 23
Dame 14 24
König 10 20
ungültiges Feld -1 -1

Die Implementierung des Zuggenerators hängt eng mit der internen Brettdarstellung zusammen. Hier gibt es drei wichtige Vertreter:

12×10-Darstellung[Bearbeiten]

Spielstellung nach: 1. e4 e5 2. Sc3

-1 (0) -1 (1) -1 (2) -1 (3) -1 (4) -1 (5) -1 (6) -1 (7) -1 (8) -1 (...)
-1 (10) -1 -1 -1 -1 -1 (15) -1 -1 -1 -1 (19)
-1 (20) 21 22 23 24 20 23 22 (27) 21 -1
-1 2 2 2 2 0 (35) 2 2 2 -1 (39)
-1 0 0 0 0 0 0 (46) 0 0 (48) -1
-1 0 0 0 0 2 0 0 0 -1
-1 0 0 0 0 1 0 0 0 -1
-1 0 0 12 0 0 0 0 0 -1
-1 1 1 1 1 0 1 1 1 -1
-1 11 0 13 14 10 13 12 11 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 (...) -1 (115) -1 (116) -1 (117) -1 (118) -1 (119)
Das Spielbrett wird auf ein eindimensionales und 120 Elemente großes Array abgebildet. Der Index (Zahlen in Klammern) läuft in der Regel zeilenweise, hier von 0 (links oben) bis 119 (rechts unten). Zusätzlich zu den 64 gültigen Feldern enthält das Array Felder, welche eine Figur beim Verlassen des Brettes erreichen würde und die quasi einen Rand um das reguläre Brett bilden. Auf diesen Randfeldern wird ein bestimmter Wert (hier -1) gespeichert, und wenn eine Figur auf ein Feld mit diesem Eintrag ziehen würde, heißt das, dass sie damit das Brett verlassen würde. Dies kann leicht abgefragt werden, da man ohnehin nachsehen muss, ob das Zielfeld von einer eigenen Figur besetzt ist (nur gegnerische Figuren dürfen geschlagen werden). Diese Technik macht den Zuggenerator sehr schnell (z. B. in Phalanx, ein Schachprogramm, welches man sich als Lehrbeispiel wegen seiner Übersichtlichkeit gut ansehen kann). Der linke und rechte Rand an jeder Seite muss nur ein Feld groß sein, denn ein Springer, der seitlich vom Brett zieht, landet immer entweder auf der linken oder der rechten Randreihe.
Durch Addition der folgenden Konstanten zu einem Feldindex lassen sich die möglichen Zielfelder für eine Figur auf diesem Feld bestimmen.
Bewegung Konstanten
Horizontale und vertikale Bewegung (Turm, Dame, König) -10, -1, +1, +10
Diagonale Bewegung (Läufer, Dame, König) -11, -9, +9, +11
Bewegung wie ein Springer -21, -19, -12, -8, +8, +12, +19, +21
Betrachten wir den schwarzen Springer auf Feld 27 (Sg8). Die Addition dieser Konstanten zu 27 ergibt die potentiellen Zielfelder: 6, 8, 15, 19, 35, 39, 46 und 48. Ist der Wert im Zielfeld -1, dann ist der Zug nicht möglich, da der Springer über den Rand ziehen würde. Ist der Wert 1 oder 10 bis 14, ist eine weiße Figur auf dem Feld, die geschlagen werden kann, und ist er gleich Null ist ein Zug auf das leere Feld möglich. Der Springer kann hier also drei verschiedene Züge auf die Zielfelder 35, 46 und 48 ausführen, die der Zugliste hinzugefügt werden. Falls der Zuggenerator nur legale Züge – und nicht alle pseudolegalen – erzeugen soll, muss man noch beachten, ob der Springer gefesselt ist oder ein Schachgebot besteht, das man abwehren muss.
Ähnlich geht es mit den anderen Figurenarten. Die langschrittigen (Dame, Läufer, Turm) können ein besetztes Feld nicht überspringen. Nachdem ein solches erreicht wurde, ist in dieser Richtung kein weiterer Zug möglich und man geht zur nächsten Zugrichtung.
Während der Zuggenerator recht einfach aufgebaut und schnell ist, sind die statischen Bewertungsfunktionen langsamer.

8×8-Darstellung[Bearbeiten]

Spielstellung nach: 1. e4 e5 2. Sc3
21 22 23 24 20 23 22 21
2 2 2 2 0 2 2 2
0 0 0 0 0 0 0 0
0 0 0 0 2 0 0 0
0 0 0 0 1 0 0 0
0 0 12 0 0 0 0 0
1 1 1 1 0 1 1 1
11 0 13 14 10 13 12 11
Die 8×8-Darstellung ist der menschlichen Sicht am nächsten. Das Programm GNU Chess verwendete sie bis Version 4. Das Brett wird, wie auch bei 12x10, als eindimensionales Array modelliert, hier mit Indexbereich 0 bis 63 (oder 1 bis 64). Ein Zweidimensionales Array scheint näherliegend, ist aber langsamer, denn ein Feld muss hier mit zwei Zahlen (Reihe und Linie) bezeichnet werden, zu beiden muss bei der Zugerzeugung eine Konstante addiert werden, und beim Zugriff auf ein Feld ist die Adressberechnung mit zwei Indizes komplizierter.
Prinzipiell funktioniert bei einer 8x8-Darstellung der Zuggenerator ähnlich. Da hier die Spezialfälle am Rand aber gesondert behandelt werden müssen, ist der Zuggenerator viel komplexer. Die statische Bewertungsfunktion arbeitet allerdings schneller, da Reihe und Linie, auf denen ein Feld liegt, mit schnellen Bitoperationen bestimmt werden können: UND-Verknüpfen mit 7 ergibt die Linie und Rechtsschieben um 3 Bit die Reihe (bei zeilenweiser Felderanordnung). Beim 12×10-Brett muss man hingegen durch 10 dividieren. Die Bewertungsfunktion benötigt diese Information oft, z. B. zur Doppelbauern- oder Isolani-Erkennung.
Auch mit dem 8×8-Brett ist eine schnelle und einfache Zugerzeugung möglich, allerdings um den Preis von viel zusätzlichem Speicherverbrauch. GNU Chess verwendet für jede Figurenart ein zweidimensionales Array nextpos mit 64 mal 64 Elementen. Indiziert man es mit dem Ausgangsfeld f einer Figur und einem ihrer Zielfelder, liest man das nächste Zielfeld für die Figur daraus ab. nextpos(f,f) liefert das erste Zielfeld. Für die langschrittigen Figuren gibt es zusätzlich das Array nextdir, aus dem bei besetztem Zielfeld das nächste Zielfeld gelesen wird (erstes Feld in einer neuen Zugrichtung). Gibt es kein Zielfeld mehr, liefern beide wieder den Wert f.
Eine andere Möglichkeit ist ein dreidimensionales Array, das für alle Felder und Figurentypen alle Zielfelder enthält, die diese Figur von diesem Feld aus erreichen kann. Der dritte Index läuft über diese Zielfelder. Der Speicherverbrauch ist hier niedriger, besonders wenn man ein zweidimensionales Array von Zeigern verwendet, die jeweils auf ein Halden-Array passender Größe zeigen, entsprechend der unterschiedlichen Zahl der Zielfelder. Die Einträge sind zweiteilig: der erste Teil ist der Zielfeldindex und der zweite ist die Zahl der im Array darauf folgenden Felder, die bei besetztem Zielfeld zu übergehen sind.

0×88-Darstellung[Bearbeiten]

Diese ist eine Weiterentwicklung der 8×8-Darstellung. Bei zeilenweiser Darstellung mit 16 Feldern je Zeile bildet der linke Bereich von 8 mal 8 Feldern das Schachbrett, der rechte Bereich von 8 mal 8 Feldern wird nicht verwendet. Wenn eine Figur über den Rand ziehen würde, erkennt man das durch die Konjunktion (UND-Verknüpfung) des Zielfeldindex mit der Hexadezimalzahl 0×88 (=136). Wenn das Ergebnis Null ist, bezeichnet der Feldindex ein gültiges Feld, anderenfalls würde die Figur das Brett verlassen. Reihe und Linie eines Feldes kann man ähnlich wie beim 8×8-Brett durch Rechtsschieben um 4 Bit bzw. UND-Verknüpfen mit 7 berechnen.

Bitboards[Bearbeiten]

Manche modernen Schachprogramme, etwa Rybka, Crafty oder GNU Chess 5, verwenden Bitboards. Diese sind besonders effizient auf 64-Bit-Rechnerarchitekturen implementierbar, wo die Anzahl der Bits eines Registers mit der Anzahl der Spielfelder übereinstimmt.
Spielstellung nach: 1. e4 e5 2. Sc3
zur besseren Übersichtlichkeit sind Bits mit dem Wert 0 durch '-' dargestellt

         Reihe     8        7        6        5        4        3        2        1
         Linie  abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh
    Bitposition 63    56       48       40       32       24       16        8        0
 Registername   |      |        |        |        |        |        |        |        |
            |   |      |        |        |        |        |        |        |        |
Bauern      B   -------- 1111-111 -------- ----1--- ----1--- -------- 1111-111 --------
Türme       T   1------1 -------- -------- -------- -------- -------- -------- 1------1
Springer    S   -1----1- -------- -------- -------- -------- --1----- -------- ------1-
Läufer      L   --1--1-- -------- -------- -------- -------- -------- -------- --1--1--
Damen       D   ---1---- -------- -------- -------- -------- -------- -------- ---1----
Könige      K   ----1--- -------- -------- -------- -------- -------- -------- ----1---
Weiss     WEI   -------- -------- -------- -------- ----1--- --1----- 1111-111 1-111111
Schwarz   SCH   11111111 1111-111 -------- ----1--- -------- -------- -------- --------
Beispiele: Durch die Bitweise UND-Verknüpfung T & WEI lassen sich jetzt alle Positionen der weißen Türme bestimmen, und ((B & SCH) >> 8) & !(WEI | SCH) liefert ein Bitmuster mit den Feldern, auf die ein schwarzer Bauer mit einem Einzelschritt ziehen kann.

Bewertungsfunktionen[Bearbeiten]

Die Bewertungsfunktion liefert die heuristische Bewertung einer Stellung zurück, ohne die Nachfolgezüge zu bestimmen. Sie setzt sich aus einer materiellen und einer positionellen Komponente zusammen. Die positionelle Komponente ergänzt die materielle, da die Stärke der Spielfiguren auch von ihren Positionen untereinander abhängen. Vereinfachte Bewertungsfunktionen können auch von menschlichen Spielern ausgeführt werden, was allerdings nur eine historische Bedeutung hat. Computerprogramme zeigen sehr oft die Bewertung einer Spielsituation numerisch (in sogenannten Bauerneinheiten) an, wobei positive Werte Vorteile und negative Werte Nachteile für einen bestimmten Spieler bedeuten.

Material[Bearbeiten]

Für die materielle Wertung werden für die auf dem Brett befindlichen Spielfiguren Werte addiert. Der ungefähre Wert der Figurenarten in 1/100 Bauerneinheiten ist in der folgenden Tabelle angegeben.

Bauer Springer Läufer Turm Dame
100 275 325 465 900

Dabei werden die weißen Figuren (bzw. die der Partei am Zug) positiv gezählt und die schwarzen (bzw. die der nachziehenden Partei) negativ. Der König braucht nicht mitgezählt zu werden, da beide Parteien während des gesamten Spiels jeweils einen König haben.

Position[Bearbeiten]

Die positionelle Wertung zu bestimmen, ist eine Aufgabe von größerer Komplexität, in der sich die verschiedenen Schachprogramme deutlich voneinander unterscheiden. Bei kommerziellen Programmen bleibt sie ein wohlgehütetes Geheimnis. Bei der positionellen Wertung wird versucht, Stellungen aufgrund von schachrelevanten Parametern zu bewerten. Schachrelevante Parameter lassen sich grob klassifizieren in Königssicherheit, Bauernstruktur, beherrschte und bedrohte Felder sowie Figurenentwicklung. So wird zum Beispiel eine Stellung, bei der die Türme noch eingeengt zwischen Springern und Bauern stehen, schlechter bewertet als eine, bei der die Türme schon auf offenen Linien stehen.

Innerhalb dieser Kategorien gibt es quasi beliebig viele Parameter (für Bauernstrukturen zum Beispiel Freibauer, Doppelbauer, Hebel, Widder, Isolani, Bauernketten; für Königssicherheit zum Beispiel: Kann der König leicht links oder rechts rochieren? Kann er im Zentrum bleiben? Sind Bauern vor dem König?). Es bietet sich an, diese Parameter zunächst wertneutral aus der gegebenen Stellung zu extrahieren. Schachprogrammierer stehen vor der Entscheidung, wie viel Rechenzeit sie für die positionelle Komponente einer ausgefeilten Bewertungsfunktion aufwenden sollen, und welche Parameter überhaupt einfließen sollen: Je tiefer die Schachprogramme den Suchbaum analysieren können, desto eher wird nämlich die Umwandlung positioneller Vorteile in materielle Vorteile sichtbar.

Statische Bewertungsfunktion[Bearbeiten]

Kann ein Schachprogramm die Werte dieser Parameter pro Stellung effizient bestimmen, müssen diese untereinander gewichtet werden. Die Gewichtung der positionellen Komponente kann teilweise automatisch über das Analysieren von Schachdatenbanken oder durch Spiele gegen andere Schachprogramme erfolgen. Geschieht dies im Vorfeld der Programmentwicklung, spricht man von einer statischen Bewertungsfunktion. Einfach aufgebaute Bewertungsfunktionen verwenden für die positionelle Komponente Positionsgewichte für die sechs Spielfigurentypen, die aber für Eröffnung, Mittel- und Endspiel jeweils unterschiedlich ausfallen.

Die Bewertungsfunktion kann außer in Grenzfällen wie Endspielen oder Matt- oder Pattsituationen keine objektiv richtigen Ergebnisse liefern. Indem die Bewertungsfunktion die materielle und positionelle Komponente zu einer einzigen Bewertungszahl zusammenfasst, ermöglicht sie aber die Sortierung und Auswahl des „besten“ beziehungsweise „schlechtesten“ Zuges.

Dynamische Bewertungsfunktion[Bearbeiten]

In der Regel wird die Bewertungsfunktion vom Programmierer implementiert und während des Spieles nicht mehr verändert. Eine erweiterte Möglichkeit besteht darin, während des Spieles vergleichbare Stellungen aus einer Schachdatenbank zu ermitteln und so die Gewichtung der positionellen Parameter zu optimieren. Dies entspricht eher dem menschlichen Ansatz. Ein erfahrener Spieler berücksichtigt Kriterien wie Königssicherheit oder Freibauern auch unter Einbeziehung ihm bekannter Partien und deren Ergebnissen.

Steuerung der Suche und Zugauswahl[Bearbeiten]

Grundsätzlich basiert die Steuerung der Suche auf dem Aufbau eines Positionsbaumes (Suchbaum) beginnend bei der aktuellen Stellung, allen Antwortzügen des Anziehenden, sowie für jeden Antwortzug aller möglichen Antwortzüge des Nachziehenden und so weiter, allein begrenzt durch die Rechenleistung und die für den Zug zur Verfügung gestellte Zeit. Jede dabei entstehende Stellung wird prinzipiell bewertet. Am Ende der Berechnung erfolgt die Zugauswahl nach dem Minimax-Algorithmus.

Da die Anzahl der zu untersuchenden Stellungen exponentiell wächst, andererseits eine höhere Suchleistung eine entsprechende Spielstärkeverbesserung hervorbringt, wurde von Programmierern in den rund 50 Jahren der Programmentwicklung ein ganzes Arsenal an Beschleunigungsmaßnahmen erfunden, die man in zwei Bereiche einteilen kann. Die einen versuchen, den Suchbaum durch allgemeine Algorithmen der Informatik zu vereinfachen, so zum Beispiel:

Die anderen verwenden intelligentere Ansätze (siehe B-Strategie), wie

  • das Sortieren der Züge nach ihrer Wertigkeit,
  • die Verwendung vereinfachter Bewertungsfunktionen für weniger gute Züge,
  • die selektiven Erweiterungen des Suchbaums für Hauptvarianten.

Diese Algorithmen ahmen das Verhalten eines menschlichen Spielers nach und sind sehr viel schwieriger zu implementieren als die erstgenannten. Auch lassen sie sich nicht so ohne weiteres auf andere Spiele wie Go übertragen.

Bibliotheken und Datenbanken[Bearbeiten]

Eröffnungsbibliothek[Bearbeiten]

Schach wird im Wettkampf auf Zeit gespielt, das heißt, für eine Anzahl von Zügen steht nur eine definierte Zeit zur Verfügung. Viele Schachprogramme sind daher mit einer Eröffnungsbibliothek ausgestattet, in der sehr viele „gute“ Zugreihenfolgen in der Eröffnungsphase von Schachspielen abgespeichert sind. In der Anfangsphase des Schachspiels sieht das Programm in dieser Bibliothek nach, welcher Zug in einer bestimmten Brettstellung der geeignetste ist. Dieses „Nachsehen“ geht schneller, als den Zug auszurechnen. Die so gesparte Rechenzeit steht dem Programm dann in späteren Phasen des Spiels zur Verfügung. Das Verfahren, Brettstellungen einschließlich der „guten“ Züge abzuspeichern, ist nur für Eröffnung und Endspiel sinnvoll, da hier die Anzahl der Brettstellungen noch überschaubar ist. Eröffnungsbibliotheken kommerziell erhältlicher Programme weisen einen immer größer werdenden Umfang auf. Sie werden meist aus Meisterpartien generiert. Dies birgt die Gefahr, dass auch unbemerkte Fehler übernommen werden, die das Programm aus eigener Berechnung nicht spielen würde.

Einen großen Anteil an der Spielstärke hat die Abstimmung der Eröffnungsbibliothek auf die später in der Partie genutzte Bewertungsfunktion.

Endspiel-Datenbank[Bearbeiten]

Im Endspiel, wenn nur noch wenige Figuren auf dem Brett sind, kann man den optimalen Zug im Vorhinein durch vollständige Analyse (Brute-Force-Methode) berechnen. Es gibt nicht wenige Endspielstellungen, in denen das menschliche Denken, aber auch die Computeranalyse in Echtzeit völlig überfordert wären. Viele Schachprogramme verwenden deshalb Endspiel-Datenbanken, die alle möglichen Stellungen mit 3, 4 oder 5 Steinen sowie deren Ausgang (bei optimalem Spiel) enthalten. Das Erstellen von Endspiel-Datenbanken geht auf Ken Thompson zurück. Die ersten Sechssteiner wurden 1991 von Lewis Stiller vollständig berechnet.

Schachdatenbank[Bearbeiten]

Schachdatenbanken enthalten gespielte Partien. Sie helfen zum Beispiel beim Studium von Eröffnungen und bei der Vorbereitung auf die nächsten Gegner.

Für Schachprogramme lassen sich aus dem Datenbestand Eröffnungsbibliotheken generieren. Auch ist es möglich, während der Partie vergleichbare Stellungen aus einer Schachdatenbank zu ermitteln und unter Berücksichtigung des dort verzeichneten Partieverlaufs positionelle Bewertungsparameter (siehe oben) zu optimieren (dynamische Bewertungsfunktion).

Geschichte[Bearbeiten]

Die Geschichte des Schachprogramms hängt sehr eng mit der Geschichte des Schachcomputers zusammen und lässt sich zumeist nicht getrennt behandeln. Hier werden lediglich Entwicklungen der grundlegenden Algorithmen beschrieben. Zu den in den letzten Jahren medienwirksam ausgetragenen Wettbewerben mit Weltklassespielern siehe den Artikel Computerschach.

Konrad Zuse[Bearbeiten]

In den Jahren 1942 bis 1945 schrieb Konrad Zuse das weltweit erste Schachprogramm in seiner neu entwickelten Programmiersprache, dem Plankalkül. Erstmals implementiert wurde die Sprache aber erst in den 1970ern.[12]

Alan Turing[Bearbeiten]

Alan Turing entwickelte während des Zweiten Weltkrieges in Bletchley Park ein Verfahren, welches jedem möglichen Zug einen Wert zuweist. So funktionierte Turings Schachprogramm:

  • Jede Figur erhielt einen bestimmten Wert: Bauer = 1; Springer = 3; Läufer = 3,5; Turm = 5; Dame = 10 und König = 1000 (damit dieser niemals geopfert werden konnte).
  • Alle weißen Züge und alle schwarzen Gegenzüge wurden untersucht. Wenn Weiß einen Schlagzug ausführen konnte, dann wurden alle Schlagzüge des Gegners, alle darauffolgenden weißen Schlagzüge usw. untersucht, bis die Stellung „tot“ war, das heißt bis es keine weiteren Schlagzüge und kein Matt gab. In den entstehenden Stellungen wurde eine Figurenzählung durchgeführt und der Zug gewählt, der das meiste Material gewann bzw. am wenigsten verlor.

Da jedoch, besonders in der Eröffnungsphase, die meisten zur Auswahl stehenden Züge das gleiche Ergebnis (± Null) lieferten, führte Turing auch einige positionelle Bewertungskriterien ein.


Solid white.svg a b c d e f g h Solid white.svg
8 Chess l45.svg Chess rdd45.svg Chess l45.svg Chess rdd45.svg Chess l45.svg Chess d45.svg Chess kdl45.svg Chess d45.svg 8
7 Chess pdd45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess pdl45.svg Chess pdd45.svg Chess pdl45.svg 7
6 Chess l45.svg Chess d45.svg Chess l45.svg Chess qld45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg 6
5 Chess d45.svg Chess qdl45.svg Chess d45.svg Chess l45.svg Chess pdd45.svg Chess l45.svg Chess d45.svg Chess bdl45.svg 5
4 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess pll45.svg Chess d45.svg Chess l45.svg Chess pld45.svg 4
3 Chess d45.svg Chess l45.svg Chess bld45.svg Chess l45.svg Chess d45.svg Chess pll45.svg Chess rld45.svg Chess l45.svg 3
2 Chess l45.svg Chess pld45.svg Chess pll45.svg Chess kld45.svg Chess l45.svg Chess pld45.svg Chess l45.svg Chess d45.svg 2
1 Chess d45.svg Chess l45.svg Chess d45.svg Chess rll45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg 1
a b c d e f g h
Stellung nach dem 29. Zug

Die erste Partie der „Papiermaschine“ von Turing fand im Jahr 1952 statt und soll hier beispielhaft aufgeführt werden:

Turings Papiermaschine - Alick Glennie, Manchester, 1952
1. e4 e5 2. Sc3 Sf6 3. d4 Lb4 4. Sf3 d6 5. Ld2 Sc6 6. d5 Sd4 7. h4 Lg4 8. a4 Sxf3+ 9. gxf3 Lh5 10. Lb5+ c6 11. dxc6 0-0 12. cxb7 Tb8 13. La6 Da5 14. De2 Sd7 15. Tg1 Sc5 16. Tg5 Lg6 17. Lb5 Sxb7 18. 0-0-0 Sc5 19. Lc6 Tfc8 20. Ld5 Lxc3 21. Lxc3 Dxa4 22. Kd2 (22. h5 hätte den Laufer erobert.) 22... Se6 23. Tg4 Sd4 (23... Txb2 24. Lxb2 Txc2+) 24. Dd3 Sb5 25. Lb3 Da6 26. Lc4 Lh5 27. Tg3 Da4 28. Lxb5 Dxb5 29. Dxd6 Td8 0-1[13]

Zu der „Papiermaschine“ von Alan Turing gibt es auch Implementierungen für heutige Computer.

Claude Shannon[Bearbeiten]

In den Bell Laboratories hielt Claude Shannon am 9. März 1949 einen für die Entwicklung von Schachprogrammen entscheidenden Vortrag. Er beschrieb dort die interne Brettdarstellung, die Baumsuche, die Bewertungsfunktion sowie die Zugsuche mit Hilfe des Minimax-Algorithmus. Er gab auch schon zwei verschiedene Strategien zur Bestimmung des besten Zuges an: A-Strategie und B-Strategie.

Dietrich Prinz[Bearbeiten]

Dietrich Günter Prinz von der Universität Manchester hat im November 1951 für den Ferranti-Mark-I-Computer (GB) ein Programm erstellt, das eine zweizügige Mattaufgabe in 15 Minuten löste. Das Programm gilt als erstes Löseprogramm der Schachgeschichte.[14]

John von Neumann[Bearbeiten]

John von Neumann klassifizierte das Schachspiel in seiner Spieltheorie als Zwei-Personen-Nullsummenspiel mit vollständiger Information. Diese Klasse von Problemen (dazu gehört auch Tic Tac Toe) kann mit dem Minimax-Algorithmus gelöst werden. Schach ist jedoch zu komplex, um den Suchbaum vollständig abarbeiten zu können. Schachprogramme sind deshalb auf Näherungsverfahren angewiesen.

Chess rdl44.png Chess ndd44.png Chess qdl44.png Chess kdd44.png Chess ndl44.png Chess rdd44.png
Chess pdd44.png Chess pdl44.png Chess pdd44.png Chess pdl44.png Chess pdd44.png Chess pdl44.png
Chess l44.png Chess d44.png Chess l44.png Chess d44.png Chess l44.png Chess d44.png
Chess d44.png Chess l44.png Chess d44.png Chess l44.png Chess d44.png Chess l44.png
Chess pll44.png Chess pld44.png Chess pll44.png Chess pld44.png Chess pll44.png Chess pld44.png
Chess rld44.png Chess nll44.png Chess qld44.png Chess kll44.png Chess nld44.png Chess rll44.png
Grundstellung
Chess l44.png Chess d44.png Chess l44.png Chess d44.png Chess l44.png Chess qld44.png
Chess d44.png Chess l44.png Chess ndd44.png Chess kdl44.png Chess d44.png Chess l44.png
Chess rdl44.png Chess d44.png Chess pdl44.png Chess pdd44.png Chess l44.png Chess pdd44.png
Chess d44.png Chess l44.png Chess pdd44.png Chess pll44.png Chess d44.png Chess nll44.png
Chess l44.png Chess d44.png Chess pll44.png Chess d44.png Chess pll44.png Chess d44.png
Chess d44.png Chess rll44.png Chess d44.png Chess kll44.png Chess d44.png Chess rll44.png
Stellung nach dem 21. Zug

Das Schachprogramm von John von Neumann wurde Mitte der 1950er-Jahre fertiggestellt und lief auf dem 1950 aufgestellten Röhrenrechner MANIAC I. Zur Vereinfachung wurde nur auf einem 6x6-Brett gespielt. Das Programm spielte insgesamt drei Partien: Die erste gegen sich selbst, eine weitere verlor es gegen einen starken Schachspieler, obwohl dieser ihm eine Dame vorgab, und die dritte gewann es gegen eine junge Frau, die erst seit einer Woche Schach spielte und extra für dieses Spiel trainiert hatte.

MANIAC I - Mensch, Los Alamos, 1956:
(6×6-Brett ohne Läufer, kein Doppelschritt oder Rochade)
1. d3 b4 2. Sf3 d4 3. b3 e4 4. Se1 a4 5. bxa4 (5. Sd2 nebst 6. Sc4+ Sxc4 7. bxc4 mit gutem Spiel) 5... Sxa4 6. Kd2 Sc3 7. Sxc3 bxc3+ 8. Kd1 f4 9. a3 Tb6 10. a4 Ta6 11. a5 Kd5 12. Da3 Db5 13. Da2+ Ke5 14. Tb1 Txa5 15. Txb5 Txa2 16. Tb1 (Um 16...Ta1 matt zu verhindern) 16... Ta5 17. f3 Ta4 18. fxe4 c4 19. Sf3+ Kd6 20. e5+ Kd5 21. exf6 (=D) 21... Sc5 (22. Dxd4+ Kc6 23. Se5 matt.) 1-0[13]

Zum ersten Mal hat ein Mensch gegen ein Schachprogramm verloren. Diese vereinfachte Schachvariante wird auch Los Alamos Chess genannt.

1957 implementierte der IBM-Angestellte Alex Bernstein auf einer IBM 704 ein Schachprogramm, das nach den Standardregeln spielte. Es selektierte in jeder Stellung die sieben plausibelsten Züge und führte eine Suche von 4 Halbzügen durch, was ungefähr 8 Minuten Rechenzeit erforderte. Bernstein erhielt bei der Entwicklung Unterstützung durch den amerikanischen Großmeister Arthur Bisguier. Das Programm verlor chancenlos gegen den Schachmeister Edward Lasker, der dem Computer jedoch ein passables Amateurniveau bescheinigte.

1958 wurde die Alpha-Beta-Suche von Allen Newell, John Clifford Shaw und Herbert A. Simon entdeckt und brachte einen gewaltigen Leistungsschub.

Richard Greenblatt[Bearbeiten]

Solid white.svg a b c d e f g h Solid white.svg
8 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess kdl45.svg Chess d45.svg 8
7 Chess pdd45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg 7
6 Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess pdl45.svg Chess d45.svg Chess pdl45.svg Chess d45.svg 6
5 Chess d45.svg Chess pdl45.svg Chess d45.svg Chess rdl45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg 5
4 Chess l45.svg Chess pld45.svg Chess kll45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg 4
3 Chess rdd45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess pdl45.svg 3
2 Chess pll45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess d45.svg 2
1 Chess d45.svg Chess l45.svg Chess d45.svg Chess l45.svg Chess bld45.svg Chess l45.svg Chess d45.svg Chess rll45.svg 1
a b c d e f g h
Mattstellung nach dem 37. Zug

Das erste Programm, das an menschlichen Turnieren teilnahm, war MacHack, das 1966 von Richard Greenblatt am MIT entwickelt wurde.

Hubert Dreyfus - MacHack, MIT, 1967
1. e4 e5 2. Sf3 Sc6 3. Lc4 Sf6 4. Sc3 Lc5 5. d3 0-0 6. Sg5 Sa5 7. Ld5 c6 8. Lb3 Sxb3 9. cxb3 h6 10. Sh3 d5 11. exd5 Lg4 12. f3 Lxh3 13. gxh3 Sxd5 14. Sxd5 Dxd5 15. Ld2 Dxd3 16. b4 Le7 17. Tg1 e4 18. fxe4 Lh4+ 19. Tg3 Lxg3+ 20. hxg3 Dxg3+ 21. Ke2 Dxh3 22. Dg1 h5 23. Lc3 g6 24. Df2 h4 25. Df6 Dg4+ 26. Kd2 Tad8+ 27. Kc2 Dxe4+ 28. Kb3 De6+ 29. Dxe6 fxe6 30. Th1 Tf4 31. Le1 Tf3+ 32. Ka4 h3 33. b5 Td4+ 34. b4 cxb5+ 35. Kxb5 Ta3 36. Kc5 Td5+ 37. Kc4 b5# 0-1[13]

Von 1967 bis 1970 kam es zu einem Boom in der Schachprogrammierung, welcher in die erste Computerschach-Meisterschaft der Geschichte mündete, die von der Association for Computing Machinery (ACM) ausgetragen wurde. Sieger war Chess 3.0.

Peter Jennings[Bearbeiten]

Peter Jennings entwickelte 1976 Microchess für den KIM-1-Heimcomputer. Das Programm wurde bis 1979 über 50.000 mal verkauft und war damit das erste kommerziell erfolgreiche Mikrocomputerprogramm. Aufgrund des nur 1152 Bytes großen RAM Speichers waren Rochade, En passant und Bauernumwandlung nicht implementiert.

Ken Thompson[Bearbeiten]

Ken Thompson entwickelte 1979 die berühmte Schachmaschine Belle, die mit einer Eröffnungsbibliothek und Hashtables arbeitete.

Feng-hsiung Hsu[Bearbeiten]

Das erste Computerprogramm, welches einen amtierenden Schachweltmeister in einer regulären Turnierpartie schlug, war Deep Blue. Entwickelt von IBM aufgrund einer Anregung und unter der Leitung des jungen Informatikers Feng-hsiung Hsu, besiegte dieses Programm am 10. Februar 1996 auf einer angepassten und auf Schach optimierten Computerhardware, die ebenfalls von IBM stammte, den damaligen Weltmeister Garri Kasparow in einer dadurch berühmt gewordenen Partie. Den Wettkampf konnte Garri Kasparow noch mit 4 zu 2 für sich entscheiden. Eine verbesserte Version von Deep Blue nahm allerdings am 11. Mai 1997 auch diese Hürde und errang in einem zweiten Wettkampf mit der sechsten Turnierpartie den Gesamtsieg über Kasparow mit 3,5 zu 2,5. Deep Blue wurde nach dem spektakulären Sieg demontiert und eingemottet. Die Entstehung des Programms wurde später vom Erfinder in einem Buch beschrieben.[15]

Chrilly Donninger und Ulf Lorenz[Bearbeiten]

Der erste, der sich nach Deep Blue wieder auf den Bau spezialisierter Schachhardwarekomponenten als Basis für ein Schachprogramm verlegte, war der österreichische Schachprogrammierer Christian „Chrilly“ Donninger, der zuvor jahrelang mit seinem PC-Programm an Computerschachturnieren teilgenommen hatte. Er entwarf ab 2002 einen Schachcomputer mit von ihm selbst modifizierter Hardware, den er zunächst Brutus nannte. Geldgeber ChessBase zog seine Unterstützung dafür aber nach dem schlechten Abschneiden bei einem Turnier 2003 in Graz zurück; Christian Donninger und Ulf Lorenz verfolgten das Projekt zunächst auf eigene Faust unter dem neuen Namen Hydra weiter. 2004 fanden Donninger und Lorenz einen neuen Sponsor aus den arabischen Emiraten, PAL Computer Systems. Noch im selben Jahr schlug Hydra den damaligen Computerweltmeister Shredder. Im Juni 2005 fand gegen den britischen Supergroßmeister Michael Adams ein Wettkampf unter Turnierbedingungen statt, den Hydra überlegen mit 5,5 zu 0,5 gewann.[16] Dies entspricht einer Turnierperformance von über 3100 Elo-Punkten, soviel wie bisher kein Mensch erreicht hat. In dieser Version mit 64 Prozessoren galt Hydra als aktuell stärkstes existierendes schachspielendes DV-System der Welt.

Aktuelle Entwicklungen[Bearbeiten]

Die Verteilung des Rechenaufwandes auf viele einzelne Teilprozesse, die parallel ablaufen können und so Multi-Prozessor-Systeme sinnvoll nutzen, ist aufgrund der Baumsuche nicht trivial und ein aktuelles Forschungsgebiet der Schachprogrammierung (siehe Hydra). Mittlerweile ist es aber ruhig um das Hydraprojekt geworden.

Auf dem Sektor herkömmlicher PC-Schachprogramme ist die parallele Nutzung mehrerer Prozessorkerne seit einigen Jahren möglich und erfolgt durch die sog. „Deep-Versionen“ der jeweiligen Engines. Diese Entwicklung schloss an die zunehmende Verbreitung der entsprechenden PC-Hardware mit Mehrkernprozessoren an. Dasselbe gilt mittlerweile für Betriebssysteme mit 64-Bit-Architektur und spezielle Schachprogrammversionen dafür, welche diese vorteilhaft unterstützen bzw. darauf schneller ablaufen als die 32 Bit-Versionen.

Ein möglicherweise neuer Trend besteht in der Nutzung besonders vieler CPUs, jedoch im Unterschied zu Hydra auf Basis herkömmlicher Computer, kombiniert zu sog. Clustern. Bekannt geworden sind Turniereinsätze der Engines Toga sowie Rybka auf Cluster-Hardware.

Wettbewerbe[Bearbeiten]

Es gibt verschiedene Wettbewerbe, bei denen sich Schachprogramme in ihrer Spielstärke gegenseitig messen. Einer der wichtigsten ist die seit 1974 ausgetragene World Computer Chess Championship (WCCC), die für alle Typen von Hardware offensteht:

Nr. Termin Austragungsort Siegerprogramm Entwickler Herkunftsland Hardware
1. 1974 Stockholm, Schweden Kaissa Mikhail Donskoy Russland British ICL 4/70 |
2. 1977 Toronto, Kanada Chess 4.6 David Slate, Larry Atkin USA CDC
3. 25.-29. Sept. 1980 Linz, Österreich Belle Kenneth Lane Thompson USA DEC PDP-11/23 + 1700 Spezialchips, entwickelt von Ken Thompson
4. 1983 New York, USA Cray Blitz Robert Hyatt USA Cray X-MP
5. 1986 Köln, Deutschland Cray Blitz Robert Hyatt USA Cray X-MP
6. 1989 Edmonton, Kanada Deep Thought Feng-hsiung Hsu, Thomas Anantharaman, Murray Campbell, Andreas Nowatzyk, Mike Browne USA Dual-Prozessor-Spezialchips, entwickelt von Feng-hsiung Hsu
7. 23.–27. Nov. 1992 Madrid, Spanien ChessMachine (Rebel) Ed Schröder Niederlande Archimedes RISC
8. 25.–29. Mai 1995 Hong Kong Fritz 3 Frans Morsch Niederlande Pentium 90 MHz
9. 14.-19. Juni 1999 Paderborn, Deutschland Shredder Stefan Meyer-Kahlen Deutschland Pentium III 550 MHz
10. 6.–11. Juni 2002 Maastricht, Niederlande Deep Junior 7 Amir Ban, Shay Bushinsky Israel Multiprozessor
11. 22.-29. Nov. 2003 Graz, Österreich Shredder Stefan Meyer-Kahlen Deutschland Dual Intel Xeon 3 GHz
12. 4.–12. Juli 2004 Ramat-Gan, Israel Junior Amir Ban, Shay Bushinsky Israel 4 CPUs 2,2 GHz, Proliant HP
13. 13.–21. Aug. 2005 Reykjavik, Island Zappa Anthony Cozzie USA 2 AMD-Opteron-Dualcore-CPUs 2,2 GHz
14. 25. Mai – 1. Juni 2006 Turin, Italien Junior Amir Ban, Shay Bushinsky Israel 2 Intel-Woodcrest-Dualcore-CPUs 3 GHz
15. 11.–18. Juni 2007 Amsterdam, Niederlande Rybka Vasik Rajlich USA / Tschechien 2 Intel Xeon X5355
16. 28. Sept. – 4. Okt. 2008 Peking, China Rybka Vasik Rajlich USA / Tschechien Cluster, 40 cores
17. 10.-18. Mai 2009 Pamplona, Spanien Rybka Vasik Rajlich USA / Tschechien Intel Xeon W5580 @ 3,2 GHz x 8
18. 24. Sept. - 1. Okt. 2010 Kanazawa, Japan Rybka Vasik Rajlich USA / Tschechien 200 Nehalem EP Westmere, 2.93-3.6 GHz
19. 2011 Tilburg, Niederlande Junior Amir Ban, Shay Bushinsky Israel Intel Xeon W5580 @ 3,2 GHz x 8
20. 2013 Yokohama, Japan Junior Amir Ban, Shay Bushinsky Israel ?

Rybka und Entwickler Vasik Rajlich verloren allerdings aufgrund von Plagiatsvorwürfen alle seit 2006 erworbenen Titel und wurden von allen kommenden Weltmeisterschaften ausgeschlossen.

Elo-Zahlen[Bearbeiten]

Elo-Zahlen der stärksten Schachprogramme[1]
Rang Name Punkte
1 Stockfish 5.0 x64 12CPU 3320
2 Komodo 7.0a x64 8CPU 3239
3 Houdini 4.0 x64 8CPU 3224
4 Gull 3.0 x64 4CPU 3176
5 Critter 1.6 x64 4CPU 3123
6 Rybka 4.1 x64 8CPU 3119
7 Equinox 3.00 x64 4CPU 3114
8 BlackMamba 2.0 x64 4CPU 3041
9 Strelka 5.0 x64 1CPU 3027
10 Protector 1.6.0 x64 4CPU 2993

Auch Schachprogrammen kann man eine Elo-Zahl geben, die ihre Spielstärke beschreibt. Zum Vergleich: Ein Schachweltmeister von heute bewegt sich in etwa um Elo 2800. Die Elo-Zahlen in Computer-Ranglisten sind aber nicht ohne weiteres mit denen menschlicher Schachspieler zu vergleichen, da sie praktisch ausschließlich durch Partien zwischen Computern ermittelt wurden. Hinsichtlich der absoluten Größe der Wertungszahlen fehlt eine Kalibrierung zwischen Leistungsskalen menschlicher Meisterspieler und jenen von Schachprogrammen; diese würde sehr zahlreiche ernste Wettkampfpartien zwischen beiden Spielergruppen erfordern. D.h. das Zahlenniveau in reinen Computerwertungslisten muss notgedrungen von einer plausiblen oder praxisgeeigneten Annahme ausgehen, und die konkreten Resultate der Programme gegeneinander bestimmen lediglich die Rangfolge und die Abstände zwischen ihren Wertungszahlen.

Wegen der grundsätzlich unterschiedlichen Methoden von Menschen und Computerprogrammen beim Schachspiel ist eine große Spielstärke gegen ein anderes Schachprogramm nicht zwingend gleichbedeutend mit entsprechend besserer Leistung gegenüber einem menschlichen Gegner. Wettbewerbe von Schachprogrammen untereinander sagen daher nur bedingt etwas über die Spielstärke gegen Menschen aus. Jedoch hat die Praxis gezeigt, dass eine hohe Spielstärke gegen Programme in der Regel auch eine hohe Spielstärke gegen Menschen bedeutet. Das Programm Rybka hat gegen verschiedene Großmeister - teilweise mit einem Bauern Vorgabe - gewinnen können. Andere Programme sind inzwischen noch spielstärker.

Eine Bewertung der Spielstärke von Schachprogrammen und Schachcomputern ist darüber hinaus auch mit einem als BT2450 bezeichneten Test möglich. Dieser besteht aus 30 Stellungen, zu denen der jeweilige Lösungszug zu finden ist. Aus den dafür benötigten Zeiten für alle Stellungen wird ein BT2450-Testwert berechnet, der begrenzt mit der ELO-Zahl von menschlichen Spielern vergleichbar ist. Es gibt inzwischen weitere, z.T. umfangreichere und/oder schwierigere Tests, welche innerhalb der Computerschach-Community erstellt und angewandt werden.

Siehe auch[Bearbeiten]

Quellen[Bearbeiten]

  1. a b CEGT-Rangliste, abgerufen am 19. November 2011
  2. Plagiatsvorwurf gegen Computerschach-Weltmeister, Heise.de, 1. März 2011
  3. CCRL 40/4
  4. CCRL 40/40
  5. CCRL 404FRC
  6. CEGT 40/4
  7. CEGT 40/20
  8. CEGT 40/4
  9. WBEC Ridderkerk, abgerufen am 1. März 2011
  10. Arasan Homepage, abgerufen am 1. März 2011
  11. Sourceforge.net, abgerufen am 1. März 2011
  12. Raúl Rojas u. a.: Konrad Zuses Plankalkül – Seine Genese und eine moderne Implementierung. FU Berlin, FB Mathematik und Informatik
  13. a b c Dieter Steinweder, Frederic A. Friedel: Schach am PC, Markt und Technik, 1995, ISBN 3-87791-522-1
  14. Eric van Reem: Geschichte des Computerschachs. Januar 2003. Abgerufen am 21. Juli 2010
  15. Feng-hsiung Hsu: Behind Deep Blue. Princeton University Press Princeton und Oxford 2002, ISBN 0-691-09065-3
  16. heise online - Computerschach: Großmeister von Hydra deklassiert

Literatur[Bearbeiten]

  • Rainer Bartel, Hans-Joachim Kraas, Günther Schrüfer: Das große Computerschachbuch. Data Becker, Düsseldorf 1985, ISBN 3-89011-117-3 (gute Einführung in die Programmierung von Computerschach mit Beispielen in BASIC)
  • Computerschach und Spiele (CSS). 1/1986 bis 6/2004 (danach nur noch online); Zeitschrift überwiegend zum Thema Computerschach.
  • Claude Shannon: Programming a Computer for Playing Chess. In: Philosophical Magazine. 1950/41, S. 256-257
  • Claude Shannon: Programming a Computer to Play Chess. In: Scientific American. 2/1950, S. 48-51
  • Dieter Steinweder, Frederic A. Friedel: Schach am PC. Markt und Technik, Haar bei München 1995, ISBN 3-87791-522-1 (Geschichte des Computerschachs, didaktisches Schachprogramm mit Quellen in BASIC und C, inkl. CD)

Weblinks[Bearbeiten]

Dies ist ein als lesenswert ausgezeichneter Artikel.
Dieser Artikel wurde am 24. Februar 2006 in dieser Version in die Liste der lesenswerten Artikel aufgenommen.