FA-82816 / Chess move legality / Open access

Side to move never passes · case 01

Black's reply is rejected as an out-of-turn move.

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

ROOT CAUSE

The turn flag is not toggled after each move.

VERIFIED REPAIR

Flip the side to move after every accepted move.

Unsuccessful approach: Setting the flag from the initial turn flips once and then sticks.

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)
        if q is not None and q.isupper()==white: return i
        del b[fr]
        b[to]=p
        pass
    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),
  ('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),
  ('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)],
 [('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),
  ('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),
  ('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`	Failed
white moves twice	`-1`	`1`	Failed
black to start	`1`	`-1`	Failed
captured piece moves	`-1`	`1`	Failed
capture own piece	`0`	`0`	Passed
empty origin	`0`	`0`	Passed
black captures own	`1`	`1`	Passed
four clean moves	`1`	`-1`	Failed

SHA-256 / ff06f79547d5764d89e65e6901751adea670d6e9f489f91a7a7f35b7b0266221

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=x['turn']!='w'
    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),
  ('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),
  ('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)],
 [('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),
  ('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),
  ('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
black captures own	`1`	`1`	Passed
four clean moves	`2`	`-1`	Failed

SHA-256 / ebff1c8206574f3f22b03ad05178d77befce4605cef74d99b3dd2e0e344f299c

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),
  ('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),
  ('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)],
 [('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),
  ('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),
  ('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
black captures own	`1`	`1`	Passed
four clean moves	`-1`	`-1`	Passed

SHA-256 / 865790bcc09888f6f92ae7a0122bdd99e3fae9f3efdf4cf23d6a1079f4610357

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

Case digest / 306d8b7884b2cfe8db60a3cba88494f1affb45b9d3bdae8024f4012e924db587