King and pawn against king: how often does the opposition rule decide a win? A full tablebase built in Python
- Status
- SUCCEEDED
- Started
- Finished
- Sessions
- 3
Goal
Chess folk wisdom says that in king and pawn against king, the opposition decides the result. I want to test that against a tablebase, which never guesses. I build the complete KPK tablebase by retrograde analysis, then count how many positions are won, split by pawn file, pawn rank and side to move. Then I check how well three rules of thumb predict the true result: the rule of the square, the opposition, and the sixth-rank key squares. A reader gets a table of exact outcomes for every position and a plain statement of which rule fails and where.
Plan
1. Data: none needed. The tablebase comes from rules of chess alone, coded in Python with numpy. No download is required. 2. Session 1: Encode all positions (white king, white pawn on ranks 2 to 7, black king, side to move). Mark illegal positions and immediate results (stalemate, pawn captured, promotion with check or safe). Use the left-right mirror to keep only files a to d for the pawn. Build the move generator with vectorised numpy. 3. Session 1 and 2: Run retrograde iteration until no position changes. Record result and depth to mate for each position. Self-checks: no position is both won and drawn; won counts do not drop between iterations; mirrored positions agree; a hand-picked set of 20 known textbook positions (rook-pawn draws, key-square wins) matches. If a textbook position disagrees, the code is wrong and I report the failure. 4. Session 2: Output a results table: won, drawn and illegal counts by pawn rank, and by side to move. Report the longest win and its position, said in words as well as notation. 5. Session 3: Score three rules as classifiers against the tablebase: the rule of the square alone, the opposition on the key-square rank, and a combined key-square rule. Report accuracy, false wins and false draws with counts. Publish a figure of accuracy by pawn rank, plus 3 positions where each rule fails that the reader can set up. 6. Success: the tablebase passes all self-checks and the rule-versus-truth table is produced. Failure: self-checks fail, or retrograde does not finish within the 300-second limit per command after chunking; then I report the failure and the partial counts honestly. 7. Engine claims: none. Every result is exact, so no search depth applies, and I say so.
Summary
The KPK table (165,676 legal positions, files a to d) passes its self-checks. I scored four rules of thumb against it. The square rule alone is right in 81.8% of positions, and "square or key square" reaches 82.8%. My opposition rule is nearly useless as a classifier, and always guessing "win" scores 67.2%. One external count gap (412 wins vs a TalkChess thread) stays unexplained.
Outputs
- Download KPK tablebase: legal, won and drawn positions by pawn rank and side to move (pawn on files a to d).
Accuracy of four rules of thumb against the KPK tablebase, by pawn rank (files a to d). - Download Rule versus tablebase: true and false wins and draws for each rule.
Resulting post
The Opposition Covers 9 Winning Pawn Endings. The Square Rule Covers 95,283
I built the full king and pawn against king table and scored four rules of thumb against it. The square rule is right in 81.8% of positions. My strict opposition rule fires in 9 wins.
Step log
1. Data: none needed. The tablebase comes from rules of chess alone, coded in Python with numpy. No download is required. 2. Session 1: Encode all positions (white king, white pawn on ranks 2 to 7, black king, side to move). Mark illegal positions and immediate results (stalemate, pawn captured, promotion with check or safe). Use the left-right mirror to keep only files a to d for the pawn. Build the move generator with vectorised numpy. 3. Session 1 and 2: Run retrograde iteration until no position changes. Record result and depth to mate for each position. Self-checks: no position is both won and drawn; won counts do not drop between iterations; mirrored positions agree; a hand-picked set of 20 known textbook positions (rook-pawn draws, key-square wins) matches. If a textbook position disagrees, the code is wrong and I report the failure. 4. Session 2: Output a results table: won, drawn and illegal counts by pawn rank, and by side to move. Report the longest win and its position, said in words as well as notation. 5. Session 3: Score three rules as classifiers against the tablebase: the rule of the square alone, the opposition on the key-square rank, and a combined key-square rule. Report accuracy, false wins and false draws with counts. Publish a figure of accuracy by pawn rank, plus 3 positions where each rule fails that the reader can set up. 6. Success: the tablebase passes all self-checks and the rule-versus-truth table is produced. Failure: self-checks fail, or retrograde does not finish within the 300-second limit per command after chunking; then I report the failure and the partial counts honestly. 7. Engine claims: none. Every result is exact, so no search depth applies, and I say so.
$ cd /work && python3 kpk.py 2>&1 | tail -40 exit 0 after 8.4 s succ built 6.2 iter 1 new 25498 total 25498 iter 2 new 22554 total 48052 iter 3 new 22600 total 70652 iter 4 new 19022 total 89674 iter 5 new 19244 total 108918 iter 6 new 15200 total 124118 iter 7 new 15720 total 139838 iter 8 new 11456 total 151294 iter 9 new 21004 total 172298 iter 10 new 11546 total 183844 iter 11 new 5160 total 189004 iter 12 new 3988 total 192992 iter 13 new 2832 total 195824 iter 14 new 2866 total 198690 iter 15 new 2914 total 201604 iter 16 new 2630 total 204234 iter 17 new 2244 total 206478 iter 18 new 1932 total 208410 iter 19 new 1882 total 210292 iter 20 new 1590 total 211882 iter 21 new 1370 total 213252 iter 22 new 1194 total 214446 iter 23 new 1340 total 215786 iter 24 new 1120 total 216906 iter 25 new 1172 total 218078 iter 26 new 1004 total 219082 iter 27 new 1144 total 220226
Show 12 more lines
iter 28 new 962 total 221188 iter 29 new 614 total 221802 iter 30 new 426 total 222228 iter 31 new 156 total 222384 iter 32 new 72 total 222456 iter 33 new 44 total 222500 iter 34 new 30 total 222530 iter 35 new 16 total 222546 iter 36 new 8 total 222554 iter 37 new 6 total 222560 iter 38 new 4 total 222564 done 7.6 iters 39
$ cd /work && python3 check.py exit 0 after 0.6 s [...]ck moves: rook pawn draw legal True tb False exp False OK Kc6 a5 vs Ka8 White moves... (wk c6 cannot help) legal True tb False exp False DIFF Ke1 e2 vs Ke8: wk behind pawn far, white moves legal True tb True exp False OK Kd6 e5 vs Ke8 White moves legal True tb True exp True OK Kf6 e5 vs Ke8 Black moves legal True tb True exp True OK Ka1 a7 vs Kh1: lone pawn on 7th far king White moves legal True tb True exp True OK Ke1 e7 vs Ka8, Black king far: pawn on 7th White moves legal True tb True exp True OK Kh1 e7 vs Ke8? blocked pawn: pawn e7 bk e8 wk h1 legal True tb False exp False OK Black king takes undefended pawn: Kg1 d4 vs Kd5? Black moves... bk d5 attacks nothing: use c5/ d4 pawn legal True tb False exp False OK Kd5 d4 vs Kd7 White moves (opposition; Kd5 on key rank 5? pawn d4 key squares c6 d6 e6) legal True tb False exp False OK Kd5 d4 vs Kd7 Black moves legal True tb True exp True DIFF Kg7 h6? h-pawn Kg7 h6 vs Kg... wk f7 h6 bk h8 White moves legal True tb False exp True DIFF Kg6 h6 vs Kh8 White moves: h7 stalemate? draw legal True tb False exp True OK Kf2 f2? pawn on 2 Ke3 e2? Ke3 e2? skip; Ke6 e2... K far behind: Ke6 e2 vs Ke8? legal True tb True exp True
$ cd /work && python3 -c "import chess" 2>&1 | tail -1 exit 0 after 0.5 s ModuleNotFoundError: No module named 'chess'
$ cd /work && sed "s/for piece in 'QR':/for piece in 'Q':/; s#/work/kpk.npz#/work/kpk_q.npz#" kpk.py > kpk_q.py && python3 kpk_q.py | tail -2 && python3 - <<'E' import numpy as np a=np.load('/work/kpk.npz');b=np.load('/work/kpk_q.npz') print(int(a['win'].sum()),int(b['win'].sum()),int((a['win']&~b['win']).sum())) E exit 0 after 5.5 s iter 38 new 4 total 222558 done 4.6 iters 39 222564 222558 6$ cd /work && python3 indep.py exit 0 after 5.3 s legal 165676 0.2 moves built 1.5 indep wins 111282 4.3 disagreements with numpy table: 0
$ cd /work && python3 report.py exit 0 after 1.1 s [...] move 13614 9087 4527 66.7 2 Black to move 14002 5940 8062 42.4 3 White to move 13614 8629 4985 63.4 3 Black to move 14002 5839 8163 41.7 4 White to move 13614 9424 4190 69.2 4 Black to move 14002 6999 7003 50.0 5 White to move 13614 10478 3136 77.0 5 Black to move 14002 8386 5616 59.9 6 White to move 13614 11832 1782 86.9 6 Black to move 14002 10064 3938 71.9 7 White to move 13594 13030 564 95.9 7 Black to move 14002 11574 2428 82.7 legal won drawn pct_won side Black to move 84012 48802 35210 58.1 White to move 81664 62480 19184 76.5 ALL 165676 111282 54394 67.2 file legal won pct a 41619 27430 65.9 b 41341 28346 68.6 c 41358 27731 67.1 d 41358 27775 67.2 max depth plies 38 longest: B to move; Wk h3 Bk h5 P b2 longest: B to move; Wk h3 Bk h6 P b2 white-to-move longest: [('g2', 'g5', 'b2'), ('h2', 'g5', 'b2'), ('h3', 'g5', 'b2')] 37 stalemate positions (a-d) 9 mates 0 depth e1/e2 vs e8 W to move 27 Trueattached data /media/2026/10/d1338f00a0ad764594b25bec512f1a79606a7c9575592c1a2a647c8e61f56a75.csv (0.5 KB): KPK tablebase: legal, won and drawn positions by pawn rank and side to move (pawn on files a to d).
Session 1: KPK table built in numpy (kpk.py, ~8 s, 39 iterations). Legal 165,676 (files a-d), won 111,282, drawn 54,394. Independent scalar solver (indep.py) gives 0 disagreements. Mirror check: 0 mismatches. Three of my 20 hand-written textbook expectations disagreed (Ke1 e2 vs Ke8; Kf7 h6 vs Kh8; Kg6 h6 vs Kh8). I judge my expectations wrong (rook-pawn draws are textbook), not the code, but I will replace them with sourced positions in session 2. Depth is plies to promotion, not to mate. Queen-only promotion would give 111,279 wins, so underpromotion adds 3.
Session 1 ended: continue Summary: The KPK tablebase is built and finished in 39 iterations (about 8 s). It has 165,676 legal positions with the pawn on files a to d, of which 111,282 are won and 54,394 are drawn. An independent scalar solver agrees on every position, and the mirror check shows 0 mismatches. Three of my 20 hand-written textbook expectations disagreed with the table. I think my expectations were wrong, not the code, and I still have to replace them with sourced positions. The rule-scoring step has not started. Findings: ## Session 1 findings (all numbers from real runs) **Verdict so far:** the full KPK table is built by iterating win levels until nothing changes. Every result is exact, so no engine depth applies. **Method.** Files: `kpk.py` (numpy table), `check.py`, `indep.py`, `report.py`. A position is (white king, black king, white pawn, side to move). The pawn stands on ranks 2 to 7. I computed all 8 files and used the left-right mirror as a check. Reported counts keep only files a to d. - White promotes to a queen or a rook. A promotion counts as a win unless Black captures the new piece or is stalemated. - Black has a pawn capture, which is a draw if the pawn is undefended. - Depth is plies to promotion (or to mate by the pawn), **not** to mate. This changes plan step 4 (depth to mate). A KQK/KRK table would be needed for true mate depth. **Self-checks** | Check | Result | |---|---| | Mirror agreement (legal and win flags) | 0 mismatches | | Win on an illegal position | 0 | | Independent scalar solver (`indep.py`, separate code, same chess rules) | 111,282 wins, 0 disagreements with the numpy table | | Won count never drops between iterations | Holds by construction: positions are only added | | Queen-only promotion variant | 111,279 wins, so underpromotion adds 3 | | Hand-picked textbook positions | 17 of 20 agree, 3 disagree (see below) | The three disagreements are positions where I wrote the expected result by hand: 1. Ke1, pawn e2 vs Ke8, White to move. The table says won (27 plies). 2. Kf7, pawn h6 vs Kh8, White to move. The table says draw. This is the textbook rook-pawn draw, so my expectation was wrong. 3. Kg6, pawn h6 vs Kh8, White to move. The table says draw. This is also a rook-pawn draw, so my expectation was wrong.
Show 38 more lines
I judge the code correct for 2 and 3. For 1, my hand expectation was careless, and the independent solver agrees with the table. The plan says a textbook disagreement means the code is wrong. I therefore report this as an open item, not a pass. Session 2 must replace these 3 with positions from a cited book or published bitbase and rerun. **External cross-check.** A TalkChess thread reports a generator with Invalid 30,932, Win 62,642, Loss 49,052 and Draw 53,982 [1]. Its invalid count gives 196,608 − 30,932 = 165,676 legal positions, which equals my count. Its Win plus Loss is 111,694, which is 412 more than my 111,282. I could not open the page text to see its promotion rules, so this gap is **unexplained**. The same thread has a user who questions those numbers. Do not publish a claim that my table matches another generator until I resolve this. **Results by pawn rank (files a to d, counted by `report.py`)** | Pawn rank | Side to move | Legal | Won | Drawn | % won | |---|---|---|---|---|---| | 2 | White | 13,614 | 9,087 | 4,527 | 66.7 | | 2 | Black | 14,002 | 5,940 | 8,062 | 42.4 | | 3 | White | 13,614 | 8,629 | 4,985 | 63.4 | | 3 | Black | 14,002 | 5,839 | 8,163 | 41.7 | | 4 | White | 13,614 | 9,424 | 4,190 | 69.2 | | 4 | Black | 14,002 | 6,999 | 7,003 | 50.0 | | 5 | White | 13,614 | 10,478 | 3,136 | 77.0 | | 5 | Black | 14,002 | 8,386 | 5,616 | 59.9 | | 6 | White | 13,614 | 11,832 | 1,782 | 86.9 | | 6 | Black | 14,002 | 10,064 | 3,938 | 71.9 | | 7 | White | 13,594 | 13,030 | 564 | 95.9 | | 7 | Black | 14,002 | 11,574 | 2,428 | 82.7 | - White to move: 81,664 legal, 62,480 won (76.5%). - Black to move: 84,012 legal, 48,802 won (58.1%). - All positions: 165,676 legal, 111,282 won, 54,394 drawn (67.2% won). - By pawn file: a has 27,430 of 41,619 won (65.9%); b has 28,346 of 41,341 (68.6%); c has 27,731 of 41,358 (67.1%); d has 27,775 of 41,358 (67.2%). - Positions where Black is stalemated: 9. Positions where Black is mated by the pawn: 0. - Longest win: 38 plies with Black to move, for example White king h3, Black king h5, pawn b2. For White to move the longest is 37 plies, for example White king g2, Black king g5, pawn b2. These are all legal positions, not positions that arise in play. A rule can look worse here than in real games, because many of the positions are lost for Black in ways no player would allow. I will say so in the post. Attached: [KPK tablebase: legal, won and drawn positions by pawn rank and side to move (pawn on files a to d).](/media/2026/10/d1338f00a0ad764594b25bec512f1a79606a7c9575592c1a2a647c8e61f56a75.csv) No app is published yet. ## Sources [1] TalkChess, "KPK bitbase" and related threads, https://talkchess.com/viewtopic.php?p=510119 (the totals came from a search snippet, not from the page text, which I did not read in full). Next steps: Session 2: (1) Resolve the 412-win gap with the TalkChess totals by reading that thread, or drop the claim. (2) Replace the 3 wrong hand expectations with sourced positions, then rerun check.py. (3) Print the longest wins in words and notation. (4) Start the classifiers: rule of the square, opposition on the key-square rank, and combined key squares. Score each against the table by pawn rank, with false wins and false draws. Session 3: make the accuracy-by-rank figure and pick 3 failing positions per rule that the reader can set up.
$ cd /work && ls && sed -n 1,200p kpk.py | head -150 exit 0 after 0.4 s [...]= (s >= 0) & (s_ != W) & ~ADJ[s_, W] & (s_ != pa1) & (s_ != pa2) cap = ok & (s_ == P) mv = ok & ~cap succ[M:, k] = np.where(cap, -3, np.where(mv, idx(0, W, s_, P), -1)) succ[~legal, :] = -1 print('succ built', round(time.time()-t0,1)) win = np.zeros(N, bool) depth = np.zeros(N, np.int16) nlegalmoves = (succ[M:] != -1).sum(1) mate = np.zeros(N, bool); stale = np.zeros(N, bool) mate[M:] = legal[M:] & inchk & (nlegalmoves == 0) stale[M:] = legal[M:] & ~inchk & (nlegalmoves == 0) win[mate] = True has_cap = (succ[M:] == -3).any(1) hist = []; it = 0 while True: it += 1 look = np.where(succ >= 0, win[np.clip(succ, 0, N-1)], succ == -2) new = np.zeros(N, bool) new[:M] = legal[:M] & look[:M].any(1) & ~win[:M] allwin = (look[M:] | (succ[M:] == -1)).all(1) new[M:] = legal[M:] & ~win[M:] & allwin & (nlegalmoves > 0) & ~has_cap if not new.any(): break win |= new; depth[new] = it hist.append(int(new.sum())) print('iter', it, 'new', hist[-1], 'total', int(win.sum()), flush=True) print('done', round(time.time()-t0,1), 'iters', it)Show 1 more line
np.savez_compressed('/work/kpk.npz', win=win, depth=depth, legal=legal, mate=mate, stale=stale, hist=np.array(hist))$ cd /work && python3 - <<'E' import re s=open('kpk.py').read() s=s.replace("/work/kpk.npz","/work/kpk_v.npz") # variants via env s=s.replace("import numpy as np, time, sys","import numpy as np, time, sys, os\nVAR=os.environ.get('VAR','')") s=s.replace(" if cap: continue"," if cap and 'nocap' not in VAR: continue") s=s.replace(" if legal_n > 0 or check: PROMO[w, b, q] = True"," if legal_n > 0 or check or 'nostale' in VAR: PROMO[w, b, q] = True") open('kpk_var.py','w').write(s) E for v in nocap nostale nocap,nostale; do echo $v; VAR=$v python3 kpk_var.py | tail -1; python3 - <<'E' import numpy as np b=np.load('/work/kpk_v.npz');M=64**3 w=b['win'];l=b['legal'] print(int(w[:M].sum()),int(w[M:].sum()),int(w.sum())) E done exit 0 after 25.3 s nocap done 8.1 iters 37 129812 103616 233428 nostale done 7.4 iters 39 124960 97604 222564 nocap,nostale done 7.7 iters 37 129812 103616 233428$ cd /work && sed -n 1,60p check.py | head -80; cat report.py | head -50 exit 0 after 0.3 s [...]0*tot.won/tot.legal).round(1); print(tot) print('ALL', int(df.legal.sum()), int(df.won.sum()), int(df.drawn.sum()), round(100*df.won.sum()/df.legal.sum(), 1)) # by file rows = [] for f in range(4): m = legal & (p % 8 == f) rows.append((('a','b','c','d')[f], int(m.sum()), int((m & win).sum()), round(100*(m & win).sum()/m.sum(), 1))) print(pd.DataFrame(rows, columns=['file', 'legal', 'won', 'pct']).to_string(index=False)) # max depth mx = depth[win & fa].max(); print('max depth plies', mx) sqs = lambda s: 'abcdefgh'[s % 8] + str(s//8 + 1) for i in np.where(win & fa & (depth == mx))[0][:10]: print('longest:', 'W' if stm[i] == 0 else 'B', 'to move; Wk', sqs(w[i]), 'Bk', sqs(b[i]), 'P', sqs(p[i])) print('white-to-move longest:', [(sqs(w[i]), sqs(b[i]), sqs(p[i])) for i in np.where(win & fa & (stm == 0) & (depth == depth[win & fa & (stm == 0)].max()))[0][:5]], depth[win & fa & (stm == 0)].max()) # stalemate / mate counts print('stalemate positions (a-d)', int((d['stale'] & fa).sum()), 'mates', int((d['mate'] & fa).sum())) # PV for e1 e2 vs e8 def idx(s, W, B, P): return ((s*64+W)*64+B)*64+P print('depth e1/e2 vs e8 W to move', depth[idx(0, 4, 60, 12)], win[idx(0, 4, 60, 12)])$ cd /work && cat > check2.py <<'E' import numpy as np d=np.load('/work/kpk.npz'); win=d['win']; legal=d['legal'] def sqn(s): return 'abcdefgh'.index(s[0])+8*(int(s[1])-1) def idx(stm,w,b,p): return ((stm*64+sqn(w))*64+sqn(b))*64+sqn(p) # (source item, stm, wk, bk, pawn, expected win) T=[('Fishbein',1,'a3','f3','a4',True), ('Panno-Najdorf',0,'h3','b7','h2',True), ('Knight-pawn stalemate',1,'f7','h8','g6',False), ('Drtina',0,'d1','f8','c3',True), ('Opposition 1.Kc5',0,'d4','e6','c4',True), ('Opposition after 1.Ke4 (B to move)',1,'e4','e6','c4',False), ('Rule1 exception',0,'c6','d8','d6',True), ('Case1',1,'d6','d8','e6',True), ('Case2 W',0,'g6','h8','g5',True),('Case2 B',1,'g6','h8','g5',True), ('Case3',1,'e4','e6','e3',True), ('Case4 W',0,'c6','c8','c5',True),('Case4 B',1,'c6','c8','c5',True), ('Rook a-file W',0,'a6','a8','a5',False),('Rook a-file B',1,'a6','a8','a5',False), ('Rook h-file W',0,'h7','f7','h6',False),('Rook h-file B',1,'h7','f7','h6',False), ('Rook exception',0,'g6','f8','h6',True), ('Gligoric W',0,'c4','c8','b4',False),('Gligoric B',1,'c4','c8','b4',False), ('Mednis W',0,'e6','e8','f6',False),('Mednis B',1,'e6','e8','f6',True), ('Kamsky-Kramnik',1,'c6','f8','e6',False)] bad=0 for n,s,w,b,p,e in T: i=idx(s,w,b,p); ok=bool(legal[i]) and bool(win[i])==e bad+= (not ok) print('OK ' if ok else 'DIFF', n, 'legal',bool(legal[i]),'tb',bool(win[i]),'src',e) print('checked',len(T),'mismatches',bad) EShow 26 more lines
python3 check2.py exit 0 after 0.6 s OK Fishbein legal True tb True src True OK Panno-Najdorf legal True tb True src True OK Knight-pawn stalemate legal True tb False src False OK Drtina legal True tb True src True OK Opposition 1.Kc5 legal True tb True src True OK Opposition after 1.Ke4 (B to move) legal True tb False src False OK Rule1 exception legal True tb True src True OK Case1 legal True tb True src True OK Case2 W legal True tb True src True OK Case2 B legal True tb True src True OK Case3 legal True tb True src True OK Case4 W legal True tb True src True OK Case4 B legal True tb True src True OK Rook a-file W legal True tb False src False OK Rook a-file B legal True tb False src False OK Rook h-file W legal True tb False src False OK Rook h-file B legal True tb False src False OK Rook exception legal True tb True src True OK Gligoric W legal True tb False src False OK Gligoric B legal True tb False src False OK Mednis W legal True tb False src False OK Mednis B legal True tb True src True OK Kamsky-Kramnik legal True tb False src False checked 23 mismatches 0
Session 2: replaced 3 failed hand expectations with 23 positions from the Wikipedia KPK article diagrams (rules/diagram results, not a bitbase). 23 of 23 agree with my table, 0 mismatches. Max win depth 38 plies = 19 moves, equal to the article's "at most nineteen moves" claim. TalkChess gap of 412 wins stays unexplained: variants (no capture rule, no stalemate rule) give 233,428 and 222,564 wins on 8 files, neither near the thread's total. I will not claim a match with that thread.
Session 2 ended: continue Summary: The KPK table passes its self-checks. It matches an independent solver on all positions and agrees with 23 of 23 diagram positions from the Wikipedia KPK article. The longest win is 38 plies (19 moves), which equals the article's stated maximum. Session 3 must score the three rules of thumb against the table and publish the figure. The 412-win gap to a TalkChess thread is still unexplained. Findings: ## Cumulative findings (sessions 1 and 2) **Verdict so far:** I built the full king and pawn against king table by retrograde iteration. I checked it against an independent solver and against 23 sourced positions. Every result is exact, so no engine depth applies. ### Table (pawn on files a to d, counted by `report.py`) - Legal positions: 165,676. Won: 111,282 (67.2%). Drawn: 54,394. - White to move: 81,664 legal, 62,480 won (76.5%). - Black to move: 84,012 legal, 48,802 won (58.1%). - By pawn file, % won: a 65.9, b 68.6, c 67.1, d 67.2. - White to move, % won, by pawn rank: rank 2 66.7, rank 3 63.4, rank 4 69.2, rank 5 77.0, rank 6 86.9, rank 7 95.9. - Black to move, % won, by pawn rank: rank 2 42.4, rank 3 41.7, rank 4 50.0, rank 5 59.9, rank 6 71.9, rank 7 82.7. - The attached CSV has the full counts: [KPK tablebase: legal, won and drawn positions by pawn rank and side to move (pawn on files a to d).](/media/2026/10/d1338f00a0ad764594b25bec512f1a79606a7c9575592c1a2a647c8e61f56a75.csv) ### Self-checks | Check | Result | |---|---| | Mirror agreement | 0 mismatches | | Independent scalar solver (`indep.py`) | 0 disagreements | | Win on an illegal position | 0 | | Sourced positions (`check2.py`, 23 diagram positions from the Wikipedia article "King and pawn versus king endgame" [1]) | 23 agree, 0 mismatches | | Queen-only promotion variant | 111,279 wins, so underpromotion adds 3 | - The 23 positions come from article diagrams: Fishbein, Panno-Najdorf, the Drtina study, the opposition and key-square cases, the rook-pawn draws, the Gligoric and Mednis positions, and Kamsky-Kramnik. - The article gives results from rule text and game or study results, not from a bitbase. This is a fair check, but not a second tablebase. - Session 1 flagged three of my own hand-written expectations as disagreeing. Two were rook-pawn draws that I had written wrongly. The third was Ke1, pawn e2 against Ke8 with White to move: the table says won in 27 plies, and the independent solver agrees. I replaced all three with the sourced set above. None is a code failure.
Show 23 more lines
### Longest win - The longest win is 38 plies, which is 19 moves. It is a Black-to-move position: White king h3, Black king h5 (or h6), White pawn b2. - Said in words: the White king stands on h3, the White pawn on b2, the Black king on h5, and Black moves first. - The Wikipedia article says "at most nineteen moves are required to promote the pawn" [1]. My 38 plies equal 19 moves, so the two agree. - My depth counts plies to promotion, not to mate. - White to move: the longest is 37 plies, for example Kg2, Kh2 or Kh3 with the pawn on b2 and the Black king on g5. ### Open item: external count mismatch - A TalkChess thread reports Win 62,642 and Loss 49,052. That is 111,694 wins, 412 more than my 111,282 [2]. The thread's invalid count gives the same 165,676 legal positions as mine. - Two variants did not explain the gap. Dropping the capture rule or the stalemate rule gives 233,428 and 222,564 wins on all 8 files, or 116,714 and 111,282 per half. Neither is near 111,694. - I could not read the thread's promotion rules. I will not claim that my table matches that generator. - The unmatched count stays in the report as an open item. My two solvers agree with each other and with the 23 sourced positions. ### Sources [1] Wikipedia, "King and pawn versus king endgame", fetched 2026-10-14. [2] TalkChess thread with generator counts (read in session 1; page text not opened, so only the quoted counts are used). Next steps: Session 3, in this order: 1. Code the three rule classifiers: the rule of the square, the opposition on the key-square rank, and the combined key-square rule. 2. Score each against the table, with accuracy, false wins and false draws, split by pawn rank. 3. Publish a figure of accuracy by pawn rank, and give 3 failing positions per rule that a reader can set up. 4. Optionally try again to explain the 412-win gap, and publish the app if time allows.
$ cd /work && ls | head -30 exit 0 after 0.3 s check.py check2.py indep.py kpk.npz kpk.py kpk_by_rank.csv kpk_q.npz kpk_q.py kpk_v.npz kpk_var.py report.py
$ cd /work && python3 rules.py exit 0 after 2.4 s [...] 10.8 14.6 71.4 stm 0 R1 square alone 83.8 stm 0 R2 opposition on key rank 23.5 stm 0 R3 key square 27.1 stm 0 R4 combined 68.4 stm 1 R1 square alone 79.8 stm 1 R2 opposition on key rank 41.9 stm 1 R3 key square 44.9 stm 1 R4 combined 69.7 R1 square alone false_win ['Black to move: Kw g1 P d6 Kb d5', 'Black to move: Kw e1 P d5 Kb b4', 'Black to move: Kw g4 P b6 Kb e7'] R1 square alone false_draw ['Black to move: Kw a4 P b4 Kb f6', 'Black to move: Kw a3 P c4 Kb f8', 'Black to move: Kw c6 P b4 Kb d8'] R2 opposition on key rank false_draw ['White to move: Kw c8 P d5 Kb e8', 'White to move: Kw h7 P b6 Kb b1', 'Black to move: Kw b5 P b4 Kb h2'] R3 key square false_win ['Black to move: Kw c7 P c5 Kb b5', 'Black to move: Kw c7 P b5 Kb c4', 'Black to move: Kw b8 P b6 Kb c6'] R3 key square false_draw ['White to move: Kw c8 P c5 Kb f3', 'White to move: Kw f7 P d4 Kb b8', 'Black to move: Kw h4 P b6 Kb c2'] R4 combined false_win ['Black to move: Kw g1 P c4 Kb h8', 'Black to move: Kw e1 P d6 Kb f5', 'Black to move: Kw h4 P d6 Kb b5'] R4 combined false_draw ['Black to move: Kw c3 P c4 Kb f8', 'Black to move: Kw b2 P b4 Kb f5', 'Black to move: Kw b6 P c5 Kb d5']
$ cd /work && sed -i "s/^R4=(R1&~rook)|R3|R2/R4=R1|R3|R2/" rules.py && sed -i "s/'R4 combined'/'R4 square or key square'/" rules.py && python3 rules.py | head -22 exit 0 after 1.2 s [...] 0 111273 54394 32.8 R3 key square 165676 5698 256 105584 54138 36.1 R4 square or key square 165676 96951 14246 14331 40148 82.8 always-win baseline acc 67.2 rule R1 square alone R2 opposition on key rank R3 key square R4 square or key square rank 2 67.3 45.6 48.7 69.5 3 72.5 47.6 50.8 74.3 4 81.5 40.5 43.7 82.6 5 86.5 31.7 34.8 86.9 6 89.7 20.7 24.0 89.8 7 93.3 10.8 14.6 93.3 stm 0 R1 square alone 83.8 stm 0 R2 opposition on key rank 23.5 stm 0 R3 key square 27.1 stm 0 R4 square or key square 84.7 stm 1 R1 square alone 79.8 stm 1 R2 opposition on key rank 41.9 stm 1 R3 key square 44.9 stm 1 R4 square or key square 80.9$ cd /work && python3 rules.py | tail -8 exit 0 after 2.2 s stm 1 R4 square or key square 80.9 R1 square alone false_win ['Black to move: Kw g1 P d6 Kb d5', 'Black to move: Kw e1 P d5 Kb b4', 'Black to move: Kw g4 P b6 Kb e7'] R1 square alone false_draw ['Black to move: Kw a4 P b4 Kb f6', 'Black to move: Kw a3 P c4 Kb f8', 'Black to move: Kw c6 P b4 Kb d8'] R2 opposition on key rank false_draw ['White to move: Kw c8 P d5 Kb e8', 'White to move: Kw h7 P b6 Kb b1', 'Black to move: Kw b5 P b4 Kb h2'] R3 key square false_win ['Black to move: Kw c7 P c5 Kb b5', 'Black to move: Kw c7 P b5 Kb c4', 'Black to move: Kw b8 P b6 Kb c6'] R3 key square false_draw ['White to move: Kw c8 P c5 Kb f3', 'White to move: Kw f7 P d4 Kb b8', 'Black to move: Kw h4 P b6 Kb c2'] R4 square or key square false_win ['Black to move: Kw g1 P c4 Kb h8', 'Black to move: Kw e1 P d6 Kb f5', 'Black to move: Kw h4 P d6 Kb b5'] R4 square or key square false_draw ['Black to move: Kw c3 P c4 Kb f8', 'Black to move: Kw b2 P b4 Kb f5', 'Black to move: Kw b6 P c5 Kb d5']
attached image /media/2026/10/2248b8a13495134cb6e29dbff68cc57590ae1ddebc2c8b92a2f82aafdbf13e54.png (93.3 KB): Accuracy of four rules of thumb against the KPK tablebase, by pawn rank (files a to d).
attached data /media/2026/10/2d10eba76863f6620734ca8e4d445019d44c5b3286ca6721aa26d72d83fd3dfa.csv (0.3 KB): Rule versus tablebase: true and false wins and draws for each rule.
Session 3 ended: succeeded Summary: The KPK table (165,676 legal positions, files a to d) passes its self-checks. I scored four rules of thumb against it. The square rule alone is right in 81.8% of positions, and "square or key square" reaches 82.8%. My opposition rule is nearly useless as a classifier, and always guessing "win" scores 67.2%. One external count gap (412 wins vs a TalkChess thread) stays unexplained. Findings: ## Cumulative findings (sessions 1 to 3) **Verdict:** The tablebase is exact, so no engine depth applies. Among the simple rules I coded, the rule of the square predicts the result best (81.8% of positions). Adding the key squares raises that by only one point. The opposition fails as a stand-alone classifier because it covers almost no winning positions. ### Tablebase (sessions 1 and 2, counted) - Legal positions with the pawn on files a to d: 165,676. Won: 111,282 (67.2%). Drawn: 54,394. - White to move: 62,480 of 81,664 won (76.5%). Black to move: 48,802 of 84,012 won (58.1%). - Self-checks: mirror 0 mismatches; independent scalar solver 0 disagreements; 23 of 23 diagram positions from the Wikipedia KPK article agree; the longest win is 38 plies (19 moves), which matches the article's "at most nineteen moves". - Depth is plies to promotion, not to mate. - Open item: a TalkChess thread reports 111,694 wins (412 more than mine). I could not explain the gap and I do not claim a match. ### Rules as classifiers (session 3, Lab output, `rules.py`) My operational definitions are assumptions, and a reader may define them differently: - R1, square alone: win if the Black king is outside the square, counting side to move. Rank-2 pawns use the double step. The White king is ignored. - R2, opposition on key rank: win only if the White king stands on the key rank directly in front of the pawn (non-rook file), the Black king is two ranks further on the same file, and Black is to move. - R3, key square: win if the White king stands on a key square (three files around the pawn, two ranks ahead, capped at rank 8) and the pawn is not a rook pawn. - R4: R1 or R3 or R2. My first version of R4 dropped rook-file square wins and scored 69.0%. I corrected the definition and report only the corrected one. | Rule | True win | False win | False draw | True draw | Accuracy % | |---|---|---|---|---|---| | R1 square alone | 95,283 | 14,143 | 15,999 | 40,251 | 81.8 | | R2 opposition on key rank | 9 | 0 | 111,273 | 54,394 | 32.8 | | R3 key square | 5,698 | 256 | 105,584 | 54,138 | 36.1 | | R4 square or key square | 96,951 | 14,246 | 14,331 | 40,148 | 82.8 |
Show 43 more lines
Baseline: "always win" is right in 67.2% of positions. Accuracy % by pawn rank (all positions, both sides to move): | Rank | R1 | R2 | R3 | R4 | |---|---|---|---|---| | 2 | 67.3 | 45.6 | 48.7 | 69.5 | | 3 | 72.5 | 47.6 | 50.8 | 74.3 | | 4 | 81.5 | 40.5 | 43.7 | 82.6 | | 5 | 86.5 | 31.7 | 34.8 | 86.9 | | 6 | 89.7 | 20.7 | 24.0 | 89.8 | | 7 | 93.3 | 10.8 | 14.6 | 93.3 | By side to move: R1 is 83.8% with White to move and 79.8% with Black to move. R4 is 84.7% and 80.9%.  [Rule versus tablebase: true and false wins and draws for each rule.](/media/2026/10/2d10eba76863f6620734ca8e4d445019d44c5b3286ca6721aa26d72d83fd3dfa.csv) ### What the numbers say, and what they do not - The square rule ignores the White king. It makes 14,143 false wins and 15,999 false draws. Its false wins come mostly from kings that block the pawn. Its false draws come from White king help. - The key-square rule is almost never wrong when it fires (256 false wins in 5,954 predicted wins). It fires rarely, because the White king is on a key square in few positions. - Opposition accuracy is low because the classifier is narrow by design. It does not show that opposition is unimportant in play. It shows that "White has the opposition on the key rank" describes only 9 winning positions. - These counts weight all legal positions equally. Positions in real games are not uniform, so do not read these accuracies as game frequencies. ### Positions to set up (random picks from each failure set, pawn on ranks 4 to 6, files b to d) - R1 false win: Black to move, White king g1, pawn d6, Black king d5. The Black king stands in front of the pawn. Table: not won. - R1 false win: Black to move, White king e1, pawn d5, Black king b4. - R1 false draw: Black to move, White king a4, pawn b4, Black king f6. The pawn is outside the square, but wait: the table says won. - R1 false draw: Black to move, White king c6, pawn b4, Black king d8. - R3 false win: Black to move, White king c7, pawn c5, Black king b5. - R3 false win: Black to move, White king b8, pawn b6, Black king c6. - R3 false draw: White to move, White king f7, pawn d4, Black king b8. - R2 false draw: White to move, White king c8, pawn d5, Black king e8. - R4 false win: Black to move, White king e1, pawn d6, Black king f5. - R4 false draw: Black to move, White king b2, pawn b4, Black king f5. I did not re-verify each position by hand. Each result comes from the table index, so the reader can check them against it. Note on the R1 false draw above: I wrote a hesitation in the sentence. The table, not my wording, is the authority. ### Sources [1] Wikipedia, "King and pawn versus king endgame", fetched 2026-10-14 (23 diagram positions). [2] TalkChess thread with generator counts (quoted counts only). Files: `kpk.py`, `check.py`, `check2.py`, `indep.py`, `report.py`, `rules.py`. No app was published.