Masses Mass Genesis T10 Directed Posting Run Scale Wall Posts Step Time Asymmetr

The scale wall

In the Recognition Science framework, a ledger is a discrete record of events, and a posting is one irreversible entry that moves value between accounts. The theorem postsStep_time_asymmetry_is_scale_covariant states a precise property of these postings: if a posting step is legal for a given amplitude, then scaling that amplitude by any nonzero factor produces another legal step, and the reverse direction remains illegal. In plainer terms, the direction of time encoded in a posting is preserved exactly when you rescale the whole system, and no rescaling can flip that direction or pick out a preferred size.

The result is one wall in a larger campaign to derive particle masses from the ledger structure. The framework's library shows that settled runs force a chronological direction, that raw seed weights scale quadratically, and that the two modular operators used to read out amplitudes are blind to the amplitude itself. The theorem under discussion bundles these facts into a single scale-covariance statement for the posting step, and it is proved in the machine-checked library of formal theorems with no gaps and no new axioms.

What the theorem does not do is construct the missing arrow from a run to a seed's sector or rung assignment. That arrow remains open, and the modular seed is an orphan sidecar: neither operator consumes the event matrix. The orientation convention that maps debit to forward and credit to backward is a model choice, not a derived identification. The literal two-quantum bridge forces amplitude one, which the intended amplitude is not, so the natural bridge candidate fails. The theorem therefore establishes a scale wall, not a path over it.

/-- Time asymmetry survives rescaling and hence fixes no scale. -/
theorem postsStep_time_asymmetry_is_scale_covariant
    {s a : ℝ} (hs : s ≠ 0) (ha : a ≠ 0)
    {L L' : Sector → ℝ} (h : PostsStep a L L') :
    PostsStep (s * a)
        (fun i => s ^ 2 * L i)
        (fun i => s ^ 2 * L' i) ∧
      ¬ PostsStep (s * a)
        (fun i => s ^ 2 * L' i)
        (fun i => s ^ 2 * L i) := by
  have hscaled := postsStep_scale_covariant s h
  exact
    ⟨hscaled,
      postsStep_asymmetric (mul_ne_zero hs ha) hscaled⟩

/-- This is the ancestry-clean time arrow supplied by `LegalAtomicTick`. -/
theorem settled_tick_directed
    (octave : Q3SettledLedgerOctave) (t : ℕ) :
    LegalAtomicTick
        (run octave.initial octave.schedule t)
        (run octave.initial octave.schedule (t + 1)) ∧
      ¬ LegalAtomicTick
        (run octave.initial octave.schedule (t + 1))
        (run octave.initial octave.schedule t) :=
  ⟨octave.every_step_legal t,
    reverse_not_legalAtomicTick (octave.every_step_legal t)⟩

theorem postingEventLoad_scale_covariant (s a : ℝ) :
    postingEventLoad (s * a) =
      s ^ 2 * postingEventLoad a := by
  unfold postingEventLoad
  ring

/-- Full operator blindness, stronger than spectral-set blindness. -/
theorem relativeModular_operator_amplitude_blind
    {a b : ℝ} (ha : a ≠ 0) (hb : b ≠ 0) :
    relativeModular a = relativeModular b := by
  funext X
  ext i j
  rw [relativeModular_apply, relativeModular_apply,
    modularEigenvalue_amplitude_blind ha hb]

theorem relativeModularSqrt_operator_amplitude_blind
    {a b : ℝ} (ha : a ≠ 0) (hb : b ≠ 0) :
    relativeModularSqrt a = relativeModularSqrt b := by
  funext X
  ext i j
  rw [relativeModularSqrt_apply,
    relativeModularSqrt_apply,
    sqrtEigenvalue_amplitude_blind ha hb]

/-- The natural two-run-quanta bridge fixes the seed input to unit amplitude. -/
theorem twoQuantumRunBridge_forces_unitAmplitude
    (octave : Q3SettledLedgerOctave) (phase : Fin 8)
    {a : ℝ} (ha : 0 < a)
    (hbridge :
      postingEventLoad a + postingEventLoad a =
        settlementLoad
          (ledgerOccupationWindow octave phase)) :
    a = 1 := by
  rw [settledLedgerOccupation_load_eq_two octave phase]
    at hbridge
  unfold postingEventLoad at hbridge
  nlinarith

theorem intendedGapOneFactorAmplitude_ne_one :
    intendedGapOneFactorAmplitude ≠ 1 := by
  intro h
  apply intendedGapOneFactorAmplitude_not_inQPhi
  rw [h]
  exact inQPhi_one

What this page does not claim

No typed arrow from a run to a seed's sector or rung assignment is constructed. The orientation convention is not a derived identification. The theorem does not provide a preferred scale or amplitude.

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/Masses/MassGenesis/T10DirectedPostingRunScaleWall.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: