| import OAI.NumberTheory.PowerFree.AdaptiveRanks |
|
|
| namespace OAI |
|
|
| open scoped BigOperators |
| open Matrix |
| open scoped BigOperators |
| open scoped BigOperators |
|
|
| namespace QuarticPowerFree |
|
|
| theorem product_distinct_prime_divisors_le (a : ℤ) (ha : a ≠ 0) |
| (P : Finset ℕ) (hp : ∀ p ∈ P, p.Prime) |
| (hd : ∀ p ∈ P, (p : ℤ) ∣ a) : |
| (∏ p ∈ P, (p : ℝ)) ≤ |(a : ℝ)| := by |
| have hn : a.natAbs ≠ 0 := (Int.natAbs_pos.mpr ha).ne' |
| have hs : P ⊆ a.natAbs.primeFactors := by |
| intro p h |
| exact Nat.mem_primeFactors.mpr ⟨hp p h, |
| by simpa using Int.natAbs_dvd_natAbs.mpr (hd p h), hn⟩ |
| have hh := Nat.le_of_dvd (Int.natAbs_pos.mpr ha) |
| ((Finset.prod_dvd_prod_of_subset P a.natAbs.primeFactors id hs).trans |
| (Nat.prod_primeFactors_dvd a.natAbs)) |
| have he : (a.natAbs : ℝ) = |(a : ℝ)| := by |
| rw [← Int.cast_natCast, Int.natCast_natAbs, Int.cast_abs] |
| rw [← he, ← Nat.cast_prod] |
| exact_mod_cast hh |
|
|
| theorem card_large_prime_divisors_le (a : ℤ) (ha : a ≠ 0) |
| (P : Finset ℕ) (hp : ∀ p ∈ P, p.Prime) (hd : ∀ p ∈ P, (p : ℤ) ∣ a) |
| (X ζ B : ℝ) (hX : 1 < X) (hζ : 0 < ζ) |
| (hsmall : ∀ p ∈ P, X ^ ζ ≤ (p : ℝ)) (hlarge : |(a : ℝ)| ≤ X ^ B) : |
| (P.card : ℝ) ≤ B / ζ := by |
| have hx : 0 ≤ X := (zero_lt_one.trans hX).le |
| have h : X ^ (ζ * (P.card : ℝ)) ≤ X ^ B := by |
| rw [Real.rpow_mul hx, Real.rpow_natCast] |
| calc |
| (X ^ ζ) ^ P.card = ∏ _p ∈ P, X ^ ζ := (Finset.prod_const _).symm |
| _ ≤ ∏ p ∈ P, (p : ℝ) := Finset.prod_le_prod₀ |
| (fun _ _ => (Real.rpow_pos_of_pos (zero_lt_one.trans hX) ζ).le) hsmall |
| _ ≤ |(a : ℝ)| := product_distinct_prime_divisors_le a ha P hp hd |
| _ ≤ X ^ B := hlarge |
| rw [le_div_iff₀ hζ] |
| simpa [mul_comm] using (Real.rpow_le_rpow_left_iff hX).mp h |
|
|
| theorem card_large_prime_divisors_le_floor (a : ℤ) (ha : a ≠ 0) |
| (P : Finset ℕ) (hp : ∀ p ∈ P, p.Prime) (hd : ∀ p ∈ P, (p : ℤ) ∣ a) |
| (X ζ B : ℝ) (hX : 1 < X) (hζ : 0 < ζ) |
| (hsmall : ∀ p ∈ P, X ^ ζ ≤ (p : ℝ)) (hlarge : |(a : ℝ)| ≤ X ^ B) : |
| P.card ≤ ⌊B / ζ⌋₊ := |
| Nat.le_floor (card_large_prime_divisors_le a ha P hp hd X ζ B hX hζ hsmall hlarge) |
|
|
| open scoped BigOperators |
|
|
| def cellKernel {K V ι : Type*} [Field K] [AddCommGroup V] [Module K V] |
| (ev : ι → V →ₗ[K] K) (S : Set ι) : Submodule K V := |
| ⨅ i ∈ S, LinearMap.ker (ev i) |
|
|
| theorem cellKernel_mono {K V ι : Type*} [Field K] [AddCommGroup V] [Module K V] |
| (ev : ι → V →ₗ[K] K) {S T : Set ι} (h : S ⊆ T) : |
| cellKernel ev T ≤ cellKernel ev S := by |
| intro v hv |
| simp only [cellKernel, Submodule.mem_iInf, LinearMap.mem_ker] at hv ⊢ |
| exact fun i hi => hv i (h hi) |
|
|
| theorem adaptiveStates_length {K V σ α : Type*} [Field K] [AddCommGroup V] [Module K V] |
| (W : ℕ → σ → α → Submodule K V) (next : ℕ → σ → Submodule K V → σ) |
| (n i : ℕ) (s : σ) (a : α) : (adaptiveStates W next n i s a).length = n+1 := by |
| induction n generalizing i s with |
| | zero => rfl |
| | succ n ih => simp only [adaptiveStates, List.length_cons, ih] |
|
|
| theorem list_minor_product_bound {σ : Type*} (l : List σ) (minor : σ → ℤ) |
| (X B : ℝ) (hX : 0 < X) |
| (hminor : ∀ s ∈ l, minor s ≠ 0 ∧ |(minor s : ℝ)| ≤ X^B) : |
| (l.map minor).prod ≠ 0 ∧ |(((l.map minor).prod : ℤ) : ℝ)| ≤ X^(B*(l.length : ℝ)) := by |
| induction l with |
| | nil => simp |
| | cons x l ih => |
| have hx := hminor x (by simp) |
| have ht := ih (fun s hs => hminor s (by simp [hs])) |
| constructor |
| · simpa only [List.map_cons, List.prod_cons] using mul_ne_zero hx.1 ht.1 |
| · simp only [List.map_cons, List.prod_cons, Int.cast_mul, abs_mul, |
| List.length_cons, Nat.cast_add, Nat.cast_one, mul_add, mul_one, |
| Real.rpow_add hX] |
| exact (mul_le_mul hx.2 ht.2 (abs_nonneg _) (Real.rpow_nonneg hX.le _)).trans_eq (mul_comm _ _) |
|
|
| theorem adaptive_deletion_bound {K V σ : Type*} [Field K] [AddCommGroup V] |
| [Module K V] [Module.Finite K V] |
| (W : ℕ → σ → Finset ℕ → Submodule K V) |
| (next : ℕ → σ → Submodule K V → σ) |
| (hW : ∀ i s A B, A ⊆ B → W i s A ≤ W i s B) |
| (minor : σ → ℤ) (n : ℕ) (s : σ) |
| (P : Finset ℕ) (hp : ∀ p ∈ P, p.Prime) |
| (X ζ B : ℝ) (hX : 1 < X) (hζ : 0 < ζ) |
| (hsmall : ∀ p ∈ P, X^ζ ≤ (p : ℝ)) |
| (hminor : ∀ A ⊆ P, ∀ t ∈ adaptiveStates W next n 0 s A, |
| minor t ≠ 0 ∧ |(minor t : ℝ)| ≤ X^B) |
| (ell T : ℕ) (hT : 0 < T) (hsize : ell+T < P.card) : |
| let bad := fun A => P.filter fun p : ℕ => |
| (p : ℤ) ∣ ((adaptiveStates W next n 0 s A).map minor).prod |
| (∑ j ∈ Finset.range T, badFraction P (ell+j+1) bad) / (T : ℝ) ≤ |
| (((Module.finrank K V+1)^n : ℕ) : ℝ) / T + |
| (⌊(B*(n+1:ℕ))/ζ⌋₊ : ℝ) / ((P.card : ℝ) - (ell+T)) := by |
| classical |
| intro bad |
| let R := fun A => adaptiveCode W next n 0 s A |
| apply deletion_average_bound P ell T hT hsize R bad |
| ((Module.finrank K V+1)^n) ⌊(B*(n+1:ℕ))/ζ⌋₊ |
| · intro A _ |
| exact (adaptiveCode_lt W next n 0 s A).le |
| · intro A _ q _ |
| exact (adaptiveCode_mono_stable W next (A.erase q) A |
| (fun i s => hW i s _ _ (Finset.erase_subset _ _)) n 0 s).1 |
| · intro A _ q _ he |
| have hs := (adaptiveCode_mono_stable W next (A.erase q) A |
| (fun i s => hW i s _ _ (Finset.erase_subset _ _)) n 0 s).2 he |
| dsimp [bad] |
| rw [hs] |
| · intro A hAP |
| let l := adaptiveStates W next n 0 s A |
| have hb := list_minor_product_bound l minor X B (zero_lt_one.trans hX) (hminor A hAP) |
| have hl : l.length = n+1 := adaptiveStates_length W next n 0 s A |
| have hin : P ∩ bad A = bad A := Finset.inter_eq_right.mpr (Finset.filter_subset _ _) |
| rw [hin] |
| apply card_large_prime_divisors_le_floor _ hb.1 _ |
| (fun p h => hp p (Finset.mem_filter.mp h).1) |
| (fun _ h => (Finset.mem_filter.mp h).2) X ζ (B*(n+1:ℕ)) hX hζ |
| (fun p h => hsmall p (Finset.mem_filter.mp h).1) |
| simpa only [hl] using hb.2 |
|
|
| open scoped BigOperators |
|
|
| def BlockSample (P : Finset ℕ) (ell T : ℕ) := |
| Σ j : Fin T, (P.powersetCard (ell+j.val+1)) |
|
|
| noncomputable instance (P : Finset ℕ) (ell T : ℕ) : Fintype (BlockSample P ell T) := |
| inferInstanceAs (Fintype (Σ j : Fin T, (P.powersetCard (ell+j.val+1)))) |
|
|
| noncomputable def blockWeight (P : Finset ℕ) (ell T : ℕ) |
| (a : BlockSample P ell T) : ℝ := |
| ((T : ℝ) * ((P.powersetCard (ell+a.1.val+1)).card : ℝ))⁻¹ |
|
|
| def blockSet {P : Finset ℕ} {ell T : ℕ} (a : BlockSample P ell T) : Finset ℕ := |
| a.2.val |
|
|
| theorem blockSet_spec {P : Finset ℕ} {ell T : ℕ} (a : BlockSample P ell T) : |
| blockSet a ⊆ P ∧ (blockSet a).card = ell+a.1.val+1 := |
| Finset.mem_powersetCard.mp a.2.property |
|
|
| theorem blockWeight_nonneg (P : Finset ℕ) (ell T : ℕ) |
| (a : BlockSample P ell T) : 0 ≤ blockWeight P ell T a := by |
| unfold blockWeight |
| positivity |
|
|
| theorem blockWeight_sum (P : Finset ℕ) (ell T : ℕ) |
| (hT : 0 < T) (hsize : ell+T ≤ P.card) : |
| ∑ a : BlockSample P ell T, blockWeight P ell T a = 1 := by |
| classical |
| change (∑ a : Σ j : Fin T, (P.powersetCard (ell+j.val+1)), |
| ((T : ℝ) * ((P.powersetCard (ell+a.1.val+1)).card : ℝ))⁻¹) = 1 |
| rw [Fintype.sum_sigma] |
| have he (j : Fin T) : |
| (∑ _a : (P.powersetCard (ell+j.val+1)), |
| ((T : ℝ) * ((P.powersetCard (ell+j.val+1)).card : ℝ))⁻¹) = (T : ℝ)⁻¹ := by |
| have hc : 0 < (P.powersetCard (ell+j.val+1)).card := |
| Finset.card_pos.mpr (Finset.powersetCard_nonempty.mpr (by omega)) |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_coe, nsmul_eq_mul] |
| field_simp |
| simp only [he,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] |
| exact mul_inv_cancel₀ (Nat.cast_ne_zero.mpr hT.ne') |
|
|
| theorem blockWeight_bad_average (P : Finset ℕ) (ell T : ℕ) |
| (bad : Finset ℕ → Finset ℕ) : |
| (∑ a : BlockSample P ell T, blockWeight P ell T a * |
| ((∑ q ∈ blockSet a, if q ∈ bad (blockSet a) then (1 : ℝ) else 0) / |
| (blockSet a).card)) = |
| (∑ j ∈ Finset.range T, badFraction P (ell+j+1) bad) / T := by |
| classical |
| change (∑ a : Σ j : Fin T, (P.powersetCard (ell+j.val+1)), |
| ((T : ℝ) * ((P.powersetCard (ell+a.1.val+1)).card : ℝ))⁻¹ * |
| ((∑ q ∈ a.2.val, if q ∈ bad a.2.val then (1 : ℝ) else 0) / a.2.val.card)) = _ |
| rw [Fintype.sum_sigma, ← Fin.sum_univ_eq_sum_range, Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [badFraction] |
| rw [Finset.sum_coe_sort (P.powersetCard (ell+j.val+1)) |
| (fun S : Finset ℕ => ((T : ℝ) * ((P.powersetCard (ell+j.val+1)).card : ℝ))⁻¹ * |
| ((∑ q ∈ S, if q ∈ bad S then (1 : ℝ) else 0) / S.card)), |
| Finset.sum_div, Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro a ha |
| rw [(Finset.mem_powersetCard.mp ha).2] |
| simp only [div_eq_mul_inv, _root_.mul_inv_rev] |
| ring |
|
|
| theorem independent_average_le {ι : Type*} [Fintype ι] [DecidableEq ι] |
| {Ω : ι → Type*} [∀ i, Fintype (Ω i)] |
| (w : ∀ i, Ω i → ℝ) (hw : ∀ i a, 0 ≤ w i a) |
| (hsum : ∀ i, ∑ a, w i a = 1) (i : ι) |
| (F : (∀ j, Ω j) → ℝ) (C : ℝ) |
| (hF : ∀ x, (∑ a, w i a * F (Function.update x i a)) ≤ C) : |
| (∑ x, (∏ j, w j (x j)) * F x) ≤ C := by |
| classical |
| let E := Equiv.piSplitAt i Ω |
| let W : (∀ j : {j // j ≠ i}, Ω j) → ℝ := fun x => ∏ j : {j // j ≠ i}, w j.val (x j) |
| have hs : ∑ x, W x = 1 := by |
| rw [show (∑ x, W x) = ∑ x : (∀ j : {j // j ≠ i}, Ω j), ∏ j : {j // j ≠ i}, w j.val (x j) from rfl, ← Fintype.prod_sum] |
| simp only [hsum, Finset.prod_const_one] |
| have hwE (x : ∀ j, Ω j) : (∏ j, w j (x j)) = w i (x i) * W (E x).2 := by |
| rw [← Finset.mul_prod_erase Finset.univ (fun j => w j (x j)) (Finset.mem_univ i)] |
| congr 1 |
| exact Finset.prod_subtype (p := fun j => j ≠ i) (Finset.univ.erase i) (by simp) (fun j => w j (x j)) |
| have hE (x : (∀ j : {j // j ≠ i}, Ω j)) (a b : Ω i) : |
| Function.update (E.symm (a,x)) i b = E.symm (b,x) := by |
| funext j |
| by_cases h : j = i |
| · subst j; simp [E, Equiv.piSplitAt] |
| · simp [E, Equiv.piSplitAt, h] |
| have hEq : (∑ x, (∏ j, w j (x j)) * F x) = |
| ∑ x, W x * (∑ a, w i a * F (E.symm (a,x))) := by |
| rw [Fintype.sum_equiv E _ (fun z => w i z.1 * W z.2 * F (E.symm z))] |
| · rw [Fintype.sum_prod_type, Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro x _ |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro a _ |
| ring |
| · intro x |
| rw [hwE, E.symm_apply_apply] |
| rfl |
| rw [hEq] |
| have hFin (x : ∀ j : {j // j ≠ i}, Ω j) : |
| (∑ a, w i a * F (E.symm (a,x))) ≤ C := by |
| by_cases h : Nonempty (Ω i) |
| · obtain ⟨a⟩ := h |
| simpa only [hE] using hF (E.symm (a,x)) |
| · have := not_nonempty_iff.mp h |
| have hz := hsum i |
| simp at hz |
| calc |
| _ ≤ ∑ x, W x * C := Finset.sum_le_sum fun x _ => |
| mul_le_mul_of_nonneg_left (hFin x) (Finset.prod_nonneg fun j _ => hw j.val (x j)) |
| _ = C := by rw [← Finset.sum_mul, hs, one_mul] |
|
|
| theorem exists_many_regular {Ω ι : Type*} [Fintype Ω] [Fintype ι] |
| (w : Ω → ℝ) (hw : ∀ a, 0 ≤ w a) (hsum : ∑ a, w a = 1) |
| (bad : Ω → ι → Prop) [DecidableRel bad] |
| (η : ℝ) (hbad : ∀ z, (∑ a, w a * if bad a z then (1 : ℝ) else 0) ≤ η) : |
| ∃ a : Ω, ((Finset.univ.filter fun z => ¬ bad a z).card : ℝ) ≥ |
| (1-η) * Fintype.card ι := by |
| classical |
| have havg : (∑ a, w a * ((Finset.univ.filter fun z => bad a z).card : ℝ)) ≤ |
| η * Fintype.card ι := by |
| simp_rw [← Finset.sum_boole, Finset.mul_sum] |
| rw [Finset.sum_comm] |
| exact (Finset.sum_le_sum fun z _ => hbad z).trans_eq (by simp; ring) |
| have hex : ∃ a : Ω, ((Finset.univ.filter fun z => bad a z).card : ℝ) ≤ η * Fintype.card ι := by |
| by_contra h |
| push Not at h |
| have hp : ∃ a, 0 < w a := by |
| by_contra h0 |
| push Not at h0 |
| have hz : ∀ a, w a = 0 := fun a => le_antisymm (h0 a) (hw a) |
| simp [hz] at hsum |
| obtain ⟨a,ha⟩ := hp |
| have hlt : (∑ b, w b * (η * Fintype.card ι)) < |
| ∑ b, w b * ((Finset.univ.filter fun z => bad b z).card : ℝ) := by |
| apply Finset.sum_lt_sum |
| · intro b _ |
| exact mul_le_mul_of_nonneg_left (h b).le (hw b) |
| · exact ⟨a,Finset.mem_univ _,mul_lt_mul_of_pos_left (h a) ha⟩ |
| rw [← Finset.sum_mul,hsum,one_mul] at hlt |
| linarith |
| obtain ⟨a,ha⟩ := hex |
| refine ⟨a,?_⟩ |
| have hc : (Finset.univ.filter fun z => bad a z).card + |
| (Finset.univ.filter fun z => ¬ bad a z).card = Fintype.card ι := by |
| simpa using Finset.card_filter_add_card_filter_not (s := Finset.univ) (fun z => bad a z) |
| have hcr : ((Finset.univ.filter fun z => bad a z).card : ℝ) + |
| ((Finset.univ.filter fun z => ¬ bad a z).card : ℝ) = Fintype.card ι := by exact_mod_cast hc |
| linarith |
|
|
| theorem bad_blocks_indicator_le {r : ℕ} (b : Fin r → ℝ) (hb : ∀ i, 0 ≤ b i) |
| (ξ : ℝ) (hξ : 0 < ξ) : |
| (if ∃ i, ξ < b i then (1 : ℝ) else 0) ≤ (∑ i, b i) / ξ := by |
| classical |
| split_ifs with h |
| · obtain ⟨i,hi⟩ := h |
| rw [le_div_iff₀ hξ, one_mul] |
| exact hi.le.trans (Finset.single_le_sum (fun j _ => hb j) (Finset.mem_univ i)) |
| · exact div_nonneg (Finset.sum_nonneg fun i _ => hb i) hξ.le |
|
|
| end QuarticPowerFree |
|
|
| end OAI |
|
|
