Encyclopedia Foundation Foundation Pair Kernel Scale Covariant Observables S20 Consumer

ARTICLE 4 claims 3 theorems 1 model

Foundation Pair Kernel Scale Covariant Observables S20 Consumer

A machine-checked module that defines how physical measurements stay meaningful when units are stripped away, and what survives the stripping.

Verify this page

Scale-covariant readout

A scale-covariant observable is a measurement that changes predictably when you change its units, like saying a table is 2 meters long or 200 centimeters long: the number changes, the physical fact does not. The ledger, a discrete record of recognition events, keeps its physical content only if its observables behave this way. The module PairKernelScaleCovariantObservablesS20Consumer is a machine-checked collection of formal theorems that tests exactly this: it defines the standard way to read elapsed time, energy, and action out of the ledger after absolute duration and energy units have been moved to explicit boundary inputs, and it proves which statements survive that move.

The central result is a theorem, canonicalScaleCovariantConsumer_exists, which proves that a realized posting event exists with normalized duration equal to 1, normalized energy equal to the channel price, normalized action equal to the same price, and a physical carrier dimension of 5. A second theorem, predictionReady_exactJGreen_ratios, proves a family of exact ratios: the Green ratio at the canonical drop equals sqrt(hbar*(hbar+2))/(1+hbar), the ratio at 1 equals tanh(1), and the curvature times the Green ratio equals the one-edge source at every drop. These are not numerical approximations; they are proved equalities in the framework's library of formal theorems.

The module also proves an asymmetry that matters for what the framework can claim. The theorem actionQuotient_consumer shows that dimensionless action ratios survive the unit quotient, but equality between a physical event's absolute action and the dimensionless constant hbar = phi^-5 does not survive. In plain terms: you can compare two actions as a ratio, but you cannot say an action equals a pure number once units are involved. The numeral hbar and its D+2 exponent do survive, which is why the exact-J ratios above remain prediction-ready.

The module re-exports earlier results unchanged: the S13 nonlinear Gauss law, tangent Hessian, and real Green attachment compile through S20 with only their exposed coordinates changed, not their mathematics. The canonical branch is explicitly a MODEL witness, meaning it defines a representative instance of the scale-covariant interface rather than proving uniqueness. The theorem-backed exports are the normalized tick ratios, response-derived D+2 completeness, unit-quotient invariance, and the exact-J source/curvature Green ratio.

What this changes for a reader: the framework can now state, with machine-checked proofs, which physical readouts are stable under unit changes and which are not. The distinction between dimensionless ratios and absolute equalities is not a philosophical preference but a proved structural fact about the ledger's observables.

MODEL canonicalScaleCovariantPostingReadoutSemantics3 · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean
canonicalScaleCovariantPostingReadoutSemantics3 · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean:41 
def canonicalScaleCovariantPostingReadoutSemantics3 :
    ScaleCovariantPostingReadoutSemantics3
      (classifiedPhysicalResponseSystem3
        (parentPhysicalChannelCarrier3 3))
      (@canonicalPostingEventSurvival3 3 _)
      (@canonicalPostingEventChannelPrice3 3 _)
      (canonicalCoherenceKinematics3 3) where
  elapsed := canonicalElapsedTimeObservable
  duration_reads :=
    operationalTickCount_implies_unitSpanFactorization
      canonicalKinematics_operationalTickCount_model
  carrier_observable :=
    parentResponseSystem_observable_model
  survival_selfSimilar :=
    canonicalPostingEventSurvival_selfSimilar
  price_reads_JAggregate :=
    canonicalPostingEventPrice_reads_JAggregate
  energyBoundaryUnit := 1
  energyBoundaryUnit_pos := by norm_num
  energy_reads := canonicalEnergy_has_uniformScale_one
THEOREM canonicalScaleCovariantConsumer_exists · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean
canonicalScaleCovariantConsumer_exists · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean:62 
/-- MODEL consumer: the canonical representative inhabits the
scale-covariant interface, while every exported numeric statement has had its
duration and energy boundary units divided out. -/
theorem canonicalScaleCovariantConsumer_exists :
    ∃ event : RealizedPostingEvent3 3,
      normalizedPostingDuration3
          canonicalScaleCovariantPostingReadoutSemantics3
          event.1 = 1 ∧
        normalizedPostingEnergy3
          canonicalScaleCovariantPostingReadoutSemantics3
          event.1 =
            canonicalPostingEventChannelPrice3 event ∧
        normalizedPostingAction3
          canonicalScaleCovariantPostingReadoutSemantics3
          event.1 =
            canonicalPostingEventChannelPrice3 event ∧
        physicalPostingCarrierDimension3
          (parentPhysicalChannelCarrier3 3) event = 5 ∧
        normalizedElapsedTickCount
          canonicalElapsedTimeObservable 8 = 8 := by
  obtain ⟨pair, hpair⟩ :=
    realizedPrimitivePostingPair3_exists
  let event : RealizedPostingEvent3 3 :=
    ⟨pair, hpair⟩
  refine
    ⟨event,
      normalizedPostingDuration_eq_one
        canonicalScaleCovariantPostingReadoutSemantics3 event,
      normalizedPostingEnergy_eq_price
        canonicalScaleCovariantPostingReadoutSemantics3 event,
      normalizedPostingAction_eq_price
        canonicalScaleCovariantPostingReadoutSemantics3 event,
      ?_,
      elapsedTime_octave_ratio
        canonicalElapsedTimeObservable⟩
  exact
    scaleCovariantReadout_dimension_eq_five
      canonicalScaleCovariantPostingReadoutSemantics3 event
THEOREM predictionReady_exactJGreen_ratios · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean
predictionReady_exactJGreen_ratios · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean:101 
/-- Prediction-ready exact-J ratios. The native and ledger field-unit
branches remain separate evaluations of the same scale-covariant law. -/
theorem predictionReady_exactJGreen_ratios :
    exactJGreenRatioAtDrop nativeActionCanonicalDrop =
        Real.sqrt
            (Constants.hbar * (Constants.hbar + 2)) /
          (1 + Constants.hbar) ∧
      realGreenScaleFromPostingMagnitude
          (nativeOrderedExactJSource /
            (1 + Constants.hbar)) =
        exactJGreenRatioAtDrop nativeActionCanonicalDrop ∧
      exactJGreenRatioAtDrop 1 = Real.tanh 1 ∧
      (∀ drop : ℝ,
        exactJCurvatureAtDrop drop *
            exactJGreenRatioAtDrop drop =
          exactJOneEdgeSourceAtDrop drop) ∧
      GapDerivation.configDim GapDerivation.D = 5 := by
  refine ⟨?_, ?_, ?_, exactJGreenRatio_reciprocity, ?_⟩
  · rw [nativeExactJGreenRatio_eq,
      nativeExactJConjugateSource_eq_sqrt]
  · calc
      realGreenScaleFromPostingMagnitude
          (nativeOrderedExactJSource /
            (1 + Constants.hbar)) =
          nativeExactJConjugateSource /
            (1 + Constants.hbar) :=
        nativeCurvatureTangentGreenScale
      _ = exactJGreenRatioAtDrop
          nativeActionCanonicalDrop :=
        nativeExactJGreenRatio_eq.symm
  · exact exactJGreenRatioAtDrop_eq_tanh 1
  · exact GapDerivation.configDim_at_D3
THEOREM actionQuotient_consumer · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean
actionQuotient_consumer · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20Consumer.lean:134 
/-- The quotient result is intentionally asymmetric: dimensionless action
ratios survive, while equality between a physical event's absolute action and
the dimensionless RS `hbar = phi^-5` numeral does not survive the full
duration-energy unit quotient. The numeral and its D+2 exponent do survive. -/
theorem actionQuotient_consumer :
    (∃ left right : RecognitionPhysicalValuation3.{0} 3,
      SameRecognitionData3 left right ∧
        ∃ event : RealizedPostingEvent3 3,
          postingEventAction3 left.kinematics event.1 ≠
            postingEventAction3 right.kinematics event.1) ∧
      (∀ left right : RecognitionPhysicalValuation3.{0} 3,
        SameRecognitionData3 left right →
          ∀ first second : RealizedPostingEvent3 3,
            postingEventAction3 left.kinematics first.1 *
                postingEventAction3 right.kinematics second.1 =
              postingEventAction3 left.kinematics second.1 *
                postingEventAction3 right.kinematics first.1) :=
  ⟨absolute_eventAction_not_unit_invariant,
    fun _ _ hsame =>
      unitEquivalent_action_ratio_invariant hsame⟩

What this page does not claim

The module does not prove that the canonical observable is unique; it is a MODEL witness. The module does not derive the fine-structure constant or any coupling constant. The module does not claim that absolute action equals hbar; it proves the opposite does not survive the unit quotient.

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

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND