FAILURE MAP
← Case archive

FA-44361 / Data systems / Open access

Validity follows output position instead of base position · case 01

Validity follows output position instead of base position.

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

ROOT CAUSE

selection-compose: Validity follows output position instead of base position.

VERIFIED REPAIR

Preserve the stated physical representation and operation order: Compose a sliced child selection with its parent selection, gather base values, and consult base validity. Preserve child order and repeated indices; invalid entries produce None.

Unsuccessful approach: Combining both bitmaps incorrectly nulls valid gathered rows.

Case contract

Compose a sliced child selection with its parent selection, gather base values, and consult base validity. Preserve child order and repeated indices; invalid entries produce None.

Why this case matters

A bounded deterministic data engine model makes representation and changelog faults reproducible.

1 / The failure

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

N = 1
observations = []
def solve(d):
    try:
        base,parent,child,valid,start,count=d
        selected=child[start:start+count]
        indices=[parent[i] for i in selected]
        out=[]
        for j,i in enumerate(indices):
            value=base[i]
            known=valid[j] if j<len(valid) else False
            out.append(value if known else None)
        return out
    except (IndexError, KeyError, ValueError, StopIteration) as exc:
        return {"representation_error": type(exc).__name__}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('permuted duplicates', solve([[1, 2, 3], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [3, 1, 3, 2])
    check('nonzero slice', solve([[1, 2, 3], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [3, 1])
    check('validity moves with address', solve([[1, 2, 3], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [3, 1, None])
    check('empty slice', solve([[1], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[1, 2], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[1, 2], [0, 1], [0, 1], [True, True], 0, 2]), [1, 2])
    check('last slot', solve([[1, 2], [1, 0], [1, 0], [True, True], 1, 1]), [2])
elif N == 2:
    check('permuted duplicates', solve([[2, 3, 4], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [4, 2, 4, 3])
    check('nonzero slice', solve([[2, 3, 4], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [4, 2])
    check('validity moves with address', solve([[2, 3, 4], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [4, 2, None])
    check('empty slice', solve([[2], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[2, 3], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[2, 3], [0, 1], [0, 1], [True, True], 0, 2]), [2, 3])
    check('last slot', solve([[2, 3], [1, 0], [1, 0], [True, True], 1, 1]), [3])
elif N == 3:
    check('permuted duplicates', solve([[3, 4, 5], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [5, 3, 5, 4])
    check('nonzero slice', solve([[3, 4, 5], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [5, 3])
    check('validity moves with address', solve([[3, 4, 5], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [5, 3, None])
    check('empty slice', solve([[3], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[3, 4], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[3, 4], [0, 1], [0, 1], [True, True], 0, 2]), [3, 4])
    check('last slot', solve([[3, 4], [1, 0], [1, 0], [True, True], 1, 1]), [4])
elif N == 4:
    check('permuted duplicates', solve([[4, 5, 6], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [6, 4, 6, 5])
    check('nonzero slice', solve([[4, 5, 6], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [6, 4])
    check('validity moves with address', solve([[4, 5, 6], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [6, 4, None])
    check('empty slice', solve([[4], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[4, 5], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[4, 5], [0, 1], [0, 1], [True, True], 0, 2]), [4, 5])
    check('last slot', solve([[4, 5], [1, 0], [1, 0], [True, True], 1, 1]), [5])
elif N == 5:
    check('permuted duplicates', solve([[5, 6, 7], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [7, 5, 7, 6])
    check('nonzero slice', solve([[5, 6, 7], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [7, 5])
    check('validity moves with address', solve([[5, 6, 7], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [7, 5, None])
    check('empty slice', solve([[5], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[5, 6], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[5, 6], [0, 1], [0, 1], [True, True], 0, 2]), [5, 6])
    check('last slot', solve([[5, 6], [1, 0], [1, 0], [True, True], 1, 1]), [6])
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
permuted duplicates[3, 1, 3, None][3, 1, 3, 2]Failed
nonzero slice[3, 1][3, 1]Passed
validity moves with address[3, None, 2][3, 1, None]Failed
empty slice[][]Passed
all null[None, None][None, None]Passed
identity control[1, 2][1, 2]Passed
last slot[2][2]Passed

SHA-256 / 40ec6f6330914c6749d936ca8d618e4a1eacf741fa7447cd4bb9a008c9302b31

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(d):
    try:
        base,parent,child,valid,start,count=d
        selected=child[start:start+count]
        indices=[parent[i] for i in selected]
        out=[]
        for j,i in enumerate(indices):
            value=base[i]
            known=valid[i] and (valid[j] if j<len(valid) else False)
            out.append(value if known else None)
        return out
    except (IndexError, KeyError, ValueError, StopIteration) as exc:
        return {"representation_error": type(exc).__name__}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('permuted duplicates', solve([[1, 2, 3], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [3, 1, 3, 2])
    check('nonzero slice', solve([[1, 2, 3], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [3, 1])
    check('validity moves with address', solve([[1, 2, 3], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [3, 1, None])
    check('empty slice', solve([[1], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[1, 2], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[1, 2], [0, 1], [0, 1], [True, True], 0, 2]), [1, 2])
    check('last slot', solve([[1, 2], [1, 0], [1, 0], [True, True], 1, 1]), [2])
elif N == 2:
    check('permuted duplicates', solve([[2, 3, 4], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [4, 2, 4, 3])
    check('nonzero slice', solve([[2, 3, 4], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [4, 2])
    check('validity moves with address', solve([[2, 3, 4], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [4, 2, None])
    check('empty slice', solve([[2], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[2, 3], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[2, 3], [0, 1], [0, 1], [True, True], 0, 2]), [2, 3])
    check('last slot', solve([[2, 3], [1, 0], [1, 0], [True, True], 1, 1]), [3])
elif N == 3:
    check('permuted duplicates', solve([[3, 4, 5], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [5, 3, 5, 4])
    check('nonzero slice', solve([[3, 4, 5], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [5, 3])
    check('validity moves with address', solve([[3, 4, 5], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [5, 3, None])
    check('empty slice', solve([[3], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[3, 4], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[3, 4], [0, 1], [0, 1], [True, True], 0, 2]), [3, 4])
    check('last slot', solve([[3, 4], [1, 0], [1, 0], [True, True], 1, 1]), [4])
elif N == 4:
    check('permuted duplicates', solve([[4, 5, 6], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [6, 4, 6, 5])
    check('nonzero slice', solve([[4, 5, 6], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [6, 4])
    check('validity moves with address', solve([[4, 5, 6], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [6, 4, None])
    check('empty slice', solve([[4], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[4, 5], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[4, 5], [0, 1], [0, 1], [True, True], 0, 2]), [4, 5])
    check('last slot', solve([[4, 5], [1, 0], [1, 0], [True, True], 1, 1]), [5])
elif N == 5:
    check('permuted duplicates', solve([[5, 6, 7], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [7, 5, 7, 6])
    check('nonzero slice', solve([[5, 6, 7], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [7, 5])
    check('validity moves with address', solve([[5, 6, 7], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [7, 5, None])
    check('empty slice', solve([[5], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[5, 6], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[5, 6], [0, 1], [0, 1], [True, True], 0, 2]), [5, 6])
    check('last slot', solve([[5, 6], [1, 0], [1, 0], [True, True], 1, 1]), [6])
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
permuted duplicates[3, 1, 3, None][3, 1, 3, 2]Failed
nonzero slice[3, 1][3, 1]Passed
validity moves with address[3, None, None][3, 1, None]Failed
empty slice[][]Passed
all null[None, None][None, None]Passed
identity control[1, 2][1, 2]Passed
last slot[2][2]Passed

SHA-256 / 2bcdf42a4f04062ac77d9e2a3278810a51d1a5ccbbeaa4510ebe45c3467e7962

3 / The verified repair

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

N = 1
observations = []
def solve(d):
    try:
        base,parent,child,valid,start,count=d
        selected=child[start:start+count]
        indices=[parent[i] for i in selected]
        out=[]
        for j,i in enumerate(indices):
            value=base[i]
            known=valid[i]
            out.append(value if known else None)
        return out
    except (IndexError, KeyError, ValueError, StopIteration) as exc:
        return {"representation_error": type(exc).__name__}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('permuted duplicates', solve([[1, 2, 3], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [3, 1, 3, 2])
    check('nonzero slice', solve([[1, 2, 3], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [3, 1])
    check('validity moves with address', solve([[1, 2, 3], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [3, 1, None])
    check('empty slice', solve([[1], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[1, 2], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[1, 2], [0, 1], [0, 1], [True, True], 0, 2]), [1, 2])
    check('last slot', solve([[1, 2], [1, 0], [1, 0], [True, True], 1, 1]), [2])
elif N == 2:
    check('permuted duplicates', solve([[2, 3, 4], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [4, 2, 4, 3])
    check('nonzero slice', solve([[2, 3, 4], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [4, 2])
    check('validity moves with address', solve([[2, 3, 4], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [4, 2, None])
    check('empty slice', solve([[2], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[2, 3], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[2, 3], [0, 1], [0, 1], [True, True], 0, 2]), [2, 3])
    check('last slot', solve([[2, 3], [1, 0], [1, 0], [True, True], 1, 1]), [3])
elif N == 3:
    check('permuted duplicates', solve([[3, 4, 5], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [5, 3, 5, 4])
    check('nonzero slice', solve([[3, 4, 5], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [5, 3])
    check('validity moves with address', solve([[3, 4, 5], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [5, 3, None])
    check('empty slice', solve([[3], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[3, 4], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[3, 4], [0, 1], [0, 1], [True, True], 0, 2]), [3, 4])
    check('last slot', solve([[3, 4], [1, 0], [1, 0], [True, True], 1, 1]), [4])
elif N == 4:
    check('permuted duplicates', solve([[4, 5, 6], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [6, 4, 6, 5])
    check('nonzero slice', solve([[4, 5, 6], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [6, 4])
    check('validity moves with address', solve([[4, 5, 6], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [6, 4, None])
    check('empty slice', solve([[4], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[4, 5], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[4, 5], [0, 1], [0, 1], [True, True], 0, 2]), [4, 5])
    check('last slot', solve([[4, 5], [1, 0], [1, 0], [True, True], 1, 1]), [5])
elif N == 5:
    check('permuted duplicates', solve([[5, 6, 7], [2, 0, 1], [0, 1, 0, 2], [True, True, True], 0, 4]), [7, 5, 7, 6])
    check('nonzero slice', solve([[5, 6, 7], [2, 0, 1], [2, 0, 1], [True, True, True], 1, 2]), [7, 5])
    check('validity moves with address', solve([[5, 6, 7], [2, 0, 1], [0, 1, 2], [True, False, True], 0, 3]), [7, 5, None])
    check('empty slice', solve([[5], [0], [0], [True], 0, 0]), [])
    check('all null', solve([[5, 6], [1, 0], [0, 1], [False, False], 0, 2]), [None, None])
    check('identity control', solve([[5, 6], [0, 1], [0, 1], [True, True], 0, 2]), [5, 6])
    check('last slot', solve([[5, 6], [1, 0], [1, 0], [True, True], 1, 1]), [6])
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
permuted duplicates[3, 1, 3, 2][3, 1, 3, 2]Passed
nonzero slice[3, 1][3, 1]Passed
validity moves with address[3, 1, None][3, 1, None]Passed
empty slice[][]Passed
all null[None, None][None, None]Passed
identity control[1, 2][1, 2]Passed
last slot[2][2]Passed

SHA-256 / 2173ec4925ab3109f20b363f7abec61c120063c69c213a273a4ba0dc7b312eae

Verification & scope

Offline stipulated semantics over valid small inputs; no performance, concurrency, or production-engine conformance claim. 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:44:11.466772+00:00.

Case digest / 243d2dda2c4469ea9f22e6fc22d90a4d9cfa4054983070fcecb8733f4c8d5a09