FAILURE MAP
← Case archive

FA-44776 / Data systems / Open access

Projection evaluates every row against the first source record · case 01

Projection evaluates every row against the first source record.

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

ROOT CAUSE

projection-alias-snapshot: Projection evaluates every row against the first source record.

THE FAILURE

projection-alias-snapshot: Projection evaluates every row against the first source record.

Unsuccessful approach: Using the last record still broadcasts one environment.

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=rows[0].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', 1]]][[['z', 1]], [['z', 2]]]Failed
missing with alias present[[['x', None]]][[['x', None]]]Passed
empty projection[[], []][[], []]Passed
empty input[][]Passed

SHA-256 / 0e23d4aef3449ffea000852c576795d4d5c573602046ddc4bb29221f022a42e6

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=rows[-1].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', 2]], [['z', 2]]][[['z', 1]], [['z', 2]]]Failed
missing with alias present[[['x', None]]][[['x', None]]]Passed
empty projection[[], []][[], []]Passed
empty input[][]Passed

SHA-256 / 2ddeefabab8d8d2748a42728acbb388ec5fa0d05d0c493b91e1e7e2c2f9c0e02

HELD IN THE MEMBER ARCHIVE

The verified repair and its recorded checks are member-only.

This mechanism has 7 recorded checks per implementation. The open-access tier publishes the failure and the unsuccessful fix; the repaired source that passes every check, and the observations that prove it, are available to members.

Every case sharing this mechanism uses the same contract and the same repair, so this one record is held back for all of them.

Member access is invitation-based. Sign in with your invited account to inspect the repair.

Sign in to the archive ↗

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

Case digest / aaeb5ab5e0fde3a44b21eefe93ef156e23c04502698badcf57b6148c0229e91c