import OAI.Probability.FKMaps.MarkedSpines

namespace OAI

noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.TreeCoding

lemma marked_exp_vanish {κ : ℝ} (hκ : 0 < κ) :
    Tendsto (fun n : ℕ => (((2*n+1:ℕ):ℝ)+1)*Real.exp (-κ*Real.sqrt ((2*n+1:ℕ):ℝ)))
      atTop (𝓝 0) := by
  have h := (polynomial_exp_sqrt hκ 2).add (polynomial_exp_sqrt hκ 0)
  simp only [zero_add] at h
  convert h using 1
  funext n
  rw [Real.sq_sqrt (by positivity)]
  simp only [pow_zero,one_mul]
  ring


variable {A : Type*} [MeasurableSpace A]

lemma CriticalEvenOffspring.marked_short_unconditional_bound (p : CriticalEvenOffspring)
    (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)]
    (b : (ℕ×ℕ) → A → ℝ) (hb : ∀ z,Measurable (b z)) {R : ℝ} (hR : 0 < R)
    (hbound : ∀ z a,|b z a| ≤ R) (n K : ℕ) {r : ℝ} (hr : 0 < r) :
    (p.markedCodeLaw κ n).real {x | ∃ v : Fin (2*n+2),height x.1.val v.val ≤ K ∧
      r ≤ |markedSpineSum b x.1 (by omega : v.val ≤ 2*n+1) x.2-
        codeSpineSum (fun z => ∫ a,b z a ∂κ z.1) x.1 v.val|} ≤
      ((2*n+1:ℕ)+1:ℝ)*2*Real.exp (-r^2/(2*K*R^2)) := by
  refine compProd_real_bound (p.codeLaw n) (codeMarkKernel κ (2*n+1)) ?_ (by positivity) ?_
  · simp only [Set.ofPred_exists]
    apply MeasurableSet.iUnion
    intro v
    have hh : MeasurableSet {x : Code (2*n+1) × (Fin (2*n+1) → A) | height x.1.val v.val ≤ K} :=
      (Set.to_countable {d : Code (2*n+1) | height d.val v.val ≤ K}).measurableSet.preimage measurable_fst
    exact hh.inter (measurableSet_le measurable_const
      (((measurable_marked_spine_joint b hb (by omega : v.val ≤ 2*n+1)).sub
        ((measurable_of_countable (fun d : Code (2*n+1) => codeSpineSum (fun z => ∫ a,b z a ∂κ z.1) d v.val)).comp measurable_fst)).abs))
  · intro d
    change (codeMarkLaw κ d).real {a | ∃ v : Fin (2*n+2),height d.val v.val ≤ K ∧
      r ≤ |markedSpineSum b d (by omega : v.val ≤ 2*n+1) a-
        codeSpineSum (fun z => ∫ a,b z a ∂κ z.1) d v.val|} ≤ _
    simpa only [Nat.add_assoc,show 1+1=2 by rfl] using marked_short_spine_bound κ b hb hR hbound d K hr

/-- Random marks are negligible relative to their conditional path means, uniformly over vertices. -/
lemma CriticalEvenOffspring.uniform_mark_noise (p : CriticalEvenOffspring)
    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
    (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)]
    (b : (ℕ×ℕ) → A → ℝ) (hb : ∀ z,Measurable (b z)) {R : ℝ} (hR : 0 < R)
    (hbound : ∀ z a,|b z a| ≤ R) {ε : ℝ} (hε : 0 < ε) :
    Tendsto (fun n => (p.markedCodeLaw κ n).real {x | ∃ v : Fin (2*n+2),
      ε*Real.sqrt ((2*n+1:ℕ):ℝ) < |markedSpineSum b x.1 (by omega : v.val ≤ 2*n+1) x.2-
        codeSpineSum (fun z => ∫ a,b z a ∂κ z.1) x.1 v.val|}) atTop (𝓝 0) := by
  apply tendsto_order.2
  constructor
  · intro a ha
    exact Eventually.of_forall (fun _ => ha.trans_le measureReal_nonneg)
  intro η hη
  obtain ⟨C,hC,htight⟩ := p.code_height_tight hB (by positivity : 0 < η/3)
  let δ := ε^2/(2*(C+1)*R^2)
  have hδ : 0 < δ := by dsimp [δ]; positivity
  have hlim := (marked_exp_vanish hδ).const_mul 2
  simp only [mul_zero] at hlim
  filter_upwards [htight,hlim.eventually (gt_mem_nhds (by positivity : (0:ℝ) < η/3))] with n hn hl
  let N := 2*n+1
  let s := Real.sqrt (N:ℝ)
  let K := ⌈C*s⌉₊
  let E0 := {d : Code N | ∃ v ≤ N,C*s < height d.val v}
  let E1 := {x : Code N × (Fin N → A) | ∃ v : Fin (N+1),height x.1.val v.val ≤ K ∧
      ε*s ≤ |markedSpineSum b x.1 (Nat.le_of_lt_succ v.isLt) x.2-
        codeSpineSum (fun z => ∫ a,b z a ∂κ z.1) x.1 v.val|}
  have hsub : {x : Code N × (Fin N → A) | ∃ v : Fin (N+1),ε*s <
      |markedSpineSum b x.1 (Nat.le_of_lt_succ v.isLt) x.2-
        codeSpineSum (fun z => ∫ a,b z a ∂κ z.1) x.1 v.val|} ⊆ (Prod.fst ⁻¹' E0)∪E1 := by
    rintro x ⟨v,hv⟩
    by_cases hh : C*s < (height x.1.val v.val:ℝ)
    · exact Or.inl ⟨v.val,Nat.le_of_lt_succ v.isLt,hh⟩
    · exact Or.inr ⟨v,by exact_mod_cast (not_lt.mp hh).trans (Nat.le_ceil (C*s)),hv.le⟩
  have hs : 1 ≤ s := by
    change 1 ≤ Real.sqrt (N:ℝ)
    rw [Real.le_sqrt (by norm_num) (by positivity)]
    dsimp [N]; norm_num
  have hK : (K:ℝ) ≤ (C+1)*s := by
    have h := (Nat.ceil_lt_add_one (mul_nonneg hC.le (lt_of_lt_of_le zero_lt_one hs).le)).le
    dsimp [K]; nlinarith
  have hK0 : 0 < (K:ℝ) := (mul_pos hC (lt_of_lt_of_le zero_lt_one hs)).trans_le (Nat.le_ceil _)
  have he : -(ε*s)^2/(2*K*R^2) ≤ -δ*s := by
    rw [neg_div,neg_mul]
    apply neg_le_neg
    apply (le_div_iff₀ (by positivity : 0 < 2*(K:ℝ)*R^2)).mpr
    have heq : δ*s*(2*(C+1)*s*R^2)=(ε*s)^2 := by dsimp [δ]; field_simp
    calc
      _ ≤ δ*s*(2*(C+1)*s*R^2) := by
        apply mul_le_mul_of_nonneg_left _ (by positivity)
        nlinarith [mul_le_mul_of_nonneg_right hK (sq_nonneg R)]
      _ = _ := heq
  have hbnd : (p.markedCodeLaw κ n).real E1 ≤ 2*((N:ℝ)+1)*Real.exp (-δ*s) := by
    apply (p.marked_short_unconditional_bound κ b hb hR hbound n K
      (mul_pos hε (lt_of_lt_of_le zero_lt_one hs))).trans
    change ((N:ℝ)+1)*2*Real.exp (-(ε*s)^2/(2*K*R^2)) ≤ _
    nlinarith [mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr he) (by positivity : 0 ≤ ((N:ℝ)+1)*2)]
  have hprob := (measureReal_mono (μ := p.markedCodeLaw κ n) hsub).trans (measureReal_union_le _ _)
  rw [p.markedCodeLaw_fst] at hprob
  change (p.codeLaw n).real E0 ≤ η/3 at hn
  simp only [← mul_assoc] at hl
  change 2*(((2*n+1:ℕ):ℝ)+1)*Real.exp (-δ*Real.sqrt ((2*n+1:ℕ):ℝ)) < η/3 at hl
  change 2*((N:ℝ)+1)*Real.exp (-δ*s) < η/3 at hl
  exact hprob.trans_lt (by linarith)

lemma markMean_bound (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)]
    (b : (ℕ×ℕ) → A → ℝ) {R : ℝ} (hb : ∀ z a,|b z a| ≤ R) (z : ℕ×ℕ) :
    |∫ a,b z a ∂κ z.1| ≤ R := by
  have h := norm_integral_le_of_norm_le_const (μ := κ z.1) (f := b z) (C := R)
    (ae_of_all _ (fun a => by simpa only [Real.norm_eq_abs] using hb z a))
  simpa [Real.norm_eq_abs,Measure.real] using h

/-- The bounded marked theorem with the source's genuine spine mean. -/
theorem CriticalEvenOffspring.uniform_bounded_marked_spine (p : CriticalEvenOffspring)
    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
    (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)]
    (b : (ℕ×ℕ) → A → ℝ) (hb : ∀ z,Measurable (b z)) {R : ℝ} (hR : 0 < R)
    (hbound : ∀ z a,|b z a| ≤ R) {ε : ℝ} (hε : 0 < ε) :
    Tendsto (fun n => (p.markedCodeLaw κ n).real {x | ∃ v : Fin (2*n+2),
      ε*Real.sqrt ((2*n+1:ℕ):ℝ) < |markedSpineSum b x.1 (by omega : v.val ≤ 2*n+1) x.2-
        (∫ z,∫ a,b z a ∂κ z.1 ∂p.spineLaw)*height x.1.val v.val|}) atTop (𝓝 0) := by
  let bm := fun z => ∫ a,b z a ∂κ z.1
  have h ε' (hε' : 0 < ε') := p.uniform_mark_noise hB κ b hb hR hbound hε'
  have ht := p.uniform_bounded_spine_limit hB bm hR (markMean_bound κ b hbound) (by positivity : 0 < ε/2)
  have hn := h (ε/2) (by positivity)
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds (by simpa only [zero_add] using hn.add ht)
    (fun _ => measureReal_nonneg)
  intro n
  let N := 2*n+1
  let s := Real.sqrt (N:ℝ)
  let E0 := {x : Code N × (Fin N → A) | ∃ v : Fin (N+1),(ε/2)*s <
      |markedSpineSum b x.1 (Nat.le_of_lt_succ v.isLt) x.2-codeSpineSum bm x.1 v.val|}
  let E1 := {d : Code N | ∃ v ≤ N,(ε/2)*s <
      |codeSpineSum bm d v-(∫ z,bm z ∂p.spineLaw)*height d.val v|}
  have hsub : {x : Code N × (Fin N → A) | ∃ v : Fin (N+1),ε*s <
      |markedSpineSum b x.1 (Nat.le_of_lt_succ v.isLt) x.2-(∫ z,bm z ∂p.spineLaw)*height x.1.val v.val|}
      ⊆ E0 ∪ (Prod.fst ⁻¹' E1) := by
    rintro x ⟨v,hv⟩
    by_contra hnot
    simp only [Set.mem_union,not_or] at hnot
    have h0 : |markedSpineSum b x.1 (Nat.le_of_lt_succ v.isLt) x.2-codeSpineSum bm x.1 v.val| ≤ (ε/2)*s := by
      by_contra hn; exact hnot.1 ⟨v,lt_of_not_ge hn⟩
    have h1 : |codeSpineSum bm x.1 v.val-(∫ z,bm z ∂p.spineLaw)*height x.1.val v.val| ≤ (ε/2)*s := by
      by_contra hn; exact hnot.2 ⟨v.val,Nat.le_of_lt_succ v.isLt,lt_of_not_ge hn⟩
    have hh := abs_sub_le (markedSpineSum b x.1 (Nat.le_of_lt_succ v.isLt) x.2)
      (codeSpineSum bm x.1 v.val) ((∫ z,bm z ∂p.spineLaw)*height x.1.val v.val)
    linarith
  have hh := (measureReal_mono (μ := p.markedCodeLaw κ n) hsub).trans (measureReal_union_le _ _)
  rw [p.markedCodeLaw_fst] at hh
  exact hh

end FKCRT.TreeCoding
end


noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.TreeCoding
variable {A : Type*} [MeasurableSpace A]

def markedTrunc (m : ℕ) (b : (ℕ×ℕ) → A → ℝ) (z : ℕ×ℕ) (a : A) : ℝ :=
  if z.1 ≤ m then b z a else 0

lemma measurable_markedTrunc (m : ℕ) (b : (ℕ×ℕ) → A → ℝ) (hb : ∀ z,Measurable (b z)) (z : ℕ×ℕ) :
    Measurable (markedTrunc m b z) := by
  unfold markedTrunc; split_ifs
  · exact hb z
  · exact measurable_const

omit [MeasurableSpace A] in
lemma markedTrunc_bound (m : ℕ) (b : (ℕ×ℕ) → A → ℝ) (hb : ∀ z a,|b z a| ≤ z.1) (z : ℕ×ℕ) (a : A) :
    |markedTrunc m b z a| ≤ m := by
  exact spineTrunc_bound m (fun z => b z a) (fun z => hb z a) z

lemma markedTrunc_mean (κ : ℕ → Measure A) (m : ℕ) (b : (ℕ×ℕ) → A → ℝ) (z : ℕ×ℕ) :
    (∫ a,markedTrunc m b z a ∂κ z.1)=spineTrunc m (fun z => ∫ a,b z a ∂κ z.1) z := by
  unfold markedTrunc spineTrunc
  split_ifs <;> simp

omit [MeasurableSpace A] in
lemma markedSpineSum_sub {N : ℕ} (b c : (ℕ×ℕ) → A → ℝ) (d : Code N)
    {v : ℕ} (hv : v ≤ N) (a : Fin N → A) :
    markedSpineSum (fun z a => b z a-c z a) d hv a=markedSpineSum b d hv a-markedSpineSum c d hv a := by
  unfold markedSpineSum
  exact Finset.sum_sub_distrib _ _

omit [MeasurableSpace A] in
lemma markedSpineSum_abs_dom {N : ℕ} (b : (ℕ×ℕ) → A → ℝ) (c : ℕ×ℕ → ℝ)
    (hb : ∀ z a,|b z a| ≤ c z) (d : Code N) {v : ℕ} (hv : v ≤ N) (a : Fin N → A) :
    |markedSpineSum b d hv a| ≤ codeSpineSum c d v := by
  rw [← markedSpineSum_deterministic c d hv a]
  unfold markedSpineSum
  exact (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum (fun t _ => hb _ _))

lemma marked_spine_tail_control {N : ℕ} (p : CriticalEvenOffspring)
    (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)] (d : Code N)
    (b : (ℕ×ℕ) → A → ℝ) (hb : ∀ z a,|b z a| ≤ z.1) (m : ℕ)
    {v : ℕ} (hv : v ≤ N) (a : Fin N → A) :
    |markedSpineSum b d hv a-(∫ z,∫ a,b z a ∂κ z.1 ∂p.spineLaw)*height d.val v| ≤
      |markedSpineSum (markedTrunc m b) d hv a-
        (∫ z,∫ a,markedTrunc m b z a ∂κ z.1 ∂p.spineLaw)*height d.val v|+
      |codeSpineSum (fun z => (z.1:ℝ)) d v-(p.variance+1)*height d.val v|+
      |codeSpineSum (spineTrunc m (fun z => (z.1:ℝ))) d v-
        (∫ z,spineTrunc m (fun z => (z.1:ℝ)) z ∂p.spineLaw)*height d.val v|+
      2*(∫ z,spineTail m z ∂p.spineLaw)*height d.val v := by
  let bm := fun z => ∫ a,b z a ∂κ z.1
  have hbm : ∀ z,|bm z| ≤ z.1 := by
    intro z
    have hh := norm_integral_le_of_norm_le_const (μ := κ z.1) (f := b z) (C := (z.1:ℝ))
      (ae_of_all _ (fun a => by simpa only [Real.norm_eq_abs] using hb z a))
    simpa [bm,Real.norm_eq_abs,Measure.real] using hh
  let h : ℝ := height d.val v
  have h0 : 0 ≤ h := by dsimp [h]; positivity
  have hd := markedSpineSum_abs_dom (fun z a => b z a-markedTrunc m b z a) (spineTail m)
    (fun z a => spineTrunc_tail_bound m (fun z => b z a) (fun z => hb z a) z) d hv a
  rw [markedSpineSum_sub] at hd
  have he := p.spineTrunc_integral_error m bm hbm
  have hmean : (fun z => ∫ a,markedTrunc m b z a ∂κ z.1)=spineTrunc m bm := by
    funext z; exact markedTrunc_mean κ m b z
  have hi : (∫ z,spineTail m z ∂p.spineLaw)=p.variance+1-
      ∫ z,spineTrunc m (fun z => (z.1:ℝ)) z ∂p.spineLaw := by
    rw [spineTail_eq,integral_sub p.spine_integrable_fst (p.spine_integrable_dom _ (fun z => by
      unfold spineTrunc; split_ifs <;> simp)),p.spine_integral_fst]
  have hs : codeSpineSum (spineTail m) d v=codeSpineSum (fun z => (z.1:ℝ)) d v-
      codeSpineSum (spineTrunc m (fun z => (z.1:ℝ))) d v := by rw [spineTail_eq,codeSpineSum_sub]
  rw [hmean]
  change |markedSpineSum b d hv a-(∫ z,bm z ∂p.spineLaw)*h| ≤
    |markedSpineSum (markedTrunc m b) d hv a-(∫ z,spineTrunc m bm z ∂p.spineLaw)*h|+_+_+_
  have he1 := abs_add_le (markedSpineSum (markedTrunc m b) d hv a-(∫ z,spineTrunc m bm z ∂p.spineLaw)*h)
    ((markedSpineSum b d hv a-markedSpineSum (markedTrunc m b) d hv a)-
      ((∫ z,bm z ∂p.spineLaw)-(∫ z,spineTrunc m bm z ∂p.spineLaw))*h)
  have he2 := abs_sub (markedSpineSum b d hv a-markedSpineSum (markedTrunc m b) d hv a)
      (((∫ z,bm z ∂p.spineLaw)-(∫ z,spineTrunc m bm z ∂p.spineLaw))*h)
  rw [abs_mul,abs_of_nonneg h0] at he2
  have he3 := mul_le_mul_of_nonneg_right he h0
  have hsum : markedSpineSum (markedTrunc m b) d hv a-(∫ z,spineTrunc m bm z ∂p.spineLaw)*h+
    ((markedSpineSum b d hv a-markedSpineSum (markedTrunc m b) d hv a)-
      ((∫ z,bm z ∂p.spineLaw)-(∫ z,spineTrunc m bm z ∂p.spineLaw))*h)=
    markedSpineSum b d hv a-(∫ z,bm z ∂p.spineLaw)*h := by ring
  rw [hs] at hd
  rw [hsum] at he1
  have hK := le_abs_self (codeSpineSum (fun z => (z.1:ℝ)) d v-(p.variance+1)*h)
  have hk := neg_le_abs (codeSpineSum (spineTrunc m (fun z => (z.1:ℝ))) d v-
    (∫ z,spineTrunc m (fun z => (z.1:ℝ)) z ∂p.spineLaw)*h)
  nlinarith

end FKCRT.TreeCoding
end


noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.TreeCoding

/-- The source's full uniform marked ancestral theorem, under the actual conditional
independent-mark law, with only the offspring second moment. -/
theorem CriticalEvenOffspring.uniform_integrable_marked_spine (p : CriticalEvenOffspring)
    {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P]
    {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P)
    {A : Type*} [MeasurableSpace A] (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)]
    (b : (ℕ×ℕ) → A → ℝ) (hbmeas : ∀ z,Measurable (b z)) (hb : ∀ z a,|b z a| ≤ z.1) {ε : ℝ} (hε : 0 < ε) :
    Tendsto (fun n => (p.markedCodeLaw κ n).real {x | ∃ v : Fin (2*n+1),
      ε*Real.sqrt ((2*n+1:ℕ):ℝ) < |markedSpineSum b x.1 v.isLt.le x.2-
        (∫ z,∫ a,b z a ∂κ z.1 ∂p.spineLaw)*height x.1.val v.val|})
      atTop (𝓝 0) := by
  apply tendsto_order.2
  constructor
  · intro a ha
    exact Eventually.of_forall (fun _ =>  ha.trans_le measureReal_nonneg)
  intro η hη
  obtain ⟨C,hC,hheight⟩ := p.code_height_tight hB (by positivity : 0 < η/4)
  obtain ⟨m,hm⟩ := (p.spine_tail_integral_tendsto.eventually
    (gt_mem_nhds (by positivity : (0:ℝ) < ε/(8*C)))).exists
  have ht0 : 0 ≤ ∫ z,spineTail m z ∂p.spineLaw := integral_nonneg (spineTail_nonneg m)
  have hK := p.uniform_degree_spine_limit hB (by positivity : 0 < ε/4)
  have hbR := p.uniform_bounded_marked_spine hB κ (markedTrunc m b)
    (measurable_markedTrunc m b hbmeas) (R := (m:ℝ)+1) (by positivity)
    (fun z a => (markedTrunc_bound m b hb z a).trans (by linarith))
    (by positivity : 0 < ε/4)
  have hkR := p.uniform_bounded_spine_limit hB (spineTrunc m (fun z =>  (z.1:ℝ)))
    (R := (m:ℝ)+1) (by positivity) (fun z => 
      (spineTrunc_bound m (fun z =>  (z.1:ℝ)) (fun z =>  by simp) z).trans (by linarith))
    (by positivity : 0 < ε/4)
  filter_upwards [hheight,hK.eventually (gt_mem_nhds (by positivity : (0:ℝ) < η/4)),
    hbR.eventually (gt_mem_nhds (by positivity : (0:ℝ) < η/4)),
    hkR.eventually (gt_mem_nhds (by positivity : (0:ℝ) < η/4))] with n hh hK hbR hkR
  let N := 2*n+1
  let s := Real.sqrt (N:ℝ)
  let A0 := {d : Code N | ∃ v ≤ N,C*s < height d.val v}
  let A1 := {d : Code N | ∃ v < N,(ε/4)*s < 
    |codeSpineSum (fun z =>  (z.1:ℝ)) d v-(p.variance+1)*height d.val v|}
  let A2 := {x : Code N × (Fin N → A) | ∃ v : Fin (N+1),(ε/4)*s <
    |markedSpineSum (markedTrunc m b) x.1 (Nat.le_of_lt_succ v.isLt) x.2-
      (∫ z,∫ a,markedTrunc m b z a ∂κ z.1 ∂p.spineLaw)*height x.1.val v.val|}
  let A3 := {d : Code N | ∃ v ≤ N,(ε/4)*s < 
    |codeSpineSum (spineTrunc m (fun z =>  (z.1:ℝ))) d v-
      (∫ z,spineTrunc m (fun z =>  (z.1:ℝ)) z ∂p.spineLaw)*height d.val v|}
  have hsub : {x : Code N × (Fin N → A) | ∃ v : Fin N,ε*s <
      |markedSpineSum b x.1 v.isLt.le x.2-(∫ z,∫ a,b z a ∂κ z.1 ∂p.spineLaw)*height x.1.val v.val|}
      ⊆ ((Prod.fst ⁻¹' A0)∪(Prod.fst ⁻¹' A1))∪(A2∪(Prod.fst ⁻¹' A3)) := by
    rintro x ⟨v,hbad⟩
    by_contra hn
    simp only [Set.mem_union,not_or] at hn
    have hhv : (height x.1.val v.val:ℝ) ≤ C*s := by
      by_contra h; exact hn.1.1 ⟨v.val,v.isLt.le,lt_of_not_ge h⟩
    have hKv : |codeSpineSum (fun z =>  (z.1:ℝ)) x.1 v.val-(p.variance+1)*height x.1.val v.val| ≤ (ε/4)*s := by
      by_contra h; exact hn.1.2 ⟨v.val,v.isLt,lt_of_not_ge h⟩
    have hbv : |markedSpineSum (markedTrunc m b) x.1 v.isLt.le x.2-
        (∫ z,∫ a,markedTrunc m b z a ∂κ z.1 ∂p.spineLaw)*height x.1.val v.val| ≤ (ε/4)*s := by
      by_contra h; exact hn.2.1 ⟨⟨v.val,by omega⟩,lt_of_not_ge h⟩
    have hkv : |codeSpineSum (spineTrunc m (fun z =>  (z.1:ℝ))) x.1 v.val-
        (∫ z,spineTrunc m (fun z =>  (z.1:ℝ)) z ∂p.spineLaw)*height x.1.val v.val| ≤ (ε/4)*s := by
      by_contra h; exact hn.2.2 ⟨v.val,v.isLt.le,lt_of_not_ge h⟩
    have ht : 2*(∫ z,spineTail m z ∂p.spineLaw)*height x.1.val v.val ≤ (ε/4)*s := by
      have hm' : (∫ z,spineTail m z ∂p.spineLaw)*(8*C) ≤ ε := (le_div_iff₀ (by positivity)).mp hm.le
      have hs : 0 ≤ s := Real.sqrt_nonneg _
      have h1 := mul_le_mul_of_nonneg_left hhv (show 0 ≤ 2*(∫ z,spineTail m z ∂p.spineLaw) by positivity)
      have h2 := mul_le_mul_of_nonneg_right hm' hs
      nlinarith
    have hc := marked_spine_tail_control p κ x.1 b hb m v.isLt.le x.2
    linarith
  have hprob : (p.markedCodeLaw κ n).real {x : Code N × (Fin N → A) | ∃ v : Fin N,ε*s <
        |markedSpineSum b x.1 v.isLt.le x.2-(∫ z,∫ a,b z a ∂κ z.1 ∂p.spineLaw)*height x.1.val v.val|} ≤
      (p.codeLaw n).real A0+(p.codeLaw n).real A1+(p.markedCodeLaw κ n).real A2+(p.codeLaw n).real A3 := by
    apply (measureReal_mono hsub).trans
    have h01 := measureReal_union_le (μ := p.markedCodeLaw κ n) (Prod.fst ⁻¹' A0) (Prod.fst ⁻¹' A1)
    have h23 := measureReal_union_le (μ := p.markedCodeLaw κ n) A2 (Prod.fst ⁻¹' A3)
    have htop := measureReal_union_le (μ := p.markedCodeLaw κ n)
      ((Prod.fst ⁻¹' A0)∪(Prod.fst ⁻¹' A1)) (A2∪(Prod.fst ⁻¹' A3))
    rw [p.markedCodeLaw_fst,p.markedCodeLaw_fst] at h01
    rw [p.markedCodeLaw_fst] at h23
    linarith
  change (p.codeLaw n).real A0 ≤ η/4 at hh
  change (p.codeLaw n).real A1 < η/4 at hK
  change (p.markedCodeLaw κ n).real A2 < η/4 at hbR
  change (p.codeLaw n).real A3 < η/4 at hkR
  exact hprob.trans_lt (by linarith)

end FKCRT.TreeCoding
end

end OAI