Encyclopedia Foundation Foundation Pair Kernel Scale Covariant Observables S20 Observable Carrier And Re

ARTICLE 4 claims 4 theorems

Foundation Pair Kernel Scale Covariant Observables S20 Observable Carrier And Re

A theorem in the Recognition Science library shows that physical observables like duration and energy are fixed by the theory up to a choice of positive units, and that ratios of elapsed time are unit-free.

Verify this page

Scale-covariant readouts

In physics, a measurement of duration or energy always comes with a unit: seconds, joules, or some other scale. The Recognition Science framework, a body of formal theorems about a discrete record of events called a ledger, asks what structure survives when that unit choice is removed. The answer, proved in its machine-checked library, is that the physical content of an observable is exactly what stays the same when you rescale all durations by one positive factor and all energies by another. Two valuations that agree on the ledger's events, its survival structure, and its price function differ only by those two positive unit scales, and nothing else.

The theorem observablePackage_unique_up_to_positive_units states this precisely. For any two physical valuations with the same recognition data, there exist positive numbers durationScale and energyScale such that every elapsed time in the second valuation is the first times the duration scale, every energy is the first times the energy scale, and every action, the product of duration and energy, scales by the product of the two. This is a uniqueness result: the unit choice is the only freedom. The framework does not select an absolute SI unit, a hydrogen atom datum, or a field unit. It also proves that normalized elapsed tick counts, the ratio of elapsed time to the time of one tick, are invariant under any such rescaling, so ratios of elapsed time are unit-free.

The theorem also covers the carrier, the system that realizes the ledger's responses. If responses distinguish channels and realize every parent response, then the carrier is complete in an operational sense. The parent-response catalog itself is a theorem; the physical realization of those responses and the distinguishability of channels remain the exact hypothesis boundary. The nonlinear exact-J response exports a dimensionless source-to-curvature ratio, equal to the tangent Green scale, and at unit drop this ratio equals the hyperbolic tangent of one.

What the declaration does not claim is as important as what it proves. It does not claim that any particular physical system realizes the carrier responses; that is a hypothesis, not a theorem. It does not claim that the framework selects a preferred unit system, because the whole point of the scale-covariance result is that no such selection exists. It does not claim that the framework derives the fine-structure constant or any other absolute coupling. The theorem's reach is structural: it pins down the observable content up to units, and it leaves the physical realization of that content open.

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 unitEquivalent_normalizedTick_invariant · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
unitEquivalent_normalizedTick_invariant · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:673 
/-- Dimensionless Tick counts are functions on observable classes. -/
theorem unitEquivalent_normalizedTick_invariant
    {N : ℕ} [NeZero N]
    {left right : RecognitionPhysicalValuation3 N}
    (_hsame : SameRecognitionData3 left right)
    (n : ℕ) :
    left.span.measure n / left.span.measure 1 =
      right.span.measure n / right.span.measure 1 := by
  calc
    left.span.measure n / left.span.measure 1 =
        (n : ℝ) := by
      rw [additiveTickSpanMeasure_eq_nat_mul_unit]
      field_simp [left.span_unit_pos.ne']
    _ = right.span.measure n /
        right.span.measure 1 := by
      rw [additiveTickSpanMeasure_eq_nat_mul_unit]
      field_simp [right.span_unit_pos.ne']
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⟩
THEOREM tangentGreenScale_eq_exactJGreenRatio · exactJGreenRatioAtDrop_eq_tanh · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean
tangentGreenScale_eq_exactJGreenRatio · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:768 
/-- The constant-curvature tangent Green scale is exactly the
source-to-curvature ratio after the ordered-edge factor two is accounted for. -/
theorem tangentGreenScale_eq_exactJGreenRatio
    (drop : ℝ) :
    realGreenScaleFromPostingMagnitude
        ((2 * exactJOneEdgeSourceAtDrop drop) /
          exactJCurvatureAtDrop drop) =
      exactJGreenRatioAtDrop drop := by
  change
    realGreenScaleFromPostingMagnitude
        ((2 * exactJVariationalSource drop) /
          Real.cosh drop) =
      exactJVariationalSource drop / Real.cosh drop
  unfold realGreenScaleFromPostingMagnitude
  ring
exactJGreenRatioAtDrop_eq_tanh · IndisputableMonolith/Foundation/PairKernelScaleCovariantObservablesS20.lean:761 
theorem exactJGreenRatioAtDrop_eq_tanh
    (drop : ℝ) :
    exactJGreenRatioAtDrop drop =
      Real.tanh drop := by
  rw [Real.tanh_eq_sinh_div_cosh]
  rfl

What this page does not claim

The theorem does not claim that any particular physical system realizes the carrier responses. The framework does not select an absolute SI unit, a hydrogen datum, or a field unit. The declaration does not derive the fine-structure constant or any other absolute coupling constant.

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