Masses Mass Genesis T10 Affine Section Shape Integrated Meaning Load Not Scale I

The shape that can pick a scale

A scale is a choice of size. In physics, masses come with scales: the electron mass is a number with units, and the theory must explain why that number, not another, appears. A normalization principle is a rule that selects one scale from many possibilities. The Recognition Science framework asks what shape such a rule can have. Its machine-checked library of formal theorems has just proved a sharp answer: a rule that is invariant under rescaling cannot select a scale, while a rule that grows quadratically under rescaling can.

The negative result concerns ledger costs, the framework's discrete record of posting events. If a cost is computed from a reading that depends only on a pattern's support and topology, rescaling the pattern leaves the cost unchanged. The proof shows this invariance is exact, and therefore such a cost can never cut a section of the rescaling orbits: it cannot single out one scale. This is not a failure of a particular cost function. It is a structural fact about any cost built from such a reading. The famous Jlog cost, despite its name, is not a logarithm; it is cosh t minus 1, and a cosh does not separate scales additively the way a true logarithm would.

The positive result is the declaration named in the question. The framework defines an integratedMeaningLoad, a quantity that sums meaning across a pattern's sites. Under rescaling by a factor c, this load multiplies by c squared. The theorem proves that if you subtract a scale-invariant quantity, such as the predicted mass, the difference vanishes at exactly one positive scale on each orbit. That unique zero is the section: a rule of this shape can select a normalization. The proof is instantiated concretely: for any nontrivially loaded pattern, and for a specific gap-one worldline pattern, exactly one positive rescaling satisfies the mass law load realized condition.

What the declaration does not claim is as important as what it proves. It does not derive the actual normalization; it only proves a unique scale exists, not that a realized pattern sits at that scale. That remains an open sentence. It does not say that any candidate law passes the campaign's admission gate; it characterizes the shape a candidate must have and rules out two shapes it must not have. The ledger no-go result is conditional on the reading being posting-count only, a hypothesis about a bridge that does not yet exist. The affine result assumes both quantities are positive and says nothing about orbits through zero load.

For a reader, the consequence is a precise criterion. A scale-selecting rule must be scale-covariant of nonzero degree, not scale-invariant. The framework's own load is degree two, and its predicted mass is invariant, so their difference has the right shape. This is a theorem, machine-checked, with no unproved axioms. It does not yet tell us which scale is selected, but it tells us where to look.

/-- **No-go, invariant shape.** A quantity constant along the orbit cannot cut a
section of the orbit projection. This is the special case `ρ = 1`. -/
theorem scaleInvariant_not_cutsScaleSection
    {C : LightPattern (Fin 8) → ℝ} {ψ : LightPattern (Fin 8)}
    (h : ScaleInvariantAt C ψ) :
    ¬ CutsScaleSectionAt C ψ :=
  equivariant_not_cutsScaleSection (scaleInvariantAt_equivariant h)
    (fun _ _ => one_ne_zero)

/-- **The discriminating pair.** On one orbit: the affine constraint cuts a
section, while neither the covariant term alone nor the invariant term alone
can. A module proving only the first clause would not discriminate. -/
theorem affine_cuts_where_equivariant_cannot
    (ψ : LightPattern (Fin 8)) (hL : NontrivialNeutralLoad ψ) :
    CutsScaleSectionAt (fun χ => integratedMeaningLoad χ - predictedMass χ) ψ ∧
      ¬ CutsScaleSectionAt integratedMeaningLoad ψ ∧
        ¬ CutsScaleSectionAt predictedMass ψ := by
  refine
    ⟨exists_unique_scale_integratedMeaningLoad_eq ψ predictedMass
        (predictedMass_scaleInvariantAt ψ) (predictedMass_pos ψ) hL, ?_, ?_⟩
  · refine equivariant_not_cutsScaleSection (ρ := fun c => c ^ 2) ?_ ?_
    · intro c _
      exact integratedMeaningLoad_scalePattern c ψ
    · intro c hc
      exact pow_ne_zero 2 (ne_of_gt hc)
  · exact scaleInvariant_not_cutsScaleSection (predictedMass_scaleInvariantAt ψ)

/-- `Cost.Jlog` is `Cost.Jcost ∘ Real.exp`, so the unit posting cost is
`cosh 1 - 1`. The name means "J in logarithmic coordinates", not a logarithm of
anything, and a `cosh` does not separate a scale factor additively the way a
logarithm would. -/
theorem cost_Jlog_one_eq_cosh_sub_one : Cost.Jlog (1 : ℝ) = Real.cosh 1 - 1 :=
  Cost.Jlog_as_cosh 1

/-- **Fully concrete instantiation.** Exactly one positive rescaling of a
nontrivially loaded pattern realizes the mass law. This is an existence and
uniqueness statement about the orbit; it does not say that a realized pattern
sits at that scale, which is the open sentence. -/
theorem exists_unique_scale_massLawLoadRealized
    (ψ : LightPattern (Fin 8)) (hL : NontrivialNeutralLoad ψ) :
    ∃! c : ℝ, 0 < c ∧ MassLawLoadRealized (scalePattern c ψ) := by
  obtain ⟨c₀, ⟨hc₀, hz⟩, huniq⟩ :=
    exists_unique_scale_integratedMeaningLoad_eq ψ predictedMass
      (predictedMass_scaleInvariantAt ψ) (predictedMass_pos ψ) hL
  refine ⟨c₀, ⟨hc₀, ?_⟩, ?_⟩
  · have hz' :
        integratedMeaningLoad (scalePattern c₀ ψ)
          - predictedMass (scalePattern c₀ ψ) = 0 := hz
    show integratedMeaningLoad (scalePattern c₀ ψ) = predictedMass (scalePattern c₀ ψ)
    linarith
  · rintro c ⟨hc, hrz⟩
    refine huniq c ⟨hc, ?_⟩
    have hrz' :
        integratedMeaningLoad (scalePattern c ψ)
          = predictedMass (scalePattern c ψ) := hrz
    show integratedMeaningLoad (scalePattern c ψ)
        - predictedMass (scalePattern c ψ) = 0
    linarith

What this page does not claim

The declaration does not derive the actual normalization or say a realized pattern sits at the unique scale. The ledger no-go result applies only to posting-count readings, not to all possible bridges. The affine result assumes both quantities are positive and says nothing about zero load.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Masses/MassGenesis/T10AffineSectionShape.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: