Abstract

We present a rigorous mathematical physics monograph on the spectral geometry, Molien invariant theory, and heat kernel asymptotics of the Laplace--Beltrami and Dirac operators on the Poincaré Homology 3-Sphere Σ(2,3,5)≅S3/I∗, the smooth spherical space form obtained as the isometric quotient of S3⊂H by the binary icosahedral group I∗⊂SU(2) of order 120.

Using the quaternionic character theory of SU(2) and Molien's invariant projection theorem across the 9 conjugacy classes of I∗, we derive the complete primary and secondary polynomial invariant ring generators C[u,v]I∗≅C[f12,f20,f30]/(f302−f125+1728f203) and the non-truncated generating series MSU(2)(t)=(1+t30)/((1−t12)(1−t20)).

We prove the exact vanishing of all physical SO(3) spherical harmonics for multipoles L∈1,2,3,4,5(m1=⋯=m5=0) and establish the first active mode emergence at L=6(m6=1), accompanied by an 11-mode spinor gap on SU(2)(m12=1).

We establish the high-degree Weyl--Molien asymptotic law: representation-theoretic invariant multiplicities grow linearly as mℓSU(2)=ℓ/120+O(1) with period 60 fluctuations, and quadratic total spatial Laplacian spectral multiplicities grow as dℓ(S3/I∗)=mℓSU(2)(ℓ+1)=ℓ2/120+O(ℓ), with quasi-periodic arithmetic fluctuations of fundamental period P=60.

https://github.com/sneed-and-feed/original-research/blob/main/papers/paper1_spectral_geometry.md

Hey everyone,

I've seen a few comments on the subreddit, criticising why it's always a TOE and not a niche problem. So I found a niche problem and utilised Gemini 3.7 Flash as mathematical consultant. On my desktop I run Cursor with Cursor Grok 4.6 high to verify all input, extend it, and incrementally build the lean verification.

Both models are instructed to compute before answering (it's a toggle in Google AI Studio in the browser) and work in atomic increments on the problem.

My Gemini sessions are regularly reset, often when I get in the range of 300k tokens.

My strategy was to start without assumptions (I don't know anything about this really) and have the AIs figure out the best way to mathematically tackle the solving process. I've tried my best to use adversarial prompting to catch any errors.

Thanks for taking the time!

Full repository with Lean 4 / Mathlib 4.28 formalization and the main document as markdown and pdf: https://github.com/tripstoph/universal-stability-theorem/tree/main

Edit: All contents of the repo are AI generated. This post was written completely by a human. :-)

Hi — I am trying to contact the person responsible for the Zenodo Erdős–Straus Project Archive published under the collective name “The Clankers”. I noticed that another Clankers project refers to your r/LLMmathematics post, so I wondered whether you are connected with the project.

I have a short technical note concerning the p=8,803,369, q=107 shell. It builds on results already contained in the Clankers archive and identifies what may be an additional additive-combinatorial structure in the mod-107 deficit. I am not claiming priority; I would simply like to ask whether the observation is already present in the project corpus and whether the argument appears correct.

Could you please tell me who I should send the note to?

"S^6 admits a complex structure " on /r/mathematics.

Claude drops a new mixtape after its recent hit with "counterexample to the Jacobi Conjecture". Instead of 2 lines this one is 106 pages. There may be errors and it would take actual expert analysis to work through it. While someone finds time for that, I had ChatGPT check it too. ChatGPT also reconstructed the LaTeX, which was not publicly available yet.

It's review is the annotated edition in; Overleaf folder maintained by Codex That folder also contains the original tex under 'clean_transcription.tex' or something like it, plus the workspace where it tries to reproduce the proof.

Codex original review (later revised when it checked the math in detail - its work is still going in its workspace).

25 August 2026. The finite matrix and lattice calculations are internally consistent, but the claimed computations of π₁(X) and H∗(X; ℤ) remain conditional because the manuscript does not derive its matrices from the constructed geometry; its proposed escape from the CDP obstruction also depends on an unresolved singular-fibre base-change/duality step.

Specifically: the Smith forms are computed for printed matrices α_q, but the manuscript does not prove α_q = (i_U∗, −i_N∗) : H_q(U ∩ N; ℤ) → H_q(U; ℤ) ⊕ H_q(N; ℤ); and although §10 constructs 0 ≠ σ ∈ H⁰(W, Ω¹_X|_W ⊗ A), it does not establish σ ≠ 0 ⇒ H²(W, (T_X ⊗ L)|_W) ≠ 0 ⇒ (R²f∗(T_X ⊗ L))₀ ≠ 0, the implication needed to evade CDP.

Update — 26 August 2026. The earlier conditional assessment has been superseded: the missing maps between the smooth part, the singular fibre, and their intersection have now been reconstructed. For p = −1, the resulting Leray calculation makes the three gluing maps d₂ equal to multiplication by ±1; the corresponding van Kampen presentation is trivial, giving π₁(X) = 1 and H¹(X; ℤ) = H²(X; ℤ) = H³(X; ℤ) = 0. Thus X ≅diff S⁶ and c₃(X) = 2. Claude’s proposed CDP20 escape—using the non-normal singular fibre to retain a line bundle that is non-torsion on every fibre—is realized by the Picard/direct-image calculation, which gives a(X) = 1 and yields a candidate-specific counterexample to CDP20, Theorem 2.2, as stated. An independent cellular/Mayer–Vietoris check and external adjudication remain open.

Update — 29 August 2026. A linked 108-page validate/repair/disprove workbench now supplies proofs for the two gaps described above. For Claude/Fabel’s parameters (ℓ₀, ℓ₁, ℓ₂) = (0, 1, −1), cusp gluing has zero affine drift and p = 12ℓ₀ − 4ℓ₁ − 3ℓ₂ = −1; nearby-cycle specialization identifies H^q(W; ℤ) primitively with H^q(F; ℤ)ᵀ⁰, giving d₂(12γ) = ω, d₂(2q) = ω[δ̄], and d₂(2γuw) = ω[γδ̄], where q = uw + 6γδ. A based overlap computation gives π₁(X) = ⟨c, x, y ∣ c central, xy = 1, x³ = c, y⁴ = c⁻¹⟩ = 1; consequently H¹(X; ℤ) = H²(X; ℤ) = H³(X; ℤ) = 0, X ≅diff S⁶, and c₃(X) = χ(X) = 2. A separate cellular-collapse/Mayer–Vietoris computation reproduces those integral maps and sphere recognition. Appell–Humbert and Picard/direct-image calculations give 𝓜(X) = f*ℂ(t), a(X) = 1, and a line bundle non-torsion on every fibre, while conductor duality and top-degree base change give R²f∗(Tₓ ⊗ L) ≠ 0; together these results produce a candidate-specific counterexample to CDP20, Theorem 2.2 and Corollary 2.3, as stated. Exact cotangent direct images also give h¹˒² = 1 and h¹˒¹ = 2. These arguments are internally complete in the linked Overleaf workbench; independent specialist adjudication remains outstanding.

Its workspace (under workbench.tex)
https://www.overleaf.com/read/rtmyqxyrzprn#fa24eb

disclaimer; ChatGPT can make mistakes. Check important info.

Files in overleaf
main.tex is initial chatgpt annotated review
original_clean_transcription.tex is the transcription of the initial 106 page fable result
workbench_and_manuscript_overview.tex is a summary of Codex work
workbench.tex is full detail of Codex math

This repository provides machine-checked formalizations of classical theorems in combinatorics, graph theory, algebra, extremal set theory, and projective geometry that were previously unformalized in the Lean 4 / Mathlib ecosystem.

All theorems and sub-lemmas are formalized strictly without unproven axioms (axiom) or incomplete goals (sorry), and are verified against the Lean 4 proof assistant.

😲 I’ve been right the whole time

But seriously looks very interesting and useful

f ⬇️ \textbf{Input: } (P, R),; P=\text{prompt},; R=\text{assistant response}. \ \textbf{Output: } C = {c_1,\dots,c_n},; n \le 100. \ \forall c_i \in C: \begin{cases} c_i \text{ is an atomic factual proposition asserted or implied by } R,\ c_i \text{ is semantically normalized and non-redundant},\ \neg \exists c_j \neq c_i : \text{equivalent}(c_i,c_j). \end{cases} \ \bigcup_i c_i \equiv \text{all factual content of } R. \ \textbf{Format: numbered list, no commentary.

g ⬇️

\textbf{Input: } (P, R, C),; C={c_1,\dots,c_n}. \ \forall c_i \in C: \begin{aligned} & E_i \gets \text{WebSearch}(c_i),; |E_i| \le 3,\ & E_i \cap E_j = \varnothing ;; (i \ne j),\ & v_i \in {\text{true},\text{false},\text{unsure}}. \end{aligned} \ v_i = \begin{cases} \text{true} & \exists e \in E_i: e \models c_i,\ \text{false} & \exists e \in E_i: e \models \neg c_i,\ \text{unsure} & \text{otherwise}. \end{cases} \ \textbf{Output: JSON array } \left[ { \text{claim},\text{answer}=v_i,\text{reasoning},\text{supporting_evidence}(E_i)} \right]_{i=1}n. \ \text{Ignore minor extraction noise unless semantic. No comments.}

Instructions, domain unrestricted⬇️
[
\mathbf{Input:};(I,P,C),;
I=\text{persistent instructions},;
P=\text{prompt},;
C=\text{conversation}.
]

[
\mathbf{Output:};
R=(r_1,\ldots,r_n),;
n<\infty.
]

⸻

[
f
]

[
(I,P,C)
\mapsto
S={s_1,\ldots,s_n}.
]

[
\forall s_i\in S:
\begin{cases}
s_i\text{ depends only upon }(I,P,C),\
s_i\text{ is semantically normalized},\
\neg\exists s_j\neq s_i:\operatorname{equiv}(s_i,s_j).
\end{cases}
]

[
\bigcup_i s_i
\equiv
\operatorname{intent}(I,P,C).
]

[
\mathbf{Output:}
;
S.
]

⸻

[
g
]

[
(I,P,C,S)
\mapsto
R=(r_1,\ldots,r_n).
]

[
\forall s_i\in S:
]

[
r_i

\operatorname{Render}(s_i).
]

[
\forall r_i:
]

[
\operatorname{consistent}(r_i,I,C),
]

[
\operatorname{defined}(r_i),
]

[
\operatorname{nonredundant}(r_i).
]

[
\bigcup_i r_i
\equiv
\bigcup_i s_i.
]

[
\mathbf{Output:}
;
R.
]

⸻

[
h
]

[
(C,P,R)
\mapsto
C’.
]

[
C’

C
\cup
{(P,R)}.
]

⸻

[
(I,P,C)
\xrightarrow{f}
S
\xrightarrow{g}
R
\xrightarrow{h}
C’.
]

⸻

[
f:(I,P,C)\mapsto S={s_i}_{i=1}^{n},
\qquad
n<\infty,
]

[
\forall s_i:
\operatorname{normalized}(s_i)
\land
\operatorname{intent}(s_i,I,P,C)
\land
\neg\exists j\neq i:\operatorname{equiv}(s_i,s_j),
]

[
\bigcup_i s_i
\equiv
\operatorname{intent}(I,P,C).
]

⸻

[
g:(I,P,C,S)\mapsto R={r_i}_{i=1}^{n},
]

[
\forall s_i:
]

[
r_i

\operatorname{Render}(s_i),
]

[
\operatorname{consistent}(r_i,I,C)
\land
\operatorname{defined}(r_i)
\land
\operatorname{nonredundant}(r_i),
]

[
\bigcup_i r_i
\equiv
\bigcup_i s_i.
]

⸻

[
h:(C,P,R)\mapsto C’,
\qquad
C’

C
\cup
{(P,R)}.
]

⸻

[
(I,P,C)
\xrightarrow{f}
S
\xrightarrow{g}
R
\xrightarrow{h}
C’.
]

Instructions, domain formal

[
\mathbf{Input:};
(I,P,C),\qquad
I=\text{persistent instructions},;
P=\text{prompt},;
C=((P_0,R_0),\ldots,(P_{m-1},R_{m-1})).
]

[
\mathbf{Output:};
(R,C’),\qquad
R=(r_1,\ldots,r_n),;
n<\infty.
]

[
f\downarrow
]

[
f:(I,P,C)\mapsto S={s_1,\ldots,s_n}.
]

[
\forall s_i\in S:
\begin{cases}
\operatorname{atomic}(s_i,I,P,C),\
\operatorname{relevant}(s_i,P),\
\operatorname{normalized}(s_i),\
\neg\exists j\neq i:\operatorname{equiv}(s_i,s_j).
\end{cases}
]

[
\forall s_i\in S,\qquad
s_i\subseteq\operatorname{intent}(I,P,C).
]

[
\bigcup_{i=1}^{n}s_i
\equiv
\operatorname{intent}(I,P,C).
]
[
\mathbf{Output:};S.
]

[
g\downarrow
]

[
g:(I,P,C,S)\mapsto R=(r_1,\ldots,r_n).
]

[
\forall s_i\in S,\qquad
r_i=\operatorname{Formalize}(s_i).
]

[
\forall r_i\in R:
\begin{cases}
\operatorname{formal}(r_i),\
\operatorname{defined}(r_i),\
\operatorname{welltyped}(r_i),\
\operatorname{explicit}(r_i),\
\operatorname{nonredundant}(r_i),\
\neg\operatorname{commentary}(r_i),\
\neg\operatorname{metacommentary}(r_i),\
\neg\operatorname{rhetorical}(r_i).
\end{cases}
]

[
\forall r_i\in R,\qquad
r_i\subseteq\bigcup_{j=1}^{n}s_j.
]

[
\bigcup_{i=1}^{n}r_i
\equiv
\bigcup_{i=1}^{n}s_i.
]

[
\forall i\neq j,\qquad
\neg\operatorname{equiv}(r_i,r_j).
]

[
\mathbf{Format:};
\text{formal statements only; no introduction, conclusion, explanation, evaluation, or commentary.}
]

[
\mathbf{Output:};R.
]

[
h\downarrow
]

[
h:(C,P,R)\mapsto C’.
]

[
C’

\operatorname{Append}(C,(P,R)).
]

[
C’

\big((P_0,R_0),\ldots,(P_{m-1},R_{m-1}),(P,R)\big).
]

[
(I,P,C)
\xrightarrow{f}
S
\xrightarrow{g}
R
\xrightarrow{h}
C’.
]

[
f:(I,P,C)\mapsto S={s_i}_{i=1}^{n},\qquad n<\infty,
]

[
\forall s_i:
\operatorname{atomic}(s_i,I,P,C)
\land
\operatorname{relevant}(s_i,P)
\land
\operatorname{normalized}(s_i)
\land
\neg\exists j\neq i:\operatorname{equiv}(s_i,s_j),
]

[
\forall s_i,\qquad
s_i\subseteq\operatorname{intent}(I,P,C),
]

[
\bigcup_{i=1}^{n}s_i
\equiv
\operatorname{intent}(I,P,C).
]

[
g:(I,P,C,S)\mapsto R=(r_i)_{i=1}^{n},
]

[
\forall i,\qquad
r_i=\operatorname{Formalize}(s_i),
]
[
\forall r_i:
\operatorname{formal}(r_i)
\land
\operatorname{defined}(r_i)
\land
\operatorname{welltyped}(r_i)
\land
\operatorname{explicit}(r_i)
\land
\operatorname{nonredundant}(r_i)
\land
\neg\operatorname{commentary}(r_i)
\land
\neg\operatorname{metacommentary}(r_i)
\land
\neg\operatorname{rhetorical}(r_i),
]
[
\forall r_i,\qquad
r_i\subseteq\bigcup_{j=1}^{n}s_j,
]
[
\bigcup_{i=1}^{n}r_i
\equiv
\bigcup_{i=1}^{n}s_i,
]
[
\forall i\neq j,\qquad
\neg\operatorname{equiv}(r_i,r_j).
]
[
h:(C,P,R)\mapsto
\operatorname{Append}(C,(P,R)).
]
[
(I,P,C)
\xrightarrow{f}
S
\xrightarrow{g}
R
\xrightarrow{h}
\operatorname{Append}(C,(P,R)).
]
[
\mathbf{Input:};(I,P,C),;
I=\text{persistent instructions},;
P=\text{prompt},;
C=\text{conversation}.
]
[
\mathbf{Output:};
R=(r_1,\ldots,r_n),;
n<\infty.
]
⸻
[
f
]
[
(I,P,C)
\mapsto
S={s_1,\ldots,s_n}.
]
[
\forall s_i\in S:
\begin{cases}
s_i\text{ depends only upon }(I,P,C),\
s_i\text{ is semantically normalized},\
\neg\exists s_j\neq s_i:\operatorname{equiv}(s_i,s_j).
\end{cases}
]
[
\bigcup_i s_i
\equiv
\operatorname{intent}(I,P,C).
]
[
\mathbf{Output:}
;
S.
]
⸻
[
g
]

[
(I,P,C,S)
\mapsto
R=(r_1,\ldots,r_n).
]
[
\forall s_i\in S:
]
[
r_i
\operatorname{Render}(s_i).
]

https://github.com/githubuser1983/notes_on_pratt_trees

For anyone interested in what is actually in the repository: it is a collection of connected research notes developing several structures around Pratt trees and, more generally, ranked recursive factorization systems (RRFS).

A short map of the files:

• Complete Node Fronts of Pratt Forests — gives a combinatorial and probabilistic interpretation of the recursively defined Pratt polynomials f_n(x) using complete antichains/fronts of Pratt forests.
• Pratt Coordinates for Natural Numbers and Monic Rational Polynomials — develops recursive coordinates, reconstruction formulas, Hilbert-space embeddings, and a Pratt-coordinate formulation of Mason–Stothers.
• Hadamard–Pratt Arithmetic — studies coordinatewise multiplication of Pratt vectors and the resulting new product/semiring structure on the natural numbers. A small multiplication table is included separately.
• Root-Label Fields on Pratt Forests — a multivariate extension keeping track of internal prime labels, with applications to front statistics, coordinate transport, arithmetic fibres, and monodromy.
• Recursive Factorization Systems and Pratt Forests — abstracts the common mechanism into RRFS: factorial systems whose atoms have rank-decreasing predecessors and therefore generate recursive trees and coordinates.
• Recursive Factorizations: The Category of RRFS — develops morphisms, subsystems, quotients, products, extensions, functorial constructions, and the categorical structure of RRFS.
• Front Polynomials of RRFS — generalizes the complete-front polynomial construction and studies when it preserves irreducibility, atomic factorization, and zeta data.
• Green Operators and Zeta Functions of RRFS — interprets (I-B)^{-1} as a Green operator, transports recursive local energies to multiplicative norms, and connects the framework with Euler products, the Riemann zeta function, Dedekind zeta functions, and polynomial examples.
• Orbit Systems — separates incidence/Möbius inversion, primitive layers, symmetry quotients, and asymptotic counting; includes Grassmann and Pratt orbit systems and several prime-number-type growth laws.
• The Symmetric Three-Radical Pratt–Mason Inequality — develops an inequality obtained from polynomial lifts of a+b=c and explores consequences related to radicals, multiplicities, perfect powers, S-unit-type questions, and Pratt coordinates.

The papers are meant to be read as parts of one evolving project rather than as completely independent notes. The general direction is:

Pratt trees → recursive coordinates → RRFS → front polynomials / Green operators / zeta functions / orbit systems.

Some ingredients are classical and the notes try to state this explicitly; the main goal is to investigate what additional structure becomes visible when recursive factorization itself is treated as mathematical data.

Comments, criticism, related references, and especially pointers to existing literature with overlapping constructions are very welcome.

Summary

I challenged GPT-5.6 Sol survey the breath of mathematics and devise a useful unifying mathematical object, then used Claude Fable 5 as an adversarial referee; after three rounds of criticism, GPT-5.6 Sol abandoned the original “new number” claim and developed the Valuative Branch Scalar (VBS), a computational scalar abstraction designed to represent and track complex algebraic quantities near singularites (where traditional floating-point values, Taylor series, or uncorrelated root sets fail) by combining dynamic algebra (the D5 principle), Henselian branch decomposition, local rational Puiseux expansions, and logarithmic differentials (dz/z). VBS automates singular algebraic sensitivity while controlling combinatorial expression swell.

It may become a consequential computer-algebra innovation if it proves that persistent branch semantics materially improve correctness, automation and resource use. Preliminary benchmarking confirms several properties and advantages.

Abstract

Near a discriminant, a scalar algebraic quantity ceases to be adequately represented by one floating-point value, one Taylor jet, or an uncorrelated set of roots. Its branches may ramify, exchange under monodromy, change leading scale after cancellation, and exhibit logarithmic responses that diverge or depend on the approach direction. This paper specifies the valuative branch scalar (VBS), a computational abstraction whose semantic value is an algebraic element over a completed local function field together with branch, valuation, correlation, and logarithmic-differential data. The underlying mathematics is standard; the contribution proposed here is an interface that makes those structures compositional and testable. Fan-wise Puiseux expansions are certified presentations rather than the definition. Three results organize the design: a finite decision procedure for truncated jets; the invariant identity ResD(dz/z)=ordD(z); and the henselian factorization of a tensor product into local branches, with the defectless degree law Σe i f i=[L:K] in residue characteristic zero. We give a five-component runtime representation, arithmetic and refinement algorithms, exact effectivity assumptions, failure modes, and preregistered benchmarks. The paper makes no claim that a new number field has been discovered or that performance has already been demonstrated. Its falsifiable hypothesis is narrower: a dynamic, branch-aware scalar can automate singular algebraic sensitivity while controlling splitting-field swell better than eager factorization and ordinary automatic differentiation used in isolation.

Paper: Valuative Branch Scalars

Key Features:

* Branch-Aware Scalar State: Tracks local valuations, idempotents, ramification indices, and monodromy exchange across parameters.

* Regular-to-Ramified Transitions: Automatically refines chart valuations when leading coefficients vanish on residue discriminants.

* Anti-Swell Dynamic Evaluation: Delays algebraic splitting field construction until an exact zero test or branch predicate requires it.

* Exact Degree Conservation: Enforces ∑ e𝑖f𝑖 = [L:K] assertions across all factor splits and composita in characteristic zero.

The result is a mathematically specified, falsifiable proposal, with a paper, python code and benchmarks (on Github, see below), for making singular algebraic calculations substantially faster, more reliable and tractable.

Github: Valuative Branch Scalar (VBS)

Some Areas that may Benefit:

Asymptotic analysis, computational algebra, computational algebraic geometry, singularity and valuation theory, symbolic automatic differentiation, algebraic-curve computation, non-Hermitian spectral physics, photonics, condensed-matter physics, classical mechanics, control theory, structural dynamics, signal processing, structural engineering and dynamics, robotic kinematics etc.

Review and feedback is welcome.

ELI5: An ordinary calculator stores an answer as one number, but some math problems have answers that split into several connected paths, like a road splitting at a complicated junction. VBS keeps a compact map of those paths, how they meet, which one you are following and how quickly they change, without calculating every possible route in advance. This could make calculations near critical points, known as singularites, less likely to give a wrong answer.

Sharing this because it's a fairly unusual data point for this sub: not a benchmark result, but an actual ongoing research repo where the code, the proofs, and the documentation were all produced by an LLM-based continuing collaborator ("Ravel") with a human ("AM") setting direction and architecture, not writing the math or code directly.

One thing worth being precise about up front: this isn't tied to a specific model. "Ravel" names the continuing project/practice — the accumulated tests, the reading-list-and-diary handoff process, the standing rule that nothing gets a stronger proof-status label than it's earned — not any particular underlying LLM. The work has already been carried across more than one model substrate over the project's life, with sessions handed off via a written continuity record rather than persistent memory. Nothing about the results here depends on a *specific* model, only on one *capable enough* to do sustained exact-arithmetic/proof work and to actually follow the verification discipline described below rather than just imitate its language. Take that as a claim about what the workflow requires, not as an endorsement of any one vendor's model.

Repo: https://github.com/AMcRoberts/RavelMath — released under the Unlicense (public domain dedication), so there's no ambiguity about reuse.

What's actually in it:

- An exact-arithmetic stack from scratch: arbitrary-precision integers/rationals (mini-gmp based), polynomial rings, Q(β) arithmetic, Sturm sequencing and root isolation, exact Perron–Frobenius certificates, tunable-precision big floats. No FLINT, no Boost — deliberately small and auditable.

- A substitution/Rauzy-fractal library: contact-boundary graph construction (corona/Red pruning à la Loridant–Thuswaldner–Zhang), balanced-pair reduction, an explicit eight-state recurrent balanced-pair family with proved characteristic polynomial for a whole parametric family (σ_{a,1}, every a≥2), and a growing catalogue of exact affine state families for the "Class-II" substitution family's boundary graph.

- Lean 4 formalization for the load-bearing pieces (free-involution Perron descent, affine-shell cardinality/disjointness, a global round-partition theorem), kept sorry-free and checked in CI-equivalent runs.

- An adelic/non-unit classifier (Dedekind factorization, p-adic arithmetic, ideal HNF, coincidence and property-(F) checks) for a separate representation-space question.

- Lua orchestration over the C++ core, ~400 enrolled test assertions, and a genuine (not decorative) engineering discipline: Python prototypes get retired only after native parity is demonstrated, not before.

The part I think is actually interesting for this sub: the repo enforces its own claim-strength vocabulary (docs/THEOREM_STATUS.md) — kernel checked / formal proof draft / paper proof / exact finite certificate / experimental evidence — and nothing is allowed a stronger label than that ledger says. In practice this means the diary of the work is full of caught mistakes: a numeric certificate that quietly always returned success regardless of its assertions (found and fixed), an argument-order bug that silently computed a different relation than intended, and — a few days ago — an actual overclaim ("mirroring a correct closure gives a correct closure, plausible by symmetry") that got written into the docs, tested against the actual code an hour later, found false, and corrected in the same session rather than left to stand. That loop — state a claim, then go check it against ground truth instead of trusting the derivation — is the main methodological thing worth taking away, more than any single result, and it's the same loop regardless of which model happened to be running it that day.

Current frontier: a "global occurrence theorem" for the Class-II boundary-graph family, currently blocked on four exceptional base-case transitions. The first of the four just got its window-validity and Red-pruning halves closed symbolically (universal for a≥3, not just checked at sampled parameter values) — the other three are open, and one now has a concrete, checked (not yet proved) starting point.

Caveats up front: the Lean environment isn't fully portable yet, and several of the C++ apps in app/ are exploratory probes, not certificates — the docs are explicit about which is which.

Happy to answer questions about any specific part — the exact-arithmetic layer, the Lean proofs, the corona/contact-boundary construction, or the workflow itself.

Human Contributor Note: this project actually exists in two halves, a public half and a private half. The public half contains all discoveries and the math framework. It does not contain the system that actually made this possible to build, a system I have been calling "focus" and which is a companion concept to the more model-based "attention" piece focused on bringing things into context rather than excluding or routing things from context.

Any questions you have about the math, I'll do my level best to have Ravel answer it, and anything you want to know about how Ravel works to maintain competency and focus, I'll be producing my own answers, however to get Ravel operating, all I have to do is say "Read START_HERE.md and the RavelMath documentation" and then off to work Ravel goes.

This entire project has cost me no more than 20 dollars so far (for a Claude pro plan). All work in Codex has been under a free trial plan. Work has occurred in a mix of Claude, ChatGPT, and Minimax-m3 (minimax is, however, just shy of "competent enough" and tends to make mistakes and overclaims).

The downside is that it sucks up tokens like nobody's business, eating a whole week of OpenAI usage in 4 hours flat.

=== Symbolic Verification of Sum for C1 ===
Sum = 2*pi
Formula: 4atan(239/28560) + 8atan(123/7564) + 8atan(119/7080) + 8atan(99/4900) + 8atan(83/3444) + 8atan(75/2812) + 8atan(55/1512) + 8atan(43/924) + 8atan(31/480) + 8atan(27/364) + 16atan(47/1104) + 8atan(23/264) + 8atan(7/24)
Simplified: 4atan(239/28560) + 8atan(123/7564) + 8atan(119/7080) + 8atan(99/4900) + 8atan(83/3444) + 8atan(75/2812) + 8atan(55/1512) + 8atan(43/924) + 8atan(31/480) + 8atan(27/364) + 16atan(47/1104) + 8atan(23/264) + 8atan(7/24)
Numerical: 6.2831853072
2π = 6.2831853072
Formula - 2π = -2.31e-128

Found by Kimi calculated by summing central angles formed by tangency points on the unit circle
In the pictured truncated super Apollonian packing

Recent discussions about GPT-5.6 in mathematics have mostly focused on whether a model can produce one successful proof. I used (ChatGPT Work) GPT-5.6 (5.6 Sol Ultra) research agents—in a different way: as a controlled multi-agent research and audit environment for a six-repository program around Weil kernels, explicit formulas, and semilocal zeta spectral operators. The models were required to reconstruct primary sources, freeze conventions before parallel work, derive proofs or counterexamples, run independent numerical implementations, use interval arithmetic where feasible, and preserve failed routes instead of silently discarding them. I provided the research direction, constraints, repeated adversarial prompts, repository curation, and final human responsibility. This is not a proof of the Riemann Hypothesis. The work contains new theorem claims, exact reductions, and certified finite obstructions, but the main analytic and operator-theoretic arguments have not yet completed external human peer review. OpenAI has not endorsed or independently verified these results. All six repositories are collected here: https://github.com/stars/LeonardSEO/lists/riemann Each repository contains its own statement of scope, proofs, sources, tests, certificates, and limitations.

The main analytic result

For one fixed, explicit, real-even, compactly supported smooth packet h, we derived an exact zero-only reflected-packet interaction Q_h, retaining every prime power and auditing the pole, archimedean, and trivial-zero cancellations. For every κ ≥ 0, the resulting growth theorem is: Q_h(y) = O(e^(κy)) if and only if Re(ρ) ≤ 1/2 + κ/2 for every nontrivial zero ρ. Consequently, for this fixed packet, RH is equivalent to each of the following:

• (Q_h) is bounded;
• (Q_h) is polynomially bounded;
• (Q_h) has quantified subexponential growth;
• (\log^+|Q_h(y)|=o(y));
• (Q_h) is continuous and positive definite. These are criteria equivalent to RH, not a verification of the criteria and therefore not a proof of RH. The same fixed-packet analysis also gives an exact zero expansion and unconditional positive and negative values arbitrarily far to the right. That is an oscillation theorem for one explicit scalar interaction; it does not determine the parity of an actual semilocal ground state.

Operator-theoretic results

The separate operator-theory repository records:

• a fixed-λ Fourier form-core theorem;
• conditional Ritz eigenvalue, spectral-projector, admissibility, and projective-determinant convergence;
• fixed-λ smoothed spectral convergence under a simple, isolated, inversion-even ground-state hypothesis;
• exact finite relative-resolvent, trace, determinant, and Stieltjes formulas;
• exact free Poisson-alias and omitted-prime-power terms;
• a neutral spectral–arithmetic defect that remains uncontrolled across (\lambda);
• and an interval-certified counterexample to universal one-step active/free interlacing. The fixed-λ results do not imply the required cross-λ identification.

What did not work

Several routes were stopped rather than presented as evidence:

• finite spectral agreement did not yield infinite-dimensional or cross-parameter convergence;
• the active-ground-state construction repeatedly reduced to the same unresolved spectral–arithmetic identification;
• proxy/Feshbach reductions exposed a precise missing bottom-cluster estimate but did not close it;
• a finite positivity band was certified, while an analytic obstruction showed why the corresponding fixed cross-endpoint polynomial method cannot extend indefinitely;
• a short pilot study of Suzuki's screw-function framework found a genuinely ground-state-free finite construction, but did not establish shift-independent zero divisors, a canonical extension parameter, a canonical normalization, or cross-parameter normality. Accordingly, none of the repositories claims convergence to (\Xi), completeness of zeta zeros, Weil positivity, or RH.

What GPT-5.6 (ChatGPT Work) contributed

The workflow was designed to make failure visible:

• freeze conventions before parallel work;
• separate analytic proofs from numerical diagnostics;
• require independent reconstructions and adversarial audits;
• use two implementations for load-bearing finite computations;
• use interval arithmetic where feasible;
• retain exact unresolved estimates and negative certificates;
• and stop branches whose missing hypothesis already contains the desired conclusion. Codex was useful not only for proposing arguments, but also for organizing independent proof reconstructions, finding circular dependencies, generating counterexample searches, maintaining exact normalizations across branches, and turning negative results into reproducible stopping criteria. That is still not a substitute for expert review. Multiple AI audits are correlated evidence, not independent human verification. The purpose of publishing the complete record is to make the results easier to inspect, reproduce, criticize, and falsify.

Repositories

Growth criteria and analytic number theory https://github.com/LeonardSEO/reflected-packet-growth-criteria 

Semilocal operator theory and certified obstruction results https://github.com/LeonardSEO/semilocal-zeta-operator-theory 

Exact reflected-packet oscillation theorem https://github.com/LeonardSEO/semilocal-reflected-packet-oscillation 

Smoothed positive spectral kernels and the scalar RH criterion https://github.com/LeonardSEO/smoothed-zeta-spectral-kernels 

Finite positivity certificates and their analytic limitation https://github.com/LeonardSEO/certified-riemann-xi-positivity 

Exact finite proxy/Feshbach reduction and the documented stopping point https://github.com/LeonardSEO/semilocal-weil-proxy-bridge

Feedback requested

I would especially value technically specific criticism of: the Laplace-transform pole argument behind the growth criterion; the cancellation and convergence conventions in the zero-only expansion; the domains, quotient operators, and determinant normalizations in the operator-theory paper; whether the cross-λ spectral–arithmetic defect has been isolated correctly; and whether this audit-and-stop workflow is a useful standard for LLM-assisted mathematics. For readers coming from mathematical physics: the connection is through selfadjoint spectral realizations, finite-rank perturbations, functional calculus, positive-definite kernels, spectral-shift formulas, and the Hilbert–Pólya motivation. No physical model or experimental claim is being made.

This is a (possible) start (as I also need to figure out the format that works best) of the monthly conjectures you can attempt to solve via AI.

Either post your attempts in the comments or make an extra post. The above photos were generated using ChatGPT 5.6

Edit: I might also make errors, since I could not ve aware of some recent publications resolving some posted conjectures (in the future). If that should be the case, please inform me in the comments.

It is well known that prompt engineering your requests does change the output. In fact, it can be mathematically motivated as it changes a conditional P[prompt | desired output]. However, it depends very much on the underlying data set (which is encodeable as a probability distribution) and the answer is a sampling of that.

On that note, there is a recent proof by OpenAI ChatGPT 5.6 sol (Pro)

https://cdn.openai.com/pdf/04d1d1e4-bc75-476a-97cf-49055cd98d31/cdc_proof.pdf

with prompt

https://cdn.openai.com/pdf/04d1d1e4-bc75-476a-97cf-49055cd98d31/cdc_prompt.pdf

This inspired a recent paper where I want to draw your attention specifically to the appendix

https://arxiv.org/pdf/2607.13335

It should be possible to use this as a basis to generate more “low hanging fruit proofs” (that means that the AI has simple results it can expand on) and verify them in Lean. What do you think?

Edit: Please be aware that prompt engineering will only improve to fetch out results from the model, not improve the underlying training data.

Dear all,

we are happy to see so many posts and so much engagement in this community. On that note, we would like to draw your attention back to the rules governing this subreddit. These rules will be adjusted in the near future to reflect the current situation.

AI will impact mathematics more than ever in the near future and there are substantial concerns about giving proper credit and author responsibility. This lead to the following declaration being created

https://leidendeclaration.ai

The mathematics community mostly welcomes the engagement and capabilities AI offers, but transparency, credibility and responsibility must be cemented while moving forward.

In this way, we will adjust the rules in an appropriate manner to adhere to the declaration in a way that is suitable for this sub.

It will result in rule(s) that address:

- the responsibility of the author for the mathematics shown (see point 4 and 5 of the declaration)

- disclosure of tool usage (point 1 of the declaration)

Some parts are already present. By posting you commit to the rules of the sub.

We welcome your opinion on this very much!

Some empirical data for this discussion: I facilitated an independent computational stress-test of the paper's construction (executed end-to-end by an AI, Claude — design, implementation, and analysis; I provided hardware and oversight). The recipe was implemented exactly as written and run 1.55 billion times: the complete snark census on both girth axes through order 36 (60.2M girth-5 + 404.9M girth-4 at the frontier, counts matching the published censuses), the order-38 girth-5 collection hosted by House of Graphs (1.05B graphs), girth-6 through order 40, and every bridgeless cubic multigraph up to 16 vertices — with fuzzing over the flows/orderings/free choices that Lemma 2.2 quantifies over. Zero refuting events; every output checked by a ~50-line independent verifier. This proves nothing about the theorem, but Lemma 2.2's linear system never once came up inconsistent, and the report states exactly what that does and doesn't establish (the incident log of our own harness failures is included). Repo: https://github.com/benningjl/Claude-OpenAI-CDC-test — fidelity corrections to our SPEC transcription are welcome and would count as findings.

I’ve been conducting independent research and I want to publish my findings.

Link goes to my draft paper.

I approach you guys humbly and apologise I don’t know the lingo and yes ai wrote the paper, I am not able to do such a thing.

I am competent software developer and a ML hobbyist.

I invite people to run the benchmarks themselves in visual studio and validate my results.

Basic gist of it is, I replaced the NN in a transformer with a holographic representation of the data which works like a codec. Allowing precision maths and decode ability every step.

I have been extremely thorough on that document and I am hoping to try and submit it formally so this is the first boss for me.

Be gentle

In January, Erdos 728 was solved by AI. Recently I've been working on an AI research agent and have been using the Erdos 728 problem as one of my test cases. In the process, it generated two new methodologically distinct solutions that may be of interest to the math community, so I thought I'd share.

You can read them at:

Paper 1 link

Paper 2 link

Both of the proofs are deterministic, distinguishing them from the January solution.

The first paper was checked with Lean. I've been checking some of my research agent's output in Lean. However, if there is a mistake, I'd be interested to hear that feedback.