Masses Mass Genesis T10 Orbit Section No Go Scale Blind Fragment Not Recognition

The scale-blind limit

In the Recognition Science account, a realized pattern is a discrete record of events, and a ground state is the special pattern a system settles into when its recognition cost, the forced price of maintaining that record consistent, is zero. A natural question is whether the ground state can be identified by a rule that only cares about the shape of a pattern, not its size. The formal result scaleBlindFragment_not_recognitionGroundStateSelection answers no: any predicate on patterns that is closed under positive rescaling, meaning if it accepts a pattern it also accepts every uniformly scaled copy, cannot be a ground-state selection rule as soon as it accepts at least one valid carrier pattern.

The proof is a doubling counterexample. Start with any accepted carrier pattern. Because every positive-rescaling orbit contains exactly one zero-cost point, rescale that carrier onto its orbit's zero, then double it. The doubled pattern still has ratio four to the original, and the rescaling-closed predicate still accepts it, yet the recognition cost at ratio four is not zero. A rule that cannot tell a pattern from its double cannot enforce the unique amplitude that a settled state demands. The same argument, with the same conclusion, holds for the stronger notion of a scale-blind predicate that treats a pattern and all its rescalings as equivalent.

The scope is precise. This is a statement about the rescaling-closed fragment, not an independence result about the whole foundation. The foundation is not scale-blind: a derived, load-side predicate, ledger occupancy being two-valued so a settlement anchor window is Boolean, lies outside the fragment and forces the settled amplitude to exactly one. An independence claim quantified over the entire foundation would be false; the library records that such a claim was refuted on 2026-07-27. The theorem also carries its load-bearing hypotheses: dropping the accepted-carrier condition admits the empty predicate, which vacuously satisfies ground-state selection, and dropping the same-zero-set condition in the companion no-go admits a constraint that fails the selection rule.

What this changes is the search space for a ground-state law. A candidate rule stated only in terms of pattern topology, with no amplitude information, cannot be the whole story. The settled amplitude must come from somewhere else, and the library shows it comes from the two-valued occupancy of the ledger, not from scale-invariant shape alone.

/-- **No-go 2 (the scale-blind fragment floor).** No predicate on patterns that
is closed under positive rescaling can serve as a realization predicate
satisfying `RecognitionGroundStateSelection`, once it accepts a single Q3
carrier.

This generalizes `jointScaleInvariantSelector_does_not_force_amplitude` in three
directions: from amplitude selectors to arbitrary pattern predicates, from
invariance to mere closure, and from the amplitude equation to R4 itself. It
carries no emission-layer side condition.

**Scope.** The quantifier ranges over the rescaling-closed fragment, and that
fragment is proper: see `booleanOccupancy_is_derived_and_not_scaleBlind`. This
is therefore not an independence statement about the present foundation, and
must not be read or reported as one. -/
theorem scaleBlindFragment_not_recognitionGroundStateSelection
    (Realized : LightPattern (Fin 8) → Prop)
    (hP : IsRescalingClosedPatternPredicate Realized)
    {ψ : LightPattern (Fin 8)}
    (E : Q3ClosedPatternEvidence ψ)
    (hacc : Realized ψ) :
    ¬ RecognitionGroundStateSelection Realized := by
  intro hR4
  obtain ⟨χ, hPχ, ⟨Eχ⟩, hratio⟩ :=
    rescalingClosedPredicate_accepts_ratioFour_carrier Realized hP E hacc
  have hcost0 : loadRecognitionCost χ = 0 :=
    (orbitSection_groundStateSelection_pointwise Eχ).1
      (fun c hc => hR4 χ hPχ c hc)
  exact loadRecognitionCost_ne_zero_of_loadTopologyRatio_four hratio hcost0

private theorem loadRecognitionCost_ne_zero_of_loadTopologyRatio_four
    {χ : LightPattern (Fin 8)} (h : loadTopologyRatio χ = 4) :
    loadRecognitionCost χ ≠ 0 := by
  intro hzero
  have hJ : Jcost (4 : ℝ) = 0 := by
    unfold loadRecognitionCost at hzero
    rwa [h] at hzero
  have h1 : (4 : ℝ) = 1 := (Jcost_eq_zero_iff (4 : ℝ) (by norm_num)).1 hJ
  norm_num at h1

/-- **The scope statement for no-go 2.** There is a derived, load-side predicate
of the present foundation which is outside the rescaling-closed fragment *and*
which fixes an absolute amplitude: a settled anchor whose window is Boolean has
posting amplitude exactly one.

So the foundation is not silent about the normalization and no-go 2 must never
be reported as independence from it. The honest reading is narrower and still
useful: nothing inside the scale-blind fragment can supply the missing sentence,
so a derivation has to come from the part of the foundation this predicate
inhabits. -/
theorem booleanOccupancy_is_derived_and_not_scaleBlind :
    ¬ IsRescalingClosedPatternPredicate BooleanSettledAnchorWindow ∧
      ∀ (a : ℝ) (χ : LightPattern (Fin 8)),
        SettledAnchorWindow a χ → BooleanSettledAnchorWindow χ → 0 < a →
          a = 1 :=
  ⟨booleanSettledAnchorWindow_not_rescalingClosed,
    fun _a _χ hwin hbool ha =>
      settledAnchor_boolean_forces_unitAmplitude hwin hbool ha⟩

/-- Deleting the accepted-carrier hypothesis from no-go 2 makes it false. The
empty realization predicate is rescaling-closed and satisfies R4 vacuously, so
the no-go bites exactly on predicates that accept some matter. -/
theorem acceptedCarrier_hypothesis_is_load_bearing :
    IsRescalingClosedPatternPredicate (fun _ => False) ∧
      RecognitionGroundStateSelection (fun _ => False) :=
  ⟨fun _ _ _ h => h.elim, fun _ h => h.elim⟩

What this page does not claim

Not an independence result for the whole foundation, only for the rescaling-closed fragment. Does not say no ground-state selection rule exists at all. Does not identify which specific predicate is the correct ground-state rule.

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/T10OrbitSectionNoGo.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: