FA-17566 / Time representation / Open access
Clock bias is scaled a second time or discarded · case 01
The decoded time state disagrees with the explicit regression oracle for mapped.
ROOT CAUSE
Clock bias is scaled a second time or discarded.
VERIFIED REPAIR
Preserve the declared coordinate and state contract at mapped: mapped = slope * r['reading'] + intercept.
Unsuccessful approach: The partial correction still substitutes slope * r['reading'] at the same fault site.
Case contract
Two increasing device/reference calibration pairs define a positive exact affine clock mapping. Return rational slope/intercept, mapped device reading, signed observation-minus-prediction residual, inverse-mapped observed reference, and extrapolation direction (-1 before support, 0 within including anchors, 1 after). Fractions serialize canonically as strings.
Why this case matters
Clock transfer and timestamp consumers require preserved coordinate, phase, validity and elapsed-time semantics.
1 / The failure
Exit 1"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
device_span = r['d1'] - r['d0']
reference_span = r['t1'] - r['t0']
slope = Fraction(reference_span, device_span)
reciprocal = 1 / slope
intercept = r['t0'] - slope * r['d0']
mapped = slope * (r['reading'] + intercept)
residual = r['observed'] - mapped
inverse = (r['observed'] - intercept) * reciprocal
fraction = Fraction(r['reading'] - r['d0'], device_span)
direction = -1 if fraction < 0 else (1 if fraction > 1 else 0)
return [str(slope),str(intercept),str(mapped),str(residual),str(inverse),direction]
def check(label, actual, expected):
observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 14}), ['3/2', '7', '13', '1', '14/3', 0])
check('fixture 2', solve({'d0': -4, 'd1': 4, 't0': -10, 't1': 6, 'reading': -6, 'observed': -13}), ['2', '-2', '-14', '1', '-11/2', -1])
check('fixture 3', solve({'d0': 1, 'd1': 5, 't0': 2, 't1': 4, 'reading': 8, 'observed': 5}), ['1/2', '3/2', '11/2', '-1/2', '7', 1])
check('fixture 4', solve({'d0': 0, 'd1': 10, 't0': 5, 't1': 25, 'reading': 0, 'observed': 5}), ['2', '5', '5', '0', '0', 0])
check('fixture 5', solve({'d0': 2, 'd1': 8, 't0': -3, 't1': 0, 'reading': 8, 'observed': 1}), ['1/2', '-4', '0', '1', '10', 0])
check('fixture 6', solve({'d0': -8, 'd1': -2, 't0': 2, 't1': 14, 'reading': -5, 'observed': 7}), ['2', '18', '8', '-1', '-11/2', 0])
check('fixture 7', solve({'d0': 4, 'd1': 10, 't0': 30, 't1': 39, 'reading': 10, 'observed': 40}), ['3/2', '24', '39', '1', '32/3', 0])
check('fixture 8', solve({'d0': 2, 'd1': 5, 't0': 1, 't1': 2, 'reading': 3, 'observed': 1}), ['1/3', '1/3', '4/3', '-1/3', '2', 0])
check('fixture 9', solve({'d0': 3, 'd1': 9, 't0': 4, 't1': 16, 'reading': 3, 'observed': 4}), ['2', '-2', '4', '0', '3', 0])
check('fixture 10', solve({'d0': 1, 'd1': 2, 't0': 1, 't1': 3, 'reading': 2, 'observed': 3}), ['2', '-1', '3', '0', '2', 0])
variant = [({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 15}, ['3/2', '7', '13', '2', '16/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 16}, ['3/2', '7', '13', '3', '6', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 17}, ['3/2', '7', '13', '4', '20/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 18}, ['3/2', '7', '13', '5', '22/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 19}, ['3/2', '7', '13', '6', '8', 0])]
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)
| Boundary fixture | Actual | Expected | Outcome |
|---|---|---|---|
| fixture 1 | ['3/2', '7', '33/2', '-5/2', '14/3', 0] | ['3/2', '7', '13', '1', '14/3', 0] | Failed |
| fixture 2 | ['2', '-2', '-16', '3', '-11/2', -1] | ['2', '-2', '-14', '1', '-11/2', -1] | Failed |
| fixture 3 | ['1/2', '3/2', '19/4', '1/4', '7', 1] | ['1/2', '3/2', '11/2', '-1/2', '7', 1] | Failed |
| fixture 4 | ['2', '5', '10', '-5', '0', 0] | ['2', '5', '5', '0', '0', 0] | Failed |
| fixture 5 | ['1/2', '-4', '2', '-1', '10', 0] | ['1/2', '-4', '0', '1', '10', 0] | Failed |
| fixture 6 | ['2', '18', '26', '-19', '-11/2', 0] | ['2', '18', '8', '-1', '-11/2', 0] | Failed |
| fixture 7 | ['3/2', '24', '51', '-11', '32/3', 0] | ['3/2', '24', '39', '1', '32/3', 0] | Failed |
| fixture 8 | ['1/3', '1/3', '10/9', '-1/9', '2', 0] | ['1/3', '1/3', '4/3', '-1/3', '2', 0] | Failed |
| fixture 9 | ['2', '-2', '2', '2', '3', 0] | ['2', '-2', '4', '0', '3', 0] | Failed |
| fixture 10 | ['2', '-1', '2', '1', '2', 0] | ['2', '-1', '3', '0', '2', 0] | Failed |
| variant capture | ['3/2', '7', '33/2', '-3/2', '16/3', 0] | ['3/2', '7', '13', '2', '16/3', 0] | Failed |
SHA-256 / 8793e1fc0bdb333daa44445a5a7b499dbc3626eee749db5737292dfad991fd1b
2 / The unsuccessful fix
Exit 1"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
device_span = r['d1'] - r['d0']
reference_span = r['t1'] - r['t0']
slope = Fraction(reference_span, device_span)
reciprocal = 1 / slope
intercept = r['t0'] - slope * r['d0']
mapped = slope * r['reading']
residual = r['observed'] - mapped
inverse = (r['observed'] - intercept) * reciprocal
fraction = Fraction(r['reading'] - r['d0'], device_span)
direction = -1 if fraction < 0 else (1 if fraction > 1 else 0)
return [str(slope),str(intercept),str(mapped),str(residual),str(inverse),direction]
def check(label, actual, expected):
observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 14}), ['3/2', '7', '13', '1', '14/3', 0])
check('fixture 2', solve({'d0': -4, 'd1': 4, 't0': -10, 't1': 6, 'reading': -6, 'observed': -13}), ['2', '-2', '-14', '1', '-11/2', -1])
check('fixture 3', solve({'d0': 1, 'd1': 5, 't0': 2, 't1': 4, 'reading': 8, 'observed': 5}), ['1/2', '3/2', '11/2', '-1/2', '7', 1])
check('fixture 4', solve({'d0': 0, 'd1': 10, 't0': 5, 't1': 25, 'reading': 0, 'observed': 5}), ['2', '5', '5', '0', '0', 0])
check('fixture 5', solve({'d0': 2, 'd1': 8, 't0': -3, 't1': 0, 'reading': 8, 'observed': 1}), ['1/2', '-4', '0', '1', '10', 0])
check('fixture 6', solve({'d0': -8, 'd1': -2, 't0': 2, 't1': 14, 'reading': -5, 'observed': 7}), ['2', '18', '8', '-1', '-11/2', 0])
check('fixture 7', solve({'d0': 4, 'd1': 10, 't0': 30, 't1': 39, 'reading': 10, 'observed': 40}), ['3/2', '24', '39', '1', '32/3', 0])
check('fixture 8', solve({'d0': 2, 'd1': 5, 't0': 1, 't1': 2, 'reading': 3, 'observed': 1}), ['1/3', '1/3', '4/3', '-1/3', '2', 0])
check('fixture 9', solve({'d0': 3, 'd1': 9, 't0': 4, 't1': 16, 'reading': 3, 'observed': 4}), ['2', '-2', '4', '0', '3', 0])
check('fixture 10', solve({'d0': 1, 'd1': 2, 't0': 1, 't1': 3, 'reading': 2, 'observed': 3}), ['2', '-1', '3', '0', '2', 0])
variant = [({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 15}, ['3/2', '7', '13', '2', '16/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 16}, ['3/2', '7', '13', '3', '6', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 17}, ['3/2', '7', '13', '4', '20/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 18}, ['3/2', '7', '13', '5', '22/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 19}, ['3/2', '7', '13', '6', '8', 0])]
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)
| Boundary fixture | Actual | Expected | Outcome |
|---|---|---|---|
| fixture 1 | ['3/2', '7', '6', '8', '14/3', 0] | ['3/2', '7', '13', '1', '14/3', 0] | Failed |
| fixture 2 | ['2', '-2', '-12', '-1', '-11/2', -1] | ['2', '-2', '-14', '1', '-11/2', -1] | Failed |
| fixture 3 | ['1/2', '3/2', '4', '1', '7', 1] | ['1/2', '3/2', '11/2', '-1/2', '7', 1] | Failed |
| fixture 4 | ['2', '5', '0', '5', '0', 0] | ['2', '5', '5', '0', '0', 0] | Failed |
| fixture 5 | ['1/2', '-4', '4', '-3', '10', 0] | ['1/2', '-4', '0', '1', '10', 0] | Failed |
| fixture 6 | ['2', '18', '-10', '17', '-11/2', 0] | ['2', '18', '8', '-1', '-11/2', 0] | Failed |
| fixture 7 | ['3/2', '24', '15', '25', '32/3', 0] | ['3/2', '24', '39', '1', '32/3', 0] | Failed |
| fixture 8 | ['1/3', '1/3', '1', '0', '2', 0] | ['1/3', '1/3', '4/3', '-1/3', '2', 0] | Failed |
| fixture 9 | ['2', '-2', '6', '-2', '3', 0] | ['2', '-2', '4', '0', '3', 0] | Failed |
| fixture 10 | ['2', '-1', '4', '-1', '2', 0] | ['2', '-1', '3', '0', '2', 0] | Failed |
| variant capture | ['3/2', '7', '6', '9', '16/3', 0] | ['3/2', '7', '13', '2', '16/3', 0] | Failed |
SHA-256 / 581072c858e142b32b6749f1b3f338694247b05c5b08a28d2b02804e84f3c5ac
3 / The verified repair
Exit 0"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(r):
device_span = r['d1'] - r['d0']
reference_span = r['t1'] - r['t0']
slope = Fraction(reference_span, device_span)
reciprocal = 1 / slope
intercept = r['t0'] - slope * r['d0']
mapped = slope * r['reading'] + intercept
residual = r['observed'] - mapped
inverse = (r['observed'] - intercept) * reciprocal
fraction = Fraction(r['reading'] - r['d0'], device_span)
direction = -1 if fraction < 0 else (1 if fraction > 1 else 0)
return [str(slope),str(intercept),str(mapped),str(residual),str(inverse),direction]
def check(label, actual, expected):
observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 14}), ['3/2', '7', '13', '1', '14/3', 0])
check('fixture 2', solve({'d0': -4, 'd1': 4, 't0': -10, 't1': 6, 'reading': -6, 'observed': -13}), ['2', '-2', '-14', '1', '-11/2', -1])
check('fixture 3', solve({'d0': 1, 'd1': 5, 't0': 2, 't1': 4, 'reading': 8, 'observed': 5}), ['1/2', '3/2', '11/2', '-1/2', '7', 1])
check('fixture 4', solve({'d0': 0, 'd1': 10, 't0': 5, 't1': 25, 'reading': 0, 'observed': 5}), ['2', '5', '5', '0', '0', 0])
check('fixture 5', solve({'d0': 2, 'd1': 8, 't0': -3, 't1': 0, 'reading': 8, 'observed': 1}), ['1/2', '-4', '0', '1', '10', 0])
check('fixture 6', solve({'d0': -8, 'd1': -2, 't0': 2, 't1': 14, 'reading': -5, 'observed': 7}), ['2', '18', '8', '-1', '-11/2', 0])
check('fixture 7', solve({'d0': 4, 'd1': 10, 't0': 30, 't1': 39, 'reading': 10, 'observed': 40}), ['3/2', '24', '39', '1', '32/3', 0])
check('fixture 8', solve({'d0': 2, 'd1': 5, 't0': 1, 't1': 2, 'reading': 3, 'observed': 1}), ['1/3', '1/3', '4/3', '-1/3', '2', 0])
check('fixture 9', solve({'d0': 3, 'd1': 9, 't0': 4, 't1': 16, 'reading': 3, 'observed': 4}), ['2', '-2', '4', '0', '3', 0])
check('fixture 10', solve({'d0': 1, 'd1': 2, 't0': 1, 't1': 3, 'reading': 2, 'observed': 3}), ['2', '-1', '3', '0', '2', 0])
variant = [({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 15}, ['3/2', '7', '13', '2', '16/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 16}, ['3/2', '7', '13', '3', '6', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 17}, ['3/2', '7', '13', '4', '20/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 18}, ['3/2', '7', '13', '5', '22/3', 0]), ({'d0': 2, 'd1': 6, 't0': 10, 't1': 16, 'reading': 4, 'observed': 19}, ['3/2', '7', '13', '6', '8', 0])]
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)
| Boundary fixture | Actual | Expected | Outcome |
|---|---|---|---|
| fixture 1 | ['3/2', '7', '13', '1', '14/3', 0] | ['3/2', '7', '13', '1', '14/3', 0] | Passed |
| fixture 2 | ['2', '-2', '-14', '1', '-11/2', -1] | ['2', '-2', '-14', '1', '-11/2', -1] | Passed |
| fixture 3 | ['1/2', '3/2', '11/2', '-1/2', '7', 1] | ['1/2', '3/2', '11/2', '-1/2', '7', 1] | Passed |
| fixture 4 | ['2', '5', '5', '0', '0', 0] | ['2', '5', '5', '0', '0', 0] | Passed |
| fixture 5 | ['1/2', '-4', '0', '1', '10', 0] | ['1/2', '-4', '0', '1', '10', 0] | Passed |
| fixture 6 | ['2', '18', '8', '-1', '-11/2', 0] | ['2', '18', '8', '-1', '-11/2', 0] | Passed |
| fixture 7 | ['3/2', '24', '39', '1', '32/3', 0] | ['3/2', '24', '39', '1', '32/3', 0] | Passed |
| fixture 8 | ['1/3', '1/3', '4/3', '-1/3', '2', 0] | ['1/3', '1/3', '4/3', '-1/3', '2', 0] | Passed |
| fixture 9 | ['2', '-2', '4', '0', '3', 0] | ['2', '-2', '4', '0', '3', 0] | Passed |
| fixture 10 | ['2', '-1', '3', '0', '2', 0] | ['2', '-1', '3', '0', '2', 0] | Passed |
| variant capture | ['3/2', '7', '13', '2', '16/3', 0] | ['3/2', '7', '13', '2', '16/3', 0] | Passed |
SHA-256 / 145e59e279fedb7d3265508236733f7bc7266c07c244174cb62133cd68563295
Verification & scope
Deterministic integer reference model with stipulated units and policies; not a complete clock, wire standard or platform implementation. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.
Observations recorded using Python 3.12.14 at 2026-09-29T14:39:48.095867+00:00.
Case digest / 25b57252a6011a7431a15b82180e57c4948ba078509fd20576afc4ab6f7638e7