FAILURE MAP
← Case archive

FA-18236 / Time representation / Open access

Migration drops original precision provenance · case 01

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

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

ROOT CAUSE

Migration drops original precision provenance.

VERIFIED REPAIR

Preserve the declared coordinate and state contract at precision: precision = 1000000 if r['version'] == 1 else 1.

Unsuccessful approach: The partial correction still substitutes 1000000 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 - seconds * 1000000000
    precision = 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, 1]]['ok', [0, 0, 2000000, 1000000]]Failed
fixture 2['missing', None]['missing', None]Passed
fixture 3['ok', [1, 234000000, 3000000, 1]]['ok', [1, 234000000, 3000000, 1000000]]Failed
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, 1]]['ok', [-1, 999000000, 2000000, 1000000]]Failed
fixture 12['ok', [1, 234000000, 2000000, 1]]['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, 1000000, 2000000, 1]]['ok', [0, 1000000, 2000000, 1000000]]Failed

SHA-256 / 598e0e3e6256238af0d946ca41b7d051cc7a6f181c26a53632eb6084dc5f8e3b

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 = nanoseconds - seconds * 1000000000
    precision = 1000000
    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, 1000000]]['ok', [-1, 500000000, 4, 1]]Failed
fixture 5['ok', [3, 0, 2, 1000000]]['ok', [3, 0, 2, 1]]Failed
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, 1000000]]['ok', [1, 0, 0, 1]]Failed
variant capture['ok', [0, 1000000, 2000000, 1000000]]['ok', [0, 1000000, 2000000, 1000000]]Passed

SHA-256 / ea288231a567123be846a27d4a60fb8392185090b9d05a138407cf3b7449da92

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

Case digest / 2aa888cf92c821271105b620365ff3668172e4ade3a545bba58717ca6c6545c5