math / data /lean /OAI /NumberTheory /PowerFree /HilbertSimplex.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
14.6 kB
import OAI.NumberTheory.PowerFree.ResidueRelations
namespace OAI
open scoped BigOperators
open Matrix
open scoped BigOperators
open scoped BigOperators
namespace QuarticPowerFree
section
open scoped BigOperators
theorem extend_independent_finset {K V ΞΉ : Type*} [Field K]
[AddCommGroup V] [Module K V] (v : ΞΉ β†’ V) (S A : Finset ΞΉ)
(hAS : A βŠ† S) (hA : LinearIndepOn K v (A : Set ΞΉ)) (m : β„•)
(hAm : A.card ≀ m) (hm : m ≀ Module.finrank K (Submodule.span K (v '' (S : Set ΞΉ)))) :
βˆƒ B : Finset ΞΉ, A βŠ† B ∧ B βŠ† S ∧ B.card = m ∧ LinearIndepOn K v (B : Set ΞΉ) := by
classical
have hsub : (A : Set ΞΉ) βŠ† (S : Set ΞΉ) := hAS
let T := hA.extend hsub
have hTs : T βŠ† (S : Set ΞΉ) := hA.extend_subset hsub
have hfin : T.Finite := S.finite_toSet.subset hTs
let B := hfin.toFinset
have hli : LinearIndepOn K v (B : Set ΞΉ) := by
simpa only [B, Set.Finite.coe_toFinset] using hA.linearIndepOn_extend hsub
have hspan : Submodule.span K (v '' (B : Set ΞΉ)) =
Submodule.span K (v '' (S : Set ΞΉ)) := by
simpa only [B, Set.Finite.coe_toFinset] using hA.span_image_extend_eq_span_image hsub
have hcard : Module.finrank K (Submodule.span K (v '' (B : Set ΞΉ))) = B.card := by
have hh := finrank_span_eq_card (hli.linearIndependent_restrict)
change Module.finrank K (Submodule.span K (Set.range (fun a : B => v a))) = _ at hh
have hr : Set.range (fun a : B => v a) = v '' (B : Set ΞΉ) := by
ext x
constructor
· rintro ⟨a,rfl⟩; exact ⟨a,a.property,rfl⟩
· rintro ⟨a,ha,rfl⟩; exact ⟨⟨a,ha⟩,rfl⟩
rw [hr] at hh
simpa using hh
have hAB : A βŠ† B := fun a ha => hfin.mem_toFinset.mpr (hA.subset_extend hsub ha)
have hBS : B βŠ† S := fun a ha => hTs (hfin.mem_toFinset.mp ha)
have hmB : m ≀ B.card := by rw [← hcard,hspan]; exact hm
obtain ⟨C,hAC,hCB,hC⟩ := Finset.exists_subsuperset_card_eq hAB hAm hmB
exact ⟨C,hAC,hCB.trans hBS,hC,hli.mono hCB⟩
theorem hilbert_simplex_shift (h : β„•) (hh : 0 < h) (Ξ΄ c : ℝ)
(hΞ΄ : 0 < Ξ΄) (hc : 0 ≀ c) :
βˆƒ C : ℝ, 1 ≀ C ∧ βˆ€ t : β„•,
((t+h).choose h : ℝ) ≀ (Ξ΄*t+C)^h / ((h.factorial : ℝ)*Ξ΄^h) -
c*(Ξ΄*t+C)^(h-1) := by
let a : ℝ := (h.factorial : ℝ)*c*Ξ΄^(h-1) + 1/Ξ΄
let C : ℝ := Ξ΄*((h : ℝ)+a)
have hf : (0 : ℝ) < h.factorial := by exact_mod_cast h.factorial_pos
have ha0 : 0 ≀ a := by dsimp [a]; positivity
have hC : 1 ≀ C := by
dsimp [C,a]
rw [mul_add, mul_add, div_eq_mul_inv, one_mul, mul_inv_cancelβ‚€ hΞ΄.ne']
have hN : 0 ≀ Ξ΄*(h:ℝ)+Ξ΄*((h.factorial:ℝ)*c*Ξ΄^(h-1)) := by positivity
linarith
refine ⟨C,hC,fun t => ?_⟩
let x : ℝ := (t+h : β„•)+a
have hx : 0 ≀ x := by dsimp [x]; positivity
have hlow : ((t+h : β„•) : ℝ) ≀ x := by dsimp [x]; linarith
have hT : Ξ΄*t+C = Ξ΄*x := by dsimp [C,x]; push_cast; ring
have hpow : x^h = x^(h-1)*x := by rw [← pow_succ,Nat.sub_add_cancel hh]
have hnum : ((t+h : β„•) : ℝ)^h ≀ x^h - (h.factorial : ℝ)*c*Ξ΄^(h-1)*x^(h-1) := by
have hq : ((t+h : β„•) : ℝ)^(h-1) ≀ x^(h-1) :=
pow_le_pow_leftβ‚€ (Nat.cast_nonneg _) hlow _
have hb : ((t+h : β„•) : ℝ) ≀ x - (h.factorial : ℝ)*c*Ξ΄^(h-1) := by
dsimp [x,a]
linarith [div_nonneg (by norm_num : (0:ℝ) ≀ 1) hΞ΄.le]
calc
_ = ((t+h : β„•) : ℝ)^(h-1)*((t+h : β„•) : ℝ) := by
rw [← pow_succ,Nat.sub_add_cancel hh]
_ ≀ x^(h-1)*(x-(h.factorial : ℝ)*c*Ξ΄^(h-1)) :=
mul_le_mul hq hb (Nat.cast_nonneg _) (pow_nonneg hx _)
_ = _ := by rw [hpow]; ring
have hb := (Nat.choose_le_pow_div h (t+h) : ((t+h).choose h : ℝ) ≀
((t+h : β„•) : ℝ)^h / (h.factorial : ℝ))
apply hb.trans
rw [hT,mul_pow,mul_pow]
have he : Ξ΄^h*x^h / ((h.factorial:ℝ)*Ξ΄^h) - c*(Ξ΄^(h-1)*x^(h-1)) =
(x^h-(h.factorial:ℝ)*c*Ξ΄^(h-1)*x^(h-1))/(h.factorial:ℝ) := by
field_simp
rw [he]
exact div_le_div_of_nonneg_right hnum hf.le
theorem simplex_order_step (h t : β„•) :
h*((t+1+h).choose (h+1)) + (t+1)*((t+h).choose h) =
h*((t+h).choose (h+1)) + (t+1)*((t+1+h).choose h) := by
have h₁ := Nat.choose_succ_succ (t+h) h
have hβ‚‚ := Nat.choose_mul_succ_eq (t+h) h
rw [show t+h+1-h = t+1 by omega] at hβ‚‚
rw [show t+1+h = t+h+1 by omega]
nlinarith
theorem independent_weighted_simplex {K V ΞΉ : Type*} [Field K]
[AddCommGroup V] [Module K V] (v : ΞΉ β†’ V) (S : β„• β†’ Finset ΞΉ)
(hS : βˆ€ t, S t βŠ† S (t+1)) (w : ΞΉ β†’ ℝ) (Ξ΄ C : ℝ)
(hweight : βˆ€ t a, a ∈ S t β†’ w a ≀ Ξ΄*t+C)
(h : β„•) (hrank : βˆ€ t, (t+h).choose h ≀
Module.finrank K (Submodule.span K (v '' (S t : Set ΞΉ)))) (t : β„•) :
βˆƒ A : Finset ΞΉ, A βŠ† S t ∧ A.card = (t+h).choose h ∧
LinearIndepOn K v (A : Set ι) ∧
βˆ‘ a ∈ A, w a ≀ Ξ΄*(h*((t+h).choose (h+1)) : β„•) + C*((t+h).choose h) := by
classical
induction t with
| zero =>
obtain ⟨A,_,hA,hcard,hli⟩ := extend_independent_finset v (S 0) βˆ…
(Finset.empty_subset _) (by simp)
((0+h).choose h) (by simp) (hrank 0)
refine ⟨A,hA,hcard,hli,?_⟩
have hb := Finset.sum_le_sum (s := A) (fun a ha => hweight 0 a (hA ha))
simpa only [Nat.cast_zero,mul_zero,zero_add,Finset.sum_const, nsmul_eq_mul,
hcard,Nat.choose_self,Nat.cast_one,mul_one,one_mul,Nat.choose_eq_zero_of_lt (Nat.lt_succ_self h),
Nat.mul_zero] using hb
| succ t ih =>
obtain ⟨A,hA,hcard,hli,hsum⟩ := ih
have hcount : A.card ≀ (t+1+h).choose h := by
rw [hcard]
exact Nat.choose_le_choose h (by omega)
obtain ⟨B,hAB,hB,hBcard,hlB⟩ := extend_independent_finset v (S (t+1)) A
(hA.trans (hS t)) hli ((t+1+h).choose h) hcount (hrank (t+1))
refine ⟨B,hB,hBcard,hlB,?_⟩
have hnew : βˆ‘ a ∈ B \ A, w a ≀ ((B \ A).card : ℝ)*(Ξ΄*(t+1)+C) := by
calc
_ ≀ βˆ‘ _a ∈ B \ A, (Ξ΄*(t+1)+C) := by
apply Finset.sum_le_sum
intro a ha
have haW := hweight (t+1) a (hB (Finset.mem_sdiff.mp ha).1)
simpa only [Nat.cast_add,Nat.cast_one] using haW
_ = _ := by rw [Finset.sum_const,nsmul_eq_mul]
have hsplit : (βˆ‘ a ∈ B \ A, w a) + (βˆ‘ a ∈ A, w a) = βˆ‘ a ∈ B, w a :=
Finset.sum_sdiff hAB
have hcarddiff : ((B \ A).card : ℝ) = (B.card : ℝ)-(A.card : ℝ) := by
rw [Finset.card_sdiff_of_subset hAB,Nat.cast_sub (Finset.card_le_card hAB)]
have hstep : (h*((t+1+h).choose (h+1)) : β„•) +
((t+1)*((t+h).choose h) : β„•) =
(h*((t+h).choose (h+1)) : β„•) + ((t+1)*((t+1+h).choose h) : β„•) :=
simplex_order_step h t
have hstepR : (h*((t+1+h).choose (h+1)) : ℝ) +
((t:ℝ)+1)*((t+h).choose h) =
(h*((t+h).choose (h+1)) : ℝ) + ((t:ℝ)+1)*((t+1+h).choose h) := by
exact_mod_cast hstep
rw [hcarddiff,hcard,hBcard] at hnew
push_cast at hsum ⊒
have he : (Ξ΄*(t+1)+C)*(((t+1+h).choose h : ℝ)-((t+h).choose h : ℝ)) +
(Ξ΄*(h:ℝ)*((t+h).choose (h+1))) + C*((t+h).choose h) =
Ξ΄*(h:ℝ)*((t+1+h).choose (h+1)) + C*((t+1+h).choose h) := by
nlinarith [congrArg (fun x : ℝ => Ξ΄*x) hstepR]
rw [← hsplit]
calc
_ ≀ (( (t+1+h).choose h : ℝ)-((t+h).choose h : ℝ))*(Ξ΄*(t+1)+C) +
(Ξ΄*((h:ℝ)*((t+h).choose (h+1))) + C*((t+h).choose h)) := add_le_add hnew hsum
_ = _ := by nlinarith [he]
open scoped BigOperators
open MvPolynomial
noncomputable def monomialWeight {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (a : Οƒ β†’β‚€ β„•) : ℝ := βˆ‘ i, Ο‰ i*(a i : ℝ)
theorem monomialWeight_nonneg {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (hΟ‰ : βˆ€ i, 0 ≀ Ο‰ i) (a : Οƒ β†’β‚€ β„•) : 0 ≀ monomialWeight Ο‰ a :=
Finset.sum_nonneg (fun i _ => mul_nonneg (hω i) (Nat.cast_nonneg _))
noncomputable def weightedExponentBound {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (T : ℝ) : Οƒ β†’β‚€ β„• := Finsupp.equivFunOnFinite.symm (fun i => ⌊T/Ο‰ iβŒ‹β‚Š)
noncomputable def weightedMonomials {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (T : ℝ) : Finset (Οƒ β†’β‚€ β„•) := by
classical
exact (Finset.Iic (weightedExponentBound Ο‰ T)).filter fun a => monomialWeight Ο‰ a ≀ T
theorem mem_weightedMonomials {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (hΟ‰ : βˆ€ i, 0 < Ο‰ i) (T : ℝ) (a : Οƒ β†’β‚€ β„•) :
a ∈ weightedMonomials Ο‰ T ↔ monomialWeight Ο‰ a ≀ T := by
classical
constructor
Β· exact fun h => (Finset.mem_filter.mp h).2
Β· intro ha
refine Finset.mem_filter.mpr ⟨Finset.mem_Iic.mpr ?_,ha⟩
intro i
change a i ≀ ⌊T/Ο‰ iβŒ‹β‚Š
apply Nat.le_floor
apply (le_div_iff₀ (hω i)).mpr
have hi := Finset.single_le_sum
(fun j _ => mul_nonneg (hω j).le (Nat.cast_nonneg (a j))) (Finset.mem_univ i)
simpa only [mul_comm (a i : ℝ)] using hi.trans ha
theorem weightedMonomials_mono {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (hΟ‰ : βˆ€ i, 0 < Ο‰ i) {S T : ℝ} (h : S ≀ T) :
weightedMonomials Ο‰ S βŠ† weightedMonomials Ο‰ T := by
intro a ha
exact (mem_weightedMonomials ω hω T a).mpr
(((mem_weightedMonomials ω hω S a).mp ha).trans h)
noncomputable def weightedDegreeBound {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (T : ℝ) : β„• := βˆ‘ i, ⌊T/Ο‰ iβŒ‹β‚Š
theorem weighted_monomial_degree_bound {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (hΟ‰ : βˆ€ i, 0 < Ο‰ i) (T : ℝ) (a : Οƒ β†’β‚€ β„•)
(ha : monomialWeight Ο‰ a ≀ T) : a.sum (fun _ e => e) ≀ weightedDegreeBound Ο‰ T := by
classical
have hs := (Finset.mem_filter.mp ((mem_weightedMonomials ω hω T a).mpr ha)).1
have hb : a ≀ weightedExponentBound Ο‰ T := Finset.mem_Iic.mp hs
rw [Finsupp.sum_fintype _ _ (by simp)]
exact Finset.sum_le_sum (fun i _ => hb i)
noncomputable def weightedFunctions {Οƒ K : Type*} [Fintype Οƒ] [Field K]
(I : Ideal (MvPolynomial Οƒ K)) (Ο‰ : Οƒ β†’ ℝ) (T : ℝ) :
Submodule K (MvPolynomial Οƒ K β§Έ I) :=
Submodule.span K ((fun a => Ideal.Quotient.mk I (monomial a (1:K))) ''
(weightedMonomials Ο‰ T : Set (Οƒ β†’β‚€ β„•)))
instance weightedFunctions_finite {Οƒ K : Type*} [Fintype Οƒ] [Field K]
(I : Ideal (MvPolynomial Οƒ K)) (Ο‰ : Οƒ β†’ ℝ) (T : ℝ) :
Module.Finite K (weightedFunctions I Ο‰ T) := by
classical
exact Module.Finite.span_of_finite K ((weightedMonomials Ο‰ T).finite_toSet.image _)
noncomputable def weightedHilbert {Οƒ K : Type*} [Fintype Οƒ] [Field K]
(I : Ideal (MvPolynomial Οƒ K)) (Ο‰ : Οƒ β†’ ℝ) (T : ℝ) : β„• :=
Module.finrank K (weightedFunctions I Ο‰ T)
theorem integer_monomial_abs_le {Οƒ : Type*} [Fintype Οƒ]
(Ο‰ : Οƒ β†’ ℝ) (C X : ℝ) (hC : 1 ≀ C) (hX : 0 < X)
(z : Οƒ β†’ β„€) (hz : βˆ€ i, |(z i : ℝ)| ≀ C * X^(Ο‰ i)) (a : Οƒ β†’β‚€ β„•)
(D : β„•) (hD : a.sum (fun _ e => e) ≀ D) :
|((eval z (monomial a (1:β„€)) : β„€) : ℝ)| ≀ C^D * X^(monomialWeight Ο‰ a) := by
classical
have hprod : |((eval z (monomial a (1:β„€)) : β„€) : ℝ)| = ∏ i, |(z i : ℝ)|^(a i) := by
rw [eval_monomial,one_mul,Finsupp.prod_fintype _ _ (by simp)]
simp only [Int.cast_prod,Int.cast_pow,Finset.abs_prod,abs_pow]
have hexp : (∏ i, (X^(Ο‰ i))^(a i)) = X^(monomialWeight Ο‰ a) := by
simp_rw [← Real.rpow_mul_natCast hX.le]
rw [← Real.rpow_sum_of_pos hX]
rfl
calc
_ = ∏ i, |(z i : ℝ)|^(a i) := hprod
_ ≀ ∏ i, (C*X^(Ο‰ i))^(a i) := Finset.prod_le_prodβ‚€
(fun i _ => pow_nonneg (abs_nonneg _) _) (fun i _ => pow_le_pow_leftβ‚€ (abs_nonneg _) (hz i) _)
_ = C^(a.sum (fun _ e => e)) * X^(monomialWeight Ο‰ a) := by
simp_rw [mul_pow]
rw [Finset.prod_mul_distrib,Finset.prod_pow_eq_pow_sum,hexp]
rw [Finsupp.sum_fintype _ _ (by simp)]
_ ≀ _ := mul_le_mul_of_nonneg_right (pow_le_pow_rightβ‚€ hC hD) (Real.rpow_nonneg hX.le _)
end
open scoped BigOperators
open MvPolynomial
theorem select_weighted_monomials {Οƒ K : Type*} [Fintype Οƒ] [Field K]
(I : Ideal (MvPolynomial Οƒ K)) (Ο‰ : Οƒ β†’ ℝ) (hΟ‰ : βˆ€ i, 0 < Ο‰ i)
(h : β„•) (hh : 0 < h) (Ξ΄ c : ℝ) (hΞ΄ : 0 < Ξ΄) (hc : 0 ≀ c)
(hH : βˆ€ T : ℝ, 1 ≀ T β†’ T^h / ((h.factorial : ℝ)*Ξ΄^h)-c*T^(h-1) ≀
weightedHilbert I Ο‰ T) :
βˆƒ C : ℝ, 1 ≀ C ∧ βˆ€ t : β„•, βˆƒ A : Finset (Οƒ β†’β‚€ β„•),
A.card = (t+h).choose h ∧
LinearIndepOn K (fun a => Ideal.Quotient.mk I (monomial a (1:K))) (A : Set _) ∧
(βˆ€ a ∈ A, monomialWeight Ο‰ a ≀ Ξ΄*t+C) ∧
(βˆ€ a ∈ A, a.sum (fun _ e => e) ≀ weightedDegreeBound Ο‰ (Ξ΄*t+C)) ∧
βˆ‘ a ∈ A, monomialWeight Ο‰ a ≀ Ξ΄*(h*((t+h).choose (h+1)) : β„•)+C*((t+h).choose h) := by
obtain ⟨C,hC,hshift⟩ := hilbert_simplex_shift h hh δ c hδ hc
refine ⟨C,hC,?_⟩
intro t
let S := fun t : β„• => weightedMonomials Ο‰ (Ξ΄*t+C)
have hS : βˆ€ t, S t βŠ† S (t+1) := by
intro t
apply weightedMonomials_mono ω hω
push_cast
linarith
have hw : βˆ€ t a, a ∈ S t β†’ monomialWeight Ο‰ a ≀ Ξ΄*t+C := by
intro t a ha
exact (mem_weightedMonomials ω hω _ a).mp ha
have hr : βˆ€ t, (t+h).choose h ≀ Module.finrank K
(Submodule.span K ((fun a => Ideal.Quotient.mk I (monomial a (1:K))) '' (S t : Set _))) := by
intro t
have hT : 1 ≀ Ξ΄*(t:ℝ)+C := by nlinarith [mul_nonneg hΞ΄.le (Nat.cast_nonneg t)]
have hb := (hshift t).trans (hH _ hT)
exact_mod_cast hb
obtain ⟨A,hA,hcard,hli,hsum⟩ := independent_weighted_simplex
(fun a => Ideal.Quotient.mk I (monomial a (1:K))) S hS (monomialWeight Ο‰) Ξ΄ C hw h hr t
refine ⟨A,hcard,hli,fun a ha => hw t a (hA ha),?_,hsum⟩
exact fun a ha => weighted_monomial_degree_bound ω hω _ a (hw t a (hA ha))
theorem exists_simplex_margin (h : β„•) (hh : 0 < h) (Ξ½ C : ℝ) (hΞ½ : 0 < Ξ½) :
βˆƒ t : β„•, 0 < (t+h).choose h ∧
(C+1)*((t+h).choose h : ℝ) ≀ Ξ½*(h*((t+h).choose (h+1)) : β„•) := by
obtain ⟨t,ht⟩ := exists_nat_gt (((C+1)*((h:ℝ)+1))/(Ξ½*h))
have hp : 0 < Ξ½*(h:ℝ) := mul_pos hΞ½ (by exact_mod_cast hh)
have ht' := (div_lt_iffβ‚€ hp).mp ht
have hchoose : (h+1)*((t+h).choose (h+1)) = t*((t+h).choose h) := by
have hc := Nat.add_one_mul_choose_eq (t+h) h
rw [Nat.choose_succ_succ] at hc
nlinarith
have hr : ((h:ℝ)+1)*((t+h).choose (h+1) : ℝ) = (t:ℝ)*((t+h).choose h) := by
exact_mod_cast hchoose
have hL : 0 < (t+h).choose h := Nat.choose_pos (by omega)
refine ⟨t,hL,?_⟩
have hb := mul_le_mul_of_nonneg_right ht'.le (show (0:ℝ) ≀ (t+h).choose h by positivity)
push_cast
nlinarith
end QuarticPowerFree
end OAI