| 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 |
|
|
