fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
Cotangent.val (x : P.Cotangent) : P.ker.Cotangent := x
@[ext] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.val | The identity map `P.Cotangent → P.ker.Cotangent` from the type synonym. |
Cotangent.ext {x y : P.Cotangent} (e : x.val = y.val) : x = y := e | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.ext | null |
@[simp] val_add : (x + y).val = x.val + y.val := rfl
@[simp] lemma val_zero : (0 : P.Cotangent).val = 0 := rfl
@[simp] lemma of_add : of (w + z) = of w + of z := rfl
@[simp] lemma of_zero : (of 0 : P.Cotangent) = 0 := rfl
@[simp] lemma of_val : of x.val = x := rfl
@[simp] lemma val_of : (of w).val = w := rfl
@[simp] lemma val_sub : (x - y).val = x.val - y.val := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | val_add | null |
Cotangent.smul_eq_zero_of_mem (p : P.Ring) (hp : p ∈ P.ker) (m : P.ker.Cotangent) :
p • m = 0 := by
obtain ⟨x, rfl⟩ := Ideal.toCotangent_surjective _ m
rw [← map_smul, Ideal.toCotangent_eq_zero, Submodule.coe_smul, smul_eq_mul, pow_two]
exact Ideal.mul_mem_mul hp x.2
attribute [local simp] RingHom.mem_ker | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.smul_eq_zero_of_mem | null |
noncomputable
Cotangent.module : Module S P.Cotangent where
smul := fun r s ↦ .of (P.σ r • s.val)
smul_zero := fun r ↦ ext (smul_zero (P.σ r))
smul_add := fun r x y ↦ ext (smul_add (P.σ r) x.val y.val)
add_smul := fun r s x ↦ by
have := smul_eq_zero_of_mem (P.σ (r + s) - (P.σ r + P.σ s) : P.Ring) (by simp ) x
simpa only [sub_smul, add_smul, sub_eq_zero]
zero_smul := fun x ↦ smul_eq_zero_of_mem (P.σ 0 : P.Ring) (by simp) x
one_smul := fun x ↦ by
have := smul_eq_zero_of_mem (P.σ 1 - 1 : P.Ring) (by simp) x
simpa [sub_eq_zero, sub_smul]
mul_smul := fun r s x ↦ by
have := smul_eq_zero_of_mem (P.σ (r * s) - (P.σ r * P.σ s) : P.Ring) (by simp) x
simpa only [sub_smul, mul_smul, sub_eq_zero] using this | instance | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.module | null |
Cotangent.val_smul''' {R₀} [CommRing R₀] [Algebra R₀ S] (r : R₀) (x : P.Cotangent) :
(r • x).val = P.σ (algebraMap R₀ S r) • x.val := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.val_smul''' | The action of `R₀` on `P.Cotangent` for an extension `P → S`, if `S` is an `R₀` algebra. |
@[simp]
Cotangent.val_smul (r : S) (x : P.Cotangent) : (r • x).val = P.σ r • x.val := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.val_smul | The action of `S` on `P.Cotangent` for an extension `P → S`. |
@[simp]
Cotangent.val_smul' (r : P.Ring) (x : P.Cotangent) : (r • x).val = r • x.val := by
rw [val_smul''', ← sub_eq_zero, ← sub_smul]
exact Cotangent.smul_eq_zero_of_mem _ (by simp) _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.val_smul' | The action of `P` on `P.Cotangent` for an extension `P → S`. |
@[simp]
Cotangent.val_smul'' (r : R) (x : P.Cotangent) : (r • x).val = r • x.val := by
rw [← algebraMap_smul P.Ring, val_smul', algebraMap_smul] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.val_smul'' | The action of `R` on `P.Cotangent` for an `R`-extension `P → S`. |
noncomputable Cotangent.mk : P.ker →ₗ[P.Ring] P.Cotangent where
toFun x := .of (Ideal.toCotangent _ x)
map_add' x y := by simp
map_smul' x y := ext <| by simp
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.mk | The quotient map from the kernel of `P → S` onto the cotangent space. |
Cotangent.val_mk (x : P.ker) : (mk x).val = Ideal.toCotangent _ x := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.val_mk | null |
Cotangent.mk_surjective : Function.Surjective (mk (P := P)) :=
fun x ↦ Ideal.toCotangent_surjective P.ker x.val | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.mk_surjective | null |
Cotangent.mk_eq_zero_iff {P : Extension R S} (x : P.ker) :
Cotangent.mk x = 0 ↔ x.val ∈ P.ker ^ 2 := by
simp [Cotangent.ext_iff, Ideal.toCotangent_eq_zero]
variable {P'}
variable [Algebra R R'] [Algebra R' R''] [Algebra R' S'']
variable [Algebra S S'] [Algebra S' S''] [Algebra S S'']
variable [Algebra R S'] [IsScalarTower R R' S'] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.mk_eq_zero_iff | null |
noncomputable
Cotangent.map (f : Hom P P') : P.Cotangent →ₗ[S] P'.Cotangent where
toFun x := .of (Ideal.mapCotangent (R := R) _ _ f.toAlgHom
(fun x hx ↦ by simpa using RingHom.congr_arg (algebraMap S S') hx) x.val)
map_add' x y := ext (map_add _ x.val y.val)
map_smul' r x := by
ext
obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x
obtain ⟨r, rfl⟩ := P.algebraMap_surjective r
simp only [algebraMap_smul, val_smul', val_mk, val_of, Ideal.mapCotangent_toCotangent,
RingHomCompTriple.comp_apply, ← (Ideal.toCotangent _).map_smul]
conv_rhs => rw [← algebraMap_smul S', ← f.algebraMap_toRingHom, algebraMap_smul, val_smul',
val_of, ← (Ideal.toCotangent _).map_smul]
congr 1
ext1
simp only [SetLike.val_smul, smul_eq_mul, map_mul, Hom.toAlgHom_apply]
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.map | A hom between two extensions induces a map between cotangent spaces. |
Cotangent.map_mk (f : Hom P P') (x) :
Cotangent.map f (.mk x) =
.mk ⟨f.toAlgHom x, by simpa [-map_aeval] using RingHom.congr_arg (algebraMap S S') x.2⟩ :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.map_mk | null |
Cotangent.map_id :
Cotangent.map (.id P) = LinearMap.id := by
ext x
obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x
simp only [map_mk, Hom.toAlgHom_id, AlgHom.coe_id, id_eq, Subtype.coe_eta, val_mk,
LinearMap.id_coe]
variable [Algebra R R''] [IsScalarTower R R' R''] [IsScalarTower R' R'' S'']
[Algebra R S''] [IsScalarTower R R'' S''] [IsScalarTower S S' S''] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.map_id | null |
Cotangent.map_comp (f : Hom P P') (g : Hom P' P'') :
Cotangent.map (g.comp f) = (map g).restrictScalars S ∘ₗ map f := by
ext x
obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x
simp only [map_mk, Hom.toAlgHom_apply, Hom.comp_toRingHom, RingHom.coe_comp, Function.comp_apply,
val_mk, LinearMap.coe_comp, LinearMap.coe_restrictScalars] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.map_comp | null |
Cotangent.finite (hP : P.ker.FG) :
Module.Finite S P.Cotangent := by
refine ⟨.of_restrictScalars (R := P.Ring) _ ?_⟩
rw [Submodule.restrictScalars_top, ← LinearMap.range_eq_top.mpr Extension.Cotangent.mk_surjective,
← Submodule.map_top]
exact (P.ker.fg_top.mpr hP).map _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Extension/Basic.lean | Cotangent.finite | null |
Algebra.Generators where
/-- The assignment of each variable to a value in `S`. -/
val : ι → S
/-- A section of `R[X] → S`. -/
σ' : S → MvPolynomial ι R
aeval_val_σ' : ∀ s, aeval val (σ' s) = s
/-- An `R[X]`-algebra instance on `S`. The default is the one induced by the map `R[X] → S`,
but this causes a diamond if there is an existing instance. -/
algebra : Algebra (MvPolynomial ι R) S := (aeval val).toAlgebra
algebraMap_eq :
algebraMap (MvPolynomial ι R) S = aeval (R := R) val := by rfl | structure | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Algebra.Generators | A family of generators of a `R`-algebra `S` consists of
1. `vars`: The type of variables.
2. `val : vars → S`: The assignment of each variable to a value in `S`.
3. `σ`: A section of `R[X] → S`. |
@[nolint unusedArguments]
protected
Ring (P : Generators R S ι) : Type (max w u) := MvPolynomial ι R | abbrev | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Ring | The polynomial ring w.r.t. a family of generators. |
σ : S → P.Ring := P.σ' | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | σ | The designated section of w.r.t. a family of generators. |
Simps.σ : S → P.Ring := P.σ
initialize_simps_projections Algebra.Generators (σ' → σ)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Simps.σ | See Note [custom simps projection] |
aeval_val_σ (s) : aeval P.val (P.σ s) = s := P.aeval_val_σ' s | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | aeval_val_σ | null |
@[simp]
algebraMap_apply (x) : algebraMap P.Ring S x = aeval (R := R) P.val x := by
simp [algebraMap_eq]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | algebraMap_apply | null |
σ_smul (x y) : P.σ x • y = x * y := by
rw [Algebra.smul_def, algebraMap_apply, aeval_val_σ] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | σ_smul | null |
σ_injective : P.σ.Injective := by
intro x y e
rw [← P.aeval_val_σ x, ← P.aeval_val_σ y, e] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | σ_injective | null |
algebraMap_surjective : Function.Surjective (algebraMap P.Ring S) :=
(⟨_, P.algebraMap_apply _ ▸ P.aeval_val_σ ·⟩) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | algebraMap_surjective | null |
@[simps val]
noncomputable
ofSurjective (val : ι → S) (h : Function.Surjective (aeval (R := R) val)) :
Generators R S ι where
val := val
σ' x := (h x).choose
aeval_val_σ' x := (h x).choose_spec | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofSurjective | Construct `Generators` from an assignment `I → S` such that `R[X] → S` is surjective. |
noncomputable ofSurjectiveAlgebraMap (h : Function.Surjective (algebraMap R S)) :
Generators R S PEmpty.{w + 1} :=
ofSurjective PEmpty.elim <| fun s ↦ by
use C (h s).choose
simp [(h s).choose_spec] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofSurjectiveAlgebraMap | If `algebraMap R S` is surjective, the empty type generates `S`. |
noncomputable id : Generators R R PEmpty.{w + 1} := ofSurjectiveAlgebraMap <| by
rw [algebraMap_self]
exact RingHomSurjective.is_surjective | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | id | The canonical generators for `R` as an `R`-algebra. |
noncomputable
ofAlgHom {I : Type*} (f : MvPolynomial I R →ₐ[R] S) (h : Function.Surjective f) :
Generators R S I :=
ofSurjective (f ∘ X) (by rwa [show aeval (f ∘ X) = f by ext; simp]) | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofAlgHom | Construct `Generators` from an assignment `I → S` such that `R[X] → S` is surjective. |
noncomputable
ofSet {s : Set S} (hs : Algebra.adjoin R s = ⊤) : Generators R S s := by
refine ofSurjective (Subtype.val : s → S) ?_
rwa [← AlgHom.range_eq_top, ← Algebra.adjoin_range_eq_range_aeval,
Subtype.range_coe_subtype, Set.setOf_mem_eq]
variable (R S) in | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofSet | Construct `Generators` from a family of generators of `S`. |
@[simps]
noncomputable
self : Generators R S S where
val := _root_.id
σ' := X
aeval_val_σ' := aeval_X _ | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | self | The `Generators` containing the whole algebra, which induces the canonical map `R[S] → S`. |
@[simps]
noncomputable
toExtension : Extension R S where
Ring := P.Ring
σ := P.σ
algebraMap_σ := by simp | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toExtension | The extension `R[X₁,...,Xₙ] → S` given a family of generators. |
@[simps val, simps -isSimp σ]
noncomputable
localizationAway : Generators R S Unit where
val _ := IsLocalization.Away.invSelf r
σ' s :=
letI a : R := (IsLocalization.Away.sec r s).1
letI n : ℕ := (IsLocalization.Away.sec r s).2
C a * X () ^ n
aeval_val_σ' s := by
rw [map_mul, algHom_C, map_pow, aeval_X]
simp only [← IsLocalization.Away.sec_spec, map_pow, IsLocalization.Away.invSelf]
rw [← IsLocalization.mk'_pow, one_pow, ← IsLocalization.mk'_one (M := Submonoid.powers r) S r]
rw [← IsLocalization.mk'_pow, one_pow, mul_assoc, ← IsLocalization.mk'_mul]
rw [mul_one, one_mul, IsLocalization.mk'_pow]
simp | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | localizationAway | If `S` is the localization of `R` away from `r`, we obtain a canonical generator mapping
to the inverse of `r`. |
@[simps val, simps -isSimp σ]
noncomputable
comp (Q : Generators S T ι') (P : Generators R S ι) : Generators R T (ι' ⊕ ι) where
val := Sum.elim Q.val (algebraMap S T ∘ P.val)
σ' x := (Q.σ x).sum (fun n r ↦ rename Sum.inr (P.σ r) * monomial (n.mapDomain Sum.inl) 1)
aeval_val_σ' s := by
have (x : P.Ring) : aeval (algebraMap S T ∘ P.val) x = algebraMap S T (aeval P.val x) := by
rw [map_aeval, aeval_def, coe_eval₂Hom, ← IsScalarTower.algebraMap_eq, Function.comp_def]
conv_rhs => rw [← Q.aeval_val_σ s, ← (Q.σ s).sum_single]
simp only [map_finsuppSum, map_mul, aeval_rename, Sum.elim_comp_inr, this, aeval_val_σ,
aeval_monomial, map_one, Finsupp.prod_mapDomain_index_inj Sum.inl_injective, Sum.elim_inl,
one_mul, single_eq_monomial]
variable (S) in | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | comp | Given two families of generators `S[X] → T` and `R[Y] → S`,
we may construct the family of generators `R[X, Y] → T`. |
@[simps val]
noncomputable
extendScalars (P : Generators R T ι) : Generators S T ι where
val := P.val
σ' x := map (algebraMap R S) (P.σ x)
aeval_val_σ' s := by simp [@aeval_def S, ← IsScalarTower.algebraMap_eq, ← @aeval_def R] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | extendScalars | If `R → S → T` is a tower of algebras, a family of generators `R[X] → T`
gives a family of generators `S[X] → T`. |
@[simps! val]
noncomputable
baseChange (T) [CommRing T] [Algebra R T] (P : Generators R S ι) :
Generators T (T ⊗[R] S) ι := by
apply Generators.ofSurjective (fun x ↦ 1 ⊗ₜ[R] P.val x)
intro x
induction x using TensorProduct.induction_on with
| zero => exact ⟨0, map_zero _⟩
| tmul a b =>
let X := P.σ b
use a • MvPolynomial.map (algebraMap R T) X
simp only [LinearMapClass.map_smul, X, aeval_map_algebraMap]
have : ∀ y : P.Ring,
aeval (fun x ↦ (1 ⊗ₜ[R] P.val x : T ⊗[R] S)) y = 1 ⊗ₜ aeval (fun x ↦ P.val x) y := by
intro y
induction y using MvPolynomial.induction_on with
| C a =>
rw [aeval_C, aeval_C, TensorProduct.algebraMap_apply, algebraMap_eq_smul_one, smul_tmul,
algebraMap_eq_smul_one]
| add p q hp hq => simp [map_add, tmul_add, hp, hq]
| mul_X p i hp => simp [hp]
rw [this, P.aeval_val_σ, smul_tmul', smul_eq_mul, mul_one]
| add x y ex ey =>
obtain ⟨a, ha⟩ := ex
obtain ⟨b, hb⟩ := ey
use (a + b)
rw [map_add, ha, hb] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | baseChange | If `P` is a family of generators of `S` over `R` and `T` is an `R`-algebra, we
obtain a natural family of generators of `T ⊗[R] S` over `T`. |
noncomputable reindex (P : Generators R S ι') (e : ι ≃ ι') :
Generators R S ι where
val := P.val ∘ e
σ' := rename e.symm ∘ P.σ
aeval_val_σ' s := by
conv_rhs => rw [← P.aeval_val_σ s]
rw [← MvPolynomial.aeval_rename]
simp | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | reindex | Given generators `P` and an equivalence `ι ≃ P.vars`, these
are the induced generators indexed by `ι`. |
reindex_val (P : Generators R S ι') (e : ι ≃ ι') :
(P.reindex e).val = P.val ∘ e :=
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | reindex_val | null |
@[simps val]
noncomputable
naive (s : MvPolynomial σ R ⧸ I → MvPolynomial σ R :=
Function.surjInv Ideal.Quotient.mk_surjective)
(hs : ∀ x, Ideal.Quotient.mk _ (s x) = x := by apply Function.surjInv_eq) :
Generators R (MvPolynomial σ R ⧸ I) σ where
val i := Ideal.Quotient.mk _ (X i)
σ' := s
aeval_val_σ' x := by
conv_rhs => rw [← hs x, ← Ideal.Quotient.mkₐ_eq_mk R, aeval_unique (Ideal.Quotient.mkₐ _ I)]
simp [Function.comp_def]
algebra := inferInstance
algebraMap_eq := by ext x <;> simp [IsScalarTower.algebraMap_apply R (MvPolynomial σ R)]
@[simp] lemma naive_σ : (Generators.naive s hs).σ = s := rfl | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | naive | The naive generators for a quotient `R[Xᵢ] ⧸ I`.
If the definitional equality of the section matters, it can be explicitly provided. |
@[ext]
Hom where
/-- The assignment of each variable in `I` to a value in `P' = R'[X']`. -/
val : ι → P'.Ring
aeval_val : ∀ i, aeval P'.val (val i) = algebraMap S S' (P.val i)
attribute [simp] Hom.aeval_val
variable {P P'} | structure | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom | Given a commuting square
R --→ P = R[X] ---→ S
| |
↓ ↓
R' -→ P' = R'[X'] → S
A hom between `P` and `P'` is an assignment `I → P'` such that the arrows commute.
Also see `Algebra.Generators.Hom.equivAlgHom`. |
noncomputable
Hom.toAlgHom (f : Hom P P') : P.Ring →ₐ[R] P'.Ring := MvPolynomial.aeval f.val
variable [Algebra R S'] [IsScalarTower R R' S'] [IsScalarTower R S S'] in
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toAlgHom | A hom between two families of generators gives
an algebra homomorphism between the polynomial rings. |
Hom.algebraMap_toAlgHom (f : Hom P P') (x) : MvPolynomial.aeval P'.val (f.toAlgHom x) =
algebraMap S S' (MvPolynomial.aeval P.val x) := by
suffices ((MvPolynomial.aeval P'.val).restrictScalars R).comp f.toAlgHom =
(IsScalarTower.toAlgHom R S S').comp (MvPolynomial.aeval P.val) from
DFunLike.congr_fun this x
apply MvPolynomial.algHom_ext
intro i
simp [Hom.toAlgHom]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.algebraMap_toAlgHom | null |
Hom.toAlgHom_X (f : Hom P P') (i) : f.toAlgHom (.X i) = f.val i :=
MvPolynomial.aeval_X f.val i | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toAlgHom_X | null |
Hom.toAlgHom_C (f : Hom P P') (r) : f.toAlgHom (.C r) = .C (algebraMap _ _ r) :=
MvPolynomial.aeval_C f.val r | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toAlgHom_C | null |
Hom.toAlgHom_monomial (f : Generators.Hom P P') (v r) :
f.toAlgHom (monomial v r) = r • v.prod (f.val · ^ ·) := by
rw [toAlgHom, aeval_monomial, Algebra.smul_def]
variable [Algebra R S'] [IsScalarTower R R' S'] [IsScalarTower R S S'] in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toAlgHom_monomial | null |
@[simps]
noncomputable
Hom.equivAlgHom :
Hom P P' ≃ { f : P.Ring →ₐ[R] P'.Ring //
∀ x, aeval P'.val (f x) = algebraMap S S' (aeval P.val x) } where
toFun f := ⟨f.toAlgHom, f.algebraMap_toAlgHom⟩
invFun f := ⟨fun i ↦ f.1 (.X i), fun i ↦ by simp [f.2]⟩
left_inv f := by ext; simp
right_inv f := by ext; simp
variable (P P') | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.equivAlgHom | Giving a hom between two families of generators is equivalent to
giving an algebra homomorphism between the polynomial rings. |
@[simps]
defaultHom : Hom P P' := ⟨P'.σ ∘ algebraMap S S' ∘ P.val, fun x ↦ by simp⟩ | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | defaultHom | The hom from `P` to `P'` given by the designated section of `P'`. |
@[simps]
protected noncomputable Hom.id : Hom P P := ⟨X, by simp⟩
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.id | The identity hom. |
Hom.toAlgHom_id : Hom.toAlgHom (.id P) = AlgHom.id _ _ := by ext1; simp
variable {P P' P''} | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toAlgHom_id | null |
@[simps]
noncomputable Hom.comp [IsScalarTower R' R'' S''] [IsScalarTower R' S' S'']
[IsScalarTower S S' S''] (f : Hom P' P'') (g : Hom P P') : Hom P P'' where
val x := aeval f.val (g.val x)
aeval_val x := by
rw [IsScalarTower.algebraMap_apply S S' S'', ← g.aeval_val]
induction g.val x using MvPolynomial.induction_on with
| C r => simp [← IsScalarTower.algebraMap_apply]
| add x y hx hy => simp only [map_add, hx, hy]
| mul_X p i hp => simp only [map_mul, hp, aeval_X, aeval_val]
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.comp | The composition of two homs. |
Hom.comp_id [Algebra R S'] [IsScalarTower R R' S'] [IsScalarTower R S S'] (f : Hom P P') :
f.comp (Hom.id P) = f := by ext; simp | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.comp_id | null |
@[simp]
Hom.id_comp [Algebra S S'] (f : Hom P P') : (Hom.id P').comp f = f := by
ext; simp [Hom.id, aeval_X_left]
variable [Algebra R R'] [Algebra R' R''] [Algebra R' S'']
variable [Algebra S S'] [Algebra S' S''] [Algebra S S'']
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.id_comp | null |
Hom.toAlgHom_comp_apply
[Algebra R R''] [IsScalarTower R R' R''] [IsScalarTower R' R'' S'']
[IsScalarTower R' S' S''] [IsScalarTower S S' S'']
(f : Hom P P') (g : Hom P' P'') (x) :
(g.comp f).toAlgHom x = g.toAlgHom (f.toAlgHom x) := by
induction x using MvPolynomial.induction_on with
| C r => simp only [← MvPolynomial.algebraMap_eq, AlgHom.map_algebraMap]
| add x y hx hy => simp only [map_add, hx, hy]
| mul_X p i hp => simp only [map_mul, hp, toAlgHom_X, comp_val]; rfl
variable {T : Type*} [CommRing T] [Algebra R T] [Algebra S T] [IsScalarTower R S T] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toAlgHom_comp_apply | null |
@[simps]
noncomputable
toComp (Q : Generators S T ι') (P : Generators R S ι) : Hom P (Q.comp P) where
val i := X (.inr i)
aeval_val i := by simp | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toComp | Given families of generators `X ⊆ T` over `S` and `Y ⊆ S` over `R`,
there is a map of generators `R[Y] → R[X, Y]`. |
toComp_toAlgHom (Q : Generators S T ι') (P : Generators R S ι) :
(Q.toComp P).toAlgHom = rename Sum.inr := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toComp_toAlgHom | null |
@[simps]
noncomputable
ofComp (Q : Generators S T ι') (P : Generators R S ι) : Hom (Q.comp P) Q where
val i := i.elim X (C ∘ P.val)
aeval_val i := by cases i <;> simp | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofComp | Given families of generators `X ⊆ T` over `S` and `Y ⊆ S` over `R`,
there is a map of generators `R[X, Y] → S[X]`. |
ofComp_toAlgHom_monomial_sumElim (Q : Generators S T ι') (P : Generators R S ι) (v₁ v₂ a) :
(Q.ofComp P).toAlgHom (monomial (Finsupp.sumElim v₁ v₂) a) =
monomial v₁ (aeval P.val (monomial v₂ a)) := by
rw [Hom.toAlgHom_monomial, monomial_eq]
simp only [ofComp_val, aeval_monomial]
rw [Finsupp.prod_sumElim]
simp only [Function.comp_def, Sum.elim_inl, Sum.elim_inr, ← map_pow, ← map_finsuppProd,
C_mul, Algebra.smul_def, MvPolynomial.algebraMap_apply, mul_assoc]
nth_rw 2 [mul_comm] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofComp_toAlgHom_monomial_sumElim | null |
toComp_toAlgHom_monomial (Q : Generators S T ι') (P : Generators R S ι) (j a) :
(Q.toComp P).toAlgHom (monomial j a) =
monomial (Finsupp.sumElim 0 j) a := by
convert rename_monomial _ _ _
ext f (i₁ | i₂) <;>
simp [Finsupp.mapDomain_notin_range, Finsupp.mapDomain_apply Sum.inr_injective]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toComp_toAlgHom_monomial | null |
toAlgHom_ofComp_rename (Q : Generators S T ι') (P : Generators R S ι) (p : P.Ring) :
(Q.ofComp P).toAlgHom ((rename Sum.inr) p) = C (algebraMap _ _ p) :=
have : (Q.ofComp P).toAlgHom.comp (rename Sum.inr) =
(IsScalarTower.toAlgHom R S Q.Ring).comp (IsScalarTower.toAlgHom R P.Ring S) := by ext; simp
DFunLike.congr_fun this p | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toAlgHom_ofComp_rename | null |
toAlgHom_ofComp_surjective (Q : Generators S T ι') (P : Generators R S ι) :
Function.Surjective (Q.ofComp P).toAlgHom := by
intro p
induction p using MvPolynomial.induction_on with
| C a =>
use MvPolynomial.rename Sum.inr (P.σ a)
simp only [Hom.toAlgHom, ofComp, Generators.comp, MvPolynomial.aeval_rename,
Sum.elim_comp_inr]
simp_rw [Function.comp_def, ← MvPolynomial.algebraMap_eq, ← IsScalarTower.toAlgHom_apply R,
← MvPolynomial.comp_aeval]
simp
| add p q hp hq =>
obtain ⟨p, rfl⟩ := hp
obtain ⟨q, rfl⟩ := hq
use p + q
simp
| mul_X p i hp =>
obtain ⟨(p : MvPolynomial (ι' ⊕ ι) R), rfl⟩ := hp
use p * MvPolynomial.X (R := R) (Sum.inl i)
simp [Algebra.Generators.ofComp, Algebra.Generators.Hom.toAlgHom] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toAlgHom_ofComp_surjective | null |
@[simps]
noncomputable
toExtendScalars (P : Generators R T ι) : Hom P (P.extendScalars S) where
val := X
aeval_val i := by simp
variable {P P'} in | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | toExtendScalars | Given families of generators `X ⊆ T`, there is a map `R[X] → S[X]`. |
@[simps]
noncomputable
Hom.toExtensionHom [Algebra R S'] [IsScalarTower R R' S'] [IsScalarTower R S S']
(f : P.Hom P') : P.toExtension.Hom P'.toExtension where
toRingHom := f.toAlgHom.toRingHom
toRingHom_algebraMap x := by simp
algebraMap_toRingHom x := by simp
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toExtensionHom | Reinterpret a hom between generators as a hom between extensions. |
Hom.toExtensionHom_id : Hom.toExtensionHom (.id P) = .id _ := by ext; simp
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toExtensionHom_id | null |
Hom.toExtensionHom_comp [Algebra R S'] [IsScalarTower R S S']
[Algebra R R''] [Algebra R S''] [IsScalarTower R R'' S'']
[IsScalarTower R S S''] [IsScalarTower R' R'' S''] [IsScalarTower R' S' S'']
[IsScalarTower S S' S''] [IsScalarTower R R' R''] [IsScalarTower R R' S']
(f : P'.Hom P'') (g : P.Hom P') :
toExtensionHom (f.comp g) = f.toExtensionHom.comp g.toExtensionHom := by ext; simp | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toExtensionHom_comp | null |
Hom.toExtensionHom_toAlgHom_apply [Algebra R S'] [IsScalarTower R R' S']
[IsScalarTower R S S'] (f : P.Hom P') (x) :
f.toExtensionHom.toAlgHom x = f.toAlgHom x := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | Hom.toExtensionHom_toAlgHom_apply | null |
noncomputable ker : Ideal P.Ring := P.toExtension.ker | abbrev | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ker | The kernel of a presentation. |
ker_eq_ker_aeval_val : P.ker = RingHom.ker (aeval P.val) := by
simp only [ker, Extension.ker, toExtension_Ring, algebraMap_eq]
rfl
variable {P} in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ker_eq_ker_aeval_val | null |
aeval_val_eq_zero {x} (hx : x ∈ P.ker) : aeval P.val x = 0 := by rwa [← algebraMap_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | aeval_val_eq_zero | null |
ker_naive {σ : Type*} {I : Ideal (MvPolynomial σ R)}
(s : MvPolynomial σ R ⧸ I → MvPolynomial σ R) (hs : ∀ x, Ideal.Quotient.mk _ (s x) = x) :
(Generators.naive s hs).ker = I :=
I.mk_ker | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ker_naive | null |
map_toComp_ker (Q : Generators S T ι') (P : Generators R S ι) :
P.ker.map (Q.toComp P).toAlgHom = RingHom.ker (Q.ofComp P).toAlgHom := by
letI : DecidableEq (ι' →₀ ℕ) := Classical.decEq _
apply le_antisymm
· rw [Ideal.map_le_iff_le_comap]
rintro x (hx : algebraMap P.Ring S x = 0)
have : (Q.ofComp P).toAlgHom.comp (Q.toComp P).toAlgHom = IsScalarTower.toAlgHom R _ _ := by
ext1; simp
simp only [Ideal.mem_comap,
RingHom.mem_ker, ← AlgHom.comp_apply, this, IsScalarTower.toAlgHom_apply]
rw [IsScalarTower.algebraMap_apply P.Ring S, hx, map_zero]
· rintro x (h₂ : (Q.ofComp P).toAlgHom x = 0)
let e : (ι' ⊕ ι →₀ ℕ) ≃+ (ι' →₀ ℕ) × (ι →₀ ℕ) :=
Finsupp.sumFinsuppAddEquivProdFinsupp
suffices ∑ v ∈ (support x).map e, (monomial (e.symm v)) (coeff (e.symm v) x) ∈
Ideal.map (Q.toComp P).toAlgHom.toRingHom P.ker by
simpa only [AlgHom.toRingHom_eq_coe, Finset.sum_map, Equiv.coe_toEmbedding,
EquivLike.coe_coe, AddEquiv.symm_apply_apply, support_sum_monomial_coeff] using this
rw [← Finset.sum_fiberwise_of_maps_to (fun i ↦ Finset.mem_image_of_mem Prod.fst)]
refine sum_mem fun i hi ↦ ?_
convert_to monomial (e.symm (i, 0)) 1 * (Q.toComp P).toAlgHom.toRingHom
(∑ j ∈ (support x).map e.toEmbedding with j.1 = i, monomial j.2 (coeff (e.symm j) x)) ∈ _
· rw [map_sum, Finset.mul_sum]
refine Finset.sum_congr rfl fun j hj ↦ ?_
obtain rfl := (Finset.mem_filter.mp hj).2
obtain ⟨i, j⟩ := j
clear hj hi
have : (Q.toComp P).toAlgHom (monomial j (coeff (e.symm (i, j)) x)) =
monomial (e.symm (0, j)) (coeff (e.symm (i, j)) x) :=
toComp_toAlgHom_monomial ..
simp only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
this]
rw [monomial_mul, ← map_add, Prod.mk_add_mk, add_zero, zero_add, one_mul]
· apply Ideal.mul_mem_left
refine Ideal.mem_map_of_mem _ ?_
simp only [ker_eq_ker_aeval_val, AddEquiv.toEquiv_eq_coe, RingHom.mem_ker, map_sum]
rw [← coeff_zero i, ← h₂]
clear h₂ hi
have (x : (Q.comp P).Ring) : (Function.support fun a ↦ if a.1 = i then aeval P.val
(monomial a.2 (coeff (e.symm a) x)) else 0) ⊆ ((support x).map e).toSet := by
rw [← Set.compl_subset_compl]
intro j
obtain ⟨j, rfl⟩ := e.surjective j
simp_all
rw [Finset.sum_filter, ← finsum_eq_sum_of_support_subset _ (this x)]
induction x using MvPolynomial.induction_on' with
| monomial v a =>
rw [finsum_eq_sum_of_support_subset _ (this _), ← Finset.sum_filter]
obtain ⟨v, rfl⟩ := e.symm.surjective v
conv_rhs => simp only [e, Finsupp.sumFinsuppAddEquivProdFinsupp,
Finsupp.sumFinsuppEquivProdFinsupp, AddEquiv.symm_mk, AddEquiv.coe_mk,
... | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | map_toComp_ker | null |
noncomputable
kerCompPreimage (Q : Generators S T ι') (P : Generators R S ι) (x : Q.ker) :
(Q.comp P).ker := by
refine ⟨x.1.sum fun n r ↦ ?_, ?_⟩
· -- The use of `refine` is intentional to control the elaboration order
refine rename ?_ (P.σ r) * monomial ?_ 1
exacts [Sum.inr, n.mapDomain Sum.inl]
· simp only [ker_eq_ker_aeval_val, RingHom.mem_ker]
conv_rhs => rw [← aeval_val_eq_zero x.2, ← x.1.support_sum_monomial_coeff]
simp only [Finsupp.sum, map_sum, map_mul, aeval_rename, Function.comp_def, comp_val,
Sum.elim_inr, aeval_monomial, map_one, Finsupp.prod_mapDomain_index_inj Sum.inl_injective,
Sum.elim_inl, one_mul]
congr! with v i
simp_rw [← IsScalarTower.toAlgHom_apply R, ← comp_aeval, AlgHom.comp_apply, P.aeval_val_σ,
coeff] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | kerCompPreimage | Given `R[X] → S` and `S[Y] → T`, this is the lift of an element in `ker(S[Y] → T)`
to `ker(R[X][Y] → S[Y] → T)` constructed from `P.σ`. |
ofComp_kerCompPreimage (Q : Generators S T ι') (P : Generators R S ι) (x : Q.ker) :
(Q.ofComp P).toAlgHom (kerCompPreimage Q P x) = x := by
conv_rhs => rw [← x.1.support_sum_monomial_coeff]
rw [kerCompPreimage, map_finsuppSum, Finsupp.sum]
refine Finset.sum_congr rfl fun j _ ↦ ?_
simp only [map_mul, Hom.toAlgHom_monomial]
rw [one_smul, Finsupp.prod_mapDomain_index_inj Sum.inl_injective]
rw [rename, ← AlgHom.comp_apply, comp_aeval]
simp only [ofComp_val, Sum.elim_inr, Function.comp_apply,
Sum.elim_inl, monomial_eq, Hom.toAlgHom_X]
congr 1
rw [aeval_def, IsScalarTower.algebraMap_eq R S, ← MvPolynomial.algebraMap_eq,
← coe_eval₂Hom, ← map_aeval, P.aeval_val_σ]
simp [coeff] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ofComp_kerCompPreimage | null |
map_ofComp_ker (Q : Generators S T ι') (P : Generators R S ι) :
Ideal.map (Q.ofComp P).toAlgHom (Q.comp P).ker = Q.ker := by
ext x
rw [Ideal.mem_map_iff_of_surjective _ (toAlgHom_ofComp_surjective Q P)]
constructor
· rintro ⟨x, hx, rfl⟩
simp only [ker_eq_ker_aeval_val,
RingHom.mem_ker] at hx ⊢
rw [← hx, Hom.algebraMap_toAlgHom, algebraMap_self_apply]
· intro hx
exact ⟨_, (kerCompPreimage Q P ⟨x, hx⟩).2, ofComp_kerCompPreimage Q P ⟨x, hx⟩⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | map_ofComp_ker | null |
ker_comp_eq_sup (Q : Generators S T ι') (P : Generators R S ι) :
(Q.comp P).ker =
Ideal.map (Q.toComp P).toAlgHom P.ker ⊔ Ideal.comap (Q.ofComp P).toAlgHom Q.ker := by
rw [← map_ofComp_ker Q P,
Ideal.comap_map_of_surjective _ (toAlgHom_ofComp_surjective Q P)]
rw [← sup_assoc, Algebra.Generators.map_toComp_ker, ← RingHom.ker_eq_comap_bot]
apply le_antisymm (le_trans le_sup_right le_sup_left)
simp only [le_sup_left, sup_of_le_left, sup_le_iff, le_refl, and_true]
intro x hx
simp only [RingHom.mem_ker] at hx
rw [Generators.ker_eq_ker_aeval_val, RingHom.mem_ker,
← algebraMap_self_apply (MvPolynomial.aeval _ x)]
rw [← Generators.Hom.algebraMap_toAlgHom (Q.ofComp P), hx, map_zero] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.MvPolynomial.Tower",
"Mathlib.RingTheory.TensorProduct.Basic",
"Mathlib.RingTheory.Extension.Basic"
] | Mathlib/RingTheory/Extension/Generators.lean | ker_comp_eq_sup | null |
IsFiltration (F : ι → σ) (F_lt : outParam <| ι → σ) : Prop where
mono : Monotone F
is_le {i j} : i < j → F i ≤ F_lt j
is_sup (B : σ) (j : ι) : (∀ i < j, F i ≤ B) → F_lt j ≤ B | class | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsFiltration | For a family of subsets `σ` of `A`, an increasing series of `F` in `σ` is a filtration if
there is another series `F_lt` in `σ` equal to the supremum of `F` with smaller index.
In the intended applications, `σ` is a complete lattice, and `F_lt` is uniquely-determined as
`F_lt j = ⨆ i < j, F i`. Thus `F_lt` is an implementation detail which allows us defer depending
on a complete lattice structure on `σ`. It also provides the ancillary benefit of giving us better
definition control. This is convenient e.g., when the index is `ℤ`. |
IsFiltration.F_lt_le_F (F : ι → σ) (F_lt : outParam <| ι → σ) (i : ι) [IsFiltration F F_lt] :
F_lt i ≤ F i :=
is_sup (F i) i (fun _ hi ↦ IsFiltration.mono (le_of_lt hi)) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsFiltration.F_lt_le_F | null |
IsFiltration.mk_int (F : ℤ → σ) (mono : Monotone F) :
IsFiltration F (fun n ↦ F (n - 1)) where
mono := mono
is_le lt := mono (Int.le_sub_one_of_lt lt)
is_sup _ j hi := hi (j - 1) (sub_one_lt j) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsFiltration.mk_int | A convenience constructor for `IsFiltration` when the index is the integers. |
IsRingFiltration (F : ι → σ) (F_lt : outParam <| ι → σ) : Prop
extends IsFiltration F F_lt, SetLike.GradedMonoid F | class | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsRingFiltration | For a family of subsets `σ` of semiring `R`, an increasing series `F` in `σ` is
a ring filtration if `IsFiltration F F_lt` and the pointwise multiplication of `F i` and `F j`
is in `F (i + j)`. |
IsRingFiltration.mk_int (F : ℤ → σ) (mono : Monotone F) [SetLike.GradedMonoid F] :
IsRingFiltration F (fun n ↦ F (n - 1)) where
__ := IsFiltration.mk_int F mono | lemma | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsRingFiltration.mk_int | A convenience constructor for `IsRingFiltration` when the index is the integers. |
IsModuleFiltration (F : ι → σ) (F_lt : outParam <| ι → σ) [IsRingFiltration F F_lt]
(F' : ιM → σM) (F'_lt : outParam <| ιM → σM) : Prop
extends IsFiltration F' F'_lt, SetLike.GradedSMul F F' | class | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsModuleFiltration | For `F` satisfying `IsRingFiltration F F_lt` in a semiring `R` and `σM` a family of subsets of
a `R` module `M`, an increasing series `FM` in `σM` is a module filtration if `IsFiltration F F_lt`
and the pointwise scalar multiplication of `F i` and `FM j` is in `F (i +ᵥ j)`.
The index set `ιM` for the module can be more general, however usually we take `ιM = ι`. |
IsModuleFiltration.mk_int (F : ℤ → σ) (mono : Monotone F) [SetLike.GradedMonoid F]
(F' : ℤ → σM) (mono' : Monotone F') [SetLike.GradedSMul F F'] :
letI := IsRingFiltration.mk_int F mono
IsModuleFiltration F (fun n ↦ F (n - 1)) F' (fun n ↦ F' (n - 1)) :=
letI := IsRingFiltration.mk_int F mono
{ IsFiltration.mk_int F' mono' with } | lemma | RingTheory | [
"Mathlib.Algebra.Module.Defs",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.Group.Submonoid.Defs",
"Mathlib.Algebra.GradedMulAction"
] | Mathlib/RingTheory/FilteredAlgebra/Basic.lean | IsModuleFiltration.mk_int | A convenience constructor for `IsModuleFiltration` when the index is the integers. |
fg_bot : (⊥ : Submodule R M).FG :=
⟨∅, by rw [Finset.coe_empty, span_empty]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_bot | null |
fg_span {s : Set M} (hs : s.Finite) : FG (span R s) :=
⟨hs.toFinset, by rw [hs.coe_toFinset]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_span | null |
fg_span_singleton (x : M) : FG (R ∙ x) :=
fg_span (finite_singleton x) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_span_singleton | null |
FG.sup {N₁ N₂ : Submodule R M} (hN₁ : N₁.FG) (hN₂ : N₂.FG) : (N₁ ⊔ N₂).FG :=
let ⟨t₁, ht₁⟩ := fg_def.1 hN₁
let ⟨t₂, ht₂⟩ := fg_def.1 hN₂
fg_def.2 ⟨t₁ ∪ t₂, ht₁.1.union ht₂.1, by rw [span_union, ht₁.2, ht₂.2]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | FG.sup | null |
fg_finset_sup {ι : Type*} (s : Finset ι) (N : ι → Submodule R M) (h : ∀ i ∈ s, (N i).FG) :
(s.sup N).FG :=
Finset.sup_induction fg_bot (fun _ ha _ hb => ha.sup hb) h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_finset_sup | null |
fg_biSup {ι : Type*} (s : Finset ι) (N : ι → Submodule R M) (h : ∀ i ∈ s, (N i).FG) :
(⨆ i ∈ s, N i).FG := by simpa only [Finset.sup_eq_iSup] using fg_finset_sup s N h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_biSup | null |
fg_iSup {ι : Sort*} [Finite ι] (N : ι → Submodule R M) (h : ∀ i, (N i).FG) :
(iSup N).FG := by
cases nonempty_fintype (PLift ι)
simpa [iSup_plift_down] using fg_biSup Finset.univ (N ∘ PLift.down) fun i _ => h i.down | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_iSup | null |
fg_pi {ι : Type*} {M : ι → Type*} [Finite ι] [∀ i, AddCommMonoid (M i)]
[∀ i, Module R (M i)] {p : ∀ i, Submodule R (M i)} (hsb : ∀ i, (p i).FG) :
(Submodule.pi Set.univ p).FG := by
classical
simp_rw [fg_def] at hsb ⊢
choose t htf hts using hsb
refine
⟨⋃ i, (LinearMap.single R _ i) '' t i, Set.finite_iUnion fun i => (htf i).image _, ?_⟩
simp_rw [span_iUnion, span_image _, hts, Submodule.iSup_map_single] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_pi | null |
FG.map {N : Submodule R M} (hs : N.FG) : (N.map f).FG :=
let ⟨t, ht⟩ := fg_def.1 hs
fg_def.2 ⟨f '' t, ht.1.image _, by rw [span_image, ht.2]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | FG.map | null |
fg_of_fg_map_injective (hf : Function.Injective f) {N : Submodule R M}
(hfn : (N.map f).FG) : N.FG :=
let ⟨t, ht⟩ := hfn
⟨t.preimage f fun _ _ _ _ h => hf h,
Submodule.map_injective_of_injective hf <| by
rw [map_span, Finset.coe_preimage, Set.image_preimage_eq_inter_range,
Set.inter_eq_self_of_subset_left, ht]
rw [← LinearMap.coe_range, ← span_le, ht, ← map_top]
exact map_mono le_top⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_of_fg_map_injective | null |
fg_of_fg_map {R M P : Type*} [Ring R] [AddCommGroup M] [Module R M] [AddCommGroup P]
[Module R P] (f : M →ₗ[R] P)
(hf : LinearMap.ker f = ⊥) {N : Submodule R M}
(hfn : (N.map f).FG) : N.FG :=
fg_of_fg_map_injective f (LinearMap.ker_eq_bot.1 hf) hfn | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_of_fg_map | null |
fg_top (N : Submodule R M) : (⊤ : Submodule R N).FG ↔ N.FG :=
⟨fun h => N.range_subtype ▸ map_top N.subtype ▸ h.map _, fun h =>
fg_of_fg_map_injective N.subtype Subtype.val_injective <| by rwa [map_top, range_subtype]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_top | null |
fg_of_linearEquiv (e : M ≃ₗ[R] P) (h : (⊤ : Submodule R P).FG) : (⊤ : Submodule R M).FG :=
e.symm.range ▸ map_top (e.symm : P →ₗ[R] M) ▸ h.map _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_of_linearEquiv | null |
fg_induction (R M : Type*) [Semiring R] [AddCommMonoid M] [Module R M]
(P : Submodule R M → Prop) (h₁ : ∀ x, P (Submodule.span R {x}))
(h₂ : ∀ M₁ M₂, P M₁ → P M₂ → P (M₁ ⊔ M₂)) (N : Submodule R M) (hN : N.FG) : P N := by
classical
obtain ⟨s, rfl⟩ := hN
induction s using Finset.induction with
| empty =>
rw [Finset.coe_empty, Submodule.span_empty, ← Submodule.span_zero_singleton]
exact h₁ _
| insert _ _ _ ih =>
rw [Finset.coe_insert, Submodule.span_insert]
exact h₂ _ _ (h₁ _) ih | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_induction | null |
fg_restrictScalars {R S M : Type*} [CommSemiring R] [Semiring S] [Algebra R S]
[AddCommMonoid M] [Module S M] [Module R M] [IsScalarTower R S M] (N : Submodule S M)
(hfin : N.FG) (h : Function.Surjective (algebraMap R S)) :
(Submodule.restrictScalars R N).FG := by
obtain ⟨X, rfl⟩ := hfin
use X
exact (Submodule.restrictScalars_span R S h (X : Set M)).symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | fg_restrictScalars | null |
FG.of_restrictScalars (R) {A M} [Semiring R] [Semiring A] [AddCommMonoid M]
[SMul R A] [Module R M] [Module A M] [IsScalarTower R A M] (S : Submodule A M)
(hS : (S.restrictScalars R).FG) : S.FG := by
obtain ⟨s, e⟩ := hS
refine ⟨s, Submodule.restrictScalars_injective R _ _ (le_antisymm ?_ ?_)⟩
· change Submodule.span A s ≤ S
have := Submodule.span_le.mp e.le
rwa [Submodule.span_le]
· rw [← e]
exact Submodule.span_le_restrictScalars _ _ _ | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | FG.of_restrictScalars | null |
FG.stabilizes_of_iSup_eq {M' : Submodule R M} (hM' : M'.FG) (N : ℕ →o Submodule R M)
(H : iSup N = M') : ∃ n, M' = N n := by
obtain ⟨S, hS⟩ := hM'
have : ∀ s : S, ∃ n, (s : M) ∈ N n := fun s =>
(Submodule.mem_iSup_of_chain N s).mp
(by
rw [H, ← hS]
exact Submodule.subset_span s.2)
choose f hf using this
use S.attach.sup f
apply le_antisymm
· conv_lhs => rw [← hS]
rw [Submodule.span_le]
intro s hs
exact N.2 (Finset.le_sup <| S.mem_attach ⟨s, hs⟩) (hf _)
· rw [← H]
exact le_iSup _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Order.Nonneg.Module",
"Mathlib.LinearAlgebra.Pi",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Finiteness.Defs"
] | Mathlib/RingTheory/Finiteness/Basic.lean | FG.stabilizes_of_iSup_eq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.