FA-17551 / Time representation / Open access
Clock scale is inverted or prematurely truncated · case 01
The decoded time state disagrees with the explicit regression oracle for slope.
ROOT CAUSE
Clock scale is inverted or prematurely truncated.
VERIFIED REPAIR
Preserve the declared coordinate and state contract at slope: slope = Fraction(reference_span, device_span).
Unsuccessful approach: The partial correction still substitutes Fraction(max(1,reference_span // device_span)) 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(device_span, reference_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 | ['2/3', '26/3', '34/3', '8/3', '8', 0] | ['3/2', '7', '13', '1', '14/3', 0] | Failed |
| fixture 2 | ['1/2', '-8', '-11', '-2', '-10', -1] | ['2', '-2', '-14', '1', '-11/2', -1] | Failed |
| fixture 3 | ['2', '0', '16', '-11', '5/2', 1] | ['1/2', '3/2', '11/2', '-1/2', '7', 1] | Failed |
| fixture 4 | ['1/2', '5', '5', '0', '0', 0] | ['2', '5', '5', '0', '0', 0] | Failed |
| fixture 5 | ['2', '-7', '9', '-8', '4', 0] | ['1/2', '-4', '0', '1', '10', 0] | Failed |
| fixture 6 | ['1/2', '6', '7/2', '7/2', '2', 0] | ['2', '18', '8', '-1', '-11/2', 0] | Failed |
| fixture 7 | ['2/3', '82/3', '34', '6', '19', 0] | ['3/2', '24', '39', '1', '32/3', 0] | Failed |
| fixture 8 | ['3', '-5', '4', '-3', '2', 0] | ['1/3', '1/3', '4/3', '-1/3', '2', 0] | Failed |
| fixture 9 | ['1/2', '5/2', '4', '0', '3', 0] | ['2', '-2', '4', '0', '3', 0] | Failed |
| fixture 10 | ['1/2', '1/2', '3/2', '3/2', '5', 0] | ['2', '-1', '3', '0', '2', 0] | Failed |
| variant capture | ['2/3', '26/3', '34/3', '11/3', '19/2', 0] | ['3/2', '7', '13', '2', '16/3', 0] | Failed |
SHA-256 / b8bb30d9ff062e2fd73f6b26648cbf949ca4f285e2604cfd01fcda7e15b7922c
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(max(1,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 | ['1', '8', '12', '2', '6', 0] | ['3/2', '7', '13', '1', '14/3', 0] | Failed |
| fixture 2 | ['2', '-2', '-14', '1', '-11/2', -1] | ['2', '-2', '-14', '1', '-11/2', -1] | Passed |
| fixture 3 | ['1', '1', '9', '-4', '4', 1] | ['1/2', '3/2', '11/2', '-1/2', '7', 1] | Failed |
| fixture 4 | ['2', '5', '5', '0', '0', 0] | ['2', '5', '5', '0', '0', 0] | Passed |
| fixture 5 | ['1', '-5', '3', '-2', '6', 0] | ['1/2', '-4', '0', '1', '10', 0] | Failed |
| fixture 6 | ['2', '18', '8', '-1', '-11/2', 0] | ['2', '18', '8', '-1', '-11/2', 0] | Passed |
| fixture 7 | ['1', '26', '36', '4', '14', 0] | ['3/2', '24', '39', '1', '32/3', 0] | Failed |
| fixture 8 | ['1', '-1', '2', '-1', '2', 0] | ['1/3', '1/3', '4/3', '-1/3', '2', 0] | Failed |
| 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 | ['1', '8', '12', '3', '7', 0] | ['3/2', '7', '13', '2', '16/3', 0] | Failed |
SHA-256 / 296ed854d0b41679c734c91371279e42ba287812072e843183d57cccb829cf87
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:47.683037+00:00.
Case digest / 9b9a9e043cd0ecfdba5c14eff96e4437999459fdaa152cb43f6208385d833cde