Download data/lean/OAI/Algebra/Determinantal/ProjectiveCounts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/Determinantal/ProjectiveCounts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algebra/Determinantal/ProjectiveCounts.lean
-
curl -L -o ProjectiveCounts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/Determinantal/ProjectiveCounts.lean
19.7 kB
| import OAI.Algebra.Determinantal.PointBounds | |
| namespace OAI | |
| namespace PermanentBorder.Multigraded | |
| open MvPolynomial | |
| section BilinearPointCount | |
| variable {ΞΉ L : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] [Fintype L] [DecidableEq L] | |
| noncomputable def vandermondePairs (a : ΞΉ ββ β) {M : β} | |
| (u v : Fin M β ΞΉ) (t : (Fin M Γ Bool) β β) : | |
| Fin M β FactorPair (K := β) (blockWeight (fun v : BlockVariables a => v.1)) := | |
| fun i => { left := blockLinearForm a (u i) (t (i,false)) | |
| right := blockLinearForm a (v i) (t (i,true)) | |
| leftDegree := Pi.single (u i) 1 | |
| rightDegree := Pi.single (v i) 1 | |
| left_homogeneous := blockLinearForm_homogeneous a (u i) (t (i,false)) | |
| right_homogeneous := blockLinearForm_homogeneous a (v i) (t (i,true)) } | |
| theorem bilinear_simple_point_count_chart (a : ΞΉ ββ β) {M : β} | |
| (u v : Fin M β ΞΉ) (hM : M = β j, a j) | |
| (F : Fin M β MvPolynomial (BlockVariables a) β) | |
| (hF : β i, (F i).IsWeightedHomogeneous | |
| (blockWeight (fun v : BlockVariables a => v.1)) | |
| (Pi.single (u i) 1 + Pi.single (v i) 1)) | |
| (base : ΞΉ β BlockVariables a) (hbase : β j, (base j).1 = j) | |
| (chart : (Fin M β β) β BlockVariables a β β) | |
| (hc : ContDiff β 1 chart) (hci : Function.Injective chart) | |
| (hcn : β z j, chart z (base j) = 1) | |
| (x : L β Fin M β β) (hx : Function.Injective x) | |
| (hz : β i j, eval (chart (x i)) (F j) = 0) | |
| (hs : β i, (fderiv β (fun z j => eval (chart z) (F j)) (x i)).IsInvertible) : | |
| Fintype.card L β€ (mixedPolynomial u v).coeff a := by | |
| classical | |
| let t : (Fin M Γ Bool) β β := fun i => | |
| Infinite.natEmbedding β ((Fintype.equivFin (Fin M Γ Bool) i).val) | |
| have ht : Function.Injective t := | |
| (Infinite.natEmbedding β).injective.comp | |
| (Fin.val_injective.comp (Fintype.equivFin (Fin M Γ Bool)).injective) | |
| generalize hqs : List.ofFn (vandermondePairs a u v t) = qs | |
| have hlen : qs.length = M := by rw [β hqs, List.length_ofFn] | |
| cases hlen | |
| have hget (i : Fin qs.length) : qs.get i = vandermondePairs a u v t i := by | |
| have h := congrArg (fun l => l[i.val]?) hqs | |
| simpa only [List.getElem?_ofFn, dite_eq_left i.isLt, List.getElem?_eq_getElem i.isLt, | |
| Option.some.injEq, List.get_eq_getElem] using h.symm | |
| apply product_simple_point_bound_chart a qs u v t ht | |
| (fun i => by rw [hget]; rfl) (fun i => by rw [hget]; rfl) ?_ hM F | |
| (by intro i; simpa only [hget, vandermondePairs] using hF i) | |
| base hbase chart hc hci hcn x hx hz hs | |
| intro q hq j | |
| rw [β hqs] at hq | |
| obtain β¨i,rflβ© := List.mem_ofFn.mp hq | |
| by_cases hj : j = u i <;> simp [vandermondePairs, hj] | |
| end BilinearPointCount | |
| end PermanentBorder.Multigraded | |
| namespace PermanentBorder.Multigraded | |
| open MvPolynomial | |
| section ProductAffineChart | |
| variable {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] | |
| abbrev BlockAffineVariables (a : ΞΉ β β) := (j : ΞΉ) Γ Fin (a j) | |
| noncomputable def productAffineChart (a : ΞΉ β β) {M : β} | |
| (e : BlockAffineVariables a β Fin M) (z : Fin M β β) : BlockVariables a β β := | |
| fun v => Fin.cases 1 (fun q => z (e β¨v.1,qβ©)) v.2 | |
| omit [Fintype ΞΉ] [DecidableEq ΞΉ] in | |
| lemma productAffineChart_zero (a : ΞΉ β β) {M : β} | |
| (e : BlockAffineVariables a β Fin M) (z : Fin M β β) (j : ΞΉ) : | |
| productAffineChart a e z β¨j,0β© = 1 := by | |
| simp [productAffineChart] | |
| omit [Fintype ΞΉ] [DecidableEq ΞΉ] in | |
| lemma productAffineChart_succ (a : ΞΉ β β) {M : β} | |
| (e : BlockAffineVariables a β Fin M) (z : Fin M β β) (j : ΞΉ) (q : Fin (a j)) : | |
| productAffineChart a e z β¨j,q.succβ© = z (e β¨j,qβ©) := by | |
| simp [productAffineChart] | |
| omit [Fintype ΞΉ] [DecidableEq ΞΉ] in | |
| lemma productAffineChart_injective (a : ΞΉ β β) {M : β} | |
| (e : BlockAffineVariables a β Fin M) : Function.Injective (productAffineChart a e) := by | |
| intro z z' h | |
| funext i | |
| obtain β¨β¨j,qβ©,rflβ© := e.surjective i | |
| have h := congrFun h β¨j,q.succβ© | |
| simpa only [productAffineChart_succ] using h | |
| omit [DecidableEq ΞΉ] in | |
| lemma productAffineChart_contDiff (a : ΞΉ β β) {M : β} | |
| (e : BlockAffineVariables a β Fin M) : ContDiff β 1 (productAffineChart a e) := by | |
| apply contDiff_pi.mpr | |
| rintro β¨j,qβ© | |
| refine Fin.cases ?_ (fun q => ?_) q | |
| Β· simpa only [productAffineChart_zero] using | |
| (contDiff_const : ContDiff β 1 (fun _ : Fin M β β => (1 : β))) | |
| Β· simpa only [productAffineChart_succ] using contDiff_apply β β (e β¨j,qβ©) | |
| variable {L : Type*} [Fintype L] [DecidableEq L] | |
| theorem bilinear_simple_point_count (a : ΞΉ ββ β) {M : β} | |
| (e : BlockAffineVariables a β Fin M) (u v : Fin M β ΞΉ) | |
| (F : Fin M β MvPolynomial (BlockVariables a) β) | |
| (hF : β i, (F i).IsWeightedHomogeneous | |
| (blockWeight (fun v : BlockVariables a => v.1)) | |
| (Pi.single (u i) 1 + Pi.single (v i) 1)) | |
| (x : L β Fin M β β) (hx : Function.Injective x) | |
| (hz : β i j, eval (productAffineChart a e (x i)) (F j) = 0) | |
| (hs : β i, (fderiv β (fun z j => eval (productAffineChart a e z) (F j)) | |
| (x i)).IsInvertible) : | |
| Fintype.card L β€ (mixedPolynomial u v).coeff a := by | |
| have hM : M = β j, a j := by | |
| have h := Fintype.card_congr e | |
| simpa only [BlockAffineVariables, Fintype.card_sigma, Fintype.card_fin] using h.symm | |
| exact bilinear_simple_point_count_chart a u v hM F hF (fun j => β¨j,0β©) (fun _ => rfl) | |
| (productAffineChart a e) (productAffineChart_contDiff a e) | |
| (productAffineChart_injective a e) (productAffineChart_zero a e) x hx hz hs | |
| end ProductAffineChart | |
| end PermanentBorder.Multigraded | |
| namespace PermanentBorder.Multigraded | |
| open MvPolynomial | |
| section ProjectiveInterpolation | |
| variable {K Ο ΞΉ L : Type*} [Field K] [Fintype ΞΉ] [DecidableEq ΞΉ] | |
| def BlockSeparated (group : Ο β ΞΉ) (x y : Ο β K) : Prop := | |
| β v w, group v = group w β§ x v * y w β x w * y v | |
| omit [Fintype ΞΉ] in | |
| lemma projective_pair_separator (group : Ο β ΞΉ) (x y : Ο β K) | |
| (hxy : BlockSeparated group x y) : | |
| β (p : MvPolynomial Ο K) (e : ΞΉ β β€), | |
| p.IsWeightedHomogeneous (blockWeight group) e β§ | |
| (β j, 0 β€ e j β§ e j β€ 1) β§ eval x p = 1 β§ eval y p = 0 := by | |
| classical | |
| obtain β¨v,w,hvw,hxyβ© := hxy | |
| let p : MvPolynomial Ο K := C ((x v * y w - x w * y v)β»ΒΉ) * | |
| (C (y w) * X v - C (y v) * X w) | |
| refine β¨p, Pi.single (group v) 1, ?_, ?_, ?_, ?_β© | |
| Β· apply IsWeightedHomogeneous.C_mul | |
| apply IsWeightedHomogeneous.sub | |
| Β· exact (isWeightedHomogeneous_X K (blockWeight group) v).C_mul _ | |
| Β· simpa only [blockWeight, hvw] using | |
| (isWeightedHomogeneous_X K (blockWeight group) w).C_mul (y v) | |
| Β· intro j; by_cases h : j = group v <;> simp [h] | |
| Β· simp only [p, map_mul, eval_C, map_sub, eval_X] | |
| rw [mul_comm (y w), mul_comm (y v), inv_mul_cancelβ (sub_ne_zero.mpr hxy)] | |
| Β· simp [p, mul_comm] | |
| variable [Fintype L] [DecidableEq L] | |
| theorem projective_interpolation (group : Ο β ΞΉ) (d : ΞΉ β β€) | |
| (hd : β j, (Fintype.card L : β€) β€ d j) | |
| (x : L β Ο β K) (hx : β i j, i β j β BlockSeparated group (x i) (x j)) | |
| (base : L β ΞΉ β Ο) (hbase : β i j, group (base i j) = j) | |
| (hb : β i j, x i (base i j) β 0) : | |
| β p : L β Piece (K := K) (blockWeight group) d, | |
| β i j, eval (x j) (p i).val = if j = i then 1 else 0 := by | |
| classical | |
| have hs (i j : L) : β (p : MvPolynomial Ο K) (e : ΞΉ β β€), | |
| p.IsWeightedHomogeneous (blockWeight group) e β§ | |
| (β l, 0 β€ e l β§ e l β€ 1) β§ eval (x i) p = 1 β§ (i β j β eval (x j) p = 0) := by | |
| by_cases hij : i = j | |
| Β· refine β¨1,0,isWeightedHomogeneous_one _ _,?_,by simp,?_β© | |
| Β· intro l; simp | |
| Β· exact fun h => (h hij).elim | |
| Β· obtain β¨p,e,hp,he,hi,hjβ© := projective_pair_separator group (x i) (x j) (hx i j hij) | |
| exact β¨p,e,hp,he,hi,fun _ => hjβ© | |
| choose p e hp he hi hj using hs | |
| let E : L β ΞΉ β β€ := fun i => β j, e i j | |
| have hE (i : L) (l : ΞΉ) : E i l β€ Fintype.card L := by | |
| dsimp [E] | |
| simpa using Finset.sum_le_sum (fun j (_ : j β Finset.univ) => (he i j l).2) | |
| let b : L β ΞΉ β β := fun i l => (d l - E i l).toNat | |
| have hbdeg (i : L) : (fun l => (b i l : β€)) = d-E i := by | |
| funext l | |
| exact Int.toNat_of_nonneg (sub_nonneg.mpr ((hE i l).trans (hd l))) | |
| let pad : L β MvPolynomial Ο K := fun i => | |
| β l, (C ((x i (base i l))β»ΒΉ) * X (base i l)) ^ b i l | |
| have hpadhom (i : L) : (pad i).IsWeightedHomogeneous (blockWeight group) (d - E i) := by | |
| rw [β hbdeg] | |
| have h := IsWeightedHomogeneous.prod Finset.univ | |
| (fun l => (C ((x i (base i l))β»ΒΉ) * X (base i l) : MvPolynomial Ο K)^b i l) | |
| (fun l => b i l β’ Pi.single l (1 : β€)) (fun l _ => by | |
| convert ((isWeightedHomogeneous_X K (blockWeight group) (base i l)).C_mul | |
| ((x i (base i l))β»ΒΉ)).pow (b i l) using 1 | |
| simp only [blockWeight, hbase]) | |
| convert h using 1 | |
| ext l | |
| simp [Pi.single_apply] | |
| have hpadeval (i : L) : eval (x i) (pad i) = 1 := by | |
| simp [pad, inv_mul_cancelβ (hb i _)] | |
| let P : L β MvPolynomial Ο K := fun i => (β j, p i j) * pad i | |
| have hPhom (i : L) : (P i).IsWeightedHomogeneous (blockWeight group) d := by | |
| have hp' := IsWeightedHomogeneous.prod Finset.univ (p i) (e i) (fun j _ => hp i j) | |
| have h := hp'.mul (hpadhom i) | |
| have hdeg : (β j, e i j) + (d - E i) = d := by dsimp [E]; abel | |
| rw [hdeg] at h | |
| exact h | |
| refine β¨fun i => β¨P i,hPhom iβ©,?_β© | |
| intro i j | |
| change eval (x j) (P i) = _ | |
| simp only [P, map_mul, map_prod] | |
| by_cases hij : j = i | |
| Β· subst j | |
| simp [hi, hpadeval] | |
| Β· rw [ite_eq_right hij, Finset.prod_eq_zero (Finset.mem_univ j) (hj i j (Ne.symm hij)), zero_mul] | |
| end ProjectiveInterpolation | |
| end PermanentBorder.Multigraded | |
| namespace PermanentBorder.Multigraded | |
| open MvPolynomial | |
| section ProjectivePointBound | |
| variable {K Ο ΞΉ L : Type*} [Field K] [Fintype Ο] [Fintype ΞΉ] [DecidableEq ΞΉ] | |
| [Fintype L] [DecidableEq L] | |
| theorem projective_points_le_pieceDim (group : Ο β ΞΉ) (base : L β ΞΉ β Ο) | |
| (hbase : β i j, group (base i j) = j) (I : Ideal (MvPolynomial Ο K)) | |
| (d : ΞΉ β β€) (hd : β j, (Fintype.card L : β€) β€ d j) | |
| (x : L β Ο β K) (hx : β i j, i β j β BlockSeparated group (x i) (x j)) | |
| (hb : β i j, x i (base i j) β 0) | |
| (hz : β i, β p β I, eval (x i) p = 0) : | |
| Fintype.card L β€ Module.finrank K (componentQuotient (blockWeight group) I d) := by | |
| classical | |
| let P := Piece (K := K) (blockWeight group) d | |
| let S : Submodule K P := (I.restrictScalars K).comap P.subtype | |
| let ev : P ββ[K] (L β K) := LinearMap.pi fun i => | |
| (aeval (x i)).toLinearMap.comp P.subtype | |
| have heval (p : P) (i : L) : ev p i = eval (x i) p.val := by | |
| simp [ev] | |
| have hker : S β€ LinearMap.ker ev := by | |
| intro p hp | |
| apply LinearMap.mem_ker.mpr | |
| funext i | |
| rw [heval] | |
| exact hz i p.val hp | |
| let qev := S.liftQ ev hker | |
| obtain β¨p,hpβ© := projective_interpolation group d hd x hx base hbase hb | |
| have hs : Function.Surjective qev := by | |
| intro y | |
| refine β¨S.mkQ (β i, y i β’ p i), ?_β© | |
| change ev (β i, y i β’ p i) = y | |
| apply _root_.funext | |
| intro j | |
| have hei (i : L) : ev (p i) j = if j = i then 1 else 0 := | |
| (heval (p i) j).trans (hp i j) | |
| calc | |
| ev (β i, y i β’ p i) j = β i, y i * ev (p i) j := by simp | |
| _ = y j := by simp [hei] | |
| have h := LinearMap.finrank_le_finrank_of_surjective hs | |
| simpa only [Module.finrank_pi, Module.finrank_self, Finset.sum_const, Finset.card_univ, | |
| smul_eq_mul, mul_one] using h | |
| end ProjectivePointBound | |
| end PermanentBorder.Multigraded | |
| namespace PermanentBorder.Multigraded | |
| open MvPolynomial Filter | |
| open scoped Topology | |
| section MultiChartProductCount | |
| variable {ΞΉ L V : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] [Fintype L] [DecidableEq L] | |
| [NormedAddCommGroup V] [NormedSpace β V] [CompleteSpace V] | |
| omit [Fintype ΞΉ] [DecidableEq ΞΉ] in | |
| lemma eventually_blockSeparated {Ο : Type*} (group : Ο β ΞΉ) | |
| (x : L β Ο β β) (hx : β i j, i β j β BlockSeparated group (x i) (x j)) | |
| {y : L β β β Ο β β} {c : β} | |
| (hy : β i, Tendsto (y i) (π c) (π (x i))) : | |
| βαΆ c' in π c, β i j, i β j β BlockSeparated group (y i c') (y j c') := by | |
| classical | |
| apply Filter.eventually_all.mpr | |
| intro i | |
| apply Filter.eventually_all.mpr | |
| intro j | |
| by_cases hij : i = j | |
| Β· exact Filter.Eventually.of_forall (fun _ h => (h hij).elim) | |
| obtain β¨v,w,hvw,hnβ© := hx i j hij | |
| have hvβ := (continuous_apply v).tendsto (x i) |>.comp (hy i) | |
| have hwβ := (continuous_apply w).tendsto (x i) |>.comp (hy i) | |
| have hvβ := (continuous_apply v).tendsto (x j) |>.comp (hy j) | |
| have hwβ := (continuous_apply w).tendsto (x j) |>.comp (hy j) | |
| have he := ((hvβ.mul hwβ).sub (hwβ.mul hvβ)).eventually_ne (sub_ne_zero.mpr hn) | |
| exact he.mono (fun c' hc' _ => β¨v,w,hvw,sub_ne_zero.mp hc'β©) | |
| theorem product_simple_point_bound_multichart (a : ΞΉ ββ β) | |
| (qs : List (FactorPair (K := β) (blockWeight (fun v : BlockVariables a => v.1)))) | |
| (u v : Fin qs.length β ΞΉ) (t : (Fin qs.length Γ Bool) β β) | |
| (ht : Function.Injective t) | |
| (hleft : β i, (qs.get i).left = blockLinearForm a (u i) (t (i,false))) | |
| (hright : β i, (qs.get i).right = blockLinearForm a (v i) (t (i,true))) | |
| (hdeg : β q β qs, β j, q.leftDegree j β€ 1) | |
| (hlen : qs.length = β j, a j) | |
| (F : Fin qs.length β MvPolynomial (BlockVariables a) β) | |
| (hF : β i, (F i).IsWeightedHomogeneous | |
| (blockWeight (fun v : BlockVariables a => v.1)) | |
| ((qs.get i).leftDegree + (qs.get i).rightDegree)) | |
| (base : L β ΞΉ β BlockVariables a) (hbase : β i j, (base i j).1 = j) | |
| (e : L β (Fin qs.length β β) βL[β] V) | |
| (chart : L β V β BlockVariables a β β) (hc : β i, ContDiff β 1 (chart i)) | |
| (hcn : β i z j, chart i z (base i j) = 1) | |
| (x : L β V) | |
| (hx : β i j, i β j β BlockSeparated (fun v : BlockVariables a => v.1) | |
| (chart i (x i)) (chart j (x j))) | |
| (hz : β i j, eval (chart i (x i)) (F j) = 0) | |
| (hs : β i, (fderiv β (fun z => e i (fun j => eval (chart i z) (F j))) | |
| (x i)).IsInvertible) : | |
| Fintype.card L β€ (mixedPolynomial u v).coeff a := by | |
| classical | |
| let Q : Fin qs.length β MvPolynomial (BlockVariables a) β := | |
| fun j => (qs.get j).left * (qs.get j).right | |
| let family : L β β Γ V β V := fun i z => e i | |
| (fun j => (1-z.1) * eval (chart i z.2) (Q j) + z.1 * eval (chart i z.2) (F j)) | |
| have hcont (i : L) : ContDiff β 1 (family i) := by | |
| apply (e i).contDiff.comp | |
| apply contDiff_pi.mpr | |
| intro j | |
| exact ((contDiff_const.sub contDiff_fst).mul | |
| ((PolarAnalysis.contDiff_mvPolynomial_eval (Q j)).comp ((hc i).comp contDiff_snd))).add | |
| (contDiff_fst.mul | |
| ((PolarAnalysis.contDiff_mvPolynomial_eval (F j)).comp ((hc i).comp contDiff_snd))) | |
| have hone (i : L) : (fun z => family i (1,z)) = | |
| (fun z => e i (fun j => eval (chart i z) (F j))) := by | |
| funext z | |
| simp [family] | |
| have hzero (i : L) : family i (1,x i) = 0 := by | |
| rw [congrFun (hone i)] | |
| rw [show (fun j => eval (chart i (x i)) (F j)) = 0 from funext (hz i), map_zero] | |
| have hsimple (i : L) : PolarAnalysis.SimpleAt (family i) 1 (x i) := by | |
| unfold PolarAnalysis.SimpleAt | |
| rw [β PolarAnalysis.fderiv_slice (hcont i), hone] | |
| exact hs i | |
| choose Ο hΟ hzΟ using fun i => PolarAnalysis.simple_branch (hcont i) (hzero i) (hsimple i) | |
| have hsep := eventually_blockSeparated (fun v : BlockVariables a => v.1) | |
| (fun i => chart i (x i)) hx (fun i => (hc i).continuous.continuousAt.tendsto.comp (hΟ i)) | |
| have hpersist : βαΆ c in π (1 : β), | |
| (β i, family i (c,Ο i c) = 0) β§ | |
| β i j, i β j β BlockSeparated (fun v : BlockVariables a => v.1) | |
| (chart i (Ο i c)) (chart j (Ο j c)) := by | |
| filter_upwards [Filter.eventually_all.mpr hzΟ, hsep] with c hz hc | |
| exact β¨fun i => (hz i).1,hcβ© | |
| let d : ΞΉ β β€ := fun _ => qs.length + Fintype.card L + 1 | |
| obtain β¨p,hp,hboundβ© := generic_product_piece_bound a qs u v t ht hleft hright hdeg | |
| hlen F hF d (by intro j; dsimp [d]; omega) | |
| have hpne : p β 0 := by | |
| intro h | |
| rw [h, Polynomial.eval_zero] at hp | |
| exact zero_ne_one hp | |
| have hdense : Dense {c : β | p.eval c β 0} := | |
| (Polynomial.finite_setOfPred_isRoot hpne).countable.dense_compl β | |
| obtain β¨c,hpc,hyz,hyβ© := hdense.inter_nhds_nonempty hpersist | |
| let I := Ideal.span (Set.range (fun j => (1-c) β’ Q j + c β’ F j)) | |
| have hyideal (i : L) : β p β I, eval (chart i (Ο i c)) p = 0 := by | |
| have hI : I β€ RingHom.ker (eval (chart i (Ο i c))) := by | |
| apply Ideal.span_le.mpr | |
| rintro p β¨j,rflβ© | |
| change eval (chart i (Ο i c)) ((1-c) β’ Q j + c β’ F j) = 0 | |
| have h := (e i).injective ((hyz i).trans (map_zero (e i)).symm) | |
| have h := congrFun h j | |
| simpa only [map_add, smul_eval, Pi.zero_apply] using h | |
| exact fun p hp => hI hp | |
| have hpoints := projective_points_le_pieceDim (fun v : BlockVariables a => v.1) | |
| base hbase I d (by intro j; dsimp [d]; omega) (fun i => chart i (Ο i c)) hy | |
| (fun i j => by rw [hcn]; exact one_ne_zero) hyideal | |
| exact hpoints.trans (hbound c hpc) | |
| end MultiChartProductCount | |
| end PermanentBorder.Multigraded | |
| namespace PermanentBorder.Multigraded | |
| open MvPolynomial | |
| section BilinearMultiChartCount | |
| variable {ΞΉ L V : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] [Fintype L] [DecidableEq L] | |
| [NormedAddCommGroup V] [NormedSpace β V] [CompleteSpace V] | |
| theorem bilinear_simple_point_count_multichart (a : ΞΉ ββ β) {M : β} | |
| (u v : Fin M β ΞΉ) (hM : M = β j, a j) | |
| (F : Fin M β MvPolynomial (BlockVariables a) β) | |
| (hF : β i, (F i).IsWeightedHomogeneous | |
| (blockWeight (fun v : BlockVariables a => v.1)) | |
| (Pi.single (u i) 1 + Pi.single (v i) 1)) | |
| (base : L β ΞΉ β BlockVariables a) (hbase : β i j, (base i j).1 = j) | |
| (e : L β (Fin M β β) βL[β] V) | |
| (chart : L β V β BlockVariables a β β) (hc : β i, ContDiff β 1 (chart i)) | |
| (hcn : β i z j, chart i z (base i j) = 1) | |
| (x : L β V) | |
| (hx : β i j, i β j β BlockSeparated (fun v : BlockVariables a => v.1) | |
| (chart i (x i)) (chart j (x j))) | |
| (hz : β i j, eval (chart i (x i)) (F j) = 0) | |
| (hs : β i, (fderiv β (fun z => e i (fun j => eval (chart i z) (F j))) | |
| (x i)).IsInvertible) : | |
| Fintype.card L β€ (mixedPolynomial u v).coeff a := by | |
| classical | |
| let t : (Fin M Γ Bool) β β := fun i => | |
| Infinite.natEmbedding β ((Fintype.equivFin (Fin M Γ Bool) i).val) | |
| have ht : Function.Injective t := | |
| (Infinite.natEmbedding β).injective.comp | |
| (Fin.val_injective.comp (Fintype.equivFin (Fin M Γ Bool)).injective) | |
| generalize hqs : List.ofFn (vandermondePairs a u v t) = qs | |
| have hlen : qs.length = M := by rw [β hqs, List.length_ofFn] | |
| cases hlen | |
| have hget (i : Fin qs.length) : qs.get i = vandermondePairs a u v t i := by | |
| have h := congrArg (fun l => l[i.val]?) hqs | |
| simpa only [List.getElem?_ofFn, dite_eq_left i.isLt, List.getElem?_eq_getElem i.isLt, | |
| Option.some.injEq, List.get_eq_getElem] using h.symm | |
| apply product_simple_point_bound_multichart a qs u v t ht | |
| (fun i => by rw [hget]; rfl) (fun i => by rw [hget]; rfl) ?_ hM F | |
| (by intro i; simpa only [hget, vandermondePairs] using hF i) | |
| base hbase e chart hc hcn x hx hz hs | |
| intro q hq j | |
| rw [β hqs] at hq | |
| obtain β¨i,rflβ© := List.mem_ofFn.mp hq | |
| by_cases hj : j = u i <;> simp [vandermondePairs, hj] | |
| end BilinearMultiChartCount | |
| end PermanentBorder.Multigraded | |
| end OAI | |