FAILURE MAP
← Case archive

FA-80801 / Bidirectional text layout / Open access

Visual run list for shaping: lowest odd pass · case 01

Runs at the lowest odd level stay in logical order.

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

ROOT CAUSE

The level loop stops above the lowest odd level.

VERIFIED REPAIR

Include the lowest odd level in the reversal passes.

Unsuccessful approach: Continuing one level below the lowest odd level reverses the whole line again.

Case contract

Input resolved levels of a line. Group maximal equal-level runs [logical start, length, level]; reorder whole runs from the highest level down to the lowest odd level by reversing sequences of runs at or above the level. Return [[start, length, "rtl"|"ltr"]] in visual order.

Why this case matters

Mixed right-to-left and left-to-right text must resolve levels and visual order exactly, or words, numbers and carets land in the wrong place.

1 / The failure

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

N = 1
observations = []
def solve(x):
    levels = x
    n = len(levels)
    runs = []
    for i in range(n):
        if runs and runs[-1][2] == levels[i]:
            runs[-1][1] += 1
        else:
            runs.append([i, 1, levels[i]])
    if not runs:
        return []
    odd = [r[2] for r in runs if r[2] % 2]
    if odd:
        for lev in range(max(r[2] for r in runs), min(odd), -1):
            out, i = [], 0
            while i < len(runs):
                if runs[i][2] >= lev:
                    j = i
                    while j < len(runs) and runs[j][2] >= lev:
                        j += 1
                    out.extend(runs[i:j][::-1])
                    i = j
                else:
                    out.append(runs[i])
                    i += 1
            runs = out
    return [[s, ln, 'rtl' if lv % 2 else 'ltr'] for s, ln, lv in runs]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('regression: lowest odd pass', [0, 0, 0, 0, 1, 3], [[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 3, 3, 3, 0, 0, 1, 1, 0], [[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']]), ('regression: lowest odd pass', [0, 1, 1, 1, 1, 1, 2, 2], [[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('control layout', [0, 0, 0, 0], [[0, 4, 'ltr']]), ('control layout', [4, 4, 4, 4], [[0, 4, 'ltr']]), ('control layout', [2], [[0, 1, 'ltr']])], [('regression: lowest odd pass', [1, 1, 1, 3, 3, 3, 3, 3, 2, 2, 2, 2], [[3, 5, 'rtl'], [8, 4, 'ltr'], [0, 3, 'rtl']]), ('regression: lowest odd pass', [1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 3], [[0, 3, 'rtl'], [3, 4, 'ltr'], [7, 4, 'ltr'], [11, 1, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 2, 1, 1, 1], [[4, 3, 'rtl'], [0, 4, 'ltr']]), ('partial-repair probe', [1, 1, 0], [[0, 2, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('control layout', [0, 0, 0, 0, 0, 2, 2, 2, 0], [[0, 5, 'ltr'], [5, 3, 'ltr'], [8, 1, 'ltr']]), ('control layout', [0, 0], [[0, 2, 'ltr']])], [('regression: lowest odd pass', [3, 3, 3, 4, 4, 4, 2, 2, 2, 2, 1], [[10, 1, 'rtl'], [3, 3, 'ltr'], [0, 3, 'rtl'], [6, 4, 'ltr']]), ('regression: lowest odd pass', [1, 2, 2], [[1, 2, 'ltr'], [0, 1, 'rtl']]), ('regression: lowest odd pass', [3, 3, 3, 1, 1, 1, 1], [[3, 4, 'rtl'], [0, 3, 'rtl']]), ('partial-repair probe', [1, 1, 0, 0, 0, 0, 3], [[0, 2, 'rtl'], [2, 4, 'ltr'], [6, 1, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [1, 1, 1, 1, 1, 1, 1], [[0, 7, 'rtl']]), ('control layout', [4, 4, 2, 4], [[0, 2, 'ltr'], [2, 1, 'ltr'], [3, 1, 'ltr']])], [('regression: lowest odd pass', [0, 1, 1, 1, 1, 3], [[0, 1, 'ltr'], [5, 1, 'rtl'], [1, 4, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 1, 1], [[3, 2, 'rtl'], [0, 3, 'ltr']]), ('regression: lowest odd pass', [1, 1, 1, 1, 3, 0, 0, 0, 1], [[4, 1, 'rtl'], [0, 4, 'rtl'], [5, 3, 'ltr'], [8, 1, 'rtl']]), ('regression: lowest odd pass', [3, 3, 3, 1, 1, 3, 3], [[5, 2, 'rtl'], [3, 2, 'rtl'], [0, 3, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [2, 2, 2, 2], [[0, 4, 'ltr']]), ('control layout', [2, 2, 2], [[0, 3, 'ltr']])], [('regression: lowest odd pass', [2, 2, 1, 1, 1], [[2, 3, 'rtl'], [0, 2, 'ltr']]), ('regression: lowest odd pass', [2, 1, 1, 1, 1, 3, 3, 3, 3, 1, 4], [[10, 1, 'ltr'], [9, 1, 'rtl'], [5, 4, 'rtl'], [1, 4, 'rtl'], [0, 1, 'ltr']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('partial-repair probe', [0, 0, 0, 1, 1], [[0, 3, 'ltr'], [3, 2, 'rtl']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [3, 3, 3, 3], [[0, 4, 'rtl']]), ('control layout', [1, 1, 1, 1], [[0, 4, 'rtl']]), ('control layout', [4, 4, 4, 4, 4, 4, 4, 2, 2], [[0, 7, 'ltr'], [7, 2, 'ltr']])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(args), expected)
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
LTR number inside RTL[[0, 2, 'rtl'], [2, 2, 'ltr'], [4, 1, 'rtl']][[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]Failed
regression: lowest odd pass[[0, 4, 'ltr'], [4, 1, 'rtl'], [5, 1, 'rtl']][[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']]Failed
regression: lowest odd pass[[3, 3, 'rtl'], [0, 3, 'ltr'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']][[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']]Failed
regression: lowest odd pass[[0, 1, 'ltr'], [1, 5, 'rtl'], [6, 2, 'ltr']][[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']]Failed
lowest odd is three[[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']][[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]Passed
control layout[[0, 4, 'ltr']][[0, 4, 'ltr']]Passed
control layout[[0, 4, 'ltr']][[0, 4, 'ltr']]Passed
control layout[[0, 1, 'ltr']][[0, 1, 'ltr']]Passed

SHA-256 / d5636064219db397619025e74fbc29cc2531d6a82a73e5a05d127b9f5770ffd9

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(x):
    levels = x
    n = len(levels)
    runs = []
    for i in range(n):
        if runs and runs[-1][2] == levels[i]:
            runs[-1][1] += 1
        else:
            runs.append([i, 1, levels[i]])
    if not runs:
        return []
    odd = [r[2] for r in runs if r[2] % 2]
    if odd:
        for lev in range(max(r[2] for r in runs), min(odd) - 2, -1):
            out, i = [], 0
            while i < len(runs):
                if runs[i][2] >= lev:
                    j = i
                    while j < len(runs) and runs[j][2] >= lev:
                        j += 1
                    out.extend(runs[i:j][::-1])
                    i = j
                else:
                    out.append(runs[i])
                    i += 1
            runs = out
    return [[s, ln, 'rtl' if lv % 2 else 'ltr'] for s, ln, lv in runs]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('regression: lowest odd pass', [0, 0, 0, 0, 1, 3], [[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 3, 3, 3, 0, 0, 1, 1, 0], [[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']]), ('regression: lowest odd pass', [0, 1, 1, 1, 1, 1, 2, 2], [[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('control layout', [0, 0, 0, 0], [[0, 4, 'ltr']]), ('control layout', [4, 4, 4, 4], [[0, 4, 'ltr']]), ('control layout', [2], [[0, 1, 'ltr']])], [('regression: lowest odd pass', [1, 1, 1, 3, 3, 3, 3, 3, 2, 2, 2, 2], [[3, 5, 'rtl'], [8, 4, 'ltr'], [0, 3, 'rtl']]), ('regression: lowest odd pass', [1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 3], [[0, 3, 'rtl'], [3, 4, 'ltr'], [7, 4, 'ltr'], [11, 1, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 2, 1, 1, 1], [[4, 3, 'rtl'], [0, 4, 'ltr']]), ('partial-repair probe', [1, 1, 0], [[0, 2, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('control layout', [0, 0, 0, 0, 0, 2, 2, 2, 0], [[0, 5, 'ltr'], [5, 3, 'ltr'], [8, 1, 'ltr']]), ('control layout', [0, 0], [[0, 2, 'ltr']])], [('regression: lowest odd pass', [3, 3, 3, 4, 4, 4, 2, 2, 2, 2, 1], [[10, 1, 'rtl'], [3, 3, 'ltr'], [0, 3, 'rtl'], [6, 4, 'ltr']]), ('regression: lowest odd pass', [1, 2, 2], [[1, 2, 'ltr'], [0, 1, 'rtl']]), ('regression: lowest odd pass', [3, 3, 3, 1, 1, 1, 1], [[3, 4, 'rtl'], [0, 3, 'rtl']]), ('partial-repair probe', [1, 1, 0, 0, 0, 0, 3], [[0, 2, 'rtl'], [2, 4, 'ltr'], [6, 1, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [1, 1, 1, 1, 1, 1, 1], [[0, 7, 'rtl']]), ('control layout', [4, 4, 2, 4], [[0, 2, 'ltr'], [2, 1, 'ltr'], [3, 1, 'ltr']])], [('regression: lowest odd pass', [0, 1, 1, 1, 1, 3], [[0, 1, 'ltr'], [5, 1, 'rtl'], [1, 4, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 1, 1], [[3, 2, 'rtl'], [0, 3, 'ltr']]), ('regression: lowest odd pass', [1, 1, 1, 1, 3, 0, 0, 0, 1], [[4, 1, 'rtl'], [0, 4, 'rtl'], [5, 3, 'ltr'], [8, 1, 'rtl']]), ('regression: lowest odd pass', [3, 3, 3, 1, 1, 3, 3], [[5, 2, 'rtl'], [3, 2, 'rtl'], [0, 3, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [2, 2, 2, 2], [[0, 4, 'ltr']]), ('control layout', [2, 2, 2], [[0, 3, 'ltr']])], [('regression: lowest odd pass', [2, 2, 1, 1, 1], [[2, 3, 'rtl'], [0, 2, 'ltr']]), ('regression: lowest odd pass', [2, 1, 1, 1, 1, 3, 3, 3, 3, 1, 4], [[10, 1, 'ltr'], [9, 1, 'rtl'], [5, 4, 'rtl'], [1, 4, 'rtl'], [0, 1, 'ltr']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('partial-repair probe', [0, 0, 0, 1, 1], [[0, 3, 'ltr'], [3, 2, 'rtl']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [3, 3, 3, 3], [[0, 4, 'rtl']]), ('control layout', [1, 1, 1, 1], [[0, 4, 'rtl']]), ('control layout', [4, 4, 4, 4, 4, 4, 4, 2, 2], [[0, 7, 'ltr'], [7, 2, 'ltr']])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(args), expected)
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
LTR number inside RTL[[0, 2, 'rtl'], [2, 2, 'ltr'], [4, 1, 'rtl']][[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]Failed
regression: lowest odd pass[[4, 1, 'rtl'], [5, 1, 'rtl'], [0, 4, 'ltr']][[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']]Failed
regression: lowest odd pass[[10, 1, 'ltr'], [8, 2, 'rtl'], [6, 2, 'ltr'], [3, 3, 'rtl'], [0, 3, 'ltr']][[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']]Failed
regression: lowest odd pass[[1, 5, 'rtl'], [6, 2, 'ltr'], [0, 1, 'ltr']][[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']]Failed
lowest odd is three[[2, 1, 'ltr'], [1, 1, 'rtl'], [0, 1, 'ltr']][[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]Failed
control layout[[0, 4, 'ltr']][[0, 4, 'ltr']]Passed
control layout[[0, 4, 'ltr']][[0, 4, 'ltr']]Passed
control layout[[0, 1, 'ltr']][[0, 1, 'ltr']]Passed

SHA-256 / e66e4c87cffdeaa964c2bb17262ce19121b3b0dfac07e04dd3f24476935fb04f

3 / The verified repair

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

N = 1
observations = []
def solve(x):
    levels = x
    n = len(levels)
    runs = []
    for i in range(n):
        if runs and runs[-1][2] == levels[i]:
            runs[-1][1] += 1
        else:
            runs.append([i, 1, levels[i]])
    if not runs:
        return []
    odd = [r[2] for r in runs if r[2] % 2]
    if odd:
        for lev in range(max(r[2] for r in runs), min(odd) - 1, -1):
            out, i = [], 0
            while i < len(runs):
                if runs[i][2] >= lev:
                    j = i
                    while j < len(runs) and runs[j][2] >= lev:
                        j += 1
                    out.extend(runs[i:j][::-1])
                    i = j
                else:
                    out.append(runs[i])
                    i += 1
            runs = out
    return [[s, ln, 'rtl' if lv % 2 else 'ltr'] for s, ln, lv in runs]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('regression: lowest odd pass', [0, 0, 0, 0, 1, 3], [[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 3, 3, 3, 0, 0, 1, 1, 0], [[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']]), ('regression: lowest odd pass', [0, 1, 1, 1, 1, 1, 2, 2], [[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('control layout', [0, 0, 0, 0], [[0, 4, 'ltr']]), ('control layout', [4, 4, 4, 4], [[0, 4, 'ltr']]), ('control layout', [2], [[0, 1, 'ltr']])], [('regression: lowest odd pass', [1, 1, 1, 3, 3, 3, 3, 3, 2, 2, 2, 2], [[3, 5, 'rtl'], [8, 4, 'ltr'], [0, 3, 'rtl']]), ('regression: lowest odd pass', [1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 3], [[0, 3, 'rtl'], [3, 4, 'ltr'], [7, 4, 'ltr'], [11, 1, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 2, 1, 1, 1], [[4, 3, 'rtl'], [0, 4, 'ltr']]), ('partial-repair probe', [1, 1, 0], [[0, 2, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('control layout', [0, 0, 0, 0, 0, 2, 2, 2, 0], [[0, 5, 'ltr'], [5, 3, 'ltr'], [8, 1, 'ltr']]), ('control layout', [0, 0], [[0, 2, 'ltr']])], [('regression: lowest odd pass', [3, 3, 3, 4, 4, 4, 2, 2, 2, 2, 1], [[10, 1, 'rtl'], [3, 3, 'ltr'], [0, 3, 'rtl'], [6, 4, 'ltr']]), ('regression: lowest odd pass', [1, 2, 2], [[1, 2, 'ltr'], [0, 1, 'rtl']]), ('regression: lowest odd pass', [3, 3, 3, 1, 1, 1, 1], [[3, 4, 'rtl'], [0, 3, 'rtl']]), ('partial-repair probe', [1, 1, 0, 0, 0, 0, 3], [[0, 2, 'rtl'], [2, 4, 'ltr'], [6, 1, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [1, 1, 1, 1, 1, 1, 1], [[0, 7, 'rtl']]), ('control layout', [4, 4, 2, 4], [[0, 2, 'ltr'], [2, 1, 'ltr'], [3, 1, 'ltr']])], [('regression: lowest odd pass', [0, 1, 1, 1, 1, 3], [[0, 1, 'ltr'], [5, 1, 'rtl'], [1, 4, 'rtl']]), ('regression: lowest odd pass', [2, 2, 2, 1, 1], [[3, 2, 'rtl'], [0, 3, 'ltr']]), ('regression: lowest odd pass', [1, 1, 1, 1, 3, 0, 0, 0, 1], [[4, 1, 'rtl'], [0, 4, 'rtl'], [5, 3, 'ltr'], [8, 1, 'rtl']]), ('regression: lowest odd pass', [3, 3, 3, 1, 1, 3, 3], [[5, 2, 'rtl'], [3, 2, 'rtl'], [0, 3, 'rtl']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [2, 2, 2, 2], [[0, 4, 'ltr']]), ('control layout', [2, 2, 2], [[0, 3, 'ltr']])], [('regression: lowest odd pass', [2, 2, 1, 1, 1], [[2, 3, 'rtl'], [0, 2, 'ltr']]), ('regression: lowest odd pass', [2, 1, 1, 1, 1, 3, 3, 3, 3, 1, 4], [[10, 1, 'ltr'], [9, 1, 'rtl'], [5, 4, 'rtl'], [1, 4, 'rtl'], [0, 1, 'ltr']]), ('lowest odd is three', [2, 3, 2], [[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]), ('partial-repair probe', [0, 0, 0, 1, 1], [[0, 3, 'ltr'], [3, 2, 'rtl']]), ('LTR number inside RTL', [1, 1, 2, 2, 1], [[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]), ('control layout', [3, 3, 3, 3], [[0, 4, 'rtl']]), ('control layout', [1, 1, 1, 1], [[0, 4, 'rtl']]), ('control layout', [4, 4, 4, 4, 4, 4, 4, 2, 2], [[0, 7, 'ltr'], [7, 2, 'ltr']])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(args), expected)
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
LTR number inside RTL[[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']][[4, 1, 'rtl'], [2, 2, 'ltr'], [0, 2, 'rtl']]Passed
regression: lowest odd pass[[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']][[0, 4, 'ltr'], [5, 1, 'rtl'], [4, 1, 'rtl']]Passed
regression: lowest odd pass[[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']][[0, 3, 'ltr'], [3, 3, 'rtl'], [6, 2, 'ltr'], [8, 2, 'rtl'], [10, 1, 'ltr']]Passed
regression: lowest odd pass[[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']][[0, 1, 'ltr'], [6, 2, 'ltr'], [1, 5, 'rtl']]Passed
lowest odd is three[[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']][[0, 1, 'ltr'], [1, 1, 'rtl'], [2, 1, 'ltr']]Passed
control layout[[0, 4, 'ltr']][[0, 4, 'ltr']]Passed
control layout[[0, 4, 'ltr']][[0, 4, 'ltr']]Passed
control layout[[0, 1, 'ltr']][[0, 1, 'ltr']]Passed

SHA-256 / b61e8e065ebaa32d1c6d2bc235d1cf6da00f99aceb507a694f6c7631d82f6ddb

Verification & scope

A deterministic toy bidi model over stipulated class labels and integer levels; it is inspired by, but does not claim conformance to, any published algorithm. 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:49:57.329278+00:00.

Case digest / 95da1eacde6dc51b3f64daa6ddc397e9e6c94815ecb28be9779c37ed7317a8e4