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 ⌀ |
|---|---|---|---|---|---|---|
map_comp_apply (f : Hom P P') (g : Hom P' P'') (x) :
CotangentSpace.map (g.comp f) x = .map g (.map f x) :=
DFunLike.congr_fun (map_comp f g) x | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | map_comp_apply | null |
map_cotangentComplex (f : Hom P P') (x) :
CotangentSpace.map f (P.cotangentComplex x) = P'.cotangentComplex (.map f x) := by
obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x
rw [cotangentComplex_mk, map_tmul, map_one, Cotangent.map_mk, cotangentComplex_mk] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | map_cotangentComplex | null |
map_comp_cotangentComplex (f : Hom P P') :
CotangentSpace.map f ∘ₗ P.cotangentComplex =
P'.cotangentComplex.restrictScalars S ∘ₗ Cotangent.map f := by
ext x; exact map_cotangentComplex f x | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | map_comp_cotangentComplex | null |
Hom.sub_aux (f g : Hom P P') (x y) :
letI := ((algebraMap S S').comp (algebraMap P.Ring S)).toAlgebra
f.toAlgHom (x * y) - g.toAlgHom (x * y) -
(P'.σ ((algebraMap P.Ring S') x) * (f.toAlgHom y - g.toAlgHom y) +
P'.σ ((algebraMap P.Ring S') y) * (f.toAlgHom x - g.toAlgHom x)) ∈
P'.ker ^ 2 := by
letI := ((algebraMap S S').comp (algebraMap P.Ring S)).toAlgebra
have :
(f.toAlgHom x - P'.σ (algebraMap P.Ring S' x)) * (f.toAlgHom y - g.toAlgHom y) +
(g.toAlgHom y - P'.σ (algebraMap P.Ring S' y)) * (f.toAlgHom x - g.toAlgHom x)
∈ P'.ker ^ 2 := by
rw [pow_two]
refine Ideal.add_mem _ (Ideal.mul_mem_mul ?_ ?_) (Ideal.mul_mem_mul ?_ ?_) <;>
simp only [RingHom.algebraMap_toAlgebra, RingHom.coe_comp,
Function.comp_apply,
ker, RingHom.mem_ker, map_sub, algebraMap_toRingHom,
algebraMap_σ, sub_self, toAlgHom_apply]
convert this using 1
simp only [map_mul]
ring | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Hom.sub_aux | null |
@[simps! apply_coe]
noncomputable
Hom.subToKer (f g : Hom P P') : P.Ring →ₗ[R] P'.ker := by
refine ((f.toAlgHom.toLinearMap - g.toAlgHom.toLinearMap).codRestrict
(P'.ker.restrictScalars R) ?_)
intro x
simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, ker,
Submodule.restrictScalars_mem, RingHom.mem_ker, map_sub, algebraMap_toRingHom,
sub_self, toAlgHom_apply]
variable [IsScalarTower R S S'] in | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Hom.subToKer | If `f` and `g` are two maps `P → P'` between presentations,
then the image of `f - g` is in the kernel of `P' → S`. |
noncomputable
Hom.sub (f g : Hom P P') : P.CotangentSpace →ₗ[S] P'.Cotangent := by
letI := ((algebraMap S S').comp (algebraMap P.Ring S)).toAlgebra
haveI : IsScalarTower P.Ring S S' := IsScalarTower.of_algebraMap_eq' rfl
letI := f.toAlgHom.toAlgebra
haveI : IsScalarTower P.Ring P'.Ring S' :=
IsScalarTower.of_algebraMap_eq fun x ↦ (f.algebraMap_toRingHom x).symm
haveI : IsScalarTower R P.Ring S' :=
IsScalarTower.of_algebraMap_eq fun x ↦
show algebraMap R S' x = algebraMap S S' (algebraMap P.Ring S (algebraMap R P.Ring x)) by
rw [← IsScalarTower.algebraMap_apply R P.Ring S, ← IsScalarTower.algebraMap_apply]
refine (Derivation.liftKaehlerDifferential ?_).liftBaseChange S
refine
{ __ := Cotangent.mk.restrictScalars R ∘ₗ f.subToKer g
map_one_eq_zero' := ?_
leibniz' := ?_ }
· ext
simp [Ideal.toCotangent_eq_zero]
· intro x y
ext
simp only [LinearMap.coe_comp, LinearMap.coe_restrictScalars, Function.comp_apply,
Cotangent.val_mk, Cotangent.val_add, Cotangent.val_smul''', ← map_smul, ← map_add,
Ideal.toCotangent_eq]
exact Hom.sub_aux f g x y
variable [IsScalarTower R S S'] | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Hom.sub | If `f` and `g` are two maps `P → P'` between presentations,
their difference induces a map `P.CotangentSpace →ₗ[S] P'.Cotangent` that makes two maps
between the cotangent complexes homotopic. |
Hom.sub_one_tmul (f g : Hom P P') (x) :
f.sub g (1 ⊗ₜ .D _ _ x) = Cotangent.mk (f.subToKer g x) := by
simp only [sub, LinearMap.liftBaseChange_tmul, Derivation.liftKaehlerDifferential_comp_D,
Derivation.mk_coe, LinearMap.coe_comp, LinearMap.coe_restrictScalars, Function.comp_apply,
one_smul]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Hom.sub_one_tmul | null |
Hom.sub_tmul (f g : Hom P P') (r x) :
f.sub g (r ⊗ₜ .D _ _ x) = r • Cotangent.mk (f.subToKer g x) := by
simp only [sub, LinearMap.liftBaseChange_tmul, Derivation.liftKaehlerDifferential_comp_D,
Derivation.mk_coe, LinearMap.coe_comp, LinearMap.coe_restrictScalars, Function.comp_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Hom.sub_tmul | null |
CotangentSpace.map_sub_map (f g : Hom P P') :
CotangentSpace.map f - CotangentSpace.map g =
P'.cotangentComplex.restrictScalars S ∘ₗ (f.sub g) := by
ext x
induction x using TensorProduct.induction_on with
| zero =>
simp only [map_zero]
| add =>
simp only [map_add, LinearMap.coe_comp, LinearMap.coe_restrictScalars, Function.comp_apply, *]
| tmul x y =>
obtain ⟨y, rfl⟩ := KaehlerDifferential.tensorProductTo_surjective _ _ y
induction y with
| zero => simp only [map_zero, tmul_zero]
| add => simp only [map_add, tmul_add, LinearMap.coe_comp, LinearMap.coe_restrictScalars,
Function.comp_apply, *]
| tmul =>
simp only [Derivation.tensorProductTo_tmul, tmul_smul, smul_tmul', LinearMap.sub_apply,
map_tmul, Hom.toAlgHom_apply, LinearMap.coe_comp, LinearMap.coe_restrictScalars,
Function.comp_apply, Hom.sub_tmul, LinearMap.map_smul_of_tower, cotangentComplex_mk,
Hom.subToKer_apply_coe, map_sub, ← algebraMap_eq_smul_one, tmul_sub, smul_sub] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | CotangentSpace.map_sub_map | null |
Cotangent.map_sub_map (f g : Hom P P') :
map f - map g = (f.sub g) ∘ₗ P.cotangentComplex := by
ext x
obtain ⟨x, rfl⟩ := mk_surjective x
simp only [LinearMap.sub_apply, map_mk, LinearMap.coe_comp, Function.comp_apply,
cotangentComplex_mk, Hom.sub_tmul, one_smul, val_mk]
apply (Ideal.cotangentEquivIdeal _).injective
ext
simp only [val_sub, val_mk, map_sub, AddSubgroupClass.coe_sub, Ideal.cotangentEquivIdeal_apply,
Ideal.toCotangent_to_quotient_square, Submodule.mkQ_apply, Ideal.Quotient.mk_eq_mk,
Hom.subToKer_apply_coe, Hom.toAlgHom_apply]
variable (P) in | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Cotangent.map_sub_map | null |
noncomputable
toKaehler : P.CotangentSpace →ₗ[S] Ω[S⁄R] := mapBaseChange _ _ _ | abbrev | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | toKaehler | The projection map from the relative cotangent space to the module of differentials. |
toKaehler_surjective : Function.Surjective P.toKaehler :=
mapBaseChange_surjective _ _ _ P.algebraMap_surjective | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | toKaehler_surjective | null |
exact_cotangentComplex_toKaehler : Function.Exact P.cotangentComplex P.toKaehler :=
exact_kerCotangentToTensor_mapBaseChange _ _ _ P.algebraMap_surjective
variable (P) in | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | exact_cotangentComplex_toKaehler | null |
protected noncomputable
H1Cotangent : Type _ := LinearMap.ker P.cotangentComplex
variable {P : Extension R S} | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent | The first homology of the (naive) cotangent complex of `S` over `R`,
induced by a given presentation `0 → I → P → R → 0`,
defined as the kernel of `I/I² → S ⊗[P] Ω[P⁄R]`. |
@[simp] H1Cotangent.val_add (x y : P.H1Cotangent) : (x + y).1 = x.1 + y.1 := rfl
@[simp] lemma H1Cotangent.val_zero : (0 : P.H1Cotangent).1 = 0 := rfl
@[simp] lemma H1Cotangent.val_smul {R₀} [CommRing R₀] [Algebra R₀ S] [Module R₀ P.Cotangent]
[IsScalarTower R₀ S P.Cotangent] (r : R₀) (x : P.H1Cotangent) : (r • x).1 = r • x.1 := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.val_add | null |
subsingleton_h1Cotangent (P : Extension R S) :
Subsingleton P.H1Cotangent ↔ Function.Injective P.cotangentComplex := by
delta Extension.H1Cotangent
rw [← LinearMap.ker_eq_bot, Submodule.eq_bot_iff, subsingleton_iff_forall_eq 0, Subtype.forall']
simp only [Subtype.ext_iff, Submodule.coe_zero] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | subsingleton_h1Cotangent | null |
@[simps!] noncomputable h1Cotangentι : P.H1Cotangent →ₗ[S] P.Cotangent := Submodule.subtype _ | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | h1Cotangentι | The inclusion of `H¹(L_{S/R})` into the conormal space of a presentation. |
h1Cotangentι_injective : Function.Injective P.h1Cotangentι := Subtype.val_injective
@[ext] lemma h1Cotangentι_ext (x y : P.H1Cotangent) (e : x.1 = y.1) : x = y := Subtype.ext e | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | h1Cotangentι_injective | null |
@[simps!]
noncomputable
H1Cotangent.map (f : Hom P P') : P.H1Cotangent →ₗ[S] P'.H1Cotangent := by
refine (Cotangent.map f).restrict (p := LinearMap.ker P.cotangentComplex)
(q := (LinearMap.ker P'.cotangentComplex).restrictScalars S) fun x hx ↦ ?_
simp only [LinearMap.mem_ker, Submodule.restrictScalars_mem] at hx ⊢
apply_fun (CotangentSpace.map f) at hx
rw [CotangentSpace.map_cotangentComplex] at hx
rw [hx]
exact LinearMap.map_zero _ | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.map | The induced map on the first homology of the (naive) cotangent complex. |
H1Cotangent.map_eq (f g : Hom P P') : map f = map g := by
ext x
simp only [map_apply_coe]
rw [← sub_eq_zero, ← Cotangent.val_sub, ← LinearMap.sub_apply, Cotangent.map_sub_map]
simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.map_coe_ker, map_zero,
Cotangent.val_zero]
@[simp] lemma H1Cotangent.map_id : map (.id P) = LinearMap.id := by ext; simp
omit [IsScalarTower R S S'] in | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.map_eq | null |
H1Cotangent.map_comp
(f : Hom P P') (g : Hom P' P'') :
map (g.comp f) = (map g).restrictScalars S ∘ₗ map f := by
ext; simp [Cotangent.map_comp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.map_comp | null |
@[simps! apply]
noncomputable
H1Cotangent.equiv {P₁ P₂ : Extension R S} (f₁ : P₁.Hom P₂) (f₂ : P₂.Hom P₁) :
P₁.H1Cotangent ≃ₗ[S] P₂.H1Cotangent where
__ := map f₁
invFun := map f₂
left_inv x :=
show (map f₂ ∘ₗ map f₁) x = LinearMap.id x by
rw [← Extension.H1Cotangent.map_id, eq_comm, map_eq _ (f₂.comp f₁),
Extension.H1Cotangent.map_comp]; rfl
right_inv x :=
show (map f₁ ∘ₗ map f₂) x = LinearMap.id x by
rw [← Extension.H1Cotangent.map_id, eq_comm, map_eq _ (f₁.comp f₂),
Extension.H1Cotangent.map_comp]; rfl | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.equiv | Maps `P₁ → P₂` and `P₂ → P₁` between extensions
induce an isomorphism between `H¹(L_P₁)` and `H¹(L_P₂)`. |
noncomputable
cotangentSpaceBasis : Basis ι S P.toExtension.CotangentSpace :=
(mvPolynomialBasis _ _).baseChange (R := P.Ring) _
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | cotangentSpaceBasis | The canonical basis on the `CotangentSpace`. |
cotangentSpaceBasis_repr_tmul (r x i) :
P.cotangentSpaceBasis.repr (r ⊗ₜ[P.Ring] KaehlerDifferential.D R P.Ring x : _) i =
r * aeval P.val (pderiv i x) := by
classical
simp only [cotangentSpaceBasis, Basis.baseChange_repr_tmul, mvPolynomialBasis_repr_apply,
Algebra.smul_def, mul_comm r, algebraMap_apply, toExtension] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | cotangentSpaceBasis_repr_tmul | null |
cotangentSpaceBasis_repr_one_tmul (x i) :
P.cotangentSpaceBasis.repr (1 ⊗ₜ .D _ _ x) i = aeval P.val (pderiv i x) := by
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | cotangentSpaceBasis_repr_one_tmul | null |
cotangentSpaceBasis_apply (i) :
P.cotangentSpaceBasis i = ((1 : S) ⊗ₜ[P.Ring] D R P.Ring (.X i) :) := by
simp [cotangentSpaceBasis, toExtension] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | cotangentSpaceBasis_apply | null |
@[simp]
repr_CotangentSpaceMap (f : Hom P P') (i j) :
P'.cotangentSpaceBasis.repr (CotangentSpace.map f.toExtensionHom (P.cotangentSpaceBasis i)) j =
aeval P'.val (pderiv j (f.val i)) := by
rw [cotangentSpaceBasis_apply]
simp only [toExtension]
rw [CotangentSpace.map_tmul, map_one]
erw [cotangentSpaceBasis_repr_one_tmul, Hom.toAlgHom_X]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | repr_CotangentSpaceMap | null |
toKaehler_cotangentSpaceBasis (i) :
P.toExtension.toKaehler (P.cotangentSpaceBasis i) = D R S (P.val i) := by
rw [cotangentSpaceBasis_apply]
exact (KaehlerDifferential.mapBaseChange_tmul ..).trans (by simp) | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | toKaehler_cotangentSpaceBasis | null |
@[simps! apply]
noncomputable
Generators.H1Cotangent.equiv (P : Generators R S ι) (P' : Generators R S ι') :
P.toExtension.H1Cotangent ≃ₗ[S] P'.toExtension.H1Cotangent :=
Extension.H1Cotangent.equiv
(Generators.defaultHom P P').toExtensionHom (Generators.defaultHom P' P).toExtensionHom
variable {S' : Type*} [CommRing S'] [Algebra R S']
variable {T : Type w} [CommRing T] [Algebra R T] [Algebra S T] [IsScalarTower R S T]
variable [Algebra S' T] [IsScalarTower R S' T]
variable (R S S' T) | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Generators.H1Cotangent.equiv | `H¹(L_{S/R})` is independent of the presentation chosen. |
H1Cotangent : Type _ := (Generators.self R S).toExtension.H1Cotangent | abbrev | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent | `H¹(L_{S/R})`, the first homology of the (naive) cotangent complex of `S` over `R`. |
noncomputable
H1Cotangent.map : H1Cotangent R S' →ₗ[S'] H1Cotangent S T :=
Extension.H1Cotangent.map (Generators.defaultHom _ _).toExtensionHom | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.map | The induced map on the first homology of the (naive) cotangent complex of `S` over `R`. |
noncomputable
H1Cotangent.mapEquiv (e : S ≃ₐ[R] S') :
H1Cotangent R S ≃ₗ[R] H1Cotangent R S' :=
letI := e.toRingHom.toAlgebra
letI := e.symm.toRingHom.toAlgebra
have : IsScalarTower R S S' := .of_algebraMap_eq' e.toAlgHom.comp_algebraMap.symm
have : IsScalarTower R S' S := .of_algebraMap_eq' e.symm.toAlgHom.comp_algebraMap.symm
have : IsScalarTower S S' S := .of_algebraMap_eq fun _ ↦ (e.symm_apply_apply _).symm
have : IsScalarTower S' S S' := .of_algebraMap_eq fun _ ↦ (e.apply_symm_apply _).symm
{ toFun := map R R S S'
invFun := map R R S' S
left_inv x := by
change ((map R R S' S).restrictScalars S ∘ₗ map R R S S') x = x
rw [map, map, ← Extension.H1Cotangent.map_comp, Extension.H1Cotangent.map_eq,
Extension.H1Cotangent.map_id, LinearMap.id_apply]
right_inv x := by
change ((map R R S S').restrictScalars S' ∘ₗ map R R S' S) x = x
rw [map, map, ← Extension.H1Cotangent.map_comp, Extension.H1Cotangent.map_eq,
Extension.H1Cotangent.map_id, LinearMap.id_apply]
map_add' := LinearMap.map_add (map R R S S')
map_smul' := LinearMap.CompatibleSMul.map_smul (map R R S S') }
variable {R S S' T} | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | H1Cotangent.mapEquiv | Isomorphic algebras induce isomorphic `H¹(L_{S/R})`. |
noncomputable
Generators.equivH1Cotangent (P : Generators R S ι) :
P.toExtension.H1Cotangent ≃ₗ[S] H1Cotangent R S :=
Generators.H1Cotangent.equiv _ _
attribute [local instance] Module.finitePresentation_of_projective in | abbrev | RingTheory | [
"Mathlib.RingTheory.Kaehler.Polynomial",
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/Basic.lean | Generators.equivH1Cotangent | `H¹(L_{S/R})` is independent of the presentation chosen. |
comp_localizationAway_ker (P : Generators R S ι) (f : P.Ring)
(h : algebraMap P.Ring S f = g) :
((Generators.localizationAway T g).comp P).ker =
Ideal.map ((Generators.localizationAway T g).toComp P).toAlgHom P.ker ⊔
Ideal.span {rename Sum.inr f * X (Sum.inl ()) - 1} := by
have : (localizationAway T g).ker = Ideal.map ((localizationAway T g).ofComp P).toAlgHom
(Ideal.span {MvPolynomial.rename Sum.inr f * MvPolynomial.X (Sum.inl ()) - 1}) := by
rw [Ideal.map_span, Set.image_singleton, map_sub, map_mul, map_one, ker_localizationAway,
Hom.toAlgHom_X, toAlgHom_ofComp_rename, h, ofComp_val, Sum.elim_inl]
rw [ker_comp_eq_sup, Algebra.Generators.map_toComp_ker, this,
Ideal.comap_map_of_surjective _ (toAlgHom_ofComp_surjective _ P), ← RingHom.ker_eq_comap_bot,
← sup_assoc]
simp
variable (T) in | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | comp_localizationAway_ker | null |
noncomputable
compLocalizationAwayAlgHom : ((Generators.localizationAway T g).comp P).Ring →ₐ[R]
Localization.Away (Ideal.Quotient.mk (P.ker ^ 2) (P.σ g)) :=
aeval (R := R) (S₁ := Localization.Away _)
(Sum.elim
(fun _ ↦ IsLocalization.Away.invSelf <| (Ideal.Quotient.mk (P.ker ^ 2) (P.σ g)))
(fun i : ι ↦ algebraMap P.Ring _ (X i)))
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | compLocalizationAwayAlgHom | If `R[X] → S` generates `S`, `T` is the localization of `S` away from `g` and
`f` is a pre-image of `g` in `R[X]`, this is the `R`-algebra map `R[X,Y] →ₐ[R] (R[X]/I²)[1/f]`
defined via mapping `Y` to `1/f`. |
compLocalizationAwayAlgHom_toAlgHom_toComp (x : P.Ring) :
compLocalizationAwayAlgHom T g P (((localizationAway T g).toComp P).toAlgHom x) =
algebraMap P.Ring _ x := by
simp only [toComp_toAlgHom, compLocalizationAwayAlgHom, comp,
localizationAway, AlgHom.toRingHom_eq_coe, aeval_rename,
Sum.elim_comp_inr, ← IsScalarTower.toAlgHom_apply (R := R), ← comp_aeval_apply,
aeval_X_left_apply]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | compLocalizationAwayAlgHom_toAlgHom_toComp | null |
compLocalizationAwayAlgHom_X_inl : compLocalizationAwayAlgHom T g P (X (Sum.inl ())) =
IsLocalization.Away.invSelf ((Ideal.Quotient.mk (P.ker ^ 2)) (P.σ g)) := by
simp [compLocalizationAwayAlgHom] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | compLocalizationAwayAlgHom_X_inl | null |
compLocalizationAwayAlgHom_relation_eq_zero :
compLocalizationAwayAlgHom T g P (rename Sum.inr (P.σ g) * X (Sum.inl ()) - 1) = 0 := by
rw [map_sub, map_one, map_mul, ← toComp_toAlgHom (Generators.localizationAway T g) P]
change (compLocalizationAwayAlgHom T g P)
(((localizationAway T g).toComp P).toAlgHom _) * _ - _ = _
rw [compLocalizationAwayAlgHom_toAlgHom_toComp, compLocalizationAwayAlgHom_X_inl,
IsScalarTower.algebraMap_apply P.Ring (P.Ring ⧸ P.ker ^ 2) (Localization.Away _)]
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | compLocalizationAwayAlgHom_relation_eq_zero | null |
sq_ker_comp_le_ker_compLocalizationAwayAlgHom :
((localizationAway T g).comp P).ker ^ 2 ≤
RingHom.ker (compLocalizationAwayAlgHom T g P) := by
have hsple {x} (hx : x ∈ Ideal.span {(rename Sum.inr) (P.σ g) * X (Sum.inl ()) - 1}) :
(compLocalizationAwayAlgHom T g P) x = 0 := by
obtain ⟨a, rfl⟩ := Ideal.mem_span_singleton.mp hx
rw [map_mul, compLocalizationAwayAlgHom_relation_eq_zero, zero_mul]
rw [comp_localizationAway_ker _ _ (P.σ g) (by simp), sq, Ideal.sup_mul, Ideal.mul_sup,
Ideal.mul_sup]
apply sup_le
· apply sup_le
· rw [← Ideal.map_mul, Ideal.map_le_iff_le_comap, ← sq]
intro x hx
simp only [Ideal.mem_comap, RingHom.mem_ker,
compLocalizationAwayAlgHom_toAlgHom_toComp (T := T) g P x]
rw [IsScalarTower.algebraMap_apply P.Ring (P.Ring ⧸ P.ker ^ 2) (Localization.Away _),
Ideal.Quotient.algebraMap_eq, Ideal.Quotient.eq_zero_iff_mem.mpr hx, map_zero]
· rw [Ideal.mul_le]
intro x hx y hy
simp [hsple hy]
· apply sup_le <;>
· rw [Ideal.mul_le]
intro x hx y hy
simp [hsple hx] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | sq_ker_comp_le_ker_compLocalizationAwayAlgHom | null |
@[stacks 08JZ "part of (1)"]
liftBaseChange_injective_of_isLocalizationAway :
Function.Injective (LinearMap.liftBaseChange T
(Extension.Cotangent.map
((Generators.localizationAway T g).toComp P).toExtensionHom)) := by
set Q := Generators.localizationAway T g
algebraize [((Generators.localizationAway T g).toComp P).toAlgHom.toRingHom]
let f : P.Ring ⧸ P.ker ^ 2 := P.σ g
let π := compLocalizationAwayAlgHom T g P
refine IsLocalizedModule.injective_of_map_zero (Submonoid.powers g)
(TensorProduct.mk S T P.toExtension.Cotangent 1) (fun x hx ↦ ?_)
obtain ⟨x, rfl⟩ := Algebra.Extension.Cotangent.mk_surjective x
suffices h : algebraMap P.Ring (Localization.Away f) x.val = 0 by
rw [IsScalarTower.algebraMap_apply _ (P.Ring ⧸ P.ker ^ 2) _,
IsLocalization.map_eq_zero_iff (Submonoid.powers f) (Localization.Away f)] at h
obtain ⟨⟨m, ⟨n, rfl⟩⟩, hm⟩ := h
rw [IsLocalizedModule.eq_zero_iff (Submonoid.powers g)]
use ⟨g ^ n, n, rfl⟩
dsimp [f] at hm
rw [← map_pow, ← map_mul, Ideal.Quotient.eq_zero_iff_mem] at hm
simp only [Submonoid.smul_def]
rw [show g = algebraMap P.Ring S (P.σ g) by simp, ← map_pow, algebraMap_smul, ← map_smul,
Extension.Cotangent.mk_eq_zero_iff]
simpa using hm
rw [← compLocalizationAwayAlgHom_toAlgHom_toComp (T := T)]
apply sq_ker_comp_le_ker_compLocalizationAwayAlgHom
simpa only [LinearEquiv.coe_coe, LinearMap.ringLmapEquivSelf_symm_apply,
mk_apply, lift.tmul, LinearMap.coe_restrictScalars, LinearMap.coe_smulRight,
Module.End.one_apply, LinearMap.smul_apply, one_smul, Algebra.Extension.Cotangent.map_mk,
Extension.Cotangent.mk_eq_zero_iff] using hx | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Cotangent/LocalizationAway.lean | liftBaseChange_injective_of_isLocalizationAway | Let `R → S → T` be algebras such that `T` is the localization of `S` away from one
element, where `S` is generated over `R` by `P` with kernel `I` and `Q` is the
canonical `S`-presentation of `T`. Denote by `J` the kernel of the composition
`R[X,Y] → T`. Then `T ⊗[S] (I/I²) → J/J²` is injective. |
@[nolint checkUnivs]
Algebra.Presentation extends Algebra.Generators R S ι where
/-- The assignment of each relation to a polynomial in the generators. -/
relation : σ → toGenerators.Ring
/-- The relations span the kernel of the canonical map. -/
span_range_relation_eq_ker :
Ideal.span (Set.range relation) = toGenerators.ker | structure | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | Algebra.Presentation | A presentation of an `R`-algebra `S` is a family of
generators with `σ → MvPolynomial ι R`: The assignment of
each relation to a polynomial in the generators. |
@[simp]
aeval_val_relation (i) : aeval P.val (P.relation i) = 0 := by
rw [← RingHom.mem_ker, ← P.ker_eq_ker_aeval_val, ← P.span_range_relation_eq_ker]
exact Ideal.subset_span ⟨i, rfl⟩ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aeval_val_relation | null |
relation_mem_ker (i) : P.relation i ∈ P.ker := by
rw [← P.span_range_relation_eq_ker]
apply Ideal.subset_span
use i | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | relation_mem_ker | null |
protected Quotient : Type (max w u) := P.Ring ⧸ P.ker | abbrev | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | Quotient | The polynomial algebra w.r.t. a family of generators modulo a family of relations. |
quotientEquiv : P.Quotient ≃ₐ[P.Ring] S :=
Ideal.quotientKerAlgEquivOfRightInverse (f := Algebra.ofId P.Ring S) (g := P.σ) <| fun x ↦ by
rw [Algebra.ofId_apply, P.algebraMap_apply, P.aeval_val_σ]
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | quotientEquiv | `P.Quotient` is `P.Ring`-isomorphic to `S` and in particular `R`-isomorphic to `S`. |
quotientEquiv_mk (p : P.Ring) : P.quotientEquiv p = algebraMap P.Ring S p :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | quotientEquiv_mk | null |
quotientEquiv_symm (x : S) : P.quotientEquiv.symm x = P.σ x :=
rfl
set_option linter.unusedVariables false in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | quotientEquiv_symm | null |
@[nolint unusedArguments]
noncomputable dimension (P : Presentation R S ι σ) : ℕ :=
Nat.card ι - Nat.card σ | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | dimension | Dimension of a presentation defined as the cardinality of the generators
minus the cardinality of the relations.
Note: this definition is completely non-sensical for non-finite presentations and
even then for this to make sense, you should assume that the presentation
is a complete intersection. |
fg_ker [Finite σ] : P.ker.FG := by
use (Set.finite_range P.relation).toFinset
simp [span_range_relation_eq_ker]
@[deprecated (since := "2025-05-27")] alias ideal_fg_of_isFinite := fg_ker | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | fg_ker | null |
noncomputable
ofFinitePresentationVars [FinitePresentation R S] : ℕ :=
(exists_presentation_fin R S).choose
variable (R S) in | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | ofFinitePresentationVars | If a presentation is finite, the corresponding quotient is
of finite presentation. -/
instance [Finite σ] [Finite ι] : FinitePresentation R P.Quotient :=
FinitePresentation.quotient P.fg_ker
lemma finitePresentation_of_isFinite [Finite σ] [Finite ι] (P : Presentation R S ι σ) :
FinitePresentation R S :=
FinitePresentation.equiv (P.quotientEquiv.restrictScalars R)
variable (R S) in
lemma exists_presentation_fin [FinitePresentation R S] :
∃ n m, Nonempty (Presentation R S (Fin n) (Fin m)) :=
letI H := FinitePresentation.out (R := R) (A := S)
letI n : ℕ := H.choose
letI f : MvPolynomial (Fin n) R →ₐ[R] S := H.choose_spec.choose
haveI hf : Function.Surjective f := H.choose_spec.choose_spec.1
haveI hf' : (RingHom.ker f).FG := H.choose_spec.choose_spec.2
letI H' := Submodule.fg_iff_exists_fin_generating_family.mp hf'
let m : ℕ := H'.choose
let v : Fin m → MvPolynomial (Fin n) R := H'.choose_spec.choose
have hv : Ideal.span (Set.range v) = RingHom.ker f := H'.choose_spec.choose_spec
⟨n, m,
⟨{__ := Generators.ofSurjective (fun x ↦ f (.X x)) (by convert hf; ext; simp)
relation := v
span_range_relation_eq_ker := hv.trans (by congr; ext; simp) }⟩⟩
variable (R S) in
/-- The index of generators to `ofFinitePresentation`. |
noncomputable
ofFinitePresentationRels [FinitePresentation R S] : ℕ :=
(exists_presentation_fin R S).choose_spec.choose
variable (R S) in | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | ofFinitePresentationRels | The index of relations to `ofFinitePresentation`. |
noncomputable
ofFinitePresentation [FinitePresentation R S] :
Presentation R S (Fin (ofFinitePresentationVars R S)) (Fin (ofFinitePresentationRels R S)) :=
(exists_presentation_fin R S).choose_spec.choose_spec.some | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | ofFinitePresentation | An arbitrary choice of a finite presentation of a finitely presented algebra. |
noncomputable ofBijectiveAlgebraMap (h : Function.Bijective (algebraMap R S)) :
Presentation R S PEmpty.{w + 1} PEmpty.{t + 1} where
__ := Generators.ofSurjectiveAlgebraMap h.surjective
relation := PEmpty.elim
span_range_relation_eq_ker := by
simp only [Set.range_eq_empty, Ideal.span_empty]
symm
rw [← RingHom.injective_iff_ker_eq_bot]
change Function.Injective (aeval PEmpty.elim)
rw [aeval_injective_iff_of_isEmpty]
exact h.injective | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | ofBijectiveAlgebraMap | If `algebraMap R S` is bijective, the empty generators are a presentation with no relations. |
ofBijectiveAlgebraMap_dimension (h : Function.Bijective (algebraMap R S)) :
(ofBijectiveAlgebraMap h).dimension = 0 := by
simp [dimension]
variable (R) in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | ofBijectiveAlgebraMap_dimension | null |
noncomputable id : Presentation R R PEmpty.{w + 1} PEmpty.{t + 1} :=
ofBijectiveAlgebraMap Function.bijective_id | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | id | The canonical `R`-presentation of `R` with no generators and no relations. |
id_dimension : (Presentation.id R).dimension = 0 :=
ofBijectiveAlgebraMap_dimension (R := R) Function.bijective_id | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | id_dimension | null |
_root_.Algebra.Generators.ker_localizationAway :
(Generators.localizationAway S r).ker = Ideal.span { C r * X () - 1 } := by
have : aeval (S₁ := S) (Generators.localizationAway S r).val =
(mvPolynomialQuotientEquiv S r).toAlgHom.comp
(Ideal.Quotient.mkₐ R (Ideal.span {C r * X () - 1})) := by
ext x
simp only [aeval_X, Generators.localizationAway_val,
AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_comp, AlgHom.coe_coe, Ideal.Quotient.mkₐ_eq_mk,
Function.comp_apply]
rw [IsLocalization.Away.mvPolynomialQuotientEquiv_apply, aeval_X]
rw [Generators.ker_eq_ker_aeval_val, this, AlgEquiv.toAlgHom_eq_coe, ← RingHom.ker_coe_toRingHom,
AlgHom.comp_toRingHom, ← RingHom.comap_ker]
simp only [AlgEquiv.toAlgHom_toRingHom]
change Ideal.comap _ (RingHom.ker (mvPolynomialQuotientEquiv S r)) = Ideal.span {C r * X () - 1}
simp [RingHom.ker_equiv, ← RingHom.ker_eq_comap_bot]
variable (S) in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | _root_.Algebra.Generators.ker_localizationAway | null |
@[simps relation]
noncomputable localizationAway : Presentation R S Unit Unit where
toGenerators := Generators.localizationAway S r
relation _ := C r * X () - 1
span_range_relation_eq_ker := by
simp only [Set.range_const]
exact (Generators.ker_localizationAway r).symm
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | localizationAway | If `S` is the localization of `R` away from `r`, we can construct a natural
presentation of `S` as `R`-algebra with a single generator `X` and the relation `r * X - 1 = 0`. |
localizationAway_dimension_zero : (localizationAway S r).dimension = 0 := by
simp [Presentation.dimension] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | localizationAway_dimension_zero | null |
private span_range_relation_eq_ker_baseChange :
Ideal.span (Set.range fun i ↦ (MvPolynomial.map (algebraMap R T)) (P.relation i)) =
RingHom.ker (aeval (S₁ := T ⊗[R] S) (P.baseChange T).val) := by
apply le_antisymm
· rw [Ideal.span_le]
intro x ⟨y, hy⟩
have Z := aeval_val_relation P y
apply_fun TensorProduct.includeRight (R := R) (A := T) at Z
rw [map_zero] at Z
simp only [SetLike.mem_coe, RingHom.mem_ker, ← Z, ← hy,
TensorProduct.includeRight_apply]
erw [aeval_map_algebraMap T (P.baseChange T).val (P.relation y)]
change _ = TensorProduct.includeRight.toRingHom _
rw [map_aeval, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
TensorProduct.includeRight.comp_algebraMap]
rfl
· intro x hx
rw [RingHom.mem_ker] at hx
have H := Algebra.TensorProduct.lTensor_ker (A := T) (IsScalarTower.toAlgHom R P.Ring S)
P.algebraMap_surjective
let e := MvPolynomial.algebraTensorAlgEquiv (R := R) (σ := ι) (A := T)
have H' : e.symm x ∈ RingHom.ker (TensorProduct.map (AlgHom.id R T)
(IsScalarTower.toAlgHom R P.Ring S)) := by
rw [RingHom.mem_ker, ← hx]
clear hx
induction x using MvPolynomial.induction_on with
| C a =>
simp only [algHom_C, TensorProduct.algebraMap_apply,
algebraMap_self, RingHom.id_apply, e]
rw [← MvPolynomial.algebraMap_eq, AlgEquiv.commutes]
simp only [TensorProduct.algebraMap_apply, algebraMap_self, RingHom.id_apply,
TensorProduct.map_tmul, AlgHom.coe_id, id_eq, map_one]
| add p q hp hq => simp only [map_add, hp, hq]
| mul_X p i hp => simp [hp, e]
rw [H] at H'
replace H' : e.symm x ∈ Ideal.map TensorProduct.includeRight P.ker := H'
rw [← P.span_range_relation_eq_ker, ← Ideal.mem_comap, ← Ideal.comap_coe,
← AlgEquiv.toRingEquiv_toRingHom, Ideal.comap_coe, AlgEquiv.symm_toRingEquiv,
Ideal.comap_symm, ← Ideal.map_coe, ← Ideal.map_coe _ (Ideal.span _), Ideal.map_map,
Ideal.map_span, ← Set.range_comp, AlgEquiv.toRingEquiv_toRingHom, RingHom.coe_comp,
RingHom.coe_coe] at H'
convert H'
simp [e] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | span_range_relation_eq_ker_baseChange | null |
@[simps relation]
noncomputable
baseChange : Presentation T (T ⊗[R] S) ι σ where
__ := P.toGenerators.baseChange T
relation i := MvPolynomial.map (algebraMap R T) (P.relation i)
span_range_relation_eq_ker := P.span_range_relation_eq_ker_baseChange T | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | baseChange | If `P` is a presentation of `S` over `R` and `T` is an `R`-algebra, we
obtain a natural presentation of `T ⊗[R] S` over `T`. |
baseChange_toGenerators : (P.baseChange T).toGenerators = P.toGenerators.baseChange T := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | baseChange_toGenerators | null |
private noncomputable aux (Q : Presentation S T ι' σ') (P : Presentation R S ι σ) :
MvPolynomial (ι' ⊕ ι) R →ₐ[R] MvPolynomial ι' S :=
aeval (Sum.elim X (MvPolynomial.C ∘ P.val)) | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aux | The evaluation map `MvPolynomial (ι' ⊕ ι) →ₐ[R] T` factors via this map. For more
details, see the module docstring at the beginning of the section. |
private noncomputable comp_relation_aux (r : σ') : MvPolynomial (ι' ⊕ ι) R :=
Finsupp.sum (Q.relation r)
(fun x j ↦ (MvPolynomial.rename Sum.inr <| P.σ j) * monomial (x.mapDomain Sum.inl) 1)
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | comp_relation_aux | A choice of pre-image of `Q.relation r` under `aux`. |
private aux_X (i : ι' ⊕ ι) : (Q.aux P) (X i) = Sum.elim X (C ∘ P.val) i :=
aeval_X (Sum.elim X (C ∘ P.val)) i | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aux_X | null |
private comp_relation_aux_map (r : σ') :
(Q.aux P) (Q.comp_relation_aux P r) = Q.relation r := by
simp only [aux, comp_relation_aux, map_finsuppSum]
simp only [map_mul, aeval_rename, aeval_monomial, Sum.elim_comp_inr]
conv_rhs => rw [← Finsupp.sum_single (Q.relation r)]
congr
ext u s m
simp only [MvPolynomial.single_eq_monomial, aeval, AlgHom.coe_mk, coe_eval₂Hom]
rw [monomial_eq, IsScalarTower.algebraMap_eq R S, algebraMap_eq, ← eval₂_comp_left, ← aeval_def]
simp [Finsupp.prod_mapDomain_index_inj (Sum.inl_injective)] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | comp_relation_aux_map | The pre-images constructed in `comp_relation_aux` are indeed pre-images under `aux`. |
private aux_surjective : Function.Surjective (Q.aux P) := fun p ↦ by
induction p using MvPolynomial.induction_on with
| C a =>
use rename Sum.inr <| P.σ a
simp only [aux, aeval_rename, Sum.elim_comp_inr]
have (p : MvPolynomial ι R) :
aeval (C ∘ P.val) p = (C (aeval P.val p) : MvPolynomial ι' S) := by
induction p using MvPolynomial.induction_on with
| C a => simp
| add p q hp hq => simp [hp, hq]
| mul_X p i h => simp [h]
simp [this]
| add p q hp hq =>
obtain ⟨a, rfl⟩ := hp
obtain ⟨b, rfl⟩ := hq
exact ⟨a + b, map_add _ _ _⟩
| mul_X p i h =>
obtain ⟨a, rfl⟩ := h
exact ⟨(a * X (Sum.inl i)), by simp⟩ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aux_surjective | null |
private aux_image_relation :
Q.aux P '' (Set.range (Algebra.Presentation.comp_relation_aux Q P)) = Set.range Q.relation := by
ext x
constructor
· rintro ⟨y, ⟨a, rfl⟩, rfl⟩
exact ⟨a, (Q.comp_relation_aux_map P a).symm⟩
· rintro ⟨y, rfl⟩
use Q.comp_relation_aux P y
simp only [Set.mem_range, exists_apply_eq_apply, true_and, comp_relation_aux_map] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aux_image_relation | null |
private aux_eq_comp : Q.aux P =
(MvPolynomial.mapAlgHom (aeval P.val)).comp (sumAlgEquiv R ι' ι).toAlgHom := by
ext i : 1
cases i <;> simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aux_eq_comp | null |
private aux_ker :
RingHom.ker (Q.aux P) = Ideal.map (rename Sum.inr) (RingHom.ker (aeval P.val)) := by
rw [aux_eq_comp, ← AlgHom.comap_ker, MvPolynomial.ker_mapAlgHom]
change Ideal.comap _ (Ideal.map (IsScalarTower.toAlgHom R (MvPolynomial ι R) _) _) = _
rw [← sumAlgEquiv_comp_rename_inr, ← Ideal.map_mapₐ, Ideal.comap_map_of_bijective]
simpa using AlgEquiv.bijective (sumAlgEquiv R ι' ι)
variable [Algebra R T] [IsScalarTower R S T] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aux_ker | null |
private aeval_comp_val_eq :
(aeval (Q.comp P.toGenerators).val) =
(aevalTower (IsScalarTower.toAlgHom R S T) Q.val).comp (Q.aux P) := by
ext i
simp only [AlgHom.coe_comp, Function.comp_apply]
cases i <;> simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | aeval_comp_val_eq | null |
private span_range_relation_eq_ker_comp : Ideal.span
(Set.range (Sum.elim (Algebra.Presentation.comp_relation_aux Q P)
fun rp ↦ (rename Sum.inr) (P.relation rp))) = (Q.comp P.toGenerators).ker := by
rw [Generators.ker_eq_ker_aeval_val, Q.aeval_comp_val_eq, ← AlgHom.comap_ker]
change _ = Ideal.comap _ (RingHom.ker (aeval Q.val))
rw [← Q.ker_eq_ker_aeval_val, ← Q.span_range_relation_eq_ker, ← Q.aux_image_relation P,
← Ideal.map_span, Ideal.comap_map_of_surjective' _ (Q.aux_surjective P)]
rw [Set.Sum.elim_range, Ideal.span_union, Q.aux_ker, ← P.ker_eq_ker_aeval_val,
← P.span_range_relation_eq_ker, Ideal.map_span]
congr
ext
simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | span_range_relation_eq_ker_comp | null |
@[simps -isSimp relation]
noncomputable comp : Presentation R T (ι' ⊕ ι) (σ' ⊕ σ) where
toGenerators := Q.toGenerators.comp P.toGenerators
relation := Sum.elim (Q.comp_relation_aux P)
(fun rp ↦ MvPolynomial.rename Sum.inr <| P.relation rp)
span_range_relation_eq_ker := Q.span_range_relation_eq_ker_comp P | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | comp | Given presentations of `T` over `S` and of `S` over `R`,
we may construct a presentation of `T` over `R`. |
toGenerators_comp : (Q.comp P).toGenerators = Q.toGenerators.comp P.toGenerators := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | toGenerators_comp | null |
comp_relation_inr (r : σ) :
(Q.comp P).relation (Sum.inr r) = rename Sum.inr (P.relation r) :=
rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | comp_relation_inr | null |
comp_aeval_relation_inl (r : σ') :
aeval (Sum.elim X (MvPolynomial.C ∘ P.val)) ((Q.comp P).relation (Sum.inl r)) =
Q.relation r := by
change (Q.aux P) _ = _
simp [comp_relation, comp_relation_aux_map] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | comp_aeval_relation_inl | null |
@[simps toGenerators]
noncomputable reindex (P : Presentation R S ι σ)
{ι' σ' : Type*} (e : ι' ≃ ι) (f : σ' ≃ σ) :
Presentation R S ι' σ' where
__ := P.toGenerators.reindex e
relation := rename e.symm ∘ P.relation ∘ f
span_range_relation_eq_ker := by
rw [Generators.ker_eq_ker_aeval_val, Generators.reindex_val, ← aeval_comp_rename,
← AlgHom.comap_ker, ← P.ker_eq_ker_aeval_val, ← P.span_range_relation_eq_ker,
Set.range_comp, Set.range_comp, Equiv.range_eq_univ, Set.image_univ,
← Ideal.map_span (rename ⇑e.symm)]
have hf : Function.Bijective (MvPolynomial.rename e.symm) := (renameEquiv R e.symm).bijective
apply Ideal.comap_injective_of_surjective _ hf.2
simp_rw [Ideal.comap_comapₐ, rename_comp_rename, Equiv.self_comp_symm]
simp [Ideal.comap_map_of_bijective _ hf, rename_id]
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | reindex | Given a presentation `P` and equivalences `ι' ≃ ι` and
`σ' ≃ σ`, this is the induced presentation with variables indexed
by `ι'` and relations indexed by `σ'` |
dimension_reindex (P : Presentation R S ι σ) {ι' σ' : Type*} (e : ι' ≃ ι) (f : σ' ≃ σ) :
(P.reindex e f).dimension = P.dimension := by
simp [dimension, Nat.card_congr e, Nat.card_congr f] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | dimension_reindex | null |
@[simps! toGenerators]
noncomputable
naive {v : ι → MvPolynomial σ R}
(s : MvPolynomial σ R ⧸ (Ideal.span <| Set.range v) → MvPolynomial σ R :=
Function.surjInv Ideal.Quotient.mk_surjective)
(hs : ∀ x, Ideal.Quotient.mk _ (s x) = x := by apply Function.surjInv_eq) :
Presentation R (MvPolynomial σ R ⧸ (Ideal.span <| Set.range v)) σ ι where
__ := Generators.naive s hs
relation := v
span_range_relation_eq_ker := (Generators.ker_naive s hs).symm | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | naive | The naive presentation of a quotient `R[Xᵢ] ⧸ (vⱼ)`.
If the definitional equality of the section matters, it can be explicitly provided. |
naive_relation : (naive s hs).relation = v := rfl
@[simp] lemma naive_relation_apply (i : ι) : (naive s hs).relation i = v i := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.RingTheory.MvPolynomial.Localization",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/Extension/Presentation/Basic.lean | naive_relation | null |
@[nolint checkUnivs]
PreSubmersivePresentation extends Algebra.Presentation R S ι σ where
/-- A map from the relations type to the variables type. Used to compute the differential. -/
map : σ → ι
map_inj : Function.Injective map | structure | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | PreSubmersivePresentation | A `PreSubmersivePresentation` of an `R`-algebra `S` is a `Presentation`
with relations equipped with an injective `map : relations → vars`.
This map determines how the differential of `P` is constructed. See
`PreSubmersivePresentation.differential` for details. |
card_relations_le_card_vars_of_isFinite [Finite ι] :
Nat.card σ ≤ Nat.card ι :=
Nat.card_le_card_of_injective P.map P.map_inj | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | card_relations_le_card_vars_of_isFinite | null |
noncomputable basis : Basis σ P.Ring (σ → P.Ring) :=
Pi.basisFun P.Ring σ | abbrev | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | basis | The standard basis of `σ → P.ring`. |
noncomputable differential : (σ → P.Ring) →ₗ[P.Ring] (σ → P.Ring) :=
Basis.constr P.basis P.Ring
(fun j i : σ ↦ MvPolynomial.pderiv (P.map i) (P.relation j)) | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | differential | The differential of a `P : PreSubmersivePresentation` is a `P.Ring`-linear map on
`σ → P.Ring`:
The `j`-th standard basis vector, corresponding to the `j`-th relation of `P`, is mapped
to the vector of partial derivatives of `P.relation j` with respect
to the coordinates `P.map i` for all `i : σ`.
The determinant of this map is the Jacobian of `P` used to define when a `PreSubmersivePresentation`
is submersive. See `PreSubmersivePresentation.jacobian`. |
noncomputable aevalDifferential : (σ → S) →ₗ[S] (σ → S) :=
(Pi.basisFun S σ).constr S
(fun j i : σ ↦ aeval P.val <| pderiv (P.map i) (P.relation j))
@[simp] | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | aevalDifferential | `PreSubmersivePresentation.differential` pushed forward to `S` via `aeval P.val`. |
aevalDifferential_single [DecidableEq σ] (i j : σ) :
P.aevalDifferential (Pi.single i 1) j = aeval P.val (pderiv (P.map j) (P.relation i)) := by
dsimp only [aevalDifferential]
rw [← Pi.basisFun_apply, Basis.constr_basis] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | aevalDifferential_single | null |
noncomputable jacobian : S :=
algebraMap P.Ring S <| LinearMap.det P.differential | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | jacobian | The Jacobian of a `P : PreSubmersivePresentation` is the determinant
of `P.differential` viewed as element of `S`. |
noncomputable jacobiMatrix : Matrix σ σ P.Ring :=
LinearMap.toMatrix P.basis P.basis P.differential | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | jacobiMatrix | If `σ` has a `Fintype` and `DecidableEq` instance, the differential of `P`
can be expressed in matrix form. |
jacobian_eq_jacobiMatrix_det : P.jacobian = algebraMap P.Ring S P.jacobiMatrix.det := by
simp [jacobiMatrix, jacobian] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | jacobian_eq_jacobiMatrix_det | null |
jacobiMatrix_apply (i j : σ) :
P.jacobiMatrix i j = MvPolynomial.pderiv (P.map i) (P.relation j) := by
simp [jacobiMatrix, LinearMap.toMatrix, differential, basis] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | jacobiMatrix_apply | null |
aevalDifferential_toMatrix'_eq_mapMatrix_jacobiMatrix :
P.aevalDifferential.toMatrix' = (aeval P.val).mapMatrix P.jacobiMatrix := by
ext i j : 1
rw [← LinearMap.toMatrix_eq_toMatrix']
rw [LinearMap.toMatrix_apply]
simp [jacobiMatrix_apply] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | aevalDifferential_toMatrix'_eq_mapMatrix_jacobiMatrix | null |
jacobian_eq_det_aevalDifferential : P.jacobian = P.aevalDifferential.det := by
classical
cases nonempty_fintype σ
simp [← LinearMap.det_toMatrix', P.aevalDifferential_toMatrix'_eq_mapMatrix_jacobiMatrix,
jacobian_eq_jacobiMatrix_det, RingHom.map_det, P.algebraMap_eq] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | jacobian_eq_det_aevalDifferential | null |
isUnit_jacobian_iff_aevalDifferential_bijective :
IsUnit P.jacobian ↔ Function.Bijective P.aevalDifferential := by
rw [P.jacobian_eq_det_aevalDifferential, ← LinearMap.isUnit_iff_isUnit_det]
exact Module.End.isUnit_iff P.aevalDifferential | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | isUnit_jacobian_iff_aevalDifferential_bijective | null |
isUnit_jacobian_of_linearIndependent_of_span_eq_top
(hli : LinearIndependent S (fun j i : σ ↦ aeval P.val <| pderiv (P.map i) (P.relation j)))
(hsp : Submodule.span S
(Set.range <| (fun j i : σ ↦ aeval P.val <| pderiv (P.map i) (P.relation j))) = ⊤) :
IsUnit P.jacobian := by
classical
rw [isUnit_jacobian_iff_aevalDifferential_bijective]
exact LinearMap.bijective_of_linearIndependent_of_span_eq_top (Pi.basisFun _ _).span_eq
(by convert hli; simp) (by convert hsp; simp) | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | isUnit_jacobian_of_linearIndependent_of_span_eq_top | null |
noncomputable ofBijectiveAlgebraMap (h : Function.Bijective (algebraMap R S)) :
PreSubmersivePresentation R S PEmpty.{w + 1} PEmpty.{t + 1} where
toPresentation := Presentation.ofBijectiveAlgebraMap.{t, w} h
map := PEmpty.elim
map_inj (a b : PEmpty) h := by contradiction
@[simp] | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | ofBijectiveAlgebraMap | If `algebraMap R S` is bijective, the empty generators are a pre-submersive
presentation with no relations. |
ofBijectiveAlgebraMap_jacobian (h : Function.Bijective (algebraMap R S)) :
(ofBijectiveAlgebraMap h).jacobian = 1 := by
classical
have : (algebraMap (ofBijectiveAlgebraMap h).Ring S).mapMatrix
(ofBijectiveAlgebraMap h).jacobiMatrix = 1 := by
ext (i j : PEmpty)
contradiction
rw [jacobian_eq_jacobiMatrix_det, RingHom.map_det, this, Matrix.det_one] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | ofBijectiveAlgebraMap_jacobian | null |
@[simps map]
noncomputable localizationAway : PreSubmersivePresentation R S Unit Unit where
__ := Presentation.localizationAway S r
map _ := ()
map_inj _ _ h := h
@[simp] | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | localizationAway | If `S` is the localization of `R` at `r`, this is the canonical submersive presentation
of `S` as `R`-algebra. |
localizationAway_jacobiMatrix :
(localizationAway S r).jacobiMatrix = Matrix.diagonal (fun () ↦ MvPolynomial.C r) := by
have h : (pderiv ()) (C r * X () - 1) = C r := by simp
ext (i : Unit) (j : Unit) : 1
rwa [jacobiMatrix_apply]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | localizationAway_jacobiMatrix | null |
localizationAway_jacobian : (localizationAway S r).jacobian = algebraMap R S r := by
rw [jacobian_eq_jacobiMatrix_det, localizationAway_jacobiMatrix]
simp [show Fintype.card (localizationAway r (S := S)).rels = 1 from rfl] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | localizationAway_jacobian | null |
@[simps map]
noncomputable comp : PreSubmersivePresentation R T (ι' ⊕ ι) (σ' ⊕ σ) where
__ := Q.toPresentation.comp P.toPresentation
map := Sum.elim (fun rq ↦ Sum.inl <| Q.map rq) (fun rp ↦ Sum.inr <| P.map rp)
map_inj := Function.Injective.sumElim ((Sum.inl_injective).comp (Q.map_inj))
((Sum.inr_injective).comp (P.map_inj)) <| by simp | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.LinearAlgebra.Determinant",
"Mathlib.RingTheory.Extension.Presentation.Basic"
] | Mathlib/RingTheory/Extension/Presentation/Submersive.lean | comp | Given an `R`-algebra `S` and an `S`-algebra `T` with pre-submersive presentations,
this is the canonical pre-submersive presentation of `T` as an `R`-algebra. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.