import OAI.Combinatorics.HalvingLines.AtomicBounds

namespace OAI

open Filter Topology

namespace PlanarHalving.Limits
open MeasureTheory Set Filter
open scoped Topology
variable {X ι : Type*} [MeasurableSpace X]

lemma probability_overlap_bound (μ : FiniteMeasure X) (S : Finset ι) (p : ι → X → ℝ)
    (hp : ∀ i ∈ S, Measurable (p i)) (hp0 : ∀ i ∈ S, ∀ z, 0 ≤ p i z)
    (hsum : ∀ z, ∑ i ∈ S, p i z ≤ 1) {β : ℝ} (hβ : 0 < β) :
    ∑ i ∈ S, (μ {z | β < p i z} : ℝ) ≤ (μ.mass : ℝ)/β := by
  classical
  let A : ι → Set X := fun i => {z | β < p i z}
  have hm i (hi : i ∈ S) : MeasurableSet (A i) := measurableSet_lt measurable_const (hp i hi)
  have hInt i (hi : i ∈ S) : Integrable ((A i).indicator (fun _ : X => (1 : ℝ))) (μ : Measure X) :=
    (integrable_const 1).indicator (hm i hi)
  have he i (hi : i ∈ S) : ∫ z, (A i).indicator (fun _ : X => (1 : ℝ)) z ∂(μ : Measure X) =
      (μ (A i) : ℝ) := by
    rw [integral_indicator_const 1 (hm i hi)]
    simp
  have hbound (z : X) : (∑ i ∈ S, (A i).indicator (fun _ : X => (1 : ℝ)) z) ≤ 1/β := by
    have hh : β*(∑ i ∈ S, (A i).indicator (fun _ : X => (1 : ℝ)) z) ≤ 1 := by
      calc
        _ = ∑ i ∈ S, β*(A i).indicator (fun _ : X => (1 : ℝ)) z := Finset.mul_sum ..
        _ ≤ ∑ i ∈ S, p i z := by
          apply Finset.sum_le_sum
          intro i hi
          by_cases hz : z ∈ A i
          · simpa only [Set.indicator_of_mem hz,mul_one] using (show β < p i z from hz).le
          · simpa only [Set.indicator_of_notMem hz,mul_zero] using hp0 i hi z
        _ ≤ 1 := hsum z
    exact (le_div_iff₀ hβ).mpr (by simpa only [mul_comm] using hh)
  have hh := integral_mono (integrable_finsetSum S hInt) (integrable_const (1/β)) hbound
  rw [integral_finsetSum S hInt] at hh
  rw [Finset.sum_congr rfl he] at hh
  simpa [integral_const,div_eq_mul_inv,FiniteMeasure.mass] using hh

lemma finite_bad_cover_mass (μ : FiniteMeasure X) (S : Finset ι) (p : ι → X → ℝ)
    (hp : ∀ i ∈ S, Measurable (p i)) (hp0 : ∀ i ∈ S, ∀ z, 0 ≤ p i z)
    (hp1 : ∀ i ∈ S, ∀ z, p i z ≤ 1) {β : ℝ}
    {B : Set X} (hB : MeasurableSet B)
    (hcover : ∀ z ∈ B, ∃ i ∈ S, β < p i z) :
    β*(μ B : ℝ) ≤ ∑ i ∈ S, ∫ z in {z | β < p i z}, p i z ∂(μ : Measure X) := by
  classical
  let A : ι → Set X := fun i => {z | β < p i z}
  have hm i (hi : i ∈ S) : MeasurableSet (A i) := measurableSet_lt measurable_const (hp i hi)
  have hInt i (hi : i ∈ S) : Integrable (p i) (μ : Measure X) :=
    (integrable_const (1 : ℝ)).mono' (hp i hi).aestronglyMeasurable
      (Filter.Eventually.of_forall (fun z => by simpa only [Real.norm_eq_abs,abs_of_nonneg (hp0 i hi z)] using hp1 i hi z))
  have hInd i (hi : i ∈ S) := (hInt i hi).indicator (hm i hi)
  have hpoint (z : X) : B.indicator (fun _ : X => β) z ≤ ∑ i ∈ S, (A i).indicator (p i) z := by
    have hnn i (hi : i ∈ S) : 0 ≤ (A i).indicator (p i) z := by
      exact Set.indicator_nonneg (fun x _ => hp0 i hi x) z
    by_cases hz : z ∈ B
    · obtain ⟨i,hi,hip⟩ := hcover z hz
      rw [Set.indicator_of_mem hz]
      calc
        β ≤ (A i).indicator (p i) z := by rw [Set.indicator_of_mem (show z ∈ A i from hip)]; exact hip.le
        _ ≤ ∑ i ∈ S, (A i).indicator (p i) z := Finset.single_le_sum hnn hi
    · rw [Set.indicator_of_notMem hz]
      exact Finset.sum_nonneg hnn
  have hh := integral_mono ((integrable_const β).indicator hB) (integrable_finsetSum S hInd) hpoint
  rw [integral_indicator_const β hB,integral_finsetSum S hInd] at hh
  rw [Finset.sum_congr rfl (fun i hi => integral_indicator (hm i hi))] at hh
  simpa [mul_comm] using hh

end PlanarHalving.Limits

namespace PlanarHalving.Limits
open MeasureTheory Set Filter
open scoped Topology

theorem ae_exists_partition_small {X ι : Type*} [MeasurableSpace X]
    (lam μ : FiniteMeasure X) (S : ℕ → Finset ι) (p : ℕ → ι → X → ℝ)
    (mu nu : ℕ → ι → FiniteMeasure X) (s : ℕ → ι → ℝ) (q : ℕ → ℝ)
    {A H : ℝ} (hA : 0 ≤ A)
    (hq : ∀ n, 0 < q n) (hqtop : Tendsto q atTop atTop)
    (hcard : ∀ n, ((S n).card : ℝ) ≤ q n)
    (hp : ∀ n i, i ∈ S n → Measurable (p n i))
    (hp0 : ∀ n i, i ∈ S n → ∀ z, 0 ≤ p n i z)
    (hp1 : ∀ n i, i ∈ S n → ∀ z, p n i z ≤ 1)
    (hsum : ∀ n z, ∑ i ∈ S n, p n i z ≤ 1)
    (hs0 : ∀ n i, i ∈ S n → 0 ≤ s n i)
    (hmu : ∀ n i, i ∈ S n → ∀ B, mu n i B ≤ μ B)
    (hnu : ∀ n i, i ∈ S n → ∀ B, MeasurableSet B →
      (nu n i B : ℝ) = ∫ z in B, p n i z ∂(lam : Measure X))
    (hnuMass : ∀ n i, i ∈ S n → ((nu n i).mass : ℝ) ≤ (q n)⁻¹)
    (hmass : ∀ n i, i ∈ S n → ∀ B, MeasurableSet B →
      (nu n i B : ℝ)^3 ≤ A*(s n i)^3*(mu n i B : ℝ))
    (htail : ∀ n u, 0 < u → ((S n |>.filter fun i => u < s n i).card : ℝ) ≤
      H*u^(-(4:ℝ)/3)) {β : ℝ} (hβ : 0 < β) :
    ∀ᵐ z ∂(lam : Measure X), ∃ n, ∀ i ∈ S n, p n i z ≤ β := by
  classical
  let B : Set X := ⋂ n, ⋃ i ∈ S n, {z | β < p n i z}
  have hm n i (hi : i ∈ S n) : MeasurableSet {z | β < p n i z} :=
    measurableSet_lt measurable_const (hp n i hi)
  have hB : MeasurableSet B := by
    apply MeasurableSet.iInter
    intro n
    exact (S n).finite_toSet.measurableSet_biUnion (fun i hi => hm n i hi)
  have hcover n z (hz : z ∈ B) : ∃ i ∈ S n, β < p n i z := by
    have hz' := mem_iInter.mp hz n
    simpa only [mem_iUnion,mem_ofPred_eq,exists_prop] using hz'
  have hz := persistent_mass_zero S
    (fun n i => (nu n i {z | β < p n i z} : ℝ))
    (fun n i => (mu n i {z | β < p n i z} : ℝ)) s q
    (L := β*(lam B : ℝ)) (A := A) (H := H) (U := (μ.mass : ℝ)/β)
    (mul_nonneg hβ.le (NNReal.coe_nonneg _)) hA hq hqtop hcard
    (fun _ _ _ => NNReal.coe_nonneg _) ?_
    (fun _ _ _ => NNReal.coe_nonneg _) hs0 ?_ ?_ htail ?_
  · have hzero : (lam B : ℝ) = 0 := (mul_eq_zero.mp hz).resolve_left hβ.ne'
    have hzero' : (lam : Measure X) B = 0 := by
      apply (measureReal_eq_zero_iff (measure_ne_top _ _)).mp
      simpa using hzero
    rw [ae_iff]
    have he : {z | ¬ ∃ n, ∀ i ∈ S n, p n i z ≤ β} = B := by
      ext z
      simp only [mem_ofPred_eq,not_exists,not_forall,not_le,B,mem_iInter,mem_iUnion,
        exists_prop]
    rw [he]
    exact hzero'
  · intro n i hi
    exact (show (nu n i {z | β < p n i z} : ℝ) ≤ ((nu n i).mass : ℝ) from
      NNReal.coe_le_coe.mpr ((nu n i).apply_le_mass _)).trans (hnuMass n i hi)
  · intro n i hi
    exact hmass n i hi _ (hm n i hi)
  · intro n
    exact (Finset.sum_le_sum (fun i hi => NNReal.coe_le_coe.mpr (hmu n i hi _))).trans
      (probability_overlap_bound μ (S n) (p n) (hp n) (hp0 n) (hsum n) hβ)
  · intro n
    have hc := finite_bad_cover_mass lam (S n) (p n) (hp n) (hp0 n) (hp1 n) hB (hcover n)
    simpa only [Finset.sum_congr rfl (fun i hi => hnu n i hi _ (hm n i hi))] using hc

end PlanarHalving.Limits

namespace PlanarHalving.Limits
open MeasureTheory Set Filter ProbabilityTheory

lemma kernel_nullSingleton_of_cells {X T ι : Type*} [MeasurableSpace X]
    [MeasurableSpace T] (lam : Measure X) (h : Kernel X T) [IsMarkovKernel h]
    (S : ℕ → Finset ι) (cell : ℕ → ι → Set T)
    (hcover : ∀ n t, ∃ i ∈ S n, t ∈ cell n i)
    (hsmall : ∀ m : ℕ, ∀ᵐ z ∂lam, ∃ n, ∀ i ∈ S n,
      (h z).real (cell n i) ≤ 1/((m : ℝ)+1)) :
    ∀ᵐ z ∂lam, NullSingletonClass (h z) := by
  have hh := (ae_all_iff.mpr hsmall)
  filter_upwards [hh] with z hz
  constructor
  intro t
  apply (measureReal_eq_zero_iff (measure_ne_top _ _)).mp
  by_contra hpos
  have htpos : 0 < (h z).real {t} := lt_of_le_of_ne (measureReal_nonneg) (Ne.symm hpos)
  obtain ⟨m, hm⟩ := exists_nat_one_div_lt htpos
  obtain ⟨n, hn⟩ := hz m
  obtain ⟨i, hi, hit⟩ := hcover n t
  have hh : (h z).real {t} ≤ (h z).real (cell n i) :=
    measureReal_mono (singleton_subset_iff.mpr hit)
  linarith [hn i hi]

end PlanarHalving.Limits
namespace PlanarHalving.UniformPartition
open MeasureTheory Set
open scoped unitInterval

noncomputable def boundary (m : ℕ) [NeZero m] (i : Fin (m+1)) : I :=
  ⟨(i : ℝ)/(m : ℝ), by
    have hm : (0 : ℝ) < m := Nat.cast_pos.mpr (NeZero.pos m)
    constructor
    · positivity
    · apply (div_le_one hm).mpr
      exact_mod_cast (Nat.le_of_lt_succ i.isLt)⟩

noncomputable def cell (m : ℕ) [NeZero m] (i : Fin m) : Set I :=
  if i.val+1=m then Icc (boundary m i.castSucc) (boundary m i.succ)
  else Ico (boundary m i.castSucc) (boundary m i.succ)

lemma cell_measurable (m : ℕ) [NeZero m] (i : Fin m) : MeasurableSet (cell m i) := by
  unfold cell
  split_ifs <;> measurability

lemma cell_lower (m : ℕ) [NeZero m] (i : Fin m) {t : I} (ht : t ∈ cell m i) :
    (i : ℝ)/(m : ℝ) ≤ (t : ℝ) := by
  unfold cell at ht
  split_ifs at ht <;> exact ht.1

lemma cell_upper (m : ℕ) [NeZero m] (i : Fin m) {t : I} (ht : t ∈ cell m i) :
    (t : ℝ) ≤ ((i : ℝ)+1)/(m : ℝ) := by
  unfold cell at ht
  split_ifs at ht
  · simpa [boundary] using (show (t : ℝ) ≤ (boundary m i.succ : ℝ) from ht.2)
  · simpa [boundary] using (show (t : ℝ) ≤ (boundary m i.succ : ℝ) from ht.2.le)

lemma cell_upper_lt (m : ℕ) [NeZero m] (i : Fin m) (hi : i.val+1≠m)
    {t : I} (ht : t ∈ cell m i) : (t : ℝ) < ((i : ℝ)+1)/(m : ℝ) := by
  rw [cell,ite_eq_right hi] at ht
  simpa [boundary] using (show (t : ℝ) < (boundary m i.succ : ℝ) from ht.2)

lemma cells_disjoint (m : ℕ) [NeZero m] : Pairwise (fun i j : Fin m => Disjoint (cell m i) (cell m j)) := by
  have hh (i j : Fin m) (hlt : i.val < j.val) : Disjoint (cell m i) (cell m j) := by
    apply Set.disjoint_left.mpr
    intro t hti htj
    have hm : (0 : ℝ) < m := Nat.cast_pos.mpr (NeZero.pos m)
    have hu := cell_upper_lt m i (by omega) hti
    have hl := cell_lower m j htj
    have hij' : (i : ℝ)+1 ≤ (j : ℝ) := by exact_mod_cast hlt
    have hc := div_le_div_of_nonneg_right hij' hm.le
    linarith
  intro i j hij
  have hne : i.val ≠ j.val := fun h => hij (Fin.ext h)
  rcases lt_or_gt_of_ne hne with h | h
  · exact hh i j h
  · exact (hh j i h).symm

lemma mem_some_cell (m : ℕ) [NeZero m] (t : I) : ∃ i : Fin m, t ∈ cell m i := by
  have hm : 0 < m := NeZero.pos m
  have hm' : (0 : ℝ) < m := Nat.cast_pos.mpr hm
  by_cases ht : (t : ℝ)=1
  · let i : Fin m := ⟨m-1, by omega⟩
    refine ⟨i, ?_⟩
    have hi : i.val+1=m := by dsimp [i]; omega
    rw [cell,ite_eq_left hi]
    constructor
    · change (i : ℝ)/(m : ℝ) ≤ (t : ℝ)
      rw [ht]
      apply (div_le_one hm').mpr
      exact_mod_cast i.isLt.le
    · change (t : ℝ) ≤ ((i.val+1 : ℕ) : ℝ)/(m : ℝ)
      rw [Nat.cast_add,Nat.cast_one,ht]
      have he : (i : ℝ)+1=(m : ℝ) := by exact_mod_cast hi
      rw [he,div_self hm'.ne']
  · have ht' : (t : ℝ)<1 := lt_of_le_of_ne t.property.2 ht
    have hx : 0 ≤ (m : ℝ)*(t : ℝ) := mul_nonneg hm'.le t.property.1
    have hi : ⌊(m : ℝ)*(t : ℝ)⌋₊ < m := by
      apply (Nat.floor_lt hx).mpr
      nlinarith
    let i : Fin m := ⟨⌊(m : ℝ)*(t : ℝ)⌋₊, hi⟩
    have hlo : (i : ℝ)/(m : ℝ) ≤ (t : ℝ) := by
      apply (div_le_iff₀ hm').mpr
      simpa [i,mul_comm] using Nat.floor_le hx
    have hup : (t : ℝ) < ((i : ℝ)+1)/(m : ℝ) := by
      apply (lt_div_iff₀ hm').mpr
      simpa [i,mul_comm] using Nat.lt_floor_add_one ((m : ℝ)*(t : ℝ))
    refine ⟨i, ?_⟩
    unfold cell
    split_ifs
    · refine ⟨hlo, ?_⟩
      change (t : ℝ) ≤ ((i.val+1 : ℕ) : ℝ)/(m : ℝ)
      simpa only [Nat.cast_add,Nat.cast_one] using hup.le
    · refine ⟨hlo, ?_⟩
      change (t : ℝ) < ((i.val+1 : ℕ) : ℝ)/(m : ℝ)
      simpa only [Nat.cast_add,Nat.cast_one] using hup

lemma cells_cover (m : ℕ) [NeZero m] : (⋃ i : Fin m, cell m i) = univ := by
  ext t
  simp only [mem_iUnion,mem_univ,iff_true]
  exact mem_some_cell m t

lemma cell_volume (m : ℕ) [NeZero m] (i : Fin m) :
    volume (cell m i) = ENNReal.ofReal (1/(m : ℝ)) := by
  have he : ((boundary m i.succ : I) : ℝ) - ((boundary m i.castSucc : I) : ℝ) =
      1/(m : ℝ) := by simp [boundary]; ring
  unfold cell
  split_ifs
  · rw [unitInterval.volume_Icc,he]
  · rw [unitInterval.volume_Ico,he]

lemma cell_diameter_bound (m : ℕ) [NeZero m] (i : Fin m) {s t : I}
    (hs : s ∈ cell m i) (ht : t ∈ cell m i) : dist s t ≤ 1/(m : ℝ) := by
  rw [Subtype.dist_eq,Real.dist_eq]
  apply abs_le.mpr
  have hs0 := cell_lower m i hs
  have hs1 := cell_upper m i hs
  have ht0 := cell_lower m i ht
  have ht1 := cell_upper m i ht
  have he : ((i : ℝ)+1)/(m : ℝ) = (i : ℝ)/(m : ℝ)+1/(m : ℝ) := by ring
  rw [he] at hs1 ht1
  constructor <;> linarith

end PlanarHalving.UniformPartition

namespace PlanarHalving.UniformPartition
open MeasureTheory Set Filter
open scoped unitInterval Topology

noncomputable def index (m : ℕ) [NeZero m] (t : I) : Fin m :=
  (mem_some_cell m t).choose

lemma mem_cell_index (m : ℕ) [NeZero m] (t : I) : t ∈ cell m (index m t) :=
  (mem_some_cell m t).choose_spec

lemma index_eq (m : ℕ) [NeZero m] (t : I) (i : Fin m) : index m t = i ↔ t ∈ cell m i := by
  constructor
  · intro h; rw [← h]; exact mem_cell_index m t
  · intro ht
    by_contra hne
    exact Set.disjoint_left.mp (cells_disjoint m hne) (mem_cell_index m t) ht

lemma index_measurable (m : ℕ) [NeZero m] : Measurable (index m) := by
  apply measurable_to_countable'
  intro i
  have he : (index m) ⁻¹' {i} = cell m i := by ext t; exact index_eq m t i
  rw [he]
  exact cell_measurable m i

noncomputable def grid (m : ℕ) [NeZero m] (t : I) : I := boundary m (index m t).castSucc

lemma grid_measurable (m : ℕ) [NeZero m] : Measurable (grid m) :=
  (measurable_of_finite (fun i : Fin m => boundary m i.castSucc)).comp (index_measurable m)

lemma dist_grid (m : ℕ) [NeZero m] (t : I) : dist (grid m t) t ≤ 1/(m : ℝ) := by
  have ht := mem_cell_index m t
  have hl := cell_lower m (index m t) ht
  have hu := cell_upper m (index m t) ht
  rw [Subtype.dist_eq,Real.dist_eq,abs_sub_comm]
  change |(t : ℝ)-(index m t : ℝ)/(m : ℝ)| ≤ _
  rw [abs_of_nonneg (sub_nonneg.mpr hl)]
  change (t : ℝ)-(index m t : ℝ)/(m : ℝ) ≤ 1/(m : ℝ)
  have he : ((index m t : ℝ)+1)/(m : ℝ) = (index m t : ℝ)/(m : ℝ)+1/(m : ℝ) := by ring
  rw [he] at hu
  linarith

lemma grid_tendsto (t : I) : Tendsto (fun n : ℕ => grid (n+1) t) atTop (𝓝 t) := by
  apply tendsto_iff_dist_tendsto_zero.mpr
  apply squeeze_zero (fun _ => dist_nonneg) (fun n => dist_grid (n+1) t)
  simpa only [Nat.cast_add,Nat.cast_one] using tendsto_one_div_add_atTop_nhds_zero_nat

lemma grid_pair_tendsto (t : I × I) :
    Tendsto (fun n : ℕ => (grid (n+1) t.1,grid (n+1) t.2)) atTop (𝓝 t) :=
  (grid_tendsto t.1).prodMk_nhds (grid_tendsto t.2)

lemma integral_partition {X ι : Type*} [MeasurableSpace X] [Fintype ι]
    (μ : Measure X) [IsFiniteMeasure μ] (C : ι → Set X)
    (hC : ∀ i, MeasurableSet (C i))
    (idx : X → ι) (hi : ∀ x i, idx x = i ↔ x ∈ C i) (v : ι → ℝ) :
    ∫ x, v (idx x) ∂μ = ∑ i, μ.real (C i)*v i := by
  classical
  have he : (fun x => v (idx x)) = fun x => ∑ i, (C i).indicator (fun _ => v i) x := by
    funext x
    symm
    rw [Finset.sum_eq_single (idx x)]
    · exact Set.indicator_of_mem ((hi x (idx x)).mp rfl) _
    · intro j _ hj
      rw [Set.indicator_of_notMem]
      intro hx
      exact hj ((hi x j).mpr hx).symm
    · simp
  rw [he,integral_finsetSum]
  · apply Finset.sum_congr rfl
    intro i _
    rw [integral_indicator_const _ (hC i)]
    simp only [smul_eq_mul]
  · intro i _
    exact (integrable_const (v i)).indicator (hC i)

lemma integral_grid (m : ℕ) [NeZero m] (f : I → ℝ) :
    ∫ t, f (grid m t) = (∑ i : Fin m, f (boundary m i.castSucc))/(m : ℝ) := by
  rw [show (fun t => f (grid m t)) = fun t =>
    (fun i : Fin m => f (boundary m i.castSucc)) (index m t) from rfl]
  rw [integral_partition volume (cell m) (cell_measurable m)
    (index m) (index_eq m) (fun i : Fin m => f (boundary m i.castSucc))]
  simp only [measureReal_def,cell_volume,ENNReal.toReal_ofReal (by positivity : 0 ≤ 1/(m : ℝ))]
  rw [← Finset.mul_sum]
  ring

lemma integral_grid_pair (m : ℕ) [NeZero m] (f : I × I → ℝ) :
    ∫ t : I × I, f (grid m t.1,grid m t.2) =
      (∑ i : Fin m × Fin m, f (boundary m i.1.castSucc,boundary m i.2.castSucc))/(m : ℝ)^2 := by
  let C : Fin m × Fin m → Set (I × I) := fun i => cell m i.1 ×ˢ cell m i.2
  have hC i : MeasurableSet (C i) := (cell_measurable m i.1).prod (cell_measurable m i.2)
  let idx : I × I → Fin m × Fin m := fun t => (index m t.1,index m t.2)
  have hi t i : idx t = i ↔ t ∈ C i := by
    rcases i with ⟨i,j⟩
    simp only [idx,C,Prod.mk.injEq,index_eq,mem_prod]
  change ∫ t, (fun i : Fin m × Fin m => f (boundary m i.1.castSucc,boundary m i.2.castSucc)) (idx t) = _
  rw [integral_partition volume C hC idx hi (fun i => f (boundary m i.1.castSucc,boundary m i.2.castSucc))]
  have hv i : volume.real (C i) = 1/(m : ℝ)^2 := by
    rw [measureReal_def]
    change ((volume.prod volume) (cell m i.1 ×ˢ cell m i.2)).toReal = _
    rw [Measure.prod_prod,cell_volume,cell_volume,ENNReal.toReal_mul,
      ENNReal.toReal_ofReal (by positivity : 0 ≤ 1/(m : ℝ))]
    ring
  simp_rw [hv]
  rw [← Finset.mul_sum]
  ring

end PlanarHalving.UniformPartition

namespace PlanarHalving.UniformPartition
open MeasureTheory Set Filter BoundedContinuousFunction
open scoped unitInterval Topology

lemma grid_tendsto_seq (m : ℕ → ℕ) [∀ n, NeZero (m n)] (hm : Tendsto m atTop atTop) (t : I) :
    Tendsto (fun n => grid (m n) t) atTop (𝓝 t) := by
  apply tendsto_iff_dist_tendsto_zero.mpr
  apply squeeze_zero (fun _ => dist_nonneg) (fun n => dist_grid (m n) t)
  have hnat : Tendsto (fun n => (m n : ℝ)) atTop atTop := tendsto_natCast_atTop_atTop.comp hm
  simpa only [one_div, Function.comp_def] using tendsto_inv_atTop_zero.comp hnat

lemma riemann_tendsto (m : ℕ → ℕ) [∀ n, NeZero (m n)] (hm : Tendsto m atTop atTop)
    (f : BoundedContinuousFunction (I × I) ℝ) :
    Tendsto (fun n => (∑ i : Fin (m n) × Fin (m n),
      f (boundary (m n) i.1.castSucc,boundary (m n) i.2.castSucc))/(m n : ℝ)^2)
      atTop (𝓝 (∫ t : I × I, f t)) := by
  simp_rw [← integral_grid_pair]
  apply tendsto_integral_of_dominated_convergence (fun _ : I × I => ‖f‖)
  · intro n
    exact (f.continuous.measurable.comp
      (((grid_measurable (m n)).comp measurable_fst).prodMk
        ((grid_measurable (m n)).comp measurable_snd))).aestronglyMeasurable
  · exact integrable_const _
  · intro n
    exact Filter.Eventually.of_forall (fun _ => f.norm_coe_le_norm _)
  · exact Filter.Eventually.of_forall (fun t => (f.continuous.tendsto t).comp
      ((grid_tendsto_seq m hm t.1).prodMk_nhds (grid_tendsto_seq m hm t.2)))

end PlanarHalving.UniformPartition

namespace PlanarHalving.Limits
open MeasureTheory Set Filter BoundedContinuousFunction
open scoped Topology

lemma measure_le_of_test {X : Type*} [MetricSpace X] [CompactSpace X]
    [MeasurableSpace X] [BorelSpace X] (μ ν : FiniteMeasure X)
    (h : ∀ f : BoundedContinuousFunction X ℝ, (∀ x, 0 ≤ f x) → ∫ x, f x ∂(μ : Measure X) ≤ ∫ x, f x ∂(ν : Measure X)) :
    (μ : Measure X) ≤ (ν : Measure X) := by
  have hn (f : BoundedContinuousFunction X NNReal) : ∫⁻ x, f x ∂(μ : Measure X) ≤ ∫⁻ x, f x ∂(ν : Measure X) := by
    let g : BoundedContinuousFunction X ℝ := ⟨⟨fun x => (f x : ℝ), continuous_subtype_val.comp f.continuous⟩,f.map_bounded'⟩
    apply (ENNReal.toReal_le_toReal (f.lintegral_lt_top_of_nnreal _).ne
      (f.lintegral_lt_top_of_nnreal _).ne).mp
    rw [toReal_lintegral_coe_eq_integral f μ,toReal_lintegral_coe_eq_integral f ν]
    exact h g (fun x => NNReal.coe_nonneg _)
  have hclosed (F : Set X) (hF : IsClosed F) : (μ : Measure X) F ≤ (ν : Measure X) F := by
    exact le_of_tendsto_of_tendsto (HasOuterApproxClosed.tendsto_lintegral_apprSeq hF (μ : Measure X))
      (HasOuterApproxClosed.tendsto_lintegral_apprSeq hF (ν : Measure X)) (Filter.Eventually.of_forall (fun n => hn (hF.apprSeq n)))
  apply Measure.le_iff.mpr
  intro F hF
  rw [hF.measure_eq_iSup_isCompact (μ : Measure X)]
  exact iSup_le (fun K => iSup_le (fun hKF => iSup_le (fun hK =>
    (hclosed K hK.isClosed).trans (measure_mono hKF))))

end PlanarHalving.Limits

namespace PlanarHalving.Limits
open MeasureTheory Set Filter
open scoped Topology unitInterval NNReal ENNReal

noncomputable def weightedAtoms {X : Type*} [MeasurableSpace X] {α : Type*} [Fintype α]
    (w : ℝ≥0) (x : α → X) : FiniteMeasure X :=
  ⟨w • (∑ i, Measure.dirac (x i) : Measure X), inferInstance⟩

lemma integral_weightedAtoms {X : Type*} [MeasurableSpace X] [MeasurableSingletonClass X]
    {α : Type*} [Fintype α] (w : ℝ≥0) (x : α → X) (f : X → ℝ) :
    ∫ t, f t ∂(weightedAtoms w x : Measure X) = (w : ℝ) * ∑ i, f (x i) := by
  classical
  change ∫ t, f t ∂((w : ℝ≥0∞) • ∑ i, Measure.dirac (x i)) = _
  rw [integral_smul_measure,integral_finsetSum_measure]
  · simp only [integral_dirac,ENNReal.coe_toReal,smul_eq_mul]
  · intro i _
    exact integrable_dirac (by simp)

lemma mass_weightedAtoms {X : Type*} [MeasurableSpace X] {α : Type*} [Fintype α]
    (w : ℝ≥0) (x : α → X) :
    (weightedAtoms w x).mass = w * Fintype.card α := by
  classical
  simp [weightedAtoms,FiniteMeasure.mass,FiniteMeasure.mk_apply,Measure.smul_apply,
    Measure.finsetSum_apply]

end PlanarHalving.Limits

namespace PlanarHalving.UniformPartition
open MeasureTheory Set Filter PlanarHalving.Limits
open scoped Topology unitInterval NNReal ENNReal

noncomputable def gridPoint (m : ℕ) [NeZero m] (i : Fin m × Fin m) : I × I :=
  (boundary m i.1.castSucc,boundary m i.2.castSucc)

lemma grid_sum_le {m c : ℕ} [NeZero m] (slots : Fin c → Fin m × Fin m)
    (hs : Function.Injective slots) (f : I × I → ℝ) (hf : ∀ t, 0 ≤ f t) :
    (∑ i, f (gridPoint m (slots i))) ≤ ∑ j, f (gridPoint m j) := by
  classical
  rw [← Finset.sum_image (f := fun j => f (gridPoint m j)) hs.injOn]
  exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun i _ _ => hf _)

lemma normalized_perturbed_sum_le {m c : ℕ} [NeZero m]
    (slots : Fin c → Fin m × Fin m) (hs : Function.Injective slots)
    (x : Fin c → I × I) (f : I × I → ℝ) (hf : ∀ t, 0 ≤ f t)
    {ε : ℝ} (hε : 0 ≤ ε) (hclose : ∀ i, f (x i) ≤ f (gridPoint m (slots i)) + ε) :
    (∑ i, f (x i))/(m : ℝ)^2 ≤
      (∑ j : Fin m × Fin m, f (gridPoint m j))/(m : ℝ)^2 + ε := by
  have hm : 0 < (m : ℝ) := by exact_mod_cast NeZero.pos m
  have hc : (c : ℝ) ≤ (m : ℝ)^2 := by
    have h := Fintype.card_le_of_injective slots hs
    simp only [Fintype.card_fin,Fintype.card_prod] at h
    simpa only [pow_two] using (show (c : ℝ) ≤ (m : ℝ)*(m : ℝ) by exact_mod_cast h)
  have hsum : (∑ i, f (x i)) ≤ (∑ j : Fin m × Fin m, f (gridPoint m j)) + (c : ℝ)*ε := by
    calc
      _ ≤ ∑ i, (f (gridPoint m (slots i)) + ε) := Finset.sum_le_sum (fun i _ => hclose i)
      _ = (∑ i, f (gridPoint m (slots i))) + (c : ℝ)*ε := by simp [Finset.sum_add_distrib]
      _ ≤ _ := add_le_add (grid_sum_le slots hs f hf) le_rfl
  have hεc : (c : ℝ)*ε ≤ (m : ℝ)^2*ε := mul_le_mul_of_nonneg_right hc hε
  apply (div_le_iff₀ (sq_pos_of_pos hm)).mpr
  nlinarith [div_mul_cancel₀ (∑ j : Fin m × Fin m, f (gridPoint m j)) (ne_of_gt (sq_pos_of_pos hm))]

lemma perturbed_grid_limit_le_volume (m c : ℕ → ℕ) [∀ n, NeZero (m n)]
    (hm : Tendsto m atTop atTop) (x : ∀ n, Fin (c n) → I × I)
    (slots : ∀ n, Fin (c n) → Fin (m n) × Fin (m n))
    (hs : ∀ n, Function.Injective (slots n))
    (d : ℕ → ℝ) (hd : Tendsto d atTop (𝓝 0))
    (hclose : ∀ n i, dist (x n i) (gridPoint (m n) (slots n i)) ≤ d n)
    (μ : FiniteMeasure (I × I))
    (hμ : Tendsto (fun n => weightedAtoms ((m n : ℝ≥0)^2)⁻¹ (x n)) atTop (𝓝 μ)) :
    (μ : Measure (I × I)) ≤ volume := by
  let ν : FiniteMeasure (I × I) := ⟨volume,inferInstance⟩
  apply measure_le_of_test μ ν
  intro f hf
  apply le_of_forall_pos_le_add
  intro ε hε
  obtain ⟨δ,hδ,hfδ⟩ := Metric.uniformContinuous_iff.mp
    (CompactSpace.uniformContinuous_of_continuous f.continuous) ε hε
  have hdδ : ∀ᶠ n in atTop, d n < δ := (tendsto_order.mp hd).2 δ hδ
  have hineq : ∀ᶠ n in atTop,
      ∫ t, f t ∂(weightedAtoms ((m n : ℝ≥0)^2)⁻¹ (x n) : Measure (I × I)) ≤
        (∑ j : Fin (m n) × Fin (m n), f (gridPoint (m n) j))/(m n : ℝ)^2 + ε := by
    filter_upwards [hdδ] with n hn
    rw [integral_weightedAtoms]
    simp only [NNReal.coe_inv,NNReal.coe_pow,NNReal.coe_natCast]
    rw [← div_eq_inv_mul]
    apply normalized_perturbed_sum_le (slots n) (hs n) (x n) f hf hε.le
    intro i
    have h := hfδ ((hclose n i).trans_lt hn)
    rw [Real.dist_eq,abs_lt] at h
    linarith [h.2]
  have hlim := (FiniteMeasure.tendsto_iff_forall_integral_tendsto.mp hμ) f
  have hgrid := (riemann_tendsto m hm f).add_const ε
  apply le_of_tendsto_of_tendsto hlim hgrid
  filter_upwards [hineq] with n hn
  exact hn

end PlanarHalving.UniformPartition

end OAI