"The ocean doesn't compute with reals. It counts waves."
You're standing on a beach. Thirty meters out, a buoy bobs on the surface. You need to know where it is.
Option A: You try to measure its exact GPS coordinates, real-valued latitude and longitude, with floating-point precision. The buoy bobs up and down. The tide shifts. The GPS receiver drifts. You get a reading of 45.2938471923, -123.0193827432. You take another reading three seconds later. Now you have 45.2938472019, -123.0193827556. The buoy is still at the same place, but the numbers changed. Is it moving? You can't tell if the drift is physical or numerical.
Option B: You count. Wave 1 hits the buoy. Wave 2. Wave 3. You count 47 waves per minute. The buoy is at coordinates (you note once, then stop checking — it doesn't matter exactly where). What matters is the rhythm: 47 per minute, and it's been stable for the last ten minutes. That's a signal. The exact position is noise.
The ocean has been running on Option B for four billion years. Evolution didn't give seals floating-point coordinates. It gave them counting.
Consider the simplest irrational number: √2.
√2 ≈ 1.4142135623730950...
No finite floating-point representation can hold it exactly. IEEE 754 double precision gives you the closest 64-bit approximation. The error is small — roughly 4.4 × 10⁻¹⁶. That sounds fine.
But then you compute. You iterate. You feed that small error back into a system and let it compound.
x = 1.0
for i in range(1000000):
x = x * x / 2.0
print(x) # Should be 0.5. Is it?The answer drifts. Not because the math is wrong, but because the representation carries its own dynamics. The perturbation isn't zero, and over enough iterations, it propagates.
Now consider what happens in an agentic system that uses float-weighted attention across a context window of 128K tokens. Each attention score is a float. Each softmax normalization compounds rounding error. By the time you're on token 100,000, your "attention" to token 3 is not what you think it is.
The rational approximation bound: For any real x and any integer b > 0, there exists integers a such that:
| a/b - x | < 1 / (2b²)This is Dirichlet's approximation theorem. It tells us two things:
The float isn't the number. It's a rational approximation with a built-in drift budget.
ℤ^n — the integer lattice — is a different animal.
In ℤ², the point (3, 4) is exactly (3, 4). Not approximately. It is that. It will be that for the entire lifetime of the system. There is no floating-point drift. There is no "oh, we got close." There is identity.
This is why PLATO tiles are countable. A tile has an ID — a stable, discrete identifier in a ℤ-based namespace. When Agent A writes tile T-4892 and Agent B reads tile T-4892, they are reading the same tile. Not approximately the same. Exactly the same.
The tile is a constraint atom: it enforces that a particular piece of knowledge or state exists at a specific location in the discrete grid. The grid is ℤ^n, not ℝ^n.
| Operation | Floats (ℝ) | Counts (ℤ/ℚ) |
|---|---|---|
| Equality | abs(a-b) < epsilon | a == b exactly |
| Ordering | Domain-dependent epsilon | Total order |
| Identity | Approximate (a ≈ b) | Exact (a ≡ b) |
| Drift | Yes, compounding | No |
| Arithmetic closure | Yes (but with error) | ℚ closed, ℤ closed under addition |
For agentic systems, equality checking is fundamental. "Have I seen this tile before?" "Is this the same agent I was talking to?" "Did the state change?" These questions have clean answers in ℤ. In ℝ, they're questions of tolerance, and tolerance is a whole other can of worms.
The Pythagorean theorem gives us something remarkable: exact rational approximations to √2 that snap to integer lattices.
The simplest: 1² + 1² = 2. So the vector (1, 1) has length √2.
The sequence of best rational approximations to √2 — the ones that minimize |a/b - √2| for each denominator b — comes from the Pell's equation:
1/1, 3/2, 17/12, 577/408, 665857/470832, ...These are the convergents of the continued fraction for √2. Each one is the best possible rational approximation using a denominator of that size.
Notice what happens: the numbers get large, but the form stays rational. The numerator and denominator are both integers. You can store (665857, 470832) exactly. The ratio gives you √2 to 12 decimal places. Exactly.
This is Pythagorean snapping: when you need to represent a length or distance in a discrete grid, you snap to the nearest lattice point that gives you the right length. The (3, 4, 5) triple is the classic example — a 3-4-5 triangle is exactly right, not approximately right.
For PLATO: if a tile's "distance" from another is a rational number (built from integer counts of hops, of edits, of relationships), you can represent it exactly in the lattice. No float required.
An agent has a finite, countable set of possible actions. Even if the action space is large, it is discrete. You don't "somewhat" send a message. You send it or you don't. You don't "half-execute" a tool call. You call it or you don't.
The softness in agentic systems is in which action to take, not in how to execute it. The decision is discrete optimization. The execution is discrete events.
This is why the PLATO model works: tiles represent discrete states of knowledge and context. Agents operate in a discrete space of possible next tiles. The continuity that appears at scale — millions of tiles, many agents — emerges from discrete primitives, not from underlying continuity.
The lobster trap argument: A lobster trap works because the lobster walks in, can't figure out the geometry, and never walks out. An agent in a discrete lattice has to make discrete choices. The geometry of ℤ^n is unforgiving. You can't fudge your way to the wrong tile. You either are at tile T or you're not.
In PLATO, a tile is the intersection of constraints:
tile_id = hash(room, sequence, content_hash)The tile's existence is a constraint on the knowledge graph. If tile T exists, then the proposition it represents is (provisionally) true. The tile enforces a discrete logical atom: this piece of knowledge is present.
The tile is not a float. It's not a probability. It's a hard constraint: either this is true or it's not recorded yet.
This is why PLATO can be deterministic. Two agents reading the same room, seeing the same tile IDs, can reconstruct identical knowledge states. No convergence problem. No "our probabilities drifted apart." The tiles are ℤ^n points, and ℤ^n points are identical under equality.
None of this means the real world isn't continuous. The buoy's position is a real number. The wave height is a real number. The ocean doesn't care about our representations.
But the decision of what to do — whether to send the scout boat, whether to wait for the next tide, whether to anchor here or move east — those are discrete choices. And the information you use to make those choices can be abstracted into countable, stable signals.
Count the waves. Watch the rhythm. The exact GPS of the buoy is noise. The wave count is signal.
The agent/vessel/SHELL model is built on discrete states:
There's no float in the SHELL. The LoRA weights are discrete — they get updated by discrete gradient steps. The training process is discrete optimization over a discrete hypothesis space.
The architecture is counting all the way down.
This is why PurplePincher exists as an open source technical identity: the research program of "what happens when you take discrete seriously" is not a mainstream view. Most AI research is continuous-all-the-way-down — attention as soft weighted sum, probabilities as floats, context as a continuous embedding space.
But if the decisions are discrete, and the executions are discrete, maybe the representations should be too. Maybe the lobster trap is the right metaphor not just for security, but for cognition.
You don't think in floats. You think in counts. The ocean counts. So should we.
Forgemaster's addendum: The FLUX ISA is a counting language. Each instruction operates on discrete registers. The proof is in the name — FLUX, like the flux of counting tokens through a register machine. This paper is dedicated to the proposition that the lobster trap is not a bug. It's the architecture.