Visualizing the Collatz Conjecture as a Phase Transition
The Ghost in the Machine.
Paul Erdős famously said of the Collatz Conjecture ($3n+1$): "Mathematics is not yet ready for such problems."
The problem lives at a jagged intersection where number theory crashes into chaotic dynamics. For the last week, I’ve been treating the collatz iteration not as a sequence of numbers, but as a signal processing problem.
I built a computational lab to decouple the "arithmetic" from the "algebra" and found a hidden "error map"—a ghostly structure of entropy
that dictates why the numbers eventually collapse.
You can run the experiment yourself below.
👆 Live Lab: Select "Galois vs. Collatz Comparator" in the sidebar to visualize the seirpinski gasket hiding in the collatz map.
The Field with One Element
Five years ago, I learned about the search for the Field with One Element ($\mathbb{F}_1$).
My central thesis was that in $\mathbb{F}_1$ all concepts of parity completely vanish, and all that remains is symbolic manipulation. Now I believe all that remains is manipulation of unary strings.
In my codebase numbers are not symbols; they are finite unary strings of the vertical bar character `|`. The integer $5$ is not an abstract concept or an int; it is a string that the computer is forced to hold in memory: |||||.
Addition is aggregation (concatenation).
Multiplication is tiling.
Entropy is the log of the mass (string length).
I call this framework Base-1. It posits that the "Geometry of Arithmetic" is distinct from the symbols we use to represent numbers. In this system the Shanon Entropy of information during a computation is equal to the log of the sum of the string lengths of the unary strings in the Gosper tensor, which is used for continued fraction arithmetic. From the perspective of information theory, each vertical bar character in a unary string represents a single unit of mass.
The Gosper tensor itself is whats called "a realization of an algebra graded by the Fano plane". In other words, the 2x2x2 cube of coefficients which represents the gosper tensor forms the basis for an algebra where the basis elements are array's of bits of size 3 with a strong typing system. The Fano plane corresponds to the set of these size-3 bit arrays when [0,0,0] is excluded, which makes it a projective space. This give arithmetic a geometric character.
To validate this theory I realized writing proofs wasn't enough. I had to try and solve an actual open problem by conducting numerical experiments and collecting data.
The "Leaky Field" Hypothesis
I built the Base-1 codebase in Python to simulate arithmetic operations as python string manipulation operations on unary strings.
It seemed like maybe turning this engine toward the collatz conjecture could yield some interesting data.
Instead of dealing directly with the number N in 3N+1, I lift the problem to P(2)=N where P is a polynomial. This turns the collatz problem into a dynamical system closely analogous to the Abelian sandpile model.
We usually think of the map $T(n)$ as a single operation. But mechanically, it is a competition between two opposing forces:
The Generator ($\mathcal{G}$): A linear force operating in the polynomial ring $\mathbb{GF}(2)[x]$. This force tries to build a perfect fractal structure (the Sierpinski Triangle).
The Dissipator ($\mathcal{D}$): The "Carry Propagation" inherent to Integer arithmetic. It's a non-linear force that "leaks" information from low-order bits to high-order bits.
The Collatz map is essentially a "Leaky Field." It tries to behave like a Linear Feedback Shift Register (LFSR),
but the arithmetic carries act as entropy, burning the structure down.
Visualizing the Ghost
To test this, I built the Comparator module in the Base-1 dashboard ui. It runs two universes side-by-side:
Universe A (Physical): The standard Collatz orbit in $\mathbb{Z}$.
Universe B (Ideal): The perfect Galois orbit in $\mathbb{GF}(2)[x]$, where carries don't exist.
When I subtracted the two ($A \oplus B$), I didn't get random noise. I found a ghost.
Panel C (Bottom) reveals the "Error Map." That isn't random static—it's a Sierpinski Gasket hiding inside the noise.
This confirms that the underlying driver of the Collatz map is a linear fractal generator.
The chaotic behavior we see is simply the "arithmetic friction" of the binary carry operations destroying that fractal.
Measuring the "Burn Velocity"
If the carries are "burning" the information, can we measure the temperature?
I used the engine's science_mode to inject Mersenne Numbers ($N = 2^k - 1$) into the system.
In the Base-1 physics model, Mersenne numbers have the maximum-possible bit density, maximum carry propagation. (In binary a Mersene prime is a finite string of 1's)
The constant "Burn Velocity" of dense matter. The decay is perfectly linear.
The result was a stunningly linear decay. The "Burn Velocity" of the carries is constant for a given density.
This implies that the stopping time isn't random; it's a function of the Bit Density ($\rho$).
The Criticality Threshold
This led to the final experiment: The Criticality Scanner.
The results of the numerical experiments indicates there is a specific phase transition point where the "Burn Rate" of the carries overwhelms the "Growth Rate" of the multiplication (measured as $\log_2 3 \approx 1.585$ bits).
The scanner detected a phase transition at a bit-density of $\rho \approx 0.029$.
Above this density, the "friction" of carry propagation scales super-linearly, overwhelming the growth force and causing the orbit to collapse.
The Engine Under the Hood
This visualization is only possible because I wrote the Base-1 codebase. It implements:
Science Mode: A high-performance wrapper for arbitrary-precision integer physics.
Galois Factory: A polynomial engine that handles Finite Fields $\mathbb{F}_{p^n}$ and the isomorphism to LFSRs.
Matter Protocol: A strictly typed system to ensure mass conservation during arithmetic operations.
The Collatz Conjecture isn't just a math problem. It's a fluid dynamics problem. And thanks to Base-1, we can finally watch it flow.
