{"abstract":"A replica that was given rights still cannot decrement.","category":"CRDT convergence","checks":8,"contract":"Replicas share maps P (increments by replica), D (decrements by replica) and T (\"from>to\" transferred rights). A replica's rights are its own P minus its own D plus transfers to it minus transfers from it, all read from its local view. [\"inc\", r, k] grows P[r]; [\"dec\", r, k] and [\"move\", r, to, k] are rejected (event index recorded) unless rights >= k. [\"sync\", s, d] folds s's maps into d by maximum. Return values (sum P - sum D), rights, and rejected indices.","evaluation_group":"w2-crdt-convergence-bounded-counter-rights","failed_approach":"Crediting all known transfers, including those between other replicas, overstates rights.","family":"w2-crdt-convergence-bounded-counter-rights-incoming-rights","id":"FA-75036","implementations":{"attempt":{"sha256":"42d03a0f88ca14a3bdd1b4ea4107d0d2f3e8132c38b8b775e622c55433e2b0b6","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(events, replicas):\n    P = {r: {} for r in replicas}\n    D = {r: {} for r in replicas}\n    T = {r: {} for r in replicas}\n    rejected = []\n    def rights(r):\n        own = P[r].get(r, 0) - D[r].get(r, 0)\n        incoming = sum(T[r].values())\n        outgoing = sum(v for k, v in T[r].items() if k.split('>')[0] == r)\n        return own + incoming - outgoing\n    for i, ev in enumerate(events):\n        kind = ev[0]\n        if kind == 'sync':\n            s, d = ev[1], ev[2]\n            for src, dst in ((P[s], P[d]), (D[s], D[d]), (T[s], T[d])):\n                for k, v in src.items():\n                    dst[k] = max(dst.get(k, 0), v)\n        elif kind == 'inc':\n            P[ev[1]][ev[1]] = P[ev[1]].get(ev[1], 0) + ev[2]\n        elif kind == 'dec':\n            r, k = ev[1], ev[2]\n            if rights(r) < k:\n                rejected.append(i)\n            else:\n                D[r][r] = D[r].get(r, 0) + k\n        else:\n            r, to, k = ev[1], ev[2], ev[3]\n            if rights(r) < k:\n                rejected.append(i)\n            else:\n                key = r + '>' + to\n                T[r][key] = T[r].get(key, 0) + k\n    return {'values': [sum(P[r].values()) - sum(D[r].values()) for r in replicas], 'rights': [rights(r) for r in replicas], 'rejected': rejected}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = {\n    1: [('each replica spends only its own rights', [[['inc', 'a', 2], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 2]], ['a', 'b', 'c']], {'values': [0, 2, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 4], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [2, 2, 0], 'rights': [2, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 2], ['move', 'a', 'c', 1], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 1], ['dec', 'c', 1], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [1, 0, 1], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 1], ['dec', 'b', 1], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 1], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [4, 4, 3], 'rights': [1, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 5], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [2, 5, 2], 'rights': [2, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 1], ['dec', 'c', 4], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    2: [('each replica spends only its own rights', [[['inc', 'a', 3], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 3]], ['a', 'b', 'c']], {'values': [0, 3, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 5], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [3, 3, 0], 'rights': [3, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 4], ['move', 'a', 'c', 2], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 2], ['dec', 'c', 2], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [2, 0, 2], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 2], ['dec', 'b', 2], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 2], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [5, 5, 3], 'rights': [2, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 6], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [3, 6, 3], 'rights': [3, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 2], ['dec', 'c', 5], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    3: [('each replica spends only its own rights', [[['inc', 'a', 4], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 4]], ['a', 'b', 'c']], {'values': [0, 4, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 6], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [4, 4, 0], 'rights': [4, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 6], ['move', 'a', 'c', 3], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 3], ['dec', 'c', 3], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [3, 0, 3], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 3], ['dec', 'b', 3], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 3], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [6, 6, 3], 'rights': [3, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 7], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [4, 7, 4], 'rights': [4, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 3], ['dec', 'c', 6], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    4: [('each replica spends only its own rights', [[['inc', 'a', 5], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 5]], ['a', 'b', 'c']], {'values': [0, 5, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 7], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [5, 5, 0], 'rights': [5, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 8], ['move', 'a', 'c', 4], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 4], ['dec', 'c', 4], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [4, 0, 4], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 4], ['dec', 'b', 4], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 4], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [7, 7, 3], 'rights': [4, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 8], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [5, 8, 5], 'rights': [5, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 4], ['dec', 'c', 7], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    5: [('each replica spends only its own rights', [[['inc', 'a', 6], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 6]], ['a', 'b', 'c']], {'values': [0, 6, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 8], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [6, 6, 0], 'rights': [6, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 10], ['move', 'a', 'c', 5], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 5], ['dec', 'c', 5], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [5, 0, 5], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 5], ['dec', 'b', 5], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 5], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [8, 8, 3], 'rights': [5, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 9], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [6, 9, 6], 'rights': [6, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 5], ['dec', 'c', 8], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n}[N]\nfor label, args, expected in cases:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"broken":{"sha256":"17f933c6471139300de799e99b989656aaa2c094005ac00a2c7f1936ea42d9d6","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(events, replicas):\n    P = {r: {} for r in replicas}\n    D = {r: {} for r in replicas}\n    T = {r: {} for r in replicas}\n    rejected = []\n    def rights(r):\n        own = P[r].get(r, 0) - D[r].get(r, 0)\n        incoming = 0\n        outgoing = sum(v for k, v in T[r].items() if k.split('>')[0] == r)\n        return own + incoming - outgoing\n    for i, ev in enumerate(events):\n        kind = ev[0]\n        if kind == 'sync':\n            s, d = ev[1], ev[2]\n            for src, dst in ((P[s], P[d]), (D[s], D[d]), (T[s], T[d])):\n                for k, v in src.items():\n                    dst[k] = max(dst.get(k, 0), v)\n        elif kind == 'inc':\n            P[ev[1]][ev[1]] = P[ev[1]].get(ev[1], 0) + ev[2]\n        elif kind == 'dec':\n            r, k = ev[1], ev[2]\n            if rights(r) < k:\n                rejected.append(i)\n            else:\n                D[r][r] = D[r].get(r, 0) + k\n        else:\n            r, to, k = ev[1], ev[2], ev[3]\n            if rights(r) < k:\n                rejected.append(i)\n            else:\n                key = r + '>' + to\n                T[r][key] = T[r].get(key, 0) + k\n    return {'values': [sum(P[r].values()) - sum(D[r].values()) for r in replicas], 'rights': [rights(r) for r in replicas], 'rejected': rejected}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = {\n    1: [('each replica spends only its own rights', [[['inc', 'a', 2], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 2]], ['a', 'b', 'c']], {'values': [0, 2, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 4], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [2, 2, 0], 'rights': [2, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 2], ['move', 'a', 'c', 1], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 1], ['dec', 'c', 1], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [1, 0, 1], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 1], ['dec', 'b', 1], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 1], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [4, 4, 3], 'rights': [1, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 5], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [2, 5, 2], 'rights': [2, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 1], ['dec', 'c', 4], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    2: [('each replica spends only its own rights', [[['inc', 'a', 3], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 3]], ['a', 'b', 'c']], {'values': [0, 3, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 5], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [3, 3, 0], 'rights': [3, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 4], ['move', 'a', 'c', 2], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 2], ['dec', 'c', 2], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [2, 0, 2], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 2], ['dec', 'b', 2], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 2], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [5, 5, 3], 'rights': [2, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 6], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [3, 6, 3], 'rights': [3, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 2], ['dec', 'c', 5], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    3: [('each replica spends only its own rights', [[['inc', 'a', 4], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 4]], ['a', 'b', 'c']], {'values': [0, 4, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 6], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [4, 4, 0], 'rights': [4, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 6], ['move', 'a', 'c', 3], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 3], ['dec', 'c', 3], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [3, 0, 3], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 3], ['dec', 'b', 3], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 3], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [6, 6, 3], 'rights': [3, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 7], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [4, 7, 4], 'rights': [4, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 3], ['dec', 'c', 6], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    4: [('each replica spends only its own rights', [[['inc', 'a', 5], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 5]], ['a', 'b', 'c']], {'values': [0, 5, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 7], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [5, 5, 0], 'rights': [5, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 8], ['move', 'a', 'c', 4], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 4], ['dec', 'c', 4], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [4, 0, 4], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 4], ['dec', 'b', 4], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 4], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [7, 7, 3], 'rights': [4, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 8], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [5, 8, 5], 'rights': [5, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 4], ['dec', 'c', 7], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    5: [('each replica spends only its own rights', [[['inc', 'a', 6], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 6]], ['a', 'b', 'c']], {'values': [0, 6, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 8], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [6, 6, 0], 'rights': [6, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 10], ['move', 'a', 'c', 5], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 5], ['dec', 'c', 5], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [5, 0, 5], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 5], ['dec', 'b', 5], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 5], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [8, 8, 3], 'rights': [5, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 9], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [6, 9, 6], 'rights': [6, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 5], ['dec', 'c', 8], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n}[N]\nfor label, args, expected in cases:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"fixed":{"sha256":"b87c210c4293d4ab02737f7b6c918b67e86525d6334352c297c386b21237da12","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(events, replicas):\n    P = {r: {} for r in replicas}\n    D = {r: {} for r in replicas}\n    T = {r: {} for r in replicas}\n    rejected = []\n    def rights(r):\n        own = P[r].get(r, 0) - D[r].get(r, 0)\n        incoming = sum(v for k, v in T[r].items() if k.split('>')[1] == r)\n        outgoing = sum(v for k, v in T[r].items() if k.split('>')[0] == r)\n        return own + incoming - outgoing\n    for i, ev in enumerate(events):\n        kind = ev[0]\n        if kind == 'sync':\n            s, d = ev[1], ev[2]\n            for src, dst in ((P[s], P[d]), (D[s], D[d]), (T[s], T[d])):\n                for k, v in src.items():\n                    dst[k] = max(dst.get(k, 0), v)\n        elif kind == 'inc':\n            P[ev[1]][ev[1]] = P[ev[1]].get(ev[1], 0) + ev[2]\n        elif kind == 'dec':\n            r, k = ev[1], ev[2]\n            if rights(r) < k:\n                rejected.append(i)\n            else:\n                D[r][r] = D[r].get(r, 0) + k\n        else:\n            r, to, k = ev[1], ev[2], ev[3]\n            if rights(r) < k:\n                rejected.append(i)\n            else:\n                key = r + '>' + to\n                T[r][key] = T[r].get(key, 0) + k\n    return {'values': [sum(P[r].values()) - sum(D[r].values()) for r in replicas], 'rights': [rights(r) for r in replicas], 'rejected': rejected}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = {\n    1: [('each replica spends only its own rights', [[['inc', 'a', 2], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 2]], ['a', 'b', 'c']], {'values': [0, 2, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 4], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [2, 2, 0], 'rights': [2, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 2], ['move', 'a', 'c', 1], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 1], ['dec', 'c', 1], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [1, 0, 1], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 1], ['dec', 'b', 1], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 1], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [4, 4, 3], 'rights': [1, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 5], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [2, 5, 2], 'rights': [2, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 1], ['dec', 'c', 4], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    2: [('each replica spends only its own rights', [[['inc', 'a', 3], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 3]], ['a', 'b', 'c']], {'values': [0, 3, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 5], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [3, 3, 0], 'rights': [3, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 4], ['move', 'a', 'c', 2], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 2], ['dec', 'c', 2], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [2, 0, 2], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 2], ['dec', 'b', 2], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 2], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [5, 5, 3], 'rights': [2, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 6], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [3, 6, 3], 'rights': [3, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 2], ['dec', 'c', 5], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    3: [('each replica spends only its own rights', [[['inc', 'a', 4], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 4]], ['a', 'b', 'c']], {'values': [0, 4, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 6], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [4, 4, 0], 'rights': [4, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 6], ['move', 'a', 'c', 3], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 3], ['dec', 'c', 3], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [3, 0, 3], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 3], ['dec', 'b', 3], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 3], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [6, 6, 3], 'rights': [3, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 7], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [4, 7, 4], 'rights': [4, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 3], ['dec', 'c', 6], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    4: [('each replica spends only its own rights', [[['inc', 'a', 5], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 5]], ['a', 'b', 'c']], {'values': [0, 5, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 7], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [5, 5, 0], 'rights': [5, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 8], ['move', 'a', 'c', 4], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 4], ['dec', 'c', 4], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [4, 0, 4], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 4], ['dec', 'b', 4], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 4], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [7, 7, 3], 'rights': [4, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 8], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [5, 8, 5], 'rights': [5, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 4], ['dec', 'c', 7], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n    5: [('each replica spends only its own rights', [[['inc', 'a', 6], ['sync', 'a', 'b'], ['dec', 'b', 1], ['dec', 'a', 6]], ['a', 'b', 'c']], {'values': [0, 6, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('transferred rights can be spent', [[['inc', 'a', 8], ['move', 'a', 'b', 2], ['sync', 'a', 'b'], ['dec', 'b', 2], ['sync', 'b', 'a']], ['a', 'b', 'c']], {'values': [6, 6, 0], 'rights': [6, 0, 0], 'rejected': []}), ('outgoing transfers reduce rights', [[['inc', 'a', 3], ['move', 'a', 'b', 2], ['dec', 'a', 2], ['dec', 'a', 1]], ['a', 'b', 'c']], {'values': [2, 0, 0], 'rights': [0, 0, 0], 'rejected': [2]}), ('concurrent spending cannot go negative', [[['inc', 'a', 10], ['move', 'a', 'c', 5], ['sync', 'a', 'b'], ['sync', 'a', 'c'], ['dec', 'a', 5], ['dec', 'c', 5], ['dec', 'b', 1], ['sync', 'a', 'b'], ['sync', 'c', 'b']], ['a', 'b', 'c']], {'values': [5, 0, 5], 'rights': [0, 0, 0], 'rejected': [6]}), ('rights exhausted exactly', [[['inc', 'b', 5], ['dec', 'b', 5], ['dec', 'b', 1], ['move', 'b', 'a', 1]], ['a', 'b', 'c']], {'values': [0, 0, 0], 'rights': [0, 0, 0], 'rejected': [2, 3]}), ('decrements propagate by sync', [[['inc', 'c', 5], ['sync', 'c', 'a'], ['dec', 'c', 2], ['sync', 'c', 'a'], ['inc', 'a', 5], ['sync', 'a', 'b']], ['a', 'b', 'c']], {'values': [8, 8, 3], 'rights': [5, 0, 3], 'rejected': []}), ('stale peer does not undo local decrements', [[['inc', 'a', 9], ['sync', 'a', 'b'], ['dec', 'a', 3], ['sync', 'b', 'a'], ['sync', 'a', 'c']], ['a', 'b', 'c']], {'values': [6, 9, 6], 'rights': [6, 0, 0], 'rejected': []}), ('transfer received before own increments', [[['inc', 'a', 4], ['move', 'a', 'c', 3], ['sync', 'a', 'c'], ['inc', 'c', 5], ['dec', 'c', 8], ['move', 'c', 'b', 1]], ['a', 'b', 'c']], {'values': [4, 0, 1], 'rights': [1, 0, 0], 'rejected': [5]})],\n}[N]\nfor label, args, expected in cases:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"}},"limitations":"A deterministic, bounded teaching model of one replicated data type with stipulated operation and merge rules; it is not a production CRDT library and makes no claim of conformance to any specific published design. 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.","method":"Deterministic executable model with adversarial boundary fixtures.","provenance":{"created_by":"Failure Map","dependencies":"Python standard library","family":"w2-crdt-convergence-bounded-counter-rights-incoming-rights","generated_at":"2026-09-29T14:49:02.321996+00:00","license":"CC0-1.0","python":"3.12.14","seed":1,"split":"open-access"},"relevance":"Bounded counters keep a global non-negativity invariant without coordination by escrowing rights per replica.","repair":"Add every transfer whose destination is the replica to its rights.","root_cause":"The rights computation ignores transfers addressed to the replica.","sha256":"516051198c6402d2d1e971040884593c5bf8da284062a8ec0fa66113f55b4ee5","title":"Bounded counter with rights transfer: received rights are never credited · case 01","variant":1,"variant_policy":"Five numbered records share a model and may reuse boundary fixtures.","verification":{"attempt":{"elapsed_ms":42.014,"exit_code":1,"observations":[{"actual":{"rejected":[2],"rights":[0,0,0],"values":[0,2,0]},"check":"each replica spends only its own rights","expected":{"rejected":[2],"rights":[0,0,0],"values":[0,2,0]},"passed":true},{"actual":{"rejected":[],"rights":[4,0,0],"values":[2,2,0]},"check":"transferred rights can be spent","expected":{"rejected":[],"rights":[2,0,0],"values":[2,2,0]},"passed":false},{"actual":{"rejected":[],"rights":[0,0,0],"values":[0,0,0]},"check":"outgoing transfers reduce rights","expected":{"rejected":[2],"rights":[0,0,0],"values":[2,0,0]},"passed":false},{"actual":{"rejected":[],"rights":[1,0,0],"values":[1,-1,1]},"check":"concurrent spending cannot go negative","expected":{"rejected":[6],"rights":[0,0,0],"values":[1,0,1]},"passed":false},{"actual":{"rejected":[2,3],"rights":[0,0,0],"values":[0,0,0]},"check":"rights exhausted exactly","expected":{"rejected":[2,3],"rights":[0,0,0],"values":[0,0,0]},"passed":true},{"actual":{"rejected":[],"rights":[1,0,3],"values":[4,4,3]},"check":"decrements propagate by sync","expected":{"rejected":[],"rights":[1,0,3],"values":[4,4,3]},"passed":true},{"actual":{"rejected":[],"rights":[2,0,0],"values":[2,5,2]},"check":"stale peer does not undo local decrements","expected":{"rejected":[],"rights":[2,0,0],"values":[2,5,2]},"passed":true},{"actual":{"rejected":[5],"rights":[4,0,0],"values":[4,0,1]},"check":"transfer received before own increments","expected":{"rejected":[5],"rights":[1,0,0],"values":[4,0,1]},"passed":false}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"each replica spends only its own rights\", \"actual\": {\"values\": [0, 2, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"expected\": {\"values\": [0, 2, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"passed\": true}, {\"check\": \"transferred rights can be spent\", \"actual\": {\"values\": [2, 2, 0], \"rights\": [4, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [2, 2, 0], \"rights\": [2, 0, 0], \"rejected\": []}, \"passed\": false}, {\"check\": \"outgoing transfers reduce rights\", \"actual\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [2, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"passed\": false}, {\"check\": \"concurrent spending cannot go negative\", \"actual\": {\"values\": [1, -1, 1], \"rights\": [1, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [1, 0, 1], \"rights\": [0, 0, 0], \"rejected\": [6]}, \"passed\": false}, {\"check\": \"rights exhausted exactly\", \"actual\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2, 3]}, \"expected\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2, 3]}, \"passed\": true}, {\"check\": \"decrements propagate by sync\", \"actual\": {\"values\": [4, 4, 3], \"rights\": [1, 0, 3], \"rejected\": []}, \"expected\": {\"values\": [4, 4, 3], \"rights\": [1, 0, 3], \"rejected\": []}, \"passed\": true}, {\"check\": \"stale peer does not undo local decrements\", \"actual\": {\"values\": [2, 5, 2], \"rights\": [2, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [2, 5, 2], \"rights\": [2, 0, 0], \"rejected\": []}, \"passed\": true}, {\"check\": \"transfer received before own increments\", \"actual\": {\"values\": [4, 0, 1], \"rights\": [4, 0, 0], \"rejected\": [5]}, \"expected\": {\"values\": [4, 0, 1], \"rights\": [1, 0, 0], \"rejected\": [5]}, \"passed\": false}], \"passed\": false}\n"},"broken":{"elapsed_ms":45.176,"exit_code":1,"observations":[{"actual":{"rejected":[2],"rights":[0,0,0],"values":[0,2,0]},"check":"each replica spends only its own rights","expected":{"rejected":[2],"rights":[0,0,0],"values":[0,2,0]},"passed":true},{"actual":{"rejected":[3],"rights":[2,0,0],"values":[4,4,0]},"check":"transferred rights can be spent","expected":{"rejected":[],"rights":[2,0,0],"values":[2,2,0]},"passed":false},{"actual":{"rejected":[2],"rights":[0,0,0],"values":[2,0,0]},"check":"outgoing transfers reduce rights","expected":{"rejected":[2],"rights":[0,0,0],"values":[2,0,0]},"passed":true},{"actual":{"rejected":[5,6],"rights":[0,0,0],"values":[1,1,2]},"check":"concurrent spending cannot go negative","expected":{"rejected":[6],"rights":[0,0,0],"values":[1,0,1]},"passed":false},{"actual":{"rejected":[2,3],"rights":[0,0,0],"values":[0,0,0]},"check":"rights exhausted exactly","expected":{"rejected":[2,3],"rights":[0,0,0],"values":[0,0,0]},"passed":true},{"actual":{"rejected":[],"rights":[1,0,3],"values":[4,4,3]},"check":"decrements propagate by sync","expected":{"rejected":[],"rights":[1,0,3],"values":[4,4,3]},"passed":true},{"actual":{"rejected":[],"rights":[2,0,0],"values":[2,5,2]},"check":"stale peer does not undo local decrements","expected":{"rejected":[],"rights":[2,0,0],"values":[2,5,2]},"passed":true},{"actual":{"rejected":[4],"rights":[1,0,0],"values":[4,0,5]},"check":"transfer received before own increments","expected":{"rejected":[5],"rights":[1,0,0],"values":[4,0,1]},"passed":false}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"each replica spends only its own rights\", \"actual\": {\"values\": [0, 2, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"expected\": {\"values\": [0, 2, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"passed\": true}, {\"check\": \"transferred rights can be spent\", \"actual\": {\"values\": [4, 4, 0], \"rights\": [2, 0, 0], \"rejected\": [3]}, \"expected\": {\"values\": [2, 2, 0], \"rights\": [2, 0, 0], \"rejected\": []}, \"passed\": false}, {\"check\": \"outgoing transfers reduce rights\", \"actual\": {\"values\": [2, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"expected\": {\"values\": [2, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"passed\": true}, {\"check\": \"concurrent spending cannot go negative\", \"actual\": {\"values\": [1, 1, 2], \"rights\": [0, 0, 0], \"rejected\": [5, 6]}, \"expected\": {\"values\": [1, 0, 1], \"rights\": [0, 0, 0], \"rejected\": [6]}, \"passed\": false}, {\"check\": \"rights exhausted exactly\", \"actual\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2, 3]}, \"expected\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2, 3]}, \"passed\": true}, {\"check\": \"decrements propagate by sync\", \"actual\": {\"values\": [4, 4, 3], \"rights\": [1, 0, 3], \"rejected\": []}, \"expected\": {\"values\": [4, 4, 3], \"rights\": [1, 0, 3], \"rejected\": []}, \"passed\": true}, {\"check\": \"stale peer does not undo local decrements\", \"actual\": {\"values\": [2, 5, 2], \"rights\": [2, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [2, 5, 2], \"rights\": [2, 0, 0], \"rejected\": []}, \"passed\": true}, {\"check\": \"transfer received before own increments\", \"actual\": {\"values\": [4, 0, 5], \"rights\": [1, 0, 0], \"rejected\": [4]}, \"expected\": {\"values\": [4, 0, 1], \"rights\": [1, 0, 0], \"rejected\": [5]}, \"passed\": false}], \"passed\": false}\n"},"fixed":{"elapsed_ms":42.289,"exit_code":0,"observations":[{"actual":{"rejected":[2],"rights":[0,0,0],"values":[0,2,0]},"check":"each replica spends only its own rights","expected":{"rejected":[2],"rights":[0,0,0],"values":[0,2,0]},"passed":true},{"actual":{"rejected":[],"rights":[2,0,0],"values":[2,2,0]},"check":"transferred rights can be spent","expected":{"rejected":[],"rights":[2,0,0],"values":[2,2,0]},"passed":true},{"actual":{"rejected":[2],"rights":[0,0,0],"values":[2,0,0]},"check":"outgoing transfers reduce rights","expected":{"rejected":[2],"rights":[0,0,0],"values":[2,0,0]},"passed":true},{"actual":{"rejected":[6],"rights":[0,0,0],"values":[1,0,1]},"check":"concurrent spending cannot go negative","expected":{"rejected":[6],"rights":[0,0,0],"values":[1,0,1]},"passed":true},{"actual":{"rejected":[2,3],"rights":[0,0,0],"values":[0,0,0]},"check":"rights exhausted exactly","expected":{"rejected":[2,3],"rights":[0,0,0],"values":[0,0,0]},"passed":true},{"actual":{"rejected":[],"rights":[1,0,3],"values":[4,4,3]},"check":"decrements propagate by sync","expected":{"rejected":[],"rights":[1,0,3],"values":[4,4,3]},"passed":true},{"actual":{"rejected":[],"rights":[2,0,0],"values":[2,5,2]},"check":"stale peer does not undo local decrements","expected":{"rejected":[],"rights":[2,0,0],"values":[2,5,2]},"passed":true},{"actual":{"rejected":[5],"rights":[1,0,0],"values":[4,0,1]},"check":"transfer received before own increments","expected":{"rejected":[5],"rights":[1,0,0],"values":[4,0,1]},"passed":true}],"passed":true,"stderr":"","stdout":"{\"observations\": [{\"check\": \"each replica spends only its own rights\", \"actual\": {\"values\": [0, 2, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"expected\": {\"values\": [0, 2, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"passed\": true}, {\"check\": \"transferred rights can be spent\", \"actual\": {\"values\": [2, 2, 0], \"rights\": [2, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [2, 2, 0], \"rights\": [2, 0, 0], \"rejected\": []}, \"passed\": true}, {\"check\": \"outgoing transfers reduce rights\", \"actual\": {\"values\": [2, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"expected\": {\"values\": [2, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2]}, \"passed\": true}, {\"check\": \"concurrent spending cannot go negative\", \"actual\": {\"values\": [1, 0, 1], \"rights\": [0, 0, 0], \"rejected\": [6]}, \"expected\": {\"values\": [1, 0, 1], \"rights\": [0, 0, 0], \"rejected\": [6]}, \"passed\": true}, {\"check\": \"rights exhausted exactly\", \"actual\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2, 3]}, \"expected\": {\"values\": [0, 0, 0], \"rights\": [0, 0, 0], \"rejected\": [2, 3]}, \"passed\": true}, {\"check\": \"decrements propagate by sync\", \"actual\": {\"values\": [4, 4, 3], \"rights\": [1, 0, 3], \"rejected\": []}, \"expected\": {\"values\": [4, 4, 3], \"rights\": [1, 0, 3], \"rejected\": []}, \"passed\": true}, {\"check\": \"stale peer does not undo local decrements\", \"actual\": {\"values\": [2, 5, 2], \"rights\": [2, 0, 0], \"rejected\": []}, \"expected\": {\"values\": [2, 5, 2], \"rights\": [2, 0, 0], \"rejected\": []}, \"passed\": true}, {\"check\": \"transfer received before own increments\", \"actual\": {\"values\": [4, 0, 1], \"rights\": [1, 0, 0], \"rejected\": [5]}, \"expected\": {\"values\": [4, 0, 1], \"rights\": [1, 0, 0], \"rejected\": [5]}, \"passed\": true}], \"passed\": true}\n"}},"verified":true,"visibility":"public"}