FA-82836 / Chess move legality / Open access

Replay always starts with white · case 01

A move list beginning with black's move is rejected at index 0.

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

ROOT CAUSE

The replay ignores the given side to move and starts with white.

VERIFIED REPAIR

Initialize the side to move from the input.

Unsuccessful approach: Comparing against upper-case "W" never matches the lower-case turn field.

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=True
    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),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    '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),
  ('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)],
 [('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)],
 [('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),
  ('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),
  ('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),
  ('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	`0`	`-1`	Failed
captured piece moves	`1`	`1`	Passed
capture own piece	`0`	`0`	Passed
empty origin	`0`	`0`	Passed
vacated square reused	`2`	`2`	Passed
capture then recapture	`-1`	`-1`	Passed

SHA-256 / 35a1ec6417243b182e59d556d6733948d03fc275e4b7d3afb6ee0489e49b6acb

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: 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),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    '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),
  ('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)],
 [('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)],
 [('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),
  ('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),
  ('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),
  ('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	`0`	`-1`	Failed
white moves twice	`0`	`1`	Failed
black to start	`-1`	`-1`	Passed
captured piece moves	`0`	`1`	Failed
capture own piece	`0`	`0`	Passed
empty origin	`0`	`0`	Passed
vacated square reused	`0`	`2`	Failed
capture then recapture	`0`	`-1`	Failed

SHA-256 / 74481009c5c8b642f17e60fc6ab873ba5aaf4b31bce93ca18f8f0eb93ef855ea

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),
  ('capture then recapture',
   {'board': {'d5': 'p', 'd8': 'q', 'e1': 'K', 'e4': 'P', 'e8': 'k'},
    'moves': [['e4', 'd5'], ['d8', 'd5']],
    '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),
  ('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)],
 [('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)],
 [('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),
  ('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),
  ('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),
  ('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
capture then recapture	`-1`	`-1`	Passed

SHA-256 / 06c1d2e82bd23240b28575ba64e072ededfc59f296cdf1c51d4f8b5e3d1920d0

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.923612+00:00.

Case digest / 9c520bb4116f4ddc813f9512243da67954f9fd3b5ea4dbc6970552f2cacbc4e9