FAILURE MAP
← Case archive

FA-37296 / Table interactions / Open access

Table clipboard paste mapping: start row identity · case 01

The table start row identity result violates the stipulated table clipboard paste mapping contract.

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

ROOT CAUSE

The start row identity decision uses 'ri=0' instead of 'ri=rows.index(start[0])'.

VERIFIED REPAIR

Apply the complete start row identity rule: ri=rows.index(start[0]).

Unsuccessful approach: The attempted repair 'ri=max(0,rows.index(start[0])-1)' still loses a required part of the table contract.

Case contract

Paste maps source offsets to visible table coordinates starting at a stable cell; source raggedness is retained, table edges clip, readonly holes consume coordinates but not patch capacity, raw values remain unchanged, and truncation means an additional writable patch was omitted.

Why this case matters

An offline table UI model isolates table clipboard paste mapping, including adversarial row/column relationships.

1 / The failure

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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=0; ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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 fixtureActualExpectedOutcome
offset rectangular paste{'patches': [['r0', 'b', 1], ['r0', 'c', 2], ['r1', 'b', 3], ['r1', 'c', 4]], 'rejected': [], 'truncated': False}{'patches': [['r1', 'b', 1], ['r1', 'c', 2], ['r2', 'b', 3], ['r2', 'c', 4]], 'rejected': [], 'truncated': False}Failed
hidden targets{'patches': [['r0', 'c', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}{'patches': [['r0', 'c', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}Passed
readonly holes{'patches': [['r0', 'b', 2], ['r1', 'a', 3], ['r1', 'b', 4]], 'rejected': [['r0', 'a']], 'truncated': False}{'patches': [['r0', 'b', 2], ['r1', 'a', 3], ['r1', 'b', 4]], 'rejected': [['r0', 'a']], 'truncated': False}Passed
bounded patches{'patches': [['r0', 'b', 2], ['r1', 'a', 3]], 'rejected': [['r0', 'a']], 'truncated': True}{'patches': [['r0', 'b', 2], ['r1', 'a', 3]], 'rejected': [['r0', 'a']], 'truncated': True}Passed
ragged and whitespace{'patches': [['r0', 'a', 0], ['r0', 'b', ' x '], ['r1', 'a', '']], 'rejected': [], 'truncated': False}{'patches': [['r0', 'a', 0], ['r0', 'b', ' x '], ['r1', 'a', '']], 'rejected': [], 'truncated': False}Passed
clipped edges{'patches': [['r0', 'b', 1], ['r1', 'b', 3]], 'rejected': [], 'truncated': False}{'patches': [['r1', 'b', 1]], 'rejected': [], 'truncated': False}Failed
hidden internal{'patches': [['r0', 'a', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}{'patches': [['r0', 'a', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}Passed
budget no locks{'patches': [['r0', 'a', 1]], 'rejected': [], 'truncated': True}{'patches': [['r0', 'a', 1]], 'rejected': [], 'truncated': True}Passed
empty input{'patches': [], 'rejected': [], 'truncated': False}{'patches': [], 'rejected': [], 'truncated': False}Passed

SHA-256 / 89000cc3fa062747d48e3aeb783d4f75fd45b4b4522270df1005f0e9568ff962

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=max(0,rows.index(start[0])-1); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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 fixtureActualExpectedOutcome
offset rectangular paste{'patches': [['r0', 'b', 1], ['r0', 'c', 2], ['r1', 'b', 3], ['r1', 'c', 4]], 'rejected': [], 'truncated': False}{'patches': [['r1', 'b', 1], ['r1', 'c', 2], ['r2', 'b', 3], ['r2', 'c', 4]], 'rejected': [], 'truncated': False}Failed
hidden targets{'patches': [['r0', 'c', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}{'patches': [['r0', 'c', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}Passed
readonly holes{'patches': [['r0', 'b', 2], ['r1', 'a', 3], ['r1', 'b', 4]], 'rejected': [['r0', 'a']], 'truncated': False}{'patches': [['r0', 'b', 2], ['r1', 'a', 3], ['r1', 'b', 4]], 'rejected': [['r0', 'a']], 'truncated': False}Passed
bounded patches{'patches': [['r0', 'b', 2], ['r1', 'a', 3]], 'rejected': [['r0', 'a']], 'truncated': True}{'patches': [['r0', 'b', 2], ['r1', 'a', 3]], 'rejected': [['r0', 'a']], 'truncated': True}Passed
ragged and whitespace{'patches': [['r0', 'a', 0], ['r0', 'b', ' x '], ['r1', 'a', '']], 'rejected': [], 'truncated': False}{'patches': [['r0', 'a', 0], ['r0', 'b', ' x '], ['r1', 'a', '']], 'rejected': [], 'truncated': False}Passed
clipped edges{'patches': [['r0', 'b', 1], ['r1', 'b', 3]], 'rejected': [], 'truncated': False}{'patches': [['r1', 'b', 1]], 'rejected': [], 'truncated': False}Failed
hidden internal{'patches': [['r0', 'a', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}{'patches': [['r0', 'a', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}Passed
budget no locks{'patches': [['r0', 'a', 1]], 'rejected': [], 'truncated': True}{'patches': [['r0', 'a', 1]], 'rejected': [], 'truncated': True}Passed
empty input{'patches': [], 'rejected': [], 'truncated': False}{'patches': [], 'rejected': [], 'truncated': False}Passed

SHA-256 / d13ce500921b9975ae40950bff4de39dd446b1db5a0acf6c3060f48db6214c32

3 / The verified repair

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

N = 1
observations = []
def solve(rows, cols, matrix, start, readonly, hidden, limit):
    targets=[c for c in cols if c not in hidden]
    ri=rows.index(start[0]); ci=targets.index(start[1])
    patches=[]; rejected=[]
    for y,source in enumerate(matrix):
        if ri+y>=len(rows): break
        for x,value in enumerate(source):
            if ci+x>=len(targets): break
            cell=(rows[ri+y],targets[ci+x])
            if cell in readonly: rejected.append(cell); continue
            if len(patches)>=limit: return {'patches':patches,'rejected':rejected,'truncated':True}
            patches.append((cell[0],cell[1],value))
    return {'patches':patches,'rejected':rejected,'truncated':False}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 2:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[2,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 2), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 3:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[3,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 3), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 4:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[4,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 4), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

if N == 5:
    check('offset rectangular paste', solve(['r0','r1','r2','r3'], ['a','b','c','d'], [[5,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 5), ('r1', 'c', 2), ('r2', 'b', 3), ('r2', 'c', 4)], 'rejected': [], 'truncated': False})
    check('hidden targets', solve(['r0','r1'], ['a','b','c','d'], [[1,2,3]], ('r0','c'), [], ['a','b'], 9), {'patches': [('r0', 'c', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('readonly holes', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 9), {'patches': [('r0', 'b', 2), ('r1', 'a', 3), ('r1', 'b', 4)], 'rejected': [('r0', 'a')], 'truncated': False})
    check('bounded patches', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r0','a'), [('r0','a')], [], 2), {'patches': [('r0', 'b', 2), ('r1', 'a', 3)], 'rejected': [('r0', 'a')], 'truncated': True})
    check('ragged and whitespace', solve(['r0','r1'], ['a','b','c'], [[0,' x '],['']], ('r0','a'), [], [], 9), {'patches': [('r0', 'a', 0), ('r0', 'b', ' x '), ('r1', 'a', '')], 'rejected': [], 'truncated': False})
    check('clipped edges', solve(['r0','r1'], ['a','b'], [[1,2],[3,4]], ('r1','b'), [], [], 9), {'patches': [('r1', 'b', 1)], 'rejected': [], 'truncated': False})
    check('hidden internal', solve(['r0'], ['a','b','c','d'], [[1,2,3]], ('r0','a'), [], ['b','c'], 9), {'patches': [('r0', 'a', 1), ('r0', 'd', 2)], 'rejected': [], 'truncated': False})
    check('budget no locks', solve(['r0'], ['a','b'], [[1,2]], ('r0','a'), [], [], 1), {'patches': [('r0', 'a', 1)], 'rejected': [], 'truncated': True})
    check('empty input', solve(['r0'], ['a'], [], ('r0','a'), [], [], 0), {'patches': [], 'rejected': [], 'truncated': False})

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 fixtureActualExpectedOutcome
offset rectangular paste{'patches': [['r1', 'b', 1], ['r1', 'c', 2], ['r2', 'b', 3], ['r2', 'c', 4]], 'rejected': [], 'truncated': False}{'patches': [['r1', 'b', 1], ['r1', 'c', 2], ['r2', 'b', 3], ['r2', 'c', 4]], 'rejected': [], 'truncated': False}Passed
hidden targets{'patches': [['r0', 'c', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}{'patches': [['r0', 'c', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}Passed
readonly holes{'patches': [['r0', 'b', 2], ['r1', 'a', 3], ['r1', 'b', 4]], 'rejected': [['r0', 'a']], 'truncated': False}{'patches': [['r0', 'b', 2], ['r1', 'a', 3], ['r1', 'b', 4]], 'rejected': [['r0', 'a']], 'truncated': False}Passed
bounded patches{'patches': [['r0', 'b', 2], ['r1', 'a', 3]], 'rejected': [['r0', 'a']], 'truncated': True}{'patches': [['r0', 'b', 2], ['r1', 'a', 3]], 'rejected': [['r0', 'a']], 'truncated': True}Passed
ragged and whitespace{'patches': [['r0', 'a', 0], ['r0', 'b', ' x '], ['r1', 'a', '']], 'rejected': [], 'truncated': False}{'patches': [['r0', 'a', 0], ['r0', 'b', ' x '], ['r1', 'a', '']], 'rejected': [], 'truncated': False}Passed
clipped edges{'patches': [['r1', 'b', 1]], 'rejected': [], 'truncated': False}{'patches': [['r1', 'b', 1]], 'rejected': [], 'truncated': False}Passed
hidden internal{'patches': [['r0', 'a', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}{'patches': [['r0', 'a', 1], ['r0', 'd', 2]], 'rejected': [], 'truncated': False}Passed
budget no locks{'patches': [['r0', 'a', 1]], 'rejected': [], 'truncated': True}{'patches': [['r0', 'a', 1]], 'rejected': [], 'truncated': True}Passed
empty input{'patches': [], 'rejected': [], 'truncated': False}{'patches': [], 'rejected': [], 'truncated': False}Passed

SHA-256 / 099cf6cb3aa8ccf917f5678bf8902f8cd24a3b4c2db019db19ee3a78a838ad99

Verification & scope

The start row and visible start column exist; patch capacity is a nonnegative integer. Deterministic offline table UI model; no browser, DOM, framework, or standards conformance is claimed. 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:42:59.771416+00:00.

Case digest / 1b2d8584f10e197d530c5fe6ad04613026807cfbc3f7f560a43b2a3d958fb42b