Foundation Pair Kernel Recognition Transport Residuals S18

Residual boundaries

In Recognition Science, the framework's library of formal theorems models physical quantities as readouts from a discrete ledger of recognition events. A ledger, a discrete record of events, assigns numbers to durations, channel prices, and energies. The module PairKernelRecognitionTransportResidualsS18 asks a sharp question: which of these readouts are forced by the framework's own postulates, and which still depend on a choice the framework has not made?

The answer is a precise inventory. Duration reduces to factorization through an additive tick-span measure. A tick-span measure, a rule assigning a real length to each span of ticks, is additive: the length of two consecutive spans is the sum of their lengths. Additivity fixes the complete measure from its one-successor unit, but does not select that unit. The native measure and a doubled measure are both additive, and the module proves they are different. So duration readout is forced only up to a scale factor. The classical cousin is the same ambiguity that lets a clock run fast or slow without breaking its regularity.

Carrier completeness separates into two halves: no-extra injectivity and no-missing surjectivity. Each half has an independent cardinal bound and a distinct countermodel. The module shows a carrier can fail injectivity without failing surjectivity, and vice versa. Channel applicability follows from two smaller source arrows: event-local reciprocal self-similarity and factorization of event price through the uniform J-log aggregate. Neither arrow is supplied by committed posting dynamics. The module proves that if a survival function is self-similar, meaning it satisfies s = 1/(1+s), then its value is forced to be 1/φ, the reciprocal of the golden ratio.

Energy factorizes through event price only up to a positive scalar. Batch additivity and price-ratio invariance preserve that scalar, so they cannot select physical energy. The module exhibits a doubled-energy kinematics with uniform scale 2 and a cycle-distributed kinematics with uniform scale 1/8, and proves neither reads the channel price exactly. Exact readout is equivalent to fixing the scale to one. The canonical source-side objects are MODEL witnesses: they show what a readout would look like, but the arrows attaching them to physical duration, channel price, and event energy remain OPEN.

The practical consequence is a map of what remains to be proved. A reader can now see exactly which physical conclusions the framework has not yet forced, and what each missing step would require. No sorry and no new axiom appear in the module; every claim is checked by the machine. The module does not restate desired physical conclusions. It moves the residual boundary inward, showing precisely where the framework's postulates stop and the choices begin.

/-- Additivity over `ℕ` fixes the whole measure from its one-successor unit. -/
theorem additiveTickSpanMeasure_eq_nat_mul_unit
    (span : AdditiveTickSpanMeasure)
    (n : ℕ) :
    span.measure n =
      (n : ℝ) * span.measure 1 := by
  induction n with
  | zero =>
      simp [span.measure_zero]
  | succ n ih =>
      calc
        span.measure (n + 1) =
            span.measure n + span.measure 1 :=
          span.measure_add n 1
        _ = (n : ℝ) * span.measure 1 +
            span.measure 1 := by
          rw [ih]
        _ = ((n + 1 : ℕ) : ℝ) *
            span.measure 1 := by
          push_cast
          ring

theorem doubledTickSpanMeasure_ne_native :
    doubledTickSpanMeasure ≠
      nativeTickSpanMeasure := by
  intro heq
  have hunit :=
    congrArg (fun span =>
      span.measure 1) heq
  simp [doubledTickSpanMeasure,
    nativeTickSpanMeasure] at hunit

theorem eventSurvival_forced_eq_inv_phi
    {N : ℕ} [NeZero N]
    {survival : PostingEventSurvival3 N}
    (hself :
      PostingEventSurvivalSelfSimilar3 survival)
    (event : RealizedPostingEvent3 N) :
    survival event = 1 / Constants.phi :=
  (recognitionChannelsFromEventSurvival3
    survival hself event).s_forced

/-- Conversely, exact readout forces any uniform scale representation to have
scale one as soon as one positive-price event exists. -/
theorem energyReadout_forces_uniformScale_one
    {N : ℕ} [NeZero N]
    {scale : ℝ}
    {price : PostingEventChannelPrice3 N}
    {kinematics : PostingEventKinematics3 N}
    [Nonempty (RealizedPostingEvent3 N)]
    (hprice : ∀ event, 0 < price event)
    (hscale :
      PostingEnergyHasUniformPriceScale3
        scale price kinematics)
    (hread :
      PostingEnergyReadsEventChannelPrice3
        price kinematics) :
    scale = 1 := by
  let event : RealizedPostingEvent3 N :=
    Classical.choice inferInstance
  have hscaled := hscale event
  have hexact := hread event
  nlinarith [hprice event]

What this page does not claim

The module does not prove that any particular tick-span measure, energy scale, or carrier is physically realized. The module does not derive the fine-structure constant or any specific particle mass. The OPEN source arrows are not claimed to be impossible; they are targets for future derivation.

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