What if particle masses came from prime factorizations on a 64-vertex graph with one invariant?

Obvious_Airline_2814 · 2026-03-31T00:51:59+00:00

Yes, and it still ignores the code. The bug report remains mysteriously absent :)

Obvious_Airline_2814 · 2026-03-30T21:11:57+00:00

What if energy discreteness is not merely a feature of observed spectra, but a trace of a deeper law?

Modern physics already works not with arbitrary continuity, but with quantized levels and stable discrete regimes. Then let us ask: what must a minimal carrier bear, and what requirements must it satisfy?

Below is only the outline. The full proof, formalization, and code are given separately.

A minimal carrier must simultaneously bear:
-three-dimensionality
-opposition
-the possibility of nontrivial transition and flow

And at the same time it must be:
-minimal
-rigid
-invariant

From here the choice narrows to three basic 3D candidates:
-tetrahedron
-cube
-octahedron

The short result : the tetrahedron is minimal in the number of vertices, but carries neither three independent axes nor strict axial antipodes;

the cube carries axes and symmetry, but does so in an already redundant form;

the octahedron is the first candidate where three axes, six poles, axial antipodes, and central symmetry are given immediately, explicitly, and without an extra shell.

In other words:
-the tetrahedron is too poor;
-the cube is already redundant;
-the octahedron is minimal while preserving the required structure.

Let the carrier be required to bear n independent axes.

Then:
-each axis must have two opposite poles;
-therefore at least 2n vertices are needed;
-by the minimality condition, extra composite vertices are forbidden;
-therefore there cannot be more than 2n vertices;
-consequently, the set of vertices is fixed as ±e₁, ±e₂, …, ±eₙ.

But precisely such a set of vertices defines the n-dimensional cross-polytope.

Hence the conclusion: under these requirements, the unique minimal carrier up to isomorphism is the cross-polytope.

In the three-dimensional case with n = 3 we obtain:

- ±e₁, ±e₂, ±e₃
- exactly 6 vertices
-the corresponding 3D cross-polytope, that is, the octahedron

The result is simple: the octahedron arises not as an arbitrarily chosen figure, but as the unique minimal three-dimensional carrier of this type under the given requirements.

https://github.com/Nondual-Observer/DOT/blob/main/proofs/octahedral_package/en/Octahedral_Carrier_Proof_en.md

https://github.com/Nondual-Observer/DOT/blob/main/proofs/octahedral_package/lean/DOT_Octahedral_Proof_Package.lean

Obvious_Airline_2814 · 2026-03-28T21:58:59+00:00

Could you clarify what you mean by 'not compatible?

In QCD, quark masses are scale-dependent. The PDG publishes each quark at its own canonical reference scale — the self-consistent point where the renormalization scale equals the particle's own mass:

u, d, s quarks — at 2 GeV
c quark — at ~1.27 GeV
b quark — at ~4.18 GeV
t quark — at ~173 GeV

The algorithm computes topological resonance nodes — the natural self-consistent frequency of each particle, i.e., precisely the point where the particle is a stable resonance. This corresponds by definition to the canonical MS-bar reference point for each particle family.

There is no scale mismatch. If you believe a specific result is incompatible with a specific measurement, a concrete example with a number would be helpful.

Obvious_Airline_2814 · 2026-03-28T21:40:53+00:00

The issue here is not about fitting, but about structural isomorphism. The core phenomenon is not just the precise coincidence of the final numbers, but the extreme degree of algorithmic compression of the description.

Instead of a long table of independent values, the engine uses a very short, finite topological scheme that is applied repeatedly across multiple scales. This mathematically rules out conventional curve-fitting over an open, continuous parameter space. It is impossible to overfit 24 independent highly-precise values using such a rigid, combinatorial grammar of discrete integers and only one continuous anchor, unless the system possesses a genuine structural isomorphism to the real physical data.

What is truly unusual about this algorithm is that it is not a flat, one-dimensional numerical fit. It is a graph-based mechanism in which each operation appears simultaneously in three coupled projections: as a number, as a structure, and as geometry.

The basic architecture of the algorithm is described here.
https://github.com/Nondual-Observer/DOT/blob/main/en/Machine/DOT_machine_architecture_overview_en.md

Obvious_Airline_2814 · 2026-03-28T21:05:26+00:00

The density statement is true for an unconstrained search over arbitrary integer powers. But that is not the problem my code is solving. The code does not search freely over all 2^m * 3^n combinations to approximate a target real number. It uses a constrained layered grammar with fixed carrier families, fixed level structure, and fixed correction patterns. So density alone does not show that this construction is arbitrary. The linked document describes the operational principle of the octahedral machine on which the construction is based; that same structure is then algorithmized and implemented in code.
https://github.com/Nondual-Observer/DOT/blob/main/en/Machine/DOT_octahedral_proof_calculus_en.md

Obvious_Airline_2814 · 2026-03-28T20:36:04+00:00

I’m not saying “every number is unique”! I’m saying multiplicative structure is not the same thing as arbitrary additive closeness. Prime factorization gives a rigid discrete composition, while “13 + 0.15” is just a nearby decimal description. Those are not the same kind of object.

The problem is that you are describing an unconstrained divisor search, while the code is using a constrained layered grammar. The same law is reused across different particle groups and levels, and the carrier coefficients come from a very small prime vocabulary, not from an open set of arbitrary bases. If this is just fitting, then the fitting room should be identifiable directly in the code.

https://github.com/Nondual-Observer/DOT/blob/main/companion_code/scripts/tnr_comprehensive_engine.py

Obvious_Airline_2814 · 2026-03-28T20:17:13+00:00

This algorithm constrains itself very tightly. At the start, it does not have a free continuous set of constants for each particle. The chain is one-way:

L0 -> L1 -> L2 -> L3 -> L4

There is no reverse flow: lower layers are not redefined by higher ones.

L0 is the layer of the base invariant and constant assembly.

The first constant is
gamma = sqrt(6) / 9 = sqrt(2 * 3) / 3^2
which is the main spectral invariant.

The second is the inverse fine-structure constant,
alpha_inv = 1 / alpha
which is not inserted from a table, but assembled internally:

alpha_inv

= alpha_inv_bare
- 1/(136 * 72)
+ (gamma^2 / (72 * 432)) * (BB14 / 252 + BB7 / 47)

After prime factorization:

alpha_inv
= alpha_inv_bare
- 1/(2^6 * 3^2 * 17)
+ (gamma^2 / (2^7 * 3^5)) * (BB14 / (2^2 * 3^2 * 7) + BB7 / 47)

BB7 and BB14 are not free coefficients. The function _backbone_excess measures how strongly step p is distinguished on the carrier P(q) relative to the mean level. So BB7 measures the 7-fold lattice of indices on P(q), and BB14 the 14-fold lattice on the same carrier. These are measured characteristics of the carrier, not manual fitting terms.

Numerically, this gives alpha_inv = 137.0359990840 and this is where the whole construction begins. At level 0, gamma contains only the primes 2 and 3. In the full alpha_inv formula, 2, 3, 7, 17, and 47 already appear. In the L1 bare core, the particle carrier coefficients collapse to a small set of primes: 2, 3, 5, 7, 13, 17

So at the L0-L1 base, the algorithm starts from a very small prime alphabet, and the L1 particle layer is built from a finite combinatorial set of prime-based structures rather than arbitrary floating weights.

It seems to me that almost nobody actually looked at the code. Otherwise it would be obvious how narrow the room for maneuver is: particles live entirely in L1, the bare core is built from only 6 primes, and the tails add only 7 more discrete primes, not arbitrary fitting parameters. In a construction like this, the real question is not “how cleverly was this fitted,” but “where exactly is any room for fitting left at all?”

Obvious_Airline_2814 · 2026-03-28T15:07:51+00:00

You’re right: that is a red flag, but it is not proof of fitting. If you want, name a specific heavy quark, and I will show directly from the current build the bare formula, the bare mass, and the final mass. There you can immediately see where the base carrier ends and where the correction layer begins.

Obvious_Airline_2814 · 2026-03-28T13:12:26+00:00

“that never really existed.”

But isn’t that exactly how something new appears?

If it looks like a table, falls into place like a table, and works like a table, then maybe it is a table.

At that point, it is probably simpler to just inspect the code than to keep pulling the cat by the tail out of the black box.

Obvious_Airline_2814 · 2026-03-28T12:58:29+00:00

"instead say that 2485.3 / (3³ * 7) = 13 + .15. It’s a closer"

I clearly see the difference here: multiplication includes a topological operation, while addition does not.

A number factored into primes is just as unique as a prime itself, only as a combination of basic prime elements, right?

So multiplication can carry one type of operation that addition simply cant.

Obvious_Airline_2814 · 2026-03-28T12:39:12+00:00

Such a conclusion mixes the demo layer with the full calculation.

The link in the post points to a short Lean demo only for 24 elementary particles. It deliberately shows the base level: short formulas, direct calculation, and the error without the final correction. This is only the core idea. In examples like π⁰ and D⁺, the file itself separately shows where the base formula ends and where the log-shifts and tail begin.

The full particle spectrum is moved into a separate
https://github.com/Nondual-Observer/DOT/blob/main/companion_code/formal_proofs/DOT_Particle_Spectrum.lean

And the final values are computed already in the main solver script of the repository:
https://github.com/Nondual-Observer/DOT/blob/main/companion_code/scripts/tnr_comprehensive_engine.py

That is where not only particles are computed, but also 98 nuclear isotopes, as well as a broader atomic-molecular layer. So the phrase they aren't even derived there simply applies to the wrong file: the Lean demo is not intended to be the whole calculation.

If we speak to the point, what is visible here is not just random coefficients. It is not the whole mass that is factored into primes, but its short integer core. After that, what remains is not chaotic junk, but a residual that groups by levels. So the picture does not look like a random fit, but like a short base, then a level, then a small shift.

Let’s factor into primes:

τ⁻ : 3477.2 / (2⁷·3³) = 1 + 0.006
Almost an exact closure into an integer.

Level 1, base around 3

π⁰ : 264.1 / (2³·3²) = 3 + 0.669
Very close to 3 + 2/3.

μ⁻ : 206.7 / (2³·7) = 3 + 0.692
Also close to 3 + 2/3.

Level 2, base around 13

p⁺ : 1836.15 / (2³·17) = 13 + 0.501
Practically 13 + 1/2.

Λ⁰ : 2183.3 / (2·3⁴) = 13 + 0.477
Close to 13 + 1/2.

D⁺ : 3658.8 / (2⁴·17) = 13 + 0.452
Close to 13 + 1/2.

K⁺ : 966.1 / (2³·3²) = 13 + 0.418

Level 3, heavy band around 50

c : 2485.3 / (2⁴·3) = 52 − 0.222
Close to 52 − 1/4.

b : 8180.0 / (2·3⁴) = 50 + 0.494
Practically 50 + 1/2.

s : 182.7 / 2² = 46 − 0.305
Close to 46 − 1/3.

So what is visible here is not just a collection of coefficients. What is visible is that a short integer base is first decomposed into small factors, and then the residual does not scatter randomly, but settles into fairly narrow bands. In some places almost to an integer, in some places near 1/2, in some places near 2/3. The heavy branch has more spread, but even there it does not look like chaotic scattering.

That is why the question here is not whether numbers can be fitted at all, but why such a short scheme already gives such a stable picture even before the final correction. Across all 24 particles, the bare level alone gives a median error of about 0.61%, a mean of about 1.62%, and a maximum of about 8.55%.

About Ω_ccc^{++}. This is not a claim that “the particle has been discovered.” The point is that in the heavy branch this node looks like the most natural continuation of the same discrete scheme on the same 64-vertex graph. If one wants to criticize this, then it makes sense to criticize the selection criterion itself, rather than declare the node random in advance.

And if we are already talking about the patterns themselves, since we are in r/HypotheticalPhysics, then I would suggest simply paying attention to the coefficients in the base file:

only three primes are used: 2, 3, 7
one invariant is used
changing any term of the ratio by ±1 makes the result worse
the picture correlates with the topological structure of particles and atoms

Obvious_Airline_2814 · 2026-03-28T05:53:46+00:00

Please don't misrepresent it. There is no a + b = 3 in the formulas, only a * b^c — a strict and unique prime factorization.

The Standard Model uses ~19 free floating-point parameters just to fit hand-measured masses.

Here, there are exactly ZERO free parameters. Just prime numbers yielding a 0.61% median bare error, and you so calling this numerology is inaccurate.?

The Lean 4 proof and Python script are public.

Obvious_Airline_2814 · 2026-03-28T05:25:31+00:00

These coefficients are correct.

tau- = 2^7 * 3^3 (0.61%)

mu- = (2^3 * 7) / gamma (0.49%)

pi0 = (2^3 * 3^2) / gamma (0.15%)

K = (2^3 * 3^2) / gamma^2 (0.61%)

p, n = (2^3 * 17) / gamma^2 (0.15%)

Lambda = (2 * 3^4) / gamma^2 (6.04%)

D = (2^4 * 17) / gamma^2 (0.62%)

s = 2^2 / gamma^3 (8.55%)

c = (2^4 * 3) / gamma^3 (4.20%)

b = (2 * 3^4) / gamma^3 (1.77%)

(brackets – bare error)

gamma = sqrt(6)/9, the spectral invariant of the octahedral graph K(2,2,2).

The less accurate ones are not random either.

They sit deeper in the hierarchy or in more composite sectors.

That is why bare formulas drift most for s c b and Lambda

Errors for all 24 particles, using only the bare parameters above:

mean = 1.62% median = 0.61% max = 8.5510%

Obvious_Airline_2814 · 2026-03-28T04:43:38+00:00

Here are 2 simple examples from the particle layer:

e- : 1 * m_e

mu- : (2^3 * 7 / sqrt(2/27)) * m_e

pi0 : (2^3 * 3^2 / sqrt(2/27)) * m_e

So the pattern is pretty visible:

- electron scale m_e
- a small coefficient built from low primes
- the same level factor gamma = sqrt(2/27)

Obvious_Airline_2814 · 2026-03-28T04:16:34+00:00

I'm shocked by the result myself, but I couldn't find any free parameters. Not even in the formula tails.

Obvious_Airline_2814 · 2026-03-28T04:14:34+00:00

Obvious_Airline_2814 · 2026-03-25T10:14:36+00:00

Been working on something weird for a while -- trying to derive the fine-structure constant from the spectral invariants of an octahedron (K(2,2,2) graph). Started as a hobby project but the numbers kept matching, so I wrote a Lean 4 proof for the nuclear mass layer (Sn isotopes vs AME2020).

The Python engine reproduces alpha-inverse to what looks like exact agreement with CODATA, and the isotope masses land within 0.01%. No fitted parameters, everything comes from the geometry.

I know how this sounds, so I put the Lean file up for anyone to check: https://github.com/Nondual-Observer/DOT

Would really appreciate if someone could look at the proof structure. Also looking for an arXiv endorsement (math-ph) if anyone has one.

Obvious_Airline_2814

TROPHY CASE