import OAI.Combinatorics.HalvingLines.Partition

namespace OAI

open Filter Topology

namespace PlanarHalving.TimeWindows
open Set
open scoped unitInterval Classical

abbrev Window := Σ d : ℕ, Fin (2^d)

noncomputable def carrier (J : Window) : Set I := UniformPartition.cell (2^J.1) J.2

lemma measurable_carrier (J : Window) : MeasurableSet (carrier J) :=
  UniformPartition.cell_measurable _ _

noncomputable def time (R : ℕ) [NeZero R] (b : Fin R) : I :=
  ⟨((b : ℝ)+1/2)/(R : ℝ),by
    have hR : (0 : ℝ)<R := Nat.cast_pos.mpr (NeZero.pos R)
    constructor
    · positivity
    · apply (div_le_one hR).mpr
      have hb : (b : ℝ)+1 ≤ R := by exact_mod_cast b.isLt
      linarith⟩

lemma time_lt_one (R : ℕ) [NeZero R] (b : Fin R) : (time R b : ℝ)<1 := by
  apply (div_lt_one (Nat.cast_pos.mpr (NeZero.pos R))).mpr
  have hb : (b : ℝ)+1 ≤ R := by exact_mod_cast b.isLt
  linarith

lemma time_strictMono (R : ℕ) [NeZero R] : StrictMono (time R) := by
  intro b c hbc
  change ((b : ℝ)+1/2)/(R : ℝ)<((c : ℝ)+1/2)/(R : ℝ)
  have hh : (b : ℝ)<(c : ℝ) := by exact_mod_cast hbc
  exact div_lt_div_of_pos_right (by linarith only [hh])
    (Nat.cast_pos.mpr (NeZero.pos R))

noncomputable def cut {α : Type*} [LinearOrder α] {R : ℕ} (t : Fin R → α) (x : α) : ℕ :=
  (Finset.univ.filter fun b => t b<x).card

lemma cut_le {α : Type*} [LinearOrder α] {R : ℕ} (t : Fin R → α) (x : α) : cut t x ≤ R := by
  exact (Finset.card_le_card (Finset.filter_subset _ _)).trans_eq (by simp)

lemma cut_mono {α : Type*} [LinearOrder α] {R : ℕ} (t : Fin R → α) : Monotone (cut t) := by
  intro x y hxy
  apply Finset.card_le_card
  intro b hb
  exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,((Finset.mem_filter.mp hb).2).trans_le hxy⟩

lemma lt_cut_iff {α : Type*} [LinearOrder α] {R : ℕ} {t : Fin R → α}
    (ht : StrictMono t) (b : Fin R) (x : α) : b.val < cut t x ↔ t b < x := by
  constructor
  · intro h
    by_contra hbx
    have hsub : (Finset.univ.filter fun c => t c<x) ⊆ Finset.Iio b := by
      intro c hc
      apply Finset.mem_Iio.mpr
      apply ht.lt_iff_lt.mp
      exact ((Finset.mem_filter.mp hc).2).trans_le (le_of_not_gt hbx)
    have hh := Finset.card_le_card hsub
    rw [Fin.card_Iio] at hh
    exact (not_lt_of_ge hh) h
  · intro hb
    have hsub : Finset.Iic b ⊆ (Finset.univ.filter fun c => t c<x) := by
      intro c hc
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(ht.monotone (Finset.mem_Iic.mp hc)).trans_lt hb⟩
    have hh := Finset.card_le_card hsub
    rw [Fin.card_Iic] at hh
    exact hh

noncomputable def start (R : ℕ) [NeZero R] (J : Window) : ℕ :=
  cut (time R) (UniformPartition.boundary (2^J.1) J.2.castSucc)
noncomputable def stop (R : ℕ) [NeZero R] (J : Window) : ℕ :=
  cut (time R) (UniformPartition.boundary (2^J.1) J.2.succ)

lemma start_le_stop (R : ℕ) [NeZero R] (J : Window) : start R J ≤ stop R J := by
  apply cut_mono
  change (J.2 : ℝ)/(2^J.1 : ℕ) ≤ ((J.2.val+1 : ℕ) : ℝ)/(2^J.1 : ℕ)
  apply div_le_div_of_nonneg_right
  · exact_mod_cast Nat.le_succ J.2.val
  · positivity

lemma stop_le (R : ℕ) [NeZero R] (J : Window) : stop R J ≤ R := cut_le _ _

lemma mem_carrier_iff (R : ℕ) [NeZero R] (J : Window) (b : Fin R) :
    time R b ∈ carrier J ↔ start R J ≤ b.val ∧ b.val < stop R J := by
  have hlo := lt_cut_iff (time_strictMono R) b (UniformPartition.boundary (2^J.1) J.2.castSucc)
  have hhi := lt_cut_iff (time_strictMono R) b (UniformPartition.boundary (2^J.1) J.2.succ)
  have hl : UniformPartition.boundary (2^J.1) J.2.castSucc ≤ time R b ↔ start R J ≤ b.val := by
    simpa only [not_lt,start] using (not_congr hlo).symm
  change time R b ∈ UniformPartition.cell (2^J.1) J.2 ↔ _
  rw [UniformPartition.cell]
  split_ifs with hj
  · have hu : UniformPartition.boundary (2^J.1) J.2.succ = (1 : I) := by
      apply Subtype.ext
      change ((J.2.val+1 : ℕ) : ℝ)/(2^J.1 : ℕ)=1
      rw [hj,div_self (by positivity : ((2^J.1 : ℕ) : ℝ)≠0)]
    have hb : time R b < UniformPartition.boundary (2^J.1) J.2.succ := by
      rw [hu]; exact time_lt_one R b
    simp only [mem_Icc,hl,hb.le,and_true]
    exact (and_iff_left (hhi.mpr hb)).symm
  · exact and_congr hl hhi.symm

noncomputable def length (R : ℕ) [NeZero R] (J : Window) : ℕ := stop R J-start R J
lemma start_add_length (R : ℕ) [NeZero R] (J : Window) : start R J+length R J=stop R J :=
  Nat.add_sub_of_le (start_le_stop R J)

lemma length_card (R : ℕ) [NeZero R] (J : Window) :
    length R J = (Finset.univ.filter fun b : Fin R => time R b ∈ carrier J).card := by
  have he : (Finset.univ.filter fun b : Fin R => time R b ∈ carrier J) =
      (Finset.univ.filter fun b : Fin R => b.val < stop R J) \
        (Finset.univ.filter fun b : Fin R => b.val < start R J) := by
    ext b
    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_sdiff,not_lt,
      mem_carrier_iff,and_comm]
  rw [he,Finset.card_sdiff_of_subset]
  · have hcard (c : ℕ) (hc : c ≤ R) : (Finset.univ.filter fun b : Fin R => b.val<c).card=c := by
      by_cases h : c=R
      · subst c
        simp only [Fin.is_lt,Finset.filter_true,Finset.card_univ,Fintype.card_fin]
      · have hc' : c<R := lt_of_le_of_ne hc h
        convert Fin.card_Iio (⟨c,hc'⟩ : Fin R) using 1
        congr 1
        ext b
        simp [Fin.lt_def]
    rw [hcard _ (stop_le R J),hcard _ ((start_le_stop R J).trans (stop_le R J))]
    rfl
  · intro b hb
    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,((Finset.mem_filter.mp hb).2).trans_le (start_le_stop R J)⟩

end PlanarHalving.TimeWindows

namespace PlanarHalving.Limits
open MeasureTheory Set
open scoped NNReal ENNReal Classical

lemma weightedAtoms_apply_finset {X : Type*} [MeasurableSpace X] [MeasurableSingletonClass X]
    {α : Type*} [Fintype α] (w : ℝ≥0) (x : α → X) {U : Set X} (hU : MeasurableSet U) :
    (weightedAtoms w x U : ℝ) = (w : ℝ) * ((Finset.univ.filter fun i => x i ∈ U).card : ℝ) := by
  classical
  have h := integral_weightedAtoms w x (U.indicator (fun _ => (1 : ℝ)))
  rw [integral_indicator_const 1 hU] at h
  simpa only [smul_eq_mul,mul_one,measureReal_def,← FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure,
    ENNReal.coe_toReal,Set.indicator_apply,Finset.sum_boole] using h

end PlanarHalving.Limits

namespace PlanarHalving.Batches
open MeasureTheory Set Limits
open scoped NNReal ENNReal Classical
variable {n R k a : ℕ} {P : Fin n → Point}

noncomputable def System.vertexMeasure (S : @System n R k a P)
    {X : Type*} [MeasurableSpace X] (z : Fin n → X) : FiniteMeasure X :=
  weightedAtoms (n : ℝ≥0)⁻¹ (fun v : ↥S.vertices => z v.val)

noncomputable def System.endpointMeasure (S : @System n R k a P)
    {X : Type*} [MeasurableSpace X] (z : Fin n → X) (E : ℝ≥0) : FiniteMeasure X :=
  weightedAtoms E⁻¹ (fun e : ↥S.edges => z e.val.1)

lemma System.vertexMeasure_apply (S : @System n R k a P)
    {X : Type*} [MeasurableSpace X] [MeasurableSingletonClass X] (z : Fin n → X)
    {U : Set X} (hU : MeasurableSet U) :
    (S.vertexMeasure z U : ℝ) = ((S.vertices.filter fun v => z v ∈ U).card : ℝ)/(n : ℝ) := by
  classical
  rw [System.vertexMeasure,weightedAtoms_apply_finset _ _ hU]
  have he : (Finset.univ.filter fun v : ↥S.vertices => z v.val ∈ U).card =
      (S.vertices.filter fun v => z v ∈ U).card := by
    apply Finset.card_bij (fun v _ => v.val)
    · intro v hv
      exact Finset.mem_filter.mpr ⟨v.property,(Finset.mem_filter.mp hv).2⟩
    · intro v _ w _ h; exact Subtype.ext h
    · intro v hv
      exact ⟨⟨v,(Finset.mem_filter.mp hv).1⟩,by simpa using (Finset.mem_filter.mp hv).2,rfl⟩
  rw [he]
  simp only [NNReal.coe_inv,NNReal.coe_natCast,div_eq_inv_mul]

lemma System.endpointMeasure_apply (S : @System n R k a P)
    {X : Type*} [MeasurableSpace X] [MeasurableSingletonClass X] (z : Fin n → X)
    (E : ℝ≥0) {U : Set X} (hU : MeasurableSet U) :
    (S.endpointMeasure z E U : ℝ) = ((S.edges.filter fun e => z e.1 ∈ U).card : ℝ)/(E : ℝ) := by
  classical
  rw [System.endpointMeasure,weightedAtoms_apply_finset _ _ hU]
  have he : (Finset.univ.filter fun e : ↥S.edges => z e.val.1 ∈ U).card =
      (S.edges.filter fun e => z e.1 ∈ U).card := by
    apply Finset.card_bij (fun e _ => e.val)
    · intro e he
      exact Finset.mem_filter.mpr ⟨e.property,(Finset.mem_filter.mp he).2⟩
    · intro e _ f _ h; exact Subtype.ext h
    · intro e he
      exact ⟨⟨e,(Finset.mem_filter.mp he).1⟩,by simpa using (Finset.mem_filter.mp he).2,rfl⟩
  rw [he]
  simp only [NNReal.coe_inv,div_eq_inv_mul]

theorem System.atomic_cubed_bound (S : @System n R k a P) [NeZero n] [NeZero a]
    (hP : Generic P) {X : Type*} [MeasurableSpace X] [MeasurableSingletonClass X]
    (z : Fin n → X) {E : ℝ≥0} (hE : 0 < E) {U : Set X} (hU : MeasurableSet U) :
    (S.endpointMeasure z E U : ℝ)^3 ≤
      (4608 * (a : ℝ)^2 * n^4 / (E : ℝ)^3) *
        ((S.vertices.card : ℝ)/(n : ℝ))^3 * (S.vertexMeasure z U : ℝ) +
      13824 * (S.vertices.card : ℝ)^3 / (E : ℝ)^3 := by
  classical
  let F := S.vertices.filter fun v => z v ∈ U
  have hF : F ⊆ S.vertices := Finset.filter_subset _ _
  have hc := S.localized_crossing hP F hF
  have he : S.edges.filter (fun e => e.1 ∈ F) = S.edges.filter (fun e => z e.1 ∈ U) := by
    ext e
    simp only [Finset.mem_filter,F]
    exact ⟨fun h => ⟨h.1,h.2.2⟩,fun h => ⟨h.1,(S.edge_ends h.1).1,h.2⟩⟩
  rw [he] at hc
  rw [S.endpointMeasure_apply z E hU,S.vertexMeasure_apply z hU]
  have hn : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (NeZero.ne n)
  have hER : 0 < (E : ℝ) := hE
  have hc' := div_le_div_of_nonneg_right hc (le_of_lt (pow_pos hER 3))
  convert hc' using 1
  all_goals
    try dsimp only [F]
    try field_simp [hn,ne_of_gt hER]
    try ring
    try rfl

end PlanarHalving.Batches

namespace PlanarHalving.TimeWindows
open Set Filter
open scoped unitInterval Topology

lemma cut_time_error (R : ℕ) [NeZero R] (x : I) :
    |(cut (time R) x : ℝ)-(R : ℝ)*(x : ℝ)| ≤ 1 := by
  have hR : (0 : ℝ)<R := Nat.cast_pos.mpr (NeZero.pos R)
  have hc := cut_le (time R) x
  apply abs_le.mpr
  constructor
  · by_cases h : cut (time R) x=R
    · rw [h]
      have hx := mul_le_mul_of_nonneg_left x.property.2 hR.le
      linarith
    · have hc' : cut (time R) x<R := lt_of_le_of_ne hc h
      let b : Fin R := ⟨cut (time R) x,hc'⟩
      have hb : ¬ time R b<x := by
        rw [← lt_cut_iff (time_strictMono R)]
        exact Nat.lt_irrefl _
      have hx : (x : ℝ)≤((b : ℝ)+1/2)/(R : ℝ) := le_of_not_gt hb
      have hh := (le_div_iff₀ hR).mp hx
      change (x : ℝ)*(R : ℝ) ≤ (cut (time R) x : ℝ)+1/2 at hh
      nlinarith
  · by_cases h : cut (time R) x=0
    · rw [h,Nat.cast_zero,zero_sub]
      have hx := mul_nonneg hR.le x.property.1
      linarith
    · have hc0 : 0<cut (time R) x := Nat.pos_of_ne_zero h
      let b : Fin R := ⟨cut (time R) x-1,by omega⟩
      have hb : time R b<x := (lt_cut_iff (time_strictMono R) b x).mp (by dsimp [b]; omega)
      have hx : ((b : ℝ)+1/2)/(R : ℝ)<(x : ℝ) := hb
      have hh := (div_lt_iff₀ hR).mp hx
      have hv : (b : ℝ)+1=(cut (time R) x : ℝ) := by
        exact_mod_cast (show b.val+1=cut (time R) x by dsimp [b]; omega)
      nlinarith

lemma length_error (R : ℕ) [NeZero R] (J : Window) :
    |(length R J : ℝ)/(R : ℝ)-1/(2^J.1 : ℕ)| ≤ 2/(R : ℝ) := by
  have hlo := cut_time_error R (UniformPartition.boundary (2^J.1) J.2.castSucc)
  have hhi := cut_time_error R (UniformPartition.boundary (2^J.1) J.2.succ)
  have hn : (0 : ℝ)<R := Nat.cast_pos.mpr (NeZero.pos R)
  have he : (length R J : ℝ)=(stop R J : ℝ)-(start R J : ℝ) :=
    Nat.cast_sub (start_le_stop R J)
  have hbound : |(length R J : ℝ)-(R : ℝ)/(2^J.1 : ℕ)|≤2 := by
    rw [he]
    have hid : (stop R J : ℝ)-(start R J : ℝ)-(R : ℝ)/(2^J.1 : ℕ) =
        ((stop R J : ℝ)-(R : ℝ)*(UniformPartition.boundary (2^J.1) J.2.succ : ℝ)) -
        ((start R J : ℝ)-(R : ℝ)*(UniformPartition.boundary (2^J.1) J.2.castSucc : ℝ)) := by
      simp only [UniformPartition.boundary,Fin.val_succ,Fin.val_castSucc,Nat.cast_add,Nat.cast_one]
      ring
    rw [hid]
    exact (abs_sub _ _).trans (by simpa only [start,stop,one_add_one_eq_two] using add_le_add hhi hlo)
  have hid : (length R J : ℝ)/(R : ℝ)-1/(2^J.1 : ℕ)=
      ((length R J : ℝ)-(R : ℝ)/(2^J.1 : ℕ))/(R : ℝ) := by field_simp
  rw [hid,abs_div,abs_of_pos hn]
  exact div_le_div_of_nonneg_right hbound hn.le

lemma length_tendsto (R : ℕ → ℕ) [∀ n, NeZero (R n)] (hR : Tendsto R atTop atTop) (J : Window) :
    Tendsto (fun n => (length (R n) J : ℝ)/(R n : ℝ)) atTop (𝓝 (1/(2^J.1 : ℕ) : ℝ)) := by
  apply tendsto_iff_dist_tendsto_zero.mpr
  apply squeeze_zero (fun _ => dist_nonneg) (fun n => by simpa only [Real.dist_eq] using length_error (R n) J)
  have hn : Tendsto (fun n => (R n : ℝ)) atTop atTop := tendsto_natCast_atTop_atTop.comp hR
  simpa only [div_eq_mul_inv,Function.comp_def,mul_zero] using (tendsto_inv_atTop_zero.comp hn).const_mul 2

lemma eventually_length_pos (R : ℕ → ℕ) [∀ n, NeZero (R n)] (hR : Tendsto R atTop atTop) (J : Window) :
    ∀ᶠ n in atTop, 0<length (R n) J := by
  have ht := (tendsto_order.mp (length_tendsto R hR J)).1 (0 : ℝ) (by positivity)
  filter_upwards [ht] with n hn
  have hh := (div_pos_iff.mp hn)
  rcases hh with hh|hh
  · exact_mod_cast hh.1
  · exact False.elim (not_lt_of_ge (Nat.cast_nonneg (length (R n) J)) hh.1)

end PlanarHalving.TimeWindows

namespace PlanarHalving.Directions
open MeasureTheory Set Filter
open scoped Topology

lemma measure_zero_of_null_gaps (μ : Measure ℝ) [NullSingletonClass μ]
    (S : Set ℝ) (hb : Bornology.IsBounded S)
    (hgap : ∀ s ∈ S, ∀ t ∈ S, s<t → μ (Ioo s t)=0) : μ S=0 := by
  by_cases he : S.Nonempty
  · have hsub : S ⊆ μ.supportᶜ ∪ ({sInf S,sSup S} : Set ℝ) := by
      intro t ht
      by_cases ht0 : t=sInf S
      · exact Or.inr (by simp [ht0])
      by_cases ht1 : t=sSup S
      · exact Or.inr (by simp [ht1])
      apply Or.inl
      intro hts
      have hlo : sInf S<t := lt_of_le_of_ne (csInf_le hb.bddBelow ht) (Ne.symm ht0)
      have hhi : t<sSup S := lt_of_le_of_ne (le_csSup hb.bddAbove ht) ht1
      obtain ⟨a,ha,hat⟩ := exists_lt_of_csInf_lt he hlo
      obtain ⟨b,hb,htb⟩ := exists_lt_of_lt_csSup he hhi
      have hh := (Measure.mem_support_iff_forall t).mp hts (Ioo a b) (Ioo_mem_nhds hat htb)
      rw [hgap a ha b hb (hat.trans htb)] at hh
      exact lt_irrefl _ hh
    exact measure_mono_null hsub (measure_union_null Measure.measure_compl_support (((Set.finite_singleton _).insert _).measure_zero μ))
  · rw [Set.not_nonempty_iff_eq_empty.mp he,measure_empty]

lemma interval_has_rat_interior {S : Set ℝ} (hS : Convex ℝ S) (hn : ¬ S.Subsingleton) :
    ∃ q : ℚ, (q : ℝ) ∈ interior S := by
  obtain ⟨a,ha,b,hb,hab⟩ := Set.not_subsingleton_iff.mp hn
  wlog halt : a<b generalizing a b
  · exact this b hb a ha hab.symm (lt_of_le_of_ne (le_of_not_gt halt) hab.symm)
  obtain ⟨q,hqa,hqb⟩ := exists_rat_btwn halt
  refine ⟨q,?_⟩
  have hs : Ioo a b ⊆ S := fun _ hx => hS.ordConnected.out ha hb ⟨hx.1.le,hx.2.le⟩
  exact (isOpen_Ioo.subset_interior_iff.mpr hs) ⟨hqa,hqb⟩

lemma ae_subsingleton (μ : Measure ℝ) [NullSingletonClass μ]
    (K : Set ℝ) (hK : Bornology.IsBounded K) (D : ℝ → Set ℝ)
    (hc : ∀ t ∈ K, Convex ℝ (D t))
    (hd : ∀ s ∈ K, ∀ t ∈ K, s<t → 0<μ (Ioo s t) → Disjoint (D s) (D t)) :
    μ {t | t∈K ∧ ¬ (D t).Subsingleton}=0 := by
  let S (q : ℚ) : Set ℝ := {t | t∈K ∧ (q : ℝ)∈interior (D t)}
  have hz (q : ℚ) : μ (S q)=0 := by
    apply measure_zero_of_null_gaps μ (S q) (hK.subset (fun _ ht => ht.1))
    intro s hs t ht hst
    apply le_antisymm _ zero_le
    by_contra h
    have hp : 0<μ (Ioo s t) := lt_of_not_ge h
    exact Set.disjoint_left.mp (hd s hs.1 t ht.1 hst hp)
      (interior_subset hs.2) (interior_subset ht.2)
  apply measure_mono_null (t := ⋃ q : ℚ, S q)
  · intro t ht
    obtain ⟨q,hq⟩ := interval_has_rat_interior (hc t ht.1) ht.2
    exact mem_iUnion.mpr ⟨q,ht.1,hq⟩
  · exact measure_iUnion_null hz

theorem exists_three_singletons (μ : Measure ℝ) [NullSingletonClass μ]
    (K : Set ℝ) (hK : Bornology.IsBounded K) (hpos : 0<μ K) (D : ℝ → Set ℝ)
    (hne : ∀ t ∈ K, (D t).Nonempty) (hc : ∀ t ∈ K, Convex ℝ (D t))
    (hd : ∀ s ∈ K, ∀ t ∈ K, s<t → 0<μ (Ioo s t) → Disjoint (D s) (D t)) :
    ∃ t₁ t₂ t₃ d₁ d₂ d₃ : ℝ,
      t₁∈K ∧ t₂∈K ∧ t₃∈K ∧ t₁<t₂ ∧ t₂<t₃ ∧
      D t₁={d₁} ∧ D t₂={d₂} ∧ D t₃={d₃} ∧
      d₁≠d₂ ∧ d₂≠d₃ ∧ d₁≠d₃ := by
  let B : Set ℝ := {t | t∈K ∧ ¬ (D t).Subsingleton}
  let G := (K \ B) ∩ μ.support
  have hz : μ B=0 := ae_subsingleton μ K hK D hc hd
  have hg : 0<μ G := by
    rw [show G=(K \ B) ∩ μ.support from rfl,measure_inter_conull Measure.measure_compl_support,
      measure_sdiff_null hz]
    exact hpos
  have hi : G.Infinite := by
    by_contra h
    have hh := (Set.not_infinite.mp h).measure_zero μ
    exact (ne_of_gt hg) hh
  obtain ⟨F,hFG,hF⟩ := hi.exists_subset_card_eq 5
  let t : Fin 5 → ℝ := F.orderEmbOfFin hF
  have ht : StrictMono t := (F.orderEmbOfFin hF).strictMono
  have hmem (i : Fin 5) : t i∈G := hFG (F.orderIsoOfFin hF i).property
  have hsub (i : Fin 5) : (D (t i)).Subsingleton := by
    by_contra hn
    exact (hmem i).1.2 ⟨(hmem i).1.1,hn⟩
  obtain ⟨d₁,hd₁⟩ := hne (t 0) (hmem 0).1.1
  obtain ⟨d₂,hd₂⟩ := hne (t 2) (hmem 2).1.1
  obtain ⟨d₃,hd₃⟩ := hne (t 4) (hmem 4).1.1
  have h02 : 0<μ (Ioo (t 0) (t 2)) :=
    (Measure.mem_support_iff_forall _).mp (hmem 1).2 _ (Ioo_mem_nhds (ht (by decide)) (ht (by decide)))
  have h24 : 0<μ (Ioo (t 2) (t 4)) :=
    (Measure.mem_support_iff_forall _).mp (hmem 3).2 _ (Ioo_mem_nhds (ht (by decide)) (ht (by decide)))
  have h04 : 0<μ (Ioo (t 0) (t 4)) := h02.trans_le (measure_mono (Ioo_subset_Ioo_right (ht (by decide)).le))
  refine ⟨t 0,t 2,t 4,d₁,d₂,d₃,(hmem 0).1.1,(hmem 2).1.1,(hmem 4).1.1,
    ht (by decide),ht (by decide),(hsub 0).eq_singleton_of_mem hd₁,
    (hsub 2).eq_singleton_of_mem hd₂,(hsub 4).eq_singleton_of_mem hd₃,?_,?_,?_⟩
  · intro h
    exact Set.disjoint_left.mp (hd _ (hmem 0).1.1 _ (hmem 2).1.1 (ht (by decide)) h02) hd₁ (h.symm ▸ hd₂)
  · intro h
    exact Set.disjoint_left.mp (hd _ (hmem 2).1.1 _ (hmem 4).1.1 (ht (by decide)) h24) hd₂ (h.symm ▸ hd₃)
  · intro h
    exact Set.disjoint_left.mp (hd _ (hmem 0).1.1 _ (hmem 4).1.1 (ht (by decide)) h04) hd₁ (h.symm ▸ hd₃)

end PlanarHalving.Directions

namespace PlanarHalving.Batches
open Set TimeWindows
open scoped unitInterval
variable {n R k a : ℕ} {P : Fin n → Point}

noncomputable def System.timeWindow (S : @System n R k a P) [NeZero R] (J : Window) :
    @System n (length R J) k a P :=
  S.window (start R J) (length R J) (by rw [start_add_length]; exact stop_le R J)

lemma System.timeWindow_edges (S : @System n R k a P) [NeZero R] (J : Window) :
    (S.timeWindow J).edges ⊆ S.edges := S.window_edges _ _ _

noncomputable def System.edgeTime (S : @System n R k a P) [NeZero R] [NeZero a] (e : ↥S.edges) : I :=
  time R (S.trace e.property).batch

lemma System.timeWindow_mem (S : @System n R k a P) [NeZero R] [NeZero a]
    (J : Window) (e : ↥S.edges) : e.val ∈ (S.timeWindow J).edges ↔ S.edgeTime e ∈ carrier J := by
  classical
  rw [System.edgeTime,mem_carrier_iff]
  constructor
  · intro he
    obtain ⟨b,hl,hg⟩ := ((S.timeWindow J).mem_edges e.val).mp he
    have hb := S.batch_unique (b := ⟨start R J+b.val,by have := start_add_length R J; have := stop_le R J; omega⟩)
      ⟨hl,hg⟩ ⟨(S.trace e.property).loss,(S.trace e.property).gain⟩
    have heq := congrArg Fin.val hb
    have hbl := b.isLt
    have hs := start_add_length R J
    dsimp at heq
    omega
  · intro h
    let b : Fin (length R J) := ⟨(S.trace e.property).batch.val-start R J,by
      have := start_add_length R J
      omega⟩
    apply ((S.timeWindow J).mem_edges e.val).mpr
    refine ⟨b,?_,?_⟩
    all_goals
      have heq : (⟨start R J+b.val,by have := start_add_length R J; have := stop_le R J; omega⟩ : Fin R) =
          (S.trace e.property).batch := by
        apply Fin.ext
        dsimp [b]
        omega
    · change e.val.1 ∈ S.loss ⟨start R J+b.val,by have := start_add_length R J; have := stop_le R J; omega⟩
      rw [heq]
      exact (S.trace e.property).loss
    · change e.val.2 ∈ S.gain ⟨start R J+b.val,by have := start_add_length R J; have := stop_le R J; omega⟩
      rw [heq]
      exact (S.trace e.property).gain

lemma System.edgeTime_distribution (S : @System n R k a P) [NeZero R] [NeZero a]
    (b : Fin R) :
    (Finset.univ.filter fun e : ↥S.edges => (S.trace e.property).batch=b).card=a^2 := by
  classical
  have he : (Finset.univ.filter fun e : ↥S.edges => (S.trace e.property).batch=b).card =
      ((S.loss b).product (S.gain b)).card := by
    apply Finset.card_bij (fun e _ => e.val)
    · intro e he
      have hh := (Finset.mem_filter.mp he).2
      exact Finset.mem_product.mpr (hh ▸ ⟨(S.trace e.property).loss,(S.trace e.property).gain⟩)
    · intro e _ f _ h; exact Subtype.ext h
    · intro e he
      have hm : e∈S.edges := (S.mem_edges e).mpr ⟨b,Finset.mem_product.mp he⟩
      refine ⟨⟨e,hm⟩,Finset.mem_filter.mpr ⟨Finset.mem_univ _,?_⟩,rfl⟩
      exact S.batch_unique ⟨(S.trace hm).loss,(S.trace hm).gain⟩ (Finset.mem_product.mp he)
  rw [he]
  calc
    _ = (S.loss b).card * (S.gain b).card := Finset.card_product _ _
    _ = a^2 := by rw [S.card_loss,S.card_gain,pow_two]

end PlanarHalving.Batches

end OAI