lean/OAI/NumberTheory/Jacobsthal/Probability/ArrivalKernelGeometry.lean

import Mathlib.Probability.Kernel.Composition.Comp
import Mathlib.Probability.Kernel.WithDensity
import OAI.NumberTheory.Jacobsthal.Estimates.EvenInverseBands

namespace OAI

namespace Erdos970

section

namespace NumberTheoryLean.KernelWeightTransform

open Set MeasureTheory ProbabilityTheory
open scoped ENNReal

variable {α : Type*} [MeasurableSpace α]

structure PositiveWeight (α : Type*) [MeasurableSpace α] where
  value : α → ℝ≥0∞
  measurable_value : Measurable value
  ne_zero : ∀ a, value a ≠ 0
  ne_top : ∀ a, value a ≠ ∞

instance : CoeFun (PositiveWeight α) (fun _ => α → ℝ≥0∞) := ⟨PositiveWeight.value⟩

theorem ratio_measurable (w : PositiveWeight α) :
    Measurable (Function.uncurry (fun a b => w b / w a)) :=
  (w.measurable_value.comp measurable_snd).div (w.measurable_value.comp measurable_fst)

theorem ratio_ne_top (w : PositiveWeight α) (a b : α) : w b / w a ≠ ∞ :=
  ENNReal.div_ne_top (w.ne_top b) (w.ne_zero a)

theorem ratio_cocycle (w : PositiveWeight α) (a b c : α) :
    (w b / w a) * (w c / w b) = w c / w a := by
  simp only [div_eq_mul_inv]
  calc
    _ = (w b * (w b)⁻¹) * (w c * (w a)⁻¹) := by ring
    _ = _ := by rw [ENNReal.mul_inv_cancel (w.ne_zero b) (w.ne_top b), one_mul]

noncomputable def conjugate (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α) : Kernel α α :=
  K.withDensity (fun a b => w b / w a)

instance conjugate_isSFiniteKernel (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α) :
    IsSFiniteKernel (conjugate K w) := Kernel.IsSFiniteKernel.withDensity K (ratio_ne_top w)

instance kernelPower_isSFiniteKernel (K : Kernel α α) [IsSFiniteKernel K] (n : ℕ) :
    IsSFiniteKernel (K ^ n) := by
  induction n with
  | zero => change IsSFiniteKernel (Kernel.id : Kernel α α); infer_instance
  | succ n ih =>
    have hp : K ^ (n + 1) = K ∘ₖ (K ^ n) := pow_succ' _ _
    rw [hp]
    infer_instance

theorem conjugate_apply (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α) (a : α) :
    conjugate K w a = (K a).withDensity (fun b => w b / w a) :=
  Kernel.withDensity_apply K (ratio_measurable w) a

theorem conjugate_lintegral (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α) (a : α)
    {F : α → ℝ≥0∞} (hF : Measurable F) :
    (∫⁻ b, F b ∂conjugate K w a) = ∫⁻ b, (w b / w a) * F b ∂K a :=
  Kernel.lintegral_withDensity K (ratio_measurable w) a hF

theorem conjugate_id (w : PositiveWeight α) : conjugate (Kernel.id : Kernel α α) w = Kernel.id := by
  ext a : 1
  apply Measure.ext_of_lintegral
  intro F hF
  rw [conjugate_lintegral _ w a hF,
    Kernel.lintegral_id' (f := fun b => (w b / w a) * F b) ((w.measurable_value.div measurable_const).mul hF),
    ENNReal.div_self (w.ne_zero a) (w.ne_top a), one_mul, Kernel.lintegral_id' hF]

theorem conjugate_comp (L K : Kernel α α) [IsSFiniteKernel L] [IsSFiniteKernel K]
    (w : PositiveWeight α) :
    (conjugate L w) ∘ₖ (conjugate K w) = conjugate (L ∘ₖ K) w := by
  ext a : 1
  apply Measure.ext_of_lintegral
  intro F hF
  have hInner : Measurable (fun b => ∫⁻ c, F c ∂conjugate L w b) := hF.lintegral_kernel
  have hWeighted : Measurable (fun c => (w c / w a) * F c) :=
    (w.measurable_value.div measurable_const).mul hF
  rw [Kernel.lintegral_comp _ _ _ hF,
    conjugate_lintegral K w a (F := fun b => ∫⁻ c, F c ∂conjugate L w b) hInner,
    conjugate_lintegral (L ∘ₖ K) w a hF,
    Kernel.lintegral_comp L K a hWeighted]
  apply lintegral_congr
  intro b
  rw [conjugate_lintegral L w b hF,
    ← lintegral_const_mul' _ _ (ratio_ne_top w a b)]
  apply lintegral_congr
  intro c
  rw [← mul_assoc, ratio_cocycle]

theorem conjugate_congr (L K : Kernel α α) [IsSFiniteKernel L] [IsSFiniteKernel K]
    (h : L = K) (w : PositiveWeight α) : conjugate L w = conjugate K w := by
  subst K
  rfl

theorem conjugate_pow (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α) (n : ℕ) :
    (conjugate K w) ^ n = conjugate (K ^ n) w := by
  induction n with
  | zero =>
    change (Kernel.id : Kernel α α) = conjugate Kernel.id w
    exact (conjugate_id w).symm
  | succ n ih =>
    have hp : (conjugate K w) ^ (n + 1) = (conjugate K w) ∘ₖ ((conjugate K w) ^ n) := pow_succ' _ _
    have hq : K ^ (n + 1) = K ∘ₖ (K ^ n) := pow_succ' _ _
    rw [hp, ih, conjugate_comp]
    exact conjugate_congr (K ∘ₖ (K ^ n)) (K ^ (n + 1)) hq.symm w

theorem conjugate_pow_lintegral (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α)
    (n : ℕ) (a : α) {F : α → ℝ≥0∞} (hF : Measurable F) :
    (∫⁻ b, F b ∂((conjugate K w) ^ n) a) =
      (w a)⁻¹ * ∫⁻ b, w b * F b ∂(K ^ n) a := by
  rw [conjugate_pow, conjugate_lintegral _ w a hF]
  calc
    _ = ∫⁻ b, (w a)⁻¹ * (w b * F b) ∂(K ^ n) a := by
      apply lintegral_congr
      intro b
      rw [div_eq_mul_inv]
      ring
    _ = _ := lintegral_const_mul' _ _ (ENNReal.inv_ne_top.mpr (w.ne_zero a))

theorem conjugate_prefix_sum (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α) :
    Kernel.sum (fun n : ℕ => (conjugate K w) ^ n) =
      conjugate (Kernel.sum (fun n : ℕ => K ^ n)) w := by
  calc
    _ = Kernel.sum (fun n : ℕ => conjugate (K ^ n) w) := by
      apply congrArg Kernel.sum
      funext n
      exact conjugate_pow K w n
    _ = _ := (Kernel.withDensity_kernel_sum (fun n : ℕ => K ^ n) (fun _ => inferInstance)
      (fun a b => w b / w a)).symm

end NumberTheoryLean.KernelWeightTransform

end

section

namespace NumberTheoryLean.KernelExitBarrier

open Set MeasureTheory ProbabilityTheory
open scoped ENNReal
open KernelWeightTransform

variable {α β γ : Type*} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ]

theorem restrict_inner_comp (K : Kernel α β) (L : Kernel γ α) {A : Set α} (hA : MeasurableSet A)
    (hzero : ∀ a ∉ A, K a = 0) : K ∘ₖ (L.restrict hA) = K ∘ₖ L := by
  classical
  ext z B hB
  rw [Kernel.comp_apply' _ _ _ hB, Kernel.comp_apply' _ _ _ hB, Kernel.restrict_apply,
    ← lintegral_indicator hA]
  apply lintegral_congr
  intro a
  by_cases ha : a ∈ A
  · rw [indicator_of_mem ha]
  · rw [indicator_of_notMem ha, hzero a ha]
    simp

theorem restricted_pow_eq (K : Kernel α α) {A : Set α} (hA : MeasurableSet A)
    (hNoReturn : ∀ a ∉ A, K a A = 0) (n : ℕ) :
    (K.restrict hA) ^ (n + 1) = (K ^ (n + 1)).restrict hA := by
  have hz : ∀ a ∉ A, K.restrict hA a = 0 := by
    intro a ha
    rw [Kernel.restrict_apply]
    exact Measure.restrict_eq_zero.mpr (hNoReturn a ha)
  induction n with
  | zero => simp
  | succ n ih =>
    have hL : (K.restrict hA) ^ (n + 1 + 1) = (K.restrict hA) ∘ₖ ((K.restrict hA) ^ (n + 1)) := pow_succ' _ _
    have hR : K ^ (n + 1 + 1) = K ∘ₖ (K ^ (n + 1)) := pow_succ' _ _
    rw [hL, ih, restrict_inner_comp (K.restrict hA) (K ^ (n + 1)) hA hz,
      Kernel.comp_restrict hA, hR]

theorem restricted_future_sum (K : Kernel α α) {A : Set α} (hA : MeasurableSet A)
    (hNoReturn : ∀ a ∉ A, K a A = 0) :
    Kernel.sum (fun n : ℕ => (K.restrict hA) ^ (n + 1)) =
      (Kernel.sum (fun n : ℕ => K ^ (n + 1))).restrict hA := by
  ext z B hB
  rw [Kernel.sum_apply' _ _ hB, Kernel.restrict_apply' _ _ _ hB,
    Kernel.sum_apply' _ _ (hB.inter hA)]
  apply tsum_congr
  intro n
  rw [restricted_pow_eq K hA hNoReturn, Kernel.restrict_apply' _ _ _ hB]

theorem conjugate_restrict (K : Kernel α α) [IsSFiniteKernel K] (w : PositiveWeight α)
    {A : Set α} (hA : MeasurableSet A) :
    (conjugate K w).restrict hA = conjugate (K.restrict hA) w := by
  ext a : 1
  rw [Kernel.restrict_apply, conjugate_apply K w a, conjugate_apply (K.restrict hA) w a,
    Kernel.restrict_apply, MeasureTheory.restrict_withDensity hA]

end NumberTheoryLean.KernelExitBarrier

end

section

namespace NumberTheoryLean.KernelMappedDomination

open Set MeasureTheory ProbabilityTheory
open scoped ENNReal
open KernelWeightTransform

variable {α β : Type*} [MeasurableSpace α] [MeasurableSpace β]

theorem mapped_pow_lintegral_le (K : Kernel α α) (L : Kernel β β)
    [IsSFiniteKernel K] [IsSFiniteKernel L] (P : α → β) (hP : Measurable P)
    (hrow : ∀ x, (K x).map P ≤ L (P x)) :
    ∀ n : ℕ, ∀ x : α, ∀ f : β → ℝ≥0∞, Measurable f →
      (∫⁻ y, f (P y) ∂(K^n) x) ≤ ∫⁻ y, f y ∂(L^n) (P x) := by
  intro n
  induction n with
  | zero =>
    intro x f hf
    change (∫⁻ y, f (P y) ∂Measure.dirac x) ≤ ∫⁻ y, f y ∂Measure.dirac (P x)
    rw [lintegral_dirac' _ (f := fun y => f (P y)) (hf.comp hP), lintegral_dirac' _ hf]
  | succ n ih =>
    intro x f hf
    have hp : K^(n+1) = (K^n) ∘ₖ K := pow_succ _ _
    have hq : L^(n+1) = (L^n) ∘ₖ L := pow_succ _ _
    rw [hp, hq,
      Kernel.lintegral_comp _ _ _ (g := fun y => f (P y)) (hf.comp hP),
      Kernel.lintegral_comp _ _ _ hf]
    have hF : Measurable (fun y => ∫⁻ t, f t ∂(L^n) y) := hf.lintegral_kernel
    calc
      _ ≤ ∫⁻ y, ∫⁻ t, f t ∂(L^n) (P y) ∂K x := lintegral_mono (fun y => ih y f hf)
      _ = ∫⁻ y, ∫⁻ t, f t ∂(L^n) y ∂(K x).map P :=
        (lintegral_map (f := fun y => ∫⁻ t, f t ∂(L^n) y) hF hP).symm
      _ ≤ _ := lintegral_mono' (hrow x) le_rfl

theorem mapped_pow_le (K : Kernel α α) (L : Kernel β β)
    [IsSFiniteKernel K] [IsSFiniteKernel L] (P : α → β) (hP : Measurable P)
    (hrow : ∀ x, (K x).map P ≤ L (P x)) (n : ℕ) (x : α) :
    ((K^n) x).map P ≤ (L^n) (P x) := by
  apply Measure.le_iff.mpr
  intro A hA
  have hf : Measurable (A.indicator (fun _ : β => (1 : ℝ≥0∞))) := measurable_const.indicator hA
  have h := mapped_pow_lintegral_le K L P hP hrow n x _ hf
  rw [← lintegral_map (f := A.indicator (fun _ : β => (1 : ℝ≥0∞))) hf hP] at h
  simpa only [lintegral_indicator hA, lintegral_const, one_mul, Measure.restrict_apply_univ] using h

theorem mapped_prefix_sum_le (K : Kernel α α) (L : Kernel β β)
    [IsSFiniteKernel K] [IsSFiniteKernel L] (P : α → β) (hP : Measurable P)
    (hrow : ∀ x, (K x).map P ≤ L (P x)) (x : α)
    {f : β → ℝ≥0∞} (hf : Measurable f) :
    (∑' n : ℕ, ∫⁻ y, f (P y) ∂(K^n) x) ≤
      ∑' n : ℕ, ∫⁻ y, f y ∂(L^n) (P x) :=
  ENNReal.tsum_le_tsum (fun n => mapped_pow_lintegral_le K L P hP hrow n x f hf)

theorem mapped_pow_lintegral_eq (K : Kernel α α) (L : Kernel β β)
    [IsSFiniteKernel K] [IsSFiniteKernel L] (P : α → β) (hP : Measurable P)
    (hrow : ∀ x, (K x).map P = L (P x)) :
    ∀ n : ℕ, ∀ x : α, ∀ f : β → ℝ≥0∞, Measurable f →
      (∫⁻ y, f (P y) ∂(K^n) x) = ∫⁻ y, f y ∂(L^n) (P x) := by
  intro n
  induction n with
  | zero =>
    intro x f hf
    change (∫⁻ y, f (P y) ∂Measure.dirac x) = ∫⁻ y, f y ∂Measure.dirac (P x)
    rw [lintegral_dirac' _ (f := fun y => f (P y)) (hf.comp hP), lintegral_dirac' _ hf]
  | succ n ih =>
    intro x f hf
    have hp : K^(n+1) = (K^n) ∘ₖ K := pow_succ _ _
    have hq : L^(n+1) = (L^n) ∘ₖ L := pow_succ _ _
    rw [hp, hq, Kernel.lintegral_comp _ _ _ (g := fun y => f (P y)) (hf.comp hP),
      Kernel.lintegral_comp _ _ _ hf]
    have hF : Measurable (fun y => ∫⁻ t, f t ∂(L^n) y) := hf.lintegral_kernel
    calc
      _ = ∫⁻ y, ∫⁻ t, f t ∂(L^n) (P y) ∂K x := lintegral_congr (fun y => ih y f hf)
      _ = ∫⁻ y, ∫⁻ t, f t ∂(L^n) y ∂(K x).map P :=
        (lintegral_map (f := fun y => ∫⁻ t, f t ∂(L^n) y) hF hP).symm
      _ = _ := by rw [hrow x]

theorem mapped_pow_eq (K : Kernel α α) (L : Kernel β β)
    [IsSFiniteKernel K] [IsSFiniteKernel L] (P : α → β) (hP : Measurable P)
    (hrow : ∀ x, (K x).map P = L (P x)) (n : ℕ) (x : α) :
    ((K^n) x).map P = (L^n) (P x) := by
  apply Measure.ext_of_lintegral
  intro f hf
  rw [lintegral_map hf hP]
  exact mapped_pow_lintegral_eq K L P hP hrow n x f hf

end NumberTheoryLean.KernelMappedDomination

end

section

namespace NumberTheoryLean.HarmonicWeightKernel

open Set MeasureTheory ProbabilityTheory
open scoped ProbabilityTheory ENNReal
open DerivativeWeights WeightFutureIntegrals TransitionKernels FinitePathGeometry
open FinitePathMeasures OccupationBoundaries InvariantInverseWeights
open KernelWeightTransform CostPrefixTransport OccupationDecomposition

noncomputable def harmonicWeight : PositiveWeight CostState where
  value z := ENNReal.ofReal (Real.exp (-2 * z.2) / stateWeight z.1)
  measurable_value := ENNReal.measurable_ofReal.comp
    ((Real.measurable_exp.comp (measurable_const.mul measurable_snd)).div
      (stateWeight_measurable.comp measurable_fst))
  ne_zero z := (ENNReal.ofReal_pos.mpr (div_pos (Real.exp_pos _) (stateWeight_pos z.1))).ne'
  ne_top _ := ENNReal.ofReal_ne_top

noncomputable def harmonicKernel : Kernel CostState CostState := conjugate costKernel harmonicWeight

instance harmonicKernel_isSFiniteKernel : IsSFiniteKernel harmonicKernel := by unfold harmonicKernel; infer_instance

theorem exp_neg_two_cost {t : ℝ} (ht : 0 < t) :
    Real.exp (-2 * cost t) = (t / (t + 1)) ^ 2 := by
  have h : Real.exp (-cost t) = t / (t + 1) := by
    simpa only [nextGap, one_mul] using (nextGap_eq_cost (r := 1) ht).symm
  calc
    _ = Real.exp (-cost t + -cost t) := congrArg Real.exp (by ring)
    _ = Real.exp (-cost t) * Real.exp (-cost t) := Real.exp_add _ _
    _ = _ := by rw [h, pow_two]

theorem transition_weight_ratio (z : CostState) (s : State) :
    harmonicWeight (s, z.2 + cost (stateRatio s)) / harmonicWeight z =
      ENNReal.ofReal ((stateRatio s / (stateRatio s + 1)) ^ 2 *
        (stateWeight z.1 / stateWeight s)) := by
  have hz : 0 < Real.exp (-2 * z.2) / stateWeight z.1 := div_pos (Real.exp_pos _) (stateWeight_pos z.1)
  change ENNReal.ofReal (Real.exp (-2 * (z.2 + cost (stateRatio s))) / stateWeight s) /
    ENNReal.ofReal (Real.exp (-2 * z.2) / stateWeight z.1) = _
  rw [← ENNReal.ofReal_div_of_pos hz]
  congr 1
  rw [show -2 * (z.2 + cost (stateRatio s)) = (-2 * z.2) + (-2 * cost (stateRatio s)) by ring,
    Real.exp_add, exp_neg_two_cost (stateRatio_pos s)]
  field_simp [(stateWeight_pos z.1).ne', (stateWeight_pos s).ne', (Real.exp_pos (-2 * z.2)).ne']

noncomputable def correction (i : Side) (s t : ℝ) : ℝ :=
  (t / (t + 1)) ^ 2 * (weight i s / weight i.flip t)

theorem weight_measurable (i : Side) : Measurable (weight i) := by
  cases i
  · exact phiEven_measurable
  · exact phiOdd_continuous.measurable

theorem correction_measurable (i : Side) (s : ℝ) : Measurable (correction i s) :=
  ((measurable_id.div (measurable_id.add measurable_const)).pow_const 2).mul
    (measurable_const.div (weight_measurable i.flip))

noncomputable def harmonicRatioDensity (i : Side) (s : ℝ) : ℝ → ℝ≥0∞ :=
  (Ici (minRatio i s)).indicator (fun t => ENNReal.ofReal (1 / (t + 1)))

theorem harmonicRatioDensity_measurable (i : Side) (s : ℝ) : Measurable (harmonicRatioDensity i s) :=
  (ENNReal.measurable_ofReal.comp (measurable_const.div (measurable_id.add measurable_const))).indicator measurableSet_Ici

theorem corrected_density_eq {i : Side} {s : ℝ} (hs : Valid i s) (t : ℝ) :
    ENNReal.ofReal (transitionDensity i s t) * ENNReal.ofReal (correction i s t) =
      harmonicRatioDensity i s t := by
  by_cases ht : minRatio i s ≤ t
  · have hv := valid_next hs ht
    have hp : 0 ≤ transitionDensity i s t := by
      unfold transitionDensity tailDensity
      rw [indicator_of_mem (show t ∈ Ici (minRatio i s) from ht)]
      exact div_nonneg (mul_nonneg (W_pos (valid_pos hv)).le (weight_pos hv).le) (weight_pos hs).le
    rw [← ENNReal.ofReal_mul hp, harmonicRatioDensity,
      indicator_of_mem (show t ∈ Ici (minRatio i s) from ht)]
    congr 1
    have he := step_weight_identity (r := 1) hs ht (by norm_num)
    simpa only [correction, nextGap, one_mul, div_one, mul_assoc] using he.symm
  · rw [transitionDensity, tailDensity, indicator_of_notMem (show t ∉ Ici (minRatio i s) from ht),
      ENNReal.ofReal_zero, zero_mul, harmonicRatioDensity,
      indicator_of_notMem (show t ∉ Ici (minRatio i s) from ht)]

theorem initial_weight_inv (s : State) : (harmonicWeight (s, 0))⁻¹ = ENNReal.ofReal (stateWeight s) := by
  change (ENNReal.ofReal (Real.exp (-2 * (0 : ℝ)) / stateWeight s))⁻¹ = _
  rw [mul_zero, Real.exp_zero, ENNReal.ofReal_div_of_pos (stateWeight_pos s), ENNReal.ofReal_one, one_div, inv_inv]

theorem harmonic_prefix_lintegral (n : ℕ) (s : State) {F : CostState → ℝ≥0∞} (hF : Measurable F) :
    (∫⁻ z, F z ∂(harmonicKernel ^ n) (s, 0)) = ENNReal.ofReal (stateWeight s) *
      ∫⁻ z, ENNReal.ofReal (Real.exp (-2 * z.2) / stateWeight z.1) * F z ∂(costKernel ^ n) (s, 0) := by
  rw [harmonicKernel, conjugate_pow_lintegral costKernel harmonicWeight n (s, 0) hF, initial_weight_inv]
  rfl

noncomputable def harmonicOccupation : Kernel CostState CostState := Kernel.sum (fun n : ℕ => harmonicKernel ^ n)

instance harmonicOccupation_isSFiniteKernel : IsSFiniteKernel harmonicOccupation := by
  unfold harmonicOccupation
  infer_instance

theorem inclusiveOccupation_eq_prefix_sum : inclusiveOccupation = Kernel.sum (fun n : ℕ => costKernel ^ n) := by
  ext z B hB
  rw [inclusiveOccupation, _root_.add_apply, Measure.add_apply, fullOccupation,
    Kernel.sum_apply' _ _ hB, Kernel.sum_apply' _ _ hB]
  exact (tsum_eq_zero_add' (f := fun n : ℕ => (costKernel ^ n) z B) ENNReal.summable).symm

theorem harmonicOccupation_transform : harmonicOccupation = conjugate inclusiveOccupation harmonicWeight := by
  rw [harmonicOccupation, harmonicKernel, conjugate_prefix_sum]
  exact conjugate_congr _ _ inclusiveOccupation_eq_prefix_sum.symm harmonicWeight

end NumberTheoryLean.HarmonicWeightKernel

end

section

namespace NumberTheoryLean.HarmonicKernelDensities

open Set MeasureTheory ProbabilityTheory
open scoped ENNReal
open TransitionKernels FinitePathGeometry FinitePathMeasures PairedCostGrouping
open KernelDensityBridge InvariantInverseWeights KernelWeightTransform HarmonicWeightKernel
open Erdos970Dependency.OrdinaryKernelInvariance Erdos970Dependency.StateKernelInvariance

theorem harmonic_even_typed (s : EvenState) (T : ℝ) {H : CostState → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ y, H y ∂harmonicKernel (.inl s, T)) =
      ∫⁻ t : OddState, ENNReal.ofReal (correction .even s.1 t.1) * H (.inr t, T + cost t.1) ∂evenToOdd s := by
  have hm : Measurable (fun y : CostState => (harmonicWeight y / harmonicWeight (.inl s, T)) * H y) :=
    (harmonicWeight.measurable_value.div measurable_const).mul hH
  rw [harmonicKernel, conjugate_lintegral costKernel harmonicWeight (.inl s, T) hH,
    costKernel_even_lintegral s T (H := fun y : CostState => (harmonicWeight y / harmonicWeight (.inl s, T)) * H y) hm]
  apply lintegral_congr
  intro t
  have hr : harmonicWeight (.inr t, T + cost t.1) / harmonicWeight (.inl s, T) =
      ENNReal.ofReal (correction .even s.1 t.1) := by
    simpa only [stateRatio, stateWeight, weight, Side.flip, correction, Sum.elim_inl, Sum.elim_inr] using
      transition_weight_ratio (.inl s, T) (.inr t)
  exact congrArg (fun c : ℝ≥0∞ => c * H (.inr t, T + cost t.1)) hr

theorem harmonic_odd_typed (s : OddState) (T : ℝ) {H : CostState → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ y, H y ∂harmonicKernel (.inr s, T)) =
      ∫⁻ t : EvenState, ENNReal.ofReal (correction .odd s.1 t.1) * H (.inl t, T + cost t.1) ∂oddToEven s := by
  have hm : Measurable (fun y : CostState => (harmonicWeight y / harmonicWeight (.inr s, T)) * H y) :=
    (harmonicWeight.measurable_value.div measurable_const).mul hH
  rw [harmonicKernel, conjugate_lintegral costKernel harmonicWeight (.inr s, T) hH,
    costKernel_odd_lintegral s T (H := fun y : CostState => (harmonicWeight y / harmonicWeight (.inr s, T)) * H y) hm]
  apply lintegral_congr
  intro t
  have hr : harmonicWeight (.inl t, T + cost t.1) / harmonicWeight (.inr s, T) =
      ENNReal.ofReal (correction .odd s.1 t.1) := by
    simpa only [stateRatio, stateWeight, weight, Side.flip, correction, Sum.elim_inl, Sum.elim_inr] using
      transition_weight_ratio (.inr s, T) (.inl t)
  exact congrArg (fun c : ℝ≥0∞ => c * H (.inl t, T + cost t.1)) hr

noncomputable def evenUpdateReal (T t : ℝ) : CostState := (.inr (oddLift t), T + cost t)
noncomputable def oddUpdateReal (T t : ℝ) : CostState := (.inl (evenLift t), T + cost t)

theorem evenUpdateReal_measurable (T : ℝ) : Measurable (evenUpdateReal T) :=
  (measurable_inr.comp oddLift_measurable).prodMk (measurable_const.add cost_measurable)

theorem oddUpdateReal_measurable (T : ℝ) : Measurable (oddUpdateReal T) :=
  (measurable_inl.comp evenLift_measurable).prodMk (measurable_const.add cost_measurable)

theorem harmonic_even_joint_lintegral (s : EvenState) (T : ℝ) {H : CostState → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ y, H y ∂harmonicKernel (.inl s, T)) =
      ∫⁻ t : ℝ, harmonicRatioDensity .even s.1 t * H (evenUpdateReal T t) := by
  let G : ℝ → ℝ≥0∞ := fun t => ENNReal.ofReal (correction .even s.1 t) * H (evenUpdateReal T t)
  have hG : Measurable G := (ENNReal.measurable_ofReal.comp (correction_measurable .even s.1)).mul
    (hH.comp (evenUpdateReal_measurable T))
  rw [harmonic_even_typed s T hH]
  calc
    _ = ∫⁻ t : OddState, G t.1 ∂evenToOdd s := by
      apply lintegral_congr
      intro t
      simp only [G, evenUpdateReal, oddLift_ratio]
    _ = ∫⁻ t : ℝ, G t ∂evenKernel s := evenToOdd_lintegral_ratio s hG
    _ = ∫⁻ t : ℝ, ENNReal.ofReal (transitionDensity .even s.1 t) * G t := evenKernel_lintegral_density s hG
    _ = _ := by
      apply lintegral_congr
      intro t
      dsimp [G]
      rw [← mul_assoc, corrected_density_eq (i := .even) (s := s.1) s.2 t]

theorem harmonic_odd_joint_lintegral (s : OddState) (T : ℝ) {H : CostState → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ y, H y ∂harmonicKernel (.inr s, T)) =
      ∫⁻ t : ℝ, harmonicRatioDensity .odd s.1 t * H (oddUpdateReal T t) := by
  let G : ℝ → ℝ≥0∞ := fun t => ENNReal.ofReal (correction .odd s.1 t) * H (oddUpdateReal T t)
  have hG : Measurable G := (ENNReal.measurable_ofReal.comp (correction_measurable .odd s.1)).mul
    (hH.comp (oddUpdateReal_measurable T))
  rw [harmonic_odd_typed s T hH]
  calc
    _ = ∫⁻ t : EvenState, G t.1 ∂oddToEven s := by
      apply lintegral_congr
      intro t
      simp only [G, oddUpdateReal, evenLift_ratio]
    _ = ∫⁻ t : ℝ, G t ∂oddKernel s := oddToEven_lintegral_ratio s hG
    _ = ∫⁻ t : ℝ, ENNReal.ofReal (transitionDensity .odd s.1 t) * G t := oddKernel_lintegral_density s hG
    _ = _ := by
      apply lintegral_congr
      intro t
      dsimp [G]
      rw [← mul_assoc, corrected_density_eq (i := .odd) (s := s.1) s.2 t]

theorem harmonic_even_measure (s : EvenState) (T : ℝ) :
    harmonicKernel (.inl s, T) =
      (volume.withDensity (harmonicRatioDensity .even s.1)).map (evenUpdateReal T) := by
  apply Measure.ext_of_lintegral
  intro H hH
  rw [harmonic_even_joint_lintegral s T hH,
    lintegral_map hH (evenUpdateReal_measurable T),
    lintegral_withDensity_eq_lintegral_mul volume (f := harmonicRatioDensity .even s.1)
      (g := fun t => H (evenUpdateReal T t)) (harmonicRatioDensity_measurable .even s.1)
      (hH.comp (evenUpdateReal_measurable T))]
  rfl

theorem harmonic_odd_measure (s : OddState) (T : ℝ) :
    harmonicKernel (.inr s, T) =
      (volume.withDensity (harmonicRatioDensity .odd s.1)).map (oddUpdateReal T) := by
  apply Measure.ext_of_lintegral
  intro H hH
  rw [harmonic_odd_joint_lintegral s T hH,
    lintegral_map hH (oddUpdateReal_measurable T),
    lintegral_withDensity_eq_lintegral_mul volume (f := harmonicRatioDensity .odd s.1)
      (g := fun t => H (oddUpdateReal T t)) (harmonicRatioDensity_measurable .odd s.1)
      (hH.comp (oddUpdateReal_measurable T))]
  rfl

end NumberTheoryLean.HarmonicKernelDensities

end

section

namespace NumberTheoryLean.ArrivalKernelGeometry

open Filter Set MeasureTheory ProbabilityTheory
open scoped ENNReal
open TransitionKernels FinitePathGeometry FinitePathMeasures PairedCostGrouping
open OccupationBoundaries RegeneratingInverseBands KernelDensityBridge
open HarmonicWeightKernel KernelWeightTransform

noncomputable def currentExponent (v : ℝ) (z : CostState) : ℝ := gapValue v z / stateRatio z.1

theorem gapValue_measurable (v : ℝ) : Measurable (gapValue v) :=
  Real.measurable_exp.comp (measurable_const.sub measurable_snd)

theorem currentExponent_measurable (v : ℝ) : Measurable (currentExponent v) :=
  (gapValue_measurable v).div (stateRatio_measurable.comp measurable_fst)

theorem currentExponent_pos (v : ℝ) (z : CostState) : 0 < currentExponent v z :=
  div_pos (Real.exp_pos _) (stateRatio_pos z.1)

def arrivalSet (v ell : ℝ) : Set CostState := {z | ell < currentExponent v z}

theorem arrivalSet_measurable (v ell : ℝ) : MeasurableSet (arrivalSet v ell) :=
  measurableSet_lt measurable_const (currentExponent_measurable v)

theorem arrivalSet_eq_cutoff (v : ℝ) {ell : ℝ} (hell : 0 < ell) :
    arrivalSet v ell = {z | stateRatio z.1 < gapValue v z / ell} := by
  ext z
  change ell < gapValue v z / stateRatio z.1 ↔ stateRatio z.1 < gapValue v z / ell
  rw [lt_div_iff₀ (stateRatio_pos z.1), lt_div_iff₀ hell, mul_comm ell (stateRatio z.1)]

theorem gapValue_update (v : ℝ) (z : CostState) (s : State) :
    gapValue v (s, z.2 + cost (stateRatio s)) = nextGap (gapValue v z) (stateRatio s) := by
  rw [nextGap_eq_cost (stateRatio_pos s)]
  change Real.exp (v - (z.2 + cost (stateRatio s))) = Real.exp (v - z.2) * Real.exp (-cost (stateRatio s))
  rw [show v - (z.2 + cost (stateRatio s)) = (v - z.2) + (-cost (stateRatio s)) by ring, Real.exp_add]

theorem currentExponent_update (v : ℝ) (z : CostState) (s : State) :
    currentExponent v (s, z.2 + cost (stateRatio s)) = nextExponent (gapValue v z) (stateRatio s) := by
  change gapValue v (s, z.2 + cost (stateRatio s)) / stateRatio s = _
  rw [gapValue_update, nextGap_div_ratio (stateRatio_pos s)]

theorem stateKernel_ae_minRatio (s : State) :
    ∀ᵐ t ∂stateKernel s, minRatio (stateSide s) (stateRatio s) ≤ stateRatio t := by
  cases s with
  | inl s =>
    change ∀ᵐ t ∂stateKernel (.inl s), s.1 - 1 ≤ stateRatio t
    have h : ∀ᵐ u ∂(stateKernel (.inl s)).map stateRatio, s.1 - 1 ≤ u := by
      rw [stateKernel_even_ratio]
      exact evenKernel_ae_support s
    exact (ae_map_iff stateRatio_measurable.aemeasurable measurableSet_Ici).mp h
  | inr s =>
    change ∀ᵐ t ∂stateKernel (.inr s), max 2 (s.1 - 1) ≤ stateRatio t
    have h : ∀ᵐ u ∂(stateKernel (.inr s)).map stateRatio, max 2 (s.1 - 1) ≤ u := by
      rw [stateKernel_odd_ratio]
      exact oddKernel_ae_support s
    exact (ae_map_iff stateRatio_measurable.aemeasurable measurableSet_Ici).mp h

theorem costKernel_gap_flow (v : ℝ) (z : CostState) :
    ∀ᵐ y ∂costKernel z, gapValue v z = gapValue v y + currentExponent v y := by
  have hm : Measurable (fun s : State => (s, z.2 + cost (stateRatio s))) :=
    measurable_id.prodMk (measurable_const.add (cost_measurable.comp stateRatio_measurable))
  have hp : MeasurableSet {y : CostState | gapValue v z = gapValue v y + currentExponent v y} :=
    measurableSet_eq_fun measurable_const ((gapValue_measurable v).add (currentExponent_measurable v))
  rw [costKernel_eq_map]
  apply (ae_map_iff hm.aemeasurable hp).mpr
  apply Eventually.of_forall
  intro s
  rw [gapValue_update, currentExponent_update]
  exact (gap_exponent_conservation (stateRatio_pos s)).symm

theorem costKernel_exponent_nonincreasing (v : ℝ) (z : CostState) :
    ∀ᵐ y ∂costKernel z, currentExponent v y ≤ currentExponent v z := by
  have hm : Measurable (fun s : State => (s, z.2 + cost (stateRatio s))) :=
    measurable_id.prodMk (measurable_const.add (cost_measurable.comp stateRatio_measurable))
  have hp : MeasurableSet {y : CostState | currentExponent v y ≤ currentExponent v z} :=
    measurableSet_le (currentExponent_measurable v) measurable_const
  rw [costKernel_eq_map]
  apply (ae_map_iff hm.aemeasurable hp).mpr
  filter_upwards [stateKernel_ae_minRatio z.1] with s hs
  rw [currentExponent_update]
  exact exponent_le_cutoff (stateRatio_valid z.1) hs (Real.exp_pos _)

theorem harmonicKernel_absolutelyContinuous (z : CostState) : harmonicKernel z ≪ costKernel z :=
  Kernel.withDensity_absolutelyContinuous (fun a b => harmonicWeight b / harmonicWeight a) z

theorem harmonicKernel_gap_flow (v : ℝ) (z : CostState) :
    ∀ᵐ y ∂harmonicKernel z, gapValue v z = gapValue v y + currentExponent v y :=
  (harmonicKernel_absolutelyContinuous z).ae_le (costKernel_gap_flow v z)

theorem harmonicKernel_exponent_nonincreasing (v : ℝ) (z : CostState) :
    ∀ᵐ y ∂harmonicKernel z, currentExponent v y ≤ currentExponent v z :=
  (harmonicKernel_absolutelyContinuous z).ae_le (costKernel_exponent_nonincreasing v z)

theorem costKernel_no_reentry (v ell : ℝ) (z : CostState) (hz : z ∉ arrivalSet v ell) :
    costKernel z (arrivalSet v ell) = 0 := by
  have hZ : currentExponent v z ≤ ell := le_of_not_gt hz
  have h : ∀ᵐ y ∂costKernel z, y ∉ arrivalSet v ell := by
    filter_upwards [costKernel_exponent_nonincreasing v z] with y hy
    exact not_lt_of_ge (le_trans hy hZ)
  simpa only [ae_iff, not_not, Set.ofPred_mem_eq] using h

theorem harmonicKernel_no_reentry (v ell : ℝ) (z : CostState) (hz : z ∉ arrivalSet v ell) :
    harmonicKernel z (arrivalSet v ell) = 0 :=
  harmonicKernel_absolutelyContinuous z (costKernel_no_reentry v ell z hz)

end NumberTheoryLean.ArrivalKernelGeometry

end

end Erdos970

end OAI