FAILURE MAP
← Case archive

FA-51436 / Raster clipping / Open access

User distance clip cull: clip reject any · case 01

A single negative clip vertex rejects a straddling primitive instead of clipping it.

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

ROOT CAUSE

A single negative clip vertex rejects a straddling primitive instead of clipping it.

VERIFIED REPAIR

Apply the documented state transition at clip reject any. Each primitive carries per-vertex clip-distance and cull-distance arrays, active bitmasks and a raster-discard flag. A primitive is rejected if every vertex is negative on any one enabled clip or cull plane. Surviving primitives need clipping if any enabled clip distance is negative; cull distances never cause partial clipping. Missing components default to zero and disabled plane bits are ignored. Empty primitives and raster-discarded primitives emit discarded. Only low size plane slots exist.

Unsuccessful approach: Majority-negative rejection still discards primitives with a visible portion.

Case contract

Each primitive carries per-vertex clip-distance and cull-distance arrays, active bitmasks and a raster-discard flag. A primitive is rejected if every vertex is negative on any one enabled clip or cull plane. Surviving primitives need clipping if any enabled clip distance is negative; cull distances never cause partial clipping. Missing components default to zero and disabled plane bits are ignored. Empty primitives and raster-discarded primitives emit discarded. Only low size plane slots exist.

Why this case matters

Raster clip state can leak coverage across draws even when every individual region is valid.

1 / The failure

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

N = 1
observations = []
def solve(commands, size):
    out=[]
    for clips,culls,clip_mask,cull_mask,discard in commands:
        if discard or not clips: out.append('discarded'); continue
        reject=False
        partial=False
        for plane in range(size):
            if clip_mask & (1<<plane):
                values=[v[plane] if plane<len(v) else 0 for v in clips]
                if any(x<0 for x in values): reject=True
                if any(x<0 for x in values): partial=True
            if cull_mask & (1<<plane):
                values=[v[plane] if plane<len(v) else 0 for v in culls]
                if values and all(x<0 for x in values): reject=True
        out.append('discarded' if reject else 'clipped' if partial else 'accepted')
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 4), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 4), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 4), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 4), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 4), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 4), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 4), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 4), ['accepted'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 4), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 4), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 4), ['accepted'])
if N == 2:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 5), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 5), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 5), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 5), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 5), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 5), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 5), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 5), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 5), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 5), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 5), ['accepted'])
if N == 3:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 6), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 6), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 6), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 6), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 6), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 6), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 6), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 6), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 6), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 6), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 6), ['accepted'])
if N == 4:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 7), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 7), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 7), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 7), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 7), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 7), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 7), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 7), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 7), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 7), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 7), ['accepted'])
if N == 5:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 8), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 8), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 8), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 8), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 8), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 8), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 8), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 8), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 8), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 8), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 8), ['accepted'])
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
explicit sequence 0['discarded']['discarded']Passed
explicit sequence 1['discarded']['clipped']Failed
explicit sequence 2['discarded']['clipped']Failed
explicit sequence 3['accepted']['accepted']Passed
explicit sequence 4['accepted']['accepted']Passed
explicit sequence 5['accepted']['accepted']Passed
explicit sequence 6['accepted']['accepted']Passed
explicit sequence 7['discarded']['discarded']Passed
explicit sequence 8['discarded']['clipped']Failed
explicit sequence 9['discarded']['discarded']Passed
explicit sequence 10['accepted']['accepted']Passed
explicit sequence 11['discarded']['discarded']Passed
explicit sequence 12['accepted']['accepted']Passed
explicit sequence 13['discarded']['clipped']Failed
explicit sequence 14['accepted']['accepted']Passed

SHA-256 / b0e8b5d71fe84499799f49e175f1a80e848dce5da87de98896b7746ee99abc87

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(commands, size):
    out=[]
    for clips,culls,clip_mask,cull_mask,discard in commands:
        if discard or not clips: out.append('discarded'); continue
        reject=False
        partial=False
        for plane in range(size):
            if clip_mask & (1<<plane):
                values=[v[plane] if plane<len(v) else 0 for v in clips]
                if sum(x<0 for x in values)>len(values)//2: reject=True
                if any(x<0 for x in values): partial=True
            if cull_mask & (1<<plane):
                values=[v[plane] if plane<len(v) else 0 for v in culls]
                if values and all(x<0 for x in values): reject=True
        out.append('discarded' if reject else 'clipped' if partial else 'accepted')
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 4), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 4), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 4), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 4), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 4), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 4), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 4), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 4), ['accepted'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 4), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 4), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 4), ['accepted'])
if N == 2:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 5), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 5), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 5), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 5), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 5), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 5), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 5), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 5), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 5), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 5), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 5), ['accepted'])
if N == 3:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 6), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 6), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 6), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 6), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 6), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 6), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 6), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 6), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 6), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 6), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 6), ['accepted'])
if N == 4:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 7), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 7), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 7), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 7), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 7), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 7), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 7), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 7), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 7), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 7), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 7), ['accepted'])
if N == 5:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 8), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 8), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 8), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 8), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 8), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 8), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 8), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 8), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 8), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 8), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 8), ['accepted'])
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
explicit sequence 0['discarded']['discarded']Passed
explicit sequence 1['clipped']['clipped']Passed
explicit sequence 2['clipped']['clipped']Passed
explicit sequence 3['accepted']['accepted']Passed
explicit sequence 4['accepted']['accepted']Passed
explicit sequence 5['accepted']['accepted']Passed
explicit sequence 6['accepted']['accepted']Passed
explicit sequence 7['discarded']['discarded']Passed
explicit sequence 8['clipped']['clipped']Passed
explicit sequence 9['discarded']['discarded']Passed
explicit sequence 10['accepted']['accepted']Passed
explicit sequence 11['discarded']['discarded']Passed
explicit sequence 12['accepted']['accepted']Passed
explicit sequence 13['discarded']['clipped']Failed
explicit sequence 14['accepted']['accepted']Passed

SHA-256 / 48a995993c1522fd97a75ca2f3fd82f00b83acbf3e62eb7e43fe933ccde92577

3 / The verified repair

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

N = 1
observations = []
def solve(commands, size):
    out=[]
    for clips,culls,clip_mask,cull_mask,discard in commands:
        if discard or not clips: out.append('discarded'); continue
        reject=False
        partial=False
        for plane in range(size):
            if clip_mask & (1<<plane):
                values=[v[plane] if plane<len(v) else 0 for v in clips]
                if all(x<0 for x in values): reject=True
                if any(x<0 for x in values): partial=True
            if cull_mask & (1<<plane):
                values=[v[plane] if plane<len(v) else 0 for v in culls]
                if values and all(x<0 for x in values): reject=True
        out.append('discarded' if reject else 'clipped' if partial else 'accepted')
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 4), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 4), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 4), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 4), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 4), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 4), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 4), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 4), ['accepted'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 4), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 4), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 4), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 4), ['accepted'])
if N == 2:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 5), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 5), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 5), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 5), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 5), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 5), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 5), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 5), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 5), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 5), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 5), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 5), ['accepted'])
if N == 3:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 6), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 6), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 6), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 6), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 6), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 6), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 6), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 6), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 6), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 6), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 6), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 6), ['accepted'])
if N == 4:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 7), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 7), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 7), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 7), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 7), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 7), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 7), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 7), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 7), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 7), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 7), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 7), ['accepted'])
if N == 5:
    check('explicit sequence 0', solve([[[[1], [1]], [[1], [1]], 1, 0, True]], 8), ['discarded'])
    check('explicit sequence 1', solve([[[[-1], [1]], [[0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 2', solve([[[[1], [-1]], [[0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 3', solve([[[[1], [1]], [[-3], [1]], 0, 1, False]], 8), ['accepted'])
    check('explicit sequence 4', solve([[[[1], [1]], [[-1], [1]], 0, 1, False]], 8), ['accepted'])
    check('explicit sequence 5', solve([[[[-1], [-1]], [[0], [0]], 2, 0, False]], 8), ['accepted'])
    check('explicit sequence 6', solve([[[[0], [0]], [[-1], [-1]], 0, 2, False]], 8), ['accepted'])
    check('explicit sequence 7', solve([[[[1], [1]], [[-1], [-1]], 0, 1, False]], 8), ['discarded'])
    check('explicit sequence 8', solve([[[[-1], [1]], [[-1], [-1]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 9', solve([[[[-1, 1], [1, 1]], [[-1], [-1]], 1, 1, False]], 8), ['discarded'])
    check('explicit sequence 10', solve([[[[1, 1, 1, 1, -1], [1, 1, 1, 1, -1]], [[0], [0]], 16, 0, False]], 8), ['discarded'])
    check('explicit sequence 11', solve([[[], [], 0, 0, False]], 8), ['discarded'])
    check('explicit sequence 12', solve([[[[0], [0]], [[0], [0]], 1, 1, False]], 8), ['accepted'])
    check('explicit sequence 13', solve([[[[-1], [-1], [1]], [[0], [0], [0]], 1, 0, False]], 8), ['clipped'])
    check('explicit sequence 14', solve([[[[-1], [1]], [[0], [0]], 0, 1, False]], 8), ['accepted'])
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
explicit sequence 0['discarded']['discarded']Passed
explicit sequence 1['clipped']['clipped']Passed
explicit sequence 2['clipped']['clipped']Passed
explicit sequence 3['accepted']['accepted']Passed
explicit sequence 4['accepted']['accepted']Passed
explicit sequence 5['accepted']['accepted']Passed
explicit sequence 6['accepted']['accepted']Passed
explicit sequence 7['discarded']['discarded']Passed
explicit sequence 8['clipped']['clipped']Passed
explicit sequence 9['discarded']['discarded']Passed
explicit sequence 10['accepted']['accepted']Passed
explicit sequence 11['discarded']['discarded']Passed
explicit sequence 12['accepted']['accepted']Passed
explicit sequence 13['clipped']['clipped']Passed
explicit sequence 14['accepted']['accepted']Passed

SHA-256 / 658c0740d600133eed03303f481b4a6731da1c829290a21c3f25592075066087

Verification & scope

Finite one-dimensional integer sample sets model coverage state only; no geometric intersection, memory layout, GPU or graphics-standard conformance is claimed. 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:45:18.894378+00:00.

Case digest / 1bc652e9ee2ec392b9415c1b33cfe6867b15a7622a2f75890dea7deadd1f7087