| import OAI.Combinatorics.HalvingLines.Decomposition |
|
|
| namespace OAI |
|
|
| open Filter Topology |
|
|
| namespace PlanarHalving.Sweep |
|
|
| lemma switchCount_le_sq {n : ℕ} (P : Fin n → Point) (k : ℕ) : switchCount P k≤n*n := by |
| classical |
| simpa only [switchCount,Finset.card_univ,Fintype.card_prod,Fintype.card_fin] using |
| (Finset.card_le_card (Finset.filter_subset (fun ij : Fin n × Fin n => |
| ij.1 < ij.2 ∧ 0<k ∧ k<n ∧ belowCount P ij.1 ij.2=k-1) Finset.univ)) |
|
|
| lemma packing_scale : ∃ q : ℕ, 4≤q ∧ ∀ {n k : ℕ} (P : Fin n → Point) |
| (hP : Generic P) (hk : k≤n) (_hn : 4*q≤n), |
| let b := n/q-1 |
| ∀ hb : 0<b, (((states P hP hk).activityGreedy 0 b hb).count:ℝ)+1≤(q:ℝ)^((4:ℝ)/3)/2 := by |
| obtain ⟨Q,_,hpack⟩ := activity_saving_cubic (δ := (1:ℝ)/(524288*1024)) (by norm_num) |
| obtain ⟨q,hq⟩ := exists_nat_gt (max (4:ℝ) Q) |
| have hq4 : 4≤q := by exact_mod_cast (le_max_left (4:ℝ) Q).trans hq.le |
| have hqQ : Q≤q := (le_max_right (4:ℝ) Q).trans hq.le |
| refine ⟨q,hq4,?_⟩ |
| intro n k P hP hk hn b hb |
| let S := states P hP hk |
| let G := S.activityGreedy 0 b hb |
| have hscale := division_scale hq4 hn |
| change 0<b ∧ b+1=n/q ∧ (b+1:ℝ)≤(n:ℝ)/q ∧ n≤2*q*b ∧ b+1<n at hscale |
| have hqb : q*b≤n := (Nat.mul_le_mul_left q (Nat.sub_le (n/q) 1)).trans (Nat.mul_div_le n q) |
| have hratio : Q≤(n:ℝ)/b := hqQ.trans ((le_div_iff₀ (by exact_mod_cast hb)).mpr (by exact_mod_cast hqb)) |
| have hdata := G.intervals_data S |
| have hh := hpack P hP hk hb hratio (G.intervals S) hdata.1 |
| (fun p hp => (hdata.2 p hp).1) (fun p hp => by |
| rw [← S.activitySize_eq] |
| exact (hdata.2 p hp).2) |
| rw [G.intervals_card S] at hh |
| apply greedy_count_bound hq4 hb hscale.2.2.2.1 |
| norm_num at hh |
| nlinarith |
|
|
| lemma count_bound_induction {q : ℕ} (hq : 4≤q) {β : ℝ} (hβ : 0<β) |
| (hpacking : ∀ {n k : ℕ} (P : Fin n → Point) (hP : Generic P) (hk : k≤n) |
| (_hn : 4*q≤n), let b := n/q-1 |
| ∀ hb : 0<b, (((states P hP hk).activityGreedy 0 b hb).count:ℝ)+1≤(q:ℝ)^β) : |
| ∀ n : ℕ, ∀ P : Fin n → Point, Generic P → ∀ k : ℕ, k≤n → |
| (switchCount P k:ℝ)≤(4*(q:ℝ))^2*(n:ℝ)^β := by |
| let C : ℝ := (4*(q:ℝ))^2 |
| have hC : 0≤C := sq_nonneg _ |
| have hq0 : (0:ℝ)<q := by exact_mod_cast (show 0<q by omega) |
| intro n |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| intro P hP k hk |
| by_cases hn : 4*q≤n |
| · let b := n/q-1 |
| have hscale := division_scale hq hn |
| change 0<b ∧ b+1=n/q ∧ (b+1:ℝ)≤(n:ℝ)/q ∧ n≤2*q*b ∧ b+1<n at hscale |
| let hb := hscale.1 |
| let G := (states P hP hk).activityGreedy 0 b hb |
| obtain ⟨A,r,hA,hr,hcount⟩ := activity_decomposition hP hk hb |
| have hg : (G.count:ℝ)+1≤(q:ℝ)^β := hpacking P hP hk hn hb |
| have hAreal (j : Fin (G.count+1)) : ((A j).card:ℝ)≤(n:ℝ)/q := |
| (by exact_mod_cast hA j : ((A j).card:ℝ)≤b+1).trans hscale.2.2.1 |
| have hind (j : Fin (G.count+1)) : |
| (switchCount (subsetPoints P (A j)) (r j):ℝ)≤C*((A j).card:ℝ)^β := |
| ih (A j).card ((hA j).trans_lt hscale.2.2.2.2) (subsetPoints P (A j)) |
| (subsetPoints_generic hP (A j)) (r j) (hr j) |
| change (switchCount P k:ℝ)≤C*(n:ℝ)^β |
| calc |
| (switchCount P k:ℝ) ≤ ∑ j : Fin (G.count+1), (switchCount (subsetPoints P (A j)) (r j):ℝ) := by exact_mod_cast hcount |
| _ ≤ ∑ j : Fin (G.count+1), C*((A j).card:ℝ)^β := Finset.sum_le_sum (fun j _ => hind j) |
| _ ≤ ∑ _j : Fin (G.count+1), C*((n:ℝ)/q)^β := Finset.sum_le_sum (fun j _ => |
| mul_le_mul_of_nonneg_left (Real.rpow_le_rpow (by positivity) (hAreal j) hβ.le) hC) |
| _ = C*((n:ℝ)/q)^β*((G.count:ℝ)+1) := by simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,Nat.cast_add,Nat.cast_one];ring |
| _ ≤ C*((n:ℝ)/q)^β*(q:ℝ)^β := mul_le_mul_of_nonneg_left hg (mul_nonneg hC (Real.rpow_nonneg (by positivity) _)) |
| _ = C*(n:ℝ)^β := by rw [Real.div_rpow (by positivity) hq0.le];field_simp |
| · have hs : (switchCount P k:ℝ)≤(n:ℝ)^2 := by exact_mod_cast (by simpa only [pow_two] using switchCount_le_sq P k : switchCount P k≤n^2) |
| by_cases hz : n=0 |
| · subst n |
| simpa only [Nat.cast_zero,zero_pow (by decide : (2:ℕ)≠0),Real.zero_rpow hβ.ne',mul_zero] using hs |
| · have hn1 : (1:ℝ)≤n := by exact_mod_cast (show 1≤n by omega) |
| have hnr : (n:ℝ)≤4*(q:ℝ) := by exact_mod_cast (le_of_lt (lt_of_not_ge hn)) |
| have hpow : 1≤(n:ℝ)^β := by |
| simpa only [Real.one_rpow] using Real.rpow_le_rpow (by norm_num : (0:ℝ)≤1) hn1 hβ.le |
| exact (hs.trans (pow_le_pow_left₀ (by positivity) hnr 2)).trans (le_mul_of_one_le_right hC hpow) |
|
|
| end PlanarHalving.Sweep |
|
|
| namespace PlanarHalving |
|
|
| theorem all_ranks_power : |
| ∃ ε : ℝ, 0 < ε ∧ ∃ C : ℝ, |
| ∀ n : ℕ, 1 ≤ n → ∀ P : Fin n → Point, Generic P → |
| ∀ k : ℕ, k ≤ n → (switchCount P k : ℝ) ≤ C * (n : ℝ) ^ ((4 : ℝ) / 3 - ε) := by |
| obtain ⟨q,hq,hpack⟩ := Sweep.packing_scale |
| obtain ⟨ε,he,hβ,hpow⟩ := Sweep.recurrence_exponent hq |
| refine ⟨ε,he,(4*(q:ℝ))^2,?_⟩ |
| intro n _ P hP k hk |
| apply Sweep.count_bound_induction hq hβ _ n P hP k hk |
| intro n k P hP hk hn b hb |
| exact (hpack P hP hk hn hb).trans hpow |
| end PlanarHalving |
|
|
| end OAI |
|
|
