introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
22 kB
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