The field
Values drawn as colour. Damage shows up as noise against the smooth surface.
Not a compression story
Data that repairs itself, because the shape knows what it should be.
Hold values as a shape rather than as a list and something else comes free.
Every 2×2 patch of the surface z = a·x·y + b·x + c·y + d
obeys one small identity. A cell that has been damaged no longer agrees with what its
neighbours imply, so the damage is visible from the outside, with
no master copy, no checksum file and nobody in charge. The neighbours notice, they vote,
and the lattice puts itself back.
Break it below and watch. Then break it badly, and watch it refuse to guess.
What the neighbours can see is wrong
Bright means this cell disagrees with the identity its neighbours satisfy. No cell is told the answer; each one only compares notes locally.
0cells damaged
0repair rounds
...repaired
...still wrong
Ready. The lattice is intact.
Why this happens at all
the identity
The rule constrains the values
For this surface, every 2×2 block satisfies
f(x+1,y+1) − f(x+1,y) − f(x,y+1) + f(x,y) = a.
It holds everywhere, so any cell can be predicted from three neighbours. A list of
numbers has no such property; a shape does.
the witnesses
Four blocks see every cell
Each interior cell sits in four different 2×2 blocks, so four independent predictions exist for it. When three or more agree with each other and disagree with the stored value, the stored value is the thing that is wrong.
the limit
Witnesses can be destroyed too
Damage a solid block and every witness to those cells is damaged as well. Then the neighbourhood genuinely does not know, and the right behaviour is to stop rather than invent something. That is what the third button demonstrates.
Where this sits in the established world. This is the same shape of idea as erasure coding and RAID: you recover while enough independent witnesses survive, and you lose when a single failure takes out a cell and all of its witnesses together. The engineering question it raises is the familiar one: how far apart to place things so that one accident cannot reach both. What is unusual here is that no parity was added to the data. The geometry was already carrying it, because the rule that generates the values also constrains them.
What this is evidence for
Storing data as a shape is usually argued about on size, and on measured data the size argument is modest: my own benchmarks put it at a few percent over gzip, and I publish the cases where it loses. This page is the other half of the story. A shape brings properties a compressed blob does not have: it can be queried without being unpacked, it can be produced at runtime instead of stored, and it can notice when it has been damaged and fix itself. None of those are compression, and none of them show up in a size comparison.