Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
/- | |
Copyright (c) 2020 Johan Commelin. All rights reserved. | |
Released under Apache 2.0 license as described in the file LICENSE. | |
Authors: Johan Commelin | |
-/ | |
import group_theory.finiteness | |
import ring_theory.algebra_tower | |
import ring_theory.ideal.quotient | |
import ring_theory.noetherian | |
/-! | |
# Finiteness conditions in commutative algebra | |
In this file we define several notions of finiteness that are common in commutative algebra. | |
## Main declarations | |
- `module.finite`, `algebra.finite`, `ring_hom.finite`, `alg_hom.finite` | |
all of these express that some object is finitely generated *as module* over some base ring. | |
- `algebra.finite_type`, `ring_hom.finite_type`, `alg_hom.finite_type` | |
all of these express that some object is finitely generated *as algebra* over some base ring. | |
- `algebra.finite_presentation`, `ring_hom.finite_presentation`, `alg_hom.finite_presentation` | |
all of these express that some object is finitely presented *as algebra* over some base ring. | |
-/ | |
open function (surjective) | |
open_locale big_operators polynomial | |
section module_and_algebra | |
variables (R A B M N : Type*) | |
/-- A module over a semiring is `finite` if it is finitely generated as a module. -/ | |
class module.finite [semiring R] [add_comm_monoid M] [module R M] : | |
Prop := (out : (⊤ : submodule R M).fg) | |
/-- An algebra over a commutative semiring is of `finite_type` if it is finitely generated | |
over the base ring as algebra. -/ | |
class algebra.finite_type [comm_semiring R] [semiring A] [algebra R A] : Prop := | |
(out : (⊤ : subalgebra R A).fg) | |
/-- An algebra over a commutative semiring is `finite_presentation` if it is the quotient of a | |
polynomial ring in `n` variables by a finitely generated ideal. -/ | |
def algebra.finite_presentation [comm_semiring R] [semiring A] [algebra R A] : Prop := | |
∃ (n : ℕ) (f : mv_polynomial (fin n) R →ₐ[R] A), | |
surjective f ∧ f.to_ring_hom.ker.fg | |
namespace module | |
variables [semiring R] [add_comm_monoid M] [module R M] [add_comm_monoid N] [module R N] | |
lemma finite_def {R M} [semiring R] [add_comm_monoid M] [module R M] : | |
finite R M ↔ (⊤ : submodule R M).fg := ⟨λ h, h.1, λ h, ⟨h⟩⟩ | |
@[priority 100] -- see Note [lower instance priority] | |
instance is_noetherian.finite [is_noetherian R M] : finite R M := | |
⟨is_noetherian.noetherian ⊤⟩ | |
namespace finite | |
open _root_.submodule set | |
lemma iff_add_monoid_fg {M : Type*} [add_comm_monoid M] : module.finite ℕ M ↔ add_monoid.fg M := | |
⟨λ h, add_monoid.fg_def.2 $ (fg_iff_add_submonoid_fg ⊤).1 (finite_def.1 h), | |
λ h, finite_def.2 $ (fg_iff_add_submonoid_fg ⊤).2 (add_monoid.fg_def.1 h)⟩ | |
lemma iff_add_group_fg {G : Type*} [add_comm_group G] : module.finite ℤ G ↔ add_group.fg G := | |
⟨λ h, add_group.fg_def.2 $ (fg_iff_add_subgroup_fg ⊤).1 (finite_def.1 h), | |
λ h, finite_def.2 $ (fg_iff_add_subgroup_fg ⊤).2 (add_group.fg_def.1 h)⟩ | |
variables {R M N} | |
lemma exists_fin [finite R M] : ∃ (n : ℕ) (s : fin n → M), span R (range s) = ⊤ := | |
submodule.fg_iff_exists_fin_generating_family.mp out | |
lemma of_surjective [hM : finite R M] (f : M →ₗ[R] N) (hf : surjective f) : | |
finite R N := | |
⟨begin | |
rw [← linear_map.range_eq_top.2 hf, ← submodule.map_top], | |
exact hM.1.map f | |
end⟩ | |
lemma of_injective [is_noetherian R N] (f : M →ₗ[R] N) | |
(hf : function.injective f) : finite R M := | |
⟨fg_of_injective f hf⟩ | |
variables (R) | |
instance self : finite R R := | |
⟨⟨{1}, by simpa only [finset.coe_singleton] using ideal.span_singleton_one⟩⟩ | |
variable (M) | |
lemma of_restrict_scalars_finite (R A M : Type*) [comm_semiring R] [semiring A] [add_comm_monoid M] | |
[module R M] [module A M] [algebra R A] [is_scalar_tower R A M] [hM : finite R M] : | |
finite A M := | |
begin | |
rw [finite_def, fg_def] at hM ⊢, | |
obtain ⟨S, hSfin, hSgen⟩ := hM, | |
refine ⟨S, hSfin, eq_top_iff.2 _⟩, | |
have := submodule.span_le_restrict_scalars R A S, | |
rw hSgen at this, | |
exact this | |
end | |
variables {R M} | |
instance prod [hM : finite R M] [hN : finite R N] : finite R (M × N) := | |
⟨begin | |
rw ← submodule.prod_top, | |
exact hM.1.prod hN.1 | |
end⟩ | |
instance pi {ι : Type*} {M : ι → Type*} [fintype ι] [Π i, add_comm_monoid (M i)] | |
[Π i, module R (M i)] [h : ∀ i, finite R (M i)] : finite R (Π i, M i) := | |
⟨begin | |
rw ← submodule.pi_top, | |
exact submodule.fg_pi (λ i, (h i).1), | |
end⟩ | |
lemma equiv [hM : finite R M] (e : M ≃ₗ[R] N) : finite R N := | |
of_surjective (e : M →ₗ[R] N) e.surjective | |
section algebra | |
lemma trans {R : Type*} (A B : Type*) [comm_semiring R] [comm_semiring A] [algebra R A] | |
[semiring B] [algebra R B] [algebra A B] [is_scalar_tower R A B] : | |
∀ [finite R A] [finite A B], finite R B | |
| ⟨⟨s, hs⟩⟩ ⟨⟨t, ht⟩⟩ := ⟨submodule.fg_def.2 | |
⟨set.image2 (•) (↑s : set A) (↑t : set B), | |
set.finite.image2 _ s.finite_to_set t.finite_to_set, | |
by rw [set.image2_smul, submodule.span_smul hs (↑t : set B), | |
ht, submodule.restrict_scalars_top]⟩⟩ | |
@[priority 100] -- see Note [lower instance priority] | |
instance finite_type {R : Type*} (A : Type*) [comm_semiring R] [semiring A] | |
[algebra R A] [hRA : finite R A] : algebra.finite_type R A := | |
⟨subalgebra.fg_of_submodule_fg hRA.1⟩ | |
end algebra | |
end finite | |
end module | |
instance module.finite.base_change [comm_semiring R] [semiring A] [algebra R A] | |
[add_comm_monoid M] [module R M] [h : module.finite R M] : | |
module.finite A (tensor_product R A M) := | |
begin | |
classical, | |
obtain ⟨s, hs⟩ := h.out, | |
refine ⟨⟨s.image (tensor_product.mk R A M 1), eq_top_iff.mpr $ λ x _, _⟩⟩, | |
apply tensor_product.induction_on x, | |
{ exact zero_mem _ }, | |
{ intros x y, | |
rw [finset.coe_image, ← submodule.span_span_of_tower R, submodule.span_image, hs, | |
submodule.map_top, linear_map.range_coe], | |
change _ ∈ submodule.span A (set.range $ tensor_product.mk R A M 1), | |
rw [← mul_one x, ← smul_eq_mul, ← tensor_product.smul_tmul'], | |
exact submodule.smul_mem _ x (submodule.subset_span $ set.mem_range_self y) }, | |
{ exact λ _ _, submodule.add_mem _ } | |
end | |
instance module.finite.tensor_product [comm_semiring R] | |
[add_comm_monoid M] [module R M] [add_comm_monoid N] [module R N] | |
[hM : module.finite R M] [hN : module.finite R N] : module.finite R (tensor_product R M N) := | |
{ out := (tensor_product.map₂_mk_top_top_eq_top R M N).subst (hM.out.map₂ _ hN.out) } | |
namespace algebra | |
variables [comm_ring R] [comm_ring A] [algebra R A] [comm_ring B] [algebra R B] | |
variables [add_comm_group M] [module R M] | |
variables [add_comm_group N] [module R N] | |
namespace finite_type | |
lemma self : finite_type R R := ⟨⟨{1}, subsingleton.elim _ _⟩⟩ | |
section | |
open_locale classical | |
protected lemma mv_polynomial (ι : Type*) [fintype ι] : finite_type R (mv_polynomial ι R) := | |
⟨⟨finset.univ.image mv_polynomial.X, begin | |
rw eq_top_iff, refine λ p, mv_polynomial.induction_on' p | |
(λ u x, finsupp.induction u (subalgebra.algebra_map_mem _ x) | |
(λ i n f hif hn ih, _)) | |
(λ p q ihp ihq, subalgebra.add_mem _ ihp ihq), | |
rw [add_comm, mv_polynomial.monomial_add_single], | |
exact subalgebra.mul_mem _ ih | |
(subalgebra.pow_mem _ (subset_adjoin $ finset.mem_image_of_mem _ $ finset.mem_univ _) _) | |
end⟩⟩ | |
end | |
lemma of_restrict_scalars_finite_type [algebra A B] [is_scalar_tower R A B] [hB : finite_type R B] : | |
finite_type A B := | |
begin | |
obtain ⟨S, hS⟩ := hB.out, | |
refine ⟨⟨S, eq_top_iff.2 (λ b, _)⟩⟩, | |
have le : adjoin R (S : set B) ≤ subalgebra.restrict_scalars R (adjoin A S), | |
{ apply (algebra.adjoin_le _ : _ ≤ (subalgebra.restrict_scalars R (adjoin A ↑S))), | |
simp only [subalgebra.coe_restrict_scalars], | |
exact algebra.subset_adjoin, }, | |
exact le (eq_top_iff.1 hS b), | |
end | |
variables {R A B} | |
lemma of_surjective (hRA : finite_type R A) (f : A →ₐ[R] B) (hf : surjective f) : | |
finite_type R B := | |
⟨begin | |
convert hRA.1.map f, | |
simpa only [map_top f, @eq_comm _ ⊤, eq_top_iff, alg_hom.mem_range] using hf | |
end⟩ | |
lemma equiv (hRA : finite_type R A) (e : A ≃ₐ[R] B) : finite_type R B := | |
hRA.of_surjective e e.surjective | |
lemma trans [algebra A B] [is_scalar_tower R A B] (hRA : finite_type R A) (hAB : finite_type A B) : | |
finite_type R B := | |
⟨fg_trans' hRA.1 hAB.1⟩ | |
/-- An algebra is finitely generated if and only if it is a quotient | |
of a polynomial ring whose variables are indexed by a finset. -/ | |
lemma iff_quotient_mv_polynomial : (finite_type R A) ↔ ∃ (s : finset A) | |
(f : (mv_polynomial {x // x ∈ s} R) →ₐ[R] A), (surjective f) := | |
begin | |
split, | |
{ rintro ⟨s, hs⟩, | |
use [s, mv_polynomial.aeval coe], | |
intro x, | |
have hrw : (↑s : set A) = (λ (x : A), x ∈ s.val) := rfl, | |
rw [← set.mem_range, ← alg_hom.coe_range, ← adjoin_eq_range, ← hrw, hs], | |
exact set.mem_univ x }, | |
{ rintro ⟨s, ⟨f, hsur⟩⟩, | |
exact finite_type.of_surjective (finite_type.mv_polynomial R {x // x ∈ s}) f hsur } | |
end | |
/-- An algebra is finitely generated if and only if it is a quotient | |
of a polynomial ring whose variables are indexed by a fintype. -/ | |
lemma iff_quotient_mv_polynomial' : (finite_type R A) ↔ ∃ (ι : Type u_2) (_ : fintype ι) | |
(f : (mv_polynomial ι R) →ₐ[R] A), (surjective f) := | |
begin | |
split, | |
{ rw iff_quotient_mv_polynomial, | |
rintro ⟨s, ⟨f, hsur⟩⟩, | |
use [{x // x ∈ s}, by apply_instance, f, hsur] }, | |
{ rintro ⟨ι, ⟨hfintype, ⟨f, hsur⟩⟩⟩, | |
letI : fintype ι := hfintype, | |
exact finite_type.of_surjective (finite_type.mv_polynomial R ι) f hsur } | |
end | |
/-- An algebra is finitely generated if and only if it is a quotient of a polynomial ring in `n` | |
variables. -/ | |
lemma iff_quotient_mv_polynomial'' : (finite_type R A) ↔ ∃ (n : ℕ) | |
(f : (mv_polynomial (fin n) R) →ₐ[R] A), (surjective f) := | |
begin | |
split, | |
{ rw iff_quotient_mv_polynomial', | |
rintro ⟨ι, hfintype, ⟨f, hsur⟩⟩, | |
resetI, | |
have equiv := mv_polynomial.rename_equiv R (fintype.equiv_fin ι), | |
exact ⟨fintype.card ι, alg_hom.comp f equiv.symm, function.surjective.comp hsur | |
(alg_equiv.symm equiv).surjective⟩ }, | |
{ rintro ⟨n, ⟨f, hsur⟩⟩, | |
exact finite_type.of_surjective (finite_type.mv_polynomial R (fin n)) f hsur } | |
end | |
/-- A finitely presented algebra is of finite type. -/ | |
lemma of_finite_presentation : finite_presentation R A → finite_type R A := | |
begin | |
rintro ⟨n, f, hf⟩, | |
apply (finite_type.iff_quotient_mv_polynomial'').2, | |
exact ⟨n, f, hf.1⟩ | |
end | |
instance prod [hA : finite_type R A] [hB : finite_type R B] : finite_type R (A × B) := | |
⟨begin | |
rw ← subalgebra.prod_top, | |
exact hA.1.prod hB.1 | |
end⟩ | |
lemma is_noetherian_ring (R S : Type*) [comm_ring R] [comm_ring S] [algebra R S] | |
[h : algebra.finite_type R S] [is_noetherian_ring R] : is_noetherian_ring S := | |
begin | |
obtain ⟨s, hs⟩ := h.1, | |
apply is_noetherian_ring_of_surjective | |
(mv_polynomial s R) S (mv_polynomial.aeval coe : mv_polynomial s R →ₐ[R] S), | |
rw [← set.range_iff_surjective, alg_hom.coe_to_ring_hom, ← alg_hom.coe_range, | |
← algebra.adjoin_range_eq_range_aeval, subtype.range_coe_subtype, finset.set_of_mem, hs], | |
refl | |
end | |
lemma _root_.subalgebra.fg_iff_finite_type {R A : Type*} [comm_semiring R] [semiring A] | |
[algebra R A] (S : subalgebra R A) : S.fg ↔ algebra.finite_type R S := | |
S.fg_top.symm.trans ⟨λ h, ⟨h⟩, λ h, h.out⟩ | |
end finite_type | |
namespace finite_presentation | |
variables {R A B} | |
/-- An algebra over a Noetherian ring is finitely generated if and only if it is finitely | |
presented. -/ | |
lemma of_finite_type [is_noetherian_ring R] : finite_type R A ↔ finite_presentation R A := | |
begin | |
refine ⟨λ h, _, algebra.finite_type.of_finite_presentation⟩, | |
obtain ⟨n, f, hf⟩ := algebra.finite_type.iff_quotient_mv_polynomial''.1 h, | |
refine ⟨n, f, hf, _⟩, | |
have hnoet : is_noetherian_ring (mv_polynomial (fin n) R) := by apply_instance, | |
replace hnoet := (is_noetherian_ring_iff.1 hnoet).noetherian, | |
exact hnoet f.to_ring_hom.ker, | |
end | |
/-- If `e : A ≃ₐ[R] B` and `A` is finitely presented, then so is `B`. -/ | |
lemma equiv (hfp : finite_presentation R A) (e : A ≃ₐ[R] B) : finite_presentation R B := | |
begin | |
obtain ⟨n, f, hf⟩ := hfp, | |
use [n, alg_hom.comp ↑e f], | |
split, | |
{ exact function.surjective.comp e.surjective hf.1 }, | |
suffices hker : (alg_hom.comp ↑e f).to_ring_hom.ker = f.to_ring_hom.ker, | |
{ rw hker, exact hf.2 }, | |
{ have hco : (alg_hom.comp ↑e f).to_ring_hom = ring_hom.comp ↑e.to_ring_equiv f.to_ring_hom, | |
{ have h : (alg_hom.comp ↑e f).to_ring_hom = e.to_alg_hom.to_ring_hom.comp f.to_ring_hom := rfl, | |
have h1 : ↑(e.to_ring_equiv) = (e.to_alg_hom).to_ring_hom := rfl, | |
rw [h, h1] }, | |
rw [ring_hom.ker_eq_comap_bot, hco, ← ideal.comap_comap, ← ring_hom.ker_eq_comap_bot, | |
ring_hom.ker_coe_equiv (alg_equiv.to_ring_equiv e), ring_hom.ker_eq_comap_bot] } | |
end | |
variable (R) | |
/-- The ring of polynomials in finitely many variables is finitely presented. -/ | |
protected lemma mv_polynomial (ι : Type u_2) [fintype ι] : | |
finite_presentation R (mv_polynomial ι R) := | |
begin | |
have equiv := mv_polynomial.rename_equiv R (fintype.equiv_fin ι), | |
refine ⟨_, alg_equiv.to_alg_hom equiv.symm, _⟩, | |
split, | |
{ exact (alg_equiv.symm equiv).surjective }, | |
suffices hinj : function.injective equiv.symm.to_alg_hom.to_ring_hom, | |
{ rw [(ring_hom.injective_iff_ker_eq_bot _).1 hinj], | |
exact submodule.fg_bot }, | |
exact (alg_equiv.symm equiv).injective | |
end | |
/-- `R` is finitely presented as `R`-algebra. -/ | |
lemma self : finite_presentation R R := | |
equiv (finite_presentation.mv_polynomial R pempty) (mv_polynomial.is_empty_alg_equiv R pempty) | |
variable {R} | |
/-- The quotient of a finitely presented algebra by a finitely generated ideal is finitely | |
presented. -/ | |
protected lemma quotient {I : ideal A} (h : I.fg) (hfp : finite_presentation R A) : | |
finite_presentation R (A ⧸ I) := | |
begin | |
obtain ⟨n, f, hf⟩ := hfp, | |
refine ⟨n, (ideal.quotient.mkₐ R I).comp f, _, _⟩, | |
{ exact (ideal.quotient.mkₐ_surjective R I).comp hf.1 }, | |
{ refine ideal.fg_ker_comp _ _ hf.2 _ hf.1, | |
simp [h] } | |
end | |
/-- If `f : A →ₐ[R] B` is surjective with finitely generated kernel and `A` is finitely presented, | |
then so is `B`. -/ | |
lemma of_surjective {f : A →ₐ[R] B} (hf : function.surjective f) (hker : f.to_ring_hom.ker.fg) | |
(hfp : finite_presentation R A) : finite_presentation R B := | |
equiv (hfp.quotient hker) (ideal.quotient_ker_alg_equiv_of_surjective hf) | |
lemma iff : finite_presentation R A ↔ | |
∃ n (I : ideal (mv_polynomial (fin n) R)) (e : (_ ⧸ I) ≃ₐ[R] A), I.fg := | |
begin | |
split, | |
{ rintros ⟨n, f, hf⟩, | |
exact ⟨n, f.to_ring_hom.ker, ideal.quotient_ker_alg_equiv_of_surjective hf.1, hf.2⟩ }, | |
{ rintros ⟨n, I, e, hfg⟩, | |
exact equiv ((finite_presentation.mv_polynomial R _).quotient hfg) e } | |
end | |
/-- An algebra is finitely presented if and only if it is a quotient of a polynomial ring whose | |
variables are indexed by a fintype by a finitely generated ideal. -/ | |
lemma iff_quotient_mv_polynomial' : finite_presentation R A ↔ ∃ (ι : Type u_2) (_ : fintype ι) | |
(f : mv_polynomial ι R →ₐ[R] A), surjective f ∧ f.to_ring_hom.ker.fg := | |
begin | |
split, | |
{ rintro ⟨n, f, hfs, hfk⟩, | |
set ulift_var := mv_polynomial.rename_equiv R equiv.ulift, | |
refine ⟨ulift (fin n), infer_instance, f.comp ulift_var.to_alg_hom, | |
hfs.comp ulift_var.surjective, | |
ideal.fg_ker_comp _ _ _ hfk ulift_var.surjective⟩, | |
convert submodule.fg_bot, | |
exact ring_hom.ker_coe_equiv ulift_var.to_ring_equiv, }, | |
{ rintro ⟨ι, hfintype, f, hf⟩, | |
resetI, | |
have equiv := mv_polynomial.rename_equiv R (fintype.equiv_fin ι), | |
refine ⟨fintype.card ι, f.comp equiv.symm, | |
hf.1.comp (alg_equiv.symm equiv).surjective, | |
ideal.fg_ker_comp _ f _ hf.2 equiv.symm.surjective⟩, | |
convert submodule.fg_bot, | |
exact ring_hom.ker_coe_equiv (equiv.symm.to_ring_equiv), } | |
end | |
/-- If `A` is a finitely presented `R`-algebra, then `mv_polynomial (fin n) A` is finitely presented | |
as `R`-algebra. -/ | |
lemma mv_polynomial_of_finite_presentation (hfp : finite_presentation R A) (ι : Type*) | |
[fintype ι] : finite_presentation R (mv_polynomial ι A) := | |
begin | |
rw iff_quotient_mv_polynomial' at hfp ⊢, | |
classical, | |
obtain ⟨ι', _, f, hf_surj, hf_ker⟩ := hfp, | |
resetI, | |
let g := (mv_polynomial.map_alg_hom f).comp (mv_polynomial.sum_alg_equiv R ι ι').to_alg_hom, | |
refine ⟨ι ⊕ ι', by apply_instance, g, | |
(mv_polynomial.map_surjective f.to_ring_hom hf_surj).comp (alg_equiv.surjective _), | |
ideal.fg_ker_comp _ _ _ _ (alg_equiv.surjective _)⟩, | |
{ convert submodule.fg_bot, | |
exact ring_hom.ker_coe_equiv (mv_polynomial.sum_alg_equiv R ι ι').to_ring_equiv }, | |
{ rw [alg_hom.to_ring_hom_eq_coe, mv_polynomial.map_alg_hom_coe_ring_hom, mv_polynomial.ker_map], | |
exact hf_ker.map mv_polynomial.C, } | |
end | |
/-- If `A` is an `R`-algebra and `S` is an `A`-algebra, both finitely presented, then `S` is | |
finitely presented as `R`-algebra. -/ | |
lemma trans [algebra A B] [is_scalar_tower R A B] (hfpA : finite_presentation R A) | |
(hfpB : finite_presentation A B) : finite_presentation R B := | |
begin | |
obtain ⟨n, I, e, hfg⟩ := iff.1 hfpB, | |
exact equiv ((mv_polynomial_of_finite_presentation hfpA _).quotient hfg) (e.restrict_scalars R) | |
end | |
end finite_presentation | |
end algebra | |
end module_and_algebra | |
namespace ring_hom | |
variables {A B C : Type*} [comm_ring A] [comm_ring B] [comm_ring C] | |
/-- A ring morphism `A →+* B` is `finite` if `B` is finitely generated as `A`-module. -/ | |
def finite (f : A →+* B) : Prop := | |
by letI : algebra A B := f.to_algebra; exact module.finite A B | |
/-- A ring morphism `A →+* B` is of `finite_type` if `B` is finitely generated as `A`-algebra. -/ | |
def finite_type (f : A →+* B) : Prop := @algebra.finite_type A B _ _ f.to_algebra | |
/-- A ring morphism `A →+* B` is of `finite_presentation` if `B` is finitely presented as | |
`A`-algebra. -/ | |
def finite_presentation (f : A →+* B) : Prop := @algebra.finite_presentation A B _ _ f.to_algebra | |
namespace finite | |
variables (A) | |
lemma id : finite (ring_hom.id A) := module.finite.self A | |
variables {A} | |
lemma of_surjective (f : A →+* B) (hf : surjective f) : f.finite := | |
begin | |
letI := f.to_algebra, | |
exact module.finite.of_surjective (algebra.of_id A B).to_linear_map hf | |
end | |
lemma comp {g : B →+* C} {f : A →+* B} (hg : g.finite) (hf : f.finite) : (g.comp f).finite := | |
@module.finite.trans A B C _ _ f.to_algebra _ (g.comp f).to_algebra g.to_algebra | |
begin | |
fconstructor, | |
intros a b c, | |
simp only [algebra.smul_def, ring_hom.map_mul, mul_assoc], | |
refl | |
end | |
hf hg | |
lemma finite_type {f : A →+* B} (hf : f.finite) : finite_type f := | |
@module.finite.finite_type _ _ _ _ f.to_algebra hf | |
lemma of_comp_finite {f : A →+* B} {g : B →+* C} (h : (g.comp f).finite) : g.finite := | |
begin | |
letI := f.to_algebra, | |
letI := g.to_algebra, | |
letI := (g.comp f).to_algebra, | |
letI : is_scalar_tower A B C := restrict_scalars.is_scalar_tower A B C, | |
letI : module.finite A C := h, | |
exact module.finite.of_restrict_scalars_finite A B C | |
end | |
end finite | |
namespace finite_type | |
variables (A) | |
lemma id : finite_type (ring_hom.id A) := algebra.finite_type.self A | |
variables {A} | |
lemma comp_surjective {f : A →+* B} {g : B →+* C} (hf : f.finite_type) (hg : surjective g) : | |
(g.comp f).finite_type := | |
@algebra.finite_type.of_surjective A B C _ _ f.to_algebra _ (g.comp f).to_algebra hf | |
{ to_fun := g, commutes' := λ a, rfl, .. g } hg | |
lemma of_surjective (f : A →+* B) (hf : surjective f) : f.finite_type := | |
by { rw ← f.comp_id, exact (id A).comp_surjective hf } | |
lemma comp {g : B →+* C} {f : A →+* B} (hg : g.finite_type) (hf : f.finite_type) : | |
(g.comp f).finite_type := | |
@algebra.finite_type.trans A B C _ _ f.to_algebra _ (g.comp f).to_algebra g.to_algebra | |
begin | |
fconstructor, | |
intros a b c, | |
simp only [algebra.smul_def, ring_hom.map_mul, mul_assoc], | |
refl | |
end | |
hf hg | |
lemma of_finite {f : A →+* B} (hf : f.finite) : f.finite_type := | |
@module.finite.finite_type _ _ _ _ f.to_algebra hf | |
alias of_finite ← _root_.ring_hom.finite.to_finite_type | |
lemma of_finite_presentation {f : A →+* B} (hf : f.finite_presentation) : f.finite_type := | |
@algebra.finite_type.of_finite_presentation A B _ _ f.to_algebra hf | |
lemma of_comp_finite_type {f : A →+* B} {g : B →+* C} (h : (g.comp f).finite_type) : | |
g.finite_type := | |
begin | |
letI := f.to_algebra, | |
letI := g.to_algebra, | |
letI := (g.comp f).to_algebra, | |
letI : is_scalar_tower A B C := restrict_scalars.is_scalar_tower A B C, | |
letI : algebra.finite_type A C := h, | |
exact algebra.finite_type.of_restrict_scalars_finite_type A B C | |
end | |
end finite_type | |
namespace finite_presentation | |
variables (A) | |
lemma id : finite_presentation (ring_hom.id A) := algebra.finite_presentation.self A | |
variables {A} | |
lemma comp_surjective {f : A →+* B} {g : B →+* C} (hf : f.finite_presentation) (hg : surjective g) | |
(hker : g.ker.fg) : (g.comp f).finite_presentation := | |
@algebra.finite_presentation.of_surjective A B C _ _ f.to_algebra _ (g.comp f).to_algebra | |
{ to_fun := g, commutes' := λ a, rfl, .. g } hg hker hf | |
lemma of_surjective (f : A →+* B) (hf : surjective f) (hker : f.ker.fg) : f.finite_presentation := | |
by { rw ← f.comp_id, exact (id A).comp_surjective hf hker} | |
lemma of_finite_type [is_noetherian_ring A] {f : A →+* B} : f.finite_type ↔ f.finite_presentation := | |
@algebra.finite_presentation.of_finite_type A B _ _ f.to_algebra _ | |
lemma comp {g : B →+* C} {f : A →+* B} (hg : g.finite_presentation) (hf : f.finite_presentation) : | |
(g.comp f).finite_presentation := | |
@algebra.finite_presentation.trans A B C _ _ f.to_algebra _ (g.comp f).to_algebra g.to_algebra | |
{ smul_assoc := λ a b c, begin | |
simp only [algebra.smul_def, ring_hom.map_mul, mul_assoc], | |
refl | |
end } | |
hf hg | |
end finite_presentation | |
end ring_hom | |
namespace alg_hom | |
variables {R A B C : Type*} [comm_ring R] | |
variables [comm_ring A] [comm_ring B] [comm_ring C] | |
variables [algebra R A] [algebra R B] [algebra R C] | |
/-- An algebra morphism `A →ₐ[R] B` is finite if it is finite as ring morphism. | |
In other words, if `B` is finitely generated as `A`-module. -/ | |
def finite (f : A →ₐ[R] B) : Prop := f.to_ring_hom.finite | |
/-- An algebra morphism `A →ₐ[R] B` is of `finite_type` if it is of finite type as ring morphism. | |
In other words, if `B` is finitely generated as `A`-algebra. -/ | |
def finite_type (f : A →ₐ[R] B) : Prop := f.to_ring_hom.finite_type | |
/-- An algebra morphism `A →ₐ[R] B` is of `finite_presentation` if it is of finite presentation as | |
ring morphism. In other words, if `B` is finitely presented as `A`-algebra. -/ | |
def finite_presentation (f : A →ₐ[R] B) : Prop := f.to_ring_hom.finite_presentation | |
namespace finite | |
variables (R A) | |
lemma id : finite (alg_hom.id R A) := ring_hom.finite.id A | |
variables {R A} | |
lemma comp {g : B →ₐ[R] C} {f : A →ₐ[R] B} (hg : g.finite) (hf : f.finite) : (g.comp f).finite := | |
ring_hom.finite.comp hg hf | |
lemma of_surjective (f : A →ₐ[R] B) (hf : surjective f) : f.finite := | |
ring_hom.finite.of_surjective f hf | |
lemma finite_type {f : A →ₐ[R] B} (hf : f.finite) : finite_type f := | |
ring_hom.finite.finite_type hf | |
lemma of_comp_finite {f : A →ₐ[R] B} {g : B →ₐ[R] C} (h : (g.comp f).finite) : g.finite := | |
ring_hom.finite.of_comp_finite h | |
end finite | |
namespace finite_type | |
variables (R A) | |
lemma id : finite_type (alg_hom.id R A) := ring_hom.finite_type.id A | |
variables {R A} | |
lemma comp {g : B →ₐ[R] C} {f : A →ₐ[R] B} (hg : g.finite_type) (hf : f.finite_type) : | |
(g.comp f).finite_type := | |
ring_hom.finite_type.comp hg hf | |
lemma comp_surjective {f : A →ₐ[R] B} {g : B →ₐ[R] C} (hf : f.finite_type) (hg : surjective g) : | |
(g.comp f).finite_type := | |
ring_hom.finite_type.comp_surjective hf hg | |
lemma of_surjective (f : A →ₐ[R] B) (hf : surjective f) : f.finite_type := | |
ring_hom.finite_type.of_surjective f hf | |
lemma of_finite_presentation {f : A →ₐ[R] B} (hf : f.finite_presentation) : f.finite_type := | |
ring_hom.finite_type.of_finite_presentation hf | |
lemma of_comp_finite_type {f : A →ₐ[R] B} {g : B →ₐ[R] C} (h : (g.comp f).finite_type) : | |
g.finite_type := | |
ring_hom.finite_type.of_comp_finite_type h | |
end finite_type | |
namespace finite_presentation | |
variables (R A) | |
lemma id : finite_presentation (alg_hom.id R A) := ring_hom.finite_presentation.id A | |
variables {R A} | |
lemma comp {g : B →ₐ[R] C} {f : A →ₐ[R] B} (hg : g.finite_presentation) | |
(hf : f.finite_presentation) : (g.comp f).finite_presentation := | |
ring_hom.finite_presentation.comp hg hf | |
lemma comp_surjective {f : A →ₐ[R] B} {g : B →ₐ[R] C} (hf : f.finite_presentation) | |
(hg : surjective g) (hker : g.to_ring_hom.ker.fg) : (g.comp f).finite_presentation := | |
ring_hom.finite_presentation.comp_surjective hf hg hker | |
lemma of_surjective (f : A →ₐ[R] B) (hf : surjective f) (hker : f.to_ring_hom.ker.fg) : | |
f.finite_presentation := | |
ring_hom.finite_presentation.of_surjective f hf hker | |
lemma of_finite_type [is_noetherian_ring A] {f : A →ₐ[R] B} : | |
f.finite_type ↔ f.finite_presentation := | |
ring_hom.finite_presentation.of_finite_type | |
end finite_presentation | |
end alg_hom | |
section monoid_algebra | |
variables {R : Type*} {M : Type*} | |
namespace add_monoid_algebra | |
open algebra add_submonoid submodule | |
section span | |
section semiring | |
variables [comm_semiring R] [add_monoid M] | |
/-- An element of `add_monoid_algebra R M` is in the subalgebra generated by its support. -/ | |
lemma mem_adjoin_support (f : add_monoid_algebra R M) : f ∈ adjoin R (of' R M '' f.support) := | |
begin | |
suffices : span R (of' R M '' f.support) ≤ (adjoin R (of' R M '' f.support)).to_submodule, | |
{ exact this (mem_span_support f) }, | |
rw submodule.span_le, | |
exact subset_adjoin | |
end | |
/-- If a set `S` generates, as algebra, `add_monoid_algebra R M`, then the set of supports of | |
elements of `S` generates `add_monoid_algebra R M`. -/ | |
lemma support_gen_of_gen {S : set (add_monoid_algebra R M)} (hS : algebra.adjoin R S = ⊤) : | |
algebra.adjoin R (⋃ f ∈ S, (of' R M '' (f.support : set M))) = ⊤ := | |
begin | |
refine le_antisymm le_top _, | |
rw [← hS, adjoin_le_iff], | |
intros f hf, | |
have hincl : of' R M '' f.support ⊆ | |
⋃ (g : add_monoid_algebra R M) (H : g ∈ S), of' R M '' g.support, | |
{ intros s hs, | |
exact set.mem_Union₂.2 ⟨f, ⟨hf, hs⟩⟩ }, | |
exact adjoin_mono hincl (mem_adjoin_support f) | |
end | |
/-- If a set `S` generates, as algebra, `add_monoid_algebra R M`, then the image of the union of | |
the supports of elements of `S` generates `add_monoid_algebra R M`. -/ | |
lemma support_gen_of_gen' {S : set (add_monoid_algebra R M)} (hS : algebra.adjoin R S = ⊤) : | |
algebra.adjoin R (of' R M '' (⋃ f ∈ S, (f.support : set M))) = ⊤ := | |
begin | |
suffices : of' R M '' (⋃ f ∈ S, (f.support : set M)) = ⋃ f ∈ S, (of' R M '' (f.support : set M)), | |
{ rw this, | |
exact support_gen_of_gen hS }, | |
simp only [set.image_Union] | |
end | |
end semiring | |
section ring | |
variables [comm_ring R] [add_comm_monoid M] | |
/-- If `add_monoid_algebra R M` is of finite type, there there is a `G : finset M` such that its | |
image generates, as algera, `add_monoid_algebra R M`. -/ | |
lemma exists_finset_adjoin_eq_top [h : finite_type R (add_monoid_algebra R M)] : | |
∃ G : finset M, algebra.adjoin R (of' R M '' G) = ⊤ := | |
begin | |
unfreezingI { obtain ⟨S, hS⟩ := h }, | |
letI : decidable_eq M := classical.dec_eq M, | |
use finset.bUnion S (λ f, f.support), | |
have : (finset.bUnion S (λ f, f.support) : set M) = ⋃ f ∈ S, (f.support : set M), | |
{ simp only [finset.set_bUnion_coe, finset.coe_bUnion] }, | |
rw [this], | |
exact support_gen_of_gen' hS | |
end | |
/-- The image of an element `m : M` in `add_monoid_algebra R M` belongs the submodule generated by | |
`S : set M` if and only if `m ∈ S`. -/ | |
lemma of'_mem_span [nontrivial R] {m : M} {S : set M} : | |
of' R M m ∈ span R (of' R M '' S) ↔ m ∈ S := | |
begin | |
refine ⟨λ h, _, λ h, submodule.subset_span $ set.mem_image_of_mem (of R M) h⟩, | |
rw [of', ← finsupp.supported_eq_span_single, finsupp.mem_supported, | |
finsupp.support_single_ne_zero _ (@one_ne_zero R _ (by apply_instance))] at h, | |
simpa using h | |
end | |
/--If the image of an element `m : M` in `add_monoid_algebra R M` belongs the submodule generated by | |
the closure of some `S : set M` then `m ∈ closure S`. -/ | |
lemma mem_closure_of_mem_span_closure [nontrivial R] {m : M} {S : set M} | |
(h : of' R M m ∈ span R (submonoid.closure (of' R M '' S) : set (add_monoid_algebra R M))) : | |
m ∈ closure S := | |
begin | |
suffices : multiplicative.of_add m ∈ submonoid.closure (multiplicative.to_add ⁻¹' S), | |
{ simpa [← to_submonoid_closure] }, | |
let S' := @submonoid.closure M multiplicative.mul_one_class S, | |
have h' : submonoid.map (of R M) S' = submonoid.closure ((λ (x : M), (of R M) x) '' S) := | |
monoid_hom.map_mclosure _ _, | |
rw [set.image_congr' (show ∀ x, of' R M x = of R M x, from λ x, of'_eq_of x), ← h'] at h, | |
simpa using of'_mem_span.1 h | |
end | |
end ring | |
end span | |
variables [add_comm_monoid M] | |
/-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra, | |
`add_monoid_algebra R M`. -/ | |
lemma mv_polynomial_aeval_of_surjective_of_closure [comm_semiring R] {S : set M} | |
(hS : closure S = ⊤) : function.surjective (mv_polynomial.aeval | |
(λ (s : S), of' R M ↑s) : mv_polynomial S R → add_monoid_algebra R M) := | |
begin | |
refine λ f, induction_on f (λ m, _) _ _, | |
{ have : m ∈ closure S := hS.symm ▸ mem_top _, | |
refine closure_induction this (λ m hm, _) _ _, | |
{ exact ⟨mv_polynomial.X ⟨m, hm⟩, mv_polynomial.aeval_X _ _⟩ }, | |
{ exact ⟨1, alg_hom.map_one _⟩ }, | |
{ rintro m₁ m₂ ⟨P₁, hP₁⟩ ⟨P₂, hP₂⟩, | |
exact ⟨P₁ * P₂, by rw [alg_hom.map_mul, hP₁, hP₂, of_apply, of_apply, of_apply, | |
single_mul_single, one_mul]; refl⟩ } }, | |
{ rintro f g ⟨P, rfl⟩ ⟨Q, rfl⟩, | |
exact ⟨P + Q, alg_hom.map_add _ _ _⟩ }, | |
{ rintro r f ⟨P, rfl⟩, | |
exact ⟨r • P, alg_hom.map_smul _ _ _⟩ } | |
end | |
variables (R M) | |
/-- If an additive monoid `M` is finitely generated then `add_monoid_algebra R M` is of finite | |
type. -/ | |
instance finite_type_of_fg [comm_ring R] [h : add_monoid.fg M] : | |
finite_type R (add_monoid_algebra R M) := | |
begin | |
obtain ⟨S, hS⟩ := h.out, | |
exact (finite_type.mv_polynomial R (S : set M)).of_surjective (mv_polynomial.aeval | |
(λ (s : (S : set M)), of' R M ↑s)) (mv_polynomial_aeval_of_surjective_of_closure hS) | |
end | |
variables {R M} | |
/-- An additive monoid `M` is finitely generated if and only if `add_monoid_algebra R M` is of | |
finite type. -/ | |
lemma finite_type_iff_fg [comm_ring R] [nontrivial R] : | |
finite_type R (add_monoid_algebra R M) ↔ add_monoid.fg M := | |
begin | |
refine ⟨λ h, _, λ h, @add_monoid_algebra.finite_type_of_fg _ _ _ _ h⟩, | |
obtain ⟨S, hS⟩ := @exists_finset_adjoin_eq_top R M _ _ h, | |
refine add_monoid.fg_def.2 ⟨S, (eq_top_iff' _).2 (λ m, _)⟩, | |
have hm : of' R M m ∈ (adjoin R (of' R M '' ↑S)).to_submodule, | |
{ simp only [hS, top_to_submodule, submodule.mem_top], }, | |
rw [adjoin_eq_span] at hm, | |
exact mem_closure_of_mem_span_closure hm | |
end | |
/-- If `add_monoid_algebra R M` is of finite type then `M` is finitely generated. -/ | |
lemma fg_of_finite_type [comm_ring R] [nontrivial R] [h : finite_type R (add_monoid_algebra R M)] : | |
add_monoid.fg M := | |
finite_type_iff_fg.1 h | |
/-- An additive group `G` is finitely generated if and only if `add_monoid_algebra R G` is of | |
finite type. -/ | |
lemma finite_type_iff_group_fg {G : Type*} [add_comm_group G] [comm_ring R] [nontrivial R] : | |
finite_type R (add_monoid_algebra R G) ↔ add_group.fg G := | |
by simpa [add_group.fg_iff_add_monoid.fg] using finite_type_iff_fg | |
end add_monoid_algebra | |
namespace monoid_algebra | |
open algebra submonoid submodule | |
section span | |
section semiring | |
variables [comm_semiring R] [monoid M] | |
/-- An element of `monoid_algebra R M` is in the subalgebra generated by its support. -/ | |
lemma mem_adjoint_support (f : monoid_algebra R M) : f ∈ adjoin R (of R M '' f.support) := | |
begin | |
suffices : span R (of R M '' f.support) ≤ (adjoin R (of R M '' f.support)).to_submodule, | |
{ exact this (mem_span_support f) }, | |
rw submodule.span_le, | |
exact subset_adjoin | |
end | |
/-- If a set `S` generates, as algebra, `monoid_algebra R M`, then the set of supports of elements | |
of `S` generates `monoid_algebra R M`. -/ | |
lemma support_gen_of_gen {S : set (monoid_algebra R M)} (hS : algebra.adjoin R S = ⊤) : | |
algebra.adjoin R (⋃ f ∈ S, (of R M '' (f.support : set M))) = ⊤ := | |
begin | |
refine le_antisymm le_top _, | |
rw [← hS, adjoin_le_iff], | |
intros f hf, | |
have hincl : (of R M) '' f.support ⊆ | |
⋃ (g : monoid_algebra R M) (H : g ∈ S), of R M '' g.support, | |
{ intros s hs, | |
exact set.mem_Union₂.2 ⟨f, ⟨hf, hs⟩⟩ }, | |
exact adjoin_mono hincl (mem_adjoint_support f) | |
end | |
/-- If a set `S` generates, as algebra, `monoid_algebra R M`, then the image of the union of the | |
supports of elements of `S` generates `monoid_algebra R M`. -/ | |
lemma support_gen_of_gen' {S : set (monoid_algebra R M)} (hS : algebra.adjoin R S = ⊤) : | |
algebra.adjoin R (of R M '' (⋃ f ∈ S, (f.support : set M))) = ⊤ := | |
begin | |
suffices : of R M '' (⋃ f ∈ S, (f.support : set M)) = ⋃ f ∈ S, (of R M '' (f.support : set M)), | |
{ rw this, | |
exact support_gen_of_gen hS }, | |
simp only [set.image_Union] | |
end | |
end semiring | |
section ring | |
variables [comm_ring R] [comm_monoid M] | |
/-- If `monoid_algebra R M` is of finite type, there there is a `G : finset M` such that its image | |
generates, as algera, `monoid_algebra R M`. -/ | |
lemma exists_finset_adjoin_eq_top [h :finite_type R (monoid_algebra R M)] : | |
∃ G : finset M, algebra.adjoin R (of R M '' G) = ⊤ := | |
begin | |
unfreezingI { obtain ⟨S, hS⟩ := h }, | |
letI : decidable_eq M := classical.dec_eq M, | |
use finset.bUnion S (λ f, f.support), | |
have : (finset.bUnion S (λ f, f.support) : set M) = ⋃ f ∈ S, (f.support : set M), | |
{ simp only [finset.set_bUnion_coe, finset.coe_bUnion] }, | |
rw [this], | |
exact support_gen_of_gen' hS | |
end | |
/-- The image of an element `m : M` in `monoid_algebra R M` belongs the submodule generated by | |
`S : set M` if and only if `m ∈ S`. -/ | |
lemma of_mem_span_of_iff [nontrivial R] {m : M} {S : set M} : | |
of R M m ∈ span R (of R M '' S) ↔ m ∈ S := | |
begin | |
refine ⟨λ h, _, λ h, submodule.subset_span $ set.mem_image_of_mem (of R M) h⟩, | |
rw [of, monoid_hom.coe_mk, ← finsupp.supported_eq_span_single, finsupp.mem_supported, | |
finsupp.support_single_ne_zero _ (@one_ne_zero R _ (by apply_instance))] at h, | |
simpa using h | |
end | |
/--If the image of an element `m : M` in `monoid_algebra R M` belongs the submodule generated by the | |
closure of some `S : set M` then `m ∈ closure S`. -/ | |
lemma mem_closure_of_mem_span_closure [nontrivial R] {m : M} {S : set M} | |
(h : of R M m ∈ span R (submonoid.closure (of R M '' S) : set (monoid_algebra R M))) : | |
m ∈ closure S := | |
begin | |
rw ← monoid_hom.map_mclosure at h, | |
simpa using of_mem_span_of_iff.1 h | |
end | |
end ring | |
end span | |
variables [comm_monoid M] | |
/-- If a set `S` generates a monoid `M`, then the image of `M` generates, as algebra, | |
`monoid_algebra R M`. -/ | |
lemma mv_polynomial_aeval_of_surjective_of_closure [comm_semiring R] {S : set M} | |
(hS : closure S = ⊤) : function.surjective (mv_polynomial.aeval | |
(λ (s : S), of R M ↑s) : mv_polynomial S R → monoid_algebra R M) := | |
begin | |
refine λ f, induction_on f (λ m, _) _ _, | |
{ have : m ∈ closure S := hS.symm ▸ mem_top _, | |
refine closure_induction this (λ m hm, _) _ _, | |
{ exact ⟨mv_polynomial.X ⟨m, hm⟩, mv_polynomial.aeval_X _ _⟩ }, | |
{ exact ⟨1, alg_hom.map_one _⟩ }, | |
{ rintro m₁ m₂ ⟨P₁, hP₁⟩ ⟨P₂, hP₂⟩, | |
exact ⟨P₁ * P₂, by rw [alg_hom.map_mul, hP₁, hP₂, of_apply, of_apply, of_apply, | |
single_mul_single, one_mul]⟩ } }, | |
{ rintro f g ⟨P, rfl⟩ ⟨Q, rfl⟩, | |
exact ⟨P + Q, alg_hom.map_add _ _ _⟩ }, | |
{ rintro r f ⟨P, rfl⟩, | |
exact ⟨r • P, alg_hom.map_smul _ _ _⟩ } | |
end | |
/-- If a monoid `M` is finitely generated then `monoid_algebra R M` is of finite type. -/ | |
instance finite_type_of_fg [comm_ring R] [monoid.fg M] : finite_type R (monoid_algebra R M) := | |
(add_monoid_algebra.finite_type_of_fg R (additive M)).equiv (to_additive_alg_equiv R M).symm | |
/-- A monoid `M` is finitely generated if and only if `monoid_algebra R M` is of finite type. -/ | |
lemma finite_type_iff_fg [comm_ring R] [nontrivial R] : | |
finite_type R (monoid_algebra R M) ↔ monoid.fg M := | |
⟨λ h, monoid.fg_iff_add_fg.2 $ add_monoid_algebra.finite_type_iff_fg.1 $ h.equiv $ | |
to_additive_alg_equiv R M, λ h, @monoid_algebra.finite_type_of_fg _ _ _ _ h⟩ | |
/-- If `monoid_algebra R M` is of finite type then `M` is finitely generated. -/ | |
lemma fg_of_finite_type [comm_ring R] [nontrivial R] [h : finite_type R (monoid_algebra R M)] : | |
monoid.fg M := | |
finite_type_iff_fg.1 h | |
/-- A group `G` is finitely generated if and only if `add_monoid_algebra R G` is of finite type. -/ | |
lemma finite_type_iff_group_fg {G : Type*} [comm_group G] [comm_ring R] [nontrivial R] : | |
finite_type R (monoid_algebra R G) ↔ group.fg G := | |
by simpa [group.fg_iff_monoid.fg] using finite_type_iff_fg | |
end monoid_algebra | |
end monoid_algebra | |
section vasconcelos | |
variables {R : Type*} [comm_ring R] {M : Type*} [add_comm_group M] [module R M] (f : M →ₗ[R] M) | |
noncomputable theory | |
/-- The structure of a module `M` over a ring `R` as a module over `polynomial R` when given a | |
choice of how `X` acts by choosing a linear map `f : M →ₗ[R] M` -/ | |
@[simps] | |
def module_polynomial_of_endo : module R[X] M := | |
module.comp_hom M (polynomial.aeval f).to_ring_hom | |
include f | |
lemma module_polynomial_of_endo.is_scalar_tower : @is_scalar_tower R R[X] M _ | |
(by { letI := module_polynomial_of_endo f, apply_instance }) _ := | |
begin | |
letI := module_polynomial_of_endo f, | |
constructor, | |
intros x y z, | |
simp, | |
end | |
open polynomial module | |
/-- A theorem/proof by Vasconcelos, given a finite module `M` over a commutative ring, any | |
surjective endomorphism of `M` is also injective. Based on, | |
https://math.stackexchange.com/a/239419/31917, | |
https://www.ams.org/journals/tran/1969-138-00/S0002-9947-1969-0238839-5/. | |
This is similar to `is_noetherian.injective_of_surjective_endomorphism` but only applies in the | |
commutative case, but does not use a Noetherian hypothesis. -/ | |
theorem module.finite.injective_of_surjective_endomorphism [hfg : finite R M] | |
(f_surj : function.surjective f) : function.injective f := | |
begin | |
letI := module_polynomial_of_endo f, | |
haveI : is_scalar_tower R R[X] M := module_polynomial_of_endo.is_scalar_tower f, | |
have hfgpoly : finite R[X] M, from finite.of_restrict_scalars_finite R _ _, | |
have X_mul : ∀ o, (X : R[X]) • o = f o, | |
{ intro, | |
simp, }, | |
have : (⊤ : submodule R[X] M) ≤ ideal.span {X} • ⊤, | |
{ intros a ha, | |
obtain ⟨y, rfl⟩ := f_surj a, | |
rw [← X_mul y], | |
exact submodule.smul_mem_smul (ideal.mem_span_singleton.mpr (dvd_refl _)) trivial, }, | |
obtain ⟨F, hFa, hFb⟩ := submodule.exists_sub_one_mem_and_smul_eq_zero_of_fg_of_le_smul _ | |
(⊤ : submodule R[X] M) (finite_def.mp hfgpoly) this, | |
rw [← linear_map.ker_eq_bot, linear_map.ker_eq_bot'], | |
intros m hm, | |
rw ideal.mem_span_singleton' at hFa, | |
obtain ⟨G, hG⟩ := hFa, | |
suffices : (F - 1) • m = 0, | |
{ have Fmzero := hFb m (by simp), | |
rwa [← sub_add_cancel F 1, add_smul, one_smul, this, zero_add] at Fmzero, }, | |
rw [← hG, mul_smul, X_mul m, hm, smul_zero], | |
end | |
end vasconcelos | |