Download data/lean/OAI/AlgebraicGeometry/PlaneCurves/Forms.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PlaneCurves/Forms.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/PlaneCurves/Forms.lean
-
curl -L -o Forms.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PlaneCurves/Forms.lean
17.7 kB
| import Mathlib.Algebra.CharZero.Infinite | |
| import Mathlib.Algebra.Polynomial.BigOperators | |
| import Mathlib.Data.Fintype.Perm | |
| import Mathlib.Tactic.FinCases | |
| import OAI.AlgebraicGeometry.PlaneCurves.PolynomialAvoidance | |
| namespace OAI | |
| /-! | |
| # Homogeneous polynomial forms and dehomogenization | |
| -/ | |
| section | |
| /-! | |
| # Nonzero homogeneous plane forms and products | |
| The polynomial part of the permutation-product and common-multiple | |
| constructions in manuscript Β§1, Lemma `lem:universal`. | |
| -/ | |
| noncomputable section | |
| namespace Nagata.W16 | |
| abbrev PlanePolynomial := MvPolynomial (Fin 3) β | |
| /-- Homogeneous scaling after an arbitrary coefficient-ring map. This version | |
| also applies to evaluations in localizations of affine coordinate rings. -/ | |
| theorem homogeneous_evalβ_scale {Ο K R : Type*} [CommSemiring K] [CommSemiring R] | |
| {F : MvPolynomial Ο K} {d : β} (hF : F.IsHomogeneous d) | |
| (k : K β+* R) (x : Ο β R) (a : R) : | |
| MvPolynomial.evalβ k (fun i => a * x i) F = | |
| a ^ d * MvPolynomial.evalβ k x F := by | |
| classical | |
| simp only [MvPolynomial.evalβ_eq, Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro u hu | |
| simp only [mul_pow, Finset.prod_mul_distrib, Finset.prod_pow_eq_pow_sum] | |
| rw [β hF.degree_eq_sum_deg_support hu] | |
| ac_rfl | |
| /-- Homogeneity gives the representative scaling law needed to descend a | |
| homogeneous zero locus from nonzero vectors to projective points. -/ | |
| theorem homogeneous_eval_scale {Ο K : Type*} [CommSemiring K] | |
| {F : MvPolynomial Ο K} {d : β} (hF : F.IsHomogeneous d) | |
| (x : Ο β K) (a : K) : | |
| MvPolynomial.eval (fun i => a * x i) F = a ^ d * MvPolynomial.eval x F := by | |
| classical | |
| simp only [MvPolynomial.eval_eq, Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro u hu | |
| simp only [mul_pow, Finset.prod_mul_distrib, Finset.prod_pow_eq_pow_sum] | |
| rw [β hF.degree_eq_sum_deg_support hu] | |
| ac_rfl | |
| /-- Vanishing of a homogeneous equation is invariant under nonzero rescaling | |
| of its representative. -/ | |
| theorem homogeneous_eval_scale_eq_zero_iff {Ο K : Type*} [CommRing K] | |
| [IsDomain K] {F : MvPolynomial Ο K} {d : β} | |
| (hF : F.IsHomogeneous d) (x : Ο β K) {a : K} (ha : a β 0) : | |
| MvPolynomial.eval (fun i => a * x i) F = 0 β MvPolynomial.eval x F = 0 := by | |
| rw [homogeneous_eval_scale hF x a] | |
| simp only [mul_eq_zero, pow_ne_zero d ha, false_or] | |
| /-- A nonzero degree-`d` homogeneous ternary complex polynomial. Nonreduced | |
| and reducible equations are allowed. -/ | |
| structure NonzeroHomogeneousForm (d : β) where | |
| polynomial : PlanePolynomial | |
| homogeneous : polynomial.IsHomogeneous d | |
| nonzero : polynomial β 0 | |
| namespace NonzeroHomogeneousForm | |
| theorem totalDegree_eq {d : β} (F : NonzeroHomogeneousForm d) : | |
| F.polynomial.totalDegree = d := | |
| F.homogeneous.totalDegree F.nonzero | |
| /-- A nonzero equation over `β` cannot vanish at every affine vector. -/ | |
| theorem exists_eval_ne_zero {d : β} (F : NonzeroHomogeneousForm d) : | |
| β x : Fin 3 β β, MvPolynomial.eval x F.polynomial β 0 := by | |
| classical | |
| by_contra h | |
| apply F.nonzero | |
| apply F.homogeneous.eq_zero_of_forall_eval_eq_zero | |
| intro x | |
| by_contra hx | |
| exact h β¨x, hxβ© | |
| /-- Positive-degree homogeneous equations vanish at the zero vector. -/ | |
| theorem eval_zero_of_degree_pos {d : β} (F : NonzeroHomogeneousForm d) | |
| (hd : 0 < d) : MvPolynomial.eval (0 : Fin 3 β β) F.polynomial = 0 := by | |
| have h := homogeneous_eval_scale F.homogeneous (0 : Fin 3 β β) (0 : β) | |
| simpa [hd.ne'] using h | |
| /-- A positive-degree nonzero equation has a nonzero vector outside its zero | |
| locus, providing the representative needed for projective properness. -/ | |
| theorem exists_nonzero_vector_eval_ne_zero {d : β} | |
| (F : NonzeroHomogeneousForm d) (hd : 0 < d) : | |
| β x : Fin 3 β β, x β 0 β§ MvPolynomial.eval x F.polynomial β 0 := by | |
| obtain β¨x, hxβ© := F.exists_eval_ne_zero | |
| refine β¨x, ?_, hxβ© | |
| intro hxzero | |
| subst x | |
| exact hx (F.eval_zero_of_degree_pos hd) | |
| /-- Multiplying equations adds degrees and preserves nonzeroness. -/ | |
| def mul {d e : β} (F : NonzeroHomogeneousForm d) | |
| (G : NonzeroHomogeneousForm e) : NonzeroHomogeneousForm (d + e) where | |
| polynomial := F.polynomial * G.polynomial | |
| homogeneous := F.homogeneous.mul G.homogeneous | |
| nonzero := mul_ne_zero F.nonzero G.nonzero | |
| /-- Taking a power multiplies the degree, including the zeroth power. -/ | |
| def pow {d : β} (F : NonzeroHomogeneousForm d) (N : β) : | |
| NonzeroHomogeneousForm (d * N) where | |
| polynomial := F.polynomial ^ N | |
| homogeneous := F.homogeneous.pow N | |
| nonzero := pow_ne_zero N F.nonzero | |
| theorem mul_totalDegree {d e : β} (F : NonzeroHomogeneousForm d) | |
| (G : NonzeroHomogeneousForm e) : | |
| (F.polynomial * G.polynomial).totalDegree = d + e := | |
| (F.mul G).totalDegree_eq | |
| theorem pow_totalDegree {d : β} (F : NonzeroHomogeneousForm d) (N : β) : | |
| (F.polynomial ^ N).totalDegree = d * N := | |
| (F.pow N).totalDegree_eq | |
| end NonzeroHomogeneousForm | |
| open scoped BigOperators | |
| /-- A finite product of nonzero forms has the sum of the prescribed degrees. | |
| The finite set may be empty, in which case the product is the constant one. -/ | |
| theorem finite_product_forms {ΞΉ : Type*} (s : Finset ΞΉ) | |
| (F : ΞΉ β PlanePolynomial) (d : ΞΉ β β) | |
| (hhom : β i β s, (F i).IsHomogeneous (d i)) | |
| (hne : β i β s, F i β 0) : | |
| (β i β s, F i) β 0 β§ | |
| (β i β s, F i).IsHomogeneous (β i β s, d i) β§ | |
| (β i β s, F i).totalDegree = β i β s, d i := by | |
| classical | |
| have hp : (β i β s, F i) β 0 := Finset.prod_ne_zero_iff.mpr hne | |
| have hh := MvPolynomial.IsHomogeneous.prod s F d hhom | |
| exact β¨hp, hh, hh.totalDegree hpβ© | |
| /-- Equal-degree product formula needed for the permutation product. -/ | |
| theorem finite_product_equal_degree {ΞΉ : Type*} (s : Finset ΞΉ) | |
| (F : ΞΉ β PlanePolynomial) (d : β) | |
| (hhom : β i β s, (F i).IsHomogeneous d) | |
| (hne : β i β s, F i β 0) : | |
| (β i β s, F i) β 0 β§ | |
| (β i β s, F i).totalDegree = s.card * d := by | |
| have h := finite_product_forms s F (fun _ => d) hhom hne | |
| exact β¨h.1, by simpa using h.2.2β© | |
| /-- The permutation product in Β§1 is a nonzero equation of degree `r! * d`. | |
| Each factor can be chosen independently; no symmetry of its coefficients is | |
| required. -/ | |
| theorem permutation_product_degree (r d : β) | |
| (F : Equiv.Perm (Fin r) β PlanePolynomial) | |
| (hhom : β Ο, (F Ο).IsHomogeneous d) (hne : β Ο, F Ο β 0) : | |
| (β Ο, F Ο) β 0 β§ | |
| (β Ο, F Ο).totalDegree = Nat.factorial r * d := by | |
| classical | |
| simpa [Fintype.card_perm] using | |
| finite_product_equal_degree Finset.univ F d (fun Ο _ => hhom Ο) | |
| (fun Ο _ => hne Ο) | |
| end Nagata.W16 | |
| end | |
| end | |
| section | |
| /-! Binary homogeneous equations on `[U:Z]`, restricted to `Z=1`. -/ | |
| noncomputable section | |
| namespace Nagata.W16 | |
| open scoped BigOperators | |
| def binaryAffine (F : MvPolynomial (Fin 2) β) : Polynomial β := | |
| MvPolynomial.evalβ Polynomial.C (fun i => if i = 0 then Polynomial.X else 1) F | |
| theorem binaryAffine_eq_sum (F : MvPolynomial (Fin 2) β) : | |
| binaryAffine F = β u β F.support, Polynomial.C (F.coeff u) * Polynomial.X ^ u 0 := by | |
| classical | |
| rw [binaryAffine, MvPolynomial.evalβ_eq'] | |
| apply Finset.sum_congr rfl | |
| intro u _ | |
| simp | |
| theorem binaryAffine_eval (F : MvPolynomial (Fin 2) β) (z : β) : | |
| (binaryAffine F).eval z = MvPolynomial.eval (fun i : Fin 2 => if i = 0 then z else 1) F := by | |
| classical | |
| simp [binaryAffine_eq_sum, MvPolynomial.eval_eq', Polynomial.eval_finsetSum] | |
| theorem binaryAffine_normalized {F : MvPolynomial (Fin 2) β} {d : β} | |
| (hF : F.IsHomogeneous d) (x : Fin 2 β β) (hc : x 1 β 0) : | |
| (binaryAffine F).eval (x 0 / x 1) = (x 1)β»ΒΉ ^ d * MvPolynomial.eval x F := by | |
| rw [binaryAffine_eval] | |
| have hcoords : (fun i : Fin 2 => if i = 0 then x 0 / x 1 else 1) = | |
| fun i => (x 1)β»ΒΉ * x i := by | |
| funext i | |
| fin_cases i <;> simp [hc, div_eq_mul_inv, mul_comm] | |
| rw [hcoords] | |
| exact homogeneous_eval_scale hF x (x 1)β»ΒΉ | |
| theorem binaryAffine_eq_zero_imp {F : MvPolynomial (Fin 2) β} {d : β} | |
| (hF : F.IsHomogeneous d) (hf : binaryAffine F = 0) : F = 0 := by | |
| have hmul : MvPolynomial.X 1 * F = 0 := by | |
| apply ((MvPolynomial.isHomogeneous_X β (1 : Fin 2)).mul hF).eq_zero_of_forall_eval_eq_zero | |
| intro x | |
| rw [MvPolynomial.eval_mul, MvPolynomial.eval_X] | |
| by_cases hc : x 1 = 0 | |
| Β· simp [hc] | |
| Β· have hval := binaryAffine_normalized hF x hc | |
| rw [hf, Polynomial.eval_zero] at hval | |
| have hz : MvPolynomial.eval x F = 0 := | |
| (mul_eq_zero.mp hval.symm).resolve_left (pow_ne_zero d (inv_ne_zero hc)) | |
| rw [hz, mul_zero] | |
| exact (mul_eq_zero.mp hmul).resolve_left (MvPolynomial.X_ne_zero 1) | |
| theorem binaryAffine_ne_zero {F : MvPolynomial (Fin 2) β} {d : β} | |
| (hF : F.IsHomogeneous d) (hf : F β 0) : binaryAffine F β 0 := by | |
| intro hz | |
| exact hf (binaryAffine_eq_zero_imp hF hz) | |
| theorem binaryAffine_natDegree_le {F : MvPolynomial (Fin 2) β} {d : β} | |
| (hF : F.IsHomogeneous d) : (binaryAffine F).natDegree β€ d := by | |
| classical | |
| rw [binaryAffine_eq_sum] | |
| apply Polynomial.natDegree_sum_le_of_forall_le | |
| intro u hu | |
| apply (Polynomial.natDegree_C_mul_X_pow_le (F.coeff u) (u 0)).trans | |
| rw [hF.degree_eq_sum_deg_support hu] | |
| by_cases hz : u 0 = 0 | |
| Β· simp [hz] | |
| Β· exact Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finsupp.mem_support_iff.mpr hz) | |
| end Nagata.W16 | |
| end | |
| end | |
| section | |
| /-! | |
| # Faithfulness of affine chart equations | |
| The fixed-degree homogeneous equation of a plane curve is determined by its | |
| restriction to any one ordinary projective affine chart. The proof uses | |
| polynomial function extensionality over the infinite field `β`; no analytic | |
| or scheme-theoretic density assertion is assumed. | |
| -/ | |
| namespace Nagata.W16 | |
| open Nagata.ProjectiveGeometry | |
| theorem eval_dehomogenize (c : Fin 3) (F : PlanePolynomial) | |
| (x : ChartVariables c β β) : | |
| MvPolynomial.eval x (dehomogenize c F) = | |
| MvPolynomial.eval (fun j => if h : j = c then 1 else x β¨j, hβ©) F := by | |
| classical | |
| unfold dehomogenize | |
| rw [β MvPolynomial.eval_assoc] | |
| apply congrArg (fun z : Fin 3 β β => MvPolynomial.eval z F) | |
| funext j | |
| by_cases h : j = c <;> simp [h, Function.comp_apply] | |
| /-- The affine chart evaluation formula has its exact homogeneous scaling | |
| factor, with no division performed at a zero chart coordinate. -/ | |
| theorem eval_dehomogenize_normalized {d : β} {F : PlanePolynomial} | |
| (hF : F.IsHomogeneous d) (c : Fin 3) (x : Fin 3 β β) (hc : x c β 0) : | |
| MvPolynomial.eval (fun j : ChartVariables c => x j.val / x c) | |
| (dehomogenize c F) = | |
| (x c)β»ΒΉ ^ d * MvPolynomial.eval x F := by | |
| classical | |
| rw [eval_dehomogenize] | |
| have hcoords : | |
| (fun j : Fin 3 => if h : j = c then (1 : β) else x j / x c) = | |
| fun j => (x c)β»ΒΉ * x j := by | |
| funext j | |
| by_cases h : j = c | |
| Β· subst j | |
| simp [hc] | |
| Β· simp [h, div_eq_mul_inv, mul_comm] | |
| rw [hcoords] | |
| exact homogeneous_eval_scale hF x (x c)β»ΒΉ | |
| theorem eval_eq_zero_of_dehomogenize_eq_zero {d : β} {F : PlanePolynomial} | |
| (hF : F.IsHomogeneous d) (c : Fin 3) (hchart : dehomogenize c F = 0) | |
| (x : Fin 3 β β) (hc : x c β 0) : MvPolynomial.eval x F = 0 := by | |
| have hz := congrArg | |
| (MvPolynomial.eval (fun j : ChartVariables c => x j.val / x c)) hchart | |
| rw [eval_dehomogenize_normalized hF c x hc, map_zero] at hz | |
| exact (mul_eq_zero.mp hz).resolve_left (pow_ne_zero d (inv_ne_zero hc)) | |
| /-- A homogeneous equation whose restriction to one affine chart is zero is | |
| the zero polynomial. Multiplication by the distinguished coordinate handles | |
| vectors on the omitted hyperplane. -/ | |
| theorem eq_zero_of_dehomogenize_eq_zero {d : β} {F : PlanePolynomial} | |
| (hF : F.IsHomogeneous d) (c : Fin 3) (hchart : dehomogenize c F = 0) : F = 0 := by | |
| have hmul : MvPolynomial.X c * F = 0 := by | |
| apply ((MvPolynomial.isHomogeneous_X β c).mul hF).eq_zero_of_forall_eval_eq_zero | |
| intro x | |
| rw [MvPolynomial.eval_mul, MvPolynomial.eval_X] | |
| by_cases hc : x c = 0 | |
| Β· simp [hc] | |
| Β· rw [eval_eq_zero_of_dehomogenize_eq_zero hF c hchart x hc, mul_zero] | |
| exact (mul_eq_zero.mp hmul).resolve_left (MvPolynomial.X_ne_zero c) | |
| theorem dehomogenize_ne_zero {d : β} {F : PlanePolynomial} | |
| (hF : F.IsHomogeneous d) (hne : F β 0) (c : Fin 3) : | |
| dehomogenize c F β 0 := by | |
| intro hz | |
| exact hne (eq_zero_of_dehomogenize_eq_zero hF c hz) | |
| /-- Affine restriction is injective on each fixed homogeneous degree. -/ | |
| theorem dehomogenize_injective_fixed_degree {d : β} {F G : PlanePolynomial} | |
| (hF : F.IsHomogeneous d) (hG : G.IsHomogeneous d) (c : Fin 3) | |
| (hchart : dehomogenize c F = dehomogenize c G) : F = G := by | |
| apply sub_eq_zero.mp | |
| apply eq_zero_of_dehomogenize_eq_zero (hF.sub hG) c | |
| change MvPolynomial.evalβHom (MvPolynomial.C : β β+* MvPolynomial (ChartVariables c) β) | |
| (fun j : Fin 3 => if h : j = c then 1 else MvPolynomial.X β¨j, hβ©) (F - G) = 0 | |
| rw [map_sub] | |
| exact sub_eq_zero.mpr hchart | |
| end Nagata.W16 | |
| end | |
| section | |
| /-! | |
| # Faithfulness of the simultaneous affine chart in a product of planes | |
| This is the multihomogeneous extension of single-plane dehomogenization. | |
| The affine chart uses exactly `Fin r Γ Fin 2` coordinates. In particular, | |
| no product-topology replacement for the product's Zariski geometry is used. | |
| -/ | |
| noncomputable section | |
| namespace Nagata.W16 | |
| open Nagata.ProjectiveGeometry | |
| open scoped BigOperators | |
| /-- Restrict every point block to `[1 : zβ : zβ]`. -/ | |
| def blockDehomogenize {r : β} (F : MultihomogeneousEquation r) : | |
| MvPolynomial (Fin r Γ Fin 2) β := | |
| MvPolynomial.evalβ MvPolynomial.C | |
| (fun ij => if ij.2 = 0 then 1 else | |
| if ij.2 = 1 then MvPolynomial.X (ij.1, 0) else MvPolynomial.X (ij.1, 1)) | |
| F.polynomial | |
| /-- Independent rescaling of the point blocks gives the multidegree factor. -/ | |
| theorem multihomogeneous_eval_scale {r : β} (F : MultihomogeneousEquation r) | |
| (x : Fin r Γ Fin 3 β β) (a : Fin r β β) : | |
| MvPolynomial.eval (fun ij => a ij.1 * x ij) F.polynomial = | |
| (β i, a i ^ F.multidegree i) * MvPolynomial.eval x F.polynomial := by | |
| classical | |
| simp only [MvPolynomial.eval_eq', Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro u hu | |
| simp only [mul_pow, Finset.prod_mul_distrib] | |
| have hdegrees : (β ij : Fin r Γ Fin 3, a ij.1 ^ u ij) = | |
| β i, a i ^ F.multidegree i := by | |
| rw [Fintype.prod_prod_type] | |
| apply Finset.prod_congr rfl | |
| intro i _ | |
| change (β y : Fin 3, a i ^ u (i, y)) = a i ^ F.multidegree i | |
| rw [Finset.prod_pow_eq_pow_sum, F.homogeneous u hu i] | |
| rw [hdegrees] | |
| ac_rfl | |
| theorem eval_blockDehomogenize {r : β} (F : MultihomogeneousEquation r) | |
| (x : Fin r Γ Fin 2 β β) : | |
| MvPolynomial.eval x (blockDehomogenize F) = | |
| MvPolynomial.eval | |
| (fun ij => affinePlaneVector (fun j => x (ij.1, j)) ij.2) F.polynomial := by | |
| classical | |
| unfold blockDehomogenize | |
| rw [β MvPolynomial.eval_assoc] | |
| apply congrArg (fun z : Fin r Γ Fin 3 β β => MvPolynomial.eval z F.polynomial) | |
| funext ij | |
| rcases ij with β¨i, jβ© | |
| fin_cases j <;> simp [affinePlaneVector, Function.comp_apply] | |
| theorem eval_blockDehomogenize_normalized {r : β} (F : MultihomogeneousEquation r) | |
| (x : Fin r Γ Fin 3 β β) (hc : β i, x (i, 0) β 0) : | |
| MvPolynomial.eval (fun ij : Fin r Γ Fin 2 => x (ij.1, ij.2.succ) / x (ij.1, 0)) | |
| (blockDehomogenize F) = | |
| (β i, (x (i, 0))β»ΒΉ ^ F.multidegree i) * MvPolynomial.eval x F.polynomial := by | |
| classical | |
| rw [eval_blockDehomogenize] | |
| have hcoords : | |
| (fun ij : Fin r Γ Fin 3 => | |
| affinePlaneVector (fun j => x (ij.1, j.succ) / x (ij.1, 0)) ij.2) = | |
| fun ij => (x (ij.1, 0))β»ΒΉ * x ij := by | |
| funext ij | |
| rcases ij with β¨i, jβ© | |
| fin_cases j <;> simp [affinePlaneVector, hc i, div_eq_mul_inv] <;> ac_rfl | |
| rw [hcoords] | |
| exact multihomogeneous_eval_scale F x (fun i => (x (i, 0))β»ΒΉ) | |
| /-- A zero simultaneous affine restriction forces the multihomogeneous | |
| polynomial itself to vanish. -/ | |
| theorem eq_zero_of_blockDehomogenize_eq_zero {r : β} | |
| (F : MultihomogeneousEquation r) (hchart : blockDehomogenize F = 0) : | |
| F.polynomial = 0 := by | |
| classical | |
| let Q : MvPolynomial (Fin r Γ Fin 3) β := β i : Fin r, MvPolynomial.X (i, 0) | |
| have hQ : Q β 0 := by | |
| apply Finset.prod_ne_zero_iff.mpr | |
| intro i _ | |
| exact MvPolynomial.X_ne_zero (i, 0) | |
| have hmul : Q * F.polynomial = 0 := by | |
| apply Nagata.Workers.W25.complex_polynomial_funext | |
| intro x | |
| rw [map_mul, map_zero] | |
| by_cases hc : β i : Fin r, x (i, 0) β 0 | |
| Β· have hz := congrArg | |
| (MvPolynomial.eval (fun ij : Fin r Γ Fin 2 => x (ij.1, ij.2.succ) / x (ij.1, 0))) | |
| hchart | |
| rw [eval_blockDehomogenize_normalized F x hc, map_zero] at hz | |
| have hn : (β i, (x (i, 0))β»ΒΉ ^ F.multidegree i) β 0 := by | |
| apply Finset.prod_ne_zero_iff.mpr | |
| intro i _ | |
| exact pow_ne_zero _ (inv_ne_zero (hc i)) | |
| rw [(mul_eq_zero.mp hz).resolve_left hn, mul_zero] | |
| Β· obtain β¨i, hiβ© := Classical.not_forall.mp hc | |
| have hi0 : x (i, 0) = 0 := Classical.not_not.mp hi | |
| have heval : MvPolynomial.eval x Q = β i : Fin r, x (i, 0) := by | |
| simp [Q] | |
| rw [heval, Finset.prod_eq_zero (Finset.mem_univ i) hi0, zero_mul] | |
| exact (mul_eq_zero.mp hmul).resolve_left hQ | |
| /-- Every nonzero multihomogeneous equation stays nonzero on the standard | |
| simultaneous affine chart. -/ | |
| theorem blockDehomogenize_ne_zero {r : β} (F : MultihomogeneousEquation r) | |
| (hne : F.polynomial β 0) : blockDehomogenize F β 0 := by | |
| intro hz | |
| exact hne (eq_zero_of_blockDehomogenize_eq_zero F hz) | |
| end Nagata.W16 | |
| end | |
| end | |
| end OAI | |