FA-51636 / Raster clipping / Open access

Sutherland hodgman raster rect: cyclic dedupe · case 01

Duplicate removal skips the wrap-around comparison, leaving the first vertex repeated at the end of the ring.

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

ROOT CAUSE

Duplicate removal skips the wrap-around comparison, leaving the first vertex repeated at the end of the ring.

VERIFIED REPAIR

Restore the specified clipping decision at cyclic dedupe. Each command is a polygon vertex list with exact coordinates. It is clipped in continuous raster coordinates against x>=0, x<=size, y>=0 and y<=size in that order with Sutherland-Hodgman: each stage walks edges from the previous vertex to the current vertex, emits the boundary intersection when entering before the inside vertex, emits the intersection when leaving, and chains its output into the next stage. Boundary points are inside. Cyclically repeated consecutive vertices are then removed; fewer than three remaining vertices yields an empty polygon. Vertices are returned as exact rational strings.

Unsuccessful approach: Comparing each vertex with its successor removes interior repeats but never compares the last vertex with the first.

Case contract

Each command is a polygon vertex list with exact coordinates. It is clipped in continuous raster coordinates against x>=0, x<=size, y>=0 and y<=size in that order with Sutherland-Hodgman: each stage walks edges from the previous vertex to the current vertex, emits the boundary intersection when entering before the inside vertex, emits the intersection when leaving, and chains its output into the next stage. Boundary points are inside. Cyclically repeated consecutive vertices are then removed; fewer than three remaining vertices yields an empty polygon. Vertices are returned as exact rational strings.

Why this case matters

Raster clipping decides which pixels a primitive may touch; a single wrong clip decision writes outside the target or scissor, or silently drops visible coverage.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if i==0 or p!=pts[i-1]]
        if len(clean)<3: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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
explicit case 0	`[[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]]`	`[[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]]`	Passed
explicit case 1	`[[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]]`	`[[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]]`	Passed
explicit case 2	`[[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]]`	`[[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]]`	Passed
explicit case 3	`[[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]]`	`[[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]]`	Passed
explicit case 4	`[[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]]`	`[[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]]`	Passed
explicit case 5	`[[]]`	`[[]]`	Passed
explicit case 6	`[[]]`	`[[]]`	Passed
explicit case 7	`[[]]`	`[[]]`	Passed
explicit case 8	`[[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]]`	`[[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]]`	Passed
explicit case 9	`[[['1/2', '2'], ['6', '2'], ['6', '5']]]`	`[[['1/2', '2'], ['6', '2'], ['6', '5']]]`	Passed
explicit case 10	`[[['0', '3'], ['0', '3/2'], ['2', '1'], ['0', '3']]]`	`[[['0', '3/2'], ['2', '1'], ['0', '3']]]`	Failed
explicit case 11	`[[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]]`	`[[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]]`	Passed

SHA-256 / 2f023f403f401ad5790601140181927e186b1263e32dbc3e1aceb60bad522d4d

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if i+1==len(pts) or p!=pts[i+1]]
        if len(clean)<3: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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
explicit case 0	`[[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]]`	`[[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]]`	Passed
explicit case 1	`[[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]]`	`[[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]]`	Passed
explicit case 2	`[[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]]`	`[[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]]`	Passed
explicit case 3	`[[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]]`	`[[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]]`	Passed
explicit case 4	`[[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]]`	`[[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]]`	Passed
explicit case 5	`[[]]`	`[[]]`	Passed
explicit case 6	`[[]]`	`[[]]`	Passed
explicit case 7	`[[]]`	`[[]]`	Passed
explicit case 8	`[[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]]`	`[[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]]`	Passed
explicit case 9	`[[['1/2', '2'], ['6', '2'], ['6', '5']]]`	`[[['1/2', '2'], ['6', '2'], ['6', '5']]]`	Passed
explicit case 10	`[[['0', '3'], ['0', '3/2'], ['2', '1'], ['0', '3']]]`	`[[['0', '3/2'], ['2', '1'], ['0', '3']]]`	Failed
explicit case 11	`[[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]]`	`[[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]]`	Passed

SHA-256 / ea0639d7cd48e64fcbbb90dd54429ad51ab93a5752be023d854ba9ce3e73e999

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def stage(poly,inside,cross):
        res=[]
        for i in range(len(poly)):
            cur=poly[i]
            prev=poly[i-1]
            if inside(cur):
                if not inside(prev): res.append(cross(prev,cur))
                res.append(cur)
            elif inside(prev):
                res.append(cross(prev,cur))
        return res
    def at_x(k):
        return lambda p,c: (Fraction(k),p[1]+(c[1]-p[1])*(k-p[0])/(c[0]-p[0]))
    def at_y(k):
        return lambda p,c: (p[0]+(c[0]-p[0])*(k-p[1])/(c[1]-p[1]),Fraction(k))
    out=[]
    for poly in commands:
        src=[(Fraction(x),Fraction(y)) for x,y in poly]
        pts=stage(src,lambda p:p[0]>=0,at_x(0))
        pts=stage(pts,lambda p:p[0]<=size,at_x(size))
        pts=stage(pts,lambda p:p[1]>=0,at_y(0))
        pts=stage(pts,lambda p:p[1]<=size,at_y(size))
        clean=[p for i,p in enumerate(pts) if p!=pts[i-1]]
        if len(clean)<3: clean=[]
        out.append([[str(x),str(y)] for x,y in clean])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[1, 1], [5, 1], [5, 5], [1, 5]]], 6), [[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 6), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [8, 2], [2, 4]]], 6), [[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [8, -2], [8, 8], [-2, 8]]], 6), [[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 6), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 6), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 6), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 6), [[]])
    check('explicit case 8', solve([[[1, 1], [7, 1], [1, 9]]], 6), [[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]])
    check('explicit case 9', solve([[['1/2', 2], [6, 2], [6, 5]]], 6), [[['1/2', '2'], ['6', '2'], ['6', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 6), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [8, 3], [6, 4], [5, 1]]], 6), [[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]])
if N == 2:
    check('explicit case 0', solve([[[1, 1], [6, 1], [6, 6], [1, 6]]], 7), [[['1', '1'], ['6', '1'], ['6', '6'], ['1', '6']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 7), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [9, 2], [2, 4]]], 7), [[['1', '1'], ['7', '7/4'], ['7', '18/7'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [9, -2], [9, 9], [-2, 9]]], 7), [[['0', '7'], ['0', '0'], ['7', '0'], ['7', '7']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 7), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 7), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 7), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 7), [[]])
    check('explicit case 8', solve([[[1, 1], [8, 1], [1, 10]]], 7), [[['1', '7'], ['1', '1'], ['7', '1'], ['7', '16/7'], ['10/3', '7']]])
    check('explicit case 9', solve([[['1/2', 2], [7, 2], [7, 5]]], 7), [[['1/2', '2'], ['7', '2'], ['7', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 7), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [9, 3], [7, 4], [6, 1]]], 7), [[['3', '1'], ['7', '7/3'], ['7', '4'], ['6', '1']]])
if N == 3:
    check('explicit case 0', solve([[[1, 1], [7, 1], [7, 7], [1, 7]]], 8), [[['1', '1'], ['7', '1'], ['7', '7'], ['1', '7']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 8), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [10, 2], [2, 4]]], 8), [[['1', '1'], ['8', '16/9'], ['8', '5/2'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [10, -2], [10, 10], [-2, 10]]], 8), [[['0', '8'], ['0', '0'], ['8', '0'], ['8', '8']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 8), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 8), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 8), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 8), [[]])
    check('explicit case 8', solve([[[1, 1], [9, 1], [1, 11]]], 8), [[['1', '8'], ['1', '1'], ['8', '1'], ['8', '9/4'], ['17/5', '8']]])
    check('explicit case 9', solve([[['1/2', 2], [8, 2], [8, 5]]], 8), [[['1/2', '2'], ['8', '2'], ['8', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 8), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [10, 3], [8, 4], [7, 1]]], 8), [[['3', '1'], ['8', '17/7'], ['8', '4'], ['7', '1']]])
if N == 4:
    check('explicit case 0', solve([[[1, 1], [8, 1], [8, 8], [1, 8]]], 9), [[['1', '1'], ['8', '1'], ['8', '8'], ['1', '8']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 9), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [11, 2], [2, 4]]], 9), [[['1', '1'], ['9', '9/5'], ['9', '22/9'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [11, -2], [11, 11], [-2, 11]]], 9), [[['0', '9'], ['0', '0'], ['9', '0'], ['9', '9']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 9), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 9), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 9), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 9), [[]])
    check('explicit case 8', solve([[[1, 1], [10, 1], [1, 12]]], 9), [[['1', '9'], ['1', '1'], ['9', '1'], ['9', '20/9'], ['38/11', '9']]])
    check('explicit case 9', solve([[['1/2', 2], [9, 2], [9, 5]]], 9), [[['1/2', '2'], ['9', '2'], ['9', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 9), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [11, 3], [9, 4], [8, 1]]], 9), [[['3', '1'], ['9', '5/2'], ['9', '4'], ['8', '1']]])
if N == 5:
    check('explicit case 0', solve([[[1, 1], [9, 1], [9, 9], [1, 9]]], 10), [[['1', '1'], ['9', '1'], ['9', '9'], ['1', '9']]])
    check('explicit case 1', solve([[[-2, 1], [3, 1], [3, 4]]], 10), [[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]])
    check('explicit case 2', solve([[[1, 1], [12, 2], [2, 4]]], 10), [[['1', '1'], ['10', '20/11'], ['10', '12/5'], ['2', '4']]])
    check('explicit case 3', solve([[[-2, -2], [12, -2], [12, 12], [-2, 12]]], 10), [[['0', '10'], ['0', '0'], ['10', '0'], ['10', '10']]])
    check('explicit case 4', solve([[[2, -3], [4, 2], [1, 3]]], 10), [[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]])
    check('explicit case 5', solve([[[-3, 1], [-1, 1], [-2, 3]]], 10), [[]])
    check('explicit case 6', solve([[[0, 1], [0, 3], [-2, 2]]], 10), [[]])
    check('explicit case 7', solve([[[0, 0], [-1, -2], [-2, -1]]], 10), [[]])
    check('explicit case 8', solve([[[1, 1], [11, 1], [1, 13]]], 10), [[['1', '10'], ['1', '1'], ['10', '1'], ['10', '11/5'], ['7/2', '10']]])
    check('explicit case 9', solve([[['1/2', 2], [10, 2], [10, 5]]], 10), [[['1/2', '2'], ['10', '2'], ['10', '5']]])
    check('explicit case 10', solve([[[-2, 2], [2, 1], [0, 3]]], 10), [[['0', '3/2'], ['2', '1'], ['0', '3']]])
    check('explicit case 11', solve([[[3, 1], [12, 3], [10, 4], [9, 1]]], 10), [[['3', '1'], ['10', '23/9'], ['10', '4'], ['9', '1']]])
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
explicit case 0	`[[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]]`	`[[['1', '1'], ['5', '1'], ['5', '5'], ['1', '5']]]`	Passed
explicit case 1	`[[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]]`	`[[['0', '11/5'], ['0', '1'], ['3', '1'], ['3', '4']]]`	Passed
explicit case 2	`[[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]]`	`[[['1', '1'], ['6', '12/7'], ['6', '8/3'], ['2', '4']]]`	Passed
explicit case 3	`[[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]]`	`[[['0', '6'], ['0', '0'], ['6', '0'], ['6', '6']]]`	Passed
explicit case 4	`[[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]]`	`[[['3/2', '0'], ['16/5', '0'], ['4', '2'], ['1', '3']]]`	Passed
explicit case 5	`[[]]`	`[[]]`	Passed
explicit case 6	`[[]]`	`[[]]`	Passed
explicit case 7	`[[]]`	`[[]]`	Passed
explicit case 8	`[[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]]`	`[[['1', '6'], ['1', '1'], ['6', '1'], ['6', '7/3'], ['13/4', '6']]]`	Passed
explicit case 9	`[[['1/2', '2'], ['6', '2'], ['6', '5']]]`	`[[['1/2', '2'], ['6', '2'], ['6', '5']]]`	Passed
explicit case 10	`[[['0', '3/2'], ['2', '1'], ['0', '3']]]`	`[[['0', '3/2'], ['2', '1'], ['0', '3']]]`	Passed
explicit case 11	`[[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]]`	`[[['3', '1'], ['6', '11/5'], ['6', '4'], ['5', '1']]]`	Passed

SHA-256 / ab21f2e9e146d816b085b450cb29ce9d1e9f0ceeca9470bda8e5c19fd961fa8b

Verification & scope

Exact integer/rational arithmetic on small stipulated fixtures models the clipping decision only; no memory layout, GPU pipeline, graphics API or standards 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:20.833720+00:00.

Case digest / d9517ddf30c64977ffbf8b79c15683104e1684e1eb91e184ef7fd30a2215889a