Foundation Pair Kernel Gap2a Common Type Bridge Decoy Unit Source Scale Ne Uniqu

Two scales, one bridge

In the Recognition Science framework, two different mathematical objects describe two different things. One, the Noether momentum map covector, lives on a simple scalar line. The other, the Gauss source covector, lives on field variations, which are functions from a finite set of sites to real numbers. These types are not directly equal. To compare them, the framework builds a bridge: it pulls the Gauss source back to the scalar line using a canonical embedding that sends a scalar to a field variation with a unit potential drop. This bridge is a definitional choice, a model, not a theorem.

Once the bridge is built, the framework asks a sharp question: for which source scale does the pulled-back Gauss source equal the Noether momentum map? The machine-checked library of formal theorems proves an equivalence: this equality holds if and only if the source scale equals a specific number, the unique cotangent coordinate. That number is not 1. The theorem decoyUnitSourceScale_ne_uniqueCotangent proves that the naive unit scale, the number 1, is not equal to the unique cotangent coordinate. The proof is simple: the unique cotangent coordinate is greater than 1, so it cannot equal 1. This is a theorem, fully checked by the machine.

What does this establish? It rules out a tempting but wrong identification. If you naively think the source scale should be 1, the framework proves you are wrong. The unit scale is a decoy. The theorem also shows that the bridge construction does not secretly choose the value 1/hbar or any other constant to force the physical identification. The normalization is forced by intertwining the unit Gauss operational reading with the identity on the scalar line, not by a desire to manufacture a particular constant.

What it does not claim is equally important. The theorem does not prove that the physical source is actually the unique cotangent. That physical equality remains an unforced premise, a typed residual. The framework isolates it as a separate condition, IdentifiesPhysicalSourceWithUniqueCotangent, which is equivalent to the equality but not derived from it. The library even proves a stronger negative: it is not the case that every source scale satisfying the current premises forces the identification. So the bridge is honest: it shows exactly what must be true for the identification to hold, and it leaves the physical step as an open premise, not a theorem.

theorem pulledBackGauss_eq_noether_iff_sourceScale_eq_uniqueCotangent
    {n : ℕ} [DecidableEq (Fin n)]
    (sourceScale : ℝ) (a b : Fin n) (hab : a ≠ b) :
    PulledBackGaussEqualsNoetherMomentumMap sourceScale a b ↔
      sourceScale = uniqueCotangentCoordinate := by
  have hpull := pulledBackGaussSource_eq_scale_smul_id sourceScale a b hab
  have hnoeth := noetherMomentumMapCovectorLinear_eq_uniqueCotangent_smul_id
  constructor
  · intro heq
    have hfun :
        sourceScale • (LinearMap.id : ℝ →ₗ[ℝ] ℝ) =
          uniqueCotangentCoordinate • (LinearMap.id : ℝ →ₗ[ℝ] ℝ) := by
      calc
        sourceScale • (LinearMap.id : ℝ →ₗ[ℝ] ℝ) =
            pulledBackGaussSource sourceScale a b := hpull.symm
        _ = noetherMomentumMapCovectorLinear := heq
        _ = uniqueCotangentCoordinate • (LinearMap.id : ℝ →ₗ[ℝ] ℝ) := hnoeth
    have h1 :=
      congrArg (fun φ : PostingDual => φ (1 : ℝ)) hfun
    simpa using h1
  · intro hs
    -- Rewrite both sides to the same `s • id` form.
    calc
      pulledBackGaussSource sourceScale a b =
          sourceScale • (LinearMap.id : ℝ →ₗ[ℝ] ℝ) := hpull
      _ = uniqueCotangentCoordinate • (LinearMap.id : ℝ →ₗ[ℝ] ℝ) := by
            rw [hs]
      _ = noetherMomentumMapCovectorLinear := hnoeth.symm

theorem decoyUnitSourceScale_ne_uniqueCotangent :
    decoyUnitSourceScale ≠ uniqueCotangentCoordinate := by
  intro h
  -- decoy = 1; uniqueCotangent = nativeActionQuantumInv > 1
  have hcot :
      uniqueCotangentCoordinate = nativeActionQuantumInv :=
    uniqueCotangentCoordinate_eq_nativeActionQuantumInv
  have hlt : (1 : ℝ) < nativeActionQuantumInv := one_lt_nativeActionQuantumInv
  have h1 : (1 : ℝ) = uniqueCotangentCoordinate := by
    simpa [decoyUnitSourceScale] using h
  exact (ne_of_lt hlt) (h1.trans hcot)

theorem remainingPhysicalEquality_unforced :
    ¬ (∀ sourceScale : ℝ,
      CurrentPremisesWithUniqueRealCotangent sourceScale →
        RemainingPhysicalEquality sourceScale) :=
  uniqueRealCotangent_does_not_force_identification

What this page does not claim

The theorem does not prove that the physical source is the unique cotangent; that identification is an unforced premise. The theorem does not derive the value of any physical constant such as 1/hbar. The theorem does not apply to any source scale other than the unit scale.

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/Foundation/PairKernelGap2aCommonTypeBridge.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: