The whole argument, in order, with the evidence attached
One shape, what it can do, and the places each claim stops.
This page makes a case about a single shape, z = x·y, and everything on
it is either standard mathematics you can look up, a measurement you can re-run, or a
thing you can watch happen in this browser tab. Where a claim has a boundary, the boundary
is printed beside it rather than left for you to discover.
This is not a compression trick. It is not a smaller copy of the data, it is the thing the data was a printout of, and section 03 says exactly what that does and does not mean. It is a way of answering: hold the shape, ask it questions and read the answers off it by observation instead of computing through the data, let a change travel through it, and let it repair itself. None of it is new mathematics, and none of it overturns any. It is known mathematics presented dimensionally, so the form of the answer is visible at the start instead of at the end of a long derivation.
I am one person without an institution behind me, so I am not asking you to take any of it on my word. Press the buttons.
measured a number from a run you can repeat
not claimed an explicit boundary
00 · What the flat drawing hides
Stand in a field and the ground looks flat. Go up in a plane and you see it roll. Go out to space and the same ground closes into a ball. Nothing about the Earth changed; you added a direction to look from. Over 100 metres the curve of the Earth drops about 0.2 mm, which nobody standing there can see. Over 1,000 km it drops almost 20 km.
Mathematics on paper works the same way. The results are correct. But a page is flat, so every shape drawn on it is a shadow, and a shadow has lost a direction. The claim of this page is not that the mathematics is wrong. It is that the flat form is correct, expensive and mute: it gives the right numbers and cannot tell you what shape they came from. The shape carries slope, angle, direction, sign and curvature all at once, and that is where the power is.
Sine and cosine are not waves
The wave in the textbook is a shadow. The object is a helix: a coil, like a stretched spring. Look at it from the side and you see the sine wave. From above, the cosine wave. Straight down the barrel, the unit circle. One object, three shadows.
Drag to turn it, or pick a view.
Every derivative is a quarter turn
cos turns into −sin, then −cos, then sin, then back to cos. Four quarter turns and you are home, the same way i4 = 1. On a flat graph that looks like a rule to memorise. On the helix it is just walking around the coil.
Stack the saddle and it twists
Build the saddle in layers, turning each layer a little as it rises, and its straight lines sweep out a helicoid: the spiral staircase surface. Turn each layer a full 90° instead and the sign flips layer to layer, which is exactly the alternation that makes the lattice tile without a seam.
What the shape carries
Slope: the straight line at x = a climbs at exactly a, so the slope is the address. Direction: uphill at (x, y) points along (y, x). Sign: + in two opposite quarters, − in the other two. Angle: around the centre it is (r²/2)·sin 2θ. Curvature: a saddle at every single point.
Each statement above was checked numerically on thousands of random points, with controls that are supposed to fail and do.
01 · A curved surface made of straight lines
Multiply two numbers and plot the answer as height. Do it everywhere and the result is not a number, it is a saddle. These are renders of that surface, made in Blender.
The shape lives in a cube
Nothing here needs an equation to see. Take a cube. Pick four of its eight corners so that no two of them share an edge, and join them in a loop along the faces. Now walk two opposite sides of that loop at the same pace and connect the matching points with straight lines. The surface those lines sweep out is this saddle. The other four corners give its mirror twin. The multiplication is just the name for that shape.
What the cube pictures say
The saddle's four corners are four alternate corners of the cube, and every pair of them is the same distance apart (2√2), so they make a perfect tetrahedron. The twin saddle takes the other four corners. Together the two are the stella octangula. Build the saddle in all three perpendicular orientations and you get the same two tetrahedra every time: the star is forced by the signs of multiplication, not by how the pieces are arranged. z = x·y² also has its corners on the cube, but all four lie on one flat plane, so it makes no tetrahedron. That result belongs to x·y alone.
The seed and the bloom
Multiplication gathers two things into one; division opens one back into its parts. As shapes they look nothing alike, and that difference is the point. Below, each surface is cut at a series of heights and the cuts are drawn from above.
Seed: z = x·y and z = x·y²
Every cut is a curve (a hyperbola) that bends around the centre and never reaches it. Different pairs land on the same height: 2 × 6 and 3 × 4 both gather to 12. That is what gathering means, and it is why the seed alone cannot tell you which pair made it. At zero the seed swallows everything: anything times 0 is 0.
Bloom: z = x / y and z = x / y²
Every cut is a straight line through the centre. So the bloom's value is a direction, a slope, readable from anywhere along it. Bloom undoes seed and seed undoes bloom, checked on 100,000 random pairs each way. And the famous hole is in the drawing, not the shape: turn the saddle a quarter turn and every point lands exactly on the bloom. Seed and bloom are one sheet, a quarter turn apart. The line where division "blows up" simply stands vertical, and a vertical line cannot be drawn as a height above a flat page. z = x / y² is the inverse square: double the distance and the result falls to a quarter, the same shape as the inverse-square law that light and gravity follow.
Turn it yourself
Drag to rotate. The important button is the second one: every one of those lines is perfectly straight, and they all lie exactly in the curved surface.
Doubly ruled
Through every point of this curved surface pass two perfectly straight lines that lie entirely within it. Hold x still and the height is linear in y; hold y still and it is linear in x. That is why hypar roofs, cooling towers and lattice shells get built from straight members: you obtain a curved, stiff structure without bending anything. This is textbook differential geometry, not a finding of mine.
Four corners define a patch
A patch of this surface is fixed entirely by the heights at its four corners, verified over 500 random patches. Neighbouring patches that share corners meet with no seam, verified along the shared edge. Because every interior corner is shared by four patches, a large lattice costs about one stored number per patch rather than four: 25.0% at a million patches.
02 · Ask the shape instead of working it out
The conventional way to answer a question about a field of numbers is to store every number and then go through them: scan, add, compare, search. Simplify far enough and you reach a short formula at the end. The shape hands you that formula at the start, because the shape already says where the extremes are, how the total factors, and what curve a boundary follows.
Hold
The field is a rule plus its corners, not millions of stored values. Section 03.
Ask
Questions are answered from the shape: corners, edges, directions, curves. This section.
Logic
The same shape on ones and zeros holds a complete set of logic gates, in the algebra. Section 04.
Propagate
Every value knows its neighbours, so a change updates only what depends on it. Measured: one change touched 0.18% of a 216,000-cell lattice, 111× less work than recomputing.
Repair
The neighbours notice damage and put it back, with no master copy. Section 05.
Turn
A quarter turn flips the sign: the switch that opens or closes a gate, and the rule that tiles the lattice. Section 00.
The benchmark: same question, two ways, in your browser
A field of z = x·y is built as a stored grid, which is the conventional starting point. Each question is then answered twice: by working through the grid, and by asking the shape. Every row checks that both give the same answer. The extremes and totals are also checked on 50 random regions, largest and smallest.
| Question | Conventional | Asking the shape | Faster by | Same answer |
|---|
What the numbers say
One run in Chrome at 4 million cells: the steepest slope about 96,000× faster, the largest value in a region about 6,800×, a total about 5,800×, a boundary about 690×, and an inverse lookup about 42×. Reading one stored value: no faster. At 1 million cells every gap was roughly four times smaller, because working through the field grows with the number of cells and asking the shape does not. The shape side takes around a ten-millionth of a second, close to what a browser timer can resolve, so treat the ratios as rough and your device will give its own.
That this is new, or that the conventional way is wrong
Every shortcut here is standard mathematics, and an engineer who already knew each fact would write the same shortcut. The conventional answers are correct; they are just paid for cell by cell. What the shape adds is that it tells you the shortcuts exist before you start. And it only works where the rule is known: a field with no rule behind it gives the shape nothing to say. A binary search would narrow the inverse row, but a binary search is only allowed because the column is known to be ordered, which is itself a fact about the shape.
03 · Holding data as that shape
If four numbers describe a whole patch, then a field of values can be held as shapes instead of as values. Keep the rule, derive the data when something asks for it. What you gain is exactly how much geometry the data actually has. On measured data, that is much less than the sales pitch would like.
This is not compression, and the difference is not a slogan
Compression starts with the artifact. You must already have the bytes before you can shrink them, and to answer any question about what is inside you have to put them back first. This starts at the other end. The rule comes first and the field never has to exist at all. A generator can exist for data that was never produced, which a compressor cannot do by definition, because it has nothing to work on until the data is there.
Think of what 2 + 2 is. The 4 is not filed anywhere waiting to be looked up. The
invocation produces it, and until something invokes it there is no 4 in the world. Holding a
field as a shape works the same way: what is kept is the expression and the small remainder it
cannot account for, and the values appear while they are being produced and not before. It is
closer to an illustration than to a copy, in that structure carries the content rather than a
transcript of it, except that an illustration is loose and this is deterministic. Once it is
deterministic it is not an illustration any more. It is a specification.
established Nothing sits in the shape of the answer. What sits is a rule and a remainder, and the answer exists only while it is being produced.
Two things that sentence does not say, because both of them would be wrong and the whole argument goes with them.
It does not say storage is unnecessary. The rule, its parameters and the remainder all have to live somewhere, and a rule is itself data. The claim is narrower and it is the one the table below measures: you store a generator instead of a materialisation, and what that saves is exactly the amount of geometry the data actually has. On a generated field it is two orders of magnitude. On a photograph it is a few percent. On random bytes it is nothing at all, and correctly so.
It does not say the information is absent. Every row below is lossless and hash verified, and anything that reconstructs losslessly still holds the information at rest, in another form. Whoever holds the rule and the remainder holds the data. What changes is the form it rests in and what it costs to get at it: there is no materialised copy sitting there to be read off, and every read is a computation that has to happen. That is a real difference, and it is a difference in form and cost, not a claim that the data is not there.
| Data | Best ordinary method | Held as a shape | Result |
|---|---|---|---|
| Synthetic saddle field | 12,218 (gzip) | 151 | 81× smaller |
| A year of hourly temperature, from a public API | 11,231 (gzip) | 9,332 | 1.20× smaller |
| A photograph, decoded to pixels | 356,179 (PNG) | 337,192 | 1.06× smaller |
| Real terrain elevation, 40×40 grid | 2,607 (gzip) | 2,478 | 1.05× smaller |
| A text document | 1,470 (gzip) | 1,743 | loses |
| Random bytes | 65,576 (gzip) | 65,631 | loses slightly |
Every row lossless and hash-verified. Run these yourself on the benchmark page, including on a file you drop in.
not claimed That this is a better compressor. It is not. When data is generated by a rule it wins by two orders of magnitude; when data is measured from the world it wins by a few percent or loses, because measurement carries real entropy and entropy is incompressible. Nothing gets around the Kolmogorov boundary, mine included.
So where is the actual saving?
In the files that never need to exist. Derived data (thumbnails at six sizes, map tiles per zoom level, rolled-up aggregates, rendered reports, cached variants, procedural assets) is generated by a rule by definition, which is the case that wins by orders of magnitude. Not because it compresses, but because it is never written down. Drag a map whose tiles do not exist, and watch the counter for what the stored pyramid would have weighed. measured 611× against materialising a field when 0.02% of it is read, 17× at 0.4%, and the two break even near 25%.
What that split costs
One plane per 16-pixel tile, three numbers per colour: 4,960 bytes of painting rules against 332,232 bytes for the exact remainder. Rebuild hashed against the original every run, byte for byte. On a photograph this is roughly level with PNG, which is the honest result for captured data.
04 · The same shape holds logic
On ordinary numbers x·y is a saddle. On ones and zeros the very same
expression is the AND gate. Add 1−x for NOT and you have a pair that can
express any logic circuit that exists.
This is algebraic normal form
Writing logic as sums of products has a name and a date: Zhegalkin polynomials, 1927. I am not claiming to have found it. What I am pointing at is that the expression holding the data and the expression doing the logic are the same expression, so a circuit can be stored the way data is stored: as a pattern of switched-on terms.
That this competes with a CPU
Circuit completeness is proven above and is a mathematical fact. A competitive computational substrate would need clocking, fan-out, timing and error behaviour, and a performance argument against silicon. None of that is built, so none of it is claimed. A function of n inputs also needs up to 2n terms, which is exponential unless the function has structure.
A quarter turn opens or closes the circuit
Turn the saddle 90° and every height changes sign. Lift that turned saddle by one and on ones and zeros it is NAND, the single gate from which every digital circuit can be built. The unturned saddle lifted by one is not a gate at all. The turn is the switch.
The shape a flat network cannot make
A single-layer network is a flat plane with a threshold, and in 1969 Minsky and Papert showed it cannot compute XOR. No setting of its weights works. Add the saddle term x·y and XOR is simply x + y − 2xy. Hidden layers exist to build curved shapes like this one out of flat pieces.
Two smaller facts, both verified numerically:
a quarter turn of the axes maps (x,y) to (−y,x) and
negates the product, a sign flip, which is NOT in the logic reading,
and four turns return you to the start, which is the same
statement as i4 = 1. In polar form the saddle is
(r²/2)·sin(2θ), so the surface and the trigonometry are one
object seen two ways.
05 · And repairs itself
I call this the Mrs. Kravitz lattice. Every cell knows its neighbours' addresses, not their business, and that is enough to notice when something next door stops adding up. It is the part that convinced me the shape is doing something a compressed blob cannot. Because four corners define a patch, every 2×2 block of the field obeys one identity. A damaged value stops agreeing with what its neighbours imply, so the damage is visible locally, with no master copy, no checksum file and nobody in charge. The neighbours notice, they vote, and the lattice puts itself back.
| Damage | 2D lattice | 3D lattice | Behaviour |
|---|---|---|---|
| 1 cell | 100% repaired | 100% repaired | 2 rounds in 2D, 1 in 3D |
| 1% scattered | 95 to 99% | 91 to 95% | 2 to 3 rounds |
| 5% scattered | 79 to 82% | 65 to 67% | converges, then stops |
| 20% scattered | 35 to 37% | 3% | too little intact evidence |
| a solid block | 0% | 0% | refuses to guess |
Damage lands in random places, so each run differs slightly. The ranges are the lowest and highest of repeated runs: a 200 × 200 lattice in 2D, 50 × 50 × 50 in 3D.
Two results here surprised me, and both are worth more than the headline. 3D is harder than 2D, not easier: a single bad cell sits in four of a cell's eight blocks and biases all four opinions identically, so four wrong votes can agree and outvote the truth. The repair threshold has to exceed the number of witnesses one bad cell can reach. And when a solid block is destroyed, every witness dies with it, so the lattice repairs nothing, and that is correct. It stops instead of inventing a plausible surface.
established Where this sits. This is the same shape of idea as erasure coding and RAID: recovery holds while enough independent witnesses survive, and fails when one accident takes a cell and its witnesses together. What is unusual is that no parity was added. The geometry was already carrying it, because the rule that generates the values also constrains them.
06 · The honest ledger
Everything above, sorted by how well it is supported. If you only read one section, read the bottom third.
| Claim | Standing |
|---|---|
| The surface is doubly ruled: curved, but built from straight lines | established |
| Four corner values define a patch; shared corners give a seamless lattice | established |
| x·y on bits is AND; with 1−x it expresses any circuit | established (Zhegalkin, 1927) |
| A quarter turn negates the product; four turns return to the start | established |
| Sine and cosine are side and top shadows of one helix; its end view is the unit circle | established |
| The saddle turned 90° and lifted by one is NAND; a flat single layer cannot make XOR, the saddle term can | established (Minsky and Papert, 1969) |
| The saddle's corners are a regular tetrahedron in a cube; with its twin, a six-pointed star down the diagonal | established |
| x·y² is straight one way and a parabola the other, up on one edge and down on the opposite | established |
| Division is the bloom: it undoes the seed, its level cuts are straight lines (directions), and it is the same sheet as the seed turned a quarter turn | established |
| Asking the shape answers extremes, totals, boundaries, slopes and inverses from hundreds to hundreds of thousands of times faster than scanning, with identical answers | measured (live on this page) |
| Generated fields held as a rule: 81 to 524× smaller, lossless | measured |
| Measured real-world data: 1.05 to 1.20×, sometimes a loss | measured |
| Deriving instead of materialising: 611× at 0.02% read, break-even at 25% | measured |
| Sparse corruption repairs from neighbour agreement alone | measured |
| Clustered corruption does not repair, and should not | measured |
| That this is a better general-purpose compressor | not claimed |
| That it is faster than reading a stored value (it is ~4.5× slower) | not claimed |
| That the lattice is a competitive computer | not claimed |
| That any of this is new mathematics, or that it disproves existing mathematics or science | not claimed |
| That asking the shape works on data with no rule behind it | not claimed |
| That any of this beats the Kolmogorov boundary | not claimed |
| That it borrows anything from physics | not claimed |
07 · Reproduce all of it
Nothing here needs my machine. The interactive pages run entirely in your browser, and the heavier suites are dependency-free Node scripts.
In this browser, right now
Offline, in Node
14 of 14 proofs, with the limits proven in the same run
node geometric-transport.js
the capsule table, SHA-256 verified per row
Ask me for the scripts and I will send them. They have no dependencies and print the same tables you see above, including the rows where the method loses.
If you find something wrong here, I want to know. Two bugs in my own tests turned up while this page was being built: a 3D repair rule that was quietly destroying the lattice, and a frequency search that aliased high notes into false low ones and reported real geometry as none. Both were found by checking results that looked wrong instead of publishing them. Tell me what else is broken.