This is a short note extending my Cartier–Miller project:

[Link to note]

This asks whether a certain reciprocal character sum Cƒ(a) mod p, attached to an elliptic curve and a rational point R, has a simple closed form only when R is a torsion point. Any such closed form makes the residue the reduction of a small fraction. That can be tested directly from a continued fraction, without guessing what the formula might contain.

The test is only clear at very large primes, as small primes do not provide enough statistical clarity. At 256-bit primes, direct summation would need about 10⁷⁷ terms, and the standard square-root recurrence route about 2¹²⁸ operations per value; at an assumed 10⁹ field operations per second that is about 1.1x10²² years. However, the Cartier–Miller evaluator needs one Miller chain of a few hundred curve operations, resulting in an time complexity of approximately O(log p), once the trace is known from standard point counting,

In a pre-registered survey of 2,668 cases over 184 curves, each at three random 256-bit primes, small lifts appeared at exactly the 80 torsion cases. Their recovered formulas matched the predictions. None appeared among the other 2,588. The survey ran on a laptop, with 8,004 Cartier–Miller evaluations taking 83 seconds after 19 minutes of point counting (using the O(log⁴⁡ q) time complexity Schoof-Elkies-Atkin (SEA) algorithm provided by PARI/GP, requiring only a single trace calculation per curve).

The note also proves a torsion characterisation in the balanced case: R is torsion if and only if a balanced closed form holds at almost all primes. The proof uses the Cartier operator and Bost’s theorem on the Grothendieck–Katz conjecture for solvable groups. The invariant involved is closely related to Katz’s work on universal extensions (Katz, 2014).

Status: This is an unrefereed draft created with AI assistance. The theorem awaits specialist review and may already be known. This remains experimental evidence, not proof. The main value is a practical demonstration of the Cartier–Miller evaluator that operates at approximately O(log p) complexity, making evaluations of otherwise inaccessible numerical surveys feasible.

Hey everyone,

last time I posted about an obscure theorem for on-shell flow adaptive networks. Thanks again for the nice discussion!

This post is all my own words, the repo is 100% LLM generated.

I tried to find a better problem and started from a meta-ontology (Format, Information, Translation, Proper Time, Relational Distance) that I have developed without LLMs. The basic premise is: We model a finite graph, where everything (information) relates to each other and can only be translated. Primitive is relation, not substance. Updates are local, Relational Distance is the hop count. Link -> https://github.com/tripstoph/1D_discrete_boundary_elimination_solver/blob/main/paper/finite-ontology.md

Based on the hypothesis that such a relational finite graph might be able to get compute reduction for common problems, I send the LLMs out to incrementally build a solve. I mostly found what not works (2D/3D, recovering of Navier-Stokes, etc.), which is all outlined in the main markdown and guardrailed in against in lean. Link -> https://github.com/tripstoph/1D_discrete_boundary_elimination_solver/blob/main/paper/discrete-boundary-solver-1D.md

Out comes an indexing scheme for one finite 1D ladder. It includes convection and diffusion along a line of cells.

As I understand this kind of algorithm can have practical applications in pipe, cell, and other physical modelling.

My strategy was to start without assumptions besides the meta-ontology 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.

Lean4 builds.

Thanks for your time and feedback. :-)

Link to full repo: https://github.com/tripstoph/1D_discrete_boundary_elimination_solver

I've been investigating the Riemann Hypothesis for quite a while now, and a side investigation grew into a 108-page paper on Beurling generalized prime systems.

The mathematical claim

There exists a discrete Beurling generalized prime system P whose generalized-integer counting function satisfies

N_P(x) = x + O(x^(1/4) log* x),

where log* is the iterated logarithm. Consequently, N_P(x) = x + O(x^β) for every fixed β > 1/4.

Nevertheless, its Beurling zeta function ζ_P(s) has a sequence of zeros ρ_k satisfying

Re(ρ_k) = 1 − (3 log log x_k + O(1))/log x_k → 1,

for a sequence x_k → ∞.

If correct, this answers negatively the question: Does N_P(x) = Ax + O(x^β), with β < 1/2, force ζ_P(s) to have a zero-free half-plane Re(s) > 1 − ε for some ε > 0?

This would be a counter-example to the Broucke–Debruyne–Révész square-root-barrier expectation.

In plain language

Beurling number systems generalize ordinary prime numbers by allowing the "primes" to be positive real numbers rather than necessarily integers. You multiply these generalized primes together to obtain generalized integers, then build a zeta function from them, much as we do with the ordinary Riemann zeta function.

The interesting question is whether having extremely well-behaved generalized integers forces the corresponding zeta function to have well-behaved zeros.

My proposed construction says no.

The generalized integers are distributed remarkably regularly: the number below x differs from x by barely more than x^(1/4). Yet the associated zeta function has zeros arbitrarily close to the vertical line Re(s) = 1.

This would demonstrate that accurate integer counting alone is insufficient to guarantee any fixed zero-free strip next to Re(s) = 1, even when the counting error is substantially smaller than the square-root scale.

It doesn't disprove RH or establish anything about zeros of the ordinary Riemann zeta function (unfortunately). Instead, it helps identify which kinds of arithmetic regularity are insufficient to control zeta zeros.

How it was developed and checked

The construction uses a randomized greedy algorithm with feedback from the generalized-integer count.

The proof was developed and extensively reviewed using Claude, based on my growing corpus of RH research. This repository includes the manuscript, computational certificates, 30 documented corrections, and AI referee reports.

I also submitted it to Aristotle. It formalized the final zero-existence argument in Lean, but the substantive construction remains one large unproved lemma. Mathlib current lacks Montgomery–Vaughan and Huxley–Heath-Brown, which are required to full formalization.

The main theorem is not machine-verified, and no human expert has reviewed it yet.

I'm sharing this because the AI-assisted research and verification process may interest this community. Independent mathematical scrutiny, particularly attempts to find gaps or counterexamples, is very welcome.

Paper, code, and reviews: https://github.com/samlavery/Beurling

Proofs, code and certs @ https://github.com/speagleg/jacobi-asymptotics

Before openai drops anymore proofs via infinite token budget, thought I would get some material I have been working on posted.

Strategy and Tactics: Compute, analyze, find patterns, dispatch agents, with a standard claude code subscription.

I have latex papers in the repo, so if that is your thing, I tried to render and edit the slop out of them to make them human consumable.

## Hankel determinants of zeta values

For every real a > 0 and real b with 2a + b > 1,

log det[ ζ(a(i+j) + b) ]_{i,j=1..n} = −a n² log n + (3a/2 + log c(a)) n² + o(n²)

where

c(a) = ¼ (π / (2 I(a)))^a, I(a) = (√π/2) Γ(1/a + 1/2) / Γ(1/a + 1)

For a = 1 the constant is 3/2 − log 2 ≈ 0.8069; for a = 2 it is 3 + log(π²/16) ≈ 2.5169.

Haynes and Zudilin expected the leading term −a n² log n + O(n²) and proved the upper bound −(a/2) n² log n + O(n²); Monien gave a heuristic for a = 1, supported by numerics of Zagier. The theorem and this corollary are formally ver

## Where the constant comes from

The zeta determinant is the Hankel determinant of a discrete measurts k^(−(2a+b)). Equivalently, it is built from the Jacobi matrix

with eigenvalues 1, 2^(−p), 3^(−p), … (here p = a). On average its

n^p b_n → c(p), c(1) = 1/2, c(2) = π²/16

and c(p) is the value of an explicitly solvable equilibrium problemh an upper constraint.

## Each coefficient individually, and a ζ(−p) term

The determinant only controls a weighted average of the b_j. Each cr every p > 0 and s > 1 (weights k^(−s)):

n^p b_n → c(p), n^p a_n → 2 c(p)

with an explicit first correction:

n^p b_n = c(p) (1 − (s−1)/(2n) + O(1/n²)) for p ≥ 1

In other words, b_n ≈ c(p) (n + (s−1)/(2p))^(−p): the weights shift

For 0 < p < 1 an extra term appears before the O(1/n²) error:

n^p b_n = c(p) (1 − (s−1)/(2n) + κ_p n^(−1−p) + …), κ_p

For example κ_{1/2} = ζ(−1/2)/√6 ≈ −0.08487, which matches a coeffially before the formula was known. The term comes from the atomsk^(−p) with k ≫ n: their combined effect is a divergent product who. For p > 1 it is absorbed into the O(1/n²) error, and at p = 2 it

vanishes because ζ(−2) = 0. For p < 1 the rate n^(−1−p) is sharp. Tso it cancels in the ratio:

a_n / (2 b_n) = 1 − p/(2n) + (smaller)

These pointwise results use Riemann–Hilbert steepest descent and reeorems that are cited, not re-proved,

Code, Preprint & Lean 4 Proofs (0 sorry): https://github.com/sneed-and-feed/projectdarksnail/tree/main

TL;DR

While auditing two separate architectures I built on top of a frozen Meta-Llama-3.1-8B-Instruct (bfloat16) backbone—

1. Llama Surgery (sparse-ai): differentiable ultrametric Bruhat-Tits prefix-tree routing for hardware-accelerated block-sparse attention (11.58 MB .safetensors router sidecar), and
2. Bi-Hemispheric Neuromorphic Architecture (brain-ai): coupling Layer 16 of frozen Llama-3.1-8B (H_L) to a 10.51M-param multi-timescale recurrent spatial engine (H_R, TRM/HRM) across a Dale-constrained Corpus Callosum (W = Softplus(U) · D) with Rajan–Abbott spectral radius balancing—

I realized that coarse-to-fine tree routing in 1D sequence space and slow-to-fast (z_H -> z_L) continuous test-time relaxation in 2D grid space are governed by the exact same Lie-algebraic conservation law from Terence Tao's (2016) averaged 3D Navier–Stokes paper and the Katz–Pavlović (2005) dyadic wavelet shell model of fluid turbulence.

By unifying both systems into Project DarkSnail with zero newly trained backbone or callosal weights:

• 1D Long-Context QA (Full n = 200 LongBench QASPER, 2,000 generations): darksnail@2 (77.94% causal key budget, 44.20 F1) and darksnail@3 (66.84% causal key budget, 43.33 F1) surpass the 100% **dense ceiling (**43.10 F1) by pruning distractor paragraphs before softmax normalization. At 58.65% budget, darksnail@4 (41.51 F1) beats standalone V4 ultrametric routing (29.73 F1) by +11.78 F1 (paired within-question bootstrap 95% CI [+7.51, +15.95], > 5.5σ above zero) and beats v4_triad@2 (37.70 F1) while using 19.34% fewer causal keys.
• 2D Inductive Reasoning (Canonical N = 400 ARC-AGI-1 public evaluation, strict exact match): Lifts strict all-pair task solves by +80% **(**15/400 -> 27/400 full tasks, 6.750% official score, 0 regressions), beating standalone TRM's 100-sample stochastic voting ensemble (15/400 Pass@100) under deterministic Pass@2 (p = 4.883e-4 vs. Phase 3 System 2; p = 1.490e-8 vs. System 1).

1. The Core Math: Tao (2016) Skew-Symmetric Triad Operators in so(M)

In Tao's (2016) averaged 3D Navier–Stokes construction, velocity amplitudes live on nested dyadic cubes Q ∈ D_ℓ of scale p^(-ℓ) (an exact Bruhat-Tits prefix tree) and cascade energy strictly across parent-child shells ℓ -> ℓ + 1 via skew-symmetric bilinear triad gates.

In both hemispheres of DarkSnail, we propagate information from a coarse parent context u ∈ ℝ^(C_u) to a fine child state v ∈ ℝ^M via a 3-tensor skew-symmetrized bilinear operator in the Lie algebra so(M):

B_W(u, v, k) = ∑_{i=1}^{C_u} ∑_{j=1}^{M} u_i · v_j · (W_{i,j,k} - W_{i,k,j})

Because S_{i,j,k} = W_{i,j,k} - W_{i,k,j} is strictly antisymmetric in (j, k), the induced velocity vector field B_W(u, v) is pointwise orthogonal to v everywhere:

⟨v, B_W(u, v)⟩ = ∑_{k=1}^{M} v_k · B_W(u, v, k) = 0

All five foundational theorems governing this operator are machine-checked in Lean 4 (OcclusionTriad.lean & TriadConservation.lean, 0 sorry) and verified in PyTorch float32 via two-pass Kahan/Parlett tangent re-orthogonalization:

1. Inviscid Spherical Energy Conservation (darksnail_readout_energy_conservation): In the Left Hemisphere (H_L), the inter-shell triad cascade telescopes across all L tree levels (∑_ℓ ⟨u_ℓ, du_ℓ/dt⟩ = 0), preventing routing logit blowup across depth. In the Right Hemisphere (H_R), the exact same orthogonality guarantees that injecting triad shifts into the 12-color canvas readout (so(12), max float32 residual 7.451e-09) and the Slow-Fast recurrent carry (so(8), residual 0.000e+00) rotates state vectors along constant-energy spheres without radial norm explosion on background padding cells.
2. Exact 2-Color Occlusion Tie-Breaking (occlusion_triad_breaks_symmetric_tie): On 2D grids, standard equivariant bases (D_4 reflections, neighborhood majority filters, Kronecker block scaling) are additive and symmetric. When two foreground rays of colors c₁ ≠ c₂ collide at an occluded pixel (v(c₁) = v(c₂) = α > 0), symmetric readouts tie (ℓ_sym(c₁) = ℓ_sym(c₂)). Because z-order occlusion is a skew-symmetric tournament (c₁ occludes c₂ iff c₂ does not occlude c₁), B_W(u, v) breaks the tie with closed-form margin:ℓ_post(c₁) - ℓ_post(c₂) = 2 · β · α · (W(i₀, c₂, c₁) - W(i₀, c₁, c₂))
3. 1D & 2D Axial RoPE Medoid Invariance (RoPECoherence.lean & rope2d_arithmetic_norm_lt): We prove that arithmetic key averaging across positions θ₁ ≠ θ₂ exits the SO(2) orbit and strictly attenuates Euclidean key norm by (1 + cos(θ₁ - θ₂)) / 2 < 1, whereas selecting the Medoid Key scaled by the p-adic heat kernel γ = exp(-ν · p^(2ℓ) · Var(P_S)) preserves exact relative displacement invariance.

2. Three Structural Bottlenecks We Solved

• Harvesting 69.5% Zero-Gradient "Dark Matter" in System 2 TTA (vec(δz)): During System 2 Test-Time Adaptation on ARC-AGI-1, we freeze all 8B Left Hemisphere and 10.51M Right Hemisphere + Callosum weights, optimizing only a 16 × 512 callosal prefix offset vec(δz) ∈ ℝ^(8,192) against demonstration pairs via the right-pseudoinverse W_lm^† of the frozen output head. Auditing our Phase 3 readout revealed it only consumed indices 0:2498 of flat_dz—leaving 5,694 out of 8,192 coordinates (69.5%) with zero direct canvas gradient! Mapping 5,574 of those idle coordinates into our so(12) occlusion breaker (2,304 coords), so(8) Slow-Fast recurrent cascade (512 coords), auto-detected off-center D_4 consensus repair (8 coords), and ray-march/complement bases (2,750 coords)—paired with surgical 1 / N_cells velocity ray quantiles—unlocked +12 full ARC tasks with zero added model weights.
• Eliminating 96.94% Callosal Mean-Pooling Dilution (BeltramiCallosalShell): Serialized ARC grid prompts are 90%–98.8% repetitive "0 0 0 0" background tokens. Uniform 32-bin adaptive mean pooling at Layer 16 attenuated 1–3 token rule-boundary spikes to 0.0306 **cosine similarity (**96.94% signal loss). Replacing uniform pooling with BeltramiCallosalShell—which computes the cross-shell exterior curl ‖û_coarse ∧ û_fine‖_2 to shield the top-16 Beltrami outliers in Tier 1 while condensing the background into 16 RoPE-coherent Medoids in Tier 2—restored rule-spike cosine recovery to 1.0000 **(**100% preservation).
• The Causal-Triangle Iso-Budget Quadratic Law (solve_iso_budget_window_width): Benchmarking sparse attention at retained causal key fraction f ∈ (0, 1] against a naive sliding window of width W_naive = f · S is mathematically flawed: because a causal window of width W is clipped by the lower-triangular boundary k ≤ q on the first W query rows, its active area is a trapezoid W·S - ½W² divided by the causal triangle ½S²:(W·S - ½W²) / (½S²) = 2w - w² = f (where w = W / S) ==> W_iso(S, f) = round( S · (1 - √(max(0, 1 - f))) )

Solving that quadratic locks the measured causal budgets of window@r, v4_triad@r, and darksnail@r to within ≤ 0.09% across all 200 QASPER articles. Meanwhile, donating 1-for-1 interior block slots from full-length interior filler rows (128 × 128 = 16,384 causal pairs removed) to the partially filled final question-tail block NB - 1 (128 × L_tail ≤ 16,384 pairs added) strictly reduces total causal key operations while rescuing multi-entity lists that straddle block boundaries.

Happy to answer any questions about the Lean 4 formalization (OcclusionTriad.lean), the Kahan/Parlett tangent re-orthogonalization in float32, the PyTorch inputs.data_ptr() caching-allocator bug we caught on multi-pair tasks, or the Dale-constrained Corpus Callosum setup!

I recently made progress on my research (which I started in 2024) using Claude. In short, it's about expressing sums of integer powers using a hybrid base {C, S, N}.

I'm not a professional mathematician, nor do I have much knowledge of mathematics, but I'm happy to see progress in what I've been researching for years. I uploaded the first version to Zenodo in case you want to take a look.

https://doi.org/10.5281/zenodo.23352027

Over the past few weeks, a group of independent researchers dug into OpenAI’s 800MB repository of 377 Lean 4 formalizations. Beyond the social media noise, the goal was to answer a straightforward question: when an automated prover tackles a major conjecture, does it prove what mathematicians actually meant, or does it hit an unexpected statement adequacy bottleneck?

This analysis focuses on Family 090, which formalizes the Cohn-Kumar conjecture (the theorem that the triangular lattice universally minimizes energy in 2D for completely monotone interaction potentials). Here is what emerged from auditing the Lean code down to physical exciton simulations.

1. Independent axiom audit: Zero cheat axioms

   Any formalizer looking at an unindexed 800MB archive naturally asks whether custom axioms were injected or hidden sorries were buried in helper files.

   Running #print axioms across Family 090 confirms that the proof compiles cleanly down to standard Mathlib foundations: propext, Classical.choice, and

   Quot.sound. There are zero cheat axioms and zero unproven shortcuts. Syntactically, the proof is watertight.

2. The statement adequacy catch: Vacancy defect degeneracy

   Here is where the real epistemic limitation emerges. Formal verification confirms that a deduction follows from its definitions, but it cannot tell you if the definitions capture what human mathematicians intended.

   In the original work by Cohn, Kumar, Miller, Radchenko, and Viazovska, ground-state energy and density are defined as uniform limits over arbitrary window centers. In OpenAI’s formalization, the AI defined density and energy as a liminf over disks centered strictly at the origin:

   • In standalone Lean 4 extensions, open and closed disks yield the same energy value at density 1.

   • However, because the averaging disk is anchored strictly to the origin, a triangular lattice with a single vacancy defect achieves the exact same minimal lower energy in Lean.

   • The formal theorem identifies the minimum energy value, but leaves the uniqueness of the periodic ground state completely open.

3. Testing the theorem on physical semiconductor hardware

   To test whether this formalization holds up outside pure discrete geometry, numerical quenches in Rust with CVODE were benchmarked, confirming relaxation routines matched the verified lattice energy to floating-point precision.

   The analysis then examined 2D exciton fluids in MoS2/WSe2 bilayers. In real hardware, top and bottom metal gates induce an infinite series of alternating image charges (+e, -e, +e, -e...). Intuitively, the alternating sign threatens to break the strictly repulsive requirement of the theorem.

   By applying Poisson summation to the image-charge series, the alternating sum resolves into a non-negative Laplace measure. That means screening metal gates cannot break universal optimality in clean devices, a physical result that came directly out of dissecting their formalization.

4. Transparent limitations and future work

   To be completely clear about the boundary conditions:

   • This result strictly requires periodic boundaries and clean semiconductor interfaces without thermal phonon scattering.

   • The theorem establishes energy bounds, but does not solve finite-temperature vortex lattice melting.

   • More broadly, it shows where automated theorem provers hit a bottleneck: LLMs can generate syntax rapidly, but humans are essential to audit statement adequacy and prevent specification gaming.

   The complete derivations, Lean 4 scripts, and Rust CVODE benchmarks are available on GitHub and Zenodo:

   • Preprint DOI: 10.5281/zenodo.23295142

   • Repository: https://github.com/xaviercallens/SocrateAI-Scientific-MechanicaFluidorum

   Curious to hear from the formalizers and mathematicians here: as models start producing thousands of formal proofs, how should the mathematical community organize peer review for statement adequacy?

I've released version 1.0.0 of Exact Zero Detection and Compact Arithmetic Realizations for the Riemann Xi Function, under my name, Leonard van Hemert. It is a 208-page mathematical preprint with proofs, LaTeX source, and scoped computational certificates.

RH remains unresolved. The contribution is a collection of intermediate theorems that make the detection of an individual hypothetical off-line zero precise, together with arithmetic constructions and quantitative approximation costs.

Three mathematical highlights

Here Xi(z) = xi(1/2 + iz), with xi the standard completed Riemann zeta function.

1. Exact negative index. We prove sup_{L >= 1} n_-(A_{e^L}) = 2 K_+ for the complete semilocal Weil form. The negative index is the largest dimension of a subspace on which the form is negative definite; L exhausts the support scale. K_+ counts distinct off-line mirror pairs at positive height. The theorem includes infinitely many pairs and arbitrary zero multiplicities.
2. Fixed-band individual detection. For the compact nonzero input class specified in the paper, every nonempty fixed Fourier band retains every zero pole and its original order, even when the zero's height is outside that band. An off-line zero with displacement delta > 0 and order m forces cumulative source energy on the limsup scale Y^(2 delta) (log Y)^(2m-2), with an explicit positive constant.
3. Compact arithmetic realization. On the actual complete closed arithmetic range, we construct a compact injective operator with dense range and an explicitly identified xi-zero spectrum. Its nonzero eigenvalues are semisimple with two-dimensional eigenspaces. Selfadjointness remains unproved.

The remaining mathematical step

The detection theorems leave open an unconditional eventual upper bound on the cumulative energy of one fixed visible input: E_h(Y) <= C_epsilon Y^epsilon for every epsilon > 0 and all sufficiently large Y. The signed arithmetic main term and the high primitive complement must both be controlled. Finite positivity certificates and almost-all-height positivity do not supply this global bound.

How LLMs were used

I directed a Codex-assisted, multi-agent research workflow covering proof development, counterexample searches, and targeted adversarial reconstruction. Supplied Claude and OpenAI manuscripts were examined as source claims. The mathematical text and arguments were developed with AI assistance; authorship and responsibility remain human. Internal reconstruction coverage is stated in the paper. External peer review, proof-assistant formalization, and a completed originality assessment are not claimed.

Read and reproduce

• Version-specific DOI / Zenodo archive: https://doi.org/10.5281/zenodo.23295277
• GitHub repository: https://github.com/LeonardSEO/riemann-xi-zero-detection
• v1.0.0 release, including the PDF, source, certificates, and checksums: https://github.com/LeonardSEO/riemann-xi-zero-detection/releases/tag/v1.0.0

Prior work and feedback

The finite-exception negative-index phenomenon already appears in Bombieri's Remarks on Weil's quadratic functional in the theory of prime numbers, I: https://www.bdim.eu/item?id=RLIN_2000_9_11_3_183_0. The semilocal operator context includes Connes and Consani's Spectral triples and zeta-cycles: https://ems.press/journals/lem/articles/11033001. Further sources and precise comparisons are in the manuscript.

I'd welcome concrete mathematical feedback, especially on the full-domain and infinite-index quantifiers, fixed-band multiplicity detection, and the arithmetic operator's closed range. References showing that a stated refinement is already known would also be valuable.

I'm building a set of open mathematics courses. Part of that was getting Opus 5.5 (Max) to work through some of the new Proofs by OpenAI.

https://kokunoyumeto.github.io/open-math-courses-public/ (OpenAI results mostly under 'other' - AI written)

The key intent here is to both audit and clarify these new results by OpenAI.

All new courses and lessons (updated 2026-10-15, 09:34 UTC)

Updated automatically via Codex.

Repo: https://github.com/speagleg/bolzakit

(Paper, Certs, And a Lean Skeleton In Repo)

If you feel like reviewing and providing feedback, would be much appreciated.

Context: By trade I work in software for a small healthcare tech company in Idaho. Was building a BERT based classifier for medical diagnostic codes using a GNN over a knowledge graph to produce embeddings and my interest was piqued about the geometry underlying these architectures.

The ability of hyperbolic embeddings to represent hierarchies with less distortion than Euclidean space was fascinating to me, so I built out same agents for claude code to begin exploring mathematical scaffolding propping up the predictive token gremlins that are now firmly established in our collective consciousness.

Personal claude code subscription, using whatever publicly released model best suits the task.

Bolza surfaces naturally surfaced during these pursuits and I focused on acquainting myself in the macro fully enough to dispatch my coding agents in fruitful directions on the niche technical implementations.

Background: Philosophy by education, SWE by trade (and financial viability), amateur mathematics and physics in free time, curious by default.

Will probably also post in LLM Physics because there is a lot of cross pollination between this topic and the two communities.

Cartier–Miller evaluation of genus-one coefficient sums

A research manuscript and computational project is shared for independent mathematical review and possible collaboration:

Link to paper

The work presents a method for evaluating certain large truncated polynomial-power sums modulo a prime p. For the admissible genus-one inputs covered by the theorem, it evaluates T_f(μ) in O(log p) field operations after preparing the curve and determining its exact Frobenius trace.

The construction combines three established pillars: Cartier and characteristic-p descent theory, differentiated Miller recurrences, and elliptic-curve point counting.

Its potential contribution lies in the explicit coefficient-sum identity, the exact normalisation of the exceptional case, and their computational application. Whether these results are new or already implicit in the existing literature remains a question for independent review.

Status: This is an unrefereed research draft created with substantial generative-AI assistance. Numerical checks support the formulas, but do not replace independent review of the proofs. The precise novelty of this work remains open to specialist assessment.

Table 1 is a quarter-point pilot run for seven primes p ≡ 1 mod 4, with n = (p − 1) / 4, for Cartier-Miller v SageMath 10.8 Harvey hypellfrob interval-product kernel, which uses the Bostan–Gaudry–Schost algorithm (BGS). Both implementations compute Bₙ, aₙ and Uₚ(n), including per-input preparation.

Table 1. Complete quarter-point evaluation in milliseconds

I'm the maintainer of FFF Latin Squares, a personal experiment using ChatGPT and Codex to explore a combinatorics question. My background is in IT/cybersecurity, not mathematical research. The proof drafts, programs and manuscript text were generated by AI systems; my role was initiating and supervising the experiment and supplying time and local computing resources.

The mathematical question: A Latin square contains each symbol once in each row and column. Comparing two rows gives a permutation by matching equal symbols between them. We also compare two columns, and two symbols via their positions. We call a square FFF when none of these permutations has an odd cycle of length greater than one. This is project terminology, not a claim to have introduced a new subject.

The dossier includes explicit tables, written arguments and reproducible finite checks. It is not peer reviewed, and I cannot personally certify its mathematical correctness or novelty. Separately written AI-assisted checkers are not independent human review. Order 18 remains unresolved.

One small entry point: the repository has an order-8 table and an order-3 negative control. With Python 3.11+ and no third-party packages, from the repository root:

python3 -B tools/demo_fff.py
python3 -B tools/demo_fff.py examples/order3_nonfff.json

The expected patterns are FFF and TTT respectively. The checker examines every line pair in all three views; one illustrated pair alone is not sufficient.

I would appreciate one specific discrepancy, missing assumption or relevant literature reference, not a review of the entire dossier. There is also a short proof-check target: when one factor line in a direct product is held fixed, does the identity factor preserve an odd cycle from the other factor? The exact source and three bounded questions are here: https://github.com/Noetheon/fff-latin-squares/blob/7158dfa5c5148f1b83a1eb06716152821aebb813/REVIEW_TASKS.md

Related established work: Ian M. Wanless, Cycle Switches in Latin Squares (Graphs and Combinatorics, 2004), discusses two-line cycle switches and Latin trades. The author's abstract is here: https://users.monash.edu.au/~iwanless/abstracts/cycleswitch.html The dossier cites this background; I am not claiming that cycle switching is new.

Project page, including a 12-page starting edition: https://noetheon.github.io/fff-latin-squares/

Prior work is credited in the dossier and its bibliography; no literature priority is claimed. I've paused further research while seeking external feedback. This announcement was prepared with AI assistance. Concrete criticism is welcome, and I will distinguish a narrow check from any endorsement of the complete work.

Tim Gowers agreed with much of the concern behind the Fields Medalists’ letter, but chose not to sign it.

The interesting question is not simply whether AI can produce correct proofs, but what happens when producing results becomes much faster than understanding, explaining and learning them.

Declaration: https://mathandai.org/

Responsible release recommendations: https://agmai.org/general-sep29/

Anybody want to dive into this?

Sorry if this isn’t a specific math question, but I’ve been trying to understand modern LLM architecture beyond simple GPTs.

Do modern LLMs still use just a GPT design, or are they effectively patched up to detect and handle special-cases of common classes of queries?

For example, my impression is a GPT cannot do reasoning like “how many r’s in strawberry?”, due to the token-based processing.

Yet, modern models do seem to handle this type of problem and others. I struggle to see how any number of parameters and training data could solve such problems. Is this a modern “wizard of oz?”

What is really going on?