Engine insights on human and tournaments

[Ferdy]

Stockholm Interzonal (1962) -Fischer 1st place
http://www.chessgames.com/perl/chess.pl?tid=79444

Code: Select all

Results from file c_Candidates1962.pgn:

No. Name                   Win Draw Loss Unf.  Score Games       %
------------------------------------------------------------------
  1 Petrosian, Tigran V     +8  =19   -0   *0   17.5    27   64.8%
  2 Geller, Efim P          +8  =18   -1   *0   17.0    27   63.0%
  3 Keres, Paul             +9  =16   -2   *0   17.0    27   63.0%
  4 Fischer, Robert James   +8  =12   -7   *0   14.0    27   51.9%
  5 Kortschnoj, Viktor      +7  =13   -7   *0   13.5    27   50.0%
  6 Benko, Pal C            +6  =12   -9   *0   12.0    27   44.4%
  7 Filip, Miroslav         +2  =10  -15   *0    7.0    27   25.9%
  8 Tal, Mihail             +3   =8  -10   *0    7.0    21   33.3%

Total Games:     105
White Wins:       27 (25.7%)
Black Wins:       24 (22.9%)
Draws:            54 (51.4%)

Then the conclusion of some analysts/journalists were correct, that Karpov is slightly better than Fischer when it comes to accuracy and if both their games against Spassky were calculated with regards to win/loss ratio. With your above data I think Karpov can even beat Fischer if Fischer is out of form. But very close to each other.


Linares 1994

Code: Select all

Karpov, Anatoly          :       0       9       1       0     -2.20   391    13 11.0       0 

Sotckholm Interzonal 1962

Code: Select all

Fischer, Robert James    :       0      11       1       0     -2.65   748    22 17.5       0 

Candidates 1962

Code: Select all

Fischer, Robert James    :       0      31       6       0     -3.57   853    27 14.0       5 

Nice comparison, it is close indeed.

[Ferdy]

AVRO 1938 chess tournament
From Wikipedia, the free encyclopedia
The AVRO tournament was a chess tournament held in the Netherlands in 1938, sponsored by the Dutch broadcasting company AVRO. The event was a double round-robin tournament. The eight players generally regarded as the strongest in the world took part: World Champion Alexander Alekhine, former champions José Raúl Capablanca and Max Euwe, future champion Mikhail Botvinnik and challengers Paul Keres, Reuben Fine, Samuel Reshevsky and Salo Flohr. Keres and Fine tied for first place, with Keres winning on tiebreak by virtue of his 1½-½ score in their individual games.

Capablanca's play was satisfactory in the first half of the event (50%), but collapsed in the second half, when he lost three games. He had only lost 26 tournament games in 29 years. Hooper and Whyld say "he suffered a slight stroke, and scored only four draws in the last seven games".[1] Another version is that he was extremely ill during the event. Olga Capablanca recalled that his high blood pressure nearly cost him his life: "A doctor screamed at me, 'How could you let him play?'" [2] In a later interview Capablanca denied having a cerebral defect, though he speaks of symptoms which are certainly serious.[3] However, his doctor recalled that in 1940, Capablanca was found to have extremely dangerous hypertension of 210 systolic/180 diastolic (hypertensive crisis is 180/120 or above, and even after treatment Capablanca had 180/130).[4]

The tournament was presented as one to provide a challenger to Alekhine, though this had no official status. In the event World War II dashed any hopes of a championship match for years to come. However, when FIDE organised its 1948 match tournament for the world title after Alekhine's death in 1946, it invited the six surviving AVRO participants (Capablanca had also died), except Flohr who was replaced by Vasily Smyslov.

Code: Select all

Player                   : Dange WinMi WinFo WinNF Dubio Mista Blund AErr/G   Pos Games   Pts
Flohr, Salo              :     4     1     1     0     5     1     0  -4.39   279    14   4.5
Euwe, Max                :     3     1     5     0     7     1     0  -3.33   367    14   7.0
Fine, Reuben             :     3     1     6     1     8     2     0  -4.02   369    14   8.5
Capablanca, Jose Raul    :     3     1     3     0    11     2     0  -3.19   396    14   6.0
Botvinnik, Mikhail       :     3     0     3     0     2     4     0  -2.53   327    14   7.5
Alekhine, Alexander      :     4     1     2     0     9     4     0  -4.98   490    14   7.0
Keres, Paul              :     0     1     4     0    11     4     0  -2.59   392    14   8.5
Reshevsky, Samuel Herman :     3     1     4     0    11     1     1  -4.36   458    14   7.0

TQ (Tournament Quality)  : -3.67

Code: Select all

LEGEND:
WinMi     - WinMiss, count of games where a player miss the winning move in
            one of the pos. Winning move: engine_movescore > 3.0 and
            player_movescore <= 3.0 pawns and the player failed to win this game.
WinFo     - WinFound, count of games where a player found the winning move
            the first time the position is encountered in the game. A winning
            move would result to an evaluation of more than 3 pawns.
WinNF     - WinNotFound, count of games where a player failed to find the winning
            move the first time the position is encountered in the game.
Dubio     - Dubious, count of positions where a playable position
            turns into a difficult position.
            Playable position: engine_movescore >= -0.5
            Difficult position: -0.5 < player_movescore >= -1.0
Mista     - Mistake, count of positions where a playable position
            turns into a very difficult position.
            Very difficult position: -1.0 < player_movescore >= -3.0
Blund     - Blunder, count of positions where a playable position
            turns into losing position.
            Losing position: player_movescore < -3.0
AErr/G    - Average error/game, in pawn unit.
            Measures the accuracy of a player, higher is better.
            error = player_movescore - engine_movescore
            ave_error = total_error/pos
            AErr/G = ave_error/num_games
Dange     - Danger, count of games where the player is losing.
            A game is losing when there is one position where
            engine_movescore < -3.0

NOTES:
1. Engine used in the analysis is Brainfish 300117 64 POPCNT.
2. Analysis time/pos is 10.0s.
3. Average analysis depth reached is 27.
4. When the player move error is below -6.0 pawns from a
   given position, error is set to -6.0 pawns.
5. Analysis of position starts at move 12 in every game.
6. When the score of the position in a game is already
   below -6 pawns, analysis of succeeding position in this game
   will be stopped and analysis will continue in the next game.
7. The table is sorted in order by:
   a. WinFound in descending order
   b. WinMiss in ascending order
   c. AErr/G in descending order
   d. Dubious in ascending order
   e. Mistake in ascending order
   f. Blunder in ascending order
8. Tournament quality is the average error per game of all players.
   TQ = total AErr/G / num_players
   A high TQ means the games have less mistakes overall.

[GregNeto]

Very interesting project! Maybe you could analyse a player with a long career like Kortchnoi or Lasker see what an effect age has (kind of time line)

[Ferdy]

Very interesting project! Maybe you could analyse a player with a long career like Kortchnoi or Lasker see what an effect age has (kind of time line)

This is possible especially those players without a rating.

[Vinvin]

Hello Ferdinand,
I had an idea to measure the error :
1) convert the score in win percentage : https://chessprogramming.wikispaces.com ... e,+and+ELO
2) show the error in average Win-Percentage-Lost unit.

That will avoid to put an upper limit to the score.

[Ferdy]

Hello Ferdinand,
I had an idea to measure the error :
1) convert the score in win percentage : https://chessprogramming.wikispaces.com ... e,+and+ELO

This is also what I have been aiming at. Then map this win percentage into rating points.

2) show the error in average Win-Percentage-Lost unit.
That will avoid to put an upper limit to the score.

Could you describe what is this Win-Percentage-Lost unit?
(1) could be enough already.

Generally it is easier to map the average error of these players into rating points because I have a data for engine score and win percentage and rating of the engine.

What I have been researching is how to map into rating points the other various criteria like number of dubious moves, number of mistakes, number of blunders, number games where the player is in danger of losing the game, the quality of opponents and others.

For example for a particular tournament, a player blunders (from playable position into a losing position).
ideal_blunder = 0
actual_blunder = 1
distance_blunder = 0-1 = -1
distance_blunder_sq = (-1) x (-1) = 1

Something like,
updated_rating = updated_rating - (distance_blunder_sq x blunder_weight)

Then I have to define what is the appropriate value for blunder_weight.

So the bigger the distance_blunder_sq the lower will be its rating.

[Vinvin]

...

2) show the error in average Win-Percentage-Lost unit.
That will avoid to put an upper limit to the score.

Could you describe what is this Win-Percentage-Lost unit?

Same as centipawn : the difference bewteen the best moves and the actual move. If the best move gives 52% winning probability and the actual move gives 49.5% winning probability, the "Win-Percentage-Lost" is 2.5.

Generally it is easier to map the average error of these players into rating points because I have a data for engine score and win percentage and rating of the engine.

The rating (quality) for a move is difficult to define by numbers. I didn't see clear formulas yet :/
This app worked quite well : http://rybkaforum.net/cgi-bin/rybkaforu ... ?tid=16085
but I don't know formulas behind.

What I have been researching is how to map into rating points the other various criteria like number of dubious moves, number of mistakes, number of blunders, number games where the player is in danger of losing the game, the quality of opponents and others.

For example for a particular tournament, a player blunders (from playable position into a losing position).
ideal_blunder = 0
actual_blunder = 1
distance_blunder = 0-1 = -1
distance_blunder_sq = (-1) x (-1) = 1

Something like,
updated_rating = updated_rating - (distance_blunder_sq x blunder_weight)

Then I have to define what is the appropriate value for blunder_weight.

So the bigger the distance_blunder_sq the lower will be its rating.

Good ideas.
"playable position into a losing position" is hard to define by numbers too.

[Ferdy]

"playable position into a losing position" is hard to define by numbers too.

This was already defined see Blund legend and in the table that I showed. Strong players usually have zero of this.

Code: Select all

LEGEND: 
WinMi     - WinMiss, count of games where a player miss the winning move in 
            one of the pos. Winning move: engine_movescore > 3.0 and 
            player_movescore <= 3.0 pawns and the player failed to win this game. 
WinFo     - WinFound, count of games where a player found the winning move 
            the first time the position is encountered in the game. A winning 
            move would result to an evaluation of more than 3 pawns. 
WinNF     - WinNotFound, count of games where a player failed to find the winning 
            move the first time the position is encountered in the game. 
Dubio     - Dubious, count of positions where a playable position 
            turns into a difficult position. 
            Playable position: engine_movescore >= -0.5 
            Difficult position: -0.5 < player_movescore >= -1.0 
Mista     - Mistake, count of positions where a playable position 
            turns into a very difficult position. 
            Very difficult position: -1.0 < player_movescore >= -3.0 
Blund     - Blunder, count of positions where a playable position 
            turns into losing position. 
            Losing position: player_movescore < -3.0 
AErr/G    - Average error/game, in pawn unit. 
            Measures the accuracy of a player, higher is better. 
            error = player_movescore - engine_movescore 
            ave_error = total_error/pos 
            AErr/G = ave_error/num_games 
Dange     - Danger, count of games where the player is losing. 
            A game is losing when there is one position where 
            engine_movescore < -3.0