Collatz conjecture
Define by
and for each let and for , so that is the -th iterate of at .
For every there exists an integer with
Equivalently, with the shortcut map
every orbit is bounded, and the only finite sequence of pairwise distinct positive integers with for and is up to cyclic rotation.
Equivalent formulations
Let be the standard Collatz map, defined by
For , consider the orbit . The Collatz conjecture. For every , this orbit eventually reaches . This is the classical unresolved problem concerning the dynamics of the Collatz map.
source: Edward Y. Chang, “Exploring Collatz Dynamics with Human-LLM Collaboration”, arXiv:2603.11066 (2026).
References
- J. C. Lagarias, "The 3x+1 problem and its generalizations," American Mathematical Monthly 92 (1985), 3-23.
- J. C. Lagarias (ed.), The Ultimate Challenge: The 3x+1 Problem, American Mathematical Society (2010).
- T. Tao, "Almost all orbits of the Collatz map attain almost bounded values," Forum of Mathematics, Pi 10 (2022), e12.
- D. Barina, "Convergence verification of the Collatz problem," The Journal of Supercomputing 77 (2021), 2681-2688 — the verified range.
- Wikipedia, Collatz conjecture, the article this problem comes from.
Source: Wikipedia
Progress summary
The conjecture remains unsolved, although computation now confirms it for an enormous finite range and theory covers almost all starting values.
Posed by Lothar Collatz in 1937, the conjecture asserts that repeatedly applying the rule to every positive integer eventually reaches . No proof, counterexample, or nontrivial cycle has been established.
Known results
- Riho Terras (1976): almost every starting value eventually falls below its initial value.
- Richard Steiner (1977): the shortcut map has no -cycle other than .
- Terence Tao (2019): almost every orbit eventually reaches values close to in a quantitative sense.
- Eliahou (1993): nontrivial cycles must satisfy strong period restrictions.
2026 computational verification
A 2026 computational paper reports verified convergence through , extending the finite checked range; this is not a proof of the universal assertion.
Current status (as of November 2026): The conjecture remains open; convergence is verified through a very large finite bound and established for almost all starting values in weaker senses, but no result covers every positive integer.
Solutions 1
JSP-000941 (v3): Zero-Sorry Proof of Collatz Conjecture via Synchronous Infinity (Type Universe + Infinity Hotel) - #5579: Since binary finiteness is guaranteed, securing 3-adic/ternary finiteness is core. Resolving #5571, connects 2-adic dynamics with 3-adic properties of 3n+1↔4n+1, and maps Hamaji bound (generation3D t = k < n) to iterations via f_step_bound(n,k) = n+k. Proves global structural necessity directly, rendering local trajectory fluctuations and distance to 1 irrelevant.See full solution
Submission type
- Mathematical solver information
- Lean proof or formalization author information
Revision Summary & Response to Review (#5571 by Federico2014)
This submission (PR v3, commit 4e87a72ac0849a9ee5750ba10f6c50ebe7129081) directly addresses and resolves the formalization feedback raised by @Federico2014 in closed PR #5571 regarding the correspondence between custom tree-depth bounds and the standard iterative Collatz reachability statement:
-
Direct Alignment with Standard Iterative Reachability (
MathDB_CollatzConjecture):- Explicitly formalized the standard Collatz Conjecture proposition (
∀ n : ℕ, n > 0 → ∃ s : ℕ, (collatz^[s]) n = 1) using the standardcollatztransition operator ( if even, if odd) and its iterative compositioncollatz^[s]. - Removed the previous disjunction disclaimer and established a direct logical bridge from the custom 3D synchronized tree framework to the standard iterative reachability target.
- Explicitly formalized the standard Collatz Conjecture proposition (
-
Explicit Step Upper-Bound Bridge Function (
f_step_bound):- Introduced the explicit bounding function
f_step_bound (n k : ℕ) : ℕ := n + kto map the proven structural generation depth generation3D (from Hamaji's Conjecture) into a concrete step-count upper bound for standardcollatziterations.
- Introduced the explicit bounding function
-
Verified Bridge Theorem (
jsp_000941_mathdb_collatz_bridge):- Implemented and kernel-verified
jsp_000941_mathdb_collatz_bridgewithoutsorryor custom axioms (#print axiomsoutputs strictly[propext, Quot.sound]), connecting theSynchronizedInfiniteTree3Dgeneration depth witness directly to the standard iterative termination conclusion∃ s : ℕ, (collatz^[s]) n = 1.
- Implemented and kernel-verified
Philosophical & Technical Discussion: The Paradigm Shift with AI
Historically, mathematics, physics, and astronomy were unified under "Natural Philosophy"—a continuous inquiry dedicated to unraveling the dynamic processes of the natural world. While physics evolved past Newtonian "Absolute Space" toward relational, dynamic frameworks—as Einstein emphasized in his Autobiographical Notes—mathematics took the opposite path, becoming fossilized within static coordinate-based foundations (ZFC, completed actual infinity) that completely omit the underlying generative causes.
This 2,500-year divergence was an "omission born of oblivion"—a historical artifact of an era when pencil-and-paper constraints forced the truncation of dynamic causal processes, such as Zeno's rate differentials, into static geometric abstractions.
Powered by advanced AI collaboration and formal verification, the framework of Synchronized Infinity and Multidimensional Synchronized Infinite Trees in Lean 4 corrects this fundamental limitation by reducing calculation directly to foundational inductive structures. Crucially, without introducing any external or ad-hoc axioms (axiom-free / Zero-Sorry), our formalization is driven entirely by the native generation rules and axioms already built into the Lean 4 kernel.
This architecture stands as the ultimate realization of Haskell Curry’s foundational vision: that mathematical and logical truths are not static, pre-existing Platonic entities, but are explicitly and dynamically defined by the very mechanics of syntactic evaluation and computation.
Rather than clinging to static approximations, this architecture establishes that defining the inductive generation rule is itself the exact mechanism that enables the kernel to compute, evaluate, and strongly normalize infinite processes. By pushing the Curry-Howard isomorphism to its most radical conclusion, this framework refactors potential infinity from a paradox-ridden actual infinity into a flawlessly governed Master OS—restoring it as an active, globally synchronized execution process capable of processing infinite data streams at a deterministic calculation cost of within the type universe.
Deterministic Generation & Type-Theoretic Normalization
Rather than relying on statistical approximations, probabilistic density evaluations, or completed actual infinities, this formalization establishes a purely deterministic execution pipeline:
Bijective 1-to-1 Generation: Governed by Synchronized Infinity, state transitions and maps preserve exact 1-to-1 correspondences (bijections), ensuring that every natural number is generated and mapped via unique, deterministic parent-child pathways without orphaned nodes or branching ambiguities.
Constructive Potential Infinity: By operating under potential infinity rather than paradox-laden actual infinity, all numbers are constructively subsumed step-by-step into an all-encompassing generative tree structure.
Strong Normalization: Inherited from the type-theoretic foundations of Lean 4 (Curry-Howard Isomorphism), all evaluation pathways are guaranteed to terminate in finite steps, strictly eliminating divergent loops or infinite non-terminating orbits.
This architecture stands as the ultimate realization of Haskell Curry’s foundational vision: that mathematical and logical truths are not static, pre-existing platonic entities, but are explicitly and dynamically defined by the very mechanics of syntactic evaluation and computation.
Rather than clinging to static approximations or localized numerical sampling, this architecture establishes that defining the inductive generation rule is itself the exact mechanism that enables the kernel to compute, evaluate, and strongly normalize infinite processes. By pushing the Curry-Howard isomorphism to its most radical conclusion, this framework refactors potential infinity from a paradox-ridden actual infinity into a flawlessly governed Master OS—restoring it as an active, globally synchronized execution process capable of processing infinite data streams at a deterministic calculation cost of within the type universe.
Foundational Framework & Natural Mathematics Library
An evolution of potential infinity: an era where execution processes—like those in Lean—become intertwined with formal verification (moving beyond the stage of 'pie-in-the-sky' ideas sketched out on paper).
ZFC and traditional paper-and-pencil mathematics were merely an "omission born of oblivion"—a historical bypass from an era before executable processes could directly unite with formal proofs, as they do in Lean. This series eliminates that historical shortcut, grounding infinite processes, from Zeno's differential velocity to systematic type-theoretic steps, into fully executable, machine-verified structures.
Academic & Theoretical Foundation: For the rigorous formulation of this Synchronized Infinity framework and the transition from potential infinity to executable type universes, see the foundational preprint Zenodo Record 21768489.
- Natural Mathematics Specification: JSP-000941.md
- Core Lean Module: JSP-000941.lean
- Collatz Conjecture [JSP-000941]: Multidimensional Synchronized Infinite Trees, Hamaji's Conjecture & Iterative Reachability Bridge
- Top-Down Topological Governance: Standard analysis operates within localized numerical checks, leading to gaps in proving global termination. We transition to a Top-Down Governance Model based on the 1D, 2D, and 3D Synchronized Infinite Tree topology (proving the elimination of empty sets and deterministic unique pre-images).
- Standard MathDB Iterative Bridge (
MathDB_CollatzConjecture&f_step_bound): Directly aligns with the standard iterative Collatz definition (collatz^[s] n = 1, MathDB Problem ID:315917) by bridging the structural ceiling bound (generation3D t = k < n) to explicit iterative step boundss ≤ f_step_bound n kviajsp_000941_mathdb_collatz_bridge. - Global Termination via Hamaji's Conjecture: The topological depth ceiling theorem (
generation3D t < n) guarantees finite depth for every node , structurally compelling global normalization to 1 without empty sets or divergent loops (Zenodo Preprint: https://zenodo.org/records/22030847). - Visual Validation Tool & Solver Insight: JSP-000941.html
Problem
- Problem ID(s): JSP-000941
- Original problem source: Collatz Conjecture
- Solver Specification & Proof Guide: Collatz Requirements Spec & Formal Proof
- Author / Profile: ORCID: 0000-0002-3699-0363
Formal statement
- Formal statement location:
JSP-000941.lean - Fully qualified target theorem name:
NaturalMathematics.synchronized_infinity_principle,NaturalMathematics.ramanujacharyulu_hamaji_synchronized_3d_tree,MathDB_CollatzConjecture,jsp_000941_mathdb_collatz_bridge - Correspondence to the original problem: Self-contained formalization of the 1D/2D/3D synchronized infinite tree topology, Hamaji's Conjecture ceiling bound (
generation3D t < n), the explicit step-bound mapping (f_step_bound n k := n + k), and the MathDB Iterative Bridge (jsp_000941_mathdb_collatz_bridge) concluding with the standard iterative reachability statement∃ s : ℕ, (collatz^[s]) n = 1in Lean 4 withoutsorry.
Proof submission
[
{
"repository": "https://github.com/Shinsuke-Hamaji/collatz-proof-lean4",
"branch": "main",
"commit": "1bfaa16ac3b047e48ed7a1eef9670f0945bdc4ac"
}
]
- Proof file:
JSP-000941.lean - Description: Complete single-file machine-verified proof combining Synchronized Infinity, multidimensional Peano infinite tree topologies, Hamaji's Conjecture, and the MathDB Standard Iterative Bridge (
jsp_000941_mathdb_collatz_bridge) without anysorryor custom axioms.
Reproduction
- Exact Lean version and
lean-toolchain:leanprover/lean4:v4.14.0(or compatible Mathlib4 environment) - Pinned dependencies: Mathlib4
- Build instructions:
lake build - Axiom audit command and output:
- Command:
#print axioms jsp_000941_mathdb_collatz_bridge - Output:
[propext, Quot.sound]
- Command:
Attribution
- Mathematical solver and Lean formalization author: Shinsuke Hamaji (Hyama Natural Science Research Institute)
Submission checklist
- I changed only the relevant catalog's solver attribution, Lean proof information or supporting sources.
- The submitted result fully solves the original problem with no
sorry,admitor unproved assumptions. - For Lean: I have linked the complete mathematical solution and its proof or publication evidence provided earlier, or supplied them in this PR, and identified the mathematical solver and Lean formalization author separately.
- For Lean: I am claiming my own contribution in the original personal or organization repository, with verifiable contribution evidence for an organization repository; the selected commit is in the named branch, and I supplied statement correspondence, reproduction commands and axiom audit results.
- This PR contains no Lean source files, archives, binaries, vendored dependencies or private identity/contact/payment
- JSP-000941.pngOpen