import Mathlib
import OAI.Geometry.Cannon.Modulus.PathCellIndices

namespace OAI

section
section
section
noncomputable section
section
section
section
section
section
section
section
section
section
section
open Set Metric Finset

namespace CannonCapacity

attribute [local instance] Classical.propDecidable

lemma bin_near_card (n : ℕ) (offset s d : ℝ) (hs : 0 < s) :
    (univ.filter (fun i : Fin n => |d-(offset+(i:ℝ)*s)| ≤ 5*s)).card ≤ 11 := by
  classical
  let S := univ.filter (fun i : Fin n => |d-(offset+(i:ℝ)*s)| ≤ 5*s)
  by_cases hS : S.Nonempty
  · obtain ⟨i,hi,hmin⟩ := S.exists_min_image (fun i => i.val) hS
    have hsub : S.image (fun i => i.val) ⊆ Finset.Icc i.val (i.val+10) := by
      intro k hk
      obtain ⟨j,hj,rfl⟩ := mem_image.mp hk
      refine Finset.mem_Icc.mpr ⟨hmin j hj,?_⟩
      have hi' := abs_le.mp (mem_filter.mp hi).2
      have hj' := abs_le.mp (mem_filter.mp hj).2
      have hr : (j.val:ℝ) ≤ (i.val:ℝ)+10 := by
        change -(5*s) ≤ d-(offset+(i.val:ℝ)*s) ∧ _ at hi'
        change -(5*s) ≤ d-(offset+(j.val:ℝ)*s) ∧ _ at hj'
        nlinarith
      exact_mod_cast hr
    have hc := Finset.card_le_card hsub
    rw [Finset.card_image_of_injective _ Fin.val_injective] at hc
    exact hc.trans (by simp; omega)
  · change S.card ≤ 11
    rw [Finset.not_nonempty_iff_eq_empty.mp hS,Finset.card_empty]
    norm_num

theorem exists_radial_bins (A R s : ℝ) (hs : 0 < s) (hscale : 2*s ≤ R) :
    ∃ n : ℕ, ∃ bin : Fin n → ℝ,
      R/(2*s) ≤ (n:ℝ) ∧
      (∀ i, (A+1)*R ≤ bin i ∧ bin i ≤ (A+2)*R) ∧
      (∀ i j, i ≠ j → s ≤ |bin i-bin j|) ∧
      (∀ d, (univ.filter (fun i => |d-bin i| ≤ 5*s)).card ≤ 11) := by
  let n := ⌊R/s⌋₊
  let bin : Fin n → ℝ := fun i => (A+1)*R+(i:ℝ)*s
  have hR : 0 < R := by linarith
  have hrs : 0 ≤ R/s := div_nonneg hR.le hs.le
  have hfloor : (n:ℝ) ≤ R/s := Nat.floor_le hrs
  have hfloor' : R/s < (n:ℝ)+1 := Nat.lt_floor_add_one _
  refine ⟨n,bin,?_,?_,?_,?_⟩
  · apply (div_le_iff₀ (by positivity : 0 < 2*s)).mpr
    have hf := (div_lt_iff₀ hs).mp hfloor'
    nlinarith
  · intro i
    have hi : (i:ℝ) < (n:ℝ) := by exact_mod_cast i.isLt
    have hni : (0:ℝ) ≤ (i:ℝ) := by positivity
    dsimp [bin]
    constructor
    · nlinarith
    · have hns := (le_div_iff₀ hs).mp hfloor
      nlinarith
  · intro i j hij
    have hv : i.val ≠ j.val := fun h => hij (Fin.ext h)
    have hd : 1 ≤ |(i.val:ℝ)-(j.val:ℝ)| := by
      rcases lt_or_gt_of_ne hv with h | h
      · rw [abs_of_nonpos (sub_nonpos.mpr (by exact_mod_cast (Nat.le_of_lt h)))]
        have : (i.val:ℝ)+1 ≤ (j.val:ℝ) := by exact_mod_cast h
        linarith
      · rw [abs_of_nonneg (sub_nonneg.mpr (by exact_mod_cast (Nat.le_of_lt h)))]
        have : (j.val:ℝ)+1 ≤ (i.val:ℝ) := by exact_mod_cast h
        linarith
    dsimp only [bin]
    rw [show (A+1)*R+(i:ℝ)*s-((A+1)*R+(j:ℝ)*s) = ((i:ℝ)-(j:ℝ))*s by ring,
      abs_mul,abs_of_pos hs]
    nlinarith
  · intro d
    exact bin_near_card n ((A+1)*R) s d hs

end CannonCapacity

end

section

open Filter Topology

namespace CannonCapacity

lemma subexponential_stretch (M : ℕ → ℝ)
    (hM : ∀ lam : ℝ, 1 < lam → ∃ C : ℝ, 0 < C ∧ ∀ j, M j ≤ C*lam^j)
    (m : ℕ) (hm : 0 < m) (ell : ℝ) (hell : 0 < ell) :
    ∃ C : ℝ, 0 < C ∧ ∀ n, M (m*n) ≤ C*Real.exp (ell*n) := by
  have hm' : (0:ℝ) < m := by exact_mod_cast hm
  obtain ⟨C,hC,hbound⟩ := hM (Real.exp (ell/m))
    (Real.one_lt_exp_iff.mpr (div_pos hell hm'))
  refine ⟨C,hC,fun n => ?_⟩
  have hh := hbound (m*n)
  rw [← Real.exp_nat_mul] at hh
  convert hh using 1
  congr 2
  push_cast
  field_simp

lemma eventually_exp_domination (a b C : ℝ) (hab : a < b) :
    ∀ᶠ n : ℕ in atTop, C*Real.exp (a*n) < Real.exp (b*n) := by
  have ht : Tendsto (fun n : ℕ => (b-a)*(n:ℝ)) atTop atTop :=
    tendsto_natCast_atTop_atTop.const_mul_atTop (sub_pos.mpr hab)
  have hh := (Real.tendsto_exp_atTop.comp ht).eventually (eventually_gt_atTop C)
  filter_upwards [hh] with n hn
  have hm := mul_lt_mul_of_pos_right hn (Real.exp_pos (a*n))
  dsimp only [Function.comp_apply] at hm
  rw [← Real.exp_add] at hm
  convert hm using 1; congr 1; ring

theorem eventually_capacity_thresholds (qdim : ℕ) (ell C N : ℝ)
    (hell : 0 < ell) (hC : 0 ≤ C) (hN : 0 < N) (M : ℕ → ℝ)
    (_hMnon : ∀ n, 0 ≤ M n)
    (hM : ∀ lam : ℝ, 1 < lam → ∃ C : ℝ, 0 < C ∧ ∀ j, M j ≤ C*lam^j) :
    ∀ᶠ n : ℕ in atTop, ∀ bins E : ℝ,
      Real.exp (2*ell*n)/2 ≤ bins →
      0 ≤ E → E ≤ C*Real.exp (2*qdim*ell*n)*M ((160*(qdim+1)-2)*n) →
      22*N ≤ Real.exp (-ell*n)*bins ∧
      484*E*N < Real.exp (8*(qdim+1)*ell*n)*bins^2 := by
  have hqdim : (0:ℝ) ≤ qdim := Nat.cast_nonneg _
  obtain ⟨C₁,hC₁,hstretch⟩ := subexponential_stretch M hM (160*(qdim+1)-2) (by omega) ell hell
  have hlarge := eventually_exp_domination 0 ell (44*N) hell
  have hsmall := eventually_exp_domination ((2*qdim+1)*ell) ((8*(qdim+1)+4)*ell)
    (1936*C*C₁*N) (by nlinarith only [hell,hqdim])
  filter_upwards [hlarge,hsmall] with n hn hn'
  simp only [zero_mul,Real.exp_zero,mul_one] at hn
  intro bins E hbins hE hEb
  have hx : 0 < Real.exp (ell*n) := Real.exp_pos _
  have hxn : 0 < Real.exp (-ell*n) := Real.exp_pos _
  have hx2 : 0 < Real.exp (2*ell*n) := Real.exp_pos _
  have hqq : 0 < Real.exp (8*(qdim+1)*ell*n) := Real.exp_pos _
  have hEbound : E ≤ C*C₁*Real.exp ((2*qdim+1)*ell*n) := by
    calc
      E ≤ C*Real.exp (2*qdim*ell*n)*M ((160*(qdim+1)-2)*n) := hEb
      _ ≤ C*Real.exp (2*qdim*ell*n)*(C₁*Real.exp (ell*n)) :=
        mul_le_mul_of_nonneg_left (hstretch n) (mul_nonneg hC (Real.exp_pos _).le)
      _ = _ := by rw [show C*Real.exp (2*qdim*ell*n)*(C₁*Real.exp (ell*n)) =
          C*C₁*(Real.exp (2*qdim*ell*n)*Real.exp (ell*n)) by ring,← Real.exp_add]; congr 2; ring
  constructor
  · have hm := mul_le_mul_of_nonneg_left hbins hxn.le
    have hid : Real.exp (-ell*n)*(Real.exp (2*ell*n)/2) = Real.exp (ell*n)/2 := by
      rw [← mul_div_assoc,← Real.exp_add]
      congr 2
      ring
    rw [hid] at hm
    linarith only [hm,hn]
  · have he := mul_le_mul_of_nonneg_right hEbound (by positivity : 0 ≤ (484:ℝ)*N)
    have hbnon : 0 ≤ bins := (div_pos hx2 (by norm_num)).le.trans hbins
    have hsquare := mul_le_mul hbins hbins (by positivity) hbnon
    have htarget := mul_le_mul_of_nonneg_left hsquare hqq.le
    have hid : Real.exp (8*(qdim+1)*ell*n)*((Real.exp (2*ell*n)/2)*(Real.exp (2*ell*n)/2)) =
        Real.exp ((8*(qdim+1)+4)*ell*n)/4 := by
      rw [show (Real.exp (2*ell*n)/2)*(Real.exp (2*ell*n)/2) =
        (Real.exp (2*ell*n)*Real.exp (2*ell*n))/4 by ring, ← mul_div_assoc,
        ← Real.exp_add,← Real.exp_add]
      congr 2
      ring
    rw [hid] at htarget
    nlinarith only [he,htarget,hn']

end CannonCapacity

end

namespace CannonCapacity

open Set Metric Finset CannonPacking CannonAnnular Filter Topology

attribute [local instance] Classical.propDecidable

theorem uniform_separated_capacity {X : Type*} [MetricSpace X]
    [LocallyPathConnectedSpace X] (qdim : ℕ) (CP A B₀ H C c d₀ ell : ℝ)
    (hpack : PolynomialPacking (X:=X) qdim CP) (hCP : 0 ≤ CP)
    (hA : 1 ≤ A) (hAB : A+3 ≤ B₀) (hH : 0 < H)
    (hC : 0 ≤ C) (hc : 0 < c) (hdc : d₀ ≤ c) (hell : 0 < ell)
    (M : ℕ → ℝ) (hMnon : ∀ j, 0 ≤ M j)
    (hM : ∀ lam : ℝ, 1 < lam → ∃ C : ℝ, 0 < C ∧ ∀ j, M j ≤ C*lam^j) :
    ∀ᶠ n : ℕ in atTop, ∀ {ι ζ δ : Type*} [Fintype ι] [Fintype ζ] [Fintype δ]
      (q : ι → X) (aux : ζ → X) (ξ : δ → X) (h : ζ → X ≃ₜ X)
      (x : X) (Ω : Set X) (f : X → ℝ) (K : ℝ → Set X)
      (lo hi t : ι → ℝ) (a b R r s : ℝ),
      a < b → 0 < R → 0 < r → 0 < s → r ≤ s → s ≤ R/4 →
      (B₀+1)*R ≤ 1 → max H 1*r ≤ 1 → 3*s ≤ 1 →
      max (C+2) (max c 1)*(r/s) ≤ 1 →
      R/s = Real.exp (2*ell*n) →
      (∀ i j, i ≠ j → r ≤ dist (q i) (q j)) →
      (∀ i j, i ≠ j → s ≤ dist (aux i) (aux j)) →
      (∀ i j, i ≠ j → r/s ≤ dist (ξ i) (ξ j)) →
      (∀ z, dist x (aux z) ≤ (B₀+1)*R) →
      (∀ v, (A-1)*R ≤ dist v x → dist v x ≤ (B₀+1)*R → ∃ i, dist (q i) v ≤ r) →
      (∀ v, (A-1)*R ≤ dist v x → dist v x ≤ (B₀+1)*R → ∃ z, dist v (aux z) ≤ s) →
      (∀ v, dist v x ≤ (B₀+2)*R → v ∈ Ω) →
      (∀ v ∈ Ioo a b, IsPreconnected (K v)) →
      (∀ v ∈ Ioo a b, ∃ y ∈ K v, dist y x ≤ A*R) →
      (∀ v ∈ Ioo a b, 2*B₀*R < diam (K v)) →
      (∀ v ∈ Ioo a b, ∀ y ∈ K v, y ∈ Ω → f y=v) →
      (∀ i, lo i ≤ hi i) → (∀ i, 0 ≤ t i) →
      (∀ i, clip a b (hi i)-clip a b (lo i) = (b-a)*t i) →
      (∀ i v, v ∈ Ω → dist v (q i) ≤ 2*r → f v ∈ Icc (lo i) (hi i)) →
      (∀ z v v', dist v (aux z) ≤ 3*s → dist v' (aux z) ≤ 3*s →
        dist (h z v) (h z v') ≤ C/s*dist v v' ∧ c/s*dist v v' ≤ dist (h z v) (h z v')) →
      ∀ ω : δ → ℝ, MacroscopicAdmissible ξ (r/s) d₀ ω →
      (∑ i, (ω i)^2) ≤ M ((160*(qdim+1)-2)*n) →
      ∃ S : Finset ι, (∀ i ∈ S, ∀ j ∈ S, i ≠ j → H*r < dist (q i) (q j)) ∧
        1 ≤ ∑ i ∈ S, min (Real.exp (-ell*n)*t i) (Real.exp (8*(qdim+1)*ell*n)*(t i)^2) := by
  classical
  obtain ⟨Nt,hNt,htransfer⟩ := exists_local_transfer_constant qdim CP (C+2) c
    hpack hCP (by linarith) hc
  obtain ⟨Naux,hauxcount⟩ := exists_overlap_bound qdim CP 3 1 hpack hCP (by norm_num) zero_lt_one
  obtain ⟨Ndeg,hdegcount⟩ := exists_overlap_bound qdim CP H 1 hpack hCP hH zero_lt_one
  let N := Ndeg+1
  have hN : 0 < N := by dsimp [N]; omega
  have hB : 0 ≤ B₀+1 := by linarith
  let Ctotal := (Naux:ℝ)*CP*(B₀+1)^qdim*Nt
  have hCt : 0 ≤ Ctotal := by dsimp [Ctotal]; positivity
  have hthresh := eventually_capacity_thresholds qdim ell Ctotal N hell hCt
    (by exact_mod_cast hN) M hMnon hM
  filter_upwards [hthresh] with n hn
  intro ι ζ δ _ _ _ q aux ξ h x Ω f K lo hi t a b R r s hab hR hr hs hrs hsR
    hrad hdegscale hauxscale htransscale hratio hq haux hξ hauxloc hnet hauxnet hΩ
    hK hinner hdiam hlevel hlohi ht hlen hrange hmap ω hω hωmass
  obtain ⟨nb,bin,hnb,hbin,_hbinsep,hbinmul⟩ := exists_radial_bins A R s hs (by linarith)
  have hdegree (i : ι) : (univ.filter (fun j => dist (q i) (q j) ≤ H*r)).card ≤ N := by
    exact (hdegcount q univ (q i) r hr hdegscale (by intro i _ j _ hij; simpa only [one_mul] using hq i j hij)).trans (by dsimp [N]; omega)
  have hmultaux (i : ι) : (univ.filter (fun z => dist (q i) (aux z) ≤ 3*s)).card ≤ Naux := by
    exact hauxcount aux univ (q i) s hs (by simpa using hauxscale) (by intro i _ j _ hij; simpa only [one_mul] using haux i j hij)
  have hcardaux : (Fintype.card ζ:ℝ) ≤ CP*(B₀+1)^qdim*Real.exp (2*qdim*ell*n) := by
    have hh := indexed_packing qdim CP hpack aux univ x ((B₀+1)*R) s hs
      (by nlinarith only [hsR,hA,hAB,hR]) hrad (by simpa using hauxloc) (by simpa using haux)
    simp only [card_univ] at hh
    have hid : CP*((B₀+1)*R/s)^qdim = CP*(B₀+1)^qdim*Real.exp (2*qdim*ell*n) := by
      rw [mul_div_assoc,hratio,mul_pow,← Real.exp_nat_mul, ← mul_assoc]
      congr 2
      ring
    exact hh.trans_eq hid
  let Etot := (Naux:ℝ)*Fintype.card ζ*(Nt*M ((160*(qdim+1)-2)*n))
  have hEtot : 0 ≤ Etot := by
    exact mul_nonneg (mul_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _))
      (mul_nonneg hNt (hMnon _))
  have hEtotbound : Etot ≤ Ctotal*Real.exp (2*qdim*ell*n)*M ((160*(qdim+1)-2)*n) := by
    have hh := mul_le_mul_of_nonneg_left hcardaux (by positivity : (0:ℝ) ≤ Naux)
    have hh' := mul_le_mul_of_nonneg_right hh (mul_nonneg hNt (hMnon ((160*(qdim+1)-2)*n)))
    convert hh' using 1; (try dsimp [Etot,Ctotal]); first | rfl | ring
  have hbinlower : Real.exp (2*ell*n)/2 ≤ (Fintype.card (Fin nb):ℝ) := by
    rw [← hratio,Fintype.card_fin]
    convert hnb using 1; ring
  obtain ⟨hlarge,hsmall⟩ := hn (Fintype.card (Fin nb)) Etot hbinlower hEtot hEtotbound
  apply node_separated_capacity q bin aux ξ h x Ω f K lo hi t a b A B₀ R r s C c d₀ H
    (Real.exp (-ell*n)) (Real.exp (8*(qdim+1)*ell*n)) Nt (M ((160*(qdim+1)-2)*n)) 11 N Naux
    hab hA (by linarith) hR hr hs hrs hsR hC hc hdc ?_ hnet hauxnet hΩ hK hinner hdiam hlevel
    hlohi ht hlen hrange (fun z v v' hv hv' => (hmap z v v' hv hv').1)
    (fun z v v' hv hv' => (hmap z v v' hv hv').2) ω hω hωmass ?_ hmultaux
    (Real.exp_pos _) (Real.exp_pos _) hNt (hMnon _) (by norm_num)
    (mul_nonneg hH.le hr.le) hN hdegree ?_ ?_ ?_
  · intro j
    obtain ⟨hl,hu⟩ := hbin j
    exact ⟨hl,hu.trans (by nlinarith only [hAB,hR])⟩
  · intro z
    exact htransfer q ξ (h z) (aux z) r s hr hs htransscale hq hξ
      (fun v v' hv hv' => (hmap z v v' hv hv').2) ω
  · intro i
    exact_mod_cast hbinmul (dist (q i) x)
  · linarith only [hlarge]
  · dsimp only [Etot] at hsmall
    nlinarith only [hsmall]

end CannonCapacity

end

namespace CannonCapacity

open Set Finset

attribute [local instance] Classical.propDecidable

lemma clip_mem {a b x : ℝ} (hab : a ≤ b) : clip a b x ∈ Icc a b :=
  ⟨le_max_left _ _,max_le hab (min_le_left _ _)⟩

lemma positive_clip_endpoints {a b l u : ℝ} (hab : a < b)
    (hlen : 0 < clip a b u-clip a b l) : l < b ∧ a < u := by
  constructor
  · by_contra hh
    have hbl : b ≤ l := le_of_not_gt hh
    have hclip : clip a b l = b := by simp only [clip,min_eq_left hbl,max_eq_right hab.le]
    rw [hclip] at hlen
    linarith only [hlen,(clip_mem (x := u) hab.le).2]
  · by_contra hh
    have hua : u ≤ a := le_of_not_gt hh
    have hclip : clip a b u = a := by
      simp only [clip,min_eq_right (hua.trans hab.le),max_eq_left hua]
    rw [hclip] at hlen
    linarith only [hlen,(clip_mem (x := l) hab.le).1]

lemma exists_wide_active_range {ι : Type*} [Fintype ι]
    (lo hi : ι → ℝ) (active : ι → Prop) (a b w : ℝ) (hab : a < b)
    (hlohi : ∀ i, lo i ≤ hi i) (hw : 0 ≤ w)
    (hcard : (Fintype.card ι : ℝ)*w < b-a)
    (hcover : ∀ s ∈ Ioo a b, ∃ i, active i ∧ s ∈ Icc (lo i) (hi i)) :
    ∃ i, active i ∧ w ≤ clip a b (hi i)-clip a b (lo i) := by
  classical
  have hh := CannonAnnular.weighted_open_interval_cover
    (fun i => clip a b (lo i)) (fun i => clip a b (hi i))
    (fun i => if active i then (1:ℝ) else 0) a b 1 hab.le
    (fun i => clip_mono a b (hlohi i)) (fun i => by split_ifs <;> norm_num) (by
      intro s hs
      obtain ⟨i,hai,his⟩ := hcover s hs
      calc
        1 = (Icc (clip a b (lo i)) (clip a b (hi i))).indicator
            (fun _ : ℝ => if active i then (1:ℝ) else 0) s := by
          rw [indicator_of_mem ((mem_clipped_iff hs).mpr his),ite_eq_left hai]
        _ ≤ ∑ j, (Icc (clip a b (lo j)) (clip a b (hi j))).indicator
            (fun _ : ℝ => if active j then (1:ℝ) else 0) s := by
          apply single_le_sum _ (mem_univ i)
          intro j _
          apply Set.indicator_nonneg
          intro _ _
          split_ifs <;> norm_num)
  simp only [one_mul] at hh
  by_contra hn
  have hbound : (∑ i, (if active i then (1:ℝ) else 0)*
      (clip a b (hi i)-clip a b (lo i))) ≤ (Fintype.card ι : ℝ)*w := by
    calc
      _ ≤ ∑ _i : ι, w := by
        apply sum_le_sum
        intro i _
        by_cases ha : active i
        · rw [ite_eq_left ha,one_mul]
          exact le_of_lt (lt_of_not_ge (fun hh => hn ⟨i,ha,hh⟩))
        · simp only [ite_eq_right ha,zero_mul]
          exact hw
      _ = _ := by simp
  linarith only [hh,hbound,hcard]

lemma small_outer_lower_end {a b l u : ℝ} (hab : a < b)
    (hl : l ≤ a+(b-a)/4)
    (hsmall : clip a b u-clip a b l < (b-a)/8) : u < a+3*(b-a)/8 := by
  by_contra hu
  have htarget : a+3*(b-a)/8 ≤ u := le_of_not_gt hu
  have hcL : clip a b l ≤ a+(b-a)/4 :=
    max_le (by linarith only [hab]) ((min_le_right _ _).trans hl)
  have hcU : a+3*(b-a)/8 ≤ clip a b u :=
    (le_min (by linarith only [hab]) htarget).trans (le_max_right _ _)
  linarith only [hsmall,hcL,hcU]

lemma small_outer_upper_start {a b l u : ℝ} (hab : a < b)
    (hu : a+3*(b-a)/4 ≤ u)
    (hsmall : clip a b u-clip a b l < (b-a)/8) : a+5*(b-a)/8 < l := by
  by_contra hl
  have htarget : l ≤ a+5*(b-a)/8 := le_of_not_gt hl
  have hcL : clip a b l ≤ a+5*(b-a)/8 :=
    max_le (by linarith only [hab]) ((min_le_right _ _).trans htarget)
  have hcU : a+3*(b-a)/4 ≤ clip a b u :=
    (le_min (by linarith only [hab]) hu).trans (le_max_right _ _)
  linarith only [hsmall,hcL,hcU]

theorem bad_node_large_range {ι : Type*} [Fintype ι]
    (li ui lo uo : ι → ℝ) (near : ι → Prop) (a b κ : ℝ)
    (hab : a < b) (hκ : 0 < κ) (hcount : (Fintype.card ι : ℝ)*κ ≤ 1/8)
    (hinner : ∀ i, li i ≤ ui i) (hlo : ∀ i, lo i ≤ li i) (huo : ∀ i, ui i ≤ uo i)
    (hcover : ∀ s ∈ Ioo a b, ∃ i, near i ∧ s ∈ Icc (li i) (ui i))
    (hbad : ¬ ∃ i j,
      κ*(b-a) ≤ clip a (a+(b-a)/4) (ui i)-clip a (a+(b-a)/4) (li i) ∧
      κ*(b-a) ≤ clip (a+3*(b-a)/4) b (ui j)-clip (a+3*(b-a)/4) b (li j) ∧
      uo i+(b-a)/4 ≤ lo j) :
    ∃ i, near i ∧ (b-a)/8 ≤ clip a b (uo i)-clip a b (lo i) := by
  have hΔ : 0 < b-a := sub_pos.mpr hab
  have hw : 0 < κ*(b-a) := mul_pos hκ hΔ
  have hcount' : (Fintype.card ι : ℝ)*(κ*(b-a)) ≤ (b-a)/8 := by nlinarith only [hcount,hΔ]
  obtain ⟨i,hni,hwi⟩ := exists_wide_active_range li ui near a (a+(b-a)/4) (κ*(b-a))
    (by linarith only [hab]) hinner hw.le (by linarith only [hcount',hΔ]) (by
      intro s hs
      apply hcover s
      exact ⟨hs.1,by linarith only [hs.2,hab]⟩)
  obtain ⟨j,hnj,hwj⟩ := exists_wide_active_range li ui near (a+3*(b-a)/4) b (κ*(b-a))
    (by linarith only [hab]) hinner hw.le (by linarith only [hcount',hΔ]) (by
      intro s hs
      apply hcover s
      exact ⟨by linarith only [hs.1,hab],hs.2⟩)
  by_contra hn
  have hsi : clip a b (uo i)-clip a b (lo i) < (b-a)/8 :=
    lt_of_not_ge (fun h => hn ⟨i,hni,h⟩)
  have hsj : clip a b (uo j)-clip a b (lo j) < (b-a)/8 :=
    lt_of_not_ge (fun h => hn ⟨j,hnj,h⟩)
  have hiend := (positive_clip_endpoints (by linarith only [hab]) (hw.trans_le hwi)).1
  have hjstart := (positive_clip_endpoints (by linarith only [hab]) (hw.trans_le hwj)).2
  have he := small_outer_lower_end hab ((hlo i).trans hiend.le) hsi
  have hs := small_outer_upper_start hab (hjstart.le.trans (huo j)) hsj
  exact hbad ⟨i,j,hwi,hwj,by linarith only [he,hs]⟩

end CannonCapacity

namespace CannonCapacity

open Set Metric Finset

attribute [local instance] Classical.propDecidable

theorem node_radial_cover {X : Type*} [MetricSpace X] {ι : Type*} [Fintype ι]
    (q : ι → X) (x : X) (Ω : Set X) (f : X → ℝ) (K : ℝ → Set X)
    (li ui : ι → ℝ) (a b A B R r rad : ℝ)
    (hR : 0 < R) (hr : 0 ≤ r) (hA : 0 ≤ A) (hrad : A*R ≤ rad ∧ rad ≤ B*R)
    (hnet : ∀ v, (A-1)*R ≤ dist v x → dist v x ≤ (B+1)*R → ∃ i, dist (q i) v ≤ r)
    (hΩ : ∀ v, dist v x ≤ (B+1)*R → v ∈ Ω)
    (hK : ∀ t ∈ Ioo a b, IsPreconnected (K t))
    (hinner : ∀ t ∈ Ioo a b, ∃ y ∈ K t, dist y x ≤ A*R)
    (hdiam : ∀ t ∈ Ioo a b, 2*B*R < diam (K t))
    (hlevel : ∀ t ∈ Ioo a b, ∀ v ∈ K t, v ∈ Ω → f v=t)
    (hrange : ∀ i v, v ∈ Ω → dist v (q i) ≤ 2*r → f v ∈ Icc (li i) (ui i)) :
    ∀ t ∈ Ioo a b, ∃ i, |dist (q i) x-rad| ≤ r ∧ t ∈ Icc (li i) (ui i) := by
  intro t ht
  obtain ⟨w,hw,hwr⟩ := level_radial_hit x (K t) (hK t ht)
    ((mul_nonneg hA hR.le).trans hrad.1)
    (by obtain ⟨y,hy,hyD⟩ := hinner t ht; exact ⟨y,hy,hyD.trans hrad.1⟩)
    (by nlinarith only [hdiam t ht,hrad.2])
  obtain ⟨i,hi⟩ := hnet w (by rw [hwr]; nlinarith only [hrad.1,hR])
    (by rw [hwr]; nlinarith only [hrad.2,hR])
  have hwΩ := hΩ w (by rw [hwr]; nlinarith only [hrad.2,hR])
  refine ⟨i,?_,?_⟩
  · rw [← hwr]
    exact (abs_dist_sub_le (q i) w x).trans hi
  · rw [← hlevel t ht w hw hwΩ]
    apply hrange i w hwΩ
    rw [dist_comm]
    linarith only [hi,hr]

theorem bad_node_many_children {X : Type*} [MetricSpace X] {ι : Type*} [Fintype ι]
    (q : ι → X) (x : X) (li ui lo uo t : ι → ℝ) (a b κ A B R r H : ℝ)
    (hab : a < b) (hκ : 0 < κ) (hcount : (Fintype.card ι:ℝ)*κ ≤ 1/8)
    (hR : 0 < R) (hr : 0 < r) (hH : 0 < H) (hAB : A+2 ≤ B)
    (hscale : 2*((H+3)*r) ≤ R)
    (hinner : ∀ i, li i ≤ ui i) (hlo : ∀ i, lo i ≤ li i) (huo : ∀ i, ui i ≤ uo i)
    (hlen : ∀ i, clip a b (uo i)-clip a b (lo i) = (b-a)*t i)
    (hcover : ∀ rad, A*R ≤ rad → rad ≤ B*R → ∀ s ∈ Ioo a b,
      ∃ i, |dist (q i) x-rad| ≤ r ∧ s ∈ Icc (li i) (ui i))
    (hbad : ¬ ∃ i j,
      κ*(b-a) ≤ clip a (a+(b-a)/4) (ui i)-clip a (a+(b-a)/4) (li i) ∧
      κ*(b-a) ≤ clip (a+3*(b-a)/4) b (ui j)-clip (a+3*(b-a)/4) b (li j) ∧
      uo i+(b-a)/4 ≤ lo j) :
    ∃ S : Finset ι, R/(2*(H+3)*r) ≤ (S.card:ℝ) ∧
      (∀ i ∈ S, 1/8 ≤ t i) ∧ ∀ i ∈ S, ∀ j ∈ S, i ≠ j → H*r < dist (q i) (q j) := by
  classical
  obtain ⟨n,bin,hnb,hbin,hsep,_⟩ := exists_radial_bins A R ((H+3)*r)
    (mul_pos (by linarith) hr) hscale
  have hchoose (z : Fin n) : ∃ i, |dist (q i) x-bin z| ≤ r ∧ 1/8 ≤ t i := by
    obtain ⟨i,hi,ht⟩ := bad_node_large_range li ui lo uo
      (fun i => |dist (q i) x-bin z| ≤ r) a b κ hab hκ hcount hinner hlo huo
      (hcover (bin z) (by nlinarith only [(hbin z).1,hR])
        (by nlinarith only [(hbin z).2,hAB,hR])) hbad
    refine ⟨i,hi,?_⟩
    rw [hlen] at ht
    nlinarith only [ht,hab]
  choose choose hnear ht using hchoose
  have hdist {z w : Fin n} (hzw : z ≠ w) : H*r < dist (q (choose z)) (q (choose w)) := by
    have hz := hnear z
    have hw := hnear w
    have hm := hsep z w hzw
    have hd := abs_dist_sub_le (q (choose z)) (q (choose w)) x
    have htri : |bin z-bin w| ≤ |bin z-dist (q (choose z)) x| +
        |dist (q (choose z)) x-dist (q (choose w)) x| +
        |dist (q (choose w)) x-bin w| := by
      simpa only [Real.dist_eq] using dist_triangle4 (bin z)
        (dist (q (choose z)) x) (dist (q (choose w)) x) (bin w)
    rw [abs_sub_comm (bin z) (dist (q (choose z)) x)] at htri
    nlinarith only [hz,hw,hm,hd,htri,hr]
  have hinj : Function.Injective choose := by
    intro z w hzw
    by_contra hn
    have hd := hdist hn
    rw [hzw,dist_self] at hd
    have hh := mul_pos hH hr
    linarith only [hd,hh]
  refine ⟨univ.image choose,?_,?_,?_⟩
  · rw [Finset.card_image_of_injective _ hinj,card_univ,Fintype.card_fin]
    convert hnb using 1; ring
  · intro i hi
    obtain ⟨z,_,rfl⟩ := mem_image.mp hi
    exact ht z
  · intro i hi j hj hij
    obtain ⟨z,_,rfl⟩ := mem_image.mp hi
    obtain ⟨w,_,rfl⟩ := mem_image.mp hj
    exact hdist (fun hz => hij (congrArg choose hz))

end CannonCapacity

end
end
end
end
end
end
end
end
end
end
end
end

end OAI