FAILURE MAP
← Case archive

FA-51476 / Raster clipping / Open access

User distance clip cull: rejection precedence · case 01

Partial clipping overrides a rejection by another active plane.

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

ROOT CAUSE

Partial clipping overrides a rejection by another active plane.

VERIFIED REPAIR

Apply the documented state transition at rejection precedence. 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: Only rejecting without any partial-plane flag still loses rejection precedence.

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 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('clipped' if partial else 'discarded' if reject 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['clipped']['discarded']Failed
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 / 3394c8336eb625ff2e422bfc0f077507e3449518f73ee6cfeb0ce9ac01842346

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 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 and not partial 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['clipped']['discarded']Failed
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 / 352dc943f3e71a82a1c556852acc4cd9da3241191d15fd43733da0651481abfe

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

Case digest / e441d3d41631a154bdb65a99d4d83dc582a6e911d3f755121ce2a125d62aac84