import Mathlib.Probability.Kernel.Composition.CompProd
import OAI.NumberTheory.Jacobsthal.Analysis.WeightIntegrals
import OAI.NumberTheory.Jacobsthal.Sieve.CompactExponentialMoments

namespace OAI

namespace Erdos970

section

namespace NumberTheoryLean.KernelDensityBridge

open Set MeasureTheory ProbabilityTheory
open scoped ProbabilityTheory ENNReal
open DerivativeWeights TransitionKernels FinitePathGeometry FinitePathMeasures

theorem evenToOdd_map_ratio (s : EvenState) :
    (evenToOdd s).map (Subtype.val : OddState → ℝ) = evenKernel s := by
  calc
    _ = (evenKernel s).restrict (Ici (95 / 100 : ℝ)) := by
      change ((evenKernel s).comap (Subtype.val : OddState → ℝ)).map Subtype.val = _
      exact map_comap_subtype_coe (μ := evenKernel s) (s := Ici (95 / 100 : ℝ)) measurableSet_Ici
    _ = _ := Measure.restrict_eq_self_of_ae_mem (evenKernel_ae_odd_domain s)

theorem oddToEven_map_ratio (s : OddState) :
    (oddToEven s).map (Subtype.val : EvenState → ℝ) = oddKernel s := by
  calc
    _ = (oddKernel s).restrict (Ici (198 / 100 : ℝ)) := by
      change ((oddKernel s).comap (Subtype.val : EvenState → ℝ)).map Subtype.val = _
      exact map_comap_subtype_coe (μ := oddKernel s) (s := Ici (198 / 100 : ℝ)) measurableSet_Ici
    _ = _ := Measure.restrict_eq_self_of_ae_mem (oddKernel_ae_even_domain s)

theorem stateKernel_even_ratio (s : EvenState) :
    (stateKernel (.inl s)).map stateRatio = evenKernel s := by
  change (evenBranch s).map stateRatio = _
  rw [evenBranch, Kernel.map_apply _ measurable_inr,
    Measure.map_map stateRatio_measurable measurable_inr]
  exact evenToOdd_map_ratio s

theorem stateKernel_odd_ratio (s : OddState) :
    (stateKernel (.inr s)).map stateRatio = oddKernel s := by
  change (oddBranch s).map stateRatio = _
  rw [oddBranch, Kernel.map_apply _ measurable_inl,
    Measure.map_map stateRatio_measurable measurable_inl]
  exact oddToEven_map_ratio s

theorem evenToOdd_lintegral_ratio (s : EvenState) {H : ℝ → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ t : OddState, H t.1 ∂evenToOdd s) = ∫⁻ t, H t ∂evenKernel s := by
  rw [← evenToOdd_map_ratio, lintegral_map hH measurable_subtype_coe]

theorem oddToEven_lintegral_ratio (s : OddState) {H : ℝ → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ t : EvenState, H t.1 ∂oddToEven s) = ∫⁻ t, H t ∂oddKernel s := by
  rw [← oddToEven_map_ratio, lintegral_map hH measurable_subtype_coe]

theorem evenKernel_lintegral_density (s : EvenState) {H : ℝ → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ t, H t ∂evenKernel s) =
      ∫⁻ t, ENNReal.ofReal (transitionDensity .even s.1 t) * H t := by
  exact Kernel.lintegral_withDensity (Kernel.const EvenState volume)
    (f := fun s t => ENNReal.ofReal (evenDensity s t))
    (ENNReal.measurable_ofReal.comp evenDensity_measurable) s hH

theorem oddKernel_lintegral_density (s : OddState) {H : ℝ → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ t, H t ∂oddKernel s) =
      ∫⁻ t, ENNReal.ofReal (transitionDensity .odd s.1 t) * H t := by
  exact Kernel.lintegral_withDensity (Kernel.const OddState volume)
    (f := fun s t => ENNReal.ofReal (oddDensity s t))
    (ENNReal.measurable_ofReal.comp oddDensity_measurable) s hH

theorem transitionDensity_joint_measurable (i : Side) :
    Measurable (Function.uncurry (transitionDensity i)) := by
  cases i with
  | even =>
    change Measurable (fun x : ℝ × ℝ =>
      if x.1 - 1 ≤ x.2 then W x.2 * phiOdd x.2 / phiEven x.1 else 0)
    apply Measurable.ite (measurableSet_le (measurable_fst.sub measurable_const) measurable_snd)
    · exact ((W_measurable.comp measurable_snd).mul
        (phiOdd_continuous.measurable.comp measurable_snd)).div (phiEven_measurable.comp measurable_fst)
    · exact measurable_const
  | odd =>
    change Measurable (fun x : ℝ × ℝ =>
      if max 2 (x.1 - 1) ≤ x.2 then W x.2 * phiEven x.2 / phiOdd x.1 else 0)
    apply Measurable.ite (measurableSet_le
      (measurable_const.max (measurable_fst.sub measurable_const)) measurable_snd)
    · exact ((W_measurable.comp measurable_snd).mul
        (phiEven_measurable.comp measurable_snd)).div (phiOdd_continuous.measurable.comp measurable_fst)
    · exact measurable_const

noncomputable def evenTwoStep : Kernel EvenState (ℝ × ℝ) :=
  (evenToOdd ⊗ₖ oddToEven.prodMkLeft EvenState).map (fun x : OddState × EvenState => (x.1.1, x.2.1))

noncomputable def oddTwoStep : Kernel OddState (ℝ × ℝ) :=
  (oddToEven ⊗ₖ evenToOdd.prodMkLeft OddState).map (fun x : EvenState × OddState => (x.1.1, x.2.1))

instance evenTwoStep_isMarkovKernel : IsMarkovKernel evenTwoStep :=
  Kernel.IsMarkovKernel.map _ ((measurable_subtype_coe.comp measurable_fst).prodMk
    (measurable_subtype_coe.comp measurable_snd))

instance oddTwoStep_isMarkovKernel : IsMarkovKernel oddTwoStep :=
  Kernel.IsMarkovKernel.map _ ((measurable_subtype_coe.comp measurable_fst).prodMk
    (measurable_subtype_coe.comp measurable_snd))

theorem evenTwoStep_lintegral (s : EvenState) {H : ℝ × ℝ → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ x, H x ∂evenTwoStep s) = ∫⁻ t, ∫⁻ u,
      ENNReal.ofReal (transitionDensity .even s.1 t) *
        ENNReal.ofReal (transitionDensity .odd t u) * H (t, u) := by
  have hm : Measurable (fun x : OddState × EvenState => (x.1.1, x.2.1)) :=
    (measurable_subtype_coe.comp measurable_fst).prodMk (measurable_subtype_coe.comp measurable_snd)
  rw [evenTwoStep, Kernel.lintegral_map _ hm _ hH]
  rw [Kernel.lintegral_compProd evenToOdd (oddToEven.prodMkLeft EvenState) s
    (f := fun x : OddState × EvenState => H (x.1.1, x.2.1)) (hH.comp hm)]
  change (∫⁻ t : OddState, ∫⁻ u : EvenState, H (t.1, u.1) ∂oddToEven t ∂evenToOdd s) = _
  have hinner : ∀ t : OddState, (∫⁻ u : EvenState, H (t.1, u.1) ∂oddToEven t) =
      ∫⁻ u, ENNReal.ofReal (transitionDensity .odd t.1 u) * H (t.1, u) := by
    intro t
    rw [oddToEven_lintegral_ratio t (H := fun u : ℝ => H (t.1, u)) (hH.comp measurable_prodMk_left),
      oddKernel_lintegral_density t (H := fun u : ℝ => H (t.1, u)) (hH.comp measurable_prodMk_left)]
  simp_rw [hinner]
  have hJ : Measurable (fun t : ℝ => ∫⁻ u,
      ENNReal.ofReal (transitionDensity .odd t u) * H (t, u)) :=
    ((ENNReal.measurable_ofReal.comp (transitionDensity_joint_measurable .odd)).mul hH).lintegral_prod_right
  rw [evenToOdd_lintegral_ratio s hJ, evenKernel_lintegral_density s hJ]
  apply lintegral_congr
  intro t
  rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
  apply lintegral_congr
  intro u
  ring

theorem oddTwoStep_lintegral (s : OddState) {H : ℝ × ℝ → ℝ≥0∞} (hH : Measurable H) :
    (∫⁻ x, H x ∂oddTwoStep s) = ∫⁻ t, ∫⁻ u,
      ENNReal.ofReal (transitionDensity .odd s.1 t) *
        ENNReal.ofReal (transitionDensity .even t u) * H (t, u) := by
  have hm : Measurable (fun x : EvenState × OddState => (x.1.1, x.2.1)) :=
    (measurable_subtype_coe.comp measurable_fst).prodMk (measurable_subtype_coe.comp measurable_snd)
  rw [oddTwoStep, Kernel.lintegral_map _ hm _ hH]
  rw [Kernel.lintegral_compProd oddToEven (evenToOdd.prodMkLeft OddState) s
    (f := fun x : EvenState × OddState => H (x.1.1, x.2.1)) (hH.comp hm)]
  change (∫⁻ t : EvenState, ∫⁻ u : OddState, H (t.1, u.1) ∂evenToOdd t ∂oddToEven s) = _
  have hinner : ∀ t : EvenState, (∫⁻ u : OddState, H (t.1, u.1) ∂evenToOdd t) =
      ∫⁻ u, ENNReal.ofReal (transitionDensity .even t.1 u) * H (t.1, u) := by
    intro t
    rw [evenToOdd_lintegral_ratio t (H := fun u : ℝ => H (t.1, u)) (hH.comp measurable_prodMk_left),
      evenKernel_lintegral_density t (H := fun u : ℝ => H (t.1, u)) (hH.comp measurable_prodMk_left)]
  simp_rw [hinner]
  have hJ : Measurable (fun t : ℝ => ∫⁻ u,
      ENNReal.ofReal (transitionDensity .even t u) * H (t, u)) :=
    ((ENNReal.measurable_ofReal.comp (transitionDensity_joint_measurable .even)).mul hH).lintegral_prod_right
  rw [oddToEven_lintegral_ratio s hJ, oddKernel_lintegral_density s hJ]
  apply lintegral_congr
  intro t
  rw [← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
  apply lintegral_congr
  intro u
  ring

noncomputable def jointDensity (i : Side) (s : ℝ) (x : ℝ × ℝ) : ℝ≥0∞ :=
  ENNReal.ofReal (transitionDensity i s x.1) * ENNReal.ofReal (transitionDensity i.flip x.1 x.2)

theorem jointDensity_measurable (i : Side) (s : ℝ) : Measurable (jointDensity i s) := by
  exact (ENNReal.measurable_ofReal.comp ((transitionDensity_joint_measurable i).comp
    (measurable_const.prodMk measurable_fst))).mul
    (ENNReal.measurable_ofReal.comp (transitionDensity_joint_measurable i.flip))

theorem evenTwoStep_eq_withDensity (s : EvenState) :
    evenTwoStep s = ((volume : Measure ℝ).prod volume).withDensity (jointDensity .even s.1) := by
  apply Measure.ext_of_lintegral
  intro H hH
  rw [evenTwoStep_lintegral s hH,
    lintegral_withDensity_eq_lintegral_mul _ (jointDensity_measurable .even s.1) hH]
  have hp := lintegral_prod (μ := (volume : Measure ℝ)) (ν := (volume : Measure ℝ))
    (fun x => jointDensity .even s.1 x * H x) ((jointDensity_measurable .even s.1).mul hH).aemeasurable
  exact hp.symm

theorem oddTwoStep_eq_withDensity (s : OddState) :
    oddTwoStep s = ((volume : Measure ℝ).prod volume).withDensity (jointDensity .odd s.1) := by
  apply Measure.ext_of_lintegral
  intro H hH
  rw [oddTwoStep_lintegral s hH,
    lintegral_withDensity_eq_lintegral_mul _ (jointDensity_measurable .odd s.1) hH]
  have hp := lintegral_prod (μ := (volume : Measure ℝ)) (ν := (volume : Measure ℝ))
    (fun x => jointDensity .odd s.1 x * H x) ((jointDensity_measurable .odd s.1).mul hH).aemeasurable
  exact hp.symm

end NumberTheoryLean.KernelDensityBridge

end

section

namespace NumberTheoryLean.JointMinorization

open Filter Set MeasureTheory ProbabilityTheory
open scoped ProbabilityTheory ENNReal
open DerivativeWeights TransitionKernels FinitePathGeometry FinitePathMeasures
open KernelDensityBridge TwoStepDensityBounds

def rectangle (L : ℝ) : Set (ℝ × ℝ) := Icc L (L + 1) ×ˢ Icc (L + 1) (L + 2)

theorem rectangle_measurable (L : ℝ) : MeasurableSet (rectangle L) :=
  measurableSet_Icc.prod measurableSet_Icc

noncomputable def rectangleLaw (L : ℝ) : Measure (ℝ × ℝ) :=
  ((volume : Measure ℝ).prod volume).restrict (rectangle L)

instance rectangleLaw_isProbabilityMeasure (L : ℝ) : IsProbabilityMeasure (rectangleLaw L) := by
  constructor
  rw [rectangleLaw, Measure.restrict_apply MeasurableSet.univ, univ_inter,
    rectangle, Measure.prod_prod, Real.volume_Icc, Real.volume_Icc]
  rw [show L + 1 - L = 1 by ring, show L + 2 - (L + 1) = 1 by ring]
  norm_num

theorem transitionDensity_nonneg {i : Side} {s : ℝ} (hs : Valid i s) (t : ℝ) :
    0 ≤ transitionDensity i s t := by
  cases i with
  | even => exact evenDensity_nonneg ⟨s, hs⟩ t
  | odd => exact oddDensity_nonneg ⟨s, hs⟩ t

theorem rectangle_minorization {i : Side} {s L : ℝ} (hL : 3 ≤ L)
    (hs : Valid i s) (hsL : s ≤ L) :
    ENNReal.ofReal (minorizationSize L) • rectangleLaw L ≤
      ((volume : Measure ℝ).prod volume).withDensity (jointDensity i s) := by
  rw [rectangleLaw, ← withDensity_const,
    ← withDensity_indicator (rectangle_measurable L)]
  apply withDensity_mono
  apply Eventually.of_forall
  intro x
  by_cases hx : x ∈ rectangle L
  · rw [indicator_of_mem hx]
    change ENNReal.ofReal (minorizationSize L) ≤
      ENNReal.ofReal (transitionDensity i s x.1) * ENNReal.ofReal (transitionDensity i.flip x.1 x.2)
    rw [← ENNReal.ofReal_mul (transitionDensity_nonneg hs x.1)]
    exact ENNReal.ofReal_le_ofReal (le_trans (minorizationSize_le_rectangle i L)
      (rectangle_density_lower hL hs hsL hx.1 hx.2))
  · rw [indicator_of_notMem hx]
    exact zero_le

theorem evenTwoStep_rectangle_minorization {L : ℝ} (hL : 3 ≤ L)
    (s : EvenState) (hs : s.1 ≤ L) :
    ENNReal.ofReal (minorizationSize L) • rectangleLaw L ≤ evenTwoStep s := by
  rw [evenTwoStep_eq_withDensity]
  exact rectangle_minorization hL s.2 hs

theorem oddTwoStep_rectangle_minorization {L : ℝ} (hL : 3 ≤ L)
    (s : OddState) (hs : s.1 ≤ L) :
    ENNReal.ofReal (minorizationSize L) • rectangleLaw L ≤ oddTwoStep s := by
  rw [oddTwoStep_eq_withDensity]
  exact rectangle_minorization hL s.2 hs

noncomputable def pairCost (T : ℝ) (x : ℝ × ℝ) : ℝ × ℝ :=
  (x.2, T + cost x.1 + cost x.2)

theorem pairCost_measurable (T : ℝ) : Measurable (pairCost T) :=
  measurable_snd.prodMk ((measurable_const.add (cost_measurable.comp measurable_fst)).add
    (cost_measurable.comp measurable_snd))

noncomputable def minorizingLaw (L T : ℝ) : Measure (ℝ × ℝ) := (rectangleLaw L).map (pairCost T)

instance minorizingLaw_isProbabilityMeasure (L T : ℝ) : IsProbabilityMeasure (minorizingLaw L T) :=
  (Measure.isProbabilityMeasure_map_iff (μ := rectangleLaw L)
    (pairCost_measurable T).aemeasurable).mpr inferInstance

noncomputable def evenJointKernel (T : ℝ) : Kernel EvenState (ℝ × ℝ) := evenTwoStep.map (pairCost T)
noncomputable def oddJointKernel (T : ℝ) : Kernel OddState (ℝ × ℝ) := oddTwoStep.map (pairCost T)

instance evenJointKernel_isMarkovKernel (T : ℝ) : IsMarkovKernel (evenJointKernel T) :=
  Kernel.IsMarkovKernel.map _ (pairCost_measurable T)

instance oddJointKernel_isMarkovKernel (T : ℝ) : IsMarkovKernel (oddJointKernel T) :=
  Kernel.IsMarkovKernel.map _ (pairCost_measurable T)

theorem even_joint_minorization {L : ℝ} (hL : 3 ≤ L) (s : EvenState) (hs : s.1 ≤ L) (T : ℝ) :
    ENNReal.ofReal (minorizationSize L) • minorizingLaw L T ≤ evenJointKernel T s := by
  rw [evenJointKernel, Kernel.map_apply _ (pairCost_measurable T)]
  have h := Measure.map_mono (evenTwoStep_rectangle_minorization hL s hs) (pairCost_measurable T)
  rw [Measure.map_smul _ (pairCost_measurable T).aemeasurable] at h
  exact h

theorem odd_joint_minorization {L : ℝ} (hL : 3 ≤ L) (s : OddState) (hs : s.1 ≤ L) (T : ℝ) :
    ENNReal.ofReal (minorizationSize L) • minorizingLaw L T ≤ oddJointKernel T s := by
  rw [oddJointKernel, Kernel.map_apply _ (pairCost_measurable T)]
  have h := Measure.map_mono (oddTwoStep_rectangle_minorization hL s hs) (pairCost_measurable T)
  rw [Measure.map_smul _ (pairCost_measurable T).aemeasurable] at h
  exact h

theorem compact_joint_minorization (S : ℝ) : ∃ L ε : ℝ, 3 ≤ L ∧ S ≤ L ∧ 0 < ε ∧ ε ≤ 1 ∧
    (∀ T : ℝ, IsProbabilityMeasure (minorizingLaw L T)) ∧
    (∀ T : ℝ, ∀ s : EvenState, s.1 ≤ S → ENNReal.ofReal ε • minorizingLaw L T ≤ evenJointKernel T s) ∧
    (∀ T : ℝ, ∀ s : OddState, s.1 ≤ S → ENNReal.ofReal ε • minorizingLaw L T ≤ oddJointKernel T s) := by
  refine ⟨max 3 S, minorizationSize (max 3 S), le_max_left _ _, le_max_right _ _,
    minorizationSize_pos (le_max_left _ _), minorizationSize_le_one _, ?_, ?_, ?_⟩
  · intro T
    infer_instance
  · intro T s hs
    exact even_joint_minorization (le_max_left _ _) s (le_trans hs (le_max_right _ _)) T
  · intro T s hs
    exact odd_joint_minorization (le_max_left _ _) s (le_trans hs (le_max_right _ _)) T

end NumberTheoryLean.JointMinorization

end

section

namespace NumberTheoryLean.GoodPairTransitions

open Filter Set MeasureTheory ProbabilityTheory
open scoped ENNReal
open BuchstabBridge DerivativeWeights WeightFutureIntegrals TransitionKernels
open FinitePathGeometry FinitePathMeasures KernelDensityBridge TwoStepDensityBounds JointMinorization

def goodPair (s : ℝ) : Set (ℝ × ℝ) :=
  {x | x.1 ∈ Icc (max 2 (s - 1)) (max 2 (s - 1) + 1 / 4) ∧
    x.2 ∈ Icc (x.1 - 1) (x.1 - 3 / 4)}

theorem goodPair_measurable (s : ℝ) : MeasurableSet (goodPair s) := by
  exact ((measurableSet_le measurable_const measurable_fst).inter
    (measurableSet_le measurable_fst measurable_const)).inter
    ((measurableSet_le (measurable_fst.sub measurable_const) measurable_snd).inter
      (measurableSet_le measurable_snd (measurable_fst.sub measurable_const)))

theorem goodPair_volume (s : ℝ) : ((volume : Measure ℝ).prod volume) (goodPair s) = ENNReal.ofReal (1 / 16 : ℝ) := by
  rw [Measure.prod_apply (goodPair_measurable s)]
  have heq : ∀ t : ℝ, volume (Prod.mk t ⁻¹' goodPair s) =
      (Icc (max 2 (s - 1)) (max 2 (s - 1) + 1 / 4)).indicator
        (fun _ => ENNReal.ofReal (1 / 4 : ℝ)) t := by
    intro t
    by_cases ht : t ∈ Icc (max 2 (s - 1)) (max 2 (s - 1) + 1 / 4)
    · have hp : Prod.mk t ⁻¹' goodPair s = Icc (t - 1) (t - 3 / 4) := by
        ext u
        simp only [mem_preimage, goodPair, mem_ofPred_eq, ht, true_and]
      rw [hp, Real.volume_Icc, indicator_of_mem ht]
      congr 1
      ring
    · have hp : Prod.mk t ⁻¹' goodPair s = ∅ := by
        ext u
        simp only [mem_preimage, goodPair, mem_ofPred_eq, ht, false_and, mem_empty_iff_false]
      rw [hp, measure_empty, indicator_of_notMem ht]
  rw [lintegral_congr heq, lintegral_indicator measurableSet_Icc, setLIntegral_const, Real.volume_Icc]
  rw [show max 2 (s - 1) + 1 / 4 - max 2 (s - 1) = (1 : ℝ) / 4 by ring]
  rw [← ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 1 / 4)]
  congr 1
  norm_num

theorem goodPair_bounds {s M t u : ℝ} (hM : 4 ≤ M) (hs : s ≤ M) (hg : (t, u) ∈ goodPair s) :
    2 ≤ t ∧ 1 ≤ u ∧ t ≤ M ∧ u ≤ M := by
  have ht2 : 2 ≤ t := le_trans (le_max_left _ _) hg.1.1
  have ha : max 2 (s - 1) ≤ M - 1 := max_le (by linarith) (by linarith)
  exact ⟨ht2, by linarith [hg.2.1], by linarith [hg.1.2], by linarith [hg.1.2, hg.2.2]⟩

theorem goodPair_terminal {s t u : ℝ} (hg : (t, u) ∈ goodPair s) :
    u ≤ max (3 / 2) (s - 3 / 2) := by
  by_cases hs : s ≤ 3
  · have ha : max 2 (s - 1) = 2 := max_eq_left (by linarith)
    have ht := hg.1.2
    rw [ha] at ht
    exact le_trans (show u ≤ 3 / 2 by linarith [hg.2.2]) (le_max_left _ _)
  · have ha : max 2 (s - 1) = s - 1 := max_eq_right (by linarith)
    have ht := hg.1.2
    rw [ha] at ht
    exact le_trans (show u ≤ s - 3 / 2 by linarith [hg.2.2]) (le_max_right _ _)

theorem phiOdd_le_A (s : ℝ) : phiOdd s ≤ sieveA := by
  by_cases hs : s ≤ 3
  · exact le_of_eq (phiOdd_initial hs)
  · have h := phiOdd_antitone (show 3 ≤ s by linarith)
    rwa [phiOdd_initial (s := 3) le_rfl] at h

noncomputable def goodPairDensityLower (M : ℝ) : ℝ := (1 / M) ^ 2 * (phiOdd M / sieveA)

theorem goodPairDensityLower_pos {M : ℝ} (hM : 4 ≤ M) : 0 < goodPairDensityLower M := by
  unfold goodPairDensityLower
  exact mul_pos (sq_pos_of_pos (one_div_pos.mpr (by linarith))) (div_pos (phiOdd_pos M) sieveA_pos)

theorem goodPair_density_lower {M : ℝ} (hM : 4 ≤ M) (s : OddState) (hs : s.1 ≤ M)
    {t u : ℝ} (hg : (t, u) ∈ goodPair s.1) :
    goodPairDensityLower M ≤ transitionDensity .odd s.1 t * transitionDensity .even t u := by
  obtain ⟨ht2, hu1, htM, huM⟩ := goodPair_bounds hM hs hg
  have ht0 : 0 < t := by linarith
  have hu0 : 0 < u := by linarith
  have heq := two_step_density_eq (i := .odd) s.2 hg.1.1 hg.2.1
  change transitionDensity .odd s.1 t * transitionDensity .even t u =
    (W t * W u) * (phiOdd u / phiOdd s.1) at heq
  rw [heq]
  have hW : (1 / M) ^ 2 ≤ W t * W u := by
    simpa only [pow_two] using mul_le_mul (W_lower ht0 htM) (W_lower hu0 huM)
      (one_div_nonneg.mpr (by linarith)) (W_pos ht0).le
  have hr : phiOdd M / sieveA ≤ phiOdd u / phiOdd s.1 := by
    calc
      _ ≤ phiOdd M / phiOdd s.1 := div_le_div_of_nonneg_left (phiOdd_pos M).le (phiOdd_pos s.1) (phiOdd_le_A s.1)
      _ ≤ _ := div_le_div_of_nonneg_right (phiOdd_antitone huM) (phiOdd_pos s.1).le
  exact mul_le_mul hW hr (div_pos (phiOdd_pos M) sieveA_pos).le (mul_pos (W_pos ht0) (W_pos hu0)).le

theorem goodPair_measure_lower {M : ℝ} (hM : 4 ≤ M) (s : OddState) (hs : s.1 ≤ M) :
    ENNReal.ofReal (goodPairDensityLower M / 16) ≤ oddTwoStep s (goodPair s.1) := by
  have hdom : ENNReal.ofReal (goodPairDensityLower M) •
      ((volume : Measure ℝ).prod volume).restrict (goodPair s.1) ≤ oddTwoStep s := by
    rw [oddTwoStep_eq_withDensity, ← withDensity_const,
      ← withDensity_indicator (goodPair_measurable s.1)]
    apply withDensity_mono
    apply Eventually.of_forall
    intro x
    by_cases hx : x ∈ goodPair s.1
    · rw [indicator_of_mem hx]
      change ENNReal.ofReal (goodPairDensityLower M) ≤
        ENNReal.ofReal (transitionDensity .odd s.1 x.1) * ENNReal.ofReal (transitionDensity .even x.1 x.2)
      rw [← ENNReal.ofReal_mul (transitionDensity_nonneg (i := .odd) s.2 x.1)]
      exact ENNReal.ofReal_le_ofReal (goodPair_density_lower hM s hs hx)
    · rw [indicator_of_notMem hx]
      exact zero_le
  have h := hdom (goodPair s.1)
  rw [Measure.smul_apply, Measure.restrict_apply (goodPair_measurable s.1), inter_self,
    goodPair_volume, smul_eq_mul, ← ENNReal.ofReal_mul (goodPairDensityLower_pos hM).le] at h
  convert! h using 1
  congr 1
  ring

noncomputable def goodPairProbability (M : ℝ) : ℝ := min (1 / 2) (goodPairDensityLower M / 16)

theorem goodPairProbability_pos {M : ℝ} (hM : 4 ≤ M) : 0 < goodPairProbability M :=
  lt_min (by norm_num) (div_pos (goodPairDensityLower_pos hM) (by norm_num))

theorem goodPairProbability_le_one (M : ℝ) : goodPairProbability M ≤ 1 :=
  le_trans (min_le_left _ _) (by norm_num)

theorem odd_terminal_progress {M : ℝ} (hM : 4 ≤ M) (s : OddState) (hs : s.1 ≤ M) :
    ENNReal.ofReal (goodPairProbability M) ≤
      oddTwoStep s {x : ℝ × ℝ | x.2 ≤ max (3 / 2) (s.1 - 3 / 2)} := by
  calc
    _ ≤ ENNReal.ofReal (goodPairDensityLower M / 16) := ENNReal.ofReal_le_ofReal (min_le_right _ _)
    _ ≤ oddTwoStep s (goodPair s.1) := goodPair_measure_lower hM s hs
    _ ≤ _ := measure_mono (fun x hx => goodPair_terminal hx)

end NumberTheoryLean.GoodPairTransitions

end

section

namespace NumberTheoryLean.FirstHitKernels

open Filter Set MeasureTheory ProbabilityTheory
open scoped ProbabilityTheory ENNReal Topology
open FinitePathMeasures

def regenerationStateSet : Set State :=
  fun z => Sum.elim (fun _ : TransitionKernels.EvenState => False)
    (fun s : TransitionKernels.OddState => s.1 ≤ 3) z

theorem regenerationStateSet_measurable : MeasurableSet regenerationStateSet := by
  apply measurableSet_sum_iff.mpr
  constructor
  · exact MeasurableSet.empty
  · exact measurableSet_le measurable_subtype_coe measurable_const

def regenerationSet : Set CostState := Prod.fst ⁻¹' regenerationStateSet

theorem regenerationSet_measurable : MeasurableSet regenerationSet :=
  regenerationStateSet_measurable.preimage measurable_fst

@[simp] theorem regeneration_even (s : TransitionKernels.EvenState) (T : ℝ) :
    (.inl s, T) ∉ regenerationSet := by change ¬False; exact not_false

@[simp] theorem regeneration_odd (s : TransitionKernels.OddState) (T : ℝ) :
    (.inr s, T) ∈ regenerationSet ↔ s.1 ≤ 3 := Iff.rfl

noncomputable def killed : Kernel CostState CostState := costKernel.restrict regenerationSet_measurable.compl
noncomputable def captured : Kernel CostState CostState := costKernel.restrict regenerationSet_measurable

instance killed_isFiniteKernel : IsFiniteKernel killed := by unfold killed; infer_instance
instance captured_isFiniteKernel : IsFiniteKernel captured := by unfold captured; infer_instance

instance killed_pow_isFiniteKernel (n : ℕ) : IsFiniteKernel (killed ^ n) := by
  induction n with
  | zero => change IsFiniteKernel (Kernel.id : Kernel CostState CostState); infer_instance
  | succ n ih =>
    rw [pow_succ']
    change IsFiniteKernel (killed ∘ₖ (killed ^ n))
    infer_instance

theorem captured_add_killed : captured + killed = costKernel := by
  ext z : 1
  change (costKernel z).restrict regenerationSet + (costKernel z).restrict regenerationSetᶜ = costKernel z
  exact Measure.restrict_add_restrict_compl regenerationSet_measurable

noncomputable def firstHit (n : ℕ) : Kernel CostState CostState := captured ∘ₖ (killed ^ n)

instance firstHit_isFiniteKernel (n : ℕ) : IsFiniteKernel (firstHit n) := by
  unfold firstHit
  infer_instance

noncomputable def firstHitLaw : Kernel CostState CostState := Kernel.sum firstHit

instance firstHitLaw_isSFiniteKernel : IsSFiniteKernel firstHitLaw := by
  unfold firstHitLaw
  infer_instance

theorem firstHit_mass_step (n : ℕ) (z : CostState) :
    firstHit n z univ + (killed ^ (n + 1)) z univ = (killed ^ n) z univ := by
  have hp : killed ^ (n + 1) = killed ∘ₖ (killed ^ n) := pow_succ' killed n
  calc
    _ = ((captured + killed) ∘ₖ (killed ^ n)) z univ := by
      rw [Kernel.comp_add_left, add_apply, Measure.add_apply, hp]
      rfl
    _ = (costKernel ∘ₖ (killed ^ n)) z univ := by rw [captured_add_killed]
    _ = _ := by rw [Kernel.comp_apply' _ _ _ MeasurableSet.univ]; simp

theorem firstHit_finite_mass (n : ℕ) (z : CostState) :
    (killed ^ n) z univ + ∑ k ∈ Finset.range n, firstHit k z univ = 1 := by
  induction n with
  | zero =>
    simp only [Finset.range_zero, Finset.sum_empty, add_zero, pow_zero]
    change (Measure.dirac z) univ = 1
    simp
  | succ n ih =>
    rw [Finset.sum_range_succ]
    calc
      _ = (∑ k ∈ Finset.range n, firstHit k z univ) +
          (firstHit n z univ + (killed ^ (n + 1)) z univ) := by ac_rfl
      _ = (∑ k ∈ Finset.range n, firstHit k z univ) + (killed ^ n) z univ := by rw [firstHit_mass_step]
      _ = 1 := by simpa only [add_comm] using ih

theorem survival_mass_le_one (n : ℕ) (z : CostState) : (killed ^ n) z univ ≤ 1 := by
  calc
    _ ≤ (killed ^ n) z univ + ∑ k ∈ Finset.range n, firstHit k z univ := le_add_of_nonneg_right zero_le
    _ = 1 := firstHit_finite_mass n z

theorem firstHit_partial_mass_le_one (n : ℕ) (z : CostState) :
    (∑ k ∈ Finset.range n, firstHit k z univ) ≤ 1 := by
  calc
    _ ≤ (killed ^ n) z univ + ∑ k ∈ Finset.range n, firstHit k z univ := le_add_of_nonneg_left zero_le
    _ = 1 := firstHit_finite_mass n z

theorem survival_mass_antitone (z : CostState) : Antitone (fun n => (killed ^ n) z univ) := by
  apply antitone_nat_of_succ_le
  intro n
  calc
    _ ≤ firstHit n z univ + (killed ^ (n + 1)) z univ := le_add_of_nonneg_left zero_le
    _ = _ := firstHit_mass_step n z

theorem firstHitLaw_mass_le_one (z : CostState) : firstHitLaw z univ ≤ 1 := by
  rw [firstHitLaw, Kernel.sum_apply' _ _ MeasurableSet.univ, ENNReal.tsum_eq_iSup_nat]
  exact iSup_le (fun n => firstHit_partial_mass_le_one n z)

instance firstHitLaw_isFiniteKernel : IsFiniteKernel firstHitLaw :=
  ⟨1, by norm_num, fun z => firstHitLaw_mass_le_one z⟩

theorem firstHitLaw_probability_of_survival_vanishes (z : CostState)
    (hz : Tendsto (fun n => (killed ^ n) z univ) atTop (𝓝 0)) :
    IsProbabilityMeasure (firstHitLaw z) := by
  constructor
  rw [firstHitLaw, Kernel.sum_apply' _ _ MeasurableSet.univ]
  have hs := hz.add (ENNReal.tendsto_nat_tsum (fun n => firstHit n z univ))
  simp only [zero_add, firstHit_finite_mass] at hs
  exact tendsto_nhds_unique hs tendsto_const_nhds

theorem captured_off_regeneration (z : CostState) : captured z regenerationSetᶜ = 0 := by
  rw [captured, Kernel.restrict_apply' _ _ _ regenerationSet_measurable.compl,
    compl_inter_self, measure_empty]

theorem firstHit_off_regeneration (n : ℕ) (z : CostState) : firstHit n z regenerationSetᶜ = 0 := by
  rw [firstHit, Kernel.comp_apply' _ _ _ regenerationSet_measurable.compl]
  simp only [captured_off_regeneration, lintegral_zero]

theorem firstHitLaw_off_regeneration (z : CostState) : firstHitLaw z regenerationSetᶜ = 0 := by
  rw [firstHitLaw, Kernel.sum_apply' _ _ regenerationSet_measurable.compl]
  simp only [firstHit_off_regeneration, tsum_zero]

theorem costKernel_increases_cost (z : CostState) :
    costKernel z {y : CostState | y.2 ≤ z.2} = 0 := by
  rw [costKernel_apply z (measurableSet_le measurable_snd measurable_const)]
  have he : {s : State | ((s, z.2 + FinitePathGeometry.cost (stateRatio s)) : CostState).2 ≤ z.2} = ∅ := by
    apply Set.eq_empty_iff_forall_notMem.mpr
    intro s hs
    have hp := FinitePathGeometry.cost_pos (FinitePathGeometry.valid_pos (stateRatio_valid s))
    change z.2 + FinitePathGeometry.cost (stateRatio s) ≤ z.2 at hs
    linarith
  change (stateKernel z.1) {s : State | z.2 + FinitePathGeometry.cost (stateRatio s) ≤ z.2} = 0
  rw [he, measure_empty]

end NumberTheoryLean.FirstHitKernels

end

end Erdos970

end OAI