broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = r['leap']
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86399
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for extra.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else r['label'] // 3600
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else r['label'] // 3600 % 24
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for hour.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else r['label'] // 60 % 60
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else r['label'] % 60
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for minute.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else r['label'] % 60
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else min(59,r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for second.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == 86399
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for last.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else 86400 - r['label']
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label'] - 1
    midnight = r['origin'] + length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for remaining.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = r['origin'] + 86400
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    length = 86400 + int(r['leap'])
    valid = 0 <= r['label'] < length
    atomic = r['origin'] + r['label'] if valid else None
    extra = valid and r['label'] == 86400
    hour = None if not valid else (23 if extra else r['label'] // 3600)
    minute = None if not valid else (59 if extra else r['label'] // 60 % 60)
    second = None if not valid else (60 if extra else r['label'] % 60)
    last = valid and r['label'] == length - 1
    remaining = None if not valid else length - r['label']
    midnight = length
    return [valid,atomic,[hour,minute,second],last,remaining,midnight]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'leap': True, 'label': 86400, 'origin': 100000}), [True, 186400, [23, 59, 60], True, 1, 186401])
check('fixture 2', solve({'leap': False, 'label': 86400, 'origin': 100000}), [False, None, [None, None, None], False, None, 186400])
check('fixture 3', solve({'leap': True, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], False, 2, 86451])
check('fixture 4', solve({'leap': False, 'label': 86399, 'origin': 50}), [True, 86449, [23, 59, 59], True, 1, 86450])
check('fixture 5', solve({'leap': True, 'label': 0, 'origin': -100}), [True, -100, [0, 0, 0], False, 86401, 86301])
check('fixture 6', solve({'leap': False, 'label': 3601, 'origin': 0}), [True, 3601, [1, 0, 1], False, 82799, 86400])
check('fixture 7', solve({'leap': True, 'label': -1, 'origin': 100}), [False, None, [None, None, None], False, None, 86501])
check('fixture 8', solve({'leap': True, 'label': 86401, 'origin': 20}), [False, None, [None, None, None], False, None, 86421])
check('fixture 9', solve({'leap': False, 'label': 0, 'origin': 0}), [True, 0, [0, 0, 0], False, 86400, 86400])
check('fixture 10', solve({'leap': True, 'label': 3661, 'origin': -20}), [True, 3641, [1, 1, 1], False, 82740, 86381])
variant = [({'leap': True, 'label': 86400, 'origin': 100001}, [True, 186401, [23, 59, 60], True, 1, 186402]), ({'leap': True, 'label': 86400, 'origin': 100002}, [True, 186402, [23, 59, 60], True, 1, 186403]), ({'leap': True, 'label': 86400, 'origin': 100003}, [True, 186403, [23, 59, 60], True, 1, 186404]), ({'leap': True, 'label': 86400, 'origin': 100004}, [True, 186404, [23, 59, 60], True, 1, 186405]), ({'leap': True, 'label': 86400, 'origin': 100005}, [True, 186405, [23, 59, 60], True, 1, 186406])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for midnight.

A stipulated positive-leap day has label 86400 following ordinary 0..86399; a normal day does not. Return validity, atomic origin+label or None, display [hour,minute,second] (23:59:60 for extra label), final-label flag, ticks until next midnight or None, and atomic next-midnight coordinate. No real-world leap table is claimed.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] + r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start'] + 1
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for width.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(r['atomic'] - r['start'],width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for progress.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * abs(r['leap'])
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for correction.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] + correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - int(correction)
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for smeared.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] < r['atomic'] <= r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] <= r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for active.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 + Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for slope.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = smeared - r['atomic']
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = abs(r['atomic'] - smeared)
    start_coordinate = r['start']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for residual.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start'] - r['leap']
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = 0
    end_coordinate = r['end'] - r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for start_coordinate.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
    width = r['end'] - r['start']
    progress = Fraction(min(width,max(0,r['atomic'] - r['start'])),width)
    correction = progress * r['leap']
    smeared = r['atomic'] - correction
    active = r['start'] <= r['atomic'] < r['end']
    slope = 1 - Fraction(r['leap'],width) if active else Fraction(1)
    residual = r['atomic'] - smeared
    start_coordinate = r['start']
    end_coordinate = r['end'] + r['leap']
    remaining = r['leap'] - correction
    return [str(smeared),str(slope),str(residual),[start_coordinate,end_coordinate],str(remaining)]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'start': 10, 'end': 20, 'atomic': 10, 'leap': 1}), ['10', '9/10', '0', [10, 19], '1'])
check('fixture 2', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 1}), ['29/2', '9/10', '1/2', [10, 19], '1/2'])
check('fixture 3', solve({'start': 10, 'end': 20, 'atomic': 20, 'leap': 1}), ['19', '1', '1', [10, 19], '0'])
check('fixture 4', solve({'start': 10, 'end': 20, 'atomic': 25, 'leap': 1}), ['24', '1', '1', [10, 19], '0'])
check('fixture 5', solve({'start': 10, 'end': 20, 'atomic': 5, 'leap': 1}), ['5', '1', '0', [10, 19], '1'])
check('fixture 6', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': -1}), ['31/2', '11/10', '-1/2', [10, 21], '-1/2'])
check('fixture 7', solve({'start': 2, 'end': 8, 'atomic': 3, 'leap': 2}), ['8/3', '2/3', '1/3', [2, 6], '5/3'])
check('fixture 8', solve({'start': 2, 'end': 8, 'atomic': 7, 'leap': -2}), ['26/3', '4/3', '-5/3', [2, 10], '-1/3'])
check('fixture 9', solve({'start': 10, 'end': 20, 'atomic': 15, 'leap': 0}), ['15', '1', '0', [10, 20], '0'])
check('fixture 10', solve({'start': 1, 'end': 4, 'atomic': 2, 'leap': 1}), ['5/3', '2/3', '1/3', [1, 3], '2/3'])
variant = [({'start': 10, 'end': 20, 'atomic': 10, 'leap': 2}, ['10', '4/5', '0', [10, 18], '2']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 3}, ['10', '7/10', '0', [10, 17], '3']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 4}, ['10', '3/5', '0', [10, 16], '4']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 5}, ['10', '1/2', '0', [10, 15], '5']), ({'start': 10, 'end': 20, 'atomic': 10, 'leap': 6}, ['10', '2/5', '0', [10, 14], '6'])]
check("variant capture", solve(variant[N-1][0]), variant[N-1][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)

prompt:
The decoded time state disagrees with the explicit regression oracle for end_coordinate.

Stipulated smear removes signed leap L linearly over atomic [start,end], with positive width>|L| and clamped progress outside. Return exact rational smeared coordinate, effective slope (inside start-inclusive/end-exclusive window), signed removed correction, smeared endpoint coordinates and remaining signed correction. Fraction outputs use canonical strings.

split: open-access