Encyclopedia Foundation Foundation Pair Kernel Scale Covariant Observables S20 Consumer Canonical Scale

ARTICLE 3 claims 3 theorems

Foundation Pair Kernel Scale Covariant Observables S20 Consumer Canonical Scale

A machine-checked theorem proves a single standard event exists in a scale-free system, but it does not prove that this event is unique.

Verify this page

The canonical scale-covariant consumer

In the Recognition Science framework, a ledger, a discrete record of events, can be built without choosing absolute units for duration or energy. The declaration canonicalScaleCovariantConsumer_exists is a theorem in the framework's machine-checked library of formal theorems. It establishes that, in this scale-free setting, there exists at least one standard event with a specific set of properties.

The theorem proves that a single recognition event, the basic act of registering something in the ledger, exists. This event has a normalized posting duration of exactly 1, and its normalized posting energy and action both equal its posting channel price. It occurs on a physical carrier of dimension 5, and its elapsed tick count is exactly 8. The theorem also shows that certain derived quantities, such as the ratio of the source to curvature, take on the exact value predicted by the framework's core cost function J(x) = (x + 1/x)/2 - 1.

The key point is that this is an existence proof, not a uniqueness proof. The theorem shows that at least one such event exists. It does not show that there is only one. The framework's own documentation labels the canonical branch as a MODEL witness, a definitional choice, rather than a unique consequence of the axioms. The theorem's power lies in showing that the chosen standard is consistent with the framework's laws, not in proving it is the only possible standard.

What this means in practice is that the framework can define a standard, scale-free way to talk about physical quantities like time and energy. This standard event is a reference point. But the theorem does not claim that this reference point is forced by the mathematics alone. Other valid events could exist. The theorem secures the consistency of one particular choice, leaving the question of whether that choice is special in some deeper sense as a separate matter.

In Recognition Science, this result is a building block. It allows the framework to move from abstract laws to concrete, measurable quantities. It shows that the framework can produce a definite, standard event with specific properties. But it is important to understand the limits of the claim. The existence of this event is proven. Its uniqueness is not. The theorem does not claim that the physical world must contain exactly this event and no other. It only claims that this event is a valid, consistent part of the framework's description.

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 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

What this page does not claim

The theorem does not prove that the standard event is unique. The theorem does not claim that the standard event is the one realized in the physical universe. The theorem does not establish that the framework's choice of a canonical scale is forced by the axioms.

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