FAILURE MAP
← Case archive

FA-44766 / Data systems / Open access

Projection reads the alias rather than the input field · case 01

Projection reads the alias rather than the input field.

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

ROOT CAUSE

projection-alias-snapshot: Projection reads the alias rather than the input field.

VERIFIED REPAIR

Preserve the stated physical representation and operation order: Evaluate ordered projection [output-name,input-name] pairs against each immutable input record, not earlier output aliases. Missing inputs yield None. Repeated output names occupy distinct result columns, and empty projections retain one empty result per input row.

Unsuccessful approach: Falling back to an alias invents values for missing source columns.

Case contract

Evaluate ordered projection [output-name,input-name] pairs against each immutable input record, not earlier output aliases. Missing inputs yield None. Repeated output names occupy distinct result columns, and empty projections retain one empty result per input row.

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:
        rows,projection=d
        out=[]
        for source in rows:
            record=[]
            env=source.copy()
            for alias,name in projection:
                value=env.get(alias)
                record.append([alias,value])
            out.append(record)
        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('shadowed input', solve([[{'a': 1, 'b': 2}], [['b', 'a'], ['c', 'b']]]), [[['b', 1], ['c', 2]]])
    check('new alias not input', solve([[{'a': 1}], [['x', 'a'], ['y', 'x']]]), [[['x', 1], ['y', None]]])
    check('repeated label', solve([[{'a': 1, 'b': 2}], [['x', 'a'], ['x', 'b']]]), [[['x', 1], ['x', 2]]])
    check('multiple rows', solve([[{'a': 1}, {'a': 2}], [['z', 'a']]]), [[['z', 1]], [['z', 2]]])
    check('missing with alias present', solve([[{'x': 1}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 1}, {'a': 2}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 2:
    check('shadowed input', solve([[{'a': 2, 'b': 3}], [['b', 'a'], ['c', 'b']]]), [[['b', 2], ['c', 3]]])
    check('new alias not input', solve([[{'a': 2}], [['x', 'a'], ['y', 'x']]]), [[['x', 2], ['y', None]]])
    check('repeated label', solve([[{'a': 2, 'b': 3}], [['x', 'a'], ['x', 'b']]]), [[['x', 2], ['x', 3]]])
    check('multiple rows', solve([[{'a': 2}, {'a': 3}], [['z', 'a']]]), [[['z', 2]], [['z', 3]]])
    check('missing with alias present', solve([[{'x': 2}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 2}, {'a': 3}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 3:
    check('shadowed input', solve([[{'a': 3, 'b': 4}], [['b', 'a'], ['c', 'b']]]), [[['b', 3], ['c', 4]]])
    check('new alias not input', solve([[{'a': 3}], [['x', 'a'], ['y', 'x']]]), [[['x', 3], ['y', None]]])
    check('repeated label', solve([[{'a': 3, 'b': 4}], [['x', 'a'], ['x', 'b']]]), [[['x', 3], ['x', 4]]])
    check('multiple rows', solve([[{'a': 3}, {'a': 4}], [['z', 'a']]]), [[['z', 3]], [['z', 4]]])
    check('missing with alias present', solve([[{'x': 3}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 3}, {'a': 4}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 4:
    check('shadowed input', solve([[{'a': 4, 'b': 5}], [['b', 'a'], ['c', 'b']]]), [[['b', 4], ['c', 5]]])
    check('new alias not input', solve([[{'a': 4}], [['x', 'a'], ['y', 'x']]]), [[['x', 4], ['y', None]]])
    check('repeated label', solve([[{'a': 4, 'b': 5}], [['x', 'a'], ['x', 'b']]]), [[['x', 4], ['x', 5]]])
    check('multiple rows', solve([[{'a': 4}, {'a': 5}], [['z', 'a']]]), [[['z', 4]], [['z', 5]]])
    check('missing with alias present', solve([[{'x': 4}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 4}, {'a': 5}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 5:
    check('shadowed input', solve([[{'a': 5, 'b': 6}], [['b', 'a'], ['c', 'b']]]), [[['b', 5], ['c', 6]]])
    check('new alias not input', solve([[{'a': 5}], [['x', 'a'], ['y', 'x']]]), [[['x', 5], ['y', None]]])
    check('repeated label', solve([[{'a': 5, 'b': 6}], [['x', 'a'], ['x', 'b']]]), [[['x', 5], ['x', 6]]])
    check('multiple rows', solve([[{'a': 5}, {'a': 6}], [['z', 'a']]]), [[['z', 5]], [['z', 6]]])
    check('missing with alias present', solve([[{'x': 5}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 5}, {'a': 6}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
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
shadowed input[[['b', 2], ['c', None]]][[['b', 1], ['c', 2]]]Failed
new alias not input[[['x', None], ['y', None]]][[['x', 1], ['y', None]]]Failed
repeated label[[['x', None], ['x', None]]][[['x', 1], ['x', 2]]]Failed
multiple rows[[['z', None]], [['z', None]]][[['z', 1]], [['z', 2]]]Failed
missing with alias present[[['x', 1]]][[['x', None]]]Failed
empty projection[[], []][[], []]Passed
empty input[][]Passed

SHA-256 / 733e10ff43738bcb0acd458fb9a4dace7109e0ac98bd2c7e12a93c3a1ca5f894

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(d):
    try:
        rows,projection=d
        out=[]
        for source in rows:
            record=[]
            env=source.copy()
            for alias,name in projection:
                value=env.get(name,env.get(alias))
                record.append([alias,value])
            out.append(record)
        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('shadowed input', solve([[{'a': 1, 'b': 2}], [['b', 'a'], ['c', 'b']]]), [[['b', 1], ['c', 2]]])
    check('new alias not input', solve([[{'a': 1}], [['x', 'a'], ['y', 'x']]]), [[['x', 1], ['y', None]]])
    check('repeated label', solve([[{'a': 1, 'b': 2}], [['x', 'a'], ['x', 'b']]]), [[['x', 1], ['x', 2]]])
    check('multiple rows', solve([[{'a': 1}, {'a': 2}], [['z', 'a']]]), [[['z', 1]], [['z', 2]]])
    check('missing with alias present', solve([[{'x': 1}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 1}, {'a': 2}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 2:
    check('shadowed input', solve([[{'a': 2, 'b': 3}], [['b', 'a'], ['c', 'b']]]), [[['b', 2], ['c', 3]]])
    check('new alias not input', solve([[{'a': 2}], [['x', 'a'], ['y', 'x']]]), [[['x', 2], ['y', None]]])
    check('repeated label', solve([[{'a': 2, 'b': 3}], [['x', 'a'], ['x', 'b']]]), [[['x', 2], ['x', 3]]])
    check('multiple rows', solve([[{'a': 2}, {'a': 3}], [['z', 'a']]]), [[['z', 2]], [['z', 3]]])
    check('missing with alias present', solve([[{'x': 2}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 2}, {'a': 3}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 3:
    check('shadowed input', solve([[{'a': 3, 'b': 4}], [['b', 'a'], ['c', 'b']]]), [[['b', 3], ['c', 4]]])
    check('new alias not input', solve([[{'a': 3}], [['x', 'a'], ['y', 'x']]]), [[['x', 3], ['y', None]]])
    check('repeated label', solve([[{'a': 3, 'b': 4}], [['x', 'a'], ['x', 'b']]]), [[['x', 3], ['x', 4]]])
    check('multiple rows', solve([[{'a': 3}, {'a': 4}], [['z', 'a']]]), [[['z', 3]], [['z', 4]]])
    check('missing with alias present', solve([[{'x': 3}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 3}, {'a': 4}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 4:
    check('shadowed input', solve([[{'a': 4, 'b': 5}], [['b', 'a'], ['c', 'b']]]), [[['b', 4], ['c', 5]]])
    check('new alias not input', solve([[{'a': 4}], [['x', 'a'], ['y', 'x']]]), [[['x', 4], ['y', None]]])
    check('repeated label', solve([[{'a': 4, 'b': 5}], [['x', 'a'], ['x', 'b']]]), [[['x', 4], ['x', 5]]])
    check('multiple rows', solve([[{'a': 4}, {'a': 5}], [['z', 'a']]]), [[['z', 4]], [['z', 5]]])
    check('missing with alias present', solve([[{'x': 4}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 4}, {'a': 5}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 5:
    check('shadowed input', solve([[{'a': 5, 'b': 6}], [['b', 'a'], ['c', 'b']]]), [[['b', 5], ['c', 6]]])
    check('new alias not input', solve([[{'a': 5}], [['x', 'a'], ['y', 'x']]]), [[['x', 5], ['y', None]]])
    check('repeated label', solve([[{'a': 5, 'b': 6}], [['x', 'a'], ['x', 'b']]]), [[['x', 5], ['x', 6]]])
    check('multiple rows', solve([[{'a': 5}, {'a': 6}], [['z', 'a']]]), [[['z', 5]], [['z', 6]]])
    check('missing with alias present', solve([[{'x': 5}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 5}, {'a': 6}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
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
shadowed input[[['b', 1], ['c', 2]]][[['b', 1], ['c', 2]]]Passed
new alias not input[[['x', 1], ['y', None]]][[['x', 1], ['y', None]]]Passed
repeated label[[['x', 1], ['x', 2]]][[['x', 1], ['x', 2]]]Passed
multiple rows[[['z', 1]], [['z', 2]]][[['z', 1]], [['z', 2]]]Passed
missing with alias present[[['x', 1]]][[['x', None]]]Failed
empty projection[[], []][[], []]Passed
empty input[][]Passed

SHA-256 / c521e3b291fa6425f614da86b014eb537bced5b056538109154e36314e9959c2

3 / The verified repair

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

N = 1
observations = []
def solve(d):
    try:
        rows,projection=d
        out=[]
        for source in rows:
            record=[]
            env=source.copy()
            for alias,name in projection:
                value=env.get(name)
                record.append([alias,value])
            out.append(record)
        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('shadowed input', solve([[{'a': 1, 'b': 2}], [['b', 'a'], ['c', 'b']]]), [[['b', 1], ['c', 2]]])
    check('new alias not input', solve([[{'a': 1}], [['x', 'a'], ['y', 'x']]]), [[['x', 1], ['y', None]]])
    check('repeated label', solve([[{'a': 1, 'b': 2}], [['x', 'a'], ['x', 'b']]]), [[['x', 1], ['x', 2]]])
    check('multiple rows', solve([[{'a': 1}, {'a': 2}], [['z', 'a']]]), [[['z', 1]], [['z', 2]]])
    check('missing with alias present', solve([[{'x': 1}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 1}, {'a': 2}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 2:
    check('shadowed input', solve([[{'a': 2, 'b': 3}], [['b', 'a'], ['c', 'b']]]), [[['b', 2], ['c', 3]]])
    check('new alias not input', solve([[{'a': 2}], [['x', 'a'], ['y', 'x']]]), [[['x', 2], ['y', None]]])
    check('repeated label', solve([[{'a': 2, 'b': 3}], [['x', 'a'], ['x', 'b']]]), [[['x', 2], ['x', 3]]])
    check('multiple rows', solve([[{'a': 2}, {'a': 3}], [['z', 'a']]]), [[['z', 2]], [['z', 3]]])
    check('missing with alias present', solve([[{'x': 2}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 2}, {'a': 3}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 3:
    check('shadowed input', solve([[{'a': 3, 'b': 4}], [['b', 'a'], ['c', 'b']]]), [[['b', 3], ['c', 4]]])
    check('new alias not input', solve([[{'a': 3}], [['x', 'a'], ['y', 'x']]]), [[['x', 3], ['y', None]]])
    check('repeated label', solve([[{'a': 3, 'b': 4}], [['x', 'a'], ['x', 'b']]]), [[['x', 3], ['x', 4]]])
    check('multiple rows', solve([[{'a': 3}, {'a': 4}], [['z', 'a']]]), [[['z', 3]], [['z', 4]]])
    check('missing with alias present', solve([[{'x': 3}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 3}, {'a': 4}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 4:
    check('shadowed input', solve([[{'a': 4, 'b': 5}], [['b', 'a'], ['c', 'b']]]), [[['b', 4], ['c', 5]]])
    check('new alias not input', solve([[{'a': 4}], [['x', 'a'], ['y', 'x']]]), [[['x', 4], ['y', None]]])
    check('repeated label', solve([[{'a': 4, 'b': 5}], [['x', 'a'], ['x', 'b']]]), [[['x', 4], ['x', 5]]])
    check('multiple rows', solve([[{'a': 4}, {'a': 5}], [['z', 'a']]]), [[['z', 4]], [['z', 5]]])
    check('missing with alias present', solve([[{'x': 4}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 4}, {'a': 5}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
elif N == 5:
    check('shadowed input', solve([[{'a': 5, 'b': 6}], [['b', 'a'], ['c', 'b']]]), [[['b', 5], ['c', 6]]])
    check('new alias not input', solve([[{'a': 5}], [['x', 'a'], ['y', 'x']]]), [[['x', 5], ['y', None]]])
    check('repeated label', solve([[{'a': 5, 'b': 6}], [['x', 'a'], ['x', 'b']]]), [[['x', 5], ['x', 6]]])
    check('multiple rows', solve([[{'a': 5}, {'a': 6}], [['z', 'a']]]), [[['z', 5]], [['z', 6]]])
    check('missing with alias present', solve([[{'x': 5}], [['x', 'missing']]]), [[['x', None]]])
    check('empty projection', solve([[{'a': 5}, {'a': 6}], []]), [[], []])
    check('empty input', solve([[], [['x', 'a']]]), [])
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
shadowed input[[['b', 1], ['c', 2]]][[['b', 1], ['c', 2]]]Passed
new alias not input[[['x', 1], ['y', None]]][[['x', 1], ['y', None]]]Passed
repeated label[[['x', 1], ['x', 2]]][[['x', 1], ['x', 2]]]Passed
multiple rows[[['z', 1]], [['z', 2]]][[['z', 1]], [['z', 2]]]Passed
missing with alias present[[['x', None]]][[['x', None]]]Passed
empty projection[[], []][[], []]Passed
empty input[][]Passed

SHA-256 / 0b04401f0830f4f7986f143d17683b15e68274050863bb721df66203a3af629f

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

Case digest / 77736da7143bbfb425a2f69f6a620b9fd4a9cdf0fded944c2b5c0e3a33463c75