Computerschach: Testaufgaben für Programme (ERET)

Lese­zeit für die­sen Bei­trag: ca. 15 Minu­ten

Der „Eigenmann Rapid Engine Test“ (ERET)

von Walter Eigenmann

(Update: 21. Mai 2020)

Der sog. Eigen­mann Rapid Engine Test (ERET) ist eine neue Samm­lung von 111 Auf­ga­ben für Schach-Pro­gramme. Er wurde kon­zi­piert, um schnell einen ers­ten Ein­druck von der Spiel­stärke einer neuen Engine aus­ma­chen zu kön­nen. Die Com­pu­ter­schach-Anwen­der­schaft erhält mit die­sem ERET erst­mals eine Test-Suite an die Hand, deren Ergeb­nisse innert einer hal­ben Stunde eine grobe, aber recht ver­läss­li­che Ein­schät­zung eines (neuen) Pro­gramms erlauben.

Die 111 Stel­lun­gen bzw. ihre Haupt­va­ri­an­ten kön­nen nach­ste­hend ein­zeln inter­ak­tiv nach­ge­spielt und als PGN-Datei runge­la­den wer­den. Down­load­bar ist aus­ser­dem der Test im CBH-For­mat (für Chess­base-Soft­ware) sowie als EPD-Datei für den Import in diverse Schach-GUI’s.

Die Vor­züge des ERET gegen­über älte­ren Samm­lun­gen sind namentlich:

  • grosse Band­breite der Schachmotivik
  • Ein­deu­tig­keit der Lösungen
  • Aus­ge­wo­gen­heit der Partiephasen
  • Mitt­le­rer bis hoher Schwierigkeitsgrad
  • Schnelle Pro­gramm-Resul­tate
  • Auch für zukünf­tige Engine-Gene­ra­tio­nen tauglich


Die Axiomatik des ERET-Stellungstests

Eine ambi­tio­nierte Auf­ga­ben-Samm­lung wie der ERET-Stel­lungs­test für Schach­pro­gramme basiert auf einer eige­nen Axiomatik.

Diese lässt sich in den fol­gen­den sechs Punk­ten zusammenfassen:

  1. Die 111 Auf­ga­ben des ERET decken einen gros­sen Bereich der (computer-)schachlichen Rea­li­tät ab.
  2. Diese abge­stimmte Kom­pakt­heit der Zusam­men­stel­lung ist weder durch Hin­zu­fü­gun­gen noch Weg­strei­chun­gen antastbar.
  3. Für Com­pu­ter­pro­gramme (anders als für Men­schen) ist eine Schach­par­tie grund­sätz­lich eine Samm­lung von Ein­zel-Auf­ga­ben­stel­lun­gen unter defi­nier­ten Bedin­gun­gen – ein Stel­lungs­test also.
  4. Die Denk- bzw. Rechen­ge­schwin­dig­keit beim Schach­spie­len ist eine mass­geb­li­che Kom­po­nente der „Spiel­stärke“.
  5. Das vom Test-Autor emp­foh­lene Test-Set­ting ist ein inte­gra­ler Bestand­teil des Stellungstests.
  6. Unter Wah­rung der Punkte 2 & 5 garan­tiert der ERET keine 100%ige, aber eine weit­ge­hende Über­ein­stim­mung sei­ner Test­ergeb­nisse mit den durch­schnitt­li­chen Resul­ta­ten des prak­ti­schen Engine-Tur­nier­be­trie­bes.

Das Test-Setting

Das emp­foh­lene ERET-Test-Set­ting sieht fol­gen­der­mas­sen aus:

eret-rochadeangriff-carlsen
Der ERET-Schach­test für Com­pu­ter-Pro­gramme deckt ein wei­tes Spek­trum an Eröff­nungs-, Mit­tel­spiel- und End­spiel-Ele­men­ten ab. Nament­lich ent­hält er exem­pla­ri­sche Bei­spiele der fol­gen­den tak­ti­schen und posi­tio­nel­len Motive (alpha­be­tisch): Ablen­kung – Abtausch – Damen­op­fer – Ent­las­tung – Ent­wick­lung – Fes­tung – Frei­bauer – Initia­tive – Königs­an­griff – Königs­si­cher­heit – Läu­fer­op­fer – Lini­en­öff­nen -Mobi­li­tät – Offene Linien – Posi­tio­nel­les Opfer – Qua­li­täts­op­fer – Räu­mung – Rocha­de­an­griff – Sprin­ger­op­fer – Starke Fel­der – Unter­ver­wand­lung – Ver­gif­te­ter Bauer – Ver­tei­di­gung – Zen­tra­li­sie­rung – Zen­trum – Zug­zwang – Zwi­schen­zug (Bild: Die Brenn­punkte des weis­sen Rocha­d­an­griffs in einer Fern­schach­par­tie Copie-Patrici 1986)
  • 15 Sekun­den pro Aufgabe
  • Engine-Ein­stel­lun­gen: Default
  • Prozessoren/Threads/Cores: 1-16
  • Hash-Memory: 512-1024Mb
  • Eröff­nungs­bü­cher: keine
  • End­game-Tab­le­ba­ses: beliebig
  • Extra Halb­züge: 99
  • Mul­ti­va­ri­an­ten-Modus: off

Das Design des Tes­tes ist auf diese Ein­stel­lun­gen fokus­siert, diese zei­ti­gen die aus­sa­ge­kräf­tigs­ten Resul­tate. Deut­lich davon abwei­chende Set­tings kön­nen die Ergeb­nisse verfälschen.

Die Test-Auswertung

Die Anzahl Lösun­gen einer Engine ergibt deren wich­tigs­tes Test­ergeb­nis; die­ses erlaubt bereits einen gro­ben Ver­gleich mit ande­ren Pro­gram­men. Um die Resul­tate meh­re­rer Engi­nes noch zu dif­fe­ren­zie­ren, emp­fiehlt der Autor das Inter­face „Fritz“ ab Ver­sion 11, des­sen Test­ergeb­nisse – aus der CBH- in eine PGN-Datei kon­ver­tiert – dann mit dem Free­ware-Tool EloStatTS104 von Dr. Frank Schu­bert wer­den soll­ten. Diese mathe­ma­tisch-sta­tis­tisch fun­dierte Methode der Test-Aus­wer­tung ist wenn immer mög­lich vor­zu­zie­hen. Aus­ser­dem ist bei einer Ver­wen­dung des Tes­tes mit „Fritz“ die von EloStatTS104 mit­ge­lie­ferte „Offset“-Test-File zu berück­sich­ti­gen: Mit ihm las­sen sich die unter­schied­li­chen Reak­ti­ons- bzw. Initia­li­sie­rungs­zei­ten der Engi­nes unter die­sem Inter­face eru­ie­ren, womit noch­mals genauere Ergeb­nisse gene­riert wer­den kön­nen (siehe hierzu die entspr. Readme-Datei).

Die „Fritz“-Alternative „Arena“

Eine Alter­na­tive zum „Fritz“-GUI ist die Free­ware-Ober­flä­che „Arena“, die mit zusätz­li­chen Fea­tures beim Auto­ma­ti­sier­ten Stel­lungs­tes­ten auf­war­tet und auch einen Out­put der Engine-Berech­nun­gen bie­tet, aller­dings auf jeg­li­che Rang­lis­ten-Gene­rie­rung ver­zich­tet bzw. nur die Anzahl Lösun­gen angibt, so dass keine wei­ter­ge­hende Dif­fe­ren­zie­rung der Test­ergeb­nisse mög­lich ist bzw. manu­ell erfol­gen müsste.
Andere Benut­zer­ober­flä­chen bie­ten eben­falls nur rudi­men­täre Optio­nen bezüg­lich Stel­lungs­tests und sind des­halb für den ERET nur bedingt zu emp­feh­len. Einen ver­hält­nis­mäs­sig dif­fe­ren­zier­ten Out­put beim Stel­lungs­tes­ten lie­fert schliess­lich noch die in Mit­tel­eu­ropa kaum ver­brei­tete GUI-Soft­ware ChessAssistant.
Die tech­ni­sche Durch­füh­rung des Tests ist ein­fach und bei den ver­schie­de­nen Schach-Inter­faces wie z.B. Arena, Shred­der, Chess­As­sistant oder Fritz grund­sätz­lich ähnlich.

Zufallsfaktor Multi-Prozessoren

Moderne Rech­ner mit Multi-Pro­zes­so­ren- bzw. -Hyper­th­read-Tech­ni­ken nei­gen zu Fluk­tua­tio­nen in ihrer Zug-Gene­rie­rung. Deren Aus­wir­kung in der Pra­xis wird zwar gene­rell sehr über­schätzt, aber wer auf Num­mer sicher gehen will, macht pro Engine drei bis fünf Test-Durch­läufe und nimmt den Durch­schnitt oder die kür­zeste der jewei­li­gen Lösungs­zei­ten. (Hierzu mehr im Absatz Ein­zel-Threat vs Multi-Thread)

Um Soft­ware-über­grei­fende Ver­glei­che zu ermög­li­chen, soll­ten die Engi­nes mit ihren Default-Para­me­tern getes­tet wer­den. Die Ver­wen­dung von Ope­ning-Books ist dabei irrele­vant; die meis­ten ERET-Auf­ga­ben sind „out of books“. Trotz­dem wird grund­sätz­lich ein Ver­zicht auf Engine-Eröff­nungs­bü­cher emp­foh­len, um den Ein­fluss von ggf. hoch­se­lek­ti­ven, bis weit ins Mit­tel­spiel hin­ein rei­chen­den Book-Vari­an­ten auszuschliessen.

Relationen entscheiden, nicht absolute Zahlen

Anzeige Amazon: Millennium Chess Genius PRO by Chess Genius
Anzeige

Bei der Gene­rie­rung von Rang­lis­ten mit dem ERET soll­ten nicht die abso­lu­ten Zah­len-Ergeb­nisse, son­dern viel­mehr die Engine-Rela­tio­nen beach­tet wer­den – so wie bei den Ran­kings der ver­schie­de­nen bekann­ten Engine-Tur­nie­ren auch. Diese kön­nen bekannt­lich (je nach Tur­nier-Set­tings und Berech­nungs­grund­lage) über­ra­schend unter­schied­lich aus­fal­len – siehe die ein­schlä­gi­gen Engine-Rang­lis­ten CEGT, CCRL, FCP, OHCR, SPCC, FGRL u.a.

Hier fin­det sich ein Ver­gleich von fünf häu­fig zitier­ten Rang­lis­ten im Inter­net mit den ERET-Ergeb­nis­sen (Stand März 2017). Dabei zeigte sich, wie über­ra­schend genau die Ergeb­nisse des ERET-Stel­lungs­tes­tes mit den übri­gen „regu­lä­ren“ Ran­kings über­ein­stim­men (natür­lich von ein paar übli­chen „Aus­reis­sern“ abge­se­hen, die in allen Rang­lis­ten zu fin­den sind).

Breite Quellen-Recherche

Die ein­zel­nen Stel­lun­gen hat der Autor über viele Monate hin­weg aus ver­schie­dens­ten Quel­len zusam­men­ge­tra­gen und haupt­säch­lich mit den drei Pro­gram­men Deep-Shred­der 11/12, Crit­ter 1.6 und Ryb­ka­Win­Fin­der 2.2 im Hin­blick auf ihre tak­ti­sche Kor­rekt­heit unter­sucht. Ansons­ten hat er auf wei­te­res Ein­zel­tes­ten bewusst ver­zich­tet, um den Test mög­lichst objek­tiv und nicht „geeicht“ auf bestimmte Pro­gramme gestal­ten zu kön­nen. (Über ent­spre­chende Resul­tat-Mel­dun­gen aus der Leser- bzw. Anwen­der­schaft – pri­vat oder via „Kommentar“-Funktion – würde sich der Autor freuen).

ERET-Computerschach-Testsammlung - Salai-Studie - Glarean Magazin
Wel­che Kom­ple­xi­tät eine Schach-Stel­lung mit nur weni­gen Stei­nen haben kann, zeigt diese Stu­die von L. Salai: Den Lösungs­zug 1.f4!! fin­den auch starke Com­pu­ter­pro­gramme die längste Zeit nicht

Trotz der rela­tiv kur­zen Zeit-Vor­gabe von 15 Sekunden/Stellung sind die ERET-Auf­ga­ben kei­nes­wegs tri­vial. Viele der Auf­ga­ben dürf­ten sogar ganz beson­dere Knack­nüsse auch für heu­tige Engi­nes sein. Die umfang­rei­chen per­sön­li­chen Ana­ly­sen mit­hilfe der oben­ge­nann­ten Pro­gramme legen den Schluss nahe, dass die­ser Test eher im obe­ren Schwie­rig­keits­be­reich ange­sie­delt ist. Der Autor ist des­halb zuver­sicht­lich, dass der ERET auch noch in fünf oder zehn Jah­ren nütz­lich sein wird…

Die inter­na­tio­nale Com­pu­ter­schach-Anwen­der­schaft wid­mete sich ein­ge­hend dem ERET-Stel­lungs­test und gene­rierte meh­rere Ran­king-Lis­ten auf je unter­schied­li­cher Hard­ware. Bei­spiel­haft seien hier die ERET-Test­ergeb­nisse des deut­schen Fern­schach-Meis­ters Andreas Strang­mül­ler erwähnt, der auf sei­ner vie­be­ach­te­ten Schach-Web­seite FastGMs Rating Lists (FGRL) seit Jah­ren Engine-Resul­tate doku­men­tiert. Auch in den diver­sen Com­pu­ter­schach-Foren fand der ERET-Test grosse Reso­nanz. Stell­ver­tre­tend hier ein paar Ein­zel­er­geb­nisse im CSS-Forum.

Die aktuelle ERET-Rangliste

Der Autor des Tests sel­ber hat die 111 ERET-Auf­ga­ben im Laufe der Jahre eben­falls mehr­mals von div. Pro­gram­men berech­nen lassen.
Die nach­fol­gende Rang­liste stammt vom Mai 2020 und ent­hält nicht weni­ger als 31 der aktu­ell stärks­ten Engi­nes, wie sie von den ein­schlä­gi­gen Tur­nier-Sta­tis­tik-Por­ta­len wie z.B. den bekann­ten Com­pu­ter Chess Rating Lists (CCRL) auf­ge­führt werden.
Dabei kam das fol­gende Hard- und Soft­ware-Equip­ment zum Einsatz:
AMD-Ryzen7-2700x  •  3,7Mhz-64bit  •  16Threads  •  1024MB Hash  •  5-men-Szy­zygy-Tab­le­ba­ses  •  Fritz17-GUI

Bezüg­lich der Aus­wer­tung der Lösungs­er­geb­nisse fand das bereits erwähnte Tool EloStatTS104 Ver­wen­dung; dazu unten mehr.

   Program                          Elo   +/-  Matches  Score   Av.Op.   Solutions

01 Bluefish XR7FD (16Cores)       : 2975    5   2885    61.3 %   2895    93/111
02 Crystal 140520 (16Cores)       : 2967    5   2846    60.2 %   2895    91/111
03 Black Diamond XI (16Cores)     : 2965    5   2801    59.9 %   2896    90/111
04 CorChess 6.0 (16Cores)         : 2962    5   2791    59.5 %   2896    90/111
05 Stockfish 140520 (16Cores)     : 2960    5   2804    59.1 %   2896    89/111
06 Eman 5.50 (16Cores)            : 2956    5   2776    58.5 %   2896    88/111
07 SugaR-NN 260120 (16Cores)      : 2956    5   2706    58.5 %   2896    87/111
08 Chimera 2 BF-Lc0-SF (16Cores)  : 2950    5   2708    57.6 %   2896    85/111
09 Komodo 13.3 (16Cores)          : 2946    5   2734    57.0 %   2897    85/111
10 Lc0 0.25.1 t60-3044 (1Core)    : 2943    6   2785    56.5 %   2898    84/111
11 FatFritz 1.1 (1Core)           : 2941    6   2748    56.1 %   2898    78/111
12 Houdini 6.03 (16Cores)         : 2940    5   2685    56.1 %   2897    83/111
13 Booot 6.4 (16Cores)            : 2919    6   2576    52.9 %   2899    74/111
14 Schooner 2.2 (16Cores)         : 2910    6   2617    51.4 %   2900    76/111
15 Xiphos 0.6 (16Cores)           : 2910    6   2573    51.4 %   2900    73/111
16 Ethereal 12 (16Cores)          : 2904    6   2596    50.6 %   2900    75/111
17 Fritz 17 (16Cores)             : 2890    6   2553    48.4 %   2901    70/111
18 Fizbo 2 (16Cores)              : 2889    6   2511    48.1 %   2902    65/111
19 Laser 1.7 (16Cores)            : 2885    6   2522    47.6 %   2902    69/111
20 RofChade 2.202 (16Cores)       : 2885    6   2505    47.6 %   2902    67/111
21 Critter 1.6a (16Cores)         : 2882    7   2653    47.0 %   2903    68/111
22 DeepShredder 13 (16Cores)      : 2878    6   2512    46.4 %   2903    68/111
23 Andscacs 0.95 (16Cores)        : 2872    6   2463    45.6 %   2903    65/111
24 Arasan 22.0 (16Cores)          : 2853    7   2436    42.6 %   2905    59/111
25 Wasp 3.75(16Cores)             : 2844    7   2467    41.3 %   2905    57/111
26 Fire 7.1 (16Cores)             : 2844    7   2402    41.2 %   2905    54/111
27 DeepRybka 4.1 (16Cores)        : 2842    7   2482    40.7 %   2907    53/111
28 Naum 4.6 (16Cores)             : 2815    7   2451    36.9 %   2908    47/111
29 Chiron 4 (16Cores)             : 2813    7   2429    36.7 %   2908    48/111
30 Deep Junior Yokohama (16Cores) : 2797    7   2391    34.5 %   2909    41/111
31 ProDeo 2.92 (1Core)            : 2697    7   2240    22.4 %   2913    16/111

BF-Lc0-SF = Brainfish & LeelaChessZero & Stockfish
Lc0 & FatFritz = RTX2080-GPU

Weiterführende Links

Für jene Leser, die sich näher mit der The­ma­tik Com­pu­ter­schach & Stel­lungs­tests befas­sen möch­ten, nach­fol­gend ein paar wei­ter­füh­rende Links:

ELO-Formel für Stellungstests“

  • Dr. Frank Schu­bert: Lösung eines alten Pro­blems – Autor Schu­bert unter­sucht zuerst die sei­ner­zeit gän­gi­gen Aus­wer­te­ver­fah­ren ver­schie­de­ner bekann­ter Stel­lungs­tests und stellt dann einen mathe­ma­tisch neuen, dem FIDE-Elo-Ver­fah­ren ähn­li­chen Ansatz zur Dif­fe­ren­zie­rung von Test-Ergeb­nis­sen vor. In einem his­to­ri­schen Exkurs wird auch Bezug genom­men auf noch vor eini­gen Jah­ren gebräuch­li­che Tests von Autoren wie Bednorz, Schu­ma­cher, Gurevich oder Scheidl. Zum Schluss stellt Schu­bert seine eigene Methode vor, „wel­che die Schwä­chen der bis­he­ri­gen For­meln besei­tigt und erst­ma­lig auf einer soli­den schach­li­chen Theo­rie basiert.“ Dabei zählt das Tool nicht ein­fach die Anzahl rich­ti­ger Lösun­gen ab, son­dern setzt die Ergeb­nisse je nach Lösungs­ver­hal­ten bei den ein­zel­nen Stel­lun­gen zuein­an­der in Bezug; es wird also nicht nur berück­sich­tigt, wie viele, son­dern auch wel­che Engi­nes wel­che Auf­ga­ben gelöst haben.
    Hier lässt sich EloStatTS104 down­loa­den.

Was Stellungstests testen“

  • Anzeige AMAZON: 100 brillante Schachzüge - Geniale Kombinationen - Verblüffende Strategien - Walter Eigenmann
    Anzeige

    Lars Bre­mer: Was Stel­lungs­tests tes­ten – IT-Jour­na­list und Pro­gram­mie­rer Bre­mer repli­ziert darin auf den sei­ner­zeit hef­tig umstrit­te­nen CSS-WM-Test von M. Gurevich, wobei er ebenso unver­hoh­len wie amü­sant in die Trick-Kiste greift, um seine Test-kri­ti­sche These zu unter­mau­ern: Er löschte mit einem eigens dafür geschrie­be­nen Tool in dem als Gesamt­heit kon­zi­pier­ten Test jeweils so lange ein­zelne Auf­ga­ben, bis immer wie­der Top-Resul­tate der zufäl­lig gewähl­ten (ggf. schwa­chen) Engine resul­tie­ren, womit Bre­mer den zufäl­li­gen Cha­rak­ter von Test-Ergeb­nis­sen bewei­sen möchte.
    Dahin­ter steckt aller­dings ein gro­ber Denk­feh­ler. Denn da selbst­ver­ständ­lich ein umfang­rei­cher und durch­dach­ter Stel­lungs­test immer kom­pakt gemeint ist, seine Auf­ga­ben auf­ein­an­der abge­stimmt sind und also nicht will­kür­lich zusam­men­ge­stri­chen wer­den dür­fen, ist Bre­mers Arti­kel wis­sen­schaft­lich nicht wirk­lich ernst zu neh­men und des­halb ein ein­zi­ger „Quatsch“ (Zitat) – aber den­noch wit­zig zu lesen 🙂

Chaos-System Deep Engine“

  • Lars Bre­mer: Chaos-Sys­tem Deep Engine – Ein seriö­se­rer und infor­ma­ti­ver Arti­kel des obi­gen Autors zur Pro­ble­ma­tik des „Zufäl­li­gen Zuges“ bei Deep-Engi­nes. Mit sei­nem „Fazit“ bezüg­lich der Aus­sa­ge­kraft von Stel­lungs­tests bei MP-Rech­nern ist der Schrei­bende zwar nicht ein­ver­stan­den: Aus­ge­dehnte Unter­su­chun­gen könn­ten sehr wohl doku­men­tie­ren, dass ein durch­dach­tes Design eines Stel­lungs­tes­tes die­sen „MP-Effekt“ zwar nicht rest­los aus­schal­ten, aber ent­schei­dend abfe­dern kann, so dass er bezüg­lich Ran­king schliess­lich auch sta­tis­tisch irrele­vant wird. Doch Bre­mer erklärt das Phä­no­men aus der Sicht des Pro­gram­mie­rers äus­serst anschau­lich und auch für Laien nach­voll­zieh­bar. Es wird erklärt, warum sich moderne „Deep“-Programme zuwei­len völ­lig nicht-deter­mi­nis­tisch, ja „chao­tisch“ ver­hal­ten beim Aus­spie­len von Zügen.

Einzel-Threat vs Multi-Threats“

  • Tord Rom­stad (Stock­fish): Eine kurz zusam­men­ge­fasste Erklä­rung die­ses „MP-Effek­tes“ fin­det sich auch in einem Inter­view, das Frank Quis­in­sky vor Jah­ren mit Tord Rom­stad, dem ver­ant­wort­li­chen Stock­fish-Pro­gram­mie­rer, sowie des­sen Co-Autoren geführt hat.
    Zitat: „Wenn ein Schach­pro­gramm eine Posi­tion, irgendwo tief inner­halb des Such­baums, unter­sucht, macht es Gebrauch bzw. erin­nert sich an frü­here bereits unter­suchte Posi­tio­nen der glei­chen Suche. Die Zug­be­schnei­dung, Ver­kür­zung oder Ver­län­ge­rung hän­gen davon ab, wel­che Posi­tio­nen vor­her über­prüft wur­den und wie die Ergeb­nisse der Unter­su­chung die­ser Posi­tio­nen waren. Der Gross­teil der Infor­ma­tio­nen, der für eine Ent­schei­dung ver­wen­det wird, liegt im Arbeits­spei­cher. Der Arbeits­spei­cher steht allen Pro­zes­so­ren zur Verfügung.
    Solange es nur einen Thread gibt, ist alles zu 100% repro­du­zier­bar. Aber bei meh­re­ren Threads begin­nen selt­same Dinge zu gesche­hen, weil diese Threads nie syn­chron mit glei­cher Geschwin­dig­keit aktiv sein kön­nen. Immer wie­der wird eine CPU für ein paar Mil­li­se­kun­den eine Pause ein­le­gen müs­sen und das Betriebs­sys­tem weist dann sofort eine andere Auf­gabe zu. Das geschieht zufäl­lig und ist nicht vor­her­seh­bar, eine Kon­trolle gibt es hier­für nicht. Als Kon­se­quenz erreicht jeder Pro­zes­sor eine bestimmte Posi­tion eher zufäl­lig und das wirkt sich dann auf die Suche nach Ent­schei­dun­gen zur aktu­el­len Posi­tion aus.“
  • Chess Pro­gramming Wiki: Hier fin­den sich einige „klas­si­sche“ Stel­lungs­tests (inkl. Stel­lungs­dia­gramme), die aller­dings heute eher his­to­ri­sche denn schach­li­che Bedeu­tung haben.

Der ERET-Stellungstest als EPD-/FEN-Liste

r1bqk1r1/1p1p1n2/p1n2pN1/2p1b2Q/2P1Pp2/1PN5/PB4PP/R4RK1 w q – – bm Rxf4; id „ERET 001 – Entlastung“;
r1n2N1k/2n2K1p/3pp3/5Pp1/b5R1/8/1PPP4/8 w – – bm Ng6; id „ERET 002 – Zugzwang“;
r1b1r1k1/1pqn1pbp/p2pp1p1/P7/1n1NPP1Q/2NBBR2/1PP3PP/R6K w – – bm f5; id „ERET 003 – Linienoeffnen“;
5b2/p2k1p2/P3pP1p/n2pP1p1/1p1P2P1/1P1KBN2/7P/8 w – – bm Nxg5; id „ERET 004 – Endspiel“;
r3kbnr/1b3ppp/pqn5/1pp1P3/3p4/1BN2N2/PP2QPPP/R1BR2K1 w kq – – bm Bxf7; id „ERET 005 – Laeu­fer­op­fer f7“;
r2r2k1/1p1n1pp1/4pnp1/8/PpBRqP2/1Q2B1P1/1P5P/R5K1 b – – bm Nc5; id „ERET 006 – Springeropfer“;
2rq1rk1/pb1n1ppN/4p3/1pb5/3P1Pn1/P1N5/1PQ1B1PP/R1B2RK1 b – – bm Nde5; id „ERET 007 – Laeuferpaar“;
r2qk2r/ppp1bppp/2n5/3p1b2/3P1Bn1/1QN1P3/PP3P1P/R3KBNR w KQkq – bm Qxd5; id „ERET 008 – Zentrum“;
rnb1kb1r/p4p2/1qp1pn2/1p2N2p/2p1P1p1/2N3B1/PPQ1BPPP/3RK2R w Kkq – bm Ng6; id „ERET 009 – Springeropfer“;
5rk1/pp1b4/4pqp1/2Ppb2p/1P2p3/4Q2P/P3BPP1/1R3R1K b – – bm d4; id „ERET 010 – Freibauer“;
r1b2r1k/ppp2ppp/8/4p3/2BPQ3/P3P1K1/1B3PPP/n3q1NR w – – bm dxe5, Nf3; id „ERET 011 – Rochadeangriff“;
1nkr1b1r/5p2/1q2p2p/1ppbP1p1/2pP4/2N3B1/1P1QBPPP/R4RK1 w – – bm Nxd5; id „ERET 012 – Entlastung“;
1nrq1rk1/p4pp1/bp2pn1p/3p4/2PP1B2/P1PB2N1/4QPPP/1R2R1K1 w – – bm Qd2, Bc2; id „ERET 013 – Zentrum“;
5k2/1rn2p2/3pb1p1/7p/p3PP2/PnNBK2P/3N2P1/1R6 w – – bm Nf3; id „ERET 014 – Endspiel“;
8/p2p4/r7/1k6/8/pK5Q/P7/b7 w – – bm Qd3; id „ERET 015 – Endspiel“;
1b1rr1k1/pp1q1pp1/8/NP1p1b1p/1B1Pp1n1/PQR1P1P1/4BP1P/5RK1 w – – bm Nc6; id „ERET 016 – Pos. Opfer“;
1r3rk1/6p1/p1pb1qPp/3p4/4nPR1/2N4Q/PPP4P/2K1BR2 b – – bm Rxb2; id „ERET 017 – Koenigsangriff“;
r1b1kb1r/1p1n1p2/p3pP1p/q7/3N3p/2N5/P1PQB1PP/1R3R1K b kq – bm Qg5; id „ERET 018 – Entwicklung“;
3kB3/5K2/7p/3p4/3pn3/4NN2/8/1b4B1 w – – bm Nf5; id „ERET 019 – Endspiel“;
1nrrb1k1/1qn1bppp/pp2p3/3pP3/N2P3P/1P1B1NP1/PBR1QPK1/2R5 w – – bm Bxh7; id „ERET 020 – Laeu­fer­op­fer h7“;
3rr1k1/1pq2b1p/2pp2p1/4bp2/pPPN4/4P1PP/P1QR1PB1/1R4K1 b – – bm Rc8; id „ERET 021 – Prophylaxe“;
r4rk1/p2nbpp1/2p2np1/q7/Np1PPB2/8/PPQ1N1PP/1K1R3R w – – bm h4; id „ERET 022 – Freibauer“;
r3r2k/1bq1nppp/p2b4/1pn1p2P/2p1P1QN/2P1N1P1/PPBB1P1R/2KR4 w – – bm Ng6; id „ERET 023 – Rochadeangriff“;
r2q1r1k/3bppbp/pp1p4/2pPn1Bp/P1P1P2P/2N2P2/1P1Q2P1/R3KB1RKQ – am b3; id „ERET 024 – Entwicklung“;
2kb4/p7/r1p3p1/p1P2pBp/R2P3P/2K3P1/5P2/8 w – – bm Bxd8; id „ERET 025 – Endspiel“;
rqn2rk1/pp2b2p/2n2pp1/1N2p3/5P1N/1PP1B3/4Q1PP/R4RK1 w – – bm Nxg6; id „ERET 026 – Springeropfer“;
8/3Pk1p1/1p2P1K1/1P1Bb3/7p/7P/6P1/8 w – – bm g4; id „ERET 027 – Zugzwang“;
4rrk1/Rpp3pp/6q1/2PPn3/4p3/2N5/1P2QPPP/5RK1 w – – am Rxb7; id „ERET 028 – Ver­gif­te­ter Bauer“;
2q2rk1/2p2pb1/PpP1p1pp/2n5/5B1P/3Q2P1/4PPN1/2R3K1 w – – bm Rxc5; id „ERET 029 – Qualitaetsopfer“;
rnbq1r1k/4p1bP/p3p3/1pn5/8/2Np1N2/PPQ2PP1/R1B1KB1RKQ – bm Nh4; id „ERET 030 – Initiative“;
4b1k1/1p3p2/4pPp1/p2pP1P1/P2P4/1P1B4/8/2K5 w – – bm b4; id „ERET 031 – Endspiel“;
8/7p/5P1k/1p5P/5p2/2p1p3/P1P1P1P1/1K3Nb1 w – – bm Ng3; id „ERET 032 – Zugzwang“;
r3kb1r/ppnq2pp/2n5/4pp2/1P1PN3/P4N2/4QPPP/R1B1K2R w KQkq – bm Nxe5; id „ERET 033 – Initiative“;
b4r1k/6bp/3q1ppN/1p2p3/3nP1Q1/3BB2P/1P3PP1/2R3K1 w – – bm Rc8; id „ERET 034 – Laeuferpaar“;
r3k2r/5ppp/3pbb2/qp1Np3/2BnP3/N7/PP1Q1PPP/R3K2R w KQkq – bm Nxb5; id „ERET 035 – Qualitaetsopfer“;
r1k1n2n/8/pP6/5R2/8/1b1B4/4N3/1K5N w – – bm b7; id „ERET 036 – Endspiel“;
1k6/bPN2pp1/Pp2p3/p1p5/2pn4/3P4/PPR5/1K6 w – – bm Na8; id „ERET 037 – Zugzwang“;
8/6N1/3kNKp1/3p4/4P3/p7/P6b/8 w – – bm exd5; id „ERET 038 – Endspiel“;
r1b1k2r/pp3ppp/1qn1p3/2bn4/8/6P1/PPN1PPBP/RNBQ1RK1 w kq – bm a3; id „ERET 039 – Entwicklung“;
r3kb1r/3n1ppp/p3p3/1p1pP2P/P3PBP1/4P3/1q2B3/R2Q1K1R b kq – bm Bc5; id „ERET 040 – Koenigssicherheit“;
3q1rk1/2nbppb1/pr1p1n1p/2pP1Pp1/2P1P2Q/2N2N2/1P2B1PP/R1B2RK1 w – – bm Nxg5; – id „ERET 041 – Springeropfer“;
8/2k5/N3p1p1/2KpP1P1/b2P4/8/8/8 b – – bm Kb7; id „ERET 042 – Endspiel“;
2r1rbk1/1pqb1p1p/p2p1np1/P4p2/3NP1P1/2NP1R1Q/1P5P/R5BK w – – bm Nxf5; id „ERET 043 – Springeropfer“;
rnb2rk1/pp2q2p/3p4/2pP2p1/2P1Pp2/2N5/PP1QBRPP/R5K1 w – – bm h4; id „ERET 044 – Linienoeffnen“;
5rk1/p1p1rpb1/q1Pp2p1/3Pp2p/4Pn2/1R4N1/P1BQ1PPP/R5K1 w – – bm Rb4; id „ERET 045 – Initiative“;
8/4nk2/1p3p2/1r1p2pp/1P1R1N1P/6P1/3KPP2/8 w – – bm Nd3; id „ERET 046 – Endspiel“;
4kbr1/1b1nqp2/2p1p3/2N4p/1p1PP1pP/1PpQ2B1/4BPP1/r4RK1 w – – bm Nxb7; id „ERET 047 – Entlastung“;
r1b2rk1/p2nqppp/1ppbpn2/3p4/2P5/1PN1PN2/PBQPBPPP/R4RK1 w – – bm cxd5; id „ERET 048 – Starke Felder“;
r1b1kq1r/1p1n2bp/p2p2p1/3PppB1/Q1P1N3/8/PP2BPPP/R4RK1 w kq – bm f4; id „ERET 049 – Entwicklung“;
r4r1k/p1p3bp/2pp2p1/4nb2/N1P4q/1P5P/PBNQ1PP1/R4RK1 b – – bm Nf3; id „ERET 050 – Koenigsangriff“;
6k1/pb1r1qbp/3p1p2/2p2p2/2P1rN2/1P1R3P/PB3QP1/3R2K1 b – – bm Bh6; id „ERET 051 – Verteidigung“;
2r2r2/1p1qbkpp/p2ppn2/P1n1p3/4P3/2N1BB2/QPP2PPP/R4RK1 w – – bm b4; id „ERET 052 – Starke Felder“;
r1bq1rk1/p4ppp/3p2n1/1PpPp2n/4P2P/P1PB1PP1/2Q1N3/R1B1K2RKQ – bm c4; id „ERET 053 – Pos. Opfer“;
2b1r3/5pkp/6p1/4P3/QppqPP2/5RPP/6BK/8 b – – bm c3; id „ERET 054 – Endspiel“;
r2q1rk1/1p2bpp1/p1b2n1p/8/5B2/2NB4/PP1Q1PPP/3R1RK1 w – – bm Bxh6; id „ERET 055 – Laeu­fer­op­fer h6“;
r2qr1k1/pp2bpp1/2pp3p/4nbN1/2P4P/4BP2/PPPQ2P1/1K1R1B1R w – – bm Be2; id „ERET 056 – Zwischenzug“;
r2qr1k1/pp1bbp2/n5p1/2pPp2p/8/P2PP1PP/1P2N1BK/R1BQ1R2 w – – bm d6; id „ERET 057 – Abtausch“;
8/8/R7/1b4k1/5p2/1B3r2/7P/7K w – – bm h4; id „ERET 058 – Endspiel“;
rq6/5k2/p3pP1p/3p2p1/6PP/1PB1Q3/2P5/1K6 w – – bm Qd3; id „ERET 059 – Endspiel“;
q2B2k1/pb4bp/4p1p1/2p1N3/2PnpP2/PP3B2/6PP/2RQ2K1 b – – bm Qxd8; id „ERET 060 – Koenigsangriff“;
4rrk1/pp4pp/3p4/3P3b/2PpPp1q/1Q5P/PB4B1/R4RK1 b – – bm Rf6; id „ERET 061 – Koenigsangriff“;
rr1nb1k1/2q1b1pp/pn1p1p2/1p1PpNPP/4P3/1PP1BN2/2B2P2/R2QR1K1 w – – bm g6; id „ERET 062 – Starke Felder“;
r3k2r/4qn2/p1p1b2p/6pB/P1p5/2P5/5PPP/RQ2R1K1 b kq – bm Kf8; id „ERET 063 – Verteidigung“;
8/1pp5/p3k1pp/8/P1p2PPP/2P2K2/1P3R2/5r2 b – – am Rxf2; id „ERET 064 – Endspiel“;
1r3rk1/2qbppbp/3p1np1/nP1P2B1/2p2P2/2N1P2P/1P1NB1P1/R2Q1RK1 b – – bm Qb6; id „ERET 065 – Zwischenzug“;
8/2pN1k2/p4p1p/Pn1R4/3b4/6Pp/1P3K1P/8 w – – bm Ke1; id „ERET 066 – Endspiel“;
5r1k/1p4bp/3p1q2/1NpP1b2/1pP2p2/1Q5P/1P1KBP2/r2RN2R b – – bm f3; id „ERET 067 – Raeumung“;
r3kb1r/pbq2ppp/1pn1p3/2p1P3/1nP5/1P3NP1/PB1N1PBP/R2Q1RK1 w kq – bm a3; id „ERET 068 – Offene Linie“;
5rk1/n2qbpp1/pp2p1p1/3pP1P1/PP1P3P/2rNPN2/R7/1Q3RK1 w – – bm h5; id „ERET 069 – Koenigsangriff“;
r5k1/1bqp1rpp/p1n1p3/1p4p1/1b2PP2/2NBB1P1/PPPQ4/2KR3R w – – bm a3; id „ERET 070 – Starke Felder“;
1r4k1/1nq3pp/pp1pp1r1/8/PPP2P2/6P1/5N1P/2RQR1K1 w – – bm f5; id „ERET 071 – Ablenkung“;
q5k1/p2p2bp/1p1p2r1/2p1np2/6p1/1PP2PP1/P2PQ1KP/4R1NR b – – bm Qd5; id „ERET 072 – Zentralisierung“;
r4rk1/ppp2ppp/1nnb4/8/1P1P3q/PBN1B2P/4bPP1/R2QR1K1 w – – bm Qxe2; id „ERET 073 – Mobilitaet“;
1r3k2/2N2pp1/1pR2n1p/4p3/8/1P1K1P2/P5PP/8 w – – bm Kc4; id „ERET 074 – Endspiel“;
6r1/6r1/2p1k1pp/p1pbP2q/Pp1p1PpP/1P1P2NR/1KPQ3R/8 b – – bm Qf5; id „ERET 075 – Festung“;
r1b1kb1r/1p1npppp/p2p1n2/6B1/3NPP2/q1N5/P1PQ2PP/1R2KB1R w Kkq – bm Bxf6; id „ERET 076 – Entwicklung“;
r3r1k1/1bq2ppp/p1p2n2/3ppPP1/4P3/1PbB4/PBP1Q2P/R4R1K w – – bm gxf6; id „ERET 077 – Rochadeangriff“;
r4rk1/ppq3pp/2p1Pn2/4p1Q1/8/2N5/PP4PP/2KR1R2 w – – bm Rxf6; id „ERET 078 – Freibauer“;
r1bqr1k1/3n1ppp/p2p1b2/3N1PP1/1p1B1P2/1P6/1PP1Q2P/2KR2R1 w – – bm Qxe8; id „ERET 079 – Damenopfer“;
5rk1/1ppbq1pp/3p3r/pP1PppbB/2P5/P1BP4/5PPP/3QRRK1 b – – bm Bc1; id „ERET 080 – Raeumung“;
r3r1kb/p2bp2p/1q1p1npB/5NQ1/2p1P1P1/2N2P2/PPP5/2KR3R w – – bm Bg7; id „ERET 081 – Koenigsangriff“;
8/3P4/1p3b1p/p7/P7/1P3NPP/4p1K1/3k4 w – – bm g4; id „ERET 082 – Endspiel“;
3q1rk1/7p/rp1n4/p1pPbp2/P1P2pb1/1QN4P/1B2B1P1/1R3RK1 w – – bm Nb5; id „ERET 083 – Abtausch“;
4r1k1/1r1np3/1pqp1ppB/p7/2b1P1PQ/2P2P2/P3B2R/3R2K1 w – – bm Bg7; id „ERET 084 – Koenigsangriff“;
r4rk1/q4bb1/p1R4p/3pN1p1/8/2N3P1/P4PP1/3QR1K1 w – – bm Ng4; id „ERET 085 – Abtausch“;
r3k2r/pp2pp1p/8/q2Pb3/2P5/4p3/B1Q2PPP/2R2RK1 w kq – bm c5; id „ERET 086 – Qualitaetsopfer“;
r3r1k1/1bnq1pbn/p2p2p1/1p1P3p/2p1PP1B/P1N2B1P/1PQN2P1/3RR1K1 w – – bm e5; id „ERET 087 – Raeumung“;
8/4k3/p2p2p1/P1pPn2p/1pP1P2P/1P1NK1P1/8/8 w – – bm g4; id „ERET 088 – Endspiel“;
8/2P1P3/b1B2p2/1pPRp3/2k3P1/P4pK1/nP3p1p/N7 w – – bm e8N; id „ERET 089 – Unterverwandlung“;
4K1k1/8/1p5p/1Pp3b1/8/1P3P2/P1B2P2/8 w – – bm f4; id „ERET 090 – Endspiel“;
8/6p1/3k4/3p1p1p/p2K1P1P/4P1P1/P7/8 b – – bm g6, Kc6; id „ERET 091 – Endspiel“;
r1b2rk1/ppp3p1/4p2p/4Qpq1/3P4/2PB4/PPK2PPP/R6R b – – am Qxg2; id „ERET 092 – Ver­gif­te­ter Bauer“;
2b1r3/r2ppN2/8/1p1p1k2/pP1P4/2P3R1/PP3PP1/2K5 w – – bm Nd6; id „ERET 093 – Endspiel“;
2k2Br1/p6b/Pq1r4/1p2p1b1/1Ppp2p1/Q1P3N1/5RPP/R3N1K1 b – – bm Rf6; id „ERET 094 – Damenopfer“;
r2qk2r/ppp1b1pp/2n1p3/3pP1n1/3P2b1/2PB1NN1/PP4PP/R1BQK2R w KQkq – bm Nxg5; id „ERET 095 – Damenopfer“;
8/8/4p1Pk/1rp1K1p1/4P1P1/1nP2Q2/p2b1P2/8 w – – bm Kf6; id „ERET 096 – Endspiel“;
2k5/p7/Pp1p1b2/1P1P1p2/2P2P1p/3K3P/5B2/8 w – – bm c5; id „ERET 097 – Endspiel“;
8/6pp/5k2/1p1r4/4R3/7P/5PP1/5K2 w – – am Ke2; id „ERET 098 – Endspiel“;
3q1r1k/4RPp1/p6p/2pn4/2P5/1P6/P3Q2P/6K1 w – – bm Re8; id „ERET 099 – Endspiel“;
rn2k2r/3pbppp/p3p3/8/Nq1Nn3/4B1P1/PP3P1P/R2Q1RK1 w k – bm Nf5; id „ERET 100 – Initiative“;
r1b1kb1N/pppnq1pB/8/3p4/3P4/8/PPPK1nPP/RNB1R3 b q – bm Ne5; id „ERET 101 – Entwicklung“;
N4rk1/pp1b1ppp/n3p1n1/3pP1Q1/1P1N4/8/1PP2PPP/q1B1KB1R b K – bm Nxb4; id „ERET 102 – Koenigsangriff“;
4k1br/1K1p1n1r/2p2pN1/P2p1N2/2P3pP/5B2/P2P4/8 w – – bm Kc8; id „ERET 103 – Zugzwang“;
r1bqkb1r/ppp3pp/2np4/3N1p2/3pnB2/5N2/PPP1QPPP/2KR1B1R b kq – bm Ne7; id „ERET 104 – Entwicklung“;
r3kb1r/pbqp1pp1/1pn1pn1p/8/3PP3/2PB1N2/3N1PPP/R1BQR1K1 w kq – bm e5; id „ERET 105 – Starke Felder“;
r2r2k1/pq2bppp/1np1bN2/1p2B1P1/5Q2/P4P2/1PP4P/2KR1B1R b – – bm Bxf6; id „ERET 106 – Koenigssicherheit“;
1r1r2k1/2pq3p/4p3/2Q1Pp2/1PNn1R2/P5P1/5P1P/4R2K b – – bm Rb5; id „ERET 107 – Verteidigung“;
8/5p1p/3P1k2/p1P2n2/3rp3/1B6/P4R2/6K1 w – – bm Ba4; id „ERET 108 – Endspiel“;
2rbrnk1/1b3p2/p2pp3/1p4PQ/1PqBPP2/P1NR4/2P4P/5RK1 b – – bm Qxd4; id „ERET 109 – Entlastung“;
4r1k1/1bq2r1p/p2p1np1/3Pppb1/P1P5/1N3P2/1R2B1PP/1Q1R2BK w – – bm c5; id „ERET 110 – Freibauer“;
8/8/8/8/4kp2/1R6/P2q1PPK/8 w – – bm a3; id „ERET 111 – Festung“;

9 Kommentare

  1. ERET-Test Pos.93?

    Es geht um die Pos.93/111

    ERET 093 – End­spiel T&S&B vs T&T&L, Simkho­vich 1923

    Det­lef Uter von https://forum.computerschach.de schreibt:

    Von Det­lef Uter Datum 2021-12-09 15:09“

    93. ERET 093 – End­spiel T&S&B vs T&T&L, Simkho­vich 1923 Gelöst in 0.09s/10; Gelöst: 85“

    Das kann nicht sein!!

    Das ist eine Posi­tion die bis­her keine engine gelöst hat, siehe auch:

    Von Rein­hold Stibi Datum 2021-12-09 02:39 Edi­tiert 2021-12-09 02:44“

    93. ERET 093 – End­spiel T&S&B vs T&T&L, Simkho­vich 1923 > 60s.“

    Det­lef Uter macht irgend etwas falsch.

  2. hi,
    eine inte­res­annte Posi­tion: „6r1/p1p1p1pP/P1PpP1P1/8/2P1B3/2K3pp/3P2rq/R5bk w – – „.
    Es ist eine 3x fache umwand­lung eines Bau­ern in einem Sprin­ger. Viel­leicht kann man diese FEN in dei­nen Tests aufnehmen?
    grüsse

  3. Hallo Wal­ter,
    bes­ten Dank für deine sehr lehr­reich­ten Aus­füh­run­gen auf mei­nen Feed­back. Es ist tat­säch­lich so, dass ich mich in den ver­gan­ge­nen Jah­ren nicht mit den aller­neu­es­ten Engi­nes befasst habe und daher meine Argu­mente wohl keine 5 Rap­pen mehr Wert sind 🙂
    Im Augen­blick habe ich die bes­ten Engi­nes (dar­un­ter Lc0, SugaR-NN mit Per­sis­tent Lear­ning, Hou­dini 5.1 (6.0 ist noch bes­ser, aber kos­tet was…) und die lösen tat­säch­lich deine Auf­ga­ben bin­nen Sekun­den – und ver­ste­hen sehr wohl die Lösun­gen auf­grund ither Vari­an­ten, im Gegen­satz zu was ich vor­her behaup­tete, Es ist schon eine andere Welt im Ver­gleich zu den Jah­ren 2000-2008, den Zeit­raum den ich zuletzt gut kannte, was Engi­nes betrifft.

    Mög­li­cher­weise ist Posi­tion 90, die sehr hüb­sche Stu­die, die du auch hier auf dei­ner Web­page zeigst, nicht ein­deu­tig, und lässt auch die Lösung 1.Ld1 – Ld2 2.f4!! zu, meine Pro­gramme zei­gen nach manu­el­ler Ana­lyse einen Vor­teil von +3.xx, nach­dem sie ver­geb­lich an 1.Ke7 her­um­ge­rech­net haben und ich die dazu­ge­hö­ri­gen Vari­an­ten manu­ell ein­ge­ge­ben habe. Geh‘ ich zur Anfang­s­tel­lung zurück rech­nen sie dann an 1.Ld1 und 2.f4, und nach Ein­gabe die­ser Vari­an­ten fin­den sie schliess­lich auch die Lösung 1.f4!!, ein rei­ner Hash­ta­ble-Effekt denke ich mal.. Aller­dings könnte ich mich irren, was 1.Ld1 bett­rift, ich muss wei­ter analysieren.
    Beste Grüsse,
    Michael

  4. Hallo Wal­ter,
    deine zusam­men­ge­stellte Schach­pro­bleme sind sehr schön und Hilf­reich – für Men­schen zwecks Ver­bes­se­rung ihrer Schach­kenn­tinsse. Stel­lungs­test alle­samt, inlku­sive dei­ner die­nen mei­ner Mei­nung nach kei­nes­falls zur Spiel­stär­ke­be­stim­mung eines Pro­gramms (Engine), son­dern sagt ledig­lich aus, wie gut ein Pro­gramm zur Ana­lyse geeig­net ist. Spiel­stärke wird durch Spie­len von Par­tien zwi­schen Geg­nern bestimmt, wo auch eine Elo-Eichung aus­ge­rech­net wer­den kann. Tests kön­nen – und soll­ten – kei­nes­falls auf eine Elo-Zahl schlies­sen. Stel­lun­gen lösen und Par­tien spie­len sind 2 Paar Stiefel.
    Dann gibt est ein wei­te­res gra­vie­ren­des Pro­blem mit ver­kürz­ten Test­zei­ten (in dei­nem Fall: 15 Sekun­den). In einer nur kur­zen Bedenk­zeit kön­nen Pro­gramme den rich­ti­tgen Zug aus völ­lig fal­schem Grund aus­ge­ben, dann die­sen Zug schnell wie­der ver­wer­fen, um sich spä­ter doch wie­der für dien Zug zu ent­schei­den. Das liegt an der beson­de­ren Arbe­tis­weise der Engi­nes, für das Fin­den einer Gewinn­brin­gen­den Fort­set­zung müs­sen u.U erst ein­mal völ­lig tri­viale Vari­an­ten durch­ge­rech­net wer­den, die Zei­gen, dass eine sol­che Fort­set­zung nicht zum Gewinn fürhrt, das kos­tet Zeit. Ein Mensch würde nie und nim­mer so vor­ge­hen (er erkennt Mus­ter statt Vari­an­ten). Das bedeu­tet, dass die Aus­gabe des rich­ti­gen Zuges nach 15 Sekun­den kei­nes­falls den ein­deu­ti­gen Schluss zulässt, das Pro­gamm hätte die Stel­lung auch rich­tig ver­stan­den. Eine Abhife dazu könnte sein, ein Pro­gramm 2 Minu­ten (oder län­ger) rech­nen zu las­sen, um dann sämt­li­che Lösun­gen zu berück­sich­ti­gen, die inner­halb von 15 Sekun­den gefun­den wur­den und für 2 Minu­ten die Lösung dann auch beibehält, 

    Es berei­tet mir grosse Freude deine Stel­lun­gen zusam­men mit den Engi­nes zu ana­ly­sie­ren! Bes­ten Dank für deine Arbeit.

    • Hi Michael

      Für deine Beschäf­ti­gung mit dem ERET-Com­pu­ter­test vie­len Dank.

      Dein Argu­men­ta­rium ent­hält aller­dings ein paar alt­be­kannte Irr­tü­mer und Miss­ver­ständ­nisse, die gegen­über Stel­lungs­tests immer wie­der geäus­sert wer­den, und die ich gerne auch hier richtigstelle.

      Stel­lungs­tests alle­samt, inklu­sive dei­nes die­nen mei­ner Mei­nung nach kei­nes­falls zur Spiel­stär­ke­be­stim­mung eines Pro­gramms (Engine), son­dern sagt ledig­lich aus, wie gut ein Pro­gramm zur Ana­lyse geeig­net ist“.

      Nein. Mit „Ana­lyse“ im eigent­li­chen Sinne haben Stel­lungs­tests nichts zu tun.

      Hin­ge­gen ist ein umfang­rei­cher und sorg­fäl­tig kon­zi­pier­ter Stel­lungs­test – über den ERET ins­be­son­dere und seine Axio­ma­tik steht ja alles Not­wen­dige im Arti­kel – durch­aus in der Lage, als Indi­ka­tor für die Spiel­stärke einer Engine zu fungieren.

      Selbst­ver­ständ­lich wird er die Rang­lis­ten, wie sie von sta­tis­tisch ori­en­tier­ten Pools wie z.B. CCRL gene­riert wer­den, nicht 100%-ig abbil­den kön­nen, und dies­be­züg­lich Engine-„Ausreisser“ gibt es im ERET sicher (übri­gens aber auch in den CCRL- oder CEGT-Pools, die eine und die­selbe Engine deut­lich ver­schie­den ran­gie­ren können…)

      Es ist kein Zufall, dass die vom ERET-Stel­lungs­test gene­rier­ten Ran­kings ver­blüf­fend gut kor­re­spon­die­ren mit ande­ren bekann­ten Rang­lis­ten. Vor drei Jah­ren wurde mal die dama­lige ERET-Rang­liste ver­gli­chen mit wei­te­ren geläu­fi­gen Ran­kings, und die hohe Über­ein­stim­mung die­ser sechs Lis­ten bestä­tigt die Ziel­set­zung des ERET, näm­lich inner­halb kür­zes­ter Zeit einen ers­ten Ein­druck von der Tur­nier-Per­for­mance eines Pro­gram­mes zu erhalten:

      Der ERET im Ver­gleich mit ande­ren Rankings

      Stel­lun­gen lösen und Par­tien spie­len sind 2 Paar Stiefel“.

      Jein.
      Selbst­ver­ständ­lich kön­nen in einen Stel­lungs­test Tur­nier-rele­vante Para­me­ter wie z.B. Eröff­nungs­theo­rie oder Hash-Memo­rie­rung nur bedingt einfliessen.

      Aber grund­sätz­lich ist für ein Schach­pro­gramm das Spie­len von (z.B. hun­dert) Schach­par­tien nichts ande­res als ein gigan­ti­scher Stel­lungs­test; Zug um Zug wird gene­riert, eva­lu­iert, bewer­tet, aus­ge­spielt – ein Stel­lungs­test eben. (Es sei denn, man attes­tiert den Engi­nes beim Schach­spie­len mensch­li­che Qua­li­tä­ten wie z.B. „plan­volle Stra­te­gie“, aber zu sol­cher Hybris ver­stei­gen sich nicht mal die ein­ge­fleisch­tes­ten Pro­gram­mie­rer der moder­nen Neu­ro­na­len Netz­werke…)

      Dann gibt est ein wei­te­res gra­vie­ren­des Pro­blem mit ver­kürz­ten Test­zei­ten (in dei­nem Fall: 15 Sekun­den). In einer nur kur­zen Bedenk­zeit kön­nen Pro­gramme den rich­ti­tgen Zug aus völ­lig fal­schem Grund aus­ge­ben, dann die­sen Zug schnell wie­der ver­wer­fen, um sich spä­ter doch wie­der für den Zug zu entscheiden“.

      Nein. 15 Sekun­den pro Zug ist heut­zu­tage kei­nes­wegs eine kurze, son­dern eine über­durch­schnitt­lich lange Bedenkzeit.
      Moderne Engi­nes berech­nen in Sekun­den­bruch­tei­len -zig hun­dert­tau­sende von Stel­lun­gen. Und zwar hoch­se­lek­tiv und mit raf­fi­nier­tes­ten Cut-Algo­rith­men. Die uralten Zei­ten von Brute-Force-Tech­ni­ken, wo (fast) jedem Quatsch-Zug nach­ge­gan­gen wurde, sind auch bei den tra­di­tio­nel­len Alpha-Beta-Pro­gram­men längst passé, von den aktu­el­len NN-Pro­gram­men ganz zu schweigen.

      Der weit­aus grösste Teil der heu­ti­gen Engine-Tur­niere spielt sich mit Bul­let- oder Blitz-Bedenk­zei­ten ab, also zwi­schen 3 bis 5 Minu­ten pro Engine/Partie.

      Bei einer durch­schnitt­li­chen Züge-Anzahl von 50-60 bei Engine-Par­tien sind also die 15 Sekun­den des ERET pro Zug eine über­durch­schnitt­lich lange Zeit…

      Aus­ser­dem ist eine beson­dere Qua­li­tät des ERET, dass er fast aus­schliess­lich nach sol­chen Lösungs­zü­gen fragt, die von einer Engine nicht mehr ver­wor­fen wer­den (kön­nen), sobald sie mal gefun­den wur­den. Dies kann, wer will, mit den Engi­nes gerne expe­ri­men­tell nachprüfen.

      Es berei­tet mir grosse Freude deine Stel­lun­gen zusam­men mit den Engi­nes zu ana­ly­sie­ren! Bes­ten Dank für deine Arbeit“.

      Es freut mich, dass der ERET auch fast vier Jahre nach sei­ner Ent­ste­hung immer noch für Inter­esse sorgt in der Computerschach-Welt.
      Aller­dings berei­tet mir Sorge, dass mitt­ler­weile von den aller­stärks­ten Engi­nes durch­schnitt­lich fast 100 der 111 Stel­lun­gen in den gefor­der­ten je 15 Sekun­den gelöst werden. ;-(

      Viel­leicht mache ich mir all­mäh­lich Gedan­ken über einen ERET-2 🙂

      Gruss: Wal­ter

  5. Naja, bin eigent­lich ein Geg­ner von Stel­lungs­tests, wenn es um Rang­lis­ten von Pro­gram­men geht. Erin­nere mich noch an den Bratko-Kopec-Test für Schachcomputer:
    https://www.schach-computer.info/wiki/index.php?title=Bratko-Kopec_Test
    Da waren anfäng­lich die Resul­tate auch i.O. aber mit jedem Jahr, das die Din­ger stär­ker wur­den, geriet der Bratko immer mehr in Schief­lage, bis er mit den rea­len Stär­ke­ver­hält­nis­sen über­haupt rein gra nichts mehr zutun hatte! Mitt­ler­weile ist er tri­vial (wenn über­haupt alle seine Puz­zles über­haupt kor­rekt sind…)
    Aber zuge­ge­ben, euer ERET ist von ande­rem Kali­ber, ich habe ihn kurz nach Erschei­nen mit Dut­zen­den Engi­nes getes­tet, und dann ein Jahr spä­ter mit geup­date­ten Engi­nes, und das ent­stan­dene Ran­king war prak­tisch unver­än­dert. Irgend etwas macht der ERET anders als alle ande­ren Stel­lungs­tests, Kom­pli­ment! Wenn ich eine neue Engine down­loade, hat sie bei mir immer erst euren ERET zu absol­vie­ren, dann weiss ich unge­fähr, wie sie im Ver­gleich mit Vor­gän­gern oder ande­ren Engi­nes abschnei­det. Keep on the good job! 🙂

    Thx, Tim Becker (aus dem hyper hot­ten München)

Kommentare sind willkommen! (Keine E-Mail-Pflicht)