💻 computer science

Adaptive Search in Collatz Exponent-Code Space via 2-adic and 3-adic Constraints

This paper proposes a symbolic diagnostic framework for the Collatz conjecture using 2-adic and 3-adic constraints on exponent codes to analyze obstruction structures, demonstrating through adaptive search experiments that while finite-length trade-offs can be improved, all tested methods retain positive residue rates inconsistent with counterexamples.

Original authors: Oliver Kramer

Published 2026-07-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Oliver Kramer

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the famous Collatz Conjecture as a giant, cosmic game of "Follow the Leader" played with numbers. The rules are simple: if a number is even, divide it by two; if it's odd, multiply by three and add one. The big mystery is whether every single positive number you start with will eventually shrink down to the number 1.

Most people try to solve this by picking a starting number (like 5 or 100) and watching the game play out. But this paper, written by Oliver Kramer, decides to play a different game. Instead of watching numbers, it watches the instructions the numbers follow.

The Secret Code of Divisions

Think of the game not as a sequence of numbers, but as a sequence of "how many times did we divide by two?"
When an odd number hits the "multiply by three and add one" step, it becomes even. Then, it gets divided by two repeatedly until it becomes odd again. The paper calls this sequence of division counts an "exponent code."

For example, if you start with 5:

$3 \times 5 + 1 = 16$ .
$16$ is $2^4$ , so you divide by two four times to get back to an odd number (1).
The first "instruction" in the code is 4.

The paper treats these codes like DNA. Instead of testing a million different starting numbers, the researchers are trying to build the perfect "DNA strand" (a code) that looks like it could go on forever without ever reaching 1. If they could find such a code, it would be a "counterexample" that breaks the Collatz rule.

The Three-Part Detective Kit

To see if a code is "real" (generated by a real number) or just a fake, the authors invented a 2–3–∞ diagnostic. Think of this as a three-sensor scanner that checks if a code makes sense in three different worlds:

The Real World (Drift): Does the code keep the numbers from growing too fast or shrinking too fast? The "perfect" code should have a "critical drift" where the growth and shrinking balance out perfectly.
The 2-adic World (The Start): Every code forces a specific starting number. If the code is real, this forced starting number should be small and stable. The scanner measures how "stressed" this starting number is.
The 3-adic World (The End): Every code also forces a specific ending number. If the code is real, this ending number shouldn't be exploding to infinity. The scanner checks if the ending fits within the expected growth limits.

The authors proved a very important fact: If a code is generated by a real, fixed number, these "stress scores" (called residue rates) must eventually drop to zero. It's like a fingerprint that fades away as the number gets older. If the stress scores stay high, the code is a fake.

The Great Search

The researchers tried to find a "perfect" code that looks like a counterexample using three different strategies:

Random Guessing: They threw darts at a board, creating random codes that balanced the growth rate.
Mechanical Building: They used a strict, mathematical recipe to build codes that were perfectly balanced.
Adaptive Evolution: They used a computer "survival of the fittest" system. They started with a bunch of codes, let the best ones "mate" (combine parts), "mutate" (change slightly), and "repair" themselves to get closer to the perfect balance.

They tested these codes at lengths of 100, 200, and 400 steps.

The Results: The Wall That Won't Break

Here is the big news: They didn't find a counterexample. In fact, they found that it's incredibly hard to even fake one.

Even with the fancy "Adaptive Search" (the evolutionary computer), the codes they found still had high "stress scores."

At a length of 100, the best adaptive code achieved a total score of 1.49.
At 200, the best score found was 1.68.
At 400, the best score found was 1.73.

The "stress scores" (specifically the 2-adic start rate and 3-adic endpoint rate) stayed stubbornly positive, hovering between 0.95 and 1.08 for the start, and 0.54 and 0.68 for the end.

Remember the rule? For a real number, these scores must drop to zero. The fact that they stayed high means that even the smartest computer search couldn't build a code that behaves like a real number forever. The "fake" codes always looked suspiciously like fakes.

The Takeaway

This paper doesn't prove the Collatz Conjecture is true. Instead, it builds a powerful new tool to look at the problem. It shows that the "obstacles" preventing a counterexample are deep and structural.

The adaptive search was better than random guessing, but it couldn't escape the trap. The "stress" in the codes never went away. It's as if the universe has a hidden lock on these numbers, and no matter how cleverly you try to pick the lock with these symbolic codes, the tumblers just won't click into the "zero" position.

The authors conclude that while we can make codes that look almost right, combining a perfect real-world balance with perfect 2-adic and 3-adic stability is a puzzle that remains unsolved. The search continues, but the path is much harder than we hoped.

Technical Summary: Adaptive Search in Collatz Exponent-Code Space via 2-adic and 3-adic Constraints

Problem Statement
The paper addresses the Collatz conjecture, which posits that the trajectory of any positive integer $n$ under the map $T(n) = n/2$ (if even) or $T(n) = 3n+1$ (if odd) eventually reaches 1. Rather than testing large ranges of starting integers, the authors investigate a symbolic search space defined by finite exponent codes of the accelerated Collatz map.

The accelerated map on odd integers is defined as $C(n) = (3n+1)/2^{v_2(3n+1)}$ , where $v_2(m)$ is the exponent of the highest power of 2 dividing $m$ . A trajectory $x_{k+1} = C(x_k)$ generates a sequence of exponents $a_{k+1} = v_2(3x_k + 1)$ . The sequence $(a_1, \dots, a_k)$ constitutes an exponent code. The central problem is to determine if a "counterexample-like" code exists—one that mimics the behavior of a divergent or non-convergent orbit—by satisfying specific compatibility conditions across real, 2-adic, and 3-adic domains.

Methodology: The 2–3–∞ Diagnostic
The authors propose a symbolic diagnostic framework that evaluates finite exponent codes based on three metrics, collectively termed the 2–3–∞ diagnostic:

Real Drift ( $d_k$ ): Measures the deviation of the average exponent from the critical threshold $\alpha = \log_2 3$ . The code is critical if $A_k/k \approx \alpha$ (where $A_k = \sum a_i$ ), ensuring the multiplicative factor $3^k/2^{A_k}$ remains near unity.
$d_k = |A_k/k - \alpha|$
2-adic Start Representative ( $\rho_r$ ): Determines the forced starting residue $r_k$ modulo $2^{A_k}$ required to realize the code. For a genuine orbit generated by a fixed integer $n$ , $r_k$ must eventually equal $n$ . The diagnostic measures the growth rate of this residue:
$\rho_r(k) = \frac{\log(1 + r_k)}{k}$
3-adic Endpoint Representative ( $\rho_M$ ): Determines the forced endpoint residue $M_k$ modulo $3^k$ . For a genuine orbit, the endpoint must satisfy the real growth bound $x_k + 1 \leq (n+1)(3/2)^k$ . The diagnostic measures incompatibility with this bound:
$\rho_M(k) = \frac{\log(1 + M_k/(3/2)^k)}{k}$

Theoretical Contribution
The paper proves Theorem 1, establishing a necessary condition for any infinite exponent code generated by a fixed positive integer $n$ : the residue rates must asymptotically vanish.
$\lim_{k \to \infty} \rho_r(k) = 0 \quad \text{and} \quad \lim_{k \to \infty} \rho_M(k) = 0$
Consequently, Corollary 2 states that if an infinite code exhibits $\liminf \rho_r(k) > 0$ or $\liminf \rho_M(k) > 0$ , it cannot be generated by any fixed positive integer. This implies that a valid counterexample code must simultaneously achieve near-critical real drift while maintaining vanishing 2-adic and 3-adic residue rates.

Experimental Approach
The authors compare three strategies for generating finite codes of lengths $k \in \{100, 200, 400\}$ with a fixed evaluation budget ( $N_{eval} = 1000k$ ):

Random Critical Codes: Samples $a_i \in \{1, 2\}$ with probabilities tuned to yield an expected average of $\log_2 3$ .
Mechanical Critical Codes: Uses a deterministic construction based on the fractional part of $i(\log_2 3 - 1) + \theta$ to distribute exponents evenly.
Adaptive Evolutionary Search: An evolutionary strategy where codes are genomes. The fitness function minimizes a composite score $S = d_k + \rho_r(k) + \rho_M(k)$ . The search employs selection, crossover, mutation, drift repair (to maintain critical averages), and mechanical-block injection.

Results
Experiments indicate that while adaptive search improves finite-length trade-offs compared to baselines, it fails to approach the necessary asymptotic regime:

Residue Rates: Across all methods and lengths, $\rho_r$ remains in the range $[0.95, 1.08]$ and $\rho_M$ in $[0.54, 0.68]$ .
Trend: The rates do not trend toward zero as $k$ increases. At $k=400$ , the adaptive search yields a score of $1.73838$, only marginally better than random critical sampling ($1.73653$) and worse than mechanical codes in terms of drift, though mechanical codes exhibit higher residue rates.
Conclusion of Experiments: The "diagnostic obstruction" persists; no method successfully constructs codes that satisfy the simultaneous requirements of near-critical drift and vanishing 2-adic/3-adic residues.

Significance and Claims
The paper explicitly states that its contribution is not a verification method for the Collatz conjecture. Instead, it offers a symbolic diagnostic framework for probing obstruction structures within the exponent-code space.

The significance lies in demonstrating that constructing a counterexample-like code is not merely a matter of achieving critical real drift (which is easily done), but of simultaneously satisfying strict 2-adic and 3-adic compatibility conditions. The persistence of positive residue rates across random, mechanical, and adaptive search strategies suggests that the structural constraints of the Collatz map make the simultaneous realization of these conditions difficult, if not impossible, for fixed starting values. The authors conclude that future work should focus on examining larger code lengths and establishing provable lower bounds for these residue rates.