InformationTheory

InformationTheory.Shannon.EPI.Case1.RatioLimit.PathRegular

source

§1 — Order-theoretic deliverable #

epi_of_csiszarLogRatioGap_tendsto: antitone R on Ici 0 together with R t → 0 forces R 0 ≥ 0, hence EPI. Pure order-limit argument; no analysis.

theorem

InformationTheory.Shannon.EPICase1RatioLimit.epi_of_csiszarLogRatioGap_tendsto

source

The order-limit bridge to EPI. If the log-ratio gap R = csiszarLogRatioGap … is antitone on Set.Ici 0 and R t → 0 as t → ∞, then R 0 ≥ 0, and therefore the entropy power inequality holds.

R 0 ≥ R t for every t ≥ 0 (antitonicity); since R t → 0 and the tail predicate R 0 ≥ R t holds eventually, ge_of_tendsto gives R 0 ≥ 0. The final EPI step is epi_of_csiszarLogRatioGap_zero_nonneg. @audit:ok

Used by

    §2 — Scaling cancellation (glue + threaded regularity) #

    N(law(X+√t·Z_X)) = t · N(law(X/√t + Z_X)) via entropyPower_map_mul_const.

    theorem

    InformationTheory.Shannon.EPICase1RatioLimit.entropyPower_path_scaling

    source
    {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) {t : } (ht : 0 < t) (h_ac : (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P).AbsolutelyContinuous MeasureTheory.volume) (h_ent_int : MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume) :

    The single-path scaling identity: for t > 0, entropyPower (P.map (fun ω => A ω + √t · B ω)) = t · entropyPower (P.map (fun ω => A ω / √t + B ω)).

    A + √t·B = √t·(A/√t + B), so the law on the left is the law on the right pushed forward by (· * √t); entropyPower_map_mul_const with c = √t (squared = t) finishes. The a.c. + entropy-integrability of the unscaled W-path law are regularity preconditions (consumed by entropyPower_map_mul_const). @audit:ok

    Used by

      §3 — Per-path limit (squeeze, regularity threaded) #

      N(W_X t) → N(law Z_X) via the independent-noise lower bound and the Gaussian max-entropy upper bound.

      def

      InformationTheory.Shannon.EPICase1RatioLimit.IsRescaledPathRegular

      source
      {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (varA : ) (v_B : NNReal) :

      A per-t regularity bundle for the rescaled path A/√t + B, holding the preconditions of the two envelope lemmas (differentialEntropy_add_ge_of_indep for the lower bound, applied with X := B, Y := A/√t; differentialEntropy_le_gaussian_of_variance_le for the upper bound on μ := P.map (A/√t + B) with variance bound varA/t + v_B).

      This is a regularity bundle (IndepFun / a.c. / fibre integrabilities / mean + variance-bound + integrabilities), NOT load-bearing: it never contains the conclusion Tendsto … N(B) nor either envelope inequality — those are derived in entropyPower_rescaled_path_tendsto by calling the lemmas with these preconditions.

      Not load-bearing: each conjunct matches a regularity precondition of differentialEntropy_add_ge_of_indep (lower bundle, X:=B Y:=A/√t) or differentialEntropy_le_gaussian_of_variance_le (upper bundle). The variance-bound conjunct ∫(x-m)² ≤ varA/t + v_B is the standard h_var max-entropy input (not the squeeze core): varA is pinned ≥ Var A by the all-t requirement and the squeeze limit N(B) is independent of varA's value. Not vacuous (real constraints, satisfiable by Gaussian-smoothed a.c. paths, falsifiable by non-a.c. paths; conclusion nontrivial via the separate hB_law/hv_B).

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        Used by
          theorem

          InformationTheory.Shannon.EPICase1RatioLimit.entropyPower_rescaled_path_tendsto

          source

          As t → ∞, the rescaled W-path entropy power N(law(A/√t + B)) converges to the noise entropy power N(law B) when B has a Gaussian law of nonzero variance.

          Squeeze: lower bound N(A/√t + B) ≥ N(B) (independent-noise monotonicity, differentialEntropy_add_ge_of_indep applied with X := B, Y := A/√t), upper bound N(A/√t + B) ≤ 2πe·(varA/t + v_B) → 2πe·v_B = N(B) (Gaussian max-entropy, differentialEntropy_le_gaussian_of_variance_le), both sandwiching N(law B) = 2πe·v_B (entropyPower_gaussianReal) as varA/t → 0 (tendsto_of_tendsto_of_tendsto_of_le_of_le').

          The squeeze structure (constant lower envelope from independent-noise monotonicity

          • decaying upper envelope from Gaussian max-entropy → common limit N(B)) is the analytic content of this lemma. All the per-t data feeding the two envelope lemmas are threaded as regularity preconditions (NOT load-bearing): IndepFun B (A/√t) (h_indep), a.c. of the path laws (h_path_ac, hB_ac), the 8 fibre integrabilities of the lower-bound lemma (h_lb), the max-entropy data of the upper-bound lemma (mean / variance bound by varA/t + v_B / integrabilities, packaged in h_ub). The conclusion N(W t) → N(B) is not encoded in any hypothesis — both envelopes are produced by Mathlib / in-tree lemmas, and their common limit is computed here.

          varA (= Var A, threaded as a real regularity datum with h_varA_nn : 0 ≤ varA) @audit:ok

          Used by

            §3b — Discharging IsRescaledPathRegular from method-X regularity #

            isRescaledPathRegular_of_methodX: construct the per-t regularity bundle IsRescaledPathRegular A B P varA v_B from bare method-X premises, exploiting that B is a Gaussian noise (P.map B = gaussianReal 0 v_B) independent of A. The fibre of condDistrib (B + A/√t) (A/√t) P is the translated Gaussian gaussianReal z v_B (affineShiftKernel, c = 1), so the fibre-level conditions reduce to Gaussian-density integrability rather than the general density-witness wall.

            All conjuncts (IndepFun / a.c. / fibre a.c. / fibre self-entropy / fibre-entropy-over-z / joint-≪-product / squared-deviation / both path-entropy log-integrabilities + the 3 conditional-KL cross-entropy integrabilities) are closed using hA_ac + the convDensityAdd path-density identification + the extracted cross-entropy lemmas (convCrossEntropy_perFibre_integrable / convCrossEntropy_zAvg_integrable / convJointLlr_integrable, EPI/G2/ConvEntropyDensity.lean).

            theorem

            InformationTheory.Shannon.EPICase1RatioLimit.map_div_sqrt_absolutelyContinuous

            source
            {Ω : Type u_1} { : MeasurableSpace Ω} (A : Ω) (P : MeasureTheory.Measure Ω) (hA : Measurable A) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) {t : } (ht : 0 < t) :

            Scaling preserves absolute continuity: if P.map A ≪ volume then P.map (A/√t) ≪ volume for t > 0 (the map (·/√t) is a Lebesgue-a.c. linear isomorphism).

            Used by
              theorem

              InformationTheory.Shannon.EPICase1RatioLimit.rescaledInput_density_witness

              source
              {Ω : Type u_1} { : MeasurableSpace Ω} (A : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
              ∃ (pX : ), (∀ (x : ), 0 pX x) Measurable pX (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P = MeasureTheory.volume.withDensity fun (x : ) => ENNReal.ofReal (pX x)) MeasureTheory.Integrable pX MeasureTheory.volume (y : ), pX y = 1 MeasureTheory.Integrable (fun (y : ) => y ^ 2 * pX y) MeasureTheory.volume

              A density witness for A/√t: from P.map A ≪ volume, the rescaled input A/√t admits a Real density witness pX := ((P.map (A/√t)).rnDeriv volume).toReal with all the regularity (≥ 0, measurable, withDensity law, integrable, mass = 1, finite second moment) needed to invoke convDensityAdd_negMulLog_integrable_pub and the pPath_eq_convDensityAdd identification.

              Used by
                theorem

                InformationTheory.Shannon.EPICase1RatioLimit.rescaledPath_density_rnDeriv_eq

                source
                {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B_pos : 0 < v_B) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                Used by
                  theorem

                  InformationTheory.Shannon.EPICase1RatioLimit.rescaledPath_variance_regular

                  source
                  {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (hB_ac : (MeasureTheory.Measure.map B P).AbsolutelyContinuous MeasureTheory.volume) (varA : ) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) (h_var_bound : ∀ (t : ), 0 < t (x : ), (x - (y : ), y MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P) ^ 2 MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P varA / t + v_B) (t : ) :
                  0 < t(MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P).AbsolutelyContinuous MeasureTheory.volume (x : ), (x - (y : ), y MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P) ^ 2 MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P varA / t + v_B MeasureTheory.Integrable (fun (x : ) => (x - (y : ), y MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P) ^ 2) (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P) MeasureTheory.Integrable (fun (x : ) => ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P).rnDeriv MeasureTheory.volume x).toReal.negMulLog) MeasureTheory.volume
                  Used by
                    theorem

                    InformationTheory.Shannon.EPICase1RatioLimit.indepFun_const_div_sqrt

                    source
                    {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                    ProbabilityTheory.IndepFun B (fun (ω : Ω) => A ω / t) P
                    Used by
                      theorem

                      InformationTheory.Shannon.EPICase1RatioLimit.condDistrib_indep_gaussian_add_ae_affineShift

                      source
                      {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                      (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) =ᵐ[MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P] (affineShiftKernel (MeasureTheory.Measure.map B P) 1)
                      Used by
                        theorem

                        InformationTheory.Shannon.EPICase1RatioLimit.affineShiftKernel_map_gaussian_one_eq

                        source
                        Used by
                          theorem

                          InformationTheory.Shannon.EPICase1RatioLimit.condDistrib_indep_gaussian_add_fibre_absolutelyContinuous

                          source
                          {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                          ∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, ((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).AbsolutelyContinuous MeasureTheory.volume
                          Used by
                            theorem

                            InformationTheory.Shannon.EPICase1RatioLimit.volume_absolutelyContinuous_map_indep_gaussian_add

                            source
                            {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (hB_ac : (MeasureTheory.Measure.map B P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                            Used by
                              theorem

                              InformationTheory.Shannon.EPICase1RatioLimit.condDistrib_indep_gaussian_add_fibre_rnDeriv_ae

                              source
                              {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                              ∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, ((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume =ᵐ[MeasureTheory.volume] fun (x : ) => ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal z v_B x)
                              Used by
                                theorem

                                InformationTheory.Shannon.EPICase1RatioLimit.condDistrib_indep_gaussian_add_fibre_rnDeriv_toReal_shift_ae

                                source
                                {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                                ∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, (fun (x : ) => (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal) =ᵐ[MeasureTheory.volume] fun (x : ) => ProbabilityTheory.gaussianPDFReal 0 v_B (x - z)
                                Used by
                                  theorem

                                  InformationTheory.Shannon.EPICase1RatioLimit.compProd_condDistrib_indep_gaussian_add_absolutelyContinuous_const

                                  source
                                  {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (hB_ac : (MeasureTheory.Measure.map B P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                                  ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P)).AbsolutelyContinuous ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.Kernel.const (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P)))
                                  Used by
                                    theorem

                                    InformationTheory.Shannon.EPICase1RatioLimit.condDistrib_indep_gaussian_add_fibre_selfEntropy_integrable

                                    source
                                    {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                                    ∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, MeasureTheory.Integrable (fun (x : ) => (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal * Real.log (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal) MeasureTheory.volume
                                    Used by
                                      theorem

                                      InformationTheory.Shannon.EPICase1RatioLimit.condDistrib_indep_gaussian_add_fibre_crossEntropy_integrable

                                      source
                                      {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                                      ∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, MeasureTheory.Integrable (fun (x : ) => (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal * Real.log ((MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).rnDeriv MeasureTheory.volume x).toReal) MeasureTheory.volume
                                      Used by
                                        theorem

                                        InformationTheory.Shannon.EPICase1RatioLimit.integrable_differentialEntropy_condDistrib_indep_gaussian_add

                                        source
                                        {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) {t : } :
                                        MeasureTheory.Integrable (fun (z : ) => differentialEntropy ((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z)) (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P)
                                        Used by
                                          theorem

                                          InformationTheory.Shannon.EPICase1RatioLimit.integrable_condDistrib_indep_gaussian_add_crossEntropy_zAvg

                                          source
                                          {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                                          MeasureTheory.Integrable (fun (z : ) => (x : ), (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal * Real.log ((MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).rnDeriv MeasureTheory.volume x).toReal) (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P)
                                          Used by
                                            theorem

                                            InformationTheory.Shannon.EPICase1RatioLimit.integrable_llr_compProd_condDistrib_indep_gaussian_add

                                            source
                                            {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (hB_ac : (MeasureTheory.Measure.map B P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                                            MeasureTheory.Integrable (MeasureTheory.llr ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P)) ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.Kernel.const (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P)))) ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P))
                                            Used by
                                              theorem

                                              InformationTheory.Shannon.EPICase1RatioLimit.integrable_log_map_indep_gaussian_add

                                              source
                                              {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (hB_ac : (MeasureTheory.Measure.map B P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) {t : } (ht : 0 < t) :
                                              MeasureTheory.Integrable (fun (x : ) => Real.log ((MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).rnDeriv MeasureTheory.volume x).toReal) (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P)
                                              Used by
                                                theorem

                                                InformationTheory.Shannon.EPICase1RatioLimit.rescaledPath_indep_regular

                                                source
                                                {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (hB_ac : (MeasureTheory.Measure.map B P).AbsolutelyContinuous MeasureTheory.volume) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) (t : ) :
                                                0 < tProbabilityTheory.IndepFun B (fun (ω : Ω) => A ω / t) P (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).AbsolutelyContinuous MeasureTheory.volume ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P)).AbsolutelyContinuous ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.Kernel.const (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P))) MeasureTheory.Integrable (MeasureTheory.llr ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P)) ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.Kernel.const (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P)))) ((MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P).compProd (ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P)) (∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, ((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).AbsolutelyContinuous MeasureTheory.volume) (∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, MeasureTheory.Integrable (fun (x : ) => (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal * Real.log (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal) MeasureTheory.volume) (∀ᵐ (z : ) MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P, MeasureTheory.Integrable (fun (x : ) => (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal * Real.log ((MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).rnDeriv MeasureTheory.volume x).toReal) MeasureTheory.volume) MeasureTheory.Integrable (fun (z : ) => differentialEntropy ((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z)) (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P) MeasureTheory.Integrable (fun (z : ) => (x : ), (((ProbabilityTheory.condDistrib (fun (ω : Ω) => B ω + A ω / t) (fun (ω : Ω) => A ω / t) P) z).rnDeriv MeasureTheory.volume x).toReal * Real.log ((MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).rnDeriv MeasureTheory.volume x).toReal) (MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t) P) MeasureTheory.Integrable (fun (x : ) => Real.log ((MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P).rnDeriv MeasureTheory.volume x).toReal) (MeasureTheory.Measure.map (fun (ω : Ω) => B ω + A ω / t) P)
                                                Used by
                                                  theorem

                                                  InformationTheory.Shannon.EPICase1RatioLimit.isRescaledPathRegular_of_methodX

                                                  source
                                                  {Ω : Type u_1} { : MeasurableSpace Ω} (A B : Ω) (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hA : Measurable A) (hB : Measurable B) (v_B : NNReal) (hv_B : v_B 0) (hB_law : MeasureTheory.Measure.map B P = ProbabilityTheory.gaussianReal 0 v_B) (hAB : ProbabilityTheory.IndepFun A B P) (hA_ac : (MeasureTheory.Measure.map A P).AbsolutelyContinuous MeasureTheory.volume) (varA : ) (_h_varA_nn : 0 varA) (h_mom_A : MeasureTheory.Integrable (fun (ω : Ω) => A ω ^ 2) P) (h_var_bound : ∀ (t : ), 0 < t (x : ), (x - (y : ), y MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P) ^ 2 MeasureTheory.Measure.map (fun (ω : Ω) => A ω / t + B ω) P varA / t + v_B) :
                                                  IsRescaledPathRegular A B P varA v_B

                                                  Discharge IsRescaledPathRegular from method-X regularity.

                                                  Given a Gaussian noise B (P.map B = gaussianReal 0 v_B, v_B ≠ 0) independent of the input A (hAB : IndepFun A B P), with A measurable + finite-second-moment data threaded as varA-regularity, construct the per-t regularity bundle IsRescaledPathRegular A B P varA v_B.

                                                  The key insight: the fibre of condDistrib (B + A/√t) (A/√t) P is the translated Gaussian gaussianReal z v_B (the law of B + z by affineShiftKernel/Gaussian translation). This avoids the density-witness obstruction for the general fibre: the fibre identification condDistrib (B + A/√t) (A/√t) P =ᵐ affineShiftKernel (P.map B) 1 (h_fibre_ae) and the per-fibre a.c. condDistrib z ≪ volume (hκ_v, via gaussianReal z v_B) are both closed — exactly the conjuncts that are intractable in the general case.

                                                  Preconditions only (NOT load-bearing): measurability, IndepFun A B P, the Gaussian noise law, finite-second-moment h_mom_A + varA-regularity (h_var_bound). The bundle being constructed is itself regularity (audited non-load-bearing at its def site §3).

                                                  All 9 integrability conjuncts are supplied. The 3 conditional-KL integrabilities are supplied via the extracted standalone lemmas in EPI/G2/ConvEntropyDensity.lean (convCrossEntropy_perFibre_integrable / convCrossEntropy_zAvg_integrable / convJointLlr_integrable), instantiated here with the Gaussian fibre q := gaussianPDFReal 0 v_B (translated by z) and the target convolution density g := convDensityAdd pX g_{v_B}. No signature change was needed: because the fibre is Gaussian (not the input density), the joint-llr branch (b) abs-entropy ∫ q·|log q| is the Gaussian self-entropy (finite via integrable_density_log_density_of_gaussian), so the inventory's suspected hpX_ent input-density-entropy precondition is not required (the X/Z roles are swapped vs. the density template, where the fibre is the input). All preconditions: hA_ac : P.map A ≪ volume (case-1 a.c. input, NOT load-bearing — consumed only for the density witness and P.map (A/√t) ≪ volume), h_mom_A (finite second moment, feeds the Gaussian-fibre moment domination), the Gaussian noise law, h_var_bound.

                                                  • The regularity conjuncts (closed here): IndepFun B (A/√t) (h_indep), a.c. of B + A/√t and A/√t + B (hW_ac/hμ_ac), the fibre identification h_fibre_ae + per-fibre a.c. hκ_v, the variance bound (threaded h_var_bound), joint-≪-product, the fibre/path self-entropy + log-density integrabilities, the squared-deviation, and the 3 cross-entropy conjuncts (per-z cross integrand, z-averaged cross-term, joint llr).
                                                  • The cross-entropy analytic core (condDifferentialEntropy_le's h_int/hκ_cross_int/h_cross_int): integrability of the path-density log g against each Gaussian fibre, dominated by the convDensityAdd_logFactor_poly_majorant |log g| ≤ (A+1)+B·x² and the Gaussian-fibre quadratic moments. @audit:ok
                                                  Used by