import OAI.Probability.DirectionalWalk.BandContacts

namespace OAI

open MeasureTheory ProbabilityTheory Filter Preorder
open scoped ENNReal BigOperators Topology

namespace DirectionalZeroOne

open scoped Classical

lemma dyadic_band_cover (H : ℕ → ℕ) (a b h : ℕ) (hab : a ≤ b)
    (ha : H (4*2^a) < h) (hb : h ≤ H (8*2^b)) :
    ∃ j ∈ Finset.Icc a b, H (4*2^j) < h ∧ h ≤ H (8*2^j) := by
  induction b,hab using Nat.le_induction with
  | base => exact ⟨a,Finset.mem_Icc.mpr ⟨le_rfl,le_rfl⟩,ha,hb⟩
  | succ b hab ih =>
    by_cases hh : h ≤ H (8*2^b)
    · obtain ⟨j,hj,hjlo,hjhi⟩ := ih hh
      exact ⟨j,Finset.mem_Icc.mpr ⟨(Finset.mem_Icc.mp hj).1,(Finset.mem_Icc.mp hj).2.trans (Nat.le_succ b)⟩,hjlo,hjhi⟩
    · refine ⟨b+1,Finset.mem_Icc.mpr ⟨by omega,le_rfl⟩,?_,hb⟩
      have hp : 4*2^(b+1) = 8*2^b := by rw [pow_succ];omega
      rw [hp]
      exact lt_of_not_ge hh

lemma coveredDepthBand_le_index_sum {d : ℕ} (e : Step d)
    (ν : Bool → Measure (Word d)) [∀ b, IsProbabilityMeasure (ν b)]
    (hL : ∀ b, ∀ᵐ a ∂ν b, 0 < placedWidth e b a)
    (he : ∀ᵐ Z ∂twoTapeLaw ν, ∃ H, 0 < H ∧ Z ∈ commonCut (placedWidth e) H)
    (hi : Integrable (fun Z => (firstCommonWidth (placedWidth e) Z : ℝ)) (twoTapeLaw ν))
    (a b low high : ℕ) (hab : a ≤ b) (hlow : 0 < low) (hhigh : high ≤ 8*2^b) :
    twoTapeLaw ν (coveredDepthBand e low high) ≤
      ((4*2^a : ℕ) : ℝ≥0∞) * ENNReal.ofReal (∫ Z, (firstCommonWidth (placedWidth e) Z : ℝ) ∂twoTapeLaw ν) / (low : ℝ≥0∞) +
      ∑ j ∈ Finset.Icc a b, twoTapeLaw ν (commonBandContact e (2^j)) := by
  let B := {Z | low ≤ commonDepth (placedWidth e) Z (4*2^a)}
  have hh : twoTapeLaw ν (coveredDepthBand e low high) ≤
      twoTapeLaw ν B + twoTapeLaw ν (⋃ j ∈ Finset.Icc a b, commonBandContact e (2^j)) := by
    refine (measure_mono_ae (t := B ∪ ⋃ j ∈ Finset.Icc a b, commonBandContact e (2^j)) ?_).trans (measure_union_le _ _)
    filter_upwards [ae_common_iterates ν (placedWidth e) hL he] with Z hZ
    intro hcov
    by_cases hbad : Z ∈ B
    · exact Or.inl hbad
    apply Or.inr
    obtain ⟨h,hlo,hhi,hcon⟩ := hcov
    have hmon := commonDepth_strictMono (placedWidth e) Z hZ
    obtain ⟨j,hj,hja,hjb⟩ := dyadic_band_cover (commonDepth (placedWidth e) Z) a b h hab
      ((lt_of_not_ge hbad).trans_le hlo) (hhi.le.trans (hhigh.trans (hmon.id_le _)))
    exact Set.mem_iUnion.mpr ⟨j,Set.mem_iUnion.mpr ⟨hj,h,hja,hjb,hcon⟩⟩
  exact hh.trans (add_le_add (commonDepth_markov ν (placedWidth e) hL he hi (4*2^a) low hlow)
    (measure_biUnion_finset_le _ _))

lemma sum_shift_four_sub (h : ℕ → ℝ) (J : ℕ) :
    (∑ j ∈ Finset.range J, (h (j+4)-h j)) =
      h J+h (J+1)+h (J+2)+h (J+3)-h 0-h 1-h 2-h 3 := by
  induction J with
  | zero => simp;ring
  | succ J ih =>
    rw [Finset.sum_range_succ,ih]
    have h1 : J+1+1 = J+2 := by omega
    have h2 : J+1+2 = J+3 := by omega
    have h3 : J+1+3 = J+4 := by omega
    simp only [h1,h2,h3]
    ring

lemma sum_shift_four_le (h : ℕ → ℝ) (h0 : ∀ j, 0 ≤ h j) (hm : Monotone h) (J : ℕ) :
    (∑ j ∈ Finset.range J, (h (j+4)-h j)) ≤ 4*h (J+3) := by
  rw [sum_shift_four_sub]
  have ha := hm (show J ≤ J+3 by omega)
  have hb := hm (show J+1 ≤ J+3 by omega)
  have hc := hm (show J+2 ≤ J+3 by omega)
  linarith [h0 0,h0 1,h0 2,h0 3]

lemma log_nat_pow_two_add_one (j : ℕ) :
    Real.log (((2:ℕ)^j : ℝ)+1) ≤ (j+1)*Real.log 2 := by
  have hp : (1:ℝ) ≤ 2^j := one_le_pow₀ (by norm_num)
  have hh : ((2:ℕ)^j : ℝ)+1 ≤ (2:ℝ)^(j+1) := by
    push_cast
    rw [pow_succ]
    linarith
  have ht := Real.log_le_log (by positivity : (0:ℝ) < ((2:ℕ)^j : ℝ)+1) hh
  rw [Real.log_pow] at ht
  simpa only [Nat.cast_add,Nat.cast_one] using ht

lemma entropy_dyadic_telescope {q : ℕ} (ν : Measure (Fin q → ℤ)) [IsProbabilityMeasure ν]
    (hi : ∀ i, Integrable (fun x => |(x i : ℝ)|) ν) (a : ℝ) (ha : 0 < a)
    (hb : ∀ i, (∫ x, |(x i : ℝ)| ∂ν) ≤ a) (J : ℕ) :
    (∑ j ∈ Finset.range J, (entropyOf (sumLaw ν (14*2^j)) id-entropyOf (sumLaw ν (2^j)) id)) ≤
      4*q*(1+Real.log 2+Real.log (a+1)+(J+4)*Real.log 2) := by
  let h := fun j => entropyOf (sumLaw ν (2^j)) id
  have hall (n : ℕ) := (sumLaw_lattice_entropy ν hi a ha hb n).1
  have hm := sumLaw_entropy_monotone ν hall
  have hmono : Monotone h := by
    intro m n hmn
    apply hm
    exact Nat.pow_le_pow_right (by norm_num) hmn
  have hsum : (∑ j ∈ Finset.range J, (entropyOf (sumLaw ν (14*2^j)) id-entropyOf (sumLaw ν (2^j)) id)) ≤
      ∑ j ∈ Finset.range J, (h (j+4)-h j) := by
    apply Finset.sum_le_sum
    intro j hj
    apply sub_le_sub_right
    apply hm
    rw [pow_add]
    omega
  refine hsum.trans ((sum_shift_four_le h (fun _ => entropyOf_nonneg _ _) hmono J).trans ?_)
  have hh := (sumLaw_lattice_entropy ν hi a ha hb (2^(J+3))).2
  have hl := log_nat_pow_two_add_one (J+3)
  have hq : (0:ℝ) ≤ q := Nat.cast_nonneg _
  have hb' : h (J+3) ≤ q*(1+Real.log 2+Real.log (a+1)+(J+4)*Real.log 2) := by
    refine hh.trans (mul_le_mul_of_nonneg_left ?_ hq)
    have he : ((J+3 : ℕ) : ℝ)+1 = (J:ℝ)+4 := by push_cast;ring
    rw [he] at hl
    push_cast at *
    linarith
  nlinarith

lemma kl_event_scale_bound {Ω : Type*} [MeasurableSpace Ω]
    (P Q : Measure Ω) [IsProbabilityMeasure P] [IsProbabilityMeasure Q]
    (hfin : InformationTheory.klDiv P Q ≠ ∞) (E : Set Ω) (hE : MeasurableSet E)
    (B : ℝ) (hB : 1 ≤ B) :
    Real.log B * P.real E ≤ (InformationTheory.klDiv P Q).toReal + Real.log 2 +
      Real.log B * B * Q.real E := by
  have hB0 : 0 < B := lt_of_lt_of_le zero_lt_one hB
  have hlog : 0 ≤ Real.log B := Real.log_nonneg hB
  have hkl : 0 ≤ (InformationTheory.klDiv P Q).toReal := ENNReal.toReal_nonneg
  have h2 : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num)
  by_cases hq : Q.real E = 0
  · have hq' : Q E = 0 := (ENNReal.toReal_eq_zero_iff _).mp hq |>.resolve_right (measure_ne_top Q E)
    have hp := (InformationTheory.klDiv_ne_top_iff.mp hfin).1 hq'
    simp only [measureReal_def,hp,hq',ENNReal.toReal_zero,mul_zero]
    linarith
  by_cases hsmall : Q.real E ≤ B⁻¹
  · have hq0 : 0 < Q.real E := lt_of_le_of_ne measureReal_nonneg (Ne.symm hq)
    have hh := Real.log_le_log hq0 hsmall
    rw [Real.log_inv] at hh
    have hb := kl_event_bound P Q hfin E hE
    have hp := mul_le_mul_of_nonneg_left (neg_le_neg hh) (measureReal_nonneg (μ := P) (s := E))
    have ht : 0 ≤ Real.log B*B*Q.real E := mul_nonneg (mul_nonneg hlog hB0.le) measureReal_nonneg
    nlinarith
  · have ht : 1 ≤ B*Q.real E := by
      have hh := mul_le_mul_of_nonneg_left (le_of_not_ge hsmall) hB0.le
      simpa only [mul_inv_cancel₀ hB0.ne'] using hh
    have hp := measureReal_le_one (μ := P) (s := E)
    nlinarith [mul_le_mul_of_nonneg_left ht hlog]

lemma placed_cut_positive {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) (H : ℕ) (b : Bool) :
    Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection (placedAxis e b)))
      (renewalCut (placedWidth e b) H) ≠ 0 := by
  rw [show Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection (placedAxis e b)))
      (renewalCut (placedWidth e b) H) = axisReachProb μ (placedAxis e b) H from
      axis_tapeCut_mass μ hell _ (hp b) H]
  exact ne_of_gt ((hp b).trans_le (axisReachProb_lower μ hell _ _))

lemma experiment_probability {α G : Type*} [Countable α] [MeasurableSpace α]
    [MeasurableSingletonClass α] [Countable G] [MeasurableSpace G] [MeasurableSingletonClass G]
    [AddCommGroup G] (ν : Bool → Measure α) [∀ b, IsProbabilityMeasure (ν b)]
    (L : Bool → α → ℕ) (D : Bool → α → G) (n : ℕ) [NeZero n] :
    IsProbabilityMeasure (experimentLaw ν L D n) :=
  probabilityMeasure_map (measurable_of_countable _).aemeasurable

lemma reference_probability {α G : Type*} [Countable α] [MeasurableSpace α]
    [MeasurableSingletonClass α] [Countable G] [MeasurableSpace G] [MeasurableSingletonClass G]
    [AddCommGroup G] (ν : Bool → Measure α) [∀ b, IsProbabilityMeasure (ν b)]
    (L : Bool → α → ℕ) (D : Bool → α → G)
    (hu : ∀ H b, Measure.infinitePi (fun _ : ℕ => ν b) (renewalCut (L b) H) ≠ 0)
    (n : ℕ) [NeZero n] : IsProbabilityMeasure (experimentReference ν L D n) := by
  let := experiment_probability ν L D n
  let : IsMarkovKernel (signedThreeKernel (ν false) (L false)) := signedThreeKernel_markov _ _ (fun H => hu H false)
  let : IsMarkovKernel (signedThreeKernel (ν true) (L true)) := signedThreeKernel_markov _ _ (fun H => hu H true)
  unfold experimentReference
  infer_instance

lemma placed_reference_summable {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) :
    letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) :=
      fun b => slabLaw_probability μ _ (hp b)
    Summable (fun j => (experimentReference (fun b => slabLaw μ (axisDirection (placedAxis e b)))
      (placedWidth e) (fun _ => wordEnd) (2^j)).real (experimentContact e)) := by
  let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := fun b => slabLaw_probability μ _ (hp b)
  let := slabLaw_probability μ (axisDirection e) (hp false)
  let := slabLaw_probability μ (axisDirection (oppositeStep e)) (hp true)
  let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
  obtain ⟨he,hi⟩ := placed_common_data μ hell e hp
  let W := ∫ Z, (firstCommonWidth (placedWidth e) Z : ℝ) ∂twoTapeLaw ν
  let C := ((annealed μ 0 (nonBacktracking (axisDirection e))).toReal)⁻¹^2 *
    ((annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e)))).toReal)⁻¹^2 * 24 * W
  have hc : Summable (fun j => C*((2:ℝ)^j*(axisWidthTail μ e (2^j)).toReal+
      (2:ℝ)^j*(axisWidthTail μ (oppositeStep e) (2^j)).toReal)) :=
    ((summable_dyadic_axisWidthTail μ hell e (hp false)).add
      (summable_dyadic_axisWidthTail μ hell (oppositeStep e) (hp true))).mul_left C
  apply Summable.of_nonneg_of_le (fun _ => measureReal_nonneg) _ hc
  intro j
  let : NeZero ((2:ℕ)^j) := ⟨pow_ne_zero _ (by norm_num)⟩
  let := reference_probability ν (placedWidth e) (fun _ => wordEnd) (placed_cut_positive μ hell e hp) (2^j)
  have hb := experimentReference_contact_bound μ hell e hp he hi (2^j)
  have hW : 0 ≤ W := integral_nonneg (fun Z => Nat.cast_nonneg _)
  have ht := ENNReal.toReal_mono (show
      ((annealed μ 0 (nonBacktracking (axisDirection e)))⁻¹)^2 *
      ((annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))))⁻¹)^2 * 2 *
      ENNReal.ofReal (12*(2^j : ℕ)*W) *
      (axisWidthTail μ e (2^j)+axisWidthTail μ (oppositeStep e) (2^j)) ≠ ∞ by
        apply ENNReal.mul_ne_top
        · apply ENNReal.mul_ne_top
          · apply ENNReal.mul_ne_top
            · exact ENNReal.mul_ne_top (ENNReal.pow_ne_top (ENNReal.inv_ne_top.mpr (ne_of_gt (hp false))))
                (ENNReal.pow_ne_top (ENNReal.inv_ne_top.mpr (ne_of_gt (hp true))))
            · norm_num
          · exact ENNReal.ofReal_ne_top
        · exact ENNReal.add_ne_top.mpr ⟨measure_ne_top _ _,measure_ne_top _ _⟩) hb
  have hFa : axisWidthTail μ e (2^j) ≠ ∞ := measure_ne_top _ _
  have hFb : axisWidthTail μ (oppositeStep e) (2^j) ≠ ∞ := measure_ne_top _ _
  simp only [ENNReal.toReal_mul,ENNReal.toReal_pow,ENNReal.toReal_inv,ENNReal.toReal_ofNat,
    ENNReal.toReal_add hFa hFb] at ht
  rw [ENNReal.toReal_ofReal (by positivity)] at ht
  push_cast at ht
  change _ ≤ C*((2:ℝ)^j*(axisWidthTail μ e (2^j)).toReal+
      (2:ℝ)^j*(axisWidthTail μ (oppositeStep e) (2^j)).toReal)
  calc
    _ ≤ _ := ht
    _ = _ := by dsimp only [C];ring

lemma placed_kl_bounds {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) :
    letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) :=
      fun b => slabLaw_probability μ _ (hp b)
    let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
    (∀ j, InformationTheory.klDiv (experimentLaw ν (placedWidth e) (fun _ => wordEnd) (2^j))
      (experimentReference ν (placedWidth e) (fun _ => wordEnd) (2^j)) ≠ ∞) ∧
    ∃ A : ℝ, 0 ≤ A ∧ ∀ J,
      (∑ j ∈ Finset.range J, (InformationTheory.klDiv
        (experimentLaw ν (placedWidth e) (fun _ => wordEnd) (2^j))
        (experimentReference ν (placedWidth e) (fun _ => wordEnd) (2^j))).toReal) ≤ A*J := by
  let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := fun b => slabLaw_probability μ _ (hp b)
  let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
  obtain ⟨he,hW⟩ := placed_common_data μ hell e hp
  let ρ := commonGapLaw ν (placedWidth e) (fun _ => wordEnd)
  have hi : ∀ i, Integrable (fun x : Site d => |(x i : ℝ)|) ρ :=
    commonGapLaw_lattice_integrable ν (placedWidth e) (placed_slab_positive μ hell e hp)
      he hW (fun _ => wordEnd) (placed_wordEnd_integrable μ hell e hp)
  let c := ((annealed μ 0 (nonBacktracking (axisDirection e))) *
    (annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))))).toReal
  have hc : 0 < c := ENNReal.toReal_pos (mul_ne_zero (ne_of_gt (hp false)) (ne_of_gt (hp true)))
    (ENNReal.mul_ne_top (measure_ne_top _ _) (measure_ne_top _ _))
  have hlo (H : ℕ) : ENNReal.ofReal c ≤ renewalPairMass ν (placedWidth e) H := by
    rw [show ENNReal.ofReal c = annealed μ 0 (nonBacktracking (axisDirection e))*
      annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))) from
      ENNReal.ofReal_toReal (ENNReal.mul_ne_top (measure_ne_top _ _) (measure_ne_top _ _))]
    simpa only [commonCut_mass,renewalPairMass,Fintype.prod_bool,ν,mul_comm] using placed_common_lower μ hell e hp H
  let C := 6*(1+Real.log (8*((∫ Z, (firstCommonWidth (placedWidth e) Z : ℝ) ∂twoTapeLaw ν)+1)+1))+1+Real.log 16
  have hb (j : ℕ) : InformationTheory.klDiv (experimentLaw ν (placedWidth e) (fun _ => wordEnd) (2^j))
      (experimentReference ν (placedWidth e) (fun _ => wordEnd) (2^j)) ≠ ∞ ∧
      (InformationTheory.klDiv (experimentLaw ν (placedWidth e) (fun _ => wordEnd) (2^j))
      (experimentReference ν (placedWidth e) (fun _ => wordEnd) (2^j))).toReal ≤
      C+(entropyOf (sumLaw ρ (14*2^j)) id-entropyOf (sumLaw ρ (2^j)) id) := by
    let : NeZero ((2:ℕ)^j) := ⟨pow_ne_zero _ (by norm_num)⟩
    have hh := lattice_experiment_kl_comparison ν (placedWidth e) (placed_slab_positive μ hell e hp)
      he hW (placed_cut_positive μ hell e hp) c hc hlo (fun _ => wordEnd)
      (placed_wordEnd_integrable μ hell e hp) (2^j)
    exact ⟨hh.1,by dsimp [C,ρ];linarith [hh.2]⟩
  refine ⟨fun j => (hb j).1,?_⟩
  let a := 1+∑ i : Fin d, ∫ x, |(x i : ℝ)| ∂ρ
  have ha : 0 < a := by
    have hh : 0 ≤ ∑ i : Fin d, ∫ x, |(x i : ℝ)| ∂ρ := Finset.sum_nonneg (fun i _ => integral_nonneg (fun x => abs_nonneg _))
    dsimp [a];linarith
  have hia (i : Fin d) : (∫ x, |(x i : ℝ)| ∂ρ) ≤ a := by
    have hh := Finset.single_le_sum (s := Finset.univ) (f := fun i : Fin d => ∫ x, |(x i : ℝ)| ∂ρ)
      (fun i _ => integral_nonneg (fun x => abs_nonneg _)) (Finset.mem_univ i)
    dsimp [a];linarith
  let B := 1+Real.log 2+Real.log (a+1)+4*Real.log 2
  refine ⟨|C|+4*d*(|B|+Real.log 2),by have := Real.log_nonneg (by norm_num : (1:ℝ)≤2);positivity,?_⟩
  intro J
  by_cases hJ : J = 0
  · subst J;simp
  have hJ1 : (1:ℝ) ≤ J := by exact_mod_cast Nat.pos_of_ne_zero hJ
  have hh := Finset.sum_le_sum (fun j (_ : j ∈ Finset.range J) => (hb j).2)
  simp only [Finset.sum_add_distrib,Finset.sum_const,Finset.card_range,nsmul_eq_mul] at hh
  have ht := entropy_dyadic_telescope ρ hi a ha hia J
  have hC := le_abs_self C
  have hB := le_abs_self B
  have hBB : |B| ≤ |B| * J := le_mul_of_one_le_right (abs_nonneg _) hJ1
  have hd : (0:ℝ) ≤ d := Nat.cast_nonneg _
  have hcJ := mul_le_mul_of_nonneg_right hC (Nat.cast_nonneg J)
  have hbJ := mul_le_mul_of_nonneg_left (hB.trans hBB) (by positivity : (0:ℝ)≤4*d)
  dsimp only [B] at hbJ
  nlinarith

lemma commonBand_entropy_upper {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) :
    letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) :=
      fun b => slabLaw_probability μ _ (hp b)
    let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
    ∃ A B : ℝ, 0 ≤ A ∧ 0 ≤ B ∧ ∀ (J L : ℕ),
      (L*Real.log 2)*(∑ j ∈ Finset.range J, (twoTapeLaw ν).real (commonBandContact e (2^j))) ≤
        A*J+(L*Real.log 2)*(2:ℝ)^L*B := by
  let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := fun b => slabLaw_probability μ _ (hp b)
  let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
  have : Countable (Word d) := inferInstance
  have : Countable (TapeList (Word d)) := inferInstance
  have : Countable (ThreeLists (Word d)) := inferInstance
  let Q (j : ℕ) := experimentReference ν (placedWidth e) (fun _ => wordEnd) (2^j)
  let P (j : ℕ) := experimentLaw ν (placedWidth e) (fun _ => wordEnd) (2^j)
  have hne (j : ℕ) : NeZero ((2:ℕ)^j) := ⟨pow_ne_zero _ (by norm_num)⟩
  have hP (j : ℕ) : IsProbabilityMeasure (P j) := by let := hne j;exact experiment_probability ν (placedWidth e) (fun _ => wordEnd) _
  have hQ (j : ℕ) : IsProbabilityMeasure (Q j) := by let := hne j;exact reference_probability ν (placedWidth e) (fun _ => wordEnd) (placed_cut_positive μ hell e hp) _
  obtain ⟨hfin,A,hA,hbound⟩ := placed_kl_bounds μ hell e hp
  have hsum := placed_reference_summable μ hell e hp
  let B := ∑' j, (Q j).real (experimentContact e)
  have hB : 0 ≤ B := tsum_nonneg (fun _ => measureReal_nonneg)
  refine ⟨A+Real.log 2,B,add_nonneg hA (Real.log_nonneg (by norm_num)),hB,?_⟩
  intro J L
  have hlog : 0 ≤ (L:ℝ)*Real.log 2 := mul_nonneg (Nat.cast_nonneg _) (Real.log_nonneg (by norm_num))
  have he := (placed_common_data μ hell e hp).1
  have hpoint (j : ℕ) : (L*Real.log 2)*(twoTapeLaw ν).real (commonBandContact e (2^j)) ≤
      (InformationTheory.klDiv (P j) (Q j)).toReal+Real.log 2+(L*Real.log 2)*(2:ℝ)^L*(Q j).real (experimentContact e) := by
    let := hne j
    let := hP j
    let := hQ j
    have hdom := commonBand_probability_le_experiment e ν
      (fun b => ae_slabLaw_regeneration μ hell _ (axisDirection_ne_zero _) (hp b)) he (2^j)
    have hdr := ENNReal.toReal_mono (measure_ne_top (P j) _) hdom
    have hkl := kl_event_scale_bound (P j) (Q j) (hfin j) (experimentContact e)
      (Set.to_countable _).measurableSet ((2:ℝ)^L) (one_le_pow₀ (by norm_num))
    rw [Real.log_pow] at hkl
    exact (mul_le_mul_of_nonneg_left hdr hlog).trans hkl
  have hh := Finset.sum_le_sum (fun j (_ : j ∈ Finset.range J) => hpoint j)
  simp only [Finset.sum_add_distrib,Finset.sum_const,Finset.card_range,nsmul_eq_mul,
    ← Finset.mul_sum] at hh
  have hqs : (∑ j ∈ Finset.range J, (Q j).real (experimentContact e)) ≤ B :=
    Summable.sum_le_tsum (Finset.range J) (fun _ _ => measureReal_nonneg) hsum
  have ht := mul_le_mul_of_nonneg_left hqs (mul_nonneg hlog (by positivity : (0:ℝ) ≤ (2:ℝ)^L))
  have hk := hbound J
  dsimp only [P,Q] at hh ht
  nlinarith

lemma commonBand_lower_real {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b))))
    (s N low high m a b : ℕ) (hs : 0 < s) (hsN : s ≤ N) (hls : low ≤ s) (hsh : s < high)
    (hab : a ≤ b) (hlow : 0 < low) (hhigh : high ≤ 8*2^b)
    (hΔ : axisReachProb μ e (s-low)-axisReachProb μ e s ≤ ENNReal.ofReal ((1/2 : ℝ)^m)) :
    letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) :=
      fun b => slabLaw_probability μ _ (hp b)
    let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
    (annealed μ 0).real (nonBacktracking (axisDirection e))^2 ≤
      (4*2^a : ℕ) * (∫ Z, (firstCommonWidth (placedWidth e) Z : ℝ) ∂twoTapeLaw ν) / low +
      (∑ j ∈ Finset.Icc a b, (twoTapeLaw ν).real (commonBandContact e (2^j))) +
      (∫ a, slabRadius a ∂ν false) / N +
      ((annealed μ 0).real (nonBacktracking (axisDirection e)))⁻¹ *
      ((annealed μ 0).real (nonBacktracking (axisDirection (oppositeStep e))))⁻¹ *
        ((24 / posteriorExponent)*Real.log (Fintype.card (AxisCubeSite e N (N^2+1))+1)*(m+1)^2*(1/2 : ℝ)^m) := by
  let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := fun b => slabLaw_probability μ _ (hp b)
  let ν := fun b => slabLaw μ (axisDirection (placedAxis e b))
  obtain ⟨he,hi⟩ := placed_common_data μ hell e hp
  have hbnd := coveredDepthBand_lower μ hell e hp s N low high m hs hsN hls hsh hΔ
  have hidx := coveredDepthBand_le_index_sum e ν (placed_slab_positive μ hell e hp) he hi a b low high hab hlow hhigh
  have hh := hbnd.trans (add_le_add (add_le_add hidx le_rfl) le_rfl)
  have hR := ofReal_integral_eq_lintegral_ofReal (placed_slabRadius_integrable μ hell e hp false)
    (Filter.Eventually.of_forall (fun a => slabRadius_nonneg a))
  change ENNReal.ofReal (∫ x, slabRadius x ∂slabLaw μ (axisDirection e)) =
    ∫⁻ x, ENNReal.ofReal (slabRadius x) ∂slabLaw μ (axisDirection e) at hR
  rw [← hR] at hh
  have hfin : ((4*2^a : ℕ) : ℝ≥0∞) * ENNReal.ofReal (∫ Z, (firstCommonWidth (placedWidth e) Z : ℝ) ∂twoTapeLaw ν) / (low : ℝ≥0∞) +
      (∑ j ∈ Finset.Icc a b, twoTapeLaw ν (commonBandContact e (2^j))) +
      ENNReal.ofReal (∫ a, slabRadius a ∂ν false) / (N : ℝ≥0∞) +
      (annealed μ 0 (nonBacktracking (axisDirection e)))⁻¹ *
      (annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))))⁻¹ *
        ENNReal.ofReal ((24 / posteriorExponent)*Real.log (Fintype.card (AxisCubeSite e N (N^2+1))+1)*(m+1)^2*(1/2 : ℝ)^m) ≠ ∞ := by
    have hN : (N : ℝ≥0∞) ≠ 0 := by exact_mod_cast (lt_of_lt_of_le hs hsN).ne'
    have hl : (low : ℝ≥0∞) ≠ 0 := by exact_mod_cast hlow.ne'
    have hp0 : annealed μ 0 (nonBacktracking (axisDirection e)) ≠ 0 := ne_of_gt (hp false)
    have hp1 : annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))) ≠ 0 := ne_of_gt (hp true)
    refine ENNReal.add_ne_top.mpr ⟨ENNReal.add_ne_top.mpr ⟨ENNReal.add_ne_top.mpr ⟨?_,?_⟩,?_⟩,?_⟩
    · exact ENNReal.div_ne_top (ENNReal.mul_ne_top (ENNReal.natCast_ne_top _) ENNReal.ofReal_ne_top) hl
    · exact ENNReal.sum_ne_top.mpr (fun j _ => measure_ne_top _ _)
    · exact ENNReal.div_ne_top ENNReal.ofReal_ne_top hN
    · exact ENNReal.mul_ne_top (ENNReal.mul_ne_top (ENNReal.inv_ne_top.mpr hp0)
        (ENNReal.inv_ne_top.mpr hp1)) ENNReal.ofReal_ne_top
  have ht := ENNReal.toReal_mono hfin hh
  have hW : 0 ≤ ∫ Z, (firstCommonWidth (placedWidth e) Z : ℝ) ∂twoTapeLaw ν := integral_nonneg (fun Z => Nat.cast_nonneg _)
  have hr : 0 ≤ ∫ a, slabRadius a ∂ν false := integral_nonneg slabRadius_nonneg
  have hlog : 0 ≤ Real.log (Fintype.card (AxisCubeSite e N (N^2+1))+1) := Real.log_nonneg (le_add_of_nonneg_left (Nat.cast_nonneg _))
  have hE : 0 ≤ (24/posteriorExponent)*Real.log (Fintype.card (AxisCubeSite e N (N^2+1))+1)*(m+1)^2*(1/2 : ℝ)^m := by
    have := posteriorExponent_pos
    positivity
  have hadd (x y : ℝ≥0∞) (h : x+y ≠ ∞) : (x+y).toReal = x.toReal+y.toReal :=
    ENNReal.toReal_add (ENNReal.add_ne_top.mp h).1 (ENNReal.add_ne_top.mp h).2
  rw [hadd _ _ hfin] at ht
  rw [hadd _ _ (ENNReal.add_ne_top.mp hfin).1] at ht
  rw [hadd _ _ (ENNReal.add_ne_top.mp (ENNReal.add_ne_top.mp hfin).1).1] at ht
  simp only [ENNReal.toReal_mul,
    ENNReal.toReal_div,ENNReal.toReal_natCast,ENNReal.toReal_sum (fun j _ => measure_ne_top _ _),
    ENNReal.toReal_inv,ENNReal.toReal_pow,ENNReal.toReal_ofReal hW,ENNReal.toReal_ofReal hr,
    ENNReal.toReal_ofReal hE] at ht
  exact ht

end DirectionalZeroOne

end OAI