Appendix G. Geometric derivation of gravity: lattice yield limit and saturation theory

Appendix G. Geometric derivation of gravity: It is a back-substitution from the measured surface gravity of Earth at the standard reference (CODATA g₀=9.80665ms⁻²). Inserting this single number lets the saturation theorem reproduce the observed magnitude of g, but the magnitude itself is not predicted within this appendix.

It is a back-substitution from the measured surface gravity of Earth at the standard reference (CODATA g₀=9.80665ms⁻²). Inserting this single number lets the saturation theorem reproduce the observed magnitude of g, but the magnitude itself is not predicted within this appendix.

Provenance note on Ψ_yield (added in v0.2.0). The pinning value
$\Psi_{\mathrm{yield}} := \frac{9.80665}{c^{2}}$

used below is not derived microscopically from the lattice geometry. It is a back-substitution from the measured surface gravity of Earth at the standard reference (CODATA g₀=9.80665ms⁻²). Inserting this single number lets the saturation theorem reproduce the observed magnitude of g, but the magnitude itself is not predicted within this appendix.

What is derived geometrically (in the main text §17.4) is the cap mechanism, the inflow law from quantum annihilation, the equivalence principle as a result, the velocity-driven pressure law, the height-independence (Beverloo-type) of the steady cap flow, and the universality of the cap form across celestial bodies. These structural results are independent of any choice of Ψ_yield.

The honest separation between "structure derived [F]" and "absolute scale anchored from measurement [O]" is the same epistemic situation as the standard-physics hierarchy problem. See §17.4 (Gravity: cap mechanism and the four-wall theorem) for the full statement: §17.4.0 on annihilation-driven inflow as the root cause of gravity; §17.4.3 for the five-step argument that the rise-then-saturate pattern forbids a global GM/R² closure; §17.4.4 for the four-wall enumeration of why no purely microscopic chain produces 9.8m/s² as an absolute number; §17.4.6 for how the hourglass theorem explains inter-body surface gravity differences while leaving the per-body absolute value as a back-substituted input.

G.-1 Applicable regime (Gate): derivation only in the stiffness regime

All derivations in this appendix assume the stiffness regime defined in 3.2 (χ_ST=1). If, within the observation window, the fluidity index φ(P;W) is meaningfully large (i.e., stiffness failure is frequent), then the step that treats the “lattice stiffness limit” as a fixed constant is not justified, so the conclusion for that time window/protocol is treated as INCONCLUSIVE. Therefore, all upper-bound/saturation conclusions in this appendix qualify as conclusions only in regimes with φ≈ 0.

G.0 Core claim: 9.8 is the yield strength of space (the lattice)

In this theory, gravity is not “a force by which mass attracts,” but is redefined as the restoring pressure of a jammed lattice attempting to fill the Void.

Because the lattice has finite material properties (rigidity / transmission limits), there exists an upper limit on the maximum acceleration that the lattice can transmit directly to matter under contact/rest conditions. Denote this by g_* (lattice yield limit).

$g_\star \;\equiv\; c^2\,\Psi_{\rm yield} \quad\text{(corresponding to the yield strength of space / a surface-tension analogue)}$

Each body carries its own back-substituted yield value Ψ_(rm yield)^(body) (§17.4.6; Earth 9.80665/c² kept here as the canonical [INPUT] example — the per-body values are owned by the Earth–Cosmos volume's per-body appendix as of the v0.6.0 handover); at Earth's surface Ψ_(rm geom)≈Ψ_(rm yield)^((⊕)), so the representative value observed at the surface g≈ 9.8rm m/s² is interpreted not as “a value that grows without bound as mass increases,” but as a value near the lattice yield limit.

G.1 Defense logic: gravity is observed as a (2)-channel quantity, not a single component

Reports of values that appear like g>9.8 on Jupiter/the Sun (or values back-calculated from orbital data) are not an immediate contradiction. The reason is that the observation protocol (context) differs.

In this appendix, we decompose gravitational acceleration into two components (channels):

g_{\rm (concept)} \;=\; g_{\rm geom} \;+\; g_{\rm restore}.

Note (operational definition): “sum” does not mean simple addition within the same protocol.

The above decomposition does not mean “they add simultaneously in the same experiment to produce a single scale reading.” In this theory, observables branch by protocol, and the actually comparable observables are defined as follows:

$g_{\rm obs} \;=\; \begin{cases} g_{\rm geom}\ (\approx g_{\rm pot}) & \text{Orbit / Free-fall mode (free-fall/orbit)}\\ g_{\rm restore}\ (\le g_\star) & \text{Contact / Surface mode (contact/static)} \end{cases}$

That is, the component read by orbital data (far-field motion) and the component read by a scale/normal force (contact rest) are in principle different channels.

(A) (g_(rm geom)) : channel of curvature

It is the geometric curvature component created by mass deficit. It governs orbits (satellites/probes), tides, and far-field motion, and can continue to grow with mass/radius.

(B) (g_(rm restore)) : channel of restoring pressure

It is the restoring acceleration, under contact/rest conditions, by which the lattice pushes in directly to block the Void. This component is limited by the lattice rigidity (c²) and the yield curvature demand (Ψ_(rm yield)), and only this component saturates.

$0 \le g_{\rm restore} \le g_\star.$

G.2 Geometric part: identity between deficit–curvature demand–potential acceleration

G.2.1 Lattice rigidity

G.2.2 Deficit radius (geometric equivalent quantity)

Mass M corresponds to a “deficit (Void)” in the lattice; define the equivalent deficit size as

and denote it so (a geometric length scale).

G.2.3 Geometric curvature demand (unit (m⁻¹))

Define the curvature demand at distance R by

\Psi_{\rm geom}(R) \;\equiv\; \frac{R_s}{2R^2} \;=\; \frac{GM}{c^2R^2} \quad [m^{-1}]

and denote it so. Here, Ψ is not the dimensionless strain of standard elasticity, but a curvature demand (unit m⁻¹).

G.2.4 Potential curvature acceleration (Newton-equivalent)

If rigidity c² converts curvature demand into acceleration,

g_{\rm pot}(R)\;\equiv\; c^2\,\Psi_{\rm geom}(R) \;=\; \frac{GM}{R^2}.

that is, g_(rm pot) takes the same form as the conventional Newtonian curvature acceleration.

G.3 constitutive law

The key is the yield axiom: Ψ does not diverge without bound.

G.3.1 Yield curvature demand

Therefore, the curvature demand that the lattice actually “accepts” is

\Psi_{\rm eff} \;=\; \Psi_{\rm yield}\,\Phi\!\left(\frac{\Psi_{\rm geom}}{\Psi_{\rm yield}}\right)

and can be written as. Here Φ(x) is a saturation function with 0≤Φ≤ 1.

G.3.2 Hard yield (the simplest saturation)

\Phi(x)=\min(x,1) \quad\Rightarrow\quad \Psi_{\rm eff}=\min(\Psi_{\rm geom},\Psi_{\rm yield}).

Then the lattice restoring acceleration is

$g_{\rm restore} \equiv c^2\Psi_{\rm eff} = c^2\min(\Psi_{\rm geom},\Psi_{\rm yield}) = \min(g_{\rm pot},g_\star).$

G.3.3 Hourglass/Janssen-type “gentle saturation” (continuous-transition model)

In jamming/granular media (hourglass/silo), vertical stress saturates with depth; this is analogous to Janssen-type shielding. Accordingly, we allow a gentle saturation curve of the following kind.

Normalized variable:

$x \equiv \frac{g_{\rm pot}}{g_\star} = \frac{\Psi_{\rm geom}}{\Psi_{\rm yield}}.$

Representative kernel:

$\Phi_{\rm J}(x)=1-e^{-x} \quad\Rightarrow\quad g_{\rm restore}=g_\star(1-e^{-x}).$

Or (a “velocity-like” form inspired by the master-curve of hourglass discharge rate):

(However, this form tends to break the small-x linearity (Φ x); when applying directly to acceleration, a correction (e.g., linear-near matching) is required.)

G.4 Handling counterexamples (Jupiter/Sun/neutron star, etc.)

In this theory, g_* does not mean “the gravitational field is fixed to 9.8 everywhere in the universe,” but the maximum acceleration under contact/rest conditions by which the lattice can directly support matter.

(i) Moon/Mars/Earth:

If a solid surface (contact) exists and g_(rm pot)

then surface mechanics appears identical to conventional predictions.

(ii) Jupiter/Sun:

There is no solid surface (continuous fluid/plasma), so even if g_(rm pot)gg g_* is possible, a “solid-contact-based surface reference” with g_(rm restore)≤ g_* does not form. Therefore, it is difficult to define “g measured by a scale at the surface” itself. Far-field motion/orbits are explained by g_(rm geom)≈ g_(rm pot).

(iii) Near neutron stars/black holes:

g_(rm pot) becomes extremely large, but a “solid-contact-based static condition” typically collapses/transitions to fluidization/nonlinear states, and the lattice restoring-pressure component saturates at g_*. The excess is dispersed into other constraints (fluid pressure/electromagnetism/rotation/compaction stress, etc.).

G.5 Final summary (summary equations)

$\boxed{ g_{\rm pot}(R)=\frac{GM}{R^2},\quad x=\frac{g_{\rm pot}}{g_\star},\quad g_{\rm restore}=g_\star\,\Phi(x),\quad 0\le g_{\rm restore}\le g_\star }$

G.6 Deterministic verification script (reproducible output)

The script below prints, in one run, the core identities and saturation kernels (hard/gentle) of Appendix G.

import numpy as np

# =============================================================================
# [APPENDIX G] GRAVITY (CONSOLIDATED)
# =============================================================================

def f_hard_clip(x: float) -> float:
    """Hard yield clamp: f(x)=min(x,1)."""
    if x <= 0.0:
        return 0.0
    return x if x < 1.0 else 1.0

def f_soft_clip(x: float, n: float = 64.0) -> float:
    """Smooth approximation of min(x,1): f = x/(1+x^n)^(1/n)."""
    if x <= 0.0:
        return 0.0
    if n <= 0.0:
        raise ValueError("n must be > 0")
    u = -n * np.log(x)
    log_1pexp_u = np.logaddexp(0.0, u)
    log_f = -(1.0 / n) * log_1pexp_u
    return float(np.exp(log_f))

def f_tanh(x: float) -> float:
    """Generic smooth saturation: f=tanh(x)."""
    if x <= 0.0:
        return 0.0
    return float(np.tanh(x))

def f_janssen(x: float) -> float:
    """Janssen-like saturation curve: f=1-exp(-x)."""
    if x <= 0.0:
        return 0.0
    return float(1.0 - np.exp(-x))

def f_sqrt_janssen(x: float) -> float:
    """Unified discharge master-curve shape: f=sqrt(1-exp(-x))."""
    if x <= 0.0:
        return 0.0
    return float(np.sqrt(1.0 - np.exp(-x)))

def classify_regime(x: float) -> str:
    if x < 0.1:
        return "Fluid (linear)"
    if x < 1.0:
        return "Transition (0.1<=x<1)"
    if x < 3.0:
        return "Near-yield (1<=x<3)"
    return "Saturated (x>=3)"

def g_potential_newton(G: float, M: float, R: float) -> float:
    return G * M / (R ** 2)

def schwartz_radius(G: float, M: float, c2: float) -> float:
    return (2.0 * G * M) / c2

def psi_from_rs(Rs: float, R: float) -> float:
    return Rs / (2.0 * (R ** 2))

def fmt_auto(x: float, width: int = 12, prec: int = 6) -> str:
    ax = abs(x)
    if ax == 0.0:
        return f"{0:{width}.{prec}f}"
    if ax >= 1e6 or ax < 1e-3:
        return f"{x:{width}.{prec}e}"
    return f"{x:{width}.{prec}f}"

def print_header(title: str) -> None:
    print("=" * 88)
    print(title)
    print("=" * 88)

def print_section(title: str) -> None:
    print("\n" + "[" + title + "]")

def evaluate_models_for_gpot(g_pot: float, g_limit: float, models: dict[str, callable]) -> dict[str, float]:
    x = g_pot / g_limit if g_limit > 0 else np.inf
    out: dict[str, float] = {}
    for name, f in models.items():
        frac = float(f(x))
        g_restore = g_limit * frac
        if g_restore > g_limit:
            g_restore = g_limit
        out[name] = g_restore
    return out

def main() -> None:
    c = 299_792_458.0
    c2 = c ** 2
    G = 6.67430e-11

    print_header("[APP G] GRAVITY: LATTICE STIFFNESS LIMIT & SATURATION + HOURGLASS(JANSSEN)")

    M_earth = 5.9722e24
    R_earth = 6.3710e6

    g_pot_earth = g_potential_newton(G, M_earth, R_earth)
    Rs_earth = schwartz_radius(G, M_earth, c2)
    psi_earth_from_g = g_pot_earth / c2

    psi_yield_geo = psi_earth_from_g
    g_limit_geo = c2 * psi_yield_geo

    g0_standard = 9.80665
    psi_yield_std = g0_standard / c2

    YIELD_MODE = "earth"
    if YIELD_MODE.lower().startswith("earth"):
        g_limit = g_limit_geo
        psi_yield = psi_yield_geo
    else:
        g_limit = g0_standard
        psi_yield = psi_yield_std

    n_soft = 64.0
    models: dict[str, callable] = {
        "hard": lambda x: f_hard_clip(x),
        f"soft_n{int(n_soft)}": (lambda x, n=n_soft: f_soft_clip(x, n=n)),
        "tanh": lambda x: f_tanh(x),
        "janssen": lambda x: f_janssen(x),
        "sqrt_janssen": lambda x: f_sqrt_janssen(x),
    }
    kernel_names = list(models.keys())

    bodies_geom = {
        "Moon": (7.342e22, 1.7374e6),
        "Mars": (6.4171e23, 3.3895e6),
        "Earth": (M_earth, R_earth),
        "Jupiter": (1.898e27, 7.1492e7),
        "Sun": (1.989e30, 6.963e8),
        "NeutronStar": (1.4 * 1.989e30, 1.0e4),
    }

    print_section("TABLE: (M,R)->g_pot then g_restore by kernels")
    header = ["OBJECT", "g_pot", "x"] + [f"g_{k}" for k in kernel_names] + ["REGIME"]
    print(" | ".join([f"{h:<12}" for h in header]))
    print("-" * (15 * len(header)))

    for name, (M, R) in bodies_geom.items():
        Rs = schwartz_radius(G, M, c2)
        psi_geom = psi_from_rs(Rs, R)
        g_pot = c2 * psi_geom
        x = g_pot / g_limit
        g_restore = evaluate_models_for_gpot(g_pot, g_limit, models)
        regime = classify_regime(x)

        row = [name, fmt_auto(g_pot), fmt_auto(x)]
        for k in kernel_names:
            row.append(fmt_auto(g_restore[k]))
        row.append(regime)
        print(" | ".join([f"{c:<12}" for c in row]))

    print("\nEND APP G")

if __name__ == "__main__":
    main()