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

N = 1
observations = []
def solve(a, b):
    def covered(c, rep, n):
        return n <= c['vv'].get(rep, 0) or [rep, n] in c['cloud']
    da = {tuple(x) for x in a['dots']}
    db = {tuple(x) for x in b['dots']}
    dots = (da & db) | {x for x in da if not covered(b, x[1], x[2])} | {x for x in db if not covered(a, x[1], x[2])}
    vv = dict(a['vv'])
    for rep, n in b['vv'].items():
        vv[rep] = max(vv.get(rep, 0), n)
    cloud = {tuple(x) for x in a['cloud']} | {tuple(x) for x in b['cloud']}
    changed = True
    while changed:
        changed = False
        for rep, n in sorted(cloud):
            if n == vv.get(rep, 0) + 1:
                vv[rep] = n
                cloud.discard((rep, n))
                changed = True
    return {'elements': sorted({x[0] for x in dots}), 'dots': sorted([list(x) for x in dots]), 'vv': sorted([k, v] for k, v in vv.items()), 'cloud': sorted([list(x) for x in cloud])}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = {
    1: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 1]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 3]], 'vv': {'c': 1}, 'cloud': [['c', 3]]}, {'dots': [['w', 'c', 2]], 'vv': {'c': 1}, 'cloud': [['c', 2]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 2], ['z', 'c', 3]], 'vv': [['c', 3]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 5]], 'vv': {}, 'cloud': [['a', 5]]}], {'elements': ['q'], 'dots': [['q', 'a', 5]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 5]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 1]], 'vv': {'a': 2, 'b': 1}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['r'], 'dots': [['r', 'a', 4]], 'vv': [['a', 4], ['b', 1]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 3}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 4]]}], {'elements': [], 'dots': [], 'vv': [['a', 4]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 1], ['k', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 1]], 'vv': [['a', 1], ['b', 1]], 'cloud': []})],
    2: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [], 'vv': {'a': 2}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 2]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 4]], 'vv': {'c': 2}, 'cloud': [['c', 4]]}, {'dots': [['w', 'c', 3]], 'vv': {'c': 2}, 'cloud': [['c', 3]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 3], ['z', 'c', 4]], 'vv': [['c', 4]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 6]], 'vv': {}, 'cloud': [['a', 6]]}], {'elements': ['q'], 'dots': [['q', 'a', 6]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 6]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 2]], 'vv': {'a': 2, 'b': 2}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 2], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 2]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 4}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 5]]}], {'elements': [], 'dots': [], 'vv': [['a', 5]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 2], ['k', 'b', 1]], 'vv': {'a': 2, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 2]], 'vv': [['a', 2], ['b', 1]], 'cloud': []})],
    3: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 3]], 'vv': {'a': 3}, 'cloud': []}, {'dots': [], 'vv': {'a': 3}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 3]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 5]], 'vv': {'c': 3}, 'cloud': [['c', 5]]}, {'dots': [['w', 'c', 4]], 'vv': {'c': 3}, 'cloud': [['c', 4]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 4], ['z', 'c', 5]], 'vv': [['c', 5]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 7]], 'vv': {}, 'cloud': [['a', 7]]}], {'elements': ['q'], 'dots': [['q', 'a', 7]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 7]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 3]], 'vv': {'a': 2, 'b': 3}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 3], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 3]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 5}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 6]]}], {'elements': [], 'dots': [], 'vv': [['a', 6]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 3], ['k', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 3]], 'vv': [['a', 3], ['b', 1]], 'cloud': []})],
    4: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 4]], 'vv': {'a': 4}, 'cloud': []}, {'dots': [], 'vv': {'a': 4}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 4]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 6]], 'vv': {'c': 4}, 'cloud': [['c', 6]]}, {'dots': [['w', 'c', 5]], 'vv': {'c': 4}, 'cloud': [['c', 5]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 5], ['z', 'c', 6]], 'vv': [['c', 6]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 8]], 'vv': {}, 'cloud': [['a', 8]]}], {'elements': ['q'], 'dots': [['q', 'a', 8]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 8]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 4]], 'vv': {'a': 2, 'b': 4}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 4], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 4]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 6}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 7]]}], {'elements': [], 'dots': [], 'vv': [['a', 7]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 4], ['k', 'b', 1]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 4]], 'vv': [['a', 4], ['b', 1]], 'cloud': []})],
    5: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 5]], 'vv': {'a': 5}, 'cloud': []}, {'dots': [], 'vv': {'a': 5}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 5]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 7]], 'vv': {'c': 5}, 'cloud': [['c', 7]]}, {'dots': [['w', 'c', 6]], 'vv': {'c': 5}, 'cloud': [['c', 6]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 6], ['z', 'c', 7]], 'vv': [['c', 7]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 9]], 'vv': {}, 'cloud': [['a', 9]]}], {'elements': ['q'], 'dots': [['q', 'a', 9]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 9]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 5]], 'vv': {'a': 2, 'b': 5}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 5], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 5]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 7}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 8]]}], {'elements': [], 'dots': [], 'vv': [['a', 8]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 5], ['k', 'b', 1]], 'vv': {'a': 5, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 5]], 'vv': [['a', 5], ['b', 1]], 'cloud': []})],
}[N]
for label, args, expected in cases:
    check(label, solve(*args), expected)
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)

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

N = 1
observations = []
def solve(a, b):
    def covered(c, rep, n):
        return n <= c['vv'].get(rep, 0) or [rep, n] in c['cloud']
    da = {tuple(x) for x in a['dots']}
    db = {tuple(x) for x in b['dots']}
    dots = (da & db) | {x for x in da if not covered(b, x[1], x[2])} | {x for x in db if not covered(a, x[1], x[2])}
    vv = dict(a['vv'])
    for rep, n in b['vv'].items():
        vv[rep] = max(vv.get(rep, 0), n)
    cloud = {tuple(x) for x in a['cloud']} | {tuple(x) for x in b['cloud']}
    changed = True
    while changed:
        changed = False
        for rep, n in sorted(cloud):
            if n == vv.get(rep, 0) + 1:
                vv[rep] = n
                cloud.discard((rep, n))
                changed = True
            elif n < vv.get(rep, 0):
                cloud.discard((rep, n))
                changed = True
    return {'elements': sorted({x[0] for x in dots}), 'dots': sorted([list(x) for x in dots]), 'vv': sorted([k, v] for k, v in vv.items()), 'cloud': sorted([list(x) for x in cloud])}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = {
    1: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 1]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 3]], 'vv': {'c': 1}, 'cloud': [['c', 3]]}, {'dots': [['w', 'c', 2]], 'vv': {'c': 1}, 'cloud': [['c', 2]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 2], ['z', 'c', 3]], 'vv': [['c', 3]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 5]], 'vv': {}, 'cloud': [['a', 5]]}], {'elements': ['q'], 'dots': [['q', 'a', 5]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 5]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 1]], 'vv': {'a': 2, 'b': 1}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['r'], 'dots': [['r', 'a', 4]], 'vv': [['a', 4], ['b', 1]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 3}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 4]]}], {'elements': [], 'dots': [], 'vv': [['a', 4]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 1], ['k', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 1]], 'vv': [['a', 1], ['b', 1]], 'cloud': []})],
    2: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [], 'vv': {'a': 2}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 2]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 4]], 'vv': {'c': 2}, 'cloud': [['c', 4]]}, {'dots': [['w', 'c', 3]], 'vv': {'c': 2}, 'cloud': [['c', 3]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 3], ['z', 'c', 4]], 'vv': [['c', 4]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 6]], 'vv': {}, 'cloud': [['a', 6]]}], {'elements': ['q'], 'dots': [['q', 'a', 6]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 6]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 2]], 'vv': {'a': 2, 'b': 2}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 2], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 2]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 4}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 5]]}], {'elements': [], 'dots': [], 'vv': [['a', 5]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 2], ['k', 'b', 1]], 'vv': {'a': 2, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 2]], 'vv': [['a', 2], ['b', 1]], 'cloud': []})],
    3: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 3]], 'vv': {'a': 3}, 'cloud': []}, {'dots': [], 'vv': {'a': 3}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 3]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 5]], 'vv': {'c': 3}, 'cloud': [['c', 5]]}, {'dots': [['w', 'c', 4]], 'vv': {'c': 3}, 'cloud': [['c', 4]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 4], ['z', 'c', 5]], 'vv': [['c', 5]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 7]], 'vv': {}, 'cloud': [['a', 7]]}], {'elements': ['q'], 'dots': [['q', 'a', 7]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 7]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 3]], 'vv': {'a': 2, 'b': 3}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 3], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 3]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 5}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 6]]}], {'elements': [], 'dots': [], 'vv': [['a', 6]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 3], ['k', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 3]], 'vv': [['a', 3], ['b', 1]], 'cloud': []})],
    4: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 4]], 'vv': {'a': 4}, 'cloud': []}, {'dots': [], 'vv': {'a': 4}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 4]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 6]], 'vv': {'c': 4}, 'cloud': [['c', 6]]}, {'dots': [['w', 'c', 5]], 'vv': {'c': 4}, 'cloud': [['c', 5]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 5], ['z', 'c', 6]], 'vv': [['c', 6]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 8]], 'vv': {}, 'cloud': [['a', 8]]}], {'elements': ['q'], 'dots': [['q', 'a', 8]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 8]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 4]], 'vv': {'a': 2, 'b': 4}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 4], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 4]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 6}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 7]]}], {'elements': [], 'dots': [], 'vv': [['a', 7]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 4], ['k', 'b', 1]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 4]], 'vv': [['a', 4], ['b', 1]], 'cloud': []})],
    5: [('dot unseen by the peer survives', [{'dots': [['x', 'a', 1]], 'vv': {'a': 1}, 'cloud': []}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['x'], 'dots': [['x', 'a', 1]], 'vv': [['a', 1]], 'cloud': []}), ('dot removed by the peer is dropped', [{'dots': [['x', 'a', 1], ['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}, {'dots': [['y', 'a', 2]], 'vv': {'a': 2}, 'cloud': []}], {'elements': ['y'], 'dots': [['y', 'a', 2]], 'vv': [['a', 2]], 'cloud': []}), ('dot covered only by the peer cloud is dropped', [{'dots': [['x', 'a', 3], ['y', 'b', 1]], 'vv': {'a': 3, 'b': 1}, 'cloud': []}, {'dots': [['y', 'b', 1]], 'vv': {'a': 1, 'b': 1}, 'cloud': [['a', 3]]}], {'elements': ['y'], 'dots': [['y', 'b', 1]], 'vv': [['a', 3], ['b', 1]], 'cloud': []}), ('dot at the vector boundary is covered', [{'dots': [['x', 'a', 5]], 'vv': {'a': 5}, 'cloud': []}, {'dots': [], 'vv': {'a': 5}, 'cloud': []}], {'elements': [], 'dots': [], 'vv': [['a', 5]], 'cloud': []}), ('cloud compacts into the vector', [{'dots': [['z', 'c', 7]], 'vv': {'c': 5}, 'cloud': [['c', 7]]}, {'dots': [['w', 'c', 6]], 'vv': {'c': 5}, 'cloud': [['c', 6]]}], {'elements': ['w', 'z'], 'dots': [['w', 'c', 6], ['z', 'c', 7]], 'vv': [['c', 7]], 'cloud': []}), ('gaps stay in the cloud', [{'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 3]]}, {'dots': [['q', 'a', 9]], 'vv': {}, 'cloud': [['a', 9]]}], {'elements': ['q'], 'dots': [['q', 'a', 9]], 'vv': [['a', 1]], 'cloud': [['a', 3], ['a', 9]]}), ('vectors join by maximum', [{'dots': [['p', 'b', 5]], 'vv': {'a': 2, 'b': 5}, 'cloud': []}, {'dots': [['r', 'a', 4]], 'vv': {'a': 4, 'b': 1}, 'cloud': []}], {'elements': ['p', 'r'], 'dots': [['p', 'b', 5], ['r', 'a', 4]], 'vv': [['a', 4], ['b', 5]], 'cloud': []}), ('cloud entries for a fresh replica compact from zero', [{'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': {}, 'cloud': [['d', 1], ['d', 2]]}, {'dots': [], 'vv': {}, 'cloud': []}], {'elements': ['m'], 'dots': [['m', 'd', 1], ['m', 'd', 2]], 'vv': [['d', 2]], 'cloud': []}), ('cloud entries already under the vector are pruned', [{'dots': [], 'vv': {'a': 7}, 'cloud': []}, {'dots': [], 'vv': {'a': 1}, 'cloud': [['a', 2], ['a', 8]]}], {'elements': [], 'dots': [], 'vv': [['a', 8]], 'cloud': []}), ('peer-only dot unseen locally survives', [{'dots': [], 'vv': {'b': 1}, 'cloud': []}, {'dots': [['k', 'a', 5], ['k', 'b', 1]], 'vv': {'a': 5, 'b': 1}, 'cloud': []}], {'elements': ['k'], 'dots': [['k', 'a', 5]], 'vv': [['a', 5], ['b', 1]], 'cloud': []})],
}[N]
for label, args, expected in cases:
    check(label, solve(*args), expected)
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)

prompt:
The cloud grows without bound with dots the vector already summarizes.

A state is {"dots": [[element, replica, n]], "vv": {replica: n}, "cloud": [[replica, n]]}. A context covers (r, n) when n <= vv[r] or [r, n] is in the cloud. Join keeps dots present in both states plus dots of one state not covered by the other's context; contexts join by vector maximum and cloud union, then the cloud is compacted: an entry equal to vv[r]+1 advances vv[r], entries at or below vv[r] are pruned. Return elements, dots, vector and cloud, all sorted.

split: open-access


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

N = 1
observations = []
def solve(arrivals):
    local = {}
    delivered, buffer, dups = [], [], 0
    def ready(msg):
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) <= local.get(s, 0):
            return False
        return all(v <= local.get(k, 0) for k, v in vc.items() if k != s)
    for msg in arrivals:
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) <= local.get(s, 0) or any(b[0] == s and b[1].get(s) == vc.get(s) for b in buffer):
            dups += 1
            continue
        buffer.append(msg)
        progress = True
        while progress:
            progress = False
            for b in buffer:
                if ready(b):
                    buffer.remove(b)
                    local[b[0]] = b[1][b[0]]
                    delivered.append(b[2])
                    progress = True
                    break
    return {'delivered': delivered, 'pending': sorted(b[2] for b in buffer), 'duplicates': dups, 'clock': sorted([k, v] for k, v in local.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = {
    1: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2']]], {'delivered': ['b1', 'b2'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 2]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    2: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3']]], {'delivered': ['b1', 'b2', 'b3'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 3]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 2, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    3: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4']]], {'delivered': ['b1', 'b2', 'b3', 'b4'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 4]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 3, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    4: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 5]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 4, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    5: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5'], ['b', {'b': 6}, 'b6']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5', 'b6'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 6]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 5, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
}[N]
for label, args, expected in cases:
    check(label, solve(*args), expected)
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)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

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

N = 1
observations = []
def solve(arrivals):
    local = {}
    delivered, buffer, dups = [], [], 0
    def ready(msg):
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) != len(delivered) + 1:
            return False
        return all(v <= local.get(k, 0) for k, v in vc.items() if k != s)
    for msg in arrivals:
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) <= local.get(s, 0) or any(b[0] == s and b[1].get(s) == vc.get(s) for b in buffer):
            dups += 1
            continue
        buffer.append(msg)
        progress = True
        while progress:
            progress = False
            for b in buffer:
                if ready(b):
                    buffer.remove(b)
                    local[b[0]] = b[1][b[0]]
                    delivered.append(b[2])
                    progress = True
                    break
    return {'delivered': delivered, 'pending': sorted(b[2] for b in buffer), 'duplicates': dups, 'clock': sorted([k, v] for k, v in local.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = {
    1: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2']]], {'delivered': ['b1', 'b2'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 2]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    2: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3']]], {'delivered': ['b1', 'b2', 'b3'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 3]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 2, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    3: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4']]], {'delivered': ['b1', 'b2', 'b3', 'b4'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 4]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 3, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    4: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 5]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 4, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    5: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5'], ['b', {'b': 6}, 'b6']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5', 'b6'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 6]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 5, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
}[N]
for label, args, expected in cases:
    check(label, solve(*args), expected)
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)

prompt:
A later message from a sender is applied before the earlier one it follows.

A receiver starts with an empty delivered vector. An arrival [sender, vector, payload] is a duplicate when its sender entry is at or below the delivered entry or the same (sender, entry) is already buffered. Otherwise it is buffered; then, repeatedly, the oldest buffered message whose sender entry is exactly delivered+1 and whose other entries are all <= delivered is delivered, setting only the sender entry. Return delivered payloads, sorted pending payloads, duplicate count and the delivered vector.

split: open-access


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

N = 1
observations = []
def solve(arrivals):
    local = {}
    delivered, buffer, dups = [], [], 0
    def ready(msg):
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) != local.get(s, 0) + 1:
            return False
        return True
    for msg in arrivals:
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) <= local.get(s, 0) or any(b[0] == s and b[1].get(s) == vc.get(s) for b in buffer):
            dups += 1
            continue
        buffer.append(msg)
        progress = True
        while progress:
            progress = False
            for b in buffer:
                if ready(b):
                    buffer.remove(b)
                    local[b[0]] = b[1][b[0]]
                    delivered.append(b[2])
                    progress = True
                    break
    return {'delivered': delivered, 'pending': sorted(b[2] for b in buffer), 'duplicates': dups, 'clock': sorted([k, v] for k, v in local.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = {
    1: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2']]], {'delivered': ['b1', 'b2'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 2]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    2: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3']]], {'delivered': ['b1', 'b2', 'b3'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 3]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 2, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    3: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4']]], {'delivered': ['b1', 'b2', 'b3', 'b4'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 4]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 3, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    4: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 5]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 4, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    5: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5'], ['b', {'b': 6}, 'b6']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5', 'b6'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 6]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 5, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
}[N]
for label, args, expected in cases:
    check(label, solve(*args), expected)
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)

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

N = 1
observations = []
def solve(arrivals):
    local = {}
    delivered, buffer, dups = [], [], 0
    def ready(msg):
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) != local.get(s, 0) + 1:
            return False
        return all(v <= local[k] for k, v in vc.items() if k != s and k in local)
    for msg in arrivals:
        s, vc = msg[0], msg[1]
        if vc.get(s, 0) <= local.get(s, 0) or any(b[0] == s and b[1].get(s) == vc.get(s) for b in buffer):
            dups += 1
            continue
        buffer.append(msg)
        progress = True
        while progress:
            progress = False
            for b in buffer:
                if ready(b):
                    buffer.remove(b)
                    local[b[0]] = b[1][b[0]]
                    delivered.append(b[2])
                    progress = True
                    break
    return {'delivered': delivered, 'pending': sorted(b[2] for b in buffer), 'duplicates': dups, 'clock': sorted([k, v] for k, v in local.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = {
    1: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2']]], {'delivered': ['b1', 'b2'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 2]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    2: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3']]], {'delivered': ['b1', 'b2', 'b3'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 3]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 2, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    3: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4']]], {'delivered': ['b1', 'b2', 'b3', 'b4'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 4]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 3, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    4: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 5]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 4, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
    5: [('in-order stream delivers immediately', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 2, 'b': 1}, 'b1']]], {'delivered': ['a1', 'a2', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 2], ['b', 1]]}), ('gap from one sender waits', [[['a', {'a': 2}, 'a2'], ['b', {'b': 1}, 'b1'], ['b', {'b': 2}, 'b2'], ['b', {'b': 3}, 'b3'], ['b', {'b': 4}, 'b4'], ['b', {'b': 5}, 'b5'], ['b', {'b': 6}, 'b6']]], {'delivered': ['b1', 'b2', 'b3', 'b4', 'b5', 'b6'], 'pending': ['a2'], 'duplicates': 0, 'clock': [['b', 6]]}), ('dependency on another sender waits', [[['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 1]]}), ('dependency on an unseen sender waits', [[['b', {'c': 1, 'b': 1}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1'], 'pending': ['b1'], 'duplicates': 0, 'clock': [['a', 1]]}), ('buffer drains in cascade', [[['a', {'a': 3}, 'a3'], ['a', {'a': 2}, 'a2'], ['b', {'b': 1, 'a': 3}, 'b1'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2', 'a3', 'b1'], 'pending': [], 'duplicates': 0, 'clock': [['a', 3], ['b', 1]]}), ('duplicate of a delivered message is discarded', [[['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 5, 'clock': [['a', 2]]}), ('duplicate of a buffered message is discarded', [[['a', {'a': 2}, 'a2'], ['a', {'a': 2}, 'a2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['a1', 'a2'], 'pending': [], 'duplicates': 1, 'clock': [['a', 2]]}), ('receiver ahead of a dependency keeps its clock', [[['a', {'a': 1}, 'a1'], ['a', {'a': 2}, 'a2'], ['b', {'a': 1, 'b': 1}, 'b1'], ['a', {'a': 2}, 'a2'], ['a', {'a': 3}, 'a3']]], {'delivered': ['a1', 'a2', 'b1', 'a3'], 'pending': [], 'duplicates': 1, 'clock': [['a', 3], ['b', 1]]}), ('scan restarts from the oldest buffered message', [[['b', {'b': 1, 'a': 1}, 'b1'], ['c', {'c': 1}, 'c0'], ['b', {'b': 2, 'a': 1}, 'b2'], ['c', {'c': 2, 'a': 1}, 'c2'], ['a', {'a': 1}, 'a1']]], {'delivered': ['c0', 'a1', 'b1', 'b2', 'c2'], 'pending': [], 'duplicates': 0, 'clock': [['a', 1], ['b', 2], ['c', 2]]}), ('empty arrival stream', [[]], {'delivered': [], 'pending': [], 'duplicates': 0, 'clock': []})],
}[N]
for label, args, expected in cases:
    check(label, solve(*args), expected)
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)

prompt:
An operation is applied before operations from other replicas that it causally depends on.

A receiver starts with an empty delivered vector. An arrival [sender, vector, payload] is a duplicate when its sender entry is at or below the delivered entry or the same (sender, entry) is already buffered. Otherwise it is buffered; then, repeatedly, the oldest buffered message whose sender entry is exactly delivered+1 and whose other entries are all <= delivered is delivered, setting only the sender entry. Return delivered payloads, sorted pending payloads, duplicate count and the delivered vector.

split: open-access