A New Kind of Science is often read as the idea that simple rules can generate complex behavior.

This post explores a slightly different direction:

not simple rules generating complexity, but simple constraints leaving only a very small surviving numerical structure.

In a previous post I showed that the four CODATA-level outputs of a short integer program cannot be dismissed as an ordinary fit.

This post takes a different angle: where do those numbers come from, and what kind of process generates them?

The answer is not "a formula was evaluated."

The answer is: a structural chain was opened, constraints were applied one by one, candidates were eliminated at each step, and the surviving structure produced the numbers.

Here is that process, in three steps.

Step 1. A candidate space is opened. Constraints eliminate candidates.

ClearAll["Global`*"];

roleCandidates = Range[1, 8];

survivorLog = {
  {"initial role candidates",        roleCandidates},
  {"nontrivial distinction: r >= 1", Select[roleCandidates, # >= 1 &]},
  {"re-identifiable triadic kernel: r >= 3",
                                     Select[roleCandidates, # >= 3 &]},
  {"minimal surviving kernel",
                         {Min[Select[roleCandidates, # >= 3 &]]}}
};

Grid[
  Prepend[survivorLog, {"constraint", "survivors"}],
  Frame -> All, Spacings -> {2, 1}
]

r = 3 is not inserted as a target value. It is the minimal survivor of the triadic re-identification constraint.

Step 2. The survivor propagates deterministically.

u    = 1;
r    = Min[Select[roleCandidates, # >= 3 &]];
aDir = r*(r - u);          (* directed role pairs:      6  *)
bOri = 2;                  (* boundary orientations:    2  *)
cRel = r;                  (* role-state retention:     3  *)
rel  = aDir + bOri + cRel; (* relational closure:       11 *)
n    = aDir + bOri - u;    (* oriented cycle:           7  *)
ph   = n + bOri;           (* phase inventory:          9  *)
h    = (rel + u) + n;      (* address closure:          19 *)
nStr = r + rel + ph + h;   (* total inventory:          42 *)
cap  = 2*nStr;             (* dual-slot audit capacity: 84 *)

Grid[
  {
    {"u",    u,    "minimal distinguishable unit"},
    {"r",    r,    "minimal triadic role kernel"},
    {"aDir", aDir, "directed role pairs"},
    {"bOri", bOri, "boundary orientations"},
    {"cRel", cRel, "role-state retention"},
    {"rel",  rel,  "relational closure"},
    {"n",    n,    "oriented cycle"},
    {"ph",   ph,   "phase inventory"},
    {"h",    h,    "address closure"},
    {"nStr", nStr, "total inventory"},
    {"cap",  cap,  "dual-slot audit capacity"}
  },
  Frame -> All
]

From here, the inventory is propagated by fixed structural rules.

Step 3. Only now do the readouts appear.

atten = 1 - aDir/n^2;

phi = (
  nStr*r + rel
  + r/cap
  + (rel - ph)/cap^2
  + (18/(n*Pi))*atten/cap^3
  + (4*Pi)*atten/cap^4
);

d1 = r + ph + u;
d2 = h*(nStr - (r + u));
d3 = d1*d2;
d4 = d2*(nStr - (r + u))*aDir*(rel - r);

psi1 = (
  cap*(h + r) - (ph + r)
  + (rel - ph)/d1 - u/d2 + (rel - ph)/d3 - u/d4
);

psi2 = (
  h*rel - r
  + (rel - u)/d1 - u/d2 + (r + u)/d3 + (h - r - u)/d4
);

psi3 = (
  nStr*(cap - u) - ph
  + (rel - ph)/d1 - (rel - ph)/d2 + (r + u)/d3 - (r*h)/d4
);

Grid[
  {
    {"alpha^-1 readout", NumberForm[N[phi,  20], 18],
     "CODATA 137.035 999 177(21)"},
    {"mp/me readout",    NumberForm[N[psi1, 20], 18],
     "CODATA 1836.152 673 426(32)"},
    {"mmu/me readout",   NumberForm[N[psi2, 20], 18],
     "CODATA 206.768 282 7(46)"},
    {"mtau/me readout",  NumberForm[N[psi3, 20], 18],
     "CODATA 3477.23(23)"}
  },
  Frame -> All
]

The surprise is not that a formula was evaluated.

The surprise is that the formula is downstream of a surviving structural chain — and the chain started from a single integer.

If the same surviving integer skeleton produces four independent physical readouts, should we still call it an ordinary fit?

Full framework: Finite Distinguishability Closure (FDC)

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