FAILURE MAP
← Case archive

FA-90711 / Garbage collector invariants / Open access

Identity hash: every move re-stores the hash · case 01

After a second move the hash changes and the object grows another 8 bytes.

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

ROOT CAUSE

The move path treats already-moved objects like newly hashed ones.

THE FAILURE

The move path treats already-moved objects like newly hashed ones.

Unsuccessful approach: Also storing on moves of unhashed objects freezes a hash nobody asked for and grows them.

Case contract

objs maps id -> [address, size]. The identity hash of an object is (address >> 3) & 0xFFFF of the address at which it was first hashed. Objects start unhashed; hash marks them hashed and returns the hash computed from the current address while they have not moved. The first move of a hashed object stores that hash in a new 8-byte trailing slot (size grows by 8) and later moves keep it; moving an unhashed object stores nothing. Return all hashes and the final [address, size] layout.

Why this case matters

Moving collectors must keep identity hashes stable even though they are derived from addresses.

1 / The failure

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

N = 1
observations = []
def solve(objs, events):
    objs = {k: list(v) for k, v in objs.items()}
    state = {o: 'unhashed' for o in objs}
    stored = {}
    out = []
    for ev in events:
        o = ev[1]
        if ev[0] == 'hash':
            if state[o] == 'unhashed':
                state[o] = 'hashed'
            if state[o] == 'hashed':
                out.append(objs[o][0] >> 3 & 0xFFFF)
            else:
                out.append(stored[o])
        else:
            if state[o] != 'unhashed':
                stored[o] = objs[o][0] >> 3 & 0xFFFF
                state[o] = 'moved'
                objs[o][1] += 8
            objs[o][0] = ev[2]
    return {'hashes': out, 'layout': {str(k): v for k, v in sorted(objs.items())}}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: hash survives a move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36872], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16400], ['hash', 3], ['hash', 3]]),
   {'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20488]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28680]]),
   {'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8202, 8202], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36880], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65616, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16416], ['hash', 3], ['hash', 3]]),
   {'hashes': [2052, 2052], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [16416, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8202], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20496]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20496, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28688]]),
   {'hashes': [], 'layout': {'1': [65616, 24], '2': [28688, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8203, 8203], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36888], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65624, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16432], ['hash', 3], ['hash', 3]]),
   {'hashes': [2054, 2054], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [16432, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8203], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20504]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20504, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28696]]),
   {'hashes': [], 'layout': {'1': [65624, 24], '2': [28696, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8204, 8204], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36896], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65632, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16448], ['hash', 3], ['hash', 3]]),
   {'hashes': [2056, 2056], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [16448, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8204], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20512]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20512, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28704]]),
   {'hashes': [], 'layout': {'1': [65632, 24], '2': [28704, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8205, 8205], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36904], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65640, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16464], ['hash', 3], ['hash', 3]]),
   {'hashes': [2058, 2058], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [16464, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8205], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20520]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20520, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28712]]),
   {'hashes': [], 'layout': {'1': [65640, 24], '2': [28712, 16], '3': [201272, 32]}})]]
for label, args, expected in cases[N - 1]:
    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)
Boundary fixtureActualExpectedOutcome
regression: hash survives a move{'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}Passed
object moved twice after hashing{'hashes': [1024, 4609], 'layout': {'1': [65608, 24], '2': [40960, 32], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}Failed
unhashed object moves freely{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}Passed
high address bits masked after shifting{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
hash requested again before any move{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
control: no hashing{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}Passed

SHA-256 / 95e394b66e247b308fc9c0a584179ef30a57d88e79740fa859dd07300c4d1a00

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(objs, events):
    objs = {k: list(v) for k, v in objs.items()}
    state = {o: 'unhashed' for o in objs}
    stored = {}
    out = []
    for ev in events:
        o = ev[1]
        if ev[0] == 'hash':
            if state[o] == 'unhashed':
                state[o] = 'hashed'
            if state[o] == 'hashed':
                out.append(objs[o][0] >> 3 & 0xFFFF)
            else:
                out.append(stored[o])
        else:
            if state[o] in ('hashed', 'unhashed'):
                stored[o] = objs[o][0] >> 3 & 0xFFFF
                state[o] = 'moved'
                objs[o][1] += 8
            objs[o][0] = ev[2]
    return {'hashes': out, 'layout': {str(k): v for k, v in sorted(objs.items())}}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: hash survives a move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36872], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16400], ['hash', 3], ['hash', 3]]),
   {'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20488]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28680]]),
   {'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8202, 8202], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36880], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65616, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16416], ['hash', 3], ['hash', 3]]),
   {'hashes': [2052, 2052], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [16416, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8202], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20496]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20496, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28688]]),
   {'hashes': [], 'layout': {'1': [65616, 24], '2': [28688, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8203, 8203], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36888], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65624, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16432], ['hash', 3], ['hash', 3]]),
   {'hashes': [2054, 2054], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [16432, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8203], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20504]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20504, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28696]]),
   {'hashes': [], 'layout': {'1': [65624, 24], '2': [28696, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8204, 8204], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36896], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65632, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16448], ['hash', 3], ['hash', 3]]),
   {'hashes': [2056, 2056], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [16448, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8204], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20512]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20512, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28704]]),
   {'hashes': [], 'layout': {'1': [65632, 24], '2': [28704, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8205, 8205], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36904], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65640, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16464], ['hash', 3], ['hash', 3]]),
   {'hashes': [2058, 2058], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [16464, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8205], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20520]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20520, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28712]]),
   {'hashes': [], 'layout': {'1': [65640, 24], '2': [28712, 16], '3': [201272, 32]}})]]
for label, args, expected in cases[N - 1]:
    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)
Boundary fixtureActualExpectedOutcome
regression: hash survives a move{'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}Passed
object moved twice after hashing{'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}Passed
unhashed object moves freely{'hashes': [25159, 25159], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 40]}}{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}Failed
high address bits masked after shifting{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
hash requested again before any move{'hashes': [1024, 1024], 'layout': {'1': [20488, 32], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}Failed
control: no hashing{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 24], '3': [201272, 32]}}{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}Failed

SHA-256 / 0b4f042a829f84ad46c395a333da092d68deb993dc6fdf7bbeb30e8fe1f1ed15

HELD IN THE MEMBER ARCHIVE

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

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

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

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

Sign in to the archive ↗

Verification & scope

A deterministic, bounded teaching model of one garbage-collector mechanism with stipulated rules; it is not a production collector and claims no conformance to any particular runtime. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:51:29.282595+00:00.

Case digest / e30ef21462f22b494d693a82c6b10cb71e5be20b683fd86e871be7de667abf1f