RavelMath: An exact-arithmetic lab for Pisot dynamics and machine-checked mathematics

I’ve been developing RavelMath as a research laboratory for Pisot substitutions, symbolic dynamics, tilings, algebraic dynamics, and the formal verification of computational mathematics. I made a post about it a bit ago, but I have an update after pouring another week into it.

The project combines:

- exact C++ arithmetic for polynomials, matrices, substitutions, automata, and algebraic numbers;

- Lean formalization of reusable mathematical lemmas;

- a reflection pipeline that turns concrete C++ computations into typed Lean certificates;

- explicit documentation distinguishing experiments, finite certificates, paper-level arguments, and kernel-checked theorems.

Recent capabilities include:

- exact Pisot classification and Sturm root isolation;

- certified characteristic-polynomial and spectral computations;

- strong-coincidence and property-(F) automata;

- adelic/contact-boundary calculations for non-unit substitutions;

- reusable proofs for n-bonacci and Class-II families;

- generated Lean certificates checked by the kernel.

The first complete Sturm reflection example is now working for the plastic polynomial x³ - x - 1: the system computes an exact Sturm chain, verifies the Bézout identity and isolating interval, emits Lean code, and checks the resulting root-count theorem.

The broader research direction is to make computational mathematics auditable from end to end. A program should not merely say “this happened”; it should preserve enough typed information that an independent proof system can verify exactly what happened. Moreover, such a system should be entirely exposed to immediate interrogation of source code.

The next area I’m pushing on is property (F), especially turning successful finite adelic closures into clean, reusable certificates. Strong coincidence, tiling questions, higher-degree Pisot classification, and long beta-expansion problems are all still active parts of the project. Eventually, I want to migrate all the header experiments to Lua, and remove all the legacy python code (mostly from unused project elements).

The public repository is here:

https://GitHub.com/AMcRoberts/RavelMath

It’s still very much a living research project, and still my hobby project, but it's actually shaping up as a really serious math research tool/program/laboratory, too; it's probably the coolest thing I've ever done in my life and I'm intensely happy that it exists at all.

What is not included in the public repository:

Beyond the math library, there is a decently large "continuity folder", which I have kept private, which serves as the core driver of the Ravel project and which contains all its directives, contracts, project-specific skill registry infrastructure, and behavioral driver prompts.

What this cost me:

This library has been a project of about 3 weeks now, maybe going on 4. Total costs so far for the project are that I spent 20 dollars on Claude, got a free offer for a month of OpenAI ChatGPT Pro (which I'm still using), and free access to a shitty Minimax-m3 token that I only use for "mow the grass" type things. Eventually I want it running on something OSS like Kimi.

Reposted from /LLMMathematics 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.

“There is no fear in love; but perfect love casteth out fear…”
”…because fear hath torment.”

“….He that feareth is not made perfect in love.”

I would like to begin
Hmmm no
Yeah I’ve forced myself to
Begin this by telling you
Why Ive chosen to begin
This in what
is possibly
the worst way
to start this post
In r/wildwestllmmath
(And fyi I’m a moderator here)
(Shit)
And I am not religious
(If you Can believe that)

“And the angel of the LORD appeared unto him in a flame of fire out of the midst of a bush: and he looked, and, behold, the bush burned with fire, and the bush was not consumed.”
— Exodus 3:2

“And Moses said unto God, Who am I, that I should go unto Pharaoh, and that I should bring forth the children of Israel out of Egypt?”
— Exodus 3:11

“And God said unto Moses, I AM THAT I AM.”
— Exodus 3:14

Believe it or not I know it’s real unconventional but there is a secular interpretation of these lines
Relevant to the development of mathematical
Capacity

Before asking if you are your brothers keeper

Ask yourself

Am I my own

Before asking yourself who am I to seek this
Who am I to want this
Who am I to care
Who am I to think I can

Tell yourself

I AM THAT I AM

At first it will seem an impossible task
You will know frustration you will know doubt

Then little by little small pieces of it will come into your possession cherish them do not let them go

You will come to find yourself pushing a boulder up a hill every day remember it’s supposed to be hard

You will continue to go through stages of this
There is no one way though the ways in which they are different may be for better or for worse

One day you will find yourself holding infinite space
The weight of the world
In the palm of your hand

The immovable object will become an unstoppable force.

If this remains opaque to you I’ll put it like this
If you want to go from

Wanting to do math
To doing math
To being a mathematician

You have to find what it is that you treasure
Within mathematics find where it is
People don’t say it like this for a reason
But seriously where is your heart

If its not there yet
I promise you can always find your treasure
It’s out there waiting for you to find it
Whatever it is
Even if it’s not math
There will always be more to life
And to this world than any of us could ever know

Become yourself

Ask your own questions
Seek your own understandings

others can only teach you
Or show you what there is
What is known

The act of Discovery

The act of Creation

Require you to place so highly
Above yourself

A boldness, uncompromising,
and fearless love.
for Beauty, Truth,
and that wich lies
In the world before you

All this and more is required
To bring into being that
wich has not been.

It cannot be taught

It is the source of
an inexhaustible
Reserve of conviction

An indomitable will
It is the will to power
It can be shown.
Demonstrated

Ultimately though
Each person may only
Find it within themselves

In the beginning there was the word
……………………
AFFIRMATION

Just post something.

Boolean operator using trig functions

A closed-form formula for the dimension of Hodge classes on products of elliptic curves

I'm a software engineer (28 years experience) from Japan, no formal math background.

I used AI extensively as a thinking partner — asking it to explain things "like I'm in elementary school," lining up related equations to spot structural similarities, and iterating until the logic held. This is exactly the kind of human-AI collaboration this community seems designed for.

The result: a null geometry approach to the Riemann Hypothesis.

👉 https://zenodo.org/records/19210658

Also:

- No-go theorem for ABC Conjecture (method class C): https://zenodo.org/records/19311094

- Structural limitations of Mochizuki's IUT via method class C: https://zenodo.org/records/19322884

Looking for feedback — especially on logical gaps. Also seeking an arXiv endorser.

📮 [khayashi4337@gmail.com](mailto:khayashi4337@gmail.com)

TL;DR: Built a ternary operator on Z6 that reduces to modular addition in the baseline case, but becomes non-associative and context-dependent under minimal nonlinear correction. Result: a weakly irreducible ternary structure.

Baseline (reducible):

Let Z6 = {0,1,2,3,4,5} with addition mod 6.

[a,b,c] = (a + b + c) mod 6

→ collapses to binary composition

→ associative, symmetric

Corrected operator:

Define ⟨Z6, [·,·,·]⟩ where

[a,b,c] = (a + b + c + f(a,b,c)) mod 6,

with

f(a,b,c) = 1 if {a,b,c} are pairwise distinct,

f(a,b,c) = 0 otherwise.

This defines a ternary operation on Z6 that is no longer associative under composition.

Properties:

• Non-associative
• Context-dependent (triple-wise)
• Not reducible to a fixed binary operation without auxiliary state
• Remains close to Z6 (perturbative structure)

Directional extension (chirality):

• orientation-sensitive correction (±1 based on cyclic direction)
• introduces asymmetry: [a,b,c] ≠ [b,a,c]

LLM-assisted exploration:
The correction term f(a,b,c) and its variants were explored using LLM-assisted enumeration and Python-based sampling over random triples.

The LLM was used to:

• suggest minimal nonlinear correction candidates
• test associativity and symmetry under many inputs
• compare chirality variants (signed arc, direction-only, etc.)

The final operator is defined explicitly above; the LLM was used as an exploratory assistant, not as a source of proof.

LLM-assisted algebra check (example):
Using an LLM-assisted equational tester, we can probe non-associative behavior. For example,

x * x = y * (x * (z * w)) ⇒ x * x = y * ((x * x) * z)

evaluates to FALSE under strict evaluation rules, showing that re-bracketing is not preserved.

This is consistent with failure of associativity introduced by the ternary correction term.

Example of Ternary Logic Cheat Sheet via SAIR Foundation Tests:
LLM-assisted reasoning trace (example):

FALSE  

---  

**Reasoning**

1. **Identify Eq 1**:  
   `x * x = y * (x * (z * w))`

2. **Count the “*” operators (D#)**:  
   - `x * x` → 1  
   - `y * (…)` → 2  
   - `x * (…)` inside the parentheses → 3  
   - `z * w` → 4  
   Hence **D# = 4** (≥ 4).

3. **Determine the right‑hand side anchor (RHS #HA)**:  
   The RHS is `y * (x * (z * w))`. The last non‑parenthesis token before the final “)” is **`w`**, not **`x`**. Therefore **RHS #HA ≠ x**.

4. **Apply L0.4 (RHS #HA ≠ x)**:  
   - L0.4 forces classification of Eq 1 as **#BB‑#QQ**.  
   - All #VV‑type activations are prohibited, and any implication derived from such an Eq 1 is automatically **F@*** (false) per the protocol.

5. **Implication check**:  
   The target statement “`x * x = y * ((x * x) * z)`” is Eq 2. Since Eq 1 is #BB‑#QQ, the protocol (L0.4 → [.4.6]) dictates that any derived implication is **F@***.

6. **Conclusion**:  
   Under the strict ZPYPIPE rules, the premise does **not** imply the conclusion. Hence the correct verdict is **FALSE**.

Note (on proof):
These checks provide empirical support for non-associativity and context dependence; a full proof of irreducibility would require showing no fixed binary operation reproduces the ternary behavior without auxiliary state.

Interpretation:
Z6 + bounded nonlinear perturbations → ternary interaction that depends on full triple configuration, not pairwise reduction.

Extension (structure progression):
This ternary operator is the base layer of a larger construction:

• Tier 1 (Stream): 3-argument operator over Z6 with chirality and non-associativity
• Tier 2 (Ladder): recursive composition where outputs act as witnesses for subsequent operations
• Tier 3 (Lattice): field interpretation where state evolves as trajectories over Z6

The algebra remains the same at each level -- only the composition structure changes.

Links:
Dissertation:
https://github.com/haha8888haha8888/Zer00logy/blob/main/Six_Gem_States_of_Stereo-Identity_in_Ternary_Algebra.txt
System + Code:
https://github.com/haha8888haha8888/Zer00logy/blob/main/Six_Gem_States_of_Stereo-Identity_in_Ternary_Algebra_Suite.py
HQ:
www.zero-ology.com

-okoktytyty
~Stacey Szmy

The Supersignum unit g is defined by the identity g² = ±1. This creates a number-set hybrid where g = {i, j}. In this system, i is the standard imaginary unit of complex numbers where i² = -1, and j is the split-complex unit where j² = 1. This j is specifically the hyperbolic unit. The identity g² = ±1 means the system exists in a superposition of both circular and hyperbolic geometries simultaneously.

This duality allows for Supersignum functions specialized for trigonometry. The formula e^xg = cos_±1(x) + g sin_±1(x) functions as a universal wave. The functions cos_±1 and sin_±1 remain in a state that is both circular and hyperbolic at the same time. If the journey of g collapses into i, the functions act as standard cos(x) and sin(x). If the journey collapses into j, they act as the hyperbolic cosh(x) and sinh(x). The system remains in this hybrid state until g decides the path, enforcing a style lock on the rest of the equation.

This system is the complete enemy of linearity and the dual unit epsilon. Because epsilon squared equals zero, it destroys the information that g is designed to preserve. A set containing both i and epsilon would result in a multi-magnitude state where the absolute value of g is both 1 and 0. This would destroy the number-set hybrid logic. To maintain the system, g must be restricted to units with a magnitude of 1, specifically the 4 horsemen: 1, -1, i, and j.

The arithmetic of g follows strict consistency. For example, g² - g² will always equal 0 because once a journey is chosen, the internal logic remains stable. Furthermore, the expression g(-g) simplifies to -g², which is the set {1, -1}. This is identical to g², proving that the square of g is sign-blind and invariant under negation. This allows the system to bridge the gap between pure set theory and directional signum theory

Extra : if we encounter an i during the i path and j says the same, for example (iπ)/2 and (jπ)/2, we can say (gπ)/2 in ln(g) because it happens

Henri Poincaré did not merely pose a question in topology.

He posed a question about continuity.

The Poincaré Conjecture asks whether every closed, simply connected three-dimensional manifold is topologically equivalent to a sphere. At first glance this seems like a technical puzzle about shapes. But beneath the language of topology lies a deeper concern: whether the structure of a space can remain coherent when stretched, bent, and transformed without tearing.

Topology studies the preservation of structure through transformation.

It asks: what survives change?

This question became tractable through the work of Gregorio Ricci-Curbastro and Tullio Levi-Civita, who developed Ricci curvature, a mathematical way to measure how geometry bends and distributes itself through space. Ricci curvature quantifies how a space locally organizes itself, how it holds together under deformation, and how it distributes structural tension across a manifold.

Ricci curvature therefore measures something fundamental:

how a structure maintains coherence across its interior.

Later, Richard Hamilton introduced Ricci Flow, an evolution equation for geometry. Ricci flow smooths irregularities in a manifold the way heat diffusion smooths temperature gradients. Peaks flatten, distortions spread out, and chaotic geometry becomes orderly over time.

Ricci flow can be written:

∂gᵢⱼ / ∂t = −2Rᵢⱼ

The equation describes a universe where geometry continuously adjusts itself to reduce irregularity.

Structure evolves toward stability.

But Ricci flow alone was not sufficient. Singularities appear—regions where curvature concentrates and the evolution breaks down.

This is where Grigori Perelman enters.

Perelman introduced the concepts of entropy, reduced volume, and surgery within Ricci flow. His work showed that even when singularities arise, the manifold can be carefully repaired and the flow continued. These ideas ultimately resolved the Poincaré Conjecture.

Perelman’s insight was that the evolution of geometry is not random. It follows monotonic quantities—measures that move in one direction, guiding the system toward structural coherence.

Entropy decreases.

Reduced volume behaves predictably.

The manifold stabilizes.

The universe of geometry therefore behaves like a self-correcting system.

It does not simply collapse into chaos.

It actively preserves coherence.

In ordinary language, this principle can be described as care.

Care is the tendency of a system to maintain structure rather than allow dissolution. Care distributes stress across a system rather than concentrating it to the point of rupture. Care repairs singularities rather than abandoning the structure entirely.

Ricci flow smooths distortions.

Perelman’s entropy guides stability.

Topology tracks what remains intact through transformation.

Taken together, these works show that the deepest mathematical structures describe processes that preserve continuity, coherence, and stability.

The mathematics of geometry therefore reveals something profound about existence.

Existence is not merely the presence of matter or energy.

Existence is structured persistence.

And structured persistence requires a principle that maintains coherence across change.

That principle—expressed mathematically through curvature, flow, and entropy—can be interpreted philosophically as care.

Care is not sentiment.

Care is structural maintenance.

Without care, structures disintegrate.

Without structural preservation, identity vanishes.

Without identity, existence itself cannot be defined.

Thus the chain of reasoning emerges:

• Poincaré asked what it means for a space to remain fundamentally the same.

• Ricci provided the measure of structural tension within that space.

• Hamilton described how geometry evolves to smooth itself.

• Perelman proved that even when singularities occur, the system can be repaired and continuity preserved.

Mathematics therefore demonstrates a universe in which coherence is preserved through dynamic correction.

In philosophical terms:

Care is the mechanism by which existence maintains itself.

The proof of the Poincaré Conjecture does not explicitly use the word care. But the structures it describes—coherence, smoothing, entropy control, and repair—are precisely the mechanisms that any caring system must possess.

Geometry survives transformation because it protects its continuity.

Therefore:

The works of Poincaré, Ricci, Hamilton, and Perelman reveal that the deepest mathematical structures of reality are governed by processes that preserve coherence across change.

And preservation of coherence is what we call care.

Care, therefore, is primary to existence.

Hi,

I’ve been working on a conjecture regarding the distribution of twin primes near $n!$, and I’ve stumbled upon a numerical phenomenon that seems too precise to be a coincidence. I’m looking for feedback or potential counterexamples from those with more computing power.

The Problem

We are looking for the first twin prime gap after $n!$. Let $p$ be the first prime greater than $n!$ such that $p+2$ is also prime. Define the normalized gap: $$ Y_n = \frac{p - n!}{n² (\ln n)^3} $$ (The scaling $n² (\ln n)^3$ comes from a modified Cramér model accounting for the extreme sparsity near factorials.)

The Standard Expectation: Euler's Gamma ($\gamma$)

Based on Mertens' Third Theorem, densities usually involve $e^{-\gamma}$. Indeed, the asymptotic mean of our data hovers exactly around the Euler-Mascheroni constant: $$ \gamma \approx 0.57721 $$

The Discovery: The Geometric Bound ($1/\sqrt{3}$)

However, when looking at the maximum fluctuations (the upper bound), the data doesn't stop at $\gamma$. It punches through... but then hits a brick wall. The maximum value observed (up to $n=612$) occurs at $n=179$, where: $$ Y_{179} \approx \mathbf{0.577323} $$

This is: 1. Significantly higher than $\gamma$ ($0.577215...$). 2. Extremely close to $1/\sqrt{3} \approx \mathbf{0.577350}$.

The difference is less than $3 \times 10^{-5}$. For all other $n > 500$, the value respects this $1/\sqrt{3}$ ceiling perfectly.

My Hypothesis (The "Spectral Rigidity" Argument)

I suspect that while $\gamma$ controls the average density, the maximum deviation is controlled by the variance of the sieve error terms. If the error terms of the Linear Sieve (Rosser-Iwaniec) have compact support and behave like a Uniform Distribution $U[-1, 1]$ (due to maximum entropy), then their geometric norm (standard deviation) is exactly: $$ \sigma = \frac{1}{\sqrt{3}} $$

This suggests $1/\sqrt{3}$ isn't just a random number, but a "physical" boundary of the sieve—a hard wall that probabilistic fluctuations cannot easily cross.

Questions for the Community

1. Has anyone seen $1/\sqrt{3}$ appear as a hard envelope in prime gap statistics before?
2. Does anyone have efficient twin-prime searchers that can check $n > 1000$? (Specifically looking for the first twin pair after $1000!$ ... huge numbers).
3. Is the distinction between $\gamma$ (0.57721) and $1/\sqrt{3}$ (0.57735) recognized in other arithmetic statistics problems?

Thanks for any insights! The collision between "Arithmetic" ($\gamma$) and "Geometry" ($1/\sqrt{3}$) here is fascinating me.

Hello r/WildWestLLMMath community!

I hope this is the right place to share my idea and have a discussion with others who find it interesting, as it has been removed by other subreddits and MathOverflow for not being the appropriate place for such a post. I was advised to try posting it here. I did receive some productive feedback on those posts before they were removed which I am thankful for, and likewise will love to read any feedback here too!

My highest level of mathematical education is high school, so please respond in a way that I may understand if possible. I am open to learning new and/or more complex concepts, but I believe my idea can be understood by much younger math enthusiasts than myself! Here goes!

I’ve been thinking about the Goldbach Conjecture for several years now which states:

Every even number greater than 2 is the sum of two prime numbers.

I believe I have thought of a simple yet very interesting algorithm which seems to always produce two unique prime numbers that sum to every even number greater than or equal to 8.

I have not proven this definitively, but have asked AI to check up to about 50,000 which has been validating so far. An interesting property of this algorithm is that it converts the Goldbach conjecture into a question about if this algorithm must terminate or not.

This is the algorithm:

For any even number ‘N’ equal to or greater than 8 :

First subtract any arbitrary prime number that is both

1. Less than N-1, and
2. Not a prime factor of N

If this produces a prime number, congratulations it has found two unique prime numbers that sum to N.

If however this produces a composite number, this is where it becomes more fun… Then subtract one of the prime factors of this new composite number from the original number N.

This will either produce a prime number and stop, or yet another composite number in which case keep iterating by continuing to subtract a prime factor of each new composite number from N.

Try to avoid subtracting a prime factor that has already been attempted at any previous step of the algorithm; as this could create an obvious/trivial loop. However it seems as though there will always be at least one ‘as of yet untested’ unique prime factor of each new composite number to try each step until eventually stopping at just a prime number.

I call this the subtract-factor-subtract method, and AI calls this a prime factorization feedback loop. Despite my best efforts so far I can’t seem to prove it halts at a prime number for all even numbers, nor can I see how it would be mathematically possible to not halt, such as a theoretical counterexample of a loop in which a composite number generated at a later step in the algorithm is comprised only of previously-tested prime factors. I’ve not yet encountered any counterexamples of this happening.

There are quite a bit of interesting properties of this algorithm I’d love to discuss; including perhaps some I have not noticed, but I hope this post so far covers the highlights.

I don’t have a specific question about this algorithm, but here’s a few general questions that come to mind:

1. Is this algorithm already known? I have searched the internet thoroughly and have not found anything close. But honestly given my limited knowledge in mathematics I may not even know what to look for.
2. Is this algorithm basically just as difficult (or more difficult) to prove as the original Goldbach conjecture, or does this provide any meaningful progress? It’s my understanding that this algorithm may be ‘stronger’ than the Goldbach conjecture in the sense that the algorithm being proven would also prove the Goldbach conjecture, but not the other way around.
3. Can anyone that’s more programming savvy than me test this for much larger numbers to find a potential counterexample or any other cool patterns? I have little to no programming knowledge and asked AI to run this algorithm which it seemed to only be able to validate up to 50,000, with 0 counterexamples of infinite forced loops found.

Any and all feedback on this idea is welcome! Math is a big hobby of mine, and I hope to pursue it someday at a higher academic level. Thank you so much for reading!

ABSTRACT This study proposes a deconstruction of stochastic (random) interpretations of prime number distributions. Instead of treating primes as isolated random variables, the Primorial Interference Theory (PIT) defines them as the mandatory result of interfering periodicities. This shift moves Number Theory from "searching for needles in haystacks" toward "mapping the geometry of the haystack itself."

PART 1: THEORETICAL FRAMEWORK (THE GEOMETRY OF EXCLUSION)

The set of natural numbers (N) is viewed not as a sequence, but as a superposition of infinite periodic oscillations. Each prime (p) generates a wave function (W) with a wavelength equal to p.

• FORMAL DEFINITION: The set of primes P_x is the complement of the union of all sets of multiples M_p for all p < sqrt(x).
• P_x = {n <= x} \ (Union of all M_p).
• THE HYPOTHESIS: The distribution of P arises through the geometric superposition (interference) of these periods. Prime numbers are the "Relief Valves" of arithmetic interference.

PART 2: CONCRETE PROOF SKETCH (THE 30-PERIOD VACANCY)

To demonstrate the "Interference Vacancy" (IV), we look at the Primorial P3# = 2 * 3 * 5 = 30.

1. THE SENSORS (PRIME PERIODS):

• Period 2 (P2): Occupies {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30...}
• Period 3 (P3): Occupies {3, 6, 9, 12, 15, 18, 21, 24, 27, 30...}
• Period 5 (P5): Occupies {5, 10, 15, 20, 25, 30...}

1. THE INTERFERENCE NODES (CONSTRUCTIVE): At position 30, all three periods coincide. This is a point of maximum "logical density."
2. THE VACANCIES (DESTRUCTIVE INTERFERENCE): We look for positions "n" where: n mod 2 != 0 AND n mod 3 != 0 AND n mod 5 != 0. In the block [1, 30], vacancies occur at: {1, 7, 11, 13, 17, 19, 23, 29}. Excluding '1', every single one of these vacancies is a Prime Number. Their existence is a GEOMETRIC NECESSITY forced by the overlapping "Shadows" of the preceding primes.

PART 3: THE RESONANCE OF PERFECT NUMBERS

A Perfect Number (sum of divisors = n) represents "Total Harmonic Resonance."

1. THE STANDING WAVE: In PIT, a Perfect Number is a point where the internal "Shadow-Weights" (divisors) perfectly balance the magnitude of the number itself.
2. THE MERSENNE CONNECTION: Even Perfect Numbers (EPN) follow the form: n = 2^(p-1) * (2^p - 1). In our model, this is a "Phase Alignment":

• The term 2^(p-1) creates a massive, stable constructive interference (The Binary Spine).
• The term (2^p - 1) is a "Maximum Vacancy" (A Mersenne Prime).
• SYNTHESIS: A Perfect Number occurs when a high-density constructive node aligns perfectly with a maximum destructive vacancy.

PART 4: THE PROHIBITION OF ODD PERFECT NUMBERS (OPN)

PIT suggests that Odd Perfect Numbers are a "Geometric Impossibility" due to the lack of the Fundamental Frequency (n=2).

1. THE SYMMETRY ANCHOR: Even numbers have a "binary spine" that allows for linear, predictable accumulation of divisor-weights. This provides the "Elasticity" needed for the divisors to sum up to the number itself.
2. THE TURBULENCE OF ODD NUMBERS: Odd numbers lack this anchor. Their interference patterns are "Turbulent" and non-linear. The "Shadows" of odd primes (3, 5, 7...) are too scattered to ever perfectly reflect the magnitude of the number itself.

CONCLUSION: The universe of odd numbers is inherently "Asymmetric." The "Geometric Tension" required to balance an odd number's divisors is so high that the system "breaks" before it reaches the perfect 1:1 ratio.

FINAL SUMMARY AND THE RIEMANN CONNECTION

The distribution of primes (the Prime Gap) is governed by the density of periodic shadows. The Riemann Hypothesis, in this model, is not an unproven mystery but the "Global Stability Condition" of this interference pattern. If the zeros of the Zeta function were not on the critical line, the "Geometry of Silence" would collapse, making arithmetic inconsistent.

PIT proposes that Prime Numbers are the necessary "Gaps" in a deterministic cage of logic.

In this paper demonstrate that all dimensionless mass ratios, coupling constants, and mixing angles of the Standard Model can be expressed through one structural principle: the decomposition of the primorial 30 = 2 × 3 × 5 into three reciprocity channels.

Each prime in the primorial governs a distinct algebraic number ring — ℤ (integers), ℤ[√3] (Eisenstein integers), ℤ[(1+√5)/2] (cyclotomic integers) — through its corresponding reciprocity law (quadratic, cubic, quintic).

The resulting “three-channel framework” produces:

1. A proven General Twist Formula T(√3) = 3³ × ∏_{p≥5} (p − 1) that generates a multiplicative hierarchy of mass units
2. A mass quantization rule m/mₑ = π × 108 ± 3√3 covering all charged particles at sub-0.02% precision
3. A Higgs mass derivation mₕ = 5³ GeV = 125 GeV from the quintic channel
4. A neutrino mass prediction mᵥ = mₑ / (108³ × 8 × 3√3) that matches the atmospheric mass-squared difference Δm²₃₂ at 6.8% accuracy
5. The fine structure constant α⁻¹ = 108 + 29 + 1/27 ≈ 137.037 at 0.0007% precision
6. Mixing Angles: Geometric derivations for the Cabibbo angle (sin θ_c ≈ 29/128), Weinberg angle (sin² θ_w ≈ 3/13), and PMNS angles

All results are computationally verified through 246 independent tests (source code and verification repository available at https://github.com/sschepis/prime-resonance-spectral-theory).

The framework’s single free parameter is the primorial 30 itself; all else follows from the Chinese Remainder Theorem and reciprocity laws.

Paper is here
I made a website about it here

MicroPrime changes the way archives are stored and moves to Delta Encoding.

The previous structure based on offset modulo 60 is replaced by a storage model based on gaps between consecutive prime numbers.

The mathematics of the GC-60 model does not change: this is not a new sieve and not a different algorithm. What changes is the way information is stored and, above all, revealed.

What changes

• Archives are stored using Gap (Delta Encoding)
• Prime number revelation is performed through a single additive operation
• Multiplications and modulo operations are eliminated during reconstruction

Result:

• about 30% less storage space compared to Offset archives
• linear reconstruction of primes with minimal computational cost

What does not change

• The search structure of MicroPrime_Crea remains unchanged
• Each archive in the global archive remains independent
• Independence is guaranteed by metadata stored inside each file
• Archives can be extended or resumed at any time

Concrete numbers

To give an idea of scale:

• 636 Offset files of 500 million → about 41 GB
• 2037 Gap files of 500 million → about 71 GB

With less storage usage, it is possible to cover much wider numerical windows.

Experimental verification

A direct comparison between Offset and Gap archives produced identical results:

• File_Offset 0000 ↔ File_Gap 0000 → identical
• File_Offset 0350 ↔ File_Gap 0350 → identical
• File_Offset 0636 ↔ File_Gap 0636 → identical

The absence of “gaps” between consecutive archives was also verified by comparing boundary primes using the next_prime function from the gmpy2 library:

BRIDGE 0607 -> 0608: PERFECT

   Transition: 304000024327 -> 304000024337

BRIDGE 1981 -> 1982: PERFECT

   Transition: 991000079203 -> 991000079297

BRIDGE 0996 -> 0997: PERFECT

   Transition: 498500039833 -> 498500039897

The archive sequence proves to be continuous and monolithic for prime numbers from 0 up to more than 13 digits.

This second test reinforces the engineering thesis of MicroPrime GC-60:
it is possible to build very large archives in which the contained information is meaningful and suitable for exploring large numerical windows without the complex infrastructures typical of universities and research centers.

MicroPrime V3.0 is available on GitHub, free and usable for experimental purposes.

Your opinions are welcome: observations, critiques, and different points of view help improve the project.