FAILURE MAP
← Case archive

FA-44501 / Data systems / Open access

Dense union tag dispatch ignores the declared tag map · case 01

Dense union tag dispatch ignores the declared tag map.

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

ROOT CAUSE

dense-union-gather: Dense union tag dispatch ignores the declared tag map.

VERIFIED REPAIR

Preserve the stated physical representation and operation order: Decode a dense tagged union. Tags select named child buffers through a tag map; offsets address those buffers independently of output position. Parent and selected child validity both apply. Emit [child-name,value] for valid parents, None for null parents.

Unsuccessful approach: Choosing the final child is not tag decoding.

Case contract

Decode a dense tagged union. Tags select named child buffers through a tag map; offsets address those buffers independently of output position. Parent and selected child validity both apply. Emit [child-name,value] for valid parents, None for null parents.

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:
        tags,offsets,names,children,valid,parent,selection=d
        out=[]
        for row in selection:
            tag=tags[row]
            name=list(children)[0]
            offset=offsets[row]
            value=children[name][offset] if valid[name][offset] else None
            out.append([name,value] if parent[row] 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('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [1, 2, 3], 'b': [4, 5, 6]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 1], ['a', 2], ['b', 4]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [1, 2]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 2]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [True], [0, 0]]), [['a', 1], ['a', 1]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [1, 2], 'b': [3, 4]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 4]])
elif N == 2:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [2, 3, 4], 'b': [5, 6, 7]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 2], ['a', 3], ['b', 5]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [2, 3]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 3]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [True], [0, 0]]), [['a', 2], ['a', 2]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [2, 3], 'b': [4, 5]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 5]])
elif N == 3:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [3, 4, 5], 'b': [6, 7, 8]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 3], ['a', 4], ['b', 6]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [3, 4]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 4]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [True], [0, 0]]), [['a', 3], ['a', 3]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [3, 4], 'b': [5, 6]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 6]])
elif N == 4:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [4, 5, 6], 'b': [7, 8, 9]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 4], ['a', 5], ['b', 7]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [4, 5]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 5]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [True], [0, 0]]), [['a', 4], ['a', 4]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [4, 5], 'b': [6, 7]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 7]])
elif N == 5:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [5, 6, 7], 'b': [8, 9, 10]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 5], ['a', 6], ['b', 8]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [5, 6]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 6]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [True], [0, 0]]), [['a', 5], ['a', 5]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [5, 6], 'b': [7, 8]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 8]])
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
mixed tags[['a', 1], ['a', 2], ['a', 1]][['a', 1], ['a', 2], ['b', 4]]Failed
child null[['a', None], ['a', 2]][['a', None], ['a', 2]]Passed
parent null[None][None]Passed
repeat row[['a', 1], ['a', 1]][['a', 1], ['a', 1]]Passed
empty selection[][]Passed
second tag[['a', 2]][['b', 4]]Failed

SHA-256 / a60eb81fbf9e48198ed2922c8df5468e42a3d07a1faa72a9eba8adda4e89d9d3

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(d):
    try:
        tags,offsets,names,children,valid,parent,selection=d
        out=[]
        for row in selection:
            tag=tags[row]
            name=list(children)[-1]
            offset=offsets[row]
            value=children[name][offset] if valid[name][offset] else None
            out.append([name,value] if parent[row] 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('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [1, 2, 3], 'b': [4, 5, 6]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 1], ['a', 2], ['b', 4]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [1, 2]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 2]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [True], [0, 0]]), [['a', 1], ['a', 1]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [1, 2], 'b': [3, 4]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 4]])
elif N == 2:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [2, 3, 4], 'b': [5, 6, 7]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 2], ['a', 3], ['b', 5]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [2, 3]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 3]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [True], [0, 0]]), [['a', 2], ['a', 2]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [2, 3], 'b': [4, 5]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 5]])
elif N == 3:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [3, 4, 5], 'b': [6, 7, 8]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 3], ['a', 4], ['b', 6]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [3, 4]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 4]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [True], [0, 0]]), [['a', 3], ['a', 3]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [3, 4], 'b': [5, 6]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 6]])
elif N == 4:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [4, 5, 6], 'b': [7, 8, 9]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 4], ['a', 5], ['b', 7]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [4, 5]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 5]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [True], [0, 0]]), [['a', 4], ['a', 4]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [4, 5], 'b': [6, 7]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 7]])
elif N == 5:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [5, 6, 7], 'b': [8, 9, 10]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 5], ['a', 6], ['b', 8]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [5, 6]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 6]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [True], [0, 0]]), [['a', 5], ['a', 5]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [5, 6], 'b': [7, 8]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 8]])
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
mixed tags[['b', 4], ['b', 5], ['b', 4]][['a', 1], ['a', 2], ['b', 4]]Failed
child null[['a', None], ['a', 2]][['a', None], ['a', 2]]Passed
parent null[None][None]Passed
repeat row[['a', 1], ['a', 1]][['a', 1], ['a', 1]]Passed
empty selection[][]Passed
second tag[['b', 4]][['b', 4]]Passed

SHA-256 / 58cf5b6eec5c5acc32b9e09aa3cfa80855c10d3fa45f0c2487c24dae9168eefb

3 / The verified repair

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

N = 1
observations = []
def solve(d):
    try:
        tags,offsets,names,children,valid,parent,selection=d
        out=[]
        for row in selection:
            tag=tags[row]
            name=names[str(tag)]
            offset=offsets[row]
            value=children[name][offset] if valid[name][offset] else None
            out.append([name,value] if parent[row] 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('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [1, 2, 3], 'b': [4, 5, 6]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 1], ['a', 2], ['b', 4]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [1, 2]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 2]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [True], [0, 0]]), [['a', 1], ['a', 1]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [1]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [1, 2], 'b': [3, 4]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 4]])
elif N == 2:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [2, 3, 4], 'b': [5, 6, 7]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 2], ['a', 3], ['b', 5]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [2, 3]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 3]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [True], [0, 0]]), [['a', 2], ['a', 2]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [2]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [2, 3], 'b': [4, 5]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 5]])
elif N == 3:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [3, 4, 5], 'b': [6, 7, 8]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 3], ['a', 4], ['b', 6]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [3, 4]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 4]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [True], [0, 0]]), [['a', 3], ['a', 3]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [3]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [3, 4], 'b': [5, 6]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 6]])
elif N == 4:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [4, 5, 6], 'b': [7, 8, 9]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 4], ['a', 5], ['b', 7]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [4, 5]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 5]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [True], [0, 0]]), [['a', 4], ['a', 4]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [4]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [4, 5], 'b': [6, 7]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 7]])
elif N == 5:
    check('mixed tags', solve([[7, 9, 7], [1, 0, 0], {'7': 'a', '9': 'b'}, {'a': [5, 6, 7], 'b': [8, 9, 10]}, {'a': [True, True, True], 'b': [True, True, True]}, [True, True, True], [2, 0, 1]]), [['a', 5], ['a', 6], ['b', 8]])
    check('child null', solve([[7, 7], [0, 1], {'7': 'a'}, {'a': [5, 6]}, {'a': [False, True]}, [True, True], [0, 1]]), [['a', None], ['a', 6]])
    check('parent null', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [False], [0]]), [None])
    check('repeat row', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [True], [0, 0]]), [['a', 5], ['a', 5]])
    check('empty selection', solve([[7], [0], {'7': 'a'}, {'a': [5]}, {'a': [True]}, [True], []]), [])
    check('second tag', solve([[9], [1], {'7': 'a', '9': 'b'}, {'a': [5, 6], 'b': [7, 8]}, {'a': [True, True], 'b': [True, True]}, [True], [0]]), [['b', 8]])
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
mixed tags[['a', 1], ['a', 2], ['b', 4]][['a', 1], ['a', 2], ['b', 4]]Passed
child null[['a', None], ['a', 2]][['a', None], ['a', 2]]Passed
parent null[None][None]Passed
repeat row[['a', 1], ['a', 1]][['a', 1], ['a', 1]]Passed
empty selection[][]Passed
second tag[['b', 4]][['b', 4]]Passed

SHA-256 / 3f0bc15811ad816b24c65a25481b1b0fcefbaf9ef4e6c2e5894c647c0e734390

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

Case digest / 8003f2d4fa59fbfaefdbb7c2e269d54bb50d1aed359c23356e14693a28901218