FA-44761 / Data systems / Open access

Projection aliases overwrite the input name environment · case 01

Projection aliases overwrite the input name environment.

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

ROOT CAUSE

projection-alias-snapshot: Projection aliases overwrite the input name environment.

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: Adding only new aliases still allows later inputs to refer to output names absent from source.

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(name)
                record.append([alias,value]); env[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 fixture	Actual	Expected	Outcome
shadowed input	`[[['b', 1], ['c', 1]]]`	`[[['b', 1], ['c', 2]]]`	Failed
new alias not input	`[[['x', 1], ['y', 1]]]`	`[[['x', 1], ['y', None]]]`	Failed
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 / a60846c4f55dd23e199878ccaaf92e2562f731d51e30fa636a42176134b75381

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)
                record.append([alias,value]); env.setdefault(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 fixture	Actual	Expected	Outcome
shadowed input	`[[['b', 1], ['c', 2]]]`	`[[['b', 1], ['c', 2]]]`	Passed
new alias not input	`[[['x', 1], ['y', 1]]]`	`[[['x', 1], ['y', None]]]`	Failed
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 / 3320143d65faf419578dc25e36a666fb1f5a9f3736774b8c21fec8ffa8cf6eb9

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 fixture	Actual	Expected	Outcome
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.391388+00:00.

Case digest / faaa1f5bd00ca3f4b4ef07a0ba9708227a15d413fbde88cf37c47717b785464e