Stir a bathtub and a whirlpool forms. Soon none of the water that first made it is still there, yet the whirlpool is. A memory works in a similar way. The neurons holding it are noisy and keep changing, and the memory survives anyway. In both cases the parts come and go, and what persists is a pattern that the system keeps restoring after small disturbances.
If that is what a persistent “thing” is, a natural follow-up is how many such things one system can hold, and how sturdy each can be. Thinking of identity as repair gives a precise answer: the more disturbance an identity can survive, the more of the system’s possible states it uses up. A system can hold only so many robust identities at once. The limit is the classical sphere-packing bound from coding theory, read as a statement about identity rather than about messages.
This note comes from the Ontic Frontier Engine, a public FriendMachine research project. It is a small Python program that studies persistence and identity in simple simulated systems, checking its claims by enumerating every possible state and, for the central result, by formal proof. Nothing below needs the code, but the figures were produced by it.
Identities as patterns the system repairs
To make “keeps restoring” precise, start with a small system whose state is a row of bits and which changes in steps by a fixed rule. Let it run long enough and it usually settles into a state, or a short cycle of states, that it keeps returning to. That settled pattern is called an attractor.
Now disturb the system by flipping a few bits of its state. If the rule carries the system back to the same attractor, the disturbance has been repaired, and the repair came from the system’s own rule rather than from anything outside it.
This is the same job an error-correcting code does. Engineers protect messages so that a few corrupted bits can be fixed, using a decoder that maps a damaged message back to the nearest valid one. In a self-repairing system, the rule itself plays the decoder. Each attractor that reliably repairs damage therefore behaves like a code the system maintains on its own.
Repair only makes sense relative to how hard the system was knocked. To measure “a few bits,” we use Hamming distance, the number of bits on which two states differ. A disturbance of radius 3 flips up to three bits.
The smallest example: seven voters
The whole idea, including the limit, already shows up in a system small enough to count by hand. Take seven bits. At each step, every bit is replaced by the majority value of all seven. If four or more bits are 1, the next state is all ones. Otherwise, it is all zeros.
This system has two identities, all zeros and all ones. Flip up to three bits of all zeros, and zeros still hold the majority, so one step restores all zeros. The same goes for all ones.
Count the states each identity repairs. Within three flips of all zeros there are 1 + 7 + 21 + 35 = 64 states, and the same is true for all ones. There are 2⁷ = 128 states in total, and 2 × 64 = 128. At radius 3, the two identities divide the entire state space between them exactly, with nothing left over.
Now try radius 4. Four flips from all zeros gives a state with four ones, which the majority rule sends to all ones. That state is also only three flips from all ones. One state cannot be repaired to two different identities, so neither identity can survive every four-bit disturbance. The two identities have run out of room.
Coding theorists will recognize this system as the seven-bit repetition code, a textbook example of a “perfect” code whose correction regions fill the space exactly, with no gaps.
Why the limit is general
Nothing about this collision depends on majority voting. The seven-voter case is an instance of a general rule. Call the region of states that an identity repairs its correction neighborhood. Two distinct identities cannot share a state in their neighborhoods, because the system’s rule sends each state to exactly one place. The neighborhoods never overlap, and together they fit inside the full set of states. That gives a bound:
(number of robust identities) × (states the smallest one repairs) ≤ (total number of states)
Demanding more robustness makes each neighborhood larger, so fewer identities can fit. Demanding more identities forces each to be less robust. A system’s own dynamics cannot escape this trade-off.
The project also writes this result down in Lean 4, a programming language in which mathematical proofs are checked line by line by a computer. There it is called the Causal Exclusion Theorem, stated for finite systems with a deterministic rule, meaning one that always sends a given state to the same next state. The repository describes it as a machine-checked proof that uses only Lean’s standard axioms and contains no unfinished steps. The mathematics is the familiar sphere-packing argument, and the formal proof checks it in the case where the decoder is the system’s own update rule.
A memory that repairs itself
Seven voters make a clean example but not a very interesting thing to remember. The same picture fits systems people actually use as memory. A Hopfield network is a simple model of associative memory: a set of on-off units whose connections are set so that chosen patterns become attractors. Corrupt a stored pattern slightly, and the network’s ordinary update rule pulls it back.
Each stored pattern behaves like a code word, with the network’s update rule as its decoder, so the packing bound applies here too. Storing more patterns, or making each one survive heavier corruption, draws on the same fixed space of states. The project checks this bound across several kinds of systems, including majority voting, simple cellular automata (rows of cells that update from their neighbors), random Boolean networks (on-off nodes wired together at random), Hopfield networks and small Game of Life grids.
The project also separates questions that the bound runs together. The simple packing limit says how many identities could fit at most, judging only by the size of their neighborhoods. A sharper count asks which identities could all be repaired without error by some decoder, which also depends on how the neighborhoods overlap. A third asks how many the system’s own rule actually repairs. Each number can be smaller than the one before, and the project checks that order on every run instead of assuming it.
How far this goes
The core result is classical. Sphere-packing bounds are decades old, and the seven-bit majority system is a textbook repetition code. What the project adds is a way of describing identity as something a system repairs for itself, along with tools for measuring that repair directly in small systems.
The setting is narrow. The exhaustive checks cover finite systems small enough to enumerate every state, with a fixed, deterministic rule, and mostly concern repair without any error. A noisy extension exists, but larger and more realistic systems are untested. Whether this way of identifying “things” agrees with other ways of carving a system into parts is an open question the project is still measuring.
The code, animations and Lean proof are in the Ontic Frontier Engine repository.