FA-47901 / Delimited text / Open access

Unsupported nested list syntax is retained as ordinary item text · case 01

A structured table violates the declared record or column contract.

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

ROOT CAUSE

Nested brackets are admitted by a flat list-cell grammar.

VERIFIED REPAIR

Preserve the named invariant at the faulty decision: if '[' in inner or ']' in inner: return None

Unsuccessful approach: Rejecting only unbalanced nested openers still accepts balanced nesting.

Case contract

Decode a semicolon table row whose cells are either bare scalar text or bracketed pipe lists. Backslash has no special role. List elements may be empty; [] is an empty list. Brackets must occupy the whole cell; nested brackets reject. Return each cell as scalar text or a list.

Why this case matters

Delimited interchange needs explicit framing, schema and field semantics at ingestion and emission boundaries.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
def _vary(value):
    if value == '@END': return 3 + 4*N
    if isinstance(value, str): return value.replace('@', 'cell' * N)
    if isinstance(value, list): return [_vary(x) for x in value]
    if isinstance(value, dict): return {_vary(k): _vary(v) for k,v in value.items()}
    return value
N = 1
observations = []
def solve(data):
    out = []
    for cell in data.split(';'):
        if cell.startswith('['):
            if not cell.endswith(']'): return None
            inner = cell[1:-1]
            if False: return None
            value = [] if inner == '' else inner.split('|')
        else:
            if '[' in cell or ']' in cell: return None
            value = cell
        out.append(value)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('mixed', solve(_vary('@;[a|b]')), _vary(['@', ['a', 'b']]))
check('empty list', solve(_vary('[]')), _vary([[]]))
check('empty elements', solve(_vary('[|a|]')), _vary([['', 'a', '']]))
check('bare empty', solve(_vary('')), _vary(['']))
check('unclosed', solve(_vary('[a')), _vary(None))
check('suffix', solve(_vary('[a]tail')), _vary(None))
check('nested', solve(_vary('[[a]]')), _vary(None))
check('bare bracket', solve(_vary('a]')), _vary(None))
check('pipe bare', solve(_vary('a|b')), _vary(['a|b']))
check('three list', solve(_vary('[a|b|c]')), _vary([['a', 'b', 'c']]))
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
mixed	`['cell', ['a', 'b']]`	`['cell', ['a', 'b']]`	Passed
empty list	`[[]]`	`[[]]`	Passed
empty elements	`[['', 'a', '']]`	`[['', 'a', '']]`	Passed
bare empty	`['']`	`['']`	Passed
unclosed	`None`	`None`	Passed
suffix	`None`	`None`	Passed
nested	`[['[a]']]`	`None`	Failed
bare bracket	`None`	`None`	Passed
pipe bare	`['a\|b']`	`['a\|b']`	Passed
three list	`[['a', 'b', 'c']]`	`[['a', 'b', 'c']]`	Passed

SHA-256 / a68c077dabd8b135a40643709c9148435ebb69f063c655d5619df5c2b0db40fd

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
def _vary(value):
    if value == '@END': return 3 + 4*N
    if isinstance(value, str): return value.replace('@', 'cell' * N)
    if isinstance(value, list): return [_vary(x) for x in value]
    if isinstance(value, dict): return {_vary(k): _vary(v) for k,v in value.items()}
    return value
N = 1
observations = []
def solve(data):
    out = []
    for cell in data.split(';'):
        if cell.startswith('['):
            if not cell.endswith(']'): return None
            inner = cell[1:-1]
            if '[' in inner and ']' not in inner: return None
            value = [] if inner == '' else inner.split('|')
        else:
            if '[' in cell or ']' in cell: return None
            value = cell
        out.append(value)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('mixed', solve(_vary('@;[a|b]')), _vary(['@', ['a', 'b']]))
check('empty list', solve(_vary('[]')), _vary([[]]))
check('empty elements', solve(_vary('[|a|]')), _vary([['', 'a', '']]))
check('bare empty', solve(_vary('')), _vary(['']))
check('unclosed', solve(_vary('[a')), _vary(None))
check('suffix', solve(_vary('[a]tail')), _vary(None))
check('nested', solve(_vary('[[a]]')), _vary(None))
check('bare bracket', solve(_vary('a]')), _vary(None))
check('pipe bare', solve(_vary('a|b')), _vary(['a|b']))
check('three list', solve(_vary('[a|b|c]')), _vary([['a', 'b', 'c']]))
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
mixed	`['cell', ['a', 'b']]`	`['cell', ['a', 'b']]`	Passed
empty list	`[[]]`	`[[]]`	Passed
empty elements	`[['', 'a', '']]`	`[['', 'a', '']]`	Passed
bare empty	`['']`	`['']`	Passed
unclosed	`None`	`None`	Passed
suffix	`None`	`None`	Passed
nested	`[['[a]']]`	`None`	Failed
bare bracket	`None`	`None`	Passed
pipe bare	`['a\|b']`	`['a\|b']`	Passed
three list	`[['a', 'b', 'c']]`	`[['a', 'b', 'c']]`	Passed

SHA-256 / 26149681d219d4b699b4ecc6b7a0a968d6245167128b0d91a74444c4373700f5

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json
def _vary(value):
    if value == '@END': return 3 + 4*N
    if isinstance(value, str): return value.replace('@', 'cell' * N)
    if isinstance(value, list): return [_vary(x) for x in value]
    if isinstance(value, dict): return {_vary(k): _vary(v) for k,v in value.items()}
    return value
N = 1
observations = []
def solve(data):
    out = []
    for cell in data.split(';'):
        if cell.startswith('['):
            if not cell.endswith(']'): return None
            inner = cell[1:-1]
            if '[' in inner or ']' in inner: return None
            value = [] if inner == '' else inner.split('|')
        else:
            if '[' in cell or ']' in cell: return None
            value = cell
        out.append(value)
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('mixed', solve(_vary('@;[a|b]')), _vary(['@', ['a', 'b']]))
check('empty list', solve(_vary('[]')), _vary([[]]))
check('empty elements', solve(_vary('[|a|]')), _vary([['', 'a', '']]))
check('bare empty', solve(_vary('')), _vary(['']))
check('unclosed', solve(_vary('[a')), _vary(None))
check('suffix', solve(_vary('[a]tail')), _vary(None))
check('nested', solve(_vary('[[a]]')), _vary(None))
check('bare bracket', solve(_vary('a]')), _vary(None))
check('pipe bare', solve(_vary('a|b')), _vary(['a|b']))
check('three list', solve(_vary('[a|b|c]')), _vary([['a', 'b', 'c']]))
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
mixed	`['cell', ['a', 'b']]`	`['cell', ['a', 'b']]`	Passed
empty list	`[[]]`	`[[]]`	Passed
empty elements	`[['', 'a', '']]`	`[['', 'a', '']]`	Passed
bare empty	`['']`	`['']`	Passed
unclosed	`None`	`None`	Passed
suffix	`None`	`None`	Passed
nested	`None`	`None`	Passed
bare bracket	`None`	`None`	Passed
pipe bare	`['a\|b']`	`['a\|b']`	Passed
three list	`[['a', 'b', 'c']]`	`[['a', 'b', 'c']]`	Passed

SHA-256 / d9d1414890c4d25606ec0675ea56671b810d0e81c2b522a2ee1789d93a179cf4

Verification & scope

Deterministic bounded in-memory model. No claim of complete CSV or external format conformance. 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:45.773201+00:00.

Case digest / bf9cc6332308c5771780dfe780239e0520c2806cd0f9959c24d9c3e3dbae91b0