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 = 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 = abs(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 remaining.

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):
    negative = False
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-') and not r['text'].startswith('-0')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 negative.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'].lstrip('-')
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'].strip().lstrip('-')
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 payload.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')[:2]
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.replace(',','.').split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 parts.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0] or '0'
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0].lstrip('+')
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 whole.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1][:3] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1].rstrip('0') if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 fraction.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and whole.isdigit()
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and whole.isdecimal()
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 whole_valid.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and fraction.isdigit())
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 fraction_valid.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and len(parts) == 1
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) == 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 valid.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction or '0') if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.rjust(3,'0')) if valid else None
    milliseconds = (-magnitude if negative else magnitude) if valid else None
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 magnitude.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = (-int(whole)*1000 + int(fraction.ljust(3,'0'))) if valid and negative else magnitude
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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):
    negative = r['text'].startswith('-')
    payload = r['text'][1:] if negative else r['text']
    parts = payload.split('.')
    whole = parts[0]
    fraction = parts[1] if len(parts) == 2 else ''
    whole_valid = len(whole) > 0 and all('0' <= c <= '9' for c in whole)
    fraction_valid = len(parts) == 1 or (len(parts) == 2 and 1 <= len(fraction) <= 3 and all('0' <= c <= '9' for c in fraction))
    valid = whole_valid and fraction_valid and len(parts) <= 2
    magnitude = int(whole) * 1000 + int(fraction.ljust(3,'0')) if valid else None
    milliseconds = -magnitude if valid and negative and int(whole) else magnitude
    return [valid,milliseconds,valid and negative and magnitude == 0]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'text': '1.2', 'probe': 1}), [True, 1200, False])
check('fixture 2', solve({'text': '-0.125', 'probe': 1}), [True, -125, False])
check('fixture 3', solve({'text': '12', 'probe': 1}), [True, 12000, False])
check('fixture 4', solve({'text': '-1.2', 'probe': 1}), [True, -1200, False])
check('fixture 5', solve({'text': '0', 'probe': 1}), [True, 0, False])
check('fixture 6', solve({'text': '-0.000', 'probe': 1}), [True, 0, True])
check('fixture 7', solve({'text': '1.', 'probe': 1}), [False, None, False])
check('fixture 8', solve({'text': '--1', 'probe': 1}), [False, None, False])
check('fixture 9', solve({'text': '+1', 'probe': 1}), [False, None, False])
check('fixture 10', solve({'text': ' 1', 'probe': 1}), [False, None, False])
check('fixture 11', solve({'text': '1,2', 'probe': 1}), [False, None, False])
check('fixture 12', solve({'text': '1.2.3', 'probe': 1}), [False, None, False])
check('fixture 13', solve({'text': '.2', 'probe': 1}), [False, None, False])
check('fixture 14', solve({'text': '1.2300', 'probe': 1}), [False, None, False])
check('fixture 15', solve({'text': '١', 'probe': 1}), [False, None, False])
check('fixture 16', solve({'text': '1.٢', 'probe': 1}), [False, None, False])
check('fixture 17', solve({'text': '1 2', 'probe': 1}), [False, None, False])
check('fixture 18', solve({'text': '2.000', 'probe': 1}), [True, 2000, False])
check('fixture 19', solve({'text': '0.12', 'probe': 1}), [True, 120, False])
variant = [({'text': '1.125', 'probe': 1}, [True, 1125, False]), ({'text': '2.125', 'probe': 1}, [True, 2125, False]), ({'text': '3.125', 'probe': 1}, [True, 3125, False]), ({'text': '4.125', 'probe': 1}, [True, 4125, False]), ({'text': '5.125', 'probe': 1}, [True, 5125, False])]
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 milliseconds.

Parse exact ASCII signed decimal epoch seconds: optional one leading minus, nonempty whole digits, optional dot plus one to three fractional digits. Reject whitespace, plus, comma, exponent, empty fraction, non-ASCII digits and excess precision. Return validity, exact signed milliseconds or None, and negative-zero lexical marker. No floating point is used.

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):
    hour = (r['previous_hour'] >> 4)*10+(r['previous_hour']&15)
    minute = (r['minute'] >> 4) * 10 + (r['minute'] & 15)
    second = (r['second'] >> 4) * 10 + (r['second'] & 15)
    bcd = all(0 <= r[k] <= 255 and r[k] >> 4 <= 9 and r[k] & 15 <= 9 for k in ('hour','minute','second')) and r['generation_before'] == r['generation_after']
    hour_valid = 1 <= hour <= 12 if r['twelve'] else 0 <= hour <= 23
    minute_valid = 0 <= minute <= 59
    second_valid = 0 <= second <= 59
    mode_valid = r['twelve'] or not r['pm']
    converted_hour = hour % 12 + 12 * int(r['pm']) if r['twelve'] else hour
    valid = bcd and hour_valid and minute_valid and second_valid and mode_valid and r['running']
    return [valid,converted_hour,minute,second]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 34, 56])
check('fixture 2', solve({'hour': 18, 'minute': 89, 'second': 89, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 12, 59, 59])
check('fixture 3', solve({'hour': 35, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 23, 0, 0])
check('fixture 4', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 0, 0])
check('fixture 5', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 0, 0, 0])
check('fixture 6', solve({'hour': 19, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 7', solve({'hour': 16, 'minute': 96, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 60, 0])
check('fixture 8', solve({'hour': 16, 'minute': 0, 'second': 96, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 0, 60])
check('fixture 9', solve({'hour': 26, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 20, 0, 0])
check('fixture 10', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': False, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 11', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': False, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 13, 0, 0])
check('fixture 12', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 13, 0, 0])
check('fixture 13', solve({'hour': 16, 'minute': 89, 'second': 88, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 10, 59, 58])
check('fixture 14', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 2}), [False, 0, 34, 56])
variant = [({'hour': 18, 'minute': 1, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 1, 56]), ({'hour': 18, 'minute': 2, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 2, 56]), ({'hour': 18, 'minute': 3, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 3, 56]), ({'hour': 18, 'minute': 4, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 4, 56]), ({'hour': 18, 'minute': 5, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 5, 56])]
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):
    hour = ((r['previous_hour'] >> 4)*10+(r['previous_hour']&15)) if r['minute'] == 0 else (r['hour'] >> 4)*10+(r['hour']&15)
    minute = (r['minute'] >> 4) * 10 + (r['minute'] & 15)
    second = (r['second'] >> 4) * 10 + (r['second'] & 15)
    bcd = all(0 <= r[k] <= 255 and r[k] >> 4 <= 9 and r[k] & 15 <= 9 for k in ('hour','minute','second')) and r['generation_before'] == r['generation_after']
    hour_valid = 1 <= hour <= 12 if r['twelve'] else 0 <= hour <= 23
    minute_valid = 0 <= minute <= 59
    second_valid = 0 <= second <= 59
    mode_valid = r['twelve'] or not r['pm']
    converted_hour = hour % 12 + 12 * int(r['pm']) if r['twelve'] else hour
    valid = bcd and hour_valid and minute_valid and second_valid and mode_valid and r['running']
    return [valid,converted_hour,minute,second]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 34, 56])
check('fixture 2', solve({'hour': 18, 'minute': 89, 'second': 89, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 12, 59, 59])
check('fixture 3', solve({'hour': 35, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 23, 0, 0])
check('fixture 4', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 0, 0])
check('fixture 5', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 0, 0, 0])
check('fixture 6', solve({'hour': 19, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 7', solve({'hour': 16, 'minute': 96, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 60, 0])
check('fixture 8', solve({'hour': 16, 'minute': 0, 'second': 96, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 0, 60])
check('fixture 9', solve({'hour': 26, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 20, 0, 0])
check('fixture 10', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': False, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 11', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': False, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 13, 0, 0])
check('fixture 12', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 13, 0, 0])
check('fixture 13', solve({'hour': 16, 'minute': 89, 'second': 88, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 10, 59, 58])
check('fixture 14', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 2}), [False, 0, 34, 56])
variant = [({'hour': 18, 'minute': 1, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 1, 56]), ({'hour': 18, 'minute': 2, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 2, 56]), ({'hour': 18, 'minute': 3, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 3, 56]), ({'hour': 18, 'minute': 4, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 4, 56]), ({'hour': 18, 'minute': 5, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 5, 56])]
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.

Controlled RTC snapshot consists of packed BCD hour/minute/second bytes, an hour-mode flag, PM flag and oscillator-running flag. Decode BCD only if each nibble is decimal. In twelve-hour mode valid hours are 1..12; in twenty-four-hour mode 0..23 and PM is forbidden. A stopped oscillator invalidates the reading. Return valid and 24-hour components. Equal generation stamps before and after register reads are required for a coherent snapshot; previous_hour is stale diagnostic context and must not replace the current hour.

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):
    hour = (r['hour'] >> 4) * 10 + (r['hour'] & 15)
    minute = (r['minute'] & 15) * 10 + (r['minute'] >> 4)
    second = (r['second'] >> 4) * 10 + (r['second'] & 15)
    bcd = all(0 <= r[k] <= 255 and r[k] >> 4 <= 9 and r[k] & 15 <= 9 for k in ('hour','minute','second')) and r['generation_before'] == r['generation_after']
    hour_valid = 1 <= hour <= 12 if r['twelve'] else 0 <= hour <= 23
    minute_valid = 0 <= minute <= 59
    second_valid = 0 <= second <= 59
    mode_valid = r['twelve'] or not r['pm']
    converted_hour = hour % 12 + 12 * int(r['pm']) if r['twelve'] else hour
    valid = bcd and hour_valid and minute_valid and second_valid and mode_valid and r['running']
    return [valid,converted_hour,minute,second]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 34, 56])
check('fixture 2', solve({'hour': 18, 'minute': 89, 'second': 89, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 12, 59, 59])
check('fixture 3', solve({'hour': 35, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 23, 0, 0])
check('fixture 4', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 0, 0])
check('fixture 5', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 0, 0, 0])
check('fixture 6', solve({'hour': 19, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 7', solve({'hour': 16, 'minute': 96, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 60, 0])
check('fixture 8', solve({'hour': 16, 'minute': 0, 'second': 96, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 0, 60])
check('fixture 9', solve({'hour': 26, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 20, 0, 0])
check('fixture 10', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': False, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 11', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': False, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 13, 0, 0])
check('fixture 12', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 13, 0, 0])
check('fixture 13', solve({'hour': 16, 'minute': 89, 'second': 88, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 10, 59, 58])
check('fixture 14', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 2}), [False, 0, 34, 56])
variant = [({'hour': 18, 'minute': 1, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 1, 56]), ({'hour': 18, 'minute': 2, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 2, 56]), ({'hour': 18, 'minute': 3, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 3, 56]), ({'hour': 18, 'minute': 4, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 4, 56]), ({'hour': 18, 'minute': 5, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 5, 56])]
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):
    hour = (r['hour'] >> 4) * 10 + (r['hour'] & 15)
    minute = (r['minute'] & 15)
    second = (r['second'] >> 4) * 10 + (r['second'] & 15)
    bcd = all(0 <= r[k] <= 255 and r[k] >> 4 <= 9 and r[k] & 15 <= 9 for k in ('hour','minute','second')) and r['generation_before'] == r['generation_after']
    hour_valid = 1 <= hour <= 12 if r['twelve'] else 0 <= hour <= 23
    minute_valid = 0 <= minute <= 59
    second_valid = 0 <= second <= 59
    mode_valid = r['twelve'] or not r['pm']
    converted_hour = hour % 12 + 12 * int(r['pm']) if r['twelve'] else hour
    valid = bcd and hour_valid and minute_valid and second_valid and mode_valid and r['running']
    return [valid,converted_hour,minute,second]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 34, 56])
check('fixture 2', solve({'hour': 18, 'minute': 89, 'second': 89, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 12, 59, 59])
check('fixture 3', solve({'hour': 35, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 23, 0, 0])
check('fixture 4', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 0, 0, 0])
check('fixture 5', solve({'hour': 0, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 0, 0, 0])
check('fixture 6', solve({'hour': 19, 'minute': 0, 'second': 0, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 7', solve({'hour': 16, 'minute': 96, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 60, 0])
check('fixture 8', solve({'hour': 16, 'minute': 0, 'second': 96, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 10, 0, 60])
check('fixture 9', solve({'hour': 26, 'minute': 0, 'second': 0, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 20, 0, 0])
check('fixture 10', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': False, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 1, 0, 0])
check('fixture 11', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': False, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [False, 13, 0, 0])
check('fixture 12', solve({'hour': 1, 'minute': 0, 'second': 0, 'twelve': True, 'pm': True, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 13, 0, 0])
check('fixture 13', solve({'hour': 16, 'minute': 89, 'second': 88, 'twelve': False, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}), [True, 10, 59, 58])
check('fixture 14', solve({'hour': 18, 'minute': 52, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 2}), [False, 0, 34, 56])
variant = [({'hour': 18, 'minute': 1, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 1, 56]), ({'hour': 18, 'minute': 2, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 2, 56]), ({'hour': 18, 'minute': 3, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 3, 56]), ({'hour': 18, 'minute': 4, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 4, 56]), ({'hour': 18, 'minute': 5, 'second': 86, 'twelve': True, 'pm': False, 'running': True, 'previous_hour': 17, 'generation_before': 1, 'generation_after': 1}, [True, 0, 5, 56])]
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.

Controlled RTC snapshot consists of packed BCD hour/minute/second bytes, an hour-mode flag, PM flag and oscillator-running flag. Decode BCD only if each nibble is decimal. In twelve-hour mode valid hours are 1..12; in twenty-four-hour mode 0..23 and PM is forbidden. A stopped oscillator invalidates the reading. Return valid and 24-hour components. Equal generation stamps before and after register reads are required for a coherent snapshot; previous_hour is stale diagnostic context and must not replace the current hour.

split: open-access