InformationTheory

InformationTheory.Shannon.EPI.Case1.TwoTime.MonotonicityAndSaturation

source

EPI case-1 two-time object — endpoints, antitonicity, Gaussian saturation (§4) #

The endpoint continuity twoTimeLogRatioGap_continuousWithinAt_zero, the antitonicity twoTimeLogRatioGap_antitoneOn_Ici_zero, and the Gaussian-saturation limit twoTimeLogRatioGap_tendsto_zero_atTop (the gap tends to 0 as t → ∞ along the matched paths), together with the heat-flow scaling and rescaled-path saturation machinery feeding the limit. Verbatim split of TwoTime.lean §4 (monotonicity / saturation part); proofs unchanged. Builds on the gap object and its derivative in TwoTime.GapDerivative. Umbrella: TwoTime.lean.

§4 — Endpoints, antitonicity, EPI bridge #

theorem

InformationTheory.Shannon.EPICase1TwoTime.twoTimeLogRatioGap_continuousWithinAt_zero

source
{Ω : Type u_1} { : MeasurableSpace Ω} (X Y Z_X Z_Y Z : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] {J_X J_Y s r : } (hX : Measurable X) (hY : Measurable Y) (hZX : Measurable Z_X) (hZY : Measurable Z_Y) (hZ : Measurable Z) (hZX_law : MeasureTheory.Measure.map Z_X P = ProbabilityTheory.gaussianReal 0 1) (hZY_law : MeasureTheory.Measure.map Z_Y P = ProbabilityTheory.gaussianReal 0 1) (hZ_law : MeasureTheory.Measure.map Z P = ProbabilityTheory.gaussianReal 0 1) (hXY_ZXZY_pair : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) (fun (ω : Ω) => (Z_X ω, Z_Y ω)) P) (hXY_Z : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) Z P) (hZX_ZY : ProbabilityTheory.IndepFun Z_X Z_Y P) (h_path_X : IsMatchedTimePath X Z_X P J_X s) (h_path_Y : IsMatchedTimePath Y Z_Y P J_Y r) (h_pos : ∀ (t : ), 0 < t0 < s t 0 < r t) (h_endpt_sum : IsHeatFlowEndpointRegular (fun (ω : Ω) => X ω + Y ω) Z P) :
ContinuousWithinAt (fun (t : ) => twoTimeLogRatioGap X Y Z_X Z_Y P s r t) (Set.Ioi 0) 0

TT-_continuousWithinAt_zero — the two-time gap is continuous at the left endpoint t = 0 (within Ioi 0).

The log N(s(t),r(t)) term is continuous via the matched-path continuity (IsMatchedTimePath.cont) + heat-flow endpoint continuity (heatFlowEntropyPower_continuousWithinAt_zero); the −t term is continuous. Mirrors csiszarLogRatioGap_continuousWithinAt_zero (EPI/Stam/ToBridge.lean).

Mechanism. On Set.Ioi 0 (where the matched velocities give s t, r t > 0), matchedSum_law_eq rewrites the two-time sum heat flow into the single-noise heat flow of X + Y at τ = s t + r t: sumHeatFlowEP X Y Z_X Z_Y P (s t)(r t) = heatFlowEP (X+Y) Z P (s t + r t). This eventual equality (on a neighborhood of 0 within Ioi 0) lets us transfer the continuity via ContinuousWithinAt.congr. The reduced single-noise heat flow is the composition of the endpoint continuity atom heatFlowEntropyPower_continuousWithinAt_zero with the continuous matched reparameterization τ(t) = s t + r t (IsMatchedTimePath.cont).

Added preconditions are regularity:

  • IsHeatFlowEndpointRegular (X+Y) Z P — the single-noise endpoint atom's input.
  • the matchedSum_law_eq preconditions (unit-noise laws of Z_X, Z_Y, Z, the joint/pairwise independences, measurability) — noise-distribution facts, not bundled EPI/derivative content.
  • h_pos : ∀ t, 0 < t → 0 < s t ∧ 0 < r t — the matched-path positivity on the interior (the strict-mono inverse-function path satisfies it), threaded as a precondition exactly as _hasDerivAt threads hst/hrt. @audit:ok
Used by
    theorem

    InformationTheory.Shannon.EPICase1TwoTime.twoTimeLogRatioGap_antitoneOn_Ici_zero

    source
    {Ω : Type u_1} { : MeasurableSpace Ω} (X Y Z_X Z_Y Z : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] {J_X J_Y s r : } (hX : Measurable X) (hZX : Measurable Z_X) (hXZX : ProbabilityTheory.IndepFun X Z_X P) (hY : Measurable Y) (hZY : Measurable Z_Y) (hYZY : ProbabilityTheory.IndepFun Y Z_Y P) (hZ : Measurable Z) (hZ_law : MeasureTheory.Measure.map Z P = ProbabilityTheory.gaussianReal 0 1) (hXYZ : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) Z P) (hZX_law : MeasureTheory.Measure.map Z_X P = ProbabilityTheory.gaussianReal 0 1) (hZY_law : MeasureTheory.Measure.map Z_Y P = ProbabilityTheory.gaussianReal 0 1) (hXY_ZXZY_pair : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) (fun (ω : Ω) => (Z_X ω, Z_Y ω)) P) (hZX_ZY : ProbabilityTheory.IndepFun Z_X Z_Y P) (h_path_X : IsMatchedTimePath X Z_X P J_X s) (h_path_Y : IsMatchedTimePath Y Z_Y P J_Y r) (h_reg_X : StamEPIBridge.IsDeBruijnRegularityHyp X Z_X P) (h_reg_Y : StamEPIBridge.IsDeBruijnRegularityHyp Y Z_Y P) (h_reg_sum : StamEPIBridge.IsDeBruijnRegularityHyp (fun (ω : Ω) => X ω + Y ω) Z P) (h_endpt_sum : IsHeatFlowEndpointRegular (fun (ω : Ω) => X ω + Y ω) Z P) (h_pos : ∀ (t : ), 0 < t0 < s t 0 < r t) (h_per_t : ∀ (t : ), 0 < t∀ (hst : 0 < s t) (hrt : 0 < r t), J_X (s t) = FisherInfo.fisherInfoOfDensityReal (h_reg_X.reg_at (s t) hst).density_t J_Y (r t) = FisherInfo.fisherInfoOfDensityReal (h_reg_Y.reg_at (r t) hrt).density_t 0 < J_X (s t) 0 < J_Y (r t) 0 < FisherInfo.fisherInfoOfDensityReal (h_reg_sum.reg_at (s t + r t) ).density_t 1 / FisherInfo.fisherInfoOfDensityReal (h_reg_sum.reg_at (s t + r t) ).density_t 1 / J_X (s t) + 1 / J_Y (r t)) :
    AntitoneOn (fun (t : ) => twoTimeLogRatioGap X Y Z_X Z_Y P s r t) (Set.Ici 0)

    TT-_antitoneOn_Ici_zero — the two-time gap is AntitoneOn (Set.Ici 0).

    antitoneOn_of_deriv_nonpos (convex Set.Ici 0) with continuity (twoTimeLogRatioGap_continuousWithinAt_zero), differentiability + per-t deriv ≤ 0 (twoTimeLogRatioGap_hasDerivAt.deriv + _deriv_le_zero). Mirrors csiszarLogRatioGap_antitoneOn_Ici_zero (EPI/Stam/ToBridge.lean).

    Surface structure (matched to the single-time model). On the interior Set.Ioi 0 AntitoneOn holds: continuity there is the interior differentiability (_hasDerivAt.differentiableAt.differentiableWithinAt), interior (Ioi 0) = Ioi 0, and per-t deriv ≤ 0 is (_hasDerivAt ...).deriv rewritten to the closed-form derivative J_S·(1/J_X + 1/J_Y) − 1, bounded ≤ 0 by _deriv_le_zero instantiated with the free J_S := J_S_embed(t) (= the directly-embedded sum Fisher info) and the per-t harmonic Stam supply. The endpoint 0 is then re-attached via AntitoneOn.insert_of_continuousWithinAt + the endpoint continuity (Task 1).

    The added preconditions are all regularity / Stam-supply, not a bundling of the EPI conclusion (the h_per_t conjunction supplies positivity, the density-pin equalities, and the harmonic Stam 1/J_S ≥ 1/J_X + 1/J_Y — the same shape as the model's h_pos_stam; the harmonic Stam is the single-noise-sum producer's output, threaded per-t). @audit:ok

    Used by
      theorem

      InformationTheory.Shannon.EPICase1TwoTime.heatFlowEP_zero

      source
      Used by
        theorem

        InformationTheory.Shannon.EPICase1TwoTime.matchedPath_component_div_exp_eq

        source
        {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] {J_A s : } (h_path : IsMatchedTimePath A B P J_A s) (hA : Measurable A) (hB : Measurable B) (h_scale : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => A ω / σ + B ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / σ + B ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (hs_pos : ∀ (t : ), 0 < t0 < s t) (t : ) :
        Used by
          theorem

          InformationTheory.Shannon.EPICase1TwoTime.sumHeatFlowEP_eq_mul_rescaled

          source
          {Ω : Type u_1} { : MeasurableSpace Ω} (X Y Z_X Z_Y Z : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hX : Measurable X) (hY : Measurable Y) (hZX : Measurable Z_X) (hZY : Measurable Z_Y) (hZ : Measurable Z) (hZX_law : MeasureTheory.Measure.map Z_X P = ProbabilityTheory.gaussianReal 0 1) (hZY_law : MeasureTheory.Measure.map Z_Y P = ProbabilityTheory.gaussianReal 0 1) (hZ_law : MeasureTheory.Measure.map Z P = ProbabilityTheory.gaussianReal 0 1) (hXY_ZXZY_pair : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) (fun (ω : Ω) => (Z_X ω, Z_Y ω)) P) (hXY_Z : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) Z P) (hZX_ZY : ProbabilityTheory.IndepFun Z_X Z_Y P) (h_scale_sum : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / σ + Z ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / σ + Z ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) {σ τ : } ( : 0 < σ) ( : 0 < τ) :
          sumHeatFlowEP X Y Z_X Z_Y P σ τ = (σ + τ) * EntropyPowerInequality.entropyPower (MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / (σ + τ) + Z ω) P)
          Used by
            theorem

            InformationTheory.Shannon.EPICase1TwoTime.tendsto_div_one_of_tendsto_atTop_of_eq_mul_exp

            source
            {A B : } {c : } (hc : 0 < c) (hAe : Filter.Tendsto (fun (t : ) => A t / Real.exp t) Filter.atTop (nhds c)) (hB : ∀ᶠ (t : ) in Filter.atTop, B t = c * Real.exp t) :
            Filter.Tendsto (fun (t : ) => A t / B t) Filter.atTop (nhds 1)
            Used by
              theorem

              InformationTheory.Shannon.EPICase1TwoTime.entropyPower_rescaled_path_tendsto_gaussianEP

              source
              Used by
                theorem

                InformationTheory.Shannon.EPICase1TwoTime.matchedPath_div_exp_tendsto

                source
                {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] {J_A s : } (h_path : IsMatchedTimePath A B P J_A s) (hA : Measurable A) (hB : Measurable B) (h_scale : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => A ω / σ + B ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / σ + B ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (hs_pos : ∀ (t : ), 0 < t0 < s t) {ν : } (hν_pos : 0 < ν) (hN : Filter.Tendsto (fun (t : ) => EntropyPowerInequality.entropyPower (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / (s t) + B ω) P)) Filter.atTop (nhds ν)) :
                Used by
                  theorem

                  InformationTheory.Shannon.EPICase1TwoTime.tendsto_sum_mul_div_exp

                  source
                  {f g h F : } {a b ν : } (hf : Filter.Tendsto (fun (t : ) => f t / Real.exp t) Filter.atTop (nhds a)) (hg : Filter.Tendsto (fun (t : ) => g t / Real.exp t) Filter.atTop (nhds b)) (hh : Filter.Tendsto h Filter.atTop (nhds ν)) (hF : ∀ᶠ (t : ) in Filter.atTop, F t = (f t + g t) * h t) :
                  Filter.Tendsto (fun (t : ) => F t / Real.exp t) Filter.atTop (nhds ((a + b) * ν))
                  Used by
                    theorem

                    InformationTheory.Shannon.EPICase1TwoTime.sumHeatFlowEP_div_heatFlowEP_sum_tendsto_one

                    source
                    {Ω : Type u_1} { : MeasurableSpace Ω} (X Y Z_X Z_Y : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] {J_X J_Y s r : } (h_path_X : IsMatchedTimePath X Z_X P J_X s) (h_path_Y : IsMatchedTimePath Y Z_Y P J_Y r) (Z : Ω) (hX : Measurable X) (hY : Measurable Y) (hZX : Measurable Z_X) (hZY : Measurable Z_Y) (hZ : Measurable Z) (hZX_law : MeasureTheory.Measure.map Z_X P = ProbabilityTheory.gaussianReal 0 1) (hZY_law : MeasureTheory.Measure.map Z_Y P = ProbabilityTheory.gaussianReal 0 1) (hZ_law : MeasureTheory.Measure.map Z P = ProbabilityTheory.gaussianReal 0 1) (hXY_ZXZY_pair : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) (fun (ω : Ω) => (Z_X ω, Z_Y ω)) P) (hXY_Z : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) Z P) (hZX_ZY : ProbabilityTheory.IndepFun Z_X Z_Y P) (hZX_ac : (MeasureTheory.Measure.map Z_X P).AbsolutelyContinuous MeasureTheory.volume) (hZY_ac : (MeasureTheory.Measure.map Z_Y P).AbsolutelyContinuous MeasureTheory.volume) (hZ_ac : (MeasureTheory.Measure.map Z P).AbsolutelyContinuous MeasureTheory.volume) (hs_atTop : Filter.Tendsto s Filter.atTop Filter.atTop) (hr_atTop : Filter.Tendsto r Filter.atTop Filter.atTop) (hs_pos : ∀ (t : ), 0 < t0 < s t) (hr_pos : ∀ (t : ), 0 < t0 < r t) (h_scale_X : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => X ω / σ + Z_X ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => X ω / σ + Z_X ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (h_scale_Y : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => Y ω / σ + Z_Y ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => Y ω / σ + Z_Y ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (h_scale_sum : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / σ + Z ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / σ + Z ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (varX varY varS : ) (h_varX_nn : 0 varX) (h_varY_nn : 0 varY) (h_varS_nn : 0 varS) (h_reg_X : EPICase1RatioLimit.IsRescaledPathRegular X Z_X P varX 1) (h_reg_Y : EPICase1RatioLimit.IsRescaledPathRegular Y Z_Y P varY 1) (h_reg_S : EPICase1RatioLimit.IsRescaledPathRegular (fun (ω : Ω) => X ω + Y ω) Z P varS 1) (h_den : ∀ (t : ), 0 theatFlowEP X Z_X P (s t) + heatFlowEP Y Z_Y P (r t) = (EntropyPowerInequality.entropyPower (MeasureTheory.Measure.map X P) + EntropyPowerInequality.entropyPower (MeasureTheory.Measure.map Y P)) * Real.exp t) :
                    Filter.Tendsto (fun (t : ) => sumHeatFlowEP X Y Z_X Z_Y P (s t) (r t) / (heatFlowEP X Z_X P (s t) + heatFlowEP Y Z_Y P (r t))) Filter.atTop (nhds 1)
                    Used by
                      theorem

                      InformationTheory.Shannon.EPICase1TwoTime.twoTimeLogRatioGap_tendsto_zero_atTop

                      source
                      {Ω : Type u_1} { : MeasurableSpace Ω} (X Y Z_X Z_Y : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] {J_X J_Y s r : } (h_path_X : IsMatchedTimePath X Z_X P J_X s) (h_path_Y : IsMatchedTimePath Y Z_Y P J_Y r) (Z : Ω) (hX : Measurable X) (hY : Measurable Y) (hZX : Measurable Z_X) (hZY : Measurable Z_Y) (hZ : Measurable Z) (hZX_law : MeasureTheory.Measure.map Z_X P = ProbabilityTheory.gaussianReal 0 1) (hZY_law : MeasureTheory.Measure.map Z_Y P = ProbabilityTheory.gaussianReal 0 1) (hZ_law : MeasureTheory.Measure.map Z P = ProbabilityTheory.gaussianReal 0 1) (hXY_ZXZY_pair : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) (fun (ω : Ω) => (Z_X ω, Z_Y ω)) P) (hXY_Z : ProbabilityTheory.IndepFun (fun (ω : Ω) => X ω + Y ω) Z P) (hZX_ZY : ProbabilityTheory.IndepFun Z_X Z_Y P) (hZX_ac : (MeasureTheory.Measure.map Z_X P).AbsolutelyContinuous MeasureTheory.volume) (hZY_ac : (MeasureTheory.Measure.map Z_Y P).AbsolutelyContinuous MeasureTheory.volume) (hZ_ac : (MeasureTheory.Measure.map Z P).AbsolutelyContinuous MeasureTheory.volume) (hs_atTop : Filter.Tendsto s Filter.atTop Filter.atTop) (hr_atTop : Filter.Tendsto r Filter.atTop Filter.atTop) (hs_pos : ∀ (t : ), 0 < t0 < s t) (hr_pos : ∀ (t : ), 0 < t0 < r t) (h_scale_X : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => X ω / σ + Z_X ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => X ω / σ + Z_X ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (h_scale_Y : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => Y ω / σ + Z_Y ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => Y ω / σ + Z_Y ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (h_scale_sum : ∀ (σ : ), 0 < σ(MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / σ + Z ω) P).AbsolutelyContinuous MeasureTheory.volume MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => (X ω + Y ω) / σ + Z ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) (varX varY varS : ) (h_varX_nn : 0 varX) (h_varY_nn : 0 varY) (h_varS_nn : 0 varS) (h_reg_X : EPICase1RatioLimit.IsRescaledPathRegular X Z_X P varX 1) (h_reg_Y : EPICase1RatioLimit.IsRescaledPathRegular Y Z_Y P varY 1) (h_reg_S : EPICase1RatioLimit.IsRescaledPathRegular (fun (ω : Ω) => X ω + Y ω) Z P varS 1) :
                      Filter.Tendsto (fun (t : ) => twoTimeLogRatioGap X Y Z_X Z_Y P s r t) Filter.atTop (nhds 0)

                      TT-_tendsto_zero_atTop — the two-time gap tends to 0 as t → ∞ (Gaussian-saturation limit along the matched paths). Mirrors csiszarLogRatioGap_tendsto_zero_atTop (EPI/Case1/RatioLimit/Assembly.lean).

                      §1 (reduction, sorry-free in this body). Using IsMatchedTimePath.matched_growth (for t ≥ 0, heatFlowEP A B P (s t) = heatFlowEP A B P 0 · eᵗ) and heatFlowEP A B P 0 = entropyPower (P.map A) (the √0 = 0 collapse), the matched-path denominator B t = heatFlowEP X Z_X P (s t) + heatFlowEP Y Z_Y P (r t) equals (eP X + eP Y)·eᵗ, whence log B t = log (eP X + eP Y) + t. Therefore the gap reduces (for t ≥ 0) to R t = log (A t) − log (B t), the log of the EPI saturation ratio A t / B t (A t = sumHeatFlowEP …(s t)(r t) is the numerator). The −t correction is absorbed by the eᵗ growth — established in the body via Real.log_mul/Real.log_exp, no sorry.

                      §2 (saturation core). The EPI saturation A t / B t → 1 as t → ∞, isolated into have h_ratio_tendsto; from it log (A t / B t) → log 1 = 0 (continuity of log at 1) and log (A/B) = log A − log B (both positive) recover R t → 0. The saturation is reduced to a single limit A t / eᵗ → N(X) + N(Y):

                      • A t (the matched-sum numerator) is identified with a single-noise heat flow of X+Y at τ = s t + r t via matchedSum_law_eq (@audit:ok), then split by entropyPower_path_scaling as A t = τ · NSr(τ) with NSr(σ) → ν and ν = N(𝒩(0,1)) the common noise entropy power.
                      • the component asymptotics s t / eᵗ → N(X)/ν, r t / eᵗ → N(Y)/ν come from combining matched growth (N_X(s t) = N(X)·eᵗ) with the scaling identity N_X(s t) = s t · NXr(s t) and the §3 envelope limit NXr(s t) → ν (composed with s, r → ∞). Hence τ / eᵗ → (N(X)+N(Y))/ν, so A t / eᵗ → (N(X)+N(Y)) and the ν factors cancel.

                      The §3 saturation machinery (entropyPower_rescaled_path_tendsto, IsRescaledPathRegular) is keyed to the single-time rescaling A/√t + B; the matched path uses different times s t ≠ r t, so the re-keying is exactly the matchedSum_law_eq reduction above. No EPI/Stam conclusion is bundled; the added preconditions (noise laws/independences, path divergence s,r → ∞, per-σ scaling regularity, the three IsRescaledPathRegular bundles) are regularity — none of them encodes A t / B t → 1. @audit:ok

                      Used by