Analysis research · Version 1.0.0 · 15 October 2026

Centipawn Loss and Accuracy: A 136-Case Study

Losing 100 centipawns does not have one accuracy score. The starting evaluation changes what that loss means to a nonlinear model.

Under our pinned single-move formula, 0 → −100 cp scores 67.24; +800 → +700 cp scores 92.12. We tested 136 constructed input pairs and independently recomputed every result.

Equal loss, different score

What does 100 centipawn loss mean?

A centipawn is one hundredth of a pawn in an engine’s evaluation scale. In this study, “loss” means a decrease in the supplied evaluation from the mover’s perspective. The inputs are fixed numbers, not evaluations extracted from games or comparisons against an independently searched best move.

The same 100 cp drop gives 67.24 from a level starting score and 92.12 from +800 cp. The model first converts centipawns into a nonlinear winning-chance scale. Near equality, a fixed cp drop moves that scale farther than it does in an already lopsided position. These scores are model outputs, not observed human win percentages.

Single-move score after the same 100 cp loss

0 → −100 cp

67.24

+300 → +200 cp

72.28

+500 → +400 cp

80.97

+800 → +700 cp

92.12

Scores use the fixed ChessAnalysis transform. The table below includes clipping boundaries.

All evaluations are mover-relative. W is the model’s winning-chance scale; ΔW is in percentage points.
Before → after (cp)	Loss (cp)	W before	W after	ΔW	Move accuracy
−1000 → −1100	100	2.46	2.46	0.00	100.00
−500 → −600	100	13.69	9.89	3.80	85.26
0 → −100	100	50.00	40.90	9.10	67.24
+100 → 0	100	59.10	50.00	9.10	67.24
+300 → +200	100	75.11	67.62	7.49	72.28
+500 → +400	100	86.31	81.35	4.96	80.97
+800 → +700	100	95.01	92.94	2.07	92.12
+1000 → +900	100	97.54	96.49	1.05	96.37

The −1000 → −1100 example scores 100 because both inputs clip to −1000. That is a model boundary; it does not show that the move is harmless.

The exact calculation

The formula used in this study

Let c be the evaluation from the mover’s view, clamped to [−1000, +1000] cp. Define the model scale:

W(c) = 100 / (1 + exp(−0.00368208 × c))
ΔW = W(before) − W(after)

If W(after) ≥ W(before): accuracy = 100
Otherwise:
accuracy = clamp(
  103.1668100711649 × exp(−0.04354415386753951 × ΔW)
  − 3.166924740191411 + 1,
  0, 100
)

This is the Lichess-style transform implemented in our pinned site code, including the +1 bonus. Lichess documents the approach; we do not claim these synthetic results reproduce any current Lichess or Chess.com game report.

For 0 → −100 cp, W changes from 50.00 to 40.90: a drop of about 9.10 points, producing 67.24 accuracy. Do the calculation at full precision; rounded table values are for reading, and can give slightly different results if used as inputs.

Stockfish’s evaluation documentation distinguishes centipawns from its WDL model. This study uses the formula above, not Stockfish’s WDL output. It is not calibrated for your rating, opponent or time control.

Perspective and clipping

Two boundaries that can reverse an interpretation

Convert the perspective exactly once

If the supplied evaluations use White’s view, negate both values for a Black move before measuring loss. White-view −300 → −200 is a 100 cp loss for Black: the mover-relative pair is +300 → +200. Its score is 72.28, matching the mirrored White case.

All 66 paired White/Black matrix cases matched within 1e−10 in the independent check. If your input is already mover-relative, do not negate it again. python-chess’s perspective-aware scores illustrate why the point of view belongs with the number.

Clipping can erase a numerical loss

+1200 → +1100 becomes +1000 → +1000 after clipping, so it scores 100. +1100 → +900 crosses the boundary, so the model sees a change. The four extra boundary rows disclose these cases rather than quietly treating large evaluations as precise inputs.

Mate scores, checkmate states and the site’s game-level aggregation are outside this matrix. A 100 here is a single-move model score, not proof of the best move, perfect play or an absence of cheating.

Use the result

Can average centipawn loss be converted to accuracy?

Not from the average alone under this model. The transform needs each starting evaluation and each ending evaluation. Whole-game accuracy also uses aggregation and weights, so applying the single-move formula to an average cp loss discards information it needs.

For your own review, keep the engine version and analysis settings consistent, inspect the position behind a large change, and compare the move before drawing a conclusion from its score. Use our accuracy calculator and formula guide for a single example, or review a game to inspect its moves. Those live reviews run the engine; this study does not.

Methods and limitations

How the 136 cases were calculated

The main grid contains 11 starting evaluations (−1000, −800, −500, −300, −100, 0, +100, +300, +500, +800, +1000), six losses (0, 25, 50, 100, 200, 400 cp) and two mover colors: 132 rows. Four clipping-boundary rows bring the total to 136.

We called the actual site’s winning-chance and move-accuracy functions, pinned at commit ca5c181bf32ab7200c85b59d3edcbfae68023509. A separate Python standard-library calculation checked every output to within 1e−10; its largest numerical difference was about 7.11e−14.

Inspect the White-side sensitivity matrix (66 rows)

Cells are move-accuracy scores. Column headings are loss in centipawns; row headings are the starting mover-relative evaluation.
Before (cp)	0 cp loss	25 cp loss	50 cp loss	100 cp loss	200 cp loss	400 cp loss
−1000	100.00	100.00	100.00	100.00	100.00	100.00
−800	100.00	99.13	97.45	94.54	90.20	90.20
−500	100.00	96.38	92.26	85.26	75.12	64.05
−300	100.00	93.72	87.27	76.47	61.20	45.30
−100	100.00	91.56	83.14	69.03	49.21	29.39
0	100.00	91.17	82.31	67.24	45.73	24.18
+100	100.00	91.40	82.59	67.24	44.53	21.09
+300	100.00	93.39	86.04	72.28	49.21	21.09
+500	100.00	96.07	91.07	80.97	61.20	29.39
+800	100.00	98.97	96.82	92.12	81.18	54.75
+1000	100.00	99.97	98.86	96.37	90.20	72.46

These are constructed numerical pairs, not a chess-position corpus. We ran no engine searches for this dataset and collected no player data. It cannot establish human winning probabilities, Elo, cheating, move quality in an actual position or agreement between sites. ChessAnalysis produced this first-party study; external sources do not endorse it.

Open evidence

Download and reproduce all 136 results

Save cases, JSON results and the Python verifier in the same folder. Run python3 reproduce-v1.py with Python 3; it needs no third-party package or network connection. CSV values retain full precision.

cases-v1.json19,893 bytesSHA-256 f15ab429afc274dbf0e3c89a20d82971b17e8880676d3da6c9474170e3dc4e88
limitations-v1.md769 bytesSHA-256 080339c9405ba6d543386656112f761694a53b33d4867793641932d2471b8c4b
methodology-v1.json2,176 bytesSHA-256 69fb6ea4753f36931438663ca804917217a527fe4f1f361c26f9c4a82e81798d
reproduce-v1.py2,836 bytesSHA-256 2fbbe6c7722303f180f4fdf05e4f766e9af2df58cfc181c1eb8ceedfd30bac1c
results-v1.csv18,597 bytesSHA-256 e36f2cd119749bd826a61142be131c3f85946f721ad536702b251c8bcb69df42
results-v1.json52,775 bytesSHA-256 d02a0306019ef4790e6bed339aebae613cc1b11c1e5a782a469628597d8393d7
sources-v1.json1,194 bytesSHA-256 1dd869de959fd694a388bef7b61f582ea26ed174c6db081fbbd5d9ffd963b835

Constructed data and results: CC0-1.0. Verifier: MIT. External materials retain their own licenses. Version 1.0.0 is the initial release; changes to the data or formula will receive new versioned files and a change note.

For a specific citation, link to the equal-loss comparison or the perspective and clipping results, with “ChessAnalysis, version 1.0.0, 15 October 2026.” Send corrections through Contact with the row ID, input perspective and expected calculation.

Primary references

Sources and context

Lichess Accuracy metric — Published nonlinear transform and distinct whole-game aggregation.
Stockfish FAQ — Engine centipawn scores, normalization and WDL interpretation limits.
python-chess engine documentation — Score perspective and nonlinear outcome-expectation differences.
Calculating Centipawn Loss — First-person analysis workflow; demand evidence only, not formula validation.

Sources checked 15 October 2026. Formula documentation supports the explanation; the fixed input matrix and independent verifier support this study’s numerical results.