| import OAI.AlgebraicGeometry.SurfaceCones.GradedCompletion |
| import OAI.AlgebraicGeometry.SurfaceCones.KummerCompletedBlowup |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| attribute [local instance] ExplicitCone.actualCompletion_noetherian |
| /-! Degree-one Noether normalization needed for the actual section cone. |
| The generators and all replacements are homogeneous of degree one. -/ |
| noncomputable section |
| open scoped BigOperators |
| namespace HomogeneousNoetherNormalization |
| variable {k L : Type} [Field k] [Field L] [Algebra k L] |
| open MvPolynomial |
|
|
| lemma cone_monomial {σ : Type} (v : σ → L) (e : σ →₀ ℕ) (c : k) : |
| MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) (MvPolynomial.monomial e c) = |
| Polynomial.monomial e.degree ((algebraMap k L c) * e.prod (fun i j => v i ^ j)) := by |
| classical |
| rw [MvPolynomial.aeval_monomial] |
| have hp : e.prod (fun i j => (Polynomial.monomial 1 (v i) : Polynomial L) ^ j) = |
| Polynomial.monomial e.degree (e.prod (fun i j => v i ^ j)) := by |
| simp only [← Polynomial.C_mul_X_pow_eq_monomial, pow_one, mul_pow, ← map_pow, |
| Finsupp.prod, Finset.prod_mul_distrib, ← map_prod, Finset.prod_pow_eq_pow_sum, |
| Finsupp.degree_apply, ← Polynomial.C_mul_X_pow_eq_monomial] |
| rw [hp, Polynomial.algebraMap_apply, Polynomial.C_mul_monomial] |
|
|
| lemma coeff_cone_aeval {σ : Type} (v : σ → L) (f : MvPolynomial σ k) (d : ℕ) : |
| (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) f).coeff d = |
| MvPolynomial.aeval v (homogeneousComponent d f) := by |
| classical |
| nth_rw 1 [f.as_sum] |
| rw [map_sum, Polynomial.finsetSum_coeff, homogeneousComponent_apply, |
| map_sum, Finset.sum_filter] |
| apply Finset.sum_congr rfl |
| intro e _ |
| rw [cone_monomial, Polynomial.coeff_monomial, MvPolynomial.aeval_monomial] |
|
|
| lemma homogeneous_relation {σ : Type} (v : σ → L) |
| (h : ¬ Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) : |
| MvPolynomial σ k →ₐ[k] Polynomial L)) : |
| ∃ (d : ℕ) (f : MvPolynomial σ k), f ≠ 0 ∧ f.IsHomogeneous d ∧ |
| MvPolynomial.aeval v f = 0 ∧ d > 0 := by |
| classical |
| have hex0 : ∃ g : MvPolynomial σ k, |
| MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) g = 0 ∧ g ≠ 0 := by |
| rw [Function.Injective] at h |
| push Not at h |
| obtain ⟨a, b, hab, hne⟩ := h |
| refine ⟨a - b, ?_, sub_ne_zero.mpr hne⟩ |
| simpa [map_sub] using sub_eq_zero.mpr hab |
| obtain ⟨g, hg, hgne⟩ := hex0 |
| have hc : ∀ d, MvPolynomial.aeval v (homogeneousComponent d g) = 0 := by |
| intro d |
| rw [← coeff_cone_aeval, hg] |
| simp |
| have hex : ∃ d, homogeneousComponent d g ≠ 0 := by |
| by_contra! hz |
| have hh := sum_homogeneousComponent g |
| simp only [hz, Finset.sum_const_zero] at hh |
| exact hgne hh.symm |
| obtain ⟨d, hd⟩ := hex |
| refine ⟨d, homogeneousComponent d g, hd, homogeneousComponent_isHomogeneous _ _, hc d, ?_⟩ |
| by_contra hn |
| have hd0 : d = 0 := by omega |
| subst d |
| simp only [homogeneousComponent_zero] at hd |
| have hh := hc 0 |
| simp only [homogeneousComponent_zero, MvPolynomial.aeval_C] at hh |
| have hz : g.coeff 0 = 0 := (algebraMap k L).injective (by simpa using hh) |
| exact hd (by simp [hz]) |
|
|
| lemma eval_scalar {σ : Type} {f : MvPolynomial σ k} {d : ℕ} |
| (hf : f.IsHomogeneous d) (a : σ → k) (s : k) : |
| MvPolynomial.eval (fun i => s * a i) f = s ^ d * MvPolynomial.eval a f := by |
| classical |
| rw [f.as_sum, map_sum, map_sum, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro e he |
| have hdeg := hf.degree_eq_sum_deg_support he |
| simp only [MvPolynomial.eval_monomial, mul_pow, Finsupp.prod, Finset.prod_mul_distrib, |
| Finset.prod_pow_eq_pow_sum] |
| rw [← hdeg] |
| ring |
|
|
| lemma exists_projective_nonvanishing {n d : ℕ} {f : MvPolynomial (Fin (n+1)) k} |
| [Infinite k] (hf : f.IsHomogeneous d) (hne : f ≠ 0) : |
| ∃ c : Fin n → k, MvPolynomial.eval (Fin.cases 1 c) f ≠ 0 := by |
| classical |
| have hp : f * MvPolynomial.X (0 : Fin (n+1)) ≠ 0 := mul_ne_zero hne (X_ne_zero _) |
| have hh := hf.mul (isHomogeneous_X k (0 : Fin (n+1))) |
| have hex : ∃ a : Fin (n+1) → k, MvPolynomial.eval a (f * MvPolynomial.X 0) ≠ 0 := by |
| by_contra! hz |
| exact hp (hh.eq_zero_of_forall_eval_eq_zero hz) |
| obtain ⟨a, ha⟩ := hex |
| simp only [map_mul, MvPolynomial.eval_X, mul_ne_zero_iff] at ha |
| refine ⟨fun i => (a 0)⁻¹ * a i.succ, ?_⟩ |
| have he : (fun i => (a 0)⁻¹ * a i) = Fin.cases 1 (fun i => (a 0)⁻¹ * a i.succ) := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp [ha.2] |
| · rfl |
| rw [← he, eval_scalar hf] |
| exact mul_ne_zero (pow_ne_zero _ (inv_ne_zero ha.2)) ha.1 |
|
|
| section AffineEvaluation |
| variable {S σ ι : Type} [CommRing S] [Algebra k S] |
|
|
| lemma coeff_prod_sum (s : Finset ι) (p : ι → Polynomial S) (d : ι → ℕ) |
| (h : ∀ i ∈ s, (p i).natDegree ≤ d i) : |
| (∏ i ∈ s, p i).coeff (∑ i ∈ s, d i) = ∏ i ∈ s, (p i).coeff (d i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert i s hi ih => |
| rw [Finset.prod_insert hi, Finset.sum_insert hi, Finset.prod_insert hi, |
| Polynomial.coeff_mul_add_eq_of_natDegree_le (h i (Finset.mem_insert_self _ _)) |
| ((Polynomial.natDegree_prod_le _ _).trans (Finset.sum_le_sum (fun j hj => |
| h j (Finset.mem_insert_of_mem hj)))), ih (fun j hj => h j (Finset.mem_insert_of_mem hj))] |
|
|
| lemma affine_degree (a b : σ → S) (i : σ) : |
| (Polynomial.C (b i) + Polynomial.C (a i) * Polynomial.X).natDegree ≤ 1 := by |
| apply Polynomial.natDegree_add_le_of_degree_le |
| · simp |
| · exact (Polynomial.natDegree_C_mul_le _ _).trans Polynomial.natDegree_X_le |
|
|
| lemma affine_aeval_degree {f : MvPolynomial σ k} {d : ℕ} |
| (hf : f.IsHomogeneous d) (a b : σ → S) : |
| (MvPolynomial.aeval (fun i => Polynomial.C (b i) + Polynomial.C (a i) * Polynomial.X) f).natDegree ≤ d := by |
| classical |
| rw [f.as_sum, map_sum] |
| apply Polynomial.natDegree_sum_le_of_forall_le |
| intro e he |
| rw [MvPolynomial.aeval_monomial, Polynomial.algebraMap_apply] |
| apply (Polynomial.natDegree_C_mul_le _ _).trans |
| change (∏ i ∈ e.support, |
| (Polynomial.C (b i) + Polynomial.C (a i) * Polynomial.X) ^ e i).natDegree ≤ d |
| apply (Polynomial.natDegree_prod_le _ _).trans |
| calc |
| _ ≤ ∑ i ∈ e.support, e i := Finset.sum_le_sum fun i _ => |
| (Polynomial.natDegree_pow_le).trans (by simpa using Nat.mul_le_mul_left (e i) (affine_degree a b i)) |
| _ = d := (hf.degree_eq_sum_deg_support he).symm |
|
|
| lemma affine_aeval_top_coeff {f : MvPolynomial σ k} {d : ℕ} |
| (hf : f.IsHomogeneous d) (a b : σ → S) : |
| (MvPolynomial.aeval (fun i => Polynomial.C (b i) + Polynomial.C (a i) * Polynomial.X) f).coeff d = |
| MvPolynomial.aeval a f := by |
| classical |
| rw [f.as_sum, map_sum, map_sum, Polynomial.finsetSum_coeff] |
| apply Finset.sum_congr rfl |
| intro e he |
| rw [MvPolynomial.aeval_monomial, MvPolynomial.aeval_monomial, Polynomial.algebraMap_apply, Polynomial.coeff_C_mul] |
| congr 1 |
| rw [hf.degree_eq_sum_deg_support he] |
| change (∏ i ∈ e.support, |
| (Polynomial.C (b i) + Polynomial.C (a i) * Polynomial.X) ^ e i).coeff |
| (∑ i ∈ e.support, e i) = ∏ i ∈ e.support, a i ^ e i |
| rw [coeff_prod_sum _ _ e (fun i _ => Polynomial.natDegree_pow_le.trans |
| (by simpa using Nat.mul_le_mul_left (e i) (affine_degree a b i)))] |
| apply Finset.prod_congr rfl |
| intro i _ |
| have hh := Polynomial.coeff_pow_of_natDegree_le (m := e i) (affine_degree a b i) |
| simpa using hh |
|
|
| end AffineEvaluation |
|
|
| section LinearChange |
| variable {A : Type} [CommRing A] [Algebra k A] |
|
|
| lemma integral_head_of_relation {n d : ℕ} {f : MvPolynomial (Fin (n+1)) k} |
| (hf : f.IsHomogeneous d) (x : Fin (n+1) → A) (hx : MvPolynomial.aeval x f = 0) |
| (c : Fin n → k) (hc : MvPolynomial.eval (Fin.cases 1 c) f ≠ 0) : |
| IsIntegral (Algebra.adjoin k (Set.range (fun i => x i.succ - algebraMap k A (c i) * x 0))) |
| (x 0) := by |
| classical |
| let B := Algebra.adjoin k (Set.range (fun i => x i.succ - algebraMap k A (c i) * x 0)) |
| let b : Fin n → B := fun i => ⟨_, Algebra.subset_adjoin ⟨i, rfl⟩⟩ |
| let a : Fin (n+1) → B := Fin.cases 1 (fun i => algebraMap k B (c i)) |
| let b' : Fin (n+1) → B := Fin.cases 0 b |
| let v : Fin (n+1) → Polynomial B := fun i => |
| Polynomial.C (b' i) + Polynomial.C (a i) * Polynomial.X |
| let q : Polynomial B := MvPolynomial.aeval v f |
| let t : k := MvPolynomial.eval (Fin.cases 1 c) f |
| have hdeg : q.natDegree ≤ d := affine_aeval_degree hf a b' |
| have htop : q.coeff d = algebraMap k B t := by |
| rw [affine_aeval_top_coeff hf] |
| have hh : (MvPolynomial.aeval a : MvPolynomial (Fin (n+1)) k →ₐ[k] B) = |
| (Algebra.ofId k B).comp (MvPolynomial.aeval (Fin.cases 1 c)) := by |
| ext i |
| refine Fin.cases ?_ (fun j => ?_) i <;> simp [a] |
| rw [hh] |
| simp [t] |
| let ev : Polynomial B →ₐ[k] A := (Polynomial.aeval (x 0)).restrictScalars k |
| have hev : (fun i => ev (v i)) = x := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp [ev, v, a, b'] |
| · simp [ev, v, a, b', b, B, sub_add_cancel] |
| have hroot : Polynomial.aeval (x 0) q = 0 := by |
| change ev (MvPolynomial.aeval v f) = 0 |
| rw [comp_aeval_apply, hev] |
| exact hx |
| refine ⟨Polynomial.C (algebraMap k B t⁻¹) * q, ?_, ?_⟩ |
| · apply Polynomial.monic_of_natDegree_le_of_coeff_eq_one d |
| · exact (Polynomial.natDegree_C_mul_le _ _).trans hdeg |
| · rw [Polynomial.coeff_C_mul, htop, ← map_mul, inv_mul_cancel₀ hc, map_one] |
| · change (Polynomial.aeval (x 0)) (Polynomial.C (algebraMap k B t⁻¹) * q) = 0 |
| rw [map_mul, hroot, mul_zero] |
| |
| end LinearChange |
| |
| lemma cone_aeval_homogeneous {σ : Type} {f : MvPolynomial σ k} {d : ℕ} |
| (hf : f.IsHomogeneous d) (v : σ → L) : |
| MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) f = Polynomial.monomial d (MvPolynomial.aeval v f) := by |
| apply Polynomial.ext |
| intro j |
| rw [coeff_cone_aeval, homogeneousComponent_of_mem hf, Polynomial.coeff_monomial] |
| by_cases h : j = d |
| · subst j |
| simp only [ite_true] |
| · rw [ite_eq_right h, ite_eq_right (Ne.symm h), map_zero] |
| |
| def cone {σ : Type} (v : σ → L) : Subalgebra k (Polynomial L) := |
| Algebra.adjoin k (Set.range (fun i => Polynomial.monomial 1 (v i))) |
| |
| lemma cone_gen_mem {σ : Type} (v : σ → L) (i : σ) : Polynomial.monomial 1 (v i) ∈ cone (k := k) v := |
| Algebra.subset_adjoin ⟨i, rfl⟩ |
| |
| lemma cone_shift_le {n : ℕ} (v : Fin (n+1) → L) (c : Fin n → k) : |
| cone (fun i => v i.succ - algebraMap k L (c i) * v 0) ≤ cone (k := k) v := by |
| apply Algebra.adjoin_le |
| rintro _ ⟨i, rfl⟩ |
| change Polynomial.monomial 1 (v i.succ - algebraMap k L (c i) * v 0) ∈ cone v |
| rw [map_sub, ← Polynomial.C_mul_monomial, ← Polynomial.algebraMap_apply] |
| exact (cone (k := k) v).sub_mem (cone_gen_mem v i.succ) |
| ((cone (k := k) v).mul_mem ((cone (k := k) v).algebraMap_mem (c i)) (cone_gen_mem v 0)) |
| |
| lemma cone_shift_integral {n d : ℕ} (v : Fin (n+1) → L) |
| {f : MvPolynomial (Fin (n+1)) k} (hf : f.IsHomogeneous d) (hv : MvPolynomial.aeval v f = 0) |
| (c : Fin n → k) (hc : MvPolynomial.eval (Fin.cases 1 c) f ≠ 0) : |
| (Subalgebra.inclusion (cone_shift_le v c)).IsIntegral := by |
| classical |
| let x : Fin (n+1) → Polynomial L := fun i => Polynomial.monomial 1 (v i) |
| let w : Fin n → L := fun i => v i.succ - algebraMap k L (c i) * v 0 |
| let B := cone (k := k) w |
| have hh : (Algebra.adjoin k (Set.range (fun i => x i.succ - algebraMap k (Polynomial L) (c i) * x 0))) = B := by |
| congr 2 |
| funext i |
| simp only [x, w, map_sub, Polynomial.algebraMap_apply, Polynomial.C_mul_monomial] |
| have hhead : IsIntegral B (x 0) := by |
| rw [← hh] |
| exact integral_head_of_relation hf x (by rw [cone_aeval_homogeneous hf, hv]; simp) c hc |
| have hgen (i : Fin (n+1)) : IsIntegral B (x i) := by |
| refine Fin.cases hhead (fun j => ?_) i |
| have hw : IsIntegral B (Polynomial.monomial 1 (w j)) := |
| isIntegral_algebraMap (x := (⟨_, cone_gen_mem w j⟩ : B)) |
| have hc' : IsIntegral B (algebraMap k (Polynomial L) (c j)) := |
| isIntegral_algebraMap (x := algebraMap k B (c j)) |
| have he : Polynomial.monomial 1 (w j) + algebraMap k (Polynomial L) (c j) * x 0 = x j.succ := by |
| simp only [w, x, map_sub, Polynomial.algebraMap_apply, Polynomial.C_mul_monomial, sub_add_cancel] |
| rw [← he] |
| exact hw.add (hc'.mul hhead) |
| have hle : cone (k := k) v ≤ (integralClosure B (Polynomial L)).restrictScalars k := |
| Algebra.adjoin_le (by rintro _ ⟨i, rfl⟩; exact hgen i) |
| intro z |
| exact RingHom.IsIntegralElem.of_map (g := (cone (k := k) v).val.toRingHom) |
| Subtype.val_injective (hle z.property) |
| |
| /-- Linear changes only: unlike ordinary normalization, the parameters stay |
| in degree one. The integral map is the literal inclusion into the input cone. -/ |
| theorem exists_linear_normalization [Infinite k] {n : ℕ} (v : Fin n → L) : |
| ∃ m ≤ n, ∃ w : Fin m → L, ∃ h : cone (k := k) w ≤ cone v, |
| Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (w i)) : |
| MvPolynomial (Fin m) k →ₐ[k] Polynomial L) ∧ |
| (Subalgebra.inclusion h).IsIntegral := by |
| induction n with |
| | zero => |
| refine ⟨0, le_rfl, v, le_rfl, ?_, ?_⟩ |
| · intro a b hab |
| rw [eq_C_of_isEmpty a, eq_C_of_isEmpty b] at hab ⊢ |
| exact congrArg MvPolynomial.C ((algebraMap k (Polynomial L)).injective (by simpa using hab)) |
| · exact RingHom.isIntegral_of_surjective _ (fun z => ⟨z, rfl⟩) |
| | succ n ih => |
| by_cases hinj : Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) : |
| MvPolynomial (Fin (n+1)) k →ₐ[k] Polynomial L) |
| · exact ⟨n+1, le_rfl, v, le_rfl, hinj, |
| RingHom.isIntegral_of_surjective _ (fun z => ⟨z, rfl⟩)⟩ |
| · obtain ⟨d, f, hne, hf, hv, _⟩ := homogeneous_relation v hinj |
| obtain ⟨c, hc⟩ := exists_projective_nonvanishing hf hne |
| obtain ⟨m, hmn, w, hw, hwinj, hwint⟩ := ih (fun i => v i.succ - algebraMap k L (c i) * v 0) |
| refine ⟨m, hmn.trans (Nat.le_succ n), w, hw.trans (cone_shift_le v c), hwinj, ?_⟩ |
| exact hwint.trans _ _ (cone_shift_integral v hf hv c hc) |
| |
| end HomogeneousNoetherNormalization |
| |
| namespace HomogeneousNoetherNormalization |
| variable {k L : Type} [Field k] [Field L] [Algebra k L] |
| open MvPolynomial |
| |
| def coneEval {σ : Type} (v : σ → L) : MvPolynomial σ k →ₐ[k] cone (k := k) v := |
| (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i))).codRestrict (cone v) |
| (fun f => by rw [cone, Algebra.adjoin_range_eq_range_aeval]; exact ⟨f, rfl⟩) |
| |
| lemma coneEval_surjective {σ : Type} (v : σ → L) : Function.Surjective (coneEval (k := k) v) := by |
| intro z |
| obtain ⟨f, hf⟩ : ∃ f : MvPolynomial σ k, MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) f = z.val := by |
| have hz := z.property |
| change z.val ∈ Algebra.adjoin k (Set.range (fun i => Polynomial.monomial 1 (v i))) at hz |
| rwa [Algebra.adjoin_range_eq_range_aeval] at hz |
| exact ⟨f, Subtype.ext hf⟩ |
| |
| instance finiteType_cone {σ : Type} [Finite σ] (v : σ → L) : Algebra.FiniteType k (cone (k := k) v) := |
| Algebra.FiniteType.adjoin_of_finite (Set.finite_range _) |
| |
| lemma inclusion_finite {σ τ : Type} [Finite τ] {w : σ → L} {v : τ → L} |
| {h : cone (k := k) w ≤ cone v} (hi : (Subalgebra.inclusion h).IsIntegral) : |
| (Subalgebra.inclusion h).Finite := by |
| let f := Subalgebra.inclusion h |
| let : Algebra (cone (k := k) w) (cone (k := k) v) := f.toRingHom.toAlgebra |
| let : IsScalarTower k (cone (k := k) w) (cone (k := k) v) := |
| IsScalarTower.of_algebraMap_eq (fun a => (f.commutes a).symm) |
| have : Algebra.FiniteType (cone (k := k) w) (cone (k := k) v) := |
| Algebra.FiniteType.of_restrictScalars_finiteType k _ _ |
| exact hi.to_finite this |
| |
| /-- For a cone of transcendence degree r, exactly r parameters suffice, all |
| of them linear rather than arbitrary Noether-normalization polynomials. -/ |
| theorem exists_finite_linear_normalization [Infinite k] {n r : ℕ} (v : Fin n → L) |
| (hr : Algebra.trdeg k (cone (k := k) v) = r) : |
| ∃ w : Fin r → L, ∃ h : cone (k := k) w ≤ cone v, |
| Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (w i)) : |
| MvPolynomial (Fin r) k →ₐ[k] Polynomial L) ∧ |
| (Subalgebra.inclusion h).Finite := by |
| obtain ⟨m, _, w, h, hinj, hint⟩ := exists_linear_normalization (k := k) v |
| have hw : Function.Injective (coneEval (k := k) w) := by |
| intro a b hab |
| exact hinj (congrArg Subtype.val hab) |
| let e : MvPolynomial (Fin m) k ≃ₐ[k] cone (k := k) w := |
| AlgEquiv.ofBijective (coneEval w) ⟨hw, coneEval_surjective w⟩ |
| let f := Subalgebra.inclusion h |
| let : Algebra (cone (k := k) w) (cone (k := k) v) := f.toRingHom.toAlgebra |
| let : IsScalarTower k (cone (k := k) w) (cone (k := k) v) := |
| IsScalarTower.of_algebraMap_eq (fun a => (f.commutes a).symm) |
| let : Algebra.IsIntegral (cone (k := k) w) (cone (k := k) v) := ⟨hint⟩ |
| let : FaithfulSMul (cone (k := k) w) (cone (k := k) v) := |
| (faithfulSMul_iff_algebraMap_injective _ _).mpr (Subalgebra.inclusion_injective h) |
| have hm : m = r := by |
| have hh := trdeg_add_eq k (cone (k := k) w) (A := cone (k := k) v) |
| rw [← e.trdeg_eq, trdeg_eq_zero (R := cone (k := k) w) (A := cone (k := k) v), add_zero, hr] at hh |
| simpa [MvPolynomial.trdeg_of_isDomain] using hh |
| subst m |
| exact ⟨w, h, hinj, inclusion_finite hint⟩ |
| |
| end HomogeneousNoetherNormalization |
| |
| namespace ExplicitCone |
| open HomogeneousNoetherNormalization |
| |
| lemma polynomialAlgebra_trdeg : Algebra.trdeg ℂ polynomialAlgebra = 3 := by |
| rw [← SmallCM.trdeg_fractionRing ℂ polynomialAlgebra (RatFunc L)] |
| exact rationalCone_trdeg |
| |
| lemma exists_linear_parameters : |
| ∃ w : Fin 3 → L, ∃ h : cone (k := ℂ) w ≤ polynomialAlgebra, |
| Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (w i)) : |
| MvPolynomial (Fin 3) ℂ →ₐ[ℂ] Polynomial L) ∧ |
| (Subalgebra.inclusion h).Finite := by |
| let e := Fintype.equivFin (Fin 6 × Fin 3) |
| let v : Fin (Fintype.card (Fin 6 × Fin 3)) → L := fun i => sectionCoefficient (e.symm i) |
| have he : cone (k := ℂ) v = polynomialAlgebra := by |
| apply congrArg (Algebra.adjoin ℂ) |
| ext x |
| constructor |
| · rintro ⟨i, rfl⟩ |
| exact ⟨e.symm i, polynomialGenerator_eq_monomial _⟩ |
| · rintro ⟨i, rfl⟩ |
| refine ⟨e i, ?_⟩ |
| simp only [v, Equiv.symm_apply_apply, polynomialGenerator_eq_monomial] |
| rw [← he] |
| exact exists_finite_linear_normalization (k := ℂ) (r := 3) v |
| (by rw [he]; exact polynomialAlgebra_trdeg) |
| |
| end ExplicitCone |
| noncomputable section |
| namespace SmallCM |
| |
| lemma precomplete_pi {A ι : Type*} [CommRing A] [Fintype ι] |
| (I : Ideal A) [IsPrecomplete I A] : IsPrecomplete I (ι → A) := by |
| classical |
| apply AdicCompletion.of_surjective_iff.mp |
| intro x |
| let e := AdicCompletion.piEquivOfFintype I (fun _ : ι => A) |
| choose a ha using fun i => AdicCompletion.of_surjective I A (e x i) |
| refine ⟨a, e.injective ?_⟩ |
| funext i |
| simpa [e, AdicCompletion.piEquivOfFintype_apply, AdicCompletion.pi, |
| AdicCompletion.map_of] using ha i |
| |
| /-- Adic Nakayama without assuming the target finitely generated. -/ |
| lemma finite_of_adic_finite_quotient {A M : Type*} [CommRing A] |
| [AddCommGroup M] [Module A M] (I : Ideal A) |
| [IsPrecomplete I A] [IsHausdorff I M] |
| [Module.Finite A (M ⧸ (I • ⊤ : Submodule A M))] : Module.Finite A M := by |
| obtain ⟨n, f, hf⟩ := Module.Finite.exists_fin' A (M ⧸ (I • ⊤ : Submodule A M)) |
| have := precomplete_pi (ι := Fin n) I |
| obtain ⟨g, hg⟩ := Module.projective_lifting_property |
| (Submodule.mkQ (I • ⊤ : Submodule A M)) f (Submodule.mkQ_surjective _) |
| exact Module.Finite.of_surjective g |
| (surjective_of_mkQ_comp_surjective (I := I) (by rw [hg]; exact hf)) |
|
|
| end SmallCM |
|
|
| namespace SmallCM |
| /-- A finite closed fiber stays finite after completion whenever the image |
| of the original maximal ideal generates the completed maximal ideal. -/ |
| lemma finite_fiber_of_maximal_map {k B R : Type*} [Field k] [IsAlgClosed k] |
| [CommRing B] [Algebra k B] [CommRing R] [IsNoetherianRing R] |
| [IsLocalRing R] [Algebra k R] |
| [Module.Finite k (IsLocalRing.ResidueField R)] |
| (g : B →ₐ[k] R) (I m : Ideal B) (hIm : I ≤ m) |
| (hm : m.map g.toRingHom = IsLocalRing.maximalIdeal R) |
| [Module.Finite k (B ⧸ I)] : Module.Finite k (R ⧸ I.map g.toRingHom) := by |
| let J := I.map g.toRingHom |
| have hJm : J ≤ IsLocalRing.maximalIdeal R := by |
| rw [← hm] |
| exact Ideal.map_mono hIm |
| have hJ : J ≠ ⊤ := ne_top_of_le_ne_top (IsLocalRing.maximalIdeal.isMaximal R).ne_top hJm |
| let Q := R ⧸ J |
| have : Nontrivial Q := Ideal.Quotient.nontrivial_iff.mpr hJ |
| have : IsLocalRing Q := IsLocalRing.of_surjective' (Ideal.Quotient.mk J) |
| Ideal.Quotient.mk_surjective |
| have : IsLocalHom (Ideal.Quotient.mk J) := IsLocalHom.of_surjective |
| (Ideal.Quotient.mk J) Ideal.Quotient.mk_surjective |
| let h : B ⧸ I →ₐ[k] Q := Ideal.quotientMapₐ J g (Ideal.le_comap_map) |
| have hnil : (IsLocalRing.maximalIdeal R).map (Ideal.Quotient.mk J) ≤ nilradical Q := by |
| rw [← hm, Ideal.map_map, Ideal.map_le_iff_le_comap] |
| intro b hb |
| change IsNilpotent (Ideal.Quotient.mk J (g b)) |
| apply integral_maximal_nilpotent (k := k) |
| · exact (Algebra.IsIntegral.isIntegral (Ideal.Quotient.mk I b)).map h |
| · apply map_nonunit (Ideal.Quotient.mk J) |
| rw [← hm] |
| exact Ideal.mem_map_of_mem g hb |
| let f : Q →ₐ[k] IsLocalRing.ResidueField R := Ideal.Quotient.factorₐ k hJm |
| refine Module.finite_of_surjective_of_ker_le_nilradical f |
| (Ideal.Quotient.factor_surjective hJm) ?_ (IsNoetherian.noetherian _) |
| intro x hx |
| obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective x |
| apply hnil |
| apply Ideal.mem_map_of_mem |
| exact Ideal.Quotient.eq_zero_iff_mem.mp hx |
| end SmallCM |
| |
| namespace SmallCM |
| lemma finite_of_finite_mapped_fiber {k A R : Type*} [CommRing k] [CommRing A] |
| [Algebra k A] [CommRing R] [IsNoetherianRing R] [IsLocalRing R] |
| [Algebra A R] [Algebra k R] [IsScalarTower k A R] |
| (I : Ideal A) [IsPrecomplete I A] |
| (hm : I.map (algebraMap A R) ≤ IsLocalRing.maximalIdeal R) |
| [Module.Finite k (R ⧸ I.map (algebraMap A R))] : Module.Finite A R := by |
| have : IsHausdorff (IsLocalRing.maximalIdeal R) R := IsHausdorff.of_isLocalRing |
| (IsLocalRing.maximalIdeal R) R (IsLocalRing.maximalIdeal.isMaximal R).ne_top |
| have : IsHausdorff I R := IsHausdorff.of_map hm |
| have : Module.Finite A (R ⧸ (I • ⊤ : Submodule A R)) := by |
| rw [Ideal.smul_top_eq_map] |
| change Module.Finite A (R ⧸ I.map (algebraMap A R)) |
| exact Module.Finite.of_restrictScalars_finite k A _ |
| exact finite_of_adic_finite_quotient I |
| end SmallCM |
| |
| noncomputable section |
| namespace SmallCM |
| |
| /-- The fiber over the origin of a finite polynomial-algebra map is finite |
| as a vector space over the coefficient field. -/ |
| lemma finite_polynomial_origin_fiber {k B σ : Type*} [Field k] |
| [CommRing B] [Algebra k B] (f : MvPolynomial σ k →ₐ[k] B) |
| (hf : f.Finite) : |
| Module.Finite k (B ⧸ Ideal.span (Set.range (fun i => f (MvPolynomial.X i)))) := by |
| let I : Ideal B := Ideal.span (Set.range (fun i => f (MvPolynomial.X i))) |
| let S := MvPolynomial σ k |
| let : Algebra S B := f.toRingHom.toAlgebra |
| have : Module.Finite S B := hf |
| let : Algebra S k := (MvPolynomial.constantCoeff : S →+* k).toAlgebra |
| have hh : algebraMap S (B ⧸ I) = (algebraMap k (B ⧸ I)).comp |
| (MvPolynomial.constantCoeff : S →+* k) := by |
| apply MvPolynomial.ringHom_ext |
| · intro c |
| change Ideal.Quotient.mk I (f (MvPolynomial.C c)) = _ |
| simp |
| · intro i |
| change Ideal.Quotient.mk I (f (MvPolynomial.X i)) = _ |
| simp only [RingHom.comp_apply, MvPolynomial.constantCoeff_X, map_zero] |
| exact Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span ⟨i, rfl⟩) |
| let : IsScalarTower S k (B ⧸ I) := IsScalarTower.of_algebraMap_eq fun a => |
| congrArg (fun g : S →+* B ⧸ I => g a) hh |
| exact Module.Finite.of_restrictScalars_finite S k (B ⧸ I) |
| |
| end SmallCM |
| |
| namespace SectionCompletion |
| variable {k K : Type} [Field k] [Field K] [Algebra k K] |
| variable (T : ℕ → Submodule k K) [SetLike.GradedMonoid T] |
| |
| lemma completionEquiv_polynomial (D : ℕ) (hD : 0 < D) |
| (hc : ∀ n, degreeIdeal T (n * D) ≤ degreeIdeal T 1 ^ n) (p : polynomials T) : |
| completionEquiv T D hD hc (polynomialToSeries T p) = |
| algebraMap (polynomials T) (AdicCompletion (degreeIdeal T 1) (polynomials T)) p := by |
| apply AdicCompletion.ext_evalₐ |
| intro n |
| change AdicCompletion.evalₐ (degreeIdeal T 1) n |
| (toCompletion T D hc (polynomialToSeries T p)) = _ |
| rw [eval_toCompletion, AdicCompletion.algebraMap_apply, AdicCompletion.evalₐ_of] |
| change Ideal.Quotient.mk _ (truncation T (n * D) (polynomialToSeries T p)) = |
| Ideal.Quotient.mk _ p |
| rw [Ideal.Quotient.mk_eq_mk_iff_sub_mem] |
| apply hc n |
| rw [mem_degreeIdeal] |
| intro j hj |
| change ((truncation T (n * D) (polynomialToSeries T p)).val - p.val).coeff j = 0 |
| simp [Polynomial.coeff_sub, coeff_truncation, hj, polynomialToSeries] |
| |
| lemma maximal_polynomialToSeries [Algebra.FiniteType k (polynomials T)] |
| (hzero : T 0 = LinearMap.range (Algebra.linearMap k K)) |
| [IsLocalRing (series T)] : |
| (degreeIdeal T 1).map (polynomialToSeries T).toRingHom = |
| IsLocalRing.maximalIdeal (series T) := by |
| classical |
| have : IsNoetherianRing (polynomials T) := Algebra.FiniteType.isNoetherianRing k _ |
| obtain ⟨σ, hσ, v, d, hd, hv, hgen⟩ := finite_positive_presentation T hzero |
| let := hσ |
| let D : ℕ := Finset.univ.sup d + 1 |
| have hD : 0 < D := Nat.succ_pos _ |
| have hc : ∀ n, degreeIdeal T (n * D) ≤ degreeIdeal T 1 ^ n := |
| degreeIdeal_cofinal T v d hd hv hgen D hD |
| (fun i => (Finset.le_sup (Finset.mem_univ i)).trans (Nat.le_succ _)) |
| let e := completionEquiv T D hD hc |
| have he : (polynomialToSeries T).toRingHom = e.symm.toRingHom.comp |
| (algebraMap (polynomials T) (AdicCompletion (degreeIdeal T 1) (polynomials T))) := by |
| apply RingHom.ext |
| intro p |
| apply e.injective |
| simpa using completionEquiv_polynomial T D hD hc p |
| rw [he, ← Ideal.map_map] |
| have : (degreeIdeal T 1).IsMaximal := degreeIdeal_one_isMaximal T hzero |
| have : ((degreeIdeal T 1).map |
| (algebraMap (polynomials T) (AdicCompletion (degreeIdeal T 1) (polynomials T)))).IsMaximal := |
| AdicCompletion.isMaximal_map_of_le _ _ le_rfl (IsNoetherian.noetherian _) |
| exact IsLocalRing.eq_maximalIdeal |
| (Ideal.IsMaximal.map_of_surjective_of_ker_le e.symm.surjective (by simp)) |
| end SectionCompletion |
| |
| |
| noncomputable section |
| open Polynomial |
| namespace SectionCompletion |
| variable {k K σ : Type} [Field k] [IsAlgClosed k] [Field K] [Algebra k K] [Fintype σ] |
| variable (T : ℕ → Submodule k K) [SetLike.GradedMonoid T] |
| variable (w : σ → K) (hw : ∀ i, w i ∈ T 1) |
| |
| def linearPolynomialMap : MvPolynomial σ k →ₐ[k] polynomials T := |
| MvPolynomial.aeval (fun i => ⟨Polynomial.monomial 1 (w i), |
| (monomial_mem_polynomials T 1 (w i)).mpr (hw i)⟩) |
| |
| omit [IsAlgClosed k] in |
| lemma polynomial_subst_X (i : σ) : |
| polynomialToSeries T (linearPolynomialMap T w hw (MvPolynomial.X i)) = |
| SectionGenerated.substHom T w (fun _ => 1) (fun _ => one_ne_zero) hw (MvPowerSeries.X i) := by |
| apply Subtype.ext |
| change ((linearPolynomialMap T w hw (MvPolynomial.X i)).val : PowerSeries K) = |
| (MvPowerSeries.substAlgHom (R := k) |
| (SectionGenerated.hasSubst w (fun _ : σ => (1 : ℕ)) (fun _ => one_ne_zero))) |
| (MvPowerSeries.X i) |
| rw [MvPowerSeries.substAlgHom_apply] |
| rw [MvPowerSeries.subst_X (SectionGenerated.hasSubst w (fun _ : σ => (1 : ℕ)) (fun _ => one_ne_zero))] |
| simp [linearPolynomialMap, SectionGenerated.genSeries, Polynomial.coe_monomial, |
| PowerSeries.monomial_eq_C_mul_X_pow] |
| |
| /-- Completion of finite degree-one Noether normalization stays finite, |
| proved directly by closed-fiber finiteness and adic Nakayama. -/ |
| lemma finite_linear_substitution [Algebra.FiniteType k (polynomials T)] |
| (hzero : T 0 = LinearMap.range (Algebra.linearMap k K)) |
| (hfin : (linearPolynomialMap T w hw).Finite) : |
| (SectionGenerated.substHom T w (fun _ => 1) (fun _ => one_ne_zero) hw).Finite := by |
| let R := series T |
| let A := MvPowerSeries σ k |
| let f := SectionGenerated.substHom T w (fun _ => 1) (fun _ => one_ne_zero) hw |
| let g := polynomialToSeries T |
| let B := polynomials T |
| let I : Ideal B := Ideal.span (Set.range (fun i => linearPolynomialMap T w hw (MvPolynomial.X i))) |
| have : IsNoetherianRing R := isNoetherianRing_of_finiteType T hzero |
| let : IsLocalRing R := isLocalRing T (zero_piece_closed_inv T hzero) |
| have hIm : I ≤ degreeIdeal T 1 := by |
| apply Ideal.span_le.mpr |
| rintro p ⟨i, rfl⟩ |
| simp only [linearPolynomialMap, MvPolynomial.aeval_X] |
| change (⟨Polynomial.monomial 1 (w i), _⟩ : polynomials T) ∈ degreeIdeal T 1 |
| exact monomial_mem_degreeIdeal_one T one_ne_zero _ (hw i) |
| have : Module.Finite k (B ⧸ I) := SmallCM.finite_polynomial_origin_fiber _ hfin |
| have : Module.Finite k (IsLocalRing.ResidueField R) := Module.Finite.of_surjective |
| (Algebra.linearMap k _) (residue_bijective T hzero).2 |
| have : Module.Finite k (R ⧸ I.map g.toRingHom) := |
| SmallCM.finite_fiber_of_maximal_map g I (degreeIdeal T 1) hIm |
| (maximal_polynomialToSeries T hzero) |
| let : Algebra A R := f.toRingHom.toAlgebra |
| let : IsScalarTower k A R := IsScalarTower.of_algebraMap_eq (fun a => (f.commutes a).symm) |
| have hmap : (IsLocalRing.maximalIdeal A).map (algebraMap A R) = I.map g.toRingHom := by |
| rw [← mvPowerSeries_vars_eq_maximal, Ideal.map_span, Ideal.map_span] |
| congr 1 |
| rw [← Set.range_comp, ← Set.range_comp] |
| congr 1 |
| funext i |
| exact (polynomial_subst_X T w hw i).symm |
| have : IsPrecomplete (IsLocalRing.maximalIdeal A) A := by |
| rw [← mvPowerSeries_vars_eq_maximal] |
| infer_instance |
| change Module.Finite A R |
| have : Module.Finite k (R ⧸ (IsLocalRing.maximalIdeal A).map (algebraMap A R)) := by |
| rw [hmap] |
| infer_instance |
| apply SmallCM.finite_of_finite_mapped_fiber (k := k) (IsLocalRing.maximalIdeal A) |
| rw [hmap, ← maximal_polynomialToSeries T hzero] |
| exact Ideal.map_mono hIm |
| end SectionCompletion |
| |
| namespace GradedNormalization |
| variable {k L σ : Type} [Field k] [IsAlgClosed k] [CharZero k] [Field L] |
| [Algebra k L] [Fintype σ] |
| variable (B : Subalgebra k L[X]) [Algebra.FiniteType k B] [IsFractionRing B (RatFunc L)] |
| |
| omit [IsAlgClosed k] in |
| lemma finite_normalization_map |
| (hB : ∀ a : k, ∀ p ∈ B, scale a p ∈ B) : |
| ∃ j : B →ₐ[k] SectionCompletion.polynomials (piece B), |
| j.Finite ∧ ∀ x : B, (j x).val = x.val := by |
| rw [polynomial_piece_eq B hB] |
| let j : B →ₐ[k] (integralClosure B L[X]).restrictScalars k := |
| B.val.codRestrict _ (fun x => isIntegral_algebraMap (x := x)) |
| refine ⟨j, ?_, fun _ => rfl⟩ |
| have hf : RingHom.Finite (A := B) (B := integralClosure B L[X]) |
| (algebraMap B (integralClosure B L[X])) := |
| RingHom.finite_algebraMap.mpr (finite_polynomial_normalization B) |
| exact hf |
| |
| omit [IsAlgClosed k] [Fintype σ] in |
| lemma finite_normalized_linear_parameters |
| (hB : ∀ a : k, ∀ p ∈ B, scale a p ∈ B) |
| (w : σ → L) (h : HomogeneousNoetherNormalization.cone (k := k) w ≤ B) |
| (hf : (Subalgebra.inclusion h).Finite) : |
| ∃ hw : ∀ i, w i ∈ piece B 1, |
| (SectionCompletion.linearPolynomialMap (piece B) w hw).Finite := by |
| have hw : ∀ i, w i ∈ piece B 1 := by |
| intro i |
| have hm : Polynomial.monomial 1 (w i) ∈ B := |
| h (Algebra.subset_adjoin ⟨i, rfl⟩) |
| exact isIntegral_algebraMap (x := (⟨_, hm⟩ : B)) |
| refine ⟨hw, ?_⟩ |
| obtain ⟨j, hjf, hj⟩ := finite_normalization_map B hB |
| let b : MvPolynomial σ k →ₐ[k] B := (Subalgebra.inclusion h).comp |
| (HomogeneousNoetherNormalization.coneEval w) |
| have hb : b.Finite := hf.comp (AlgHom.Finite.of_surjective _ |
| (HomogeneousNoetherNormalization.coneEval_surjective w)) |
| have hu : (j.comp b).Finite := hjf.comp hb |
| have he : j.comp b = SectionCompletion.linearPolynomialMap (piece B) w hw := by |
| apply MvPolynomial.algHom_ext |
| intro i |
| apply Subtype.ext |
| simp only [AlgHom.comp_apply, hj] |
| simp [b, HomogeneousNoetherNormalization.coneEval, |
| SectionCompletion.linearPolynomialMap] |
| rwa [he] at hu |
| end GradedNormalization |
| |
| namespace ExplicitCone |
| lemma exists_finite_linear_completed_parameters : |
| ∃ (w : Fin 3 → L) (hw : ∀ i, w i ∈ pieces 1), |
| Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (w i)) : |
| MvPolynomial (Fin 3) ℂ →ₐ[ℂ] Polynomial L) ∧ |
| (SectionGenerated.substHom pieces w (fun _ => 1) (fun _ => one_ne_zero) hw).Finite := by |
| obtain ⟨w, h, hinj, hfin⟩ := exists_linear_parameters |
| obtain ⟨hw, hfin'⟩ := GradedNormalization.finite_normalized_linear_parameters |
| polynomialAlgebra polynomialAlgebra_scale w h hfin |
| have : Algebra.FiniteType ℂ (SectionCompletion.polynomials pieces) := |
| GradedNormalization.polynomialPiece_finiteType polynomialAlgebra polynomialAlgebra_scale |
| exact ⟨w, hw, hinj, SectionCompletion.finite_linear_substitution pieces w hw zero_piece hfin'⟩ |
| end ExplicitCone |
| |
| noncomputable section |
| open scoped BigOperators |
| namespace HomogeneousParameters |
| variable {k K σ : Type*} [Field k] [Field K] [Algebra k K] |
| |
| lemma prod_monomials (v : σ → K) (d : σ → ℕ) (e : σ →₀ ℕ) : |
| e.prod (fun i n => (Polynomial.monomial (d i) (v i)) ^ n) = |
| Polynomial.monomial (Finsupp.weight d e) (e.prod (fun i n => v i ^ n)) := by |
| classical |
| simp only [← Polynomial.C_mul_X_pow_eq_monomial, mul_pow, ← map_pow, |
| Finsupp.prod, Finset.prod_mul_distrib, ← map_prod, ← pow_mul, |
| Finset.prod_pow_eq_pow_sum, Finsupp.weight_apply, Finsupp.sum, smul_eq_mul] |
| congr 2 |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact Nat.mul_comm _ _ |
| |
| lemma linearIndependent_degree_fiber (v : σ → K) |
| (hinj : Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) : |
| MvPolynomial σ k →ₐ[k] Polynomial K)) (n : ℕ) : |
| LinearIndependent k (fun e : {e : σ →₀ ℕ // Finsupp.weight (fun _ => 1) e = n} => |
| e.val.prod (fun i j => v i ^ j)) := by |
| let f : MvPolynomial σ k →ₐ[k] Polynomial K := |
| MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) |
| have h := (MvPolynomial.basisMonomials σ k).linearIndependent.map' |
| f.toLinearMap (LinearMap.ker_eq_bot.mpr hinj) |
| have h' := h.comp (fun e : {e : σ →₀ ℕ // Finsupp.weight (fun _ => 1) e = n} => e.val) |
| Subtype.val_injective |
| apply LinearIndependent.of_comp ((Polynomial.monomial n).restrictScalars k) |
| convert h' using 1 |
| · funext e |
| simp only [Function.comp_apply, MvPolynomial.coe_basisMonomials, |
| LinearMap.coe_restrictScalars, AlgHom.toLinearMap_apply] |
| change Polynomial.monomial n _ = f (MvPolynomial.monomial e.val 1) |
| rw [MvPolynomial.aeval_monomial, map_one, one_mul, prod_monomials, e.property] |
| end HomogeneousParameters |
| namespace SectionGenerated |
| variable {k K σ : Type*} [Field k] [Field K] [Algebra k K] [Fintype σ] |
| variable (v : σ → K) |
|
|
| lemma linear_subst_eq_zero |
| (hinj : Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) : |
| MvPolynomial σ k →ₐ[k] Polynomial K)) (f : MvPowerSeries σ k) |
| (hf : MvPowerSeries.subst (genSeries v (fun _ => 1)) f = 0) : f = 0 := by |
| classical |
| apply MvPowerSeries.ext |
| intro e |
| let n := Finsupp.weight (fun _ : σ => (1 : ℕ)) e |
| let : Fintype {d : σ →₀ ℕ |
| (Finsupp.finite_of_nat_weight_eq (fun _ => 1) (fun _ => one_ne_zero) n).fintype |
| have hi := HomogeneousParameters.linearIndependent_degree_fiber v hinj n |
| have h := coeff_subst_fiber v (fun _ => 1) (fun _ => one_ne_zero) f n |
| rw [hf, map_zero, finsum_eq_sum_of_fintype] at h |
| have he := Fintype.linearIndependent_iff.mp hi (fun d => MvPowerSeries.coeff d.val f) h.symm |
| simpa using he ⟨e, rfl⟩ |
|
|
| lemma linear_subst_injective |
| (hinj : Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) : |
| MvPolynomial σ k →ₐ[k] Polynomial K)) : |
| Function.Injective (MvPowerSeries.substAlgHom (R := k) |
| (hasSubst v (fun _ => 1) (fun _ => one_ne_zero))) := by |
| intro f g hfg |
| apply sub_eq_zero.mp |
| apply linear_subst_eq_zero v hinj |
| have h0 : (MvPowerSeries.substAlgHom (R := k) |
| (hasSubst v (fun _ => 1) (fun _ => one_ne_zero))) (f - g) = 0 := by |
| rw [map_sub, hfg, sub_self] |
| simpa only [MvPowerSeries.substAlgHom_apply] using h0 |
|
|
| lemma substHom_injective_linear (T : ℕ → Submodule k K) [SetLike.GradedMonoid T] |
| (hv : ∀ i, v i ∈ T 1) |
| (hinj : Function.Injective (MvPolynomial.aeval (fun i => Polynomial.monomial 1 (v i)) : |
| MvPolynomial σ k →ₐ[k] Polynomial K)) : |
| Function.Injective (substHom T v (fun _ => 1) (fun _ => one_ne_zero) hv) := by |
| intro f g hfg |
| apply linear_subst_injective v hinj |
| exact congrArg Subtype.val hfg |
| end SectionGenerated |
|
|
| namespace ExplicitCone |
| lemma exists_finite_injective_completed_parameters : |
| ∃ f : MvPowerSeries (Fin 3) ℂ →ₐ[ℂ] completedRing, |
| Function.Injective f ∧ f.Finite := by |
| obtain ⟨w, hw, hinj, hfin⟩ := exists_finite_linear_completed_parameters |
| exact ⟨SectionGenerated.substHom pieces w (fun _ => 1) (fun _ => one_ne_zero) hw, |
| SectionGenerated.substHom_injective_linear w pieces hw hinj, hfin⟩ |
| end ExplicitCone |
|
|
|
|
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
