Encyclopedia Foundation Foundation Pair Kernel Scale Covariant Observables S20

ARTICLE 5 claims 5 theorems

Foundation Pair Kernel Scale Covariant Observables S20

The S20 module shows that when a recognition ledger has no preferred unit of time or energy, the physical content survives in the ratios between measurements.

Verify this page

Scale-covariant observables

In Recognition Science, a ledger is a discrete record of recognition events. The S20 module addresses a problem with any such record: the numbers it stores depend on the units chosen for time and energy. A duration of eight ticks is eight seconds only if a second is the unit. The module proves that this unit dependence is harmless, because the physical content lives in the ratios between measurements, not in the absolute numbers.

The core theorem states that any positive elapsed-time observable is a tick count multiplied by one positive boundary unit. Two such observables that measure the same process differ only by a positive scale factor. The normalized ratio, the count of ticks divided by the count for one tick, is invariant under any change of that unit. The theorem elapsedTime_unique_up_to_positive_boundary_unit proves this uniqueness, and normalizedElapsedTickCount_invariant proves the ratio invariance.

The module extends this result from time alone to the full physical package. A theorem named observablePackage_unique_up_to_positive_units proves that two valuations with the same carrier, survival, and J price differ only by positive duration and energy scales. The action, the product of duration and energy, scales by the product of those two factors. This is the sense in which the framework's physical content is scale covariant: the form of the laws is unchanged by a rescaling of units.

The module also establishes a completeness condition. A physical carrier is complete when its channels give distinguishable responses and when it realizes every theorem-backed parent response. The theorem responseObservability_implies_carrierComplete proves that operational observability in this sense implies the carrier is complete. This is a bridge from what an observer can distinguish to what the framework's structure requires.

In Recognition Science, the S20 module removes the boundary-unit convention while preserving the physical content. It proves that ratios are the invariant quantities, that valuations form equivalence classes under unit rescaling, and that operational observability implies carrier completeness. The module does not select an absolute SI unit, a hydrogen datum, or an exact-J field unit. The parent-response catalog is theorem-backed; the physical realization of those responses and the distinguishability of channels remain the hypothesis boundary.

THEOREM elapsedTime_factors_through_Tick_count · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
elapsedTime_factors_through_Tick_count · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:80 
/-- Every positive elapsed-time observable is Tick count times its one-Tick
boundary unit. -/
theorem elapsedTime_factors_through_Tick_count
    (observable : PositiveElapsedTimeObservable)
    (n : ℕ) :
    observable.span.measure n =
      (n : ℝ) * observable.span.measure 1 :=
  additiveTickSpanMeasure_eq_nat_mul_unit observable.span n
THEOREM elapsedTime_unique_up_to_positive_boundary_unit · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
elapsedTime_unique_up_to_positive_boundary_unit · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:101 
/-- Any two elapsed-time observables differ by a unique positive unit ratio at
the level of all Tick spans. Existence is the physical scale-covariance
statement; the ratio is fixed by the one-Tick boundary values. -/
theorem elapsedTime_unique_up_to_positive_boundary_unit
    (left right : PositiveElapsedTimeObservable) :
    ∃ scale : ℝ, 0 < scale ∧
      scale = right.span.measure 1 / left.span.measure 1 ∧
      ∀ n : ℕ,
        right.span.measure n =
          scale * left.span.measure n := by
  obtain ⟨scale, hscale, hspan⟩ :=
    additiveTickSpanMeasures_unique_up_to_positive_scale
      left.span right.span left.unit_pos right.unit_pos
  refine
    ⟨scale, hscale, ?_, hspan⟩
  have hunit := hspan 1
  change
    right.span.measure 1 =
      scale * left.span.measure 1 at hunit
  apply (eq_div_iff left.unit_pos.ne').2
  nlinarith
THEOREM normalizedElapsedTickCount_invariant · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
normalizedElapsedTickCount_invariant · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:140 
/-- All dimensionless time ratios are invariant under the choice of positive
boundary unit. -/
theorem normalizedElapsedTickCount_invariant
    (left right : PositiveElapsedTimeObservable)
    (n : ℕ) :
    normalizedElapsedTickCount left n =
      normalizedElapsedTickCount right n := by
  rw [normalizedElapsedTickCount_eq_count,
    normalizedElapsedTickCount_eq_count]
THEOREM observablePackage_unique_up_to_positive_units · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
observablePackage_unique_up_to_positive_units · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:566 
/-- Two representatives of one observable class differ by exactly one
positive duration unit and one positive energy unit. -/
theorem observablePackage_unique_up_to_positive_units
    {N : ℕ} [NeZero N]
    {left right : RecognitionPhysicalValuation3 N}
    (hsame : SameRecognitionData3 left right) :
    ∃ durationScale energyScale : ℝ,
      0 < durationScale ∧
        0 < energyScale ∧
        (∀ n : ℕ,
          right.span.measure n =
            durationScale * left.span.measure n) ∧
        right.energyScale =
          energyScale * left.energyScale ∧
        (∀ event : RealizedPostingEvent3 N,
          right.kinematics.duration event.1 =
            durationScale *
              left.kinematics.duration event.1) ∧
        (∀ event : RealizedPostingEvent3 N,
          right.kinematics.energy event.1 =
            energyScale *
              left.kinematics.energy event.1) ∧
        (∀ event : RealizedPostingEvent3 N,
          postingEventAction3 right.kinematics event.1 =
            (durationScale * energyScale) *
              postingEventAction3
                left.kinematics event.1) := by
  let durationScale :=
    right.span.measure 1 / left.span.measure 1
  let energyScale :=
    right.energyScale / left.energyScale
  have hdurationScale :
      0 < durationScale :=
    div_pos right.span_unit_pos left.span_unit_pos
  have henergyScale :
      0 < energyScale :=
    div_pos right.energyScale_pos left.energyScale_pos
  have hspan :
      ∀ n : ℕ,
        right.span.measure n =
          durationScale * left.span.measure n := by
    intro n
    calc
      right.span.measure n =
          (n : ℝ) * right.span.measure 1 :=
        additiveTickSpanMeasure_eq_nat_mul_unit
          right.span n
      _ = durationScale *
          ((n : ℝ) * left.span.measure 1) := by
        dsimp [durationScale]
        field_simp [left.span_unit_pos.ne']
      _ = durationScale *
          left.span.measure n := by
        rw [additiveTickSpanMeasure_eq_nat_mul_unit
          left.span n]
  have henergyScaleEq :
      right.energyScale =
        energyScale * left.energyScale := by
    dsimp [energyScale]
    field_simp [left.energyScale_pos.ne']
  have hduration :
      ∀ event : RealizedPostingEvent3 N,
        right.kinematics.duration event.1 =
          durationScale *
            left.kinematics.duration event.1 := by
    intro event
    calc
      right.kinematics.duration event.1 =
          right.span.measure 1 :=
        tickSpanFactorization_eventDuration_eq_unit
          right.duration_factors event
      _ = durationScale * left.span.measure 1 :=
        hspan 1
      _ = durationScale *
          left.kinematics.duration event.1 := by
        rw [tickSpanFactorization_eventDuration_eq_unit
          left.duration_factors event]
  have hprice :
      right.price = left.price :=
    hsame.2.2.symm
  have henergy :
      ∀ event : RealizedPostingEvent3 N,
        right.kinematics.energy event.1 =
          energyScale *
            left.kinematics.energy event.1 := by
    intro event
    calc
      right.kinematics.energy event.1 =
          right.energyScale * right.price event :=
        right.energy_scaled event
      _ = (energyScale * left.energyScale) *
          left.price event := by
        rw [henergyScaleEq, hprice]
      _ = energyScale *
          left.kinematics.energy event.1 := by
        rw [left.energy_scaled event]
        ring
  refine
    ⟨durationScale, energyScale,
      hdurationScale, henergyScale,
      hspan, henergyScaleEq,
      hduration, henergy, ?_⟩
  intro event
  unfold postingEventAction3
  rw [hduration event, henergy event]
  ring
THEOREM responseObservability_implies_carrierComplete · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
responseObservability_implies_carrierComplete · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:359 
/-- Operational response observability discharges both S18 carrier halves. -/
theorem responseObservability_implies_carrierComplete
    {N : ℕ} [NeZero N]
    {system : PostingPhysicalResponseSystem3 N}
    (hobservable :
      PostingCarrierResponseObservability3 system) :
    PostingCarrierCoherenceComplete3 system.physical := by
  apply
    (carrierComplete_iff_injective_and_surjective
      system.physical).2
  exact
    ⟨responseDistinguishability_implies_parentInjective
        hobservable.1,
      responseRealization_implies_parentSurjective
        hobservable.2⟩

What this page does not claim

The S20 module does not select an absolute SI unit, hydrogen datum, or exact-J field unit. The physical realization of parent responses is not proved; it remains a hypothesis boundary. The module does not claim that all observable quantities are scale invariant, only the normalized ratios.

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/PairKernelScaleCovariantObservablesS20.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