FAILURE MAP
← Case archive

FA-18231 / Time representation / Open access

Migrated fraction uses legacy modulus or magnitude residue · case 01

The decoded time state disagrees with the explicit regression oracle for remainder.

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

ROOT CAUSE

Migrated fraction uses legacy modulus or magnitude residue.

VERIFIED REPAIR

Preserve the declared coordinate and state contract at remainder: remainder = nanoseconds - seconds * 1000000000.

Unsuccessful approach: The partial correction still substitutes abs(nanoseconds) % 1000000000 at the same fault site.

Case contract

Controlled timestamp migration from version 1 milliseconds or version 2 split seconds/nanos into exact nanoseconds. A separate presence bit distinguishes missing from epoch zero. Version 2 fraction must be 0..999999999; timezone offsets are forbidden because payload is already UTC. Preserve uncertainty in matching units and emit canonical seconds/remainder with precision and provenance. Negative uncertainty is invalid; zero means exact.

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):
    present = r['present']
    version_ok = r['version'] in (1,2)
    fraction_ok = r['version'] != 2 or 0 <= r['fraction'] < 1000000000
    offset_ok = r['offset'] is None
    valid = version_ok and fraction_ok and offset_ok and r['uncertainty'] >= 0
    nanoseconds = r['value'] * 1000000 if r['version'] == 1 else r['value'] * 1000000000 + r['fraction']
    uncertainty = r['uncertainty'] * (1000000 if r['version'] == 1 else 1)
    seconds = nanoseconds // 1000000000
    remainder = nanoseconds % 1000000
    precision = 1000000 if r['version'] == 1 else 1
    return ['missing' if not present else ('invalid' if not valid else 'ok'), [seconds,remainder,uncertainty,precision] if present and valid else None]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'present': True, 'version': 1, 'value': 0, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [0, 0, 2000000, 1000000]])
check('fixture 2', solve({'present': False, 'version': 1, 'value': 20, 'fraction': 0, 'offset': None, 'uncertainty': 1}), ['missing', None])
check('fixture 3', solve({'present': True, 'version': 1, 'value': 1234, 'fraction': 0, 'offset': None, 'uncertainty': 3}), ['ok', [1, 234000000, 3000000, 1000000]])
check('fixture 4', solve({'present': True, 'version': 2, 'value': -1, 'fraction': 500000000, 'offset': None, 'uncertainty': 4}), ['ok', [-1, 500000000, 4, 1]])
check('fixture 5', solve({'present': True, 'version': 2, 'value': 3, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [3, 0, 2, 1]])
check('fixture 6', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 1000000000, 'offset': None, 'uncertainty': 2}), ['invalid', None])
check('fixture 7', solve({'present': True, 'version': 2, 'value': 1, 'fraction': -1, 'offset': None, 'uncertainty': 2}), ['invalid', None])
check('fixture 8', solve({'present': True, 'version': 3, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 1}), ['invalid', None])
check('fixture 9', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': 0, 'uncertainty': 1}), ['invalid', None])
check('fixture 10', solve({'present': True, 'version': 1, 'value': 1, 'fraction': 0, 'offset': 60, 'uncertainty': 1}), ['invalid', None])
check('fixture 11', solve({'present': True, 'version': 1, 'value': -1, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [-1, 999000000, 2000000, 1000000]])
check('fixture 12', solve({'present': True, 'version': 1, 'value': 1234, 'fraction': 500, 'offset': None, 'uncertainty': 2}), ['ok', [1, 234000000, 2000000, 1000000]])
check('fixture 13', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': -1}), ['invalid', None])
check('fixture 14', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 0}), ['ok', [1, 0, 0, 1]])
variant = [({'present': True, 'version': 1, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 1000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 2, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 2000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 3, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 3000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 4, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 4000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 5, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 5000000, 2000000, 1000000]])]
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 fixtureActualExpectedOutcome
fixture 1['ok', [0, 0, 2000000, 1000000]]['ok', [0, 0, 2000000, 1000000]]Passed
fixture 2['missing', None]['missing', None]Passed
fixture 3['ok', [1, 0, 3000000, 1000000]]['ok', [1, 234000000, 3000000, 1000000]]Failed
fixture 4['ok', [-1, 0, 4, 1]]['ok', [-1, 500000000, 4, 1]]Failed
fixture 5['ok', [3, 0, 2, 1]]['ok', [3, 0, 2, 1]]Passed
fixture 6['invalid', None]['invalid', None]Passed
fixture 7['invalid', None]['invalid', None]Passed
fixture 8['invalid', None]['invalid', None]Passed
fixture 9['invalid', None]['invalid', None]Passed
fixture 10['invalid', None]['invalid', None]Passed
fixture 11['ok', [-1, 0, 2000000, 1000000]]['ok', [-1, 999000000, 2000000, 1000000]]Failed
fixture 12['ok', [1, 0, 2000000, 1000000]]['ok', [1, 234000000, 2000000, 1000000]]Failed
fixture 13['invalid', None]['invalid', None]Passed
fixture 14['ok', [1, 0, 0, 1]]['ok', [1, 0, 0, 1]]Passed
variant capture['ok', [0, 0, 2000000, 1000000]]['ok', [0, 1000000, 2000000, 1000000]]Failed

SHA-256 / f73d74877e642a71a61de839f24a5a1383d04274db3bb4cee50457ce512f3048

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):
    present = r['present']
    version_ok = r['version'] in (1,2)
    fraction_ok = r['version'] != 2 or 0 <= r['fraction'] < 1000000000
    offset_ok = r['offset'] is None
    valid = version_ok and fraction_ok and offset_ok and r['uncertainty'] >= 0
    nanoseconds = r['value'] * 1000000 if r['version'] == 1 else r['value'] * 1000000000 + r['fraction']
    uncertainty = r['uncertainty'] * (1000000 if r['version'] == 1 else 1)
    seconds = nanoseconds // 1000000000
    remainder = abs(nanoseconds) % 1000000000
    precision = 1000000 if r['version'] == 1 else 1
    return ['missing' if not present else ('invalid' if not valid else 'ok'), [seconds,remainder,uncertainty,precision] if present and valid else None]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'present': True, 'version': 1, 'value': 0, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [0, 0, 2000000, 1000000]])
check('fixture 2', solve({'present': False, 'version': 1, 'value': 20, 'fraction': 0, 'offset': None, 'uncertainty': 1}), ['missing', None])
check('fixture 3', solve({'present': True, 'version': 1, 'value': 1234, 'fraction': 0, 'offset': None, 'uncertainty': 3}), ['ok', [1, 234000000, 3000000, 1000000]])
check('fixture 4', solve({'present': True, 'version': 2, 'value': -1, 'fraction': 500000000, 'offset': None, 'uncertainty': 4}), ['ok', [-1, 500000000, 4, 1]])
check('fixture 5', solve({'present': True, 'version': 2, 'value': 3, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [3, 0, 2, 1]])
check('fixture 6', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 1000000000, 'offset': None, 'uncertainty': 2}), ['invalid', None])
check('fixture 7', solve({'present': True, 'version': 2, 'value': 1, 'fraction': -1, 'offset': None, 'uncertainty': 2}), ['invalid', None])
check('fixture 8', solve({'present': True, 'version': 3, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 1}), ['invalid', None])
check('fixture 9', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': 0, 'uncertainty': 1}), ['invalid', None])
check('fixture 10', solve({'present': True, 'version': 1, 'value': 1, 'fraction': 0, 'offset': 60, 'uncertainty': 1}), ['invalid', None])
check('fixture 11', solve({'present': True, 'version': 1, 'value': -1, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [-1, 999000000, 2000000, 1000000]])
check('fixture 12', solve({'present': True, 'version': 1, 'value': 1234, 'fraction': 500, 'offset': None, 'uncertainty': 2}), ['ok', [1, 234000000, 2000000, 1000000]])
check('fixture 13', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': -1}), ['invalid', None])
check('fixture 14', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 0}), ['ok', [1, 0, 0, 1]])
variant = [({'present': True, 'version': 1, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 1000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 2, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 2000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 3, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 3000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 4, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 4000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 5, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 5000000, 2000000, 1000000]])]
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 fixtureActualExpectedOutcome
fixture 1['ok', [0, 0, 2000000, 1000000]]['ok', [0, 0, 2000000, 1000000]]Passed
fixture 2['missing', None]['missing', None]Passed
fixture 3['ok', [1, 234000000, 3000000, 1000000]]['ok', [1, 234000000, 3000000, 1000000]]Passed
fixture 4['ok', [-1, 500000000, 4, 1]]['ok', [-1, 500000000, 4, 1]]Passed
fixture 5['ok', [3, 0, 2, 1]]['ok', [3, 0, 2, 1]]Passed
fixture 6['invalid', None]['invalid', None]Passed
fixture 7['invalid', None]['invalid', None]Passed
fixture 8['invalid', None]['invalid', None]Passed
fixture 9['invalid', None]['invalid', None]Passed
fixture 10['invalid', None]['invalid', None]Passed
fixture 11['ok', [-1, 1000000, 2000000, 1000000]]['ok', [-1, 999000000, 2000000, 1000000]]Failed
fixture 12['ok', [1, 234000000, 2000000, 1000000]]['ok', [1, 234000000, 2000000, 1000000]]Passed
fixture 13['invalid', None]['invalid', None]Passed
fixture 14['ok', [1, 0, 0, 1]]['ok', [1, 0, 0, 1]]Passed
variant capture['ok', [0, 1000000, 2000000, 1000000]]['ok', [0, 1000000, 2000000, 1000000]]Passed

SHA-256 / 73093c5a403b78047377751c4c83c206ed6b5b1beff0b440b79f64c970e1e90e

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):
    present = r['present']
    version_ok = r['version'] in (1,2)
    fraction_ok = r['version'] != 2 or 0 <= r['fraction'] < 1000000000
    offset_ok = r['offset'] is None
    valid = version_ok and fraction_ok and offset_ok and r['uncertainty'] >= 0
    nanoseconds = r['value'] * 1000000 if r['version'] == 1 else r['value'] * 1000000000 + r['fraction']
    uncertainty = r['uncertainty'] * (1000000 if r['version'] == 1 else 1)
    seconds = nanoseconds // 1000000000
    remainder = nanoseconds - seconds * 1000000000
    precision = 1000000 if r['version'] == 1 else 1
    return ['missing' if not present else ('invalid' if not valid else 'ok'), [seconds,remainder,uncertainty,precision] if present and valid else None]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('fixture 1', solve({'present': True, 'version': 1, 'value': 0, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [0, 0, 2000000, 1000000]])
check('fixture 2', solve({'present': False, 'version': 1, 'value': 20, 'fraction': 0, 'offset': None, 'uncertainty': 1}), ['missing', None])
check('fixture 3', solve({'present': True, 'version': 1, 'value': 1234, 'fraction': 0, 'offset': None, 'uncertainty': 3}), ['ok', [1, 234000000, 3000000, 1000000]])
check('fixture 4', solve({'present': True, 'version': 2, 'value': -1, 'fraction': 500000000, 'offset': None, 'uncertainty': 4}), ['ok', [-1, 500000000, 4, 1]])
check('fixture 5', solve({'present': True, 'version': 2, 'value': 3, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [3, 0, 2, 1]])
check('fixture 6', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 1000000000, 'offset': None, 'uncertainty': 2}), ['invalid', None])
check('fixture 7', solve({'present': True, 'version': 2, 'value': 1, 'fraction': -1, 'offset': None, 'uncertainty': 2}), ['invalid', None])
check('fixture 8', solve({'present': True, 'version': 3, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 1}), ['invalid', None])
check('fixture 9', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': 0, 'uncertainty': 1}), ['invalid', None])
check('fixture 10', solve({'present': True, 'version': 1, 'value': 1, 'fraction': 0, 'offset': 60, 'uncertainty': 1}), ['invalid', None])
check('fixture 11', solve({'present': True, 'version': 1, 'value': -1, 'fraction': 0, 'offset': None, 'uncertainty': 2}), ['ok', [-1, 999000000, 2000000, 1000000]])
check('fixture 12', solve({'present': True, 'version': 1, 'value': 1234, 'fraction': 500, 'offset': None, 'uncertainty': 2}), ['ok', [1, 234000000, 2000000, 1000000]])
check('fixture 13', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': -1}), ['invalid', None])
check('fixture 14', solve({'present': True, 'version': 2, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 0}), ['ok', [1, 0, 0, 1]])
variant = [({'present': True, 'version': 1, 'value': 1, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 1000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 2, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 2000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 3, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 3000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 4, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 4000000, 2000000, 1000000]]), ({'present': True, 'version': 1, 'value': 5, 'fraction': 0, 'offset': None, 'uncertainty': 2}, ['ok', [0, 5000000, 2000000, 1000000]])]
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 fixtureActualExpectedOutcome
fixture 1['ok', [0, 0, 2000000, 1000000]]['ok', [0, 0, 2000000, 1000000]]Passed
fixture 2['missing', None]['missing', None]Passed
fixture 3['ok', [1, 234000000, 3000000, 1000000]]['ok', [1, 234000000, 3000000, 1000000]]Passed
fixture 4['ok', [-1, 500000000, 4, 1]]['ok', [-1, 500000000, 4, 1]]Passed
fixture 5['ok', [3, 0, 2, 1]]['ok', [3, 0, 2, 1]]Passed
fixture 6['invalid', None]['invalid', None]Passed
fixture 7['invalid', None]['invalid', None]Passed
fixture 8['invalid', None]['invalid', None]Passed
fixture 9['invalid', None]['invalid', None]Passed
fixture 10['invalid', None]['invalid', None]Passed
fixture 11['ok', [-1, 999000000, 2000000, 1000000]]['ok', [-1, 999000000, 2000000, 1000000]]Passed
fixture 12['ok', [1, 234000000, 2000000, 1000000]]['ok', [1, 234000000, 2000000, 1000000]]Passed
fixture 13['invalid', None]['invalid', None]Passed
fixture 14['ok', [1, 0, 0, 1]]['ok', [1, 0, 0, 1]]Passed
variant capture['ok', [0, 1000000, 2000000, 1000000]]['ok', [0, 1000000, 2000000, 1000000]]Passed

SHA-256 / d235fac57f4c008cdb13488970b30711667c281a8a77e603d74729ed07f951de

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:55.515404+00:00.

Case digest / e829bc8c6b23793ac54a1e8928af597f1f0c89c60c29233382e16c333d3b6ac1