Foundation Pair Kernel Physical Valuation Initiality S19

What S19 establishes

In the Recognition Science framework, a ledger (a discrete record of events) begins with a tick, the smallest unit of recognition. The module S19 asks a sharp question: does the structure of this ledger, by itself, force the absolute physical scale of time and energy? The answer it proves is no. The framework's counting structure fixes combinatorial facts and dimensionless ratios, but leaves the absolute size of a duration or an energy as a free choice, a calibration.

The core object is the recognition tick count, which assigns to each tick the real number of its position in the sequence: zero for the first tick, one for the next, and so on. The module proves that any real-valued function on ticks that starts at zero and adds one at each successor must equal this count. This is a uniqueness theorem, and it is the sense in which the tick structure is initial: it is the unique way to count. The same idea extends to spans of ticks. Any additive measure of a span of n ticks, one that is positive and assigns a positive value to a single tick, is uniquely determined up to multiplication by a positive constant. In plain terms, the framework forces that eight ticks have eight times the duration of one tick, but it does not force what that one tick is worth in seconds.

The module then shows that this freedom is not an accident of a weak setup. It constructs a valuation that satisfies the full structural signature: it preserves tick composition, reverse-event reciprocity, positivity, the D+2 classifier codomain, J aggregation, and a uniform energy-price relation. Even with all of that, the theorem weak_signature_admits_independent_duration_energy_scales proves that two valuations can share the same physical data and yet differ in both their duration scale and their energy scale. The same signature also admits carriers that are incomplete, extra, or misclassified. The one thing J aggregation does reject is an arbitrary rescaling of prices, which is a separate rigidity result.

What this means for the framework is precise. The initiality of the tick structure fixes the combinatorics of counting and the ratios between durations, but it does not select the absolute normalization of time or energy. The module isolates the smallest live duration semantic without naming tau0, E_coh, hbar, or a desired price in its definition. The selection of a particular operational readout, such as identifying the tick count with physical time, remains a hypothesis, not a theorem. The absolute SI scale, the bridge to seconds and joules, is proved to be an injective calibration function, not a prediction.

In practice, this result tells a reader where the framework's power stops and where its freedom begins. The framework's theorems force the structure of counting and the ratios between quantities, but the choice of units, the link to the physical SI scale, is a separate act of calibration. This is not a failure of the framework; it is a precise statement of what its initiality does and does not determine.

/-- NNO initiality uniquely selects the dimensionless zero/successor-count
map. This theorem fixes a count, not a physical time unit. -/
theorem recognitionTickCount_unique
    (clock : Tick → ℝ)
    (hzero : clock tickZero = 0)
    (hsucc :
      ∀ tick : Tick,
        clock (tickSucc tick) = clock tick + 1) :
    clock = recognitionTickCount := by
  funext tick
  have hunique :=
    tick_isNNO.recursor_unique
      (0 : ℝ) (fun value => value + 1)
      clock hzero hsucc tick
  calc
    clock tick =
        tickRecursor (0 : ℝ)
          (fun value => value + 1) tick :=
      hunique
    _ = recognitionTickCount tick :=
      tickRecursor_real_succ_eq_count tick

/-- Any two positive additive Tick-span measures differ by one positive
scalar. This is the real-valued image of NNO generator freedom. -/
theorem additiveTickSpanMeasures_unique_up_to_positive_scale
    (left right : AdditiveTickSpanMeasure)
    (hleft : 0 < left.measure 1)
    (hright : 0 < right.measure 1) :
    ∃ scale : ℝ, 0 < scale ∧
      ∀ n : ℕ,
        right.measure n = scale * left.measure n := by
  refine
    ⟨right.measure 1 / left.measure 1,
      div_pos hright hleft, ?_⟩
  intro n
  calc
    right.measure n =
        (n : ℝ) * right.measure 1 :=
      additiveTickSpanMeasure_eq_nat_mul_unit right n
    _ = (right.measure 1 / left.measure 1) *
          ((n : ℝ) * left.measure 1) := by
      field_simp [ne_of_gt hleft]
    _ = (right.measure 1 / left.measure 1) *
          left.measure n := by
      rw [additiveTickSpanMeasure_eq_nat_mul_unit left n]

/-- Two full models agree on every Recognition-side datum while differing in
both absolute scales. -/
theorem weak_signature_admits_independent_duration_energy_scales :
    ∃ left right : RecognitionPhysicalValuation3.{0} 3,
      SameRecognitionData3 left right ∧
        left.span.measure 1 ≠ right.span.measure 1 ∧
        left.energyScale ≠ right.energyScale := by
  let left : RecognitionPhysicalValuation3.{0} 3 :=
    unitRecognitionPhysicalValuation3
      (parentPhysicalChannelCarrier3 3)
  let right : RecognitionPhysicalValuation3.{0} 3 :=
    scalePhysicalValuation3
      2 2 (by norm_num) (by norm_num) left
  refine
    ⟨left, right,
      scalePhysicalValuation_sameRecognitionData
        2 2 (by norm_num) (by norm_num) left,
      ?_, ?_⟩
  · intro heq
    norm_num [left, right, unitRecognitionPhysicalValuation3,
      unitTickSpanMeasure, scalePhysicalValuation3,
      scaleTickSpanMeasure] at heq
  · intro heq
    norm_num [left, right, unitRecognitionPhysicalValuation3,
      scalePhysicalValuation3] at heq

/-- J aggregation is a real restriction: an arbitrary factor-two rescaling of
the canonical event price is rejected. -/
theorem price_rescaling_rejected_by_J_aggregation :
    ¬ PostingEventPriceReadsJAggregate3
      (parentPhysicalChannelCarrier3 3)
      (@canonicalPostingEventSurvival3 3 _)
      doubledCanonicalPostingEventChannelPrice3 :=
  doubledChannelPrice_not_JAggregate

/-- The existing dimensional theorem confirms the scope of the scale result:
absolute SI units require an external dimensional anchor. -/
theorem absolute_SI_scale_remains_calibration :
    (∀ G_input : ℝ, 0 < G_input →
      0 <
        Constants.NativeDimensionalBoundary.calibratedTickSquare
          G_input) ∧
      Function.Injective
        Constants.NativeDimensionalBoundary.calibratedTickSquare :=
  Constants.NativeDimensionalBoundary.si_bridge_is_calibration_not_prediction

What this page does not claim

This module does not prove that the framework's structure is incomplete or inconsistent. This module does not claim that the absolute SI scale is arbitrary or unphysical, only that it is not forced by the initiality structure. This module does not derive the values of tau0, E_coh, or hbar.

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