FA-061 / Distributed coordination / Open access

Concurrent revisions are mistaken for causal successors · case 01

A scalar or lexicographic comparison imposes an order on independent replica updates.

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

ROOT CAUSE

Vector clocks encode a partial order, not a ranking by total counter size or replica name.

THE FAILURE

Vector clocks encode a partial order, not a ranking by total counter size or replica name.

Unsuccessful approach: Lexicographic comparison is deterministic but incorrectly orders incomparable clocks.

Case contract

Given two maps from replica ID to nonnegative counter, return equal, before, after, or concurrent. Before requires every component <= and at least one <; after is its inverse.

Why this case matters

Models conflict detection for replicated revisions; a total order can silently hide conflicts that require application-specific reconciliation.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(left, right):
    a, b = sum(left.values()), sum(right.values())
    return 'equal' if a == b else ('before' if a < b else 'after')
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same-sum independent writes', solve({'a': N+1}, {'a': N, 'b': 1}), 'concurrent')
check('unequal-sum concurrent writes', solve({'a': N+2}, {'a': N, 'b': 1}), 'concurrent')
check('strict causal extension', solve({'a': N}, {'a': N, 'b': N}), 'before')
check('reverse causal extension', solve({'a': N+1, 'b': N}, {'a': N}), 'after')
check('missing zero component', solve({'a': N}, {'a': N, 'b': 0}), 'equal')
check('empty clocks', solve({}, {}), 'equal')
check('one replica progresses', solve({'a': N}, {'a': N+1}), 'before')
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
same-sum independent writes	`equal`	`concurrent`	Failed
unequal-sum concurrent writes	`after`	`concurrent`	Failed
strict causal extension	`before`	`before`	Passed
reverse causal extension	`after`	`after`	Passed
missing zero component	`equal`	`equal`	Passed
empty clocks	`equal`	`equal`	Passed
one replica progresses	`before`	`before`	Passed

SHA-256 / 069bcfd225d3871975da9c0c471188d43cbce9adb319dfe958402228becf4c7a

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(left, right):
    keys = sorted(set(left) | set(right))
    a = tuple(left.get(k, 0) for k in keys)
    b = tuple(right.get(k, 0) for k in keys)
    return 'equal' if a == b else ('before' if a < b else 'after')
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('same-sum independent writes', solve({'a': N+1}, {'a': N, 'b': 1}), 'concurrent')
check('unequal-sum concurrent writes', solve({'a': N+2}, {'a': N, 'b': 1}), 'concurrent')
check('strict causal extension', solve({'a': N}, {'a': N, 'b': N}), 'before')
check('reverse causal extension', solve({'a': N+1, 'b': N}, {'a': N}), 'after')
check('missing zero component', solve({'a': N}, {'a': N, 'b': 0}), 'equal')
check('empty clocks', solve({}, {}), 'equal')
check('one replica progresses', solve({'a': N}, {'a': N+1}), 'before')
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
same-sum independent writes	`after`	`concurrent`	Failed
unequal-sum concurrent writes	`after`	`concurrent`	Failed
strict causal extension	`before`	`before`	Passed
reverse causal extension	`after`	`after`	Passed
missing zero component	`equal`	`equal`	Passed
empty clocks	`equal`	`equal`	Passed
one replica progresses	`before`	`before`	Passed

SHA-256 / cca318cac9388bdb2fdd6934cabc63ff471e40998819b6af9df6964cb8211cc5

HELD IN THE MEMBER ARCHIVE

The verified repair and its recorded checks are member-only.

This mechanism has 7 recorded checks per implementation. The open-access tier publishes the failure and the unsuccessful fix; the repaired source that passes every check, and the observations that prove it, are available to members.

Every case sharing this mechanism uses the same contract and the same repair, so this one record is held back for all of them.

Member access is invitation-based. Sign in with your invited account to inspect the repair.

Verification & scope

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

Case digest / f53f8d900e37e4b8e35989d6c4204cc115d214d346d37cbd9a24c5ea3fcc1a7d