FA-82826 / Chess move legality / Open access

Self-capture accepted in replay · case 01

A queen may land on its own pawn.

Verified by executionVariant 1 · 8 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

The destination is never checked for a piece of the mover's colour.

VERIFIED REPAIR

Reject moves that land on a piece of the mover's own colour.

Unsuccessful approach: Rejecting only captures of one's own king still allows other self-captures.

Case contract

Input: {"board", "turn": "w" or "b", "moves": [[from, to], ...]}. Replay the moves; return the index of the first move that starts from an empty square, moves a piece of the side not to move, or lands on a piece of its own colour; return -1 if all pass. Each move replaces any piece on the destination and passes the turn.

Why this case matters

Game servers must reject out-of-turn and self-capturing moves in submitted move lists.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(x):
    b=dict(x['board']); white=x['turn']=='w'
    for i,(fr,to) in enumerate(x['moves']):
        p=b.get(fr)
        if p is None or p.isupper()!=white: return i
        q=b.get(to)
        pass
        del b[fr]
        b[to]=p
        white=not white
    return -1
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1)],
 [('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
clean sequence	`-1`	`-1`	Passed
white moves twice	`1`	`1`	Passed
black to start	`-1`	`-1`	Passed
captured piece moves	`1`	`1`	Passed
capture own piece	`-1`	`0`	Failed
empty origin	`0`	`0`	Passed
vacated square reused	`2`	`2`	Passed
black captures own	`-1`	`1`	Failed

SHA-256 / 09884f6c4444bdaad7cad1362a3ba6fa3b1ae025ead54d341a6be2474c770a10

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(x):
    b=dict(x['board']); white=x['turn']=='w'
    for i,(fr,to) in enumerate(x['moves']):
        p=b.get(fr)
        if p is None or p.isupper()!=white: return i
        q=b.get(to)
        if q is not None and q.isupper()==white and q.upper()=='K': return i
        del b[fr]
        b[to]=p
        white=not white
    return -1
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1)],
 [('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
clean sequence	`-1`	`-1`	Passed
white moves twice	`1`	`1`	Passed
black to start	`-1`	`-1`	Passed
captured piece moves	`1`	`1`	Passed
capture own piece	`-1`	`0`	Failed
empty origin	`0`	`0`	Passed
vacated square reused	`2`	`2`	Passed
black captures own	`-1`	`1`	Failed

SHA-256 / f78cae0cd283bca3cdbae16925b9d889fb2112db7e25877e788557c0114a644c

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(x):
    b=dict(x['board']); white=x['turn']=='w'
    for i,(fr,to) in enumerate(x['moves']):
        p=b.get(fr)
        if p is None or p.isupper()!=white: return i
        q=b.get(to)
        if q is not None and q.isupper()==white: return i
        del b[fr]
        b[to]=p
        white=not white
    return -1
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)],
 [('clean sequence',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['e7', 'e5']],
    'turn': 'w'},
   -1),
  ('white moves twice',
   {'board': {'d2': 'P', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e4'], ['d2', 'd4']],
    'turn': 'w'},
   1),
  ('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1)],
 [('black to start',
   {'board': {'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e7', 'e5'], ['e2', 'e4']],
    'turn': 'b'},
   -1),
  ('captured piece moves',
   {'board': {'d1': 'Q', 'd8': 'q', 'e1': 'K', 'e8': 'k'},
    'moves': [['d1', 'd8'], ['d8', 'd1']],
    'turn': 'w'},
   1),
  ('capture own piece',
   {'board': {'d1': 'Q', 'd2': 'P', 'e1': 'K', 'e8': 'k'}, 'moves': [['d1', 'd2']], 'turn': 'w'},
   0),
  ('empty origin', {'board': {'e1': 'K', 'e8': 'k'}, 'moves': [['e2', 'e4']], 'turn': 'w'}, 0),
  ('vacated square reused',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['g1', 'h3']],
    'turn': 'w'},
   2),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    'turn': 'w'},
   -1),
  ('black captures own',
   {'board': {'d8': 'q', 'e1': 'K', 'e2': 'P', 'e7': 'p', 'e8': 'k'},
    'moves': [['e2', 'e3'], ['d8', 'e7']],
    'turn': 'w'},
   1),
  ('four clean moves',
   {'board': {'e1': 'K', 'e8': 'k', 'g1': 'N', 'g8': 'n'},
    'moves': [['g1', 'f3'], ['g8', 'f6'], ['f3', 'g1'], ['f6', 'g8']],
    'turn': 'w'},
   -1)]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
clean sequence	`-1`	`-1`	Passed
white moves twice	`1`	`1`	Passed
black to start	`-1`	`-1`	Passed
captured piece moves	`1`	`1`	Passed
capture own piece	`0`	`0`	Passed
empty origin	`0`	`0`	Passed
vacated square reused	`2`	`2`	Passed
black captures own	`1`	`1`	Passed

SHA-256 / 041e75baa563922647d474ed330b3ad6ebf2e3d14e5fb51b406613eaa5ff6333

Verification & scope

A deterministic toy model with an explicitly stated contract; boards are {square: piece} with white upper-case and black lower-case pieces; no claim of full FIDE Laws conformance. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:50:15.789418+00:00.

Case digest / fbf913f213afd8eecf759a94c712682d3306f10b6a832d9ee687c3c0a889708c