| import OAI.Combinatorics.HalvingLines.Greedy |
|
|
| namespace OAI |
|
|
| open Filter Topology |
|
|
| namespace PlanarHalving.Sweep |
| open Set |
|
|
| lemma state_eq_insert_below {n k : ℕ} {P : Fin n → Point} (hP : GeneralPosition P) |
| {s : ℝ} {M : Finset (Fin n)} (hM : Separates P s M) (hcard : M.card=k) |
| {a b : Fin n} (hab : a≠b) (hx : (P a).1≠(P b).1) |
| (hR : Refines P (slope (P a) (P b)) s) |
| (hs : projection s (P a)<projection s (P b)) (hk : 0<k) |
| (hbelow : belowCount P a b=k-1) : M=insert a (belowSet P a b) := by |
| classical |
| apply states_unique hM (below_insert_separates hP hab hx hR hs) |
| have hna : a∉belowSet P a b := by simp only [mem_belowSet,lt_self_iff_false,not_false_eq_true] |
| rw [hcard,Finset.card_insert_of_notMem hna,card_belowSet,hbelow] |
| omega |
|
|
| lemma states_change_of_pair {n k : ℕ} {P : Fin n → Point} (hP : Generic P) (hk : k≤n) |
| (i : Fin (traversal (criticalSlopes P)).size) {a b : Fin n} (hab : a≠b) |
| (hc : (traversal (criticalSlopes P)).cut i.succ.castSucc=slope (P a) (P b)) |
| (hkpos : 0<k) (hbelow : belowCount P a b=k-1) : |
| (states P hP hk).marks i.castSucc≠(states P hP hk).marks i.succ := by |
| classical |
| let T := traversal (criticalSlopes P) |
| let S := states P hP hk |
| have aux (a b : Fin n) (hx : (P a).1<(P b).1) |
| (hc : T.cut i.succ.castSucc=slope (P a) (P b)) |
| (hb : belowCount P a b=k-1) : S.marks i.castSucc≠S.marks i.succ := by |
| have hbounds := T.cut_bounds i |
| rw [hc] at hbounds |
| have ho := projection_order_at_slope hx hbounds.1 hbounds.2 |
| have hR := (T.sample_refines hP i).1 |
| rw [hc] at hR |
| have hab' : a≠b := fun he => ne_of_lt hx (congrArg (fun x => (P x).1) he) |
| have he := state_eq_insert_below hP.1 (S.separates i.castSucc) (S.card_marks i.castSucc) |
| hab' hx.ne hR ho.1 hkpos hb |
| intro hsame |
| have ha : a∈S.marks i.succ := by rw [← hsame,he];exact Finset.mem_insert_self _ _ |
| have hb' : b∉S.marks i.succ := by |
| rw [← hsame,he,Finset.mem_insert] |
| simp only [mem_belowSet,tied_projection (P a) (P b) hx.ne,lt_self_iff_false,or_false] |
| exact hab'.symm |
| exact not_lt_of_gt ho.2 (S.separates i.succ a ha b hb') |
| rcases lt_or_gt_of_ne (hP.2.1 a b hab) with hx | hx |
| · exact aux a b hx hc hbelow |
| · apply aux b a hx |
| · simpa only [slope_symm (P b) (P a)] using hc |
| · simpa only [belowCount_symm (hP.2.1 a b hab)] using hbelow |
|
|
| noncomputable def switchPairs {n : ℕ} (P : Fin n → Point) (k : ℕ) : Finset (Fin n × Fin n) := |
| Finset.univ.filter (fun ij => ij.1 < ij.2 ∧ 0<k ∧ k<n ∧ belowCount P ij.1 ij.2=k-1) |
|
|
| lemma mem_switchPairs {n : ℕ} (P : Fin n → Point) (k : ℕ) (p : Fin n × Fin n) : |
| p∈switchPairs P k ↔ p.1<p.2 ∧ 0<k ∧ k<n ∧ belowCount P p.1 p.2=k-1 := by |
| classical |
| simp only [switchPairs,Finset.mem_filter,Finset.mem_univ,true_and] |
|
|
| noncomputable def States.changeSteps {n T k : ℕ} {P : Fin n → Point} (S : @States n T k P) : Finset (Fin T) := |
| Finset.univ.filter (fun i => S.marks i.castSucc≠S.marks i.succ) |
|
|
| lemma States.mem_changeSteps {n T k : ℕ} {P : Fin n → Point} (S : @States n T k P) (i : Fin T) : |
| i∈S.changeSteps ↔ S.marks i.castSucc≠S.marks i.succ := by |
| classical |
| simp only [States.changeSteps,Finset.mem_filter,Finset.mem_univ,true_and] |
|
|
| lemma switchCount_le_changes {n k : ℕ} {P : Fin n → Point} (hP : Generic P) (hk : k≤n) : |
| switchCount P k≤(states P hP hk).changeSteps.card := by |
| classical |
| let T := traversal (criticalSlopes P) |
| let S := states P hP hk |
| have hex (p : ↥(switchPairs P k)) : ∃ i : Fin T.size, i∈S.changeSteps ∧ |
| T.cut i.succ.castSucc=slope (P p.val.1) (P p.val.2) := by |
| have hp := (mem_switchPairs P k p.val).mp p.property |
| obtain ⟨i,hi⟩ := (T.critical _).mp (mem_criticalSlopes P hp.1.ne) |
| exact ⟨i,(S.mem_changeSteps i).mpr (states_change_of_pair hP hk i hp.1.ne hi hp.2.1 hp.2.2.2),hi⟩ |
| choose f hf hs using hex |
| let g : ↥(switchPairs P k) → ↥S.changeSteps := fun p => ⟨f p,hf p⟩ |
| have hg : Function.Injective g := by |
| intro p q h |
| have he : f p=f q := congrArg Subtype.val h |
| have heq := (hs p).symm.trans ((congrArg (fun j => T.cut j.succ.castSucc) he).trans (hs q)) |
| have hp := (mem_switchPairs P k p.val).mp p.property |
| have hq := (mem_switchPairs P k q.val).mp q.property |
| obtain ⟨h1,h2⟩ := hP.2.2.1 _ _ _ _ hp.1 hq.1 heq |
| exact Subtype.ext (Prod.ext h1 h2) |
| change (switchPairs P k).card≤S.changeSteps.card |
| simpa only [Fintype.card_coe] using Fintype.card_le_of_injective g hg |
|
|
| lemma local_change_event {n k : ℕ} {P : Fin n → Point} (hP : Generic P) |
| {s t c : ℝ} {M N : Finset (Fin n)} |
| (hM : Separates P s M) (hN : Separates P t N) (hcardM : M.card=k) (hcardN : N.card=k) |
| (hRs : Refines P c s) (hRt : Refines P c t) (hne : M≠N) : |
| ∃ p∈switchPairs P k, slope (P p.1) (P p.2)=c := by |
| classical |
| have hneM : (M\N).Nonempty := by |
| by_contra hh |
| have hsub : M⊆N := Finset.sdiff_eq_empty_iff_subset.mp (Finset.not_nonempty_iff_eq_empty.mp hh) |
| exact hne (Finset.eq_of_subset_of_card_le hsub (hcardN.trans hcardM.symm).le) |
| obtain ⟨a,ha⟩ := hneM |
| have hneN : (N\M).Nonempty := by |
| rw [← Finset.card_pos,← Finset.card_sdiff_comm (hcardM.trans hcardN.symm)] |
| exact Finset.card_pos.mpr ⟨a,ha⟩ |
| obtain ⟨b,hb⟩ := hneN |
| have haM := (Finset.mem_sdiff.mp ha).1 |
| have haN := (Finset.mem_sdiff.mp ha).2 |
| have hbN := (Finset.mem_sdiff.mp hb).1 |
| have hbM := (Finset.mem_sdiff.mp hb).2 |
| have hab : a≠b := fun he => hbM (he ▸ haM) |
| have hc : projection c (P a)=projection c (P b) := by |
| apply le_antisymm |
| · by_contra h |
| exact not_lt_of_gt (hM a haM b hbM) (hRs b a (lt_of_not_ge h)) |
| · by_contra h |
| exact not_lt_of_gt (hN b hbN a haN) (hRt a b (lt_of_not_ge h)) |
| have hsc : c=slope (P a) (P b) := (projection_eq_iff_slope (hP.2.1 a b hab)).mp hc |
| have hbelow : belowCount P a b=k-1 := by |
| rw [← card_belowSet,belowSet_eq_erase hP.1 hM haM hbM (hP.2.1 a b hab) (hsc ▸ hRs), |
| Finset.card_erase_of_mem haM,hcardM] |
| have hkpos : 0<k := hcardM ▸ Finset.card_pos.mpr ⟨a,haM⟩ |
| have hkn : k<n := by |
| have he : M⊂Finset.univ := Finset.ssubset_iff_subset_ne.mpr ⟨Finset.subset_univ _,by intro h;apply hbM;rw [h];exact Finset.mem_univ _⟩ |
| simpa only [hcardM,Finset.card_univ,Fintype.card_fin] using Finset.card_lt_card he |
| rcases lt_or_gt_of_ne hab with hab | hba |
| · exact ⟨(a,b),(mem_switchPairs P k _).mpr ⟨hab,hkpos,hkn,hbelow⟩,hsc.symm⟩ |
| · exact ⟨(b,a),(mem_switchPairs P k _).mpr ⟨hba,hkpos,hkn,by rw [belowCount_symm (hP.2.1 a b (ne_of_gt hba)),hbelow]⟩, |
| (slope_symm (P b) (P a)).trans hsc.symm⟩ |
|
|
| end PlanarHalving.Sweep |
|
|
| namespace PlanarHalving.Sweep |
| open Set |
|
|
| noncomputable def subsetIndex {n : ℕ} (A : Finset (Fin n)) : Fin A.card → Fin n := |
| fun i => (A.orderIsoOfFin rfl i : Fin n) |
|
|
| lemma subsetIndex_strictMono {n : ℕ} (A : Finset (Fin n)) : StrictMono (subsetIndex A) := |
| fun _ _ h => (A.orderIsoOfFin rfl).strictMono h |
|
|
| lemma subsetIndex_mem {n : ℕ} (A : Finset (Fin n)) (i : Fin A.card) : subsetIndex A i∈A := |
| (A.orderIsoOfFin rfl i).property |
|
|
| lemma subsetIndex_surj {n : ℕ} (A : Finset (Fin n)) {x : Fin n} (hx : x∈A) : |
| ∃ i, subsetIndex A i=x := by |
| exact ⟨(A.orderIsoOfFin rfl).symm ⟨x,hx⟩,congrArg Subtype.val ((A.orderIsoOfFin rfl).apply_symm_apply ⟨x,hx⟩)⟩ |
|
|
| noncomputable def subsetPoints {n : ℕ} (P : Fin n → Point) (A : Finset (Fin n)) : Fin A.card → Point := |
| P∘subsetIndex A |
|
|
| lemma subsetPoints_generic {n : ℕ} {P : Fin n → Point} (hP : Generic P) (A : Finset (Fin n)) : |
| Generic (subsetPoints P A) := hP.comp_strictMono (subsetIndex_strictMono A) |
|
|
| noncomputable def restrictMarks {n : ℕ} (A M : Finset (Fin n)) : Finset (Fin A.card) := |
| Finset.univ.filter (fun i => subsetIndex A i∈M) |
|
|
| lemma mem_restrictMarks {n : ℕ} (A M : Finset (Fin n)) (i : Fin A.card) : |
| i∈restrictMarks A M ↔ subsetIndex A i∈M := by |
| classical |
| simp only [restrictMarks,Finset.mem_filter,Finset.mem_univ,true_and] |
|
|
| lemma card_restrictMarks {n : ℕ} (A M : Finset (Fin n)) : |
| (restrictMarks A M).card=(M∩A).card := by |
| classical |
| have he : (restrictMarks A M).image (subsetIndex A)=M∩A := by |
| ext x |
| constructor |
| · intro hx |
| obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp hx |
| exact Finset.mem_inter.mpr ⟨(mem_restrictMarks A M i).mp hi,subsetIndex_mem A i⟩ |
| · intro hx |
| obtain ⟨i,rfl⟩ := subsetIndex_surj A (Finset.mem_inter.mp hx).2 |
| exact Finset.mem_image.mpr ⟨i,(mem_restrictMarks A M i).mpr (Finset.mem_inter.mp hx).1,rfl⟩ |
| rw [← he,Finset.card_image_of_injective _ (subsetIndex_strictMono A).injective] |
|
|
| lemma restrictMarks_separates {n : ℕ} {P : Fin n → Point} {s : ℝ} {M : Finset (Fin n)} |
| (hM : Separates P s M) (A : Finset (Fin n)) : |
| Separates (subsetPoints P A) s (restrictMarks A M) := by |
| intro i hi j hj |
| exact hM _ ((mem_restrictMarks A M i).mp hi) _ (fun h => hj ((mem_restrictMarks A M j).mpr h)) |
|
|
| lemma Refines.subset {n : ℕ} {P : Fin n → Point} {c s : ℝ} (hR : Refines P c s) |
| (A : Finset (Fin n)) : Refines (subsetPoints P A) c s := fun _ _ h => hR _ _ h |
|
|
| variable {n T k : ℕ} {P : Fin n → Point} |
|
|
| lemma States.restrict_activity_card (S : @States n T k P) |
| {u v : Fin (T+1)} (huv : u ≤ v) {i : Fin (T+1)} (hui : u ≤ i) (hiv : i ≤ v) : |
| (restrictMarks (S.intervalActivity u v huv) (S.marks i)).card= |
| ((S.marks u)∩S.intervalActivity u v huv).card := by |
| classical |
| let A := S.intervalActivity u v huv |
| have he : S.marks i\A=S.marks u\A := by |
| ext x |
| simp only [Finset.mem_sdiff] |
| by_cases hx : x∈A |
| · simp [hx] |
| · rw [S.outside_activity_constant huv hx hui hiv] |
| have h1 := Finset.card_inter_add_card_sdiff (S.marks i) A |
| have h2 := Finset.card_inter_add_card_sdiff (S.marks u) A |
| rw [S.card_marks] at h1 h2 |
| rw [he] at h1 |
| rw [card_restrictMarks] |
| change (S.marks i∩A).card=(S.marks u∩A).card |
| omega |
|
|
| lemma States.restrict_activity_change (S : @States n T k P) |
| {u v : Fin (T+1)} (huv : u ≤ v) {i j : Fin (T+1)} |
| (hui : u ≤ i) (hiv : i ≤ v) (huj : u ≤ j) (hjv : j ≤ v) |
| (hne : S.marks i≠S.marks j) : |
| restrictMarks (S.intervalActivity u v huv) (S.marks i)≠ |
| restrictMarks (S.intervalActivity u v huv) (S.marks j) := by |
| classical |
| intro he |
| apply hne |
| ext x |
| by_cases hx : x∈S.intervalActivity u v huv |
| · obtain ⟨a,rfl⟩ := subsetIndex_surj _ hx |
| exact (mem_restrictMarks _ _ a).symm.trans ((congrArg (fun M => a∈M) he).to_iff.trans (mem_restrictMarks _ _ a)) |
| · exact (S.outside_activity_constant huv hx hui hiv).trans (S.outside_activity_constant huv hx huj hjv).symm |
|
|
| noncomputable def States.blockSteps (S : @States n T k P) (u v : Fin (T+1)) : Finset (Fin T) := |
| S.changeSteps.filter (fun i => u ≤ i.castSucc ∧ i.succ ≤ v) |
|
|
| lemma States.mem_blockSteps (S : @States n T k P) (u v : Fin (T+1)) (i : Fin T) : |
| i∈S.blockSteps u v ↔ i∈S.changeSteps ∧ u ≤ i.castSucc ∧ i.succ ≤ v := by |
| classical |
| simp only [States.blockSteps,Finset.mem_filter] |
|
|
| lemma card_le_of_injective_labels {α β γ : Type*} [DecidableEq α] [DecidableEq β] |
| (A : Finset α) (B : Finset β) (f : α → γ) (g : β → γ) |
| (hf : Set.InjOn f A) (hex : ∀ a∈A, ∃ b∈B, g b=f a) : A.card≤B.card := by |
| classical |
| choose h hh he using (fun a : ↥A => hex a a.property) |
| let F : ↥A → ↥B := fun a => ⟨h a,hh a⟩ |
| have hF : Function.Injective F := by |
| intro a b hab |
| have hh' : h a=h b := congrArg Subtype.val hab |
| exact Subtype.ext (hf a.property b.property ((he a).symm.trans ((congrArg g hh').trans (he b)))) |
| simpa only [Fintype.card_coe] using Fintype.card_le_of_injective F hF |
|
|
| lemma block_step_event {n k : ℕ} {P : Fin n → Point} (hP : Generic P) (hk : k≤n) |
| {u v : Fin ((traversal (criticalSlopes P)).size+1)} (huv : u ≤ v) |
| {i : Fin (traversal (criticalSlopes P)).size} (hi : i∈(states P hP hk).blockSteps u v) : |
| let A := (states P hP hk).intervalActivity u v huv |
| let r := ((states P hP hk).marks u∩A).card |
| ∃ p∈switchPairs (subsetPoints P A) r, |
| slope (subsetPoints P A p.1) (subsetPoints P A p.2)=(traversal (criticalSlopes P)).cut i.succ.castSucc := by |
| let T := traversal (criticalSlopes P) |
| let S := states P hP hk |
| let A := S.intervalActivity u v huv |
| have hi' := (S.mem_blockSteps u v i).mp hi |
| have hs := T.sample_refines hP i |
| exact local_change_event (subsetPoints_generic hP A) |
| (restrictMarks_separates (S.separates i.castSucc) A) |
| (restrictMarks_separates (S.separates i.succ) A) |
| (S.restrict_activity_card huv hi'.2.1 ((Fin.castSucc_le_succ _).trans hi'.2.2)) |
| (S.restrict_activity_card huv (hi'.2.1.trans (Fin.castSucc_le_succ _)) hi'.2.2) |
| (hs.1.subset A) (hs.2.subset A) |
| (S.restrict_activity_change huv hi'.2.1 ((Fin.castSucc_le_succ _).trans hi'.2.2) |
| (hi'.2.1.trans (Fin.castSucc_le_succ _)) hi'.2.2 ((S.mem_changeSteps _).mp hi'.1)) |
|
|
| lemma block_count_le {n k : ℕ} {P : Fin n → Point} (hP : Generic P) (hk : k≤n) |
| {u v : Fin ((traversal (criticalSlopes P)).size+1)} (huv : u ≤ v) : |
| ∃ r : ℕ, r≤((states P hP hk).intervalActivity u v huv).card ∧ |
| ((states P hP hk).blockSteps u v).card≤ |
| switchCount (subsetPoints P ((states P hP hk).intervalActivity u v huv)) r := by |
| classical |
| let T := traversal (criticalSlopes P) |
| let S := states P hP hk |
| let A := S.intervalActivity u v huv |
| let r := (S.marks u∩A).card |
| refine ⟨r,(Finset.card_le_card (Finset.inter_subset_right)),?_⟩ |
| change (S.blockSteps u v).card≤(switchPairs (subsetPoints P A) r).card |
| apply card_le_of_injective_labels _ _ (fun i => T.cut i.succ.castSucc) |
| (fun p => slope (subsetPoints P A p.1) (subsetPoints P A p.2)) |
| · intro i _ j _ he |
| exact Fin.succ_inj.mp (Fin.castSucc_inj.mp (T.increasing.injective he)) |
| · exact fun i hi => block_step_event hP hk huv hi |
|
|
| end PlanarHalving.Sweep |
|
|
| namespace PlanarHalving.Sweep |
| open Set |
| variable {n T k : ℕ} {P : Fin n → Point} |
|
|
| lemma States.blockSteps_self (S : @States n T k P) (u : Fin (T+1)) : S.blockSteps u u=∅ := by |
| classical |
| apply Finset.eq_empty_iff_forall_notMem.mpr |
| intro i hi |
| have h := (S.mem_blockSteps u u i).mp hi |
| exact not_lt_of_ge (h.2.2.trans h.2.1) (Fin.castSucc_lt_succ (i:=i)) |
|
|
| lemma States.blockSteps_all (S : @States n T k P) : S.blockSteps 0 (Fin.last T)=S.changeSteps := by |
| classical |
| ext i |
| simp only [S.mem_blockSteps,Fin.zero_le,Fin.le_last,and_true] |
|
|
| lemma States.blockSteps_card_add (S : @States n T k P) {u v w : Fin (T+1)} |
| (huv : u ≤ v) (hvw : v ≤ w) : |
| (S.blockSteps u v).card+(S.blockSteps v w).card=(S.blockSteps u w).card := by |
| classical |
| have hdis : Disjoint (S.blockSteps u v) (S.blockSteps v w) := by |
| apply Finset.disjoint_left.mpr |
| intro i hi hj |
| have hi' := (S.mem_blockSteps u v i).mp hi |
| have hj' := (S.mem_blockSteps v w i).mp hj |
| exact not_lt_of_ge (hi'.2.2.trans hj'.2.1) (Fin.castSucc_lt_succ (i:=i)) |
| have he : S.blockSteps u v ∪ S.blockSteps v w=S.blockSteps u w := by |
| ext i |
| simp only [Finset.mem_union,S.mem_blockSteps] |
| constructor |
| · rintro (⟨hi,hu,hv⟩ | ⟨hi,hv,hw⟩) |
| · exact ⟨hi,hu,hv.trans hvw⟩ |
| · exact ⟨hi,huv.trans hv,hw⟩ |
| · rintro ⟨hi,hu,hw⟩ |
| by_cases h : i.succ ≤ v |
| · exact Or.inl ⟨hi,hu,h⟩ |
| · exact Or.inr ⟨hi,(by change v.val ≤ i.val;change ¬i.val+1 ≤ v.val at h;omega),hw⟩ |
| rw [← he,Finset.card_union_of_disjoint hdis] |
|
|
| lemma States.sum_blockSteps (S : @States n T k P) (m : ℕ) |
| (f : Fin (m+1) → Fin (T+1)) (hf : Monotone f) : |
| ∑ j : Fin m, (S.blockSteps (f j.castSucc) (f j.succ)).card= |
| (S.blockSteps (f 0) (f (Fin.last m))).card := by |
| induction m with |
| | zero => simp [S.blockSteps_self] |
| | succ m ih => |
| rw [Fin.sum_univ_castSucc] |
| have hh := ih (fun j : Fin (m+1) => f j.castSucc) (fun _ _ h => hf (Fin.castSucc_le_castSucc_iff.mpr h)) |
| simp only [Fin.castSucc_succ] at hh |
| rw [hh] |
| exact S.blockSteps_card_add (hf (Fin.zero_le _)) (hf (Fin.castSucc_le_succ _)) |
|
|
| noncomputable def States.ActivityGreedy.fullIndex (S : @States n T k P) {s : Fin (T+1)} {b : ℕ} |
| (G : S.ActivityGreedy s b) : Fin (G.count+2) → Fin (T+1) := |
| Fin.snoc G.index (Fin.last T) |
|
|
| lemma States.ActivityGreedy.fullIndex_mono (S : @States n T k P) {s : Fin (T+1)} {b : ℕ} |
| (G : S.ActivityGreedy s b) : Monotone (G.fullIndex S) := by |
| intro i j hij |
| revert hij |
| refine Fin.lastCases ?_ (fun j => ?_) j |
| · intro _ |
| simpa only [States.ActivityGreedy.fullIndex,Fin.snoc_last] using (Fin.le_last (G.fullIndex S i)) |
| · refine Fin.lastCases ?_ (fun i => ?_) i |
| · intro hij |
| exact False.elim (not_le_of_gt (Fin.castSucc_lt_last j) hij) |
| · intro hij |
| simpa only [States.ActivityGreedy.fullIndex,Fin.snoc_castSucc] using G.increasing.monotone (Fin.castSucc_le_castSucc_iff.mp hij) |
|
|
| lemma States.ActivityGreedy.fullIndex_first (S : @States n T k P) {s : Fin (T+1)} {b : ℕ} |
| (G : S.ActivityGreedy s b) : G.fullIndex S 0=s := by |
| simpa only [States.ActivityGreedy.fullIndex,←Fin.castSucc_zero,Fin.snoc_castSucc] using G.first |
|
|
| lemma States.ActivityGreedy.fullIndex_last (S : @States n T k P) {s : Fin (T+1)} {b : ℕ} |
| (G : S.ActivityGreedy s b) : G.fullIndex S (Fin.last (G.count+1))=Fin.last T := Fin.snoc_last _ _ |
|
|
| lemma States.ActivityGreedy.fullIndex_activity (S : @States n T k P) {s : Fin (T+1)} {b : ℕ} |
| (G : S.ActivityGreedy s b) (j : Fin (G.count+1)) : |
| S.activitySize (G.fullIndex S j.castSucc) (G.fullIndex S j.succ)≤b+1 := by |
| refine Fin.lastCases ?_ (fun i => ?_) j |
| · simpa only [States.ActivityGreedy.fullIndex,Fin.snoc_castSucc,Fin.succ_last,Fin.snoc_last] using G.tail.le.trans (Nat.le_succ b) |
| · simpa only [States.ActivityGreedy.fullIndex,←Fin.castSucc_succ,Fin.snoc_castSucc] using G.upper i |
|
|
| lemma activity_decomposition {n k : ℕ} {P : Fin n → Point} (hP : Generic P) (hk : k≤n) |
| {b : ℕ} (hb : 0<b) : |
| ∃ (A : Fin (((states P hP hk).activityGreedy 0 b hb).count+1) → Finset (Fin n)) |
| (r : Fin (((states P hP hk).activityGreedy 0 b hb).count+1) → ℕ), |
| (∀ j, (A j).card≤b+1) ∧ (∀ j, r j≤(A j).card) ∧ |
| switchCount P k ≤ ∑ j, switchCount (subsetPoints P (A j)) (r j) := by |
| classical |
| let S := states P hP hk |
| let G := S.activityGreedy 0 b hb |
| let f := G.fullIndex S |
| have hf : Monotone f := G.fullIndex_mono S |
| let A (j : Fin (G.count+1)) := S.intervalActivity (f j.castSucc) (f j.succ) (hf (Fin.castSucc_le_succ j)) |
| have hex (j : Fin (G.count+1)) : ∃ r : ℕ, r≤(A j).card ∧ |
| (S.blockSteps (f j.castSucc) (f j.succ)).card ≤ switchCount (subsetPoints P (A j)) r := |
| block_count_le hP hk (hf (Fin.castSucc_le_succ j)) |
| choose r hr hcount using hex |
| refine ⟨A,r,?_,hr,?_⟩ |
| · intro j |
| rw [← S.activitySize_eq] |
| exact G.fullIndex_activity S j |
| · have hsum := S.sum_blockSteps (G.count+1) f hf |
| dsimp only [f] at hsum |
| rw [G.fullIndex_first S,G.fullIndex_last S,S.blockSteps_all] at hsum |
| calc |
| switchCount P k ≤ S.changeSteps.card := switchCount_le_changes hP hk |
| _ = ∑ j : Fin (G.count+1), (S.blockSteps (f j.castSucc) (f j.succ)).card := hsum.symm |
| _ ≤ _ := Finset.sum_le_sum (fun j _ => hcount j) |
|
|
| end PlanarHalving.Sweep |
|
|
| namespace PlanarHalving.Sweep |
|
|
| lemma division_scale {n q : ℕ} (hq : 4≤q) (hn : 4*q≤n) : |
| let b := n/q-1 |
| 0<b ∧ b+1=n/q ∧ (b+1:ℝ)≤(n:ℝ)/q ∧ n≤2*q*b ∧ (b+1)<n := by |
| have hq0 : 0<q := by omega |
| have hd : 4≤n/q := (Nat.le_div_iff_mul_le hq0).mpr hn |
| have hbd : n/q-1+1=n/q := by omega |
| refine ⟨by omega,hbd,?_,?_,?_⟩ |
| · have he : ((n/q-1:ℕ):ℝ)+1=(n/q:ℕ) := by exact_mod_cast hbd |
| rw [he] |
| exact (le_div_iff₀ (by exact_mod_cast hq0)).mpr (by exact_mod_cast Nat.div_mul_le_self n q) |
| · have he := Nat.mod_add_div n q |
| have hm := Nat.mod_lt n hq0 |
| nlinarith |
| · rw [hbd] |
| exact Nat.div_lt_self (by omega) (by omega) |
|
|
| lemma greedy_count_bound {q : ℕ} (hq : 4≤q) {m n b : ℕ} (hb : 0<b) |
| (hn : n≤2*q*b) (hp : (m:ℝ)^3*(b:ℝ)^4≤(n:ℝ)^4/1024) : |
| (m:ℝ)+1≤(q:ℝ)^((4:ℝ)/3)/2 := by |
| have hq0 : (0:ℝ)<q := by exact_mod_cast (show 0<q by omega) |
| have hbr : (0:ℝ)<b := by exact_mod_cast hb |
| have hnr : (n:ℝ)≤2*(q:ℝ)*b := by exact_mod_cast hn |
| have hpow : ((q:ℝ)^((4:ℝ)/3))^3=(q:ℝ)^4 := by |
| rw [←Real.rpow_mul_natCast hq0.le] |
| norm_num |
| have hm : (m:ℝ)≤(q:ℝ)^((4:ℝ)/3)/4 := by |
| apply le_of_pow_le_pow_left₀ (by decide : (3:ℕ)≠0) (by positivity) |
| have hn4 := pow_le_pow_left₀ (show (0:ℝ)≤n by positivity) hnr 4 |
| have ht : (m:ℝ)^3*(b:ℝ)^4≤((q:ℝ)^((4:ℝ)/3)/4)^3*(b:ℝ)^4 := by |
| rw [div_pow,hpow] |
| nlinarith |
| exact (mul_le_mul_iff_left₀ (pow_pos hbr 4)).mp ht |
| have hqpow : (4:ℝ)≤(q:ℝ)^((4:ℝ)/3) := by |
| have h1 := Real.rpow_le_rpow_of_exponent_le (show (1:ℝ)≤q by exact_mod_cast (show 1≤q by omega)) (by norm_num : (1:ℝ)≤4/3) |
| rw [Real.rpow_one] at h1 |
| exact (show (4:ℝ)≤q by exact_mod_cast hq).trans h1 |
| linarith |
|
|
| lemma recurrence_exponent {q : ℕ} (hq : 4≤q) : |
| ∃ ε : ℝ, 0<ε ∧ 0<(4:ℝ)/3-ε ∧ |
| (q:ℝ)^((4:ℝ)/3)/2≤(q:ℝ)^((4:ℝ)/3-ε) := by |
| have hq2 : (2:ℝ)≤q := by exact_mod_cast (show 2≤q by omega) |
| have hq0 : (0:ℝ)<q := lt_of_lt_of_le (by norm_num) hq2 |
| have hl2 : 0<Real.log 2 := Real.log_pos (by norm_num) |
| have hlq : 0<Real.log (q:ℝ) := Real.log_pos (by linarith) |
| have hlog : Real.log 2≤Real.log (q:ℝ) := Real.log_le_log (by norm_num) hq2 |
| let ε : ℝ := Real.log 2/(2*Real.log (q:ℝ)) |
| have he : 0<ε := div_pos hl2 (by positivity) |
| have hehalf : ε≤1/2 := by |
| dsimp [ε] |
| apply (div_le_iff₀ (by positivity : 0<2*Real.log (q:ℝ))).mpr |
| nlinarith |
| refine ⟨ε,he,by linarith,?_⟩ |
| rw [Real.rpow_sub hq0] |
| apply div_le_div_of_nonneg_left (by positivity) (Real.rpow_pos_of_pos hq0 ε) |
| rw [Real.rpow_def_of_pos hq0] |
| calc |
| Real.exp (Real.log (q:ℝ)*ε) ≤ Real.exp (Real.log 2) := by |
| apply Real.exp_le_exp.mpr |
| dsimp [ε] |
| have hl0 := ne_of_gt hlq |
| field_simp |
| nlinarith |
| _ = 2 := Real.exp_log (by norm_num) |
|
|
| end PlanarHalving.Sweep |
|
|
| end OAI |
|
|
