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 ⌀ |
|---|---|---|---|---|---|---|
KaehlerDifferential.kerTotal_mkQ_single_smul (r : R) (x y) : (y𝖣r • x) = r • y𝖣x := by
letI : SMulZeroClass R S := inferInstance
rw [Algebra.smul_def, KaehlerDifferential.kerTotal_mkQ_single_mul,
KaehlerDifferential.kerTotal_mkQ_single_algebraMap, add_zero, ← LinearMap.map_smul_of_tower,
Finsupp.smul_single, mul_comm, Algebra.smul_def] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_mkQ_single_smul | null |
noncomputable KaehlerDifferential.derivationQuotKerTotal :
Derivation R S ((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) where
toFun x := 1𝖣x
map_add' _ _ := KaehlerDifferential.kerTotal_mkQ_single_add _ _ _ _ _
map_smul' _ _ := KaehlerDifferential.kerTotal_mkQ_single_smul _ _ _ _ _
map_one_eq_zero' := KaehlerDifferential.kerTotal_mkQ_single_algebraMap_one _ _ _
leibniz' a b :=
(KaehlerDifferential.kerTotal_mkQ_single_mul _ _ _ _ _).trans
(by simp_rw [← Finsupp.smul_single_one _ (1 * _ : S)]; dsimp; simp) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.derivationQuotKerTotal | The (universal) derivation into `(S →₀ S) ⧸ KaehlerDifferential.kerTotal R S`. |
KaehlerDifferential.derivationQuotKerTotal_apply (x) :
KaehlerDifferential.derivationQuotKerTotal R S x = 1𝖣x :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.derivationQuotKerTotal_apply | null |
KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination :
(KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential.comp
(Finsupp.linearCombination S (KaehlerDifferential.D R S)) =
Submodule.mkQ _ := by
apply Finsupp.lhom_ext
intro a b
conv_rhs => rw [← Finsupp.smul_single_one a b, LinearMap.map_smul]
simp [KaehlerDifferential.derivationQuotKerTotal_apply] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination | null |
KaehlerDifferential.kerTotal_eq :
LinearMap.ker (Finsupp.linearCombination S (KaehlerDifferential.D R S)) =
KaehlerDifferential.kerTotal R S := by
apply le_antisymm
· conv_rhs => rw [← (KaehlerDifferential.kerTotal R S).ker_mkQ]
rw [← KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination]
exact LinearMap.ker_le_ker_comp _ _
· rw [KaehlerDifferential.kerTotal, Submodule.span_le]
rintro _ ((⟨⟨x, y⟩, rfl⟩ | ⟨⟨x, y⟩, rfl⟩) | ⟨x, rfl⟩) <;> simp [LinearMap.mem_ker] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_eq | null |
KaehlerDifferential.linearCombination_surjective :
Function.Surjective (Finsupp.linearCombination S (KaehlerDifferential.D R S)) := by
rw [← LinearMap.range_eq_top, range_linearCombination, span_range_derivation] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.linearCombination_surjective | null |
@[simps!]
noncomputable KaehlerDifferential.quotKerTotalEquiv :
((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) ≃ₗ[S] Ω[S⁄R] :=
{ (KaehlerDifferential.kerTotal R S).liftQ
(Finsupp.linearCombination S (KaehlerDifferential.D R S))
(KaehlerDifferential.kerTotal_eq R S).ge with
invFun := (KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential
left_inv := by
intro x
obtain ⟨x, rfl⟩ := Submodule.mkQ_surjective _ x
exact
LinearMap.congr_fun
(KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination R S :) x
right_inv := by
intro x
obtain ⟨x, rfl⟩ := KaehlerDifferential.linearCombination_surjective R S x
have := LinearMap.congr_fun
(KaehlerDifferential.derivationQuotKerTotal_lift_comp_linearCombination R S) x
rw [LinearMap.comp_apply] at this
rw [this]
rfl } | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.quotKerTotalEquiv | `Ω[S⁄R]` is isomorphic to `S` copies of `S` with kernel `KaehlerDifferential.kerTotal`. |
KaehlerDifferential.quotKerTotalEquiv_symm_comp_D :
(KaehlerDifferential.quotKerTotalEquiv R S).symm.toLinearMap.compDer
(KaehlerDifferential.D R S) =
KaehlerDifferential.derivationQuotKerTotal R S := by
convert (KaehlerDifferential.derivationQuotKerTotal R S).liftKaehlerDifferential_comp | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.quotKerTotalEquiv_symm_comp_D | null |
KaehlerDifferential.kerTotal_map [Algebra R B] [IsScalarTower R A B] [IsScalarTower R S B]
(h : Function.Surjective (algebraMap A B)) :
(KaehlerDifferential.kerTotal R A).map finsupp_map ⊔
Submodule.span A (Set.range fun x : S => .single (algebraMap S B x) (1 : B)) =
(KaehlerDifferential.kerTotal S B).restrictScalars _ := by
rw [KaehlerDifferential.kerTotal, Submodule.map_span, KaehlerDifferential.kerTotal,
Submodule.restrictScalars_span _ _ h]
simp_rw [Set.image_union, Submodule.span_union, ← Set.image_univ, Set.image_image, Set.image_univ,
map_sub, map_add]
simp only [LinearMap.comp_apply, Finsupp.lmapDomain_apply, Finsupp.mapDomain_single,
Finsupp.mapRange.linearMap_apply, Finsupp.mapRange_single, Algebra.linearMap_apply,
map_one, map_add, map_mul]
simp_rw [sup_assoc, ← (h.prodMap h).range_comp]
congr!
rw [sup_eq_right]
apply Submodule.span_mono
simp_rw [← IsScalarTower.algebraMap_apply R A B, IsScalarTower.algebraMap_apply R S B]
exact Set.range_comp_subset_range (algebraMap R S)
fun x => Finsupp.single (algebraMap S B x) (1 : B) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_map | Given the commutative diagram
```
A --→ B
↑ ↑
| |
R --→ S
```
The kernel of the presentation `⊕ₓ B dx ↠ Ω_{B/S}` is spanned by the image of the
kernel of `⊕ₓ A dx ↠ Ω_{A/R}` and all `ds` with `s : S`.
See `kerTotal_map'` for the special case where `R = S`. |
KaehlerDifferential.kerTotal_map' [Algebra R B]
[IsScalarTower R A B] (h : Function.Surjective (algebraMap A B)) :
(KaehlerDifferential.kerTotal R A ⊔
Submodule.span A (Set.range fun x ↦ .single (algebraMap R A x) 1)).map finsupp_map =
(KaehlerDifferential.kerTotal R B).restrictScalars _ := by
rw [Submodule.map_sup, ← kerTotal_map R R A B h, Submodule.map_span, ← Set.range_comp]
congr
ext; simp [IsScalarTower.algebraMap_eq R A B] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_map' | This is a special case of `kerTotal_map` where `R = S`.
The kernel of the presentation `⊕ₓ B dx ↠ Ω_{B/R}` is spanned by the image of the
kernel of `⊕ₓ A dx ↠ Ω_{A/R}` and all `da` with `a : A`. |
KaehlerDifferential.map : Ω[A⁄R] →ₗ[A] Ω[B⁄S] :=
Derivation.liftKaehlerDifferential
(((KaehlerDifferential.D S B).restrictScalars R).compAlgebraMap A) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.map | The map `Ω[A⁄R] →ₗ[A] Ω[B⁄S]` given a square
```
A --→ B
↑ ↑
| |
R --→ S
``` |
KaehlerDifferential.map_compDer :
(KaehlerDifferential.map R S A B).compDer (KaehlerDifferential.D R A) =
((KaehlerDifferential.D S B).restrictScalars R).compAlgebraMap A :=
Derivation.liftKaehlerDifferential_comp _
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.map_compDer | null |
KaehlerDifferential.map_D (x : A) :
KaehlerDifferential.map R S A B (KaehlerDifferential.D R A x) =
KaehlerDifferential.D S B (algebraMap A B x) :=
Derivation.congr_fun (KaehlerDifferential.map_compDer R S A B) x | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.map_D | null |
KaehlerDifferential.ker_map :
LinearMap.ker (KaehlerDifferential.map R S A B) =
(((kerTotal S B).restrictScalars A).comap finsupp_map).map
(Finsupp.linearCombination (M := Ω[A⁄R]) A (D R A)) := by
rw [← Submodule.map_comap_eq_of_surjective (linearCombination_surjective R A) (LinearMap.ker _)]
congr 1
ext x
simp only [Submodule.mem_comap, LinearMap.mem_ker, Finsupp.apply_linearCombination, ← kerTotal_eq,
Submodule.restrictScalars_mem]
simp only [linearCombination_apply, Function.comp_apply, LinearMap.coe_comp, lmapDomain_apply,
Finsupp.mapRange.linearMap_apply]
rw [Finsupp.sum_mapRange_index, Finsupp.sum_mapDomain_index]
· simp
· simp
· simp [add_smul]
· simp | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.ker_map | null |
KaehlerDifferential.ker_map_of_surjective (h : Function.Surjective (algebraMap A B)) :
LinearMap.ker (map R R A B) =
(LinearMap.ker finsupp_map).map (Finsupp.linearCombination A (D R A)) := by
rw [ker_map, ← kerTotal_map' R A B h, Submodule.comap_map_eq, Submodule.map_sup,
Submodule.map_sup, ← kerTotal_eq, ← Submodule.comap_bot,
Submodule.map_comap_eq_of_surjective (linearCombination_surjective _ _),
bot_sup_eq, Submodule.map_span, ← Set.range_comp]
convert bot_sup_eq _
rw [Submodule.span_eq_bot]; simp
open IsScalarTower (toAlgHom) | lemma | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.ker_map_of_surjective | null |
KaehlerDifferential.map_surjective_of_surjective
(h : Function.Surjective (algebraMap A B)) :
Function.Surjective (KaehlerDifferential.map R S A B) := by
rw [← LinearMap.range_eq_top, _root_.eq_top_iff,
← @Submodule.restrictScalars_top A B, ← span_range_derivation,
Submodule.restrictScalars_span _ _ h, Submodule.span_le]
rintro _ ⟨x, rfl⟩
obtain ⟨y, rfl⟩ := h x
rw [← KaehlerDifferential.map_D R S A B]
exact ⟨_, rfl⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.map_surjective_of_surjective | null |
KaehlerDifferential.map_surjective :
Function.Surjective (KaehlerDifferential.map R S B B) :=
map_surjective_of_surjective R S B B Function.surjective_id | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.map_surjective | null |
noncomputable KaehlerDifferential.mapBaseChange : B ⊗[A] Ω[A⁄R] →ₗ[B] Ω[B⁄R] :=
(TensorProduct.isBaseChange A Ω[A⁄R] B).lift (KaehlerDifferential.map R R A B)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.mapBaseChange | The lift of the map `Ω[A⁄R] →ₗ[A] Ω[B⁄R]` to the base change along `A → B`.
This is the first map in the exact sequence `B ⊗[A] Ω[A⁄R] → Ω[B⁄R] → Ω[B⁄A] → 0`. |
KaehlerDifferential.mapBaseChange_tmul (x : B) (y : Ω[A⁄R]) :
KaehlerDifferential.mapBaseChange R A B (x ⊗ₜ y) = x • KaehlerDifferential.map R R A B y := by
conv_lhs => rw [← mul_one x, ← smul_eq_mul, ← TensorProduct.smul_tmul', LinearMap.map_smul]
congr 1
exact IsBaseChange.lift_eq _ _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.mapBaseChange_tmul | null |
KaehlerDifferential.range_mapBaseChange :
LinearMap.range (mapBaseChange R A B) = LinearMap.ker (map R A B B) := by
apply le_antisymm
· rintro _ ⟨x, rfl⟩
induction x with
| zero => simp
| tmul r s =>
obtain ⟨x, rfl⟩ := linearCombination_surjective _ _ s
simp only [mapBaseChange_tmul, LinearMap.mem_ker, map_smul]
induction x using Finsupp.induction_linear
· simp
· simp [smul_add, *]
· simp
| add => rw [map_add]; exact add_mem ‹_› ‹_›
· convert_to (kerTotal A B).map (Finsupp.linearCombination B (D R B)) ≤ _
· rw [KaehlerDifferential.ker_map]
congr 1
convert Submodule.comap_id _
· ext; simp
rw [Submodule.map_le_iff_le_comap, kerTotal, Submodule.span_le]
rintro f ((⟨⟨x, y⟩, rfl⟩|⟨⟨x, y⟩, rfl⟩)|⟨x, rfl⟩)
· use 0; simp
· use 0; simp
· use 1 ⊗ₜ D _ _ x; simp | lemma | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.range_mapBaseChange | null |
KaehlerDifferential.exact_mapBaseChange_map :
Function.Exact (mapBaseChange R A B) (map R A B B) :=
SetLike.ext_iff.mp (range_mapBaseChange R A B).symm | lemma | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.exact_mapBaseChange_map | The sequence `B ⊗[A] Ω[A⁄R] → Ω[B⁄R] → Ω[B⁄A] → 0` is exact.
Also see `KaehlerDifferential.map_surjective`. |
@[simps]
noncomputable
KaehlerDifferential.kerToTensor :
RingHom.ker (algebraMap A B) →ₗ[A] B ⊗[A] Ω[A⁄R] where
toFun x := 1 ⊗ₜ D R A x
map_add' x y := by simp only [Submodule.coe_add, map_add, TensorProduct.tmul_add]
map_smul' r x := by simp only [SetLike.val_smul, smul_eq_mul, Derivation.leibniz,
TensorProduct.tmul_add, TensorProduct.tmul_smul, TensorProduct.smul_tmul', ←
algebraMap_eq_smul_one, RingHom.mem_ker.mp x.prop, TensorProduct.zero_tmul, add_zero,
RingHom.id_apply] | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerToTensor | The map `I → B ⊗[A] Ω[A⁄R]` where `I = ker(A → B)`. |
noncomputable
KaehlerDifferential.kerCotangentToTensor :
(RingHom.ker (algebraMap A B)).Cotangent →ₗ[A] B ⊗[A] Ω[A⁄R] :=
Submodule.liftQ _ (kerToTensor R A B) <| by
rw [Submodule.smul_eq_map₂]
apply iSup_le_iff.mpr
simp only [Submodule.map_le_iff_le_comap, Subtype.forall]
rintro x hx y -
simp only [Submodule.mem_comap, LinearMap.lsmul_apply, LinearMap.mem_ker, map_smul,
kerToTensor_apply, TensorProduct.smul_tmul', ← algebraMap_eq_smul_one,
RingHom.mem_ker.mp hx, TensorProduct.zero_tmul]
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerCotangentToTensor | The map `I/I² → B ⊗[A] Ω[A⁄R]` where `I = ker(A → B)`. |
KaehlerDifferential.kerCotangentToTensor_toCotangent (x) :
kerCotangentToTensor R A B (Ideal.toCotangent _ x) = 1 ⊗ₜ D _ _ x.1 := rfl
variable [Algebra R B] [IsScalarTower R A B] | lemma | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerCotangentToTensor_toCotangent | null |
KaehlerDifferential.range_kerCotangentToTensor
(h : Function.Surjective (algebraMap A B)) :
LinearMap.range (kerCotangentToTensor R A B) =
(LinearMap.ker (KaehlerDifferential.mapBaseChange R A B)).restrictScalars A := by
classical
ext x
constructor
· rintro ⟨x, rfl⟩
obtain ⟨x, rfl⟩ := Ideal.toCotangent_surjective _ x
simp only [kerCotangentToTensor_toCotangent, Submodule.restrictScalars_mem, LinearMap.mem_ker,
mapBaseChange_tmul, map_D, RingHom.mem_ker.mp x.2, map_zero, smul_zero]
· intro hx
obtain ⟨x, rfl⟩ := LinearMap.rTensor_surjective Ω[A⁄R] (g := Algebra.linearMap A B) h x
obtain ⟨x, rfl⟩ := (TensorProduct.lid _ _).symm.surjective x
replace hx : x ∈ LinearMap.ker (KaehlerDifferential.map R R A B) := by simpa using hx
rw [KaehlerDifferential.ker_map_of_surjective R A B h] at hx
obtain ⟨x, hx, rfl⟩ := hx
simp only [TensorProduct.lid_symm_apply, LinearMap.rTensor_tmul,
Algebra.linearMap_apply, map_one]
rw [← Finsupp.sum_single x, Finsupp.sum, ← Finset.sum_fiberwise_of_maps_to
(fun _ ↦ Finset.mem_image_of_mem (algebraMap A B))]
simp only [map_sum (s := x.support.image (algebraMap A B)),
TensorProduct.tmul_sum]
apply sum_mem
intro c _
simp only [LinearMap.mem_range]
simp only [map_sum, Finsupp.linearCombination_single]
have : ∑ i ∈ x.support with algebraMap A B i = c, x i ∈ RingHom.ker (algebraMap A B) := by
simpa [Finsupp.mapDomain, Finsupp.sum, Finsupp.finset_sum_apply, RingHom.mem_ker,
Finsupp.single_apply, ← Finset.sum_filter] using DFunLike.congr_fun hx c
obtain ⟨a, ha⟩ := h c
use ∑ i ∈ {i ∈ x.support | algebraMap A B i = c}.attach, x i • Ideal.toCotangent _ ⟨i - a, ?_⟩
· simp only [map_sum, LinearMapClass.map_smul, kerCotangentToTensor_toCotangent, map_sub]
simp_rw [← TensorProduct.tmul_smul]
simp only [smul_sub, TensorProduct.tmul_sub, Finset.sum_sub_distrib, ← TensorProduct.tmul_sum,
← Finset.sum_smul, Finset.sum_attach, sub_eq_self,
Finset.sum_attach (f := fun i ↦ x i • KaehlerDifferential.D R A i)]
rw [← TensorProduct.smul_tmul, ← Algebra.algebraMap_eq_smul_one, RingHom.mem_ker.mp this,
TensorProduct.zero_tmul]
· have : x i ≠ 0 ∧ algebraMap A B i = c := by
convert i.prop
simp_rw [Finset.mem_filter, Finsupp.mem_support_iff]
simp [RingHom.mem_ker, ha, this.2] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.range_kerCotangentToTensor | null |
KaehlerDifferential.exact_kerCotangentToTensor_mapBaseChange
(h : Function.Surjective (algebraMap A B)) :
Function.Exact (kerCotangentToTensor R A B) (KaehlerDifferential.mapBaseChange R A B) :=
SetLike.ext_iff.mp (range_kerCotangentToTensor R A B h).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.exact_kerCotangentToTensor_mapBaseChange | null |
KaehlerDifferential.mapBaseChange_surjective
(h : Function.Surjective (algebraMap A B)) :
Function.Surjective (KaehlerDifferential.mapBaseChange R A B) := by
have := subsingleton_of_surjective A B h
rw [← LinearMap.range_eq_top, range_mapBaseChange, ← top_le_iff]
exact fun x _ ↦ Subsingleton.elim _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.mapBaseChange_surjective | null |
Cotangent.surjective_map_ofComp :
Function.Surjective (Extension.Cotangent.map (Q.ofComp P).toExtensionHom) := by
intro x
obtain ⟨⟨x, hx⟩, rfl⟩ := Extension.Cotangent.mk_surjective x
have : x ∈ Q.ker := hx
rw [← map_ofComp_ker Q P, Ideal.mem_map_iff_of_surjective
_ (toAlgHom_ofComp_surjective Q P)] at this
obtain ⟨x, hx', rfl⟩ := this
exact ⟨.mk ⟨x, hx'⟩, Extension.Cotangent.map_mk _ _⟩
/-!
Given representations `0 → I → R[X] → S → 0` and `0 → K → S[Y] → T → 0`,
we may consider the induced representation `0 → J → R[X, Y] → T → 0`, and the sequence
`T ⊗[S] (I/I²) → J/J² → K/K²` is exact.
-/
open Extension.Cotangent in | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | Cotangent.surjective_map_ofComp | null |
Cotangent.exact :
Function.Exact
((Extension.Cotangent.map (Q.toComp P).toExtensionHom).liftBaseChange T)
(Extension.Cotangent.map (Q.ofComp P).toExtensionHom) := by
apply LinearMap.exact_of_comp_of_mem_range
· rw [LinearMap.liftBaseChange_comp, ← Extension.Cotangent.map_comp,
EmbeddingLike.map_eq_zero_iff]
ext x
obtain ⟨⟨x, hx⟩, rfl⟩ := Extension.Cotangent.mk_surjective x
simp only [map_mk, val_mk, LinearMap.zero_apply, val_zero]
convert Q.ker.toCotangent.map_zero
trans ((IsScalarTower.toAlgHom R _ _).comp (IsScalarTower.toAlgHom R P.Ring S)) x
· congr
refine MvPolynomial.algHom_ext fun i ↦ ?_
change (Q.ofComp P).toAlgHom ((Q.toComp P).toAlgHom (X i)) = _
simp
· simp [aeval_val_eq_zero hx]
· intro x hx
obtain ⟨⟨x : (Q.comp P).Ring, hx'⟩, rfl⟩ := Extension.Cotangent.mk_surjective x
replace hx : (Q.ofComp P).toAlgHom x ∈ Q.ker ^ 2 := by
simpa only [map_mk, val_mk, val_zero, Ideal.toCotangent_eq_zero] using congr(($hx).val)
rw [pow_two, ← map_ofComp_ker (P := P), ← Ideal.map_mul, Ideal.mem_map_iff_of_surjective
_ (toAlgHom_ofComp_surjective Q P)] at hx
obtain ⟨y, hy, e⟩ := hx
rw [eq_comm, ← sub_eq_zero, ← map_sub, ← RingHom.mem_ker, ← map_toComp_ker] at e
rw [LinearMap.range_liftBaseChange]
let z : (Q.comp P).ker := ⟨x - y, Ideal.sub_mem _ hx' (Ideal.mul_le_left hy)⟩
have hz : z.1 ∈ P.ker.map (Q.toComp P).toAlgHom.toRingHom := e
have : Extension.Cotangent.mk (P := (Q.comp P).toExtension) ⟨x, hx'⟩ =
Extension.Cotangent.mk z := by
ext; simpa only [val_mk, Ideal.toCotangent_eq, sub_sub_cancel, pow_two, z]
rw [this, ← Submodule.restrictScalars_mem (Q.comp P).Ring, ← Submodule.mem_comap,
← Submodule.span_singleton_le_iff_mem, ← Submodule.map_le_map_iff_of_injective
(f := Submodule.subtype _) Subtype.val_injective, Submodule.map_subtype_span_singleton,
Submodule.span_singleton_le_iff_mem]
refine (show Ideal.map (Q.toComp P).toAlgHom.toRingHom P.ker ≤ _ from ?_) hz
rw [Ideal.map_le_iff_le_comap]
rintro w hw
simp only [AlgHom.toRingHom_eq_coe, Ideal.mem_comap, RingHom.coe_coe,
Submodule.mem_map, Submodule.mem_comap, Submodule.restrictScalars_mem, Submodule.coe_subtype,
Subtype.exists, exists_and_right, exists_eq_right,
toExtension_Ring, toExtension_commRing, toExtension_algebra₂]
refine ⟨?_, Submodule.subset_span ⟨Extension.Cotangent.mk ⟨w, hw⟩, ?_⟩⟩
· simp only [ker_eq_ker_aeval_val, RingHom.mem_ker, Hom.algebraMap_toAlgHom]
rw [aeval_val_eq_zero hw, map_zero]
· rw [map_mk]
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | Cotangent.exact | null |
noncomputable
CotangentSpace.compEquiv :
(Q.comp P).toExtension.CotangentSpace ≃ₗ[T]
Q.toExtension.CotangentSpace × (T ⊗[S] P.toExtension.CotangentSpace) :=
(Q.comp P).cotangentSpaceBasis.repr.trans
(Q.cotangentSpaceBasis.prod (P.cotangentSpaceBasis.baseChange T)).repr.symm | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.compEquiv | Given `R[X] → S` and `S[Y] → T`, the cotangent space of `R[X][Y] → T` is isomorphic
to the direct product of the cotangent space of `S[Y] → T` and `R[X] → S` (base changed to `T`). |
CotangentSpace.compEquiv_symm_inr :
(compEquiv Q P).symm.toLinearMap ∘ₗ
LinearMap.inr T Q.toExtension.CotangentSpace (T ⊗[S] P.toExtension.CotangentSpace) =
(Extension.CotangentSpace.map (Q.toComp P).toExtensionHom).liftBaseChange T := by
classical
apply (P.cotangentSpaceBasis.baseChange T).ext
intro i
apply (Q.comp P).cotangentSpaceBasis.repr.injective
ext j
simp only [compEquiv, LinearEquiv.trans_symm, LinearEquiv.symm_symm,
Basis.baseChange_apply, LinearMap.coe_comp, LinearEquiv.coe_coe, LinearMap.coe_inr,
Function.comp_apply, LinearEquiv.trans_apply, Basis.repr_symm_apply, pderiv_X, toComp_val,
Basis.repr_linearCombination, LinearMap.liftBaseChange_tmul, one_smul, repr_CotangentSpaceMap]
obtain (j | j) := j <;>
simp only [Basis.prod_repr_inr, Basis.baseChange_repr_tmul,
Basis.repr_self, Basis.prod_repr_inl, map_zero, Finsupp.coe_zero,
Pi.zero_apply, ne_eq, not_false_eq_true, Pi.single_eq_of_ne, Pi.single_apply,
Finsupp.single_apply, ite_smul, one_smul, zero_smul, Sum.inr.injEq,
MonoidWithZeroHom.map_ite_one_zero, reduceCtorEq] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.compEquiv_symm_inr | null |
CotangentSpace.compEquiv_symm_zero (x) :
(compEquiv Q P).symm (0, x) =
(Extension.CotangentSpace.map (Q.toComp P).toExtensionHom).liftBaseChange T x :=
DFunLike.congr_fun (compEquiv_symm_inr Q P) x | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.compEquiv_symm_zero | null |
CotangentSpace.fst_compEquiv :
LinearMap.fst T Q.toExtension.CotangentSpace (T ⊗[S] P.toExtension.CotangentSpace) ∘ₗ
(compEquiv Q P).toLinearMap = Extension.CotangentSpace.map (Q.ofComp P).toExtensionHom := by
classical
apply (Q.comp P).cotangentSpaceBasis.ext
intro i
apply Q.cotangentSpaceBasis.repr.injective
ext j
simp only [compEquiv, LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply, ofComp_val,
LinearEquiv.trans_apply, Basis.repr_self, LinearMap.fst_apply, repr_CotangentSpaceMap]
obtain (i | i) := i <;>
simp only [Basis.repr_symm_apply, Finsupp.linearCombination_single, Basis.prod_apply,
LinearMap.coe_inl, LinearMap.coe_inr, Sum.elim_inl, Function.comp_apply, one_smul,
Basis.repr_self, Finsupp.single_apply, pderiv_X, Pi.single_apply,
Sum.elim_inr, Function.comp_apply, Basis.baseChange_apply, one_smul,
MonoidWithZeroHom.map_ite_one_zero, map_zero, Finsupp.coe_zero, Pi.zero_apply, derivation_C] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.fst_compEquiv | null |
CotangentSpace.fst_compEquiv_apply (x) :
(compEquiv Q P x).1 = Extension.CotangentSpace.map (Q.ofComp P).toExtensionHom x :=
DFunLike.congr_fun (fst_compEquiv Q P) x | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.fst_compEquiv_apply | null |
CotangentSpace.map_toComp_injective :
Function.Injective
((Extension.CotangentSpace.map (Q.toComp P).toExtensionHom).liftBaseChange T) := by
rw [← compEquiv_symm_inr]
apply (compEquiv Q P).symm.injective.comp
exact Prod.mk_right_injective _ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.map_toComp_injective | null |
CotangentSpace.map_ofComp_surjective :
Function.Surjective (Extension.CotangentSpace.map (Q.ofComp P).toExtensionHom) := by
rw [← fst_compEquiv]
exact (Prod.fst_surjective).comp (compEquiv Q P).surjective
/-!
Given representations `R[X] → S` and `S[Y] → T`, the sequence
`T ⊗[S] (⨁ₓ S dx) → (⨁ₓ T dx) ⊕ (⨁ᵧ T dy) → ⨁ᵧ T dy`
is exact.
-/ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.map_ofComp_surjective | null |
CotangentSpace.exact :
Function.Exact ((Extension.CotangentSpace.map (Q.toComp P).toExtensionHom).liftBaseChange T)
(Extension.CotangentSpace.map (Q.ofComp P).toExtensionHom) := by
rw [← fst_compEquiv, ← compEquiv_symm_inr]
conv_rhs => rw [← LinearEquiv.symm_symm (compEquiv Q P)]
rw [LinearEquiv.conj_exact_iff_exact]
exact Function.Exact.inr_fst | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | CotangentSpace.exact | null |
noncomputable
δAux :
Q.Ring →ₗ[R] T ⊗[S] Ω[S⁄R] :=
Finsupp.lsum R (R := R) fun f ↦
(TensorProduct.mk S T _ (f.prod (Q.val · ^ ·))).restrictScalars R ∘ₗ (D R S).toLinearMap | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux | Given `0 → I → S[Y] → T → 0`, this is an auxiliary map from `S[Y]` to `T ⊗[S] Ω[S⁄R]` whose
restriction to `ker(I/I² → ⊕ S dyᵢ)` is the connecting homomorphism in the Jacobi-Zariski sequence. |
δAux_monomial (n r) :
δAux R Q (monomial n r) = (n.prod (Q.val · ^ ·)) ⊗ₜ D R S r :=
Finsupp.lsum_single _ _ _ _
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux_monomial | null |
δAux_X (i) :
δAux R Q (X i) = 0 := by
rw [X, δAux_monomial]
simp only [Derivation.map_one_eq_zero, tmul_zero] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux_X | null |
δAux_mul (x y) :
δAux R Q (x * y) = x • (δAux R Q y) + y • (δAux R Q x) := by
induction x using MvPolynomial.induction_on' with
| monomial n r =>
induction y using MvPolynomial.induction_on' with
| monomial m s =>
simp only [monomial_mul, δAux_monomial, Derivation.leibniz, tmul_add, tmul_smul,
smul_tmul', Algebra.smul_def, algebraMap_apply, aeval_monomial, mul_assoc]
rw [mul_comm (m.prod _) (n.prod _)]
simp only [pow_zero, implies_true, pow_add, Finsupp.prod_add_index']
| add y₁ y₂ hy₁ hy₂ => simp only [map_add, smul_add, hy₁, hy₂, mul_add, add_smul]; abel
| add x₁ x₂ hx₁ hx₂ => simp only [add_mul, map_add, hx₁, hx₂, add_smul, smul_add]; abel | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux_mul | null |
δAux_C (r) :
δAux R Q (C r) = 1 ⊗ₜ D R S r := by
rw [← monomial_zero', δAux_monomial, Finsupp.prod_zero_index]
variable {Q} {Q'} in | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux_C | null |
δAux_toAlgHom (f : Hom Q Q') (x) :
δAux R Q' (f.toAlgHom x) = δAux R Q x + Finsupp.linearCombination _ (δAux R Q' ∘ f.val)
(Q.cotangentSpaceBasis.repr ((1 : T) ⊗ₜ[Q.Ring] D S Q.Ring x :)) := by
letI : AddCommGroup (T ⊗[S] Ω[S⁄R]) := inferInstance
have : IsScalarTower Q.Ring Q.Ring T := IsScalarTower.left _
induction x using MvPolynomial.induction_on with
| C s => simp [MvPolynomial.algebraMap_eq, δAux_C]
| add x₁ x₂ hx₁ hx₂ =>
simp only [map_add, hx₁, hx₂, tmul_add]
rw [add_add_add_comm]
| mul_X p n IH =>
simp only [map_mul, Hom.toAlgHom_X, δAux_mul, algebraMap_apply, Hom.algebraMap_toAlgHom,
← @IsScalarTower.algebraMap_smul Q'.Ring T, algebraMap_self, δAux_X,
RingHom.id_apply, coe_eval₂Hom, IH, Hom.aeval_val, smul_add, map_aeval, tmul_add, tmul_smul,
← @IsScalarTower.algebraMap_smul Q.Ring T, smul_zero, aeval_X, zero_add, Derivation.leibniz,
LinearEquiv.map_add, LinearEquiv.map_smul, Basis.repr_self, LinearMap.map_add, one_smul,
LinearMap.map_smul, Finsupp.linearCombination_single, RingHomCompTriple.comp_eq,
Function.comp_apply, ← cotangentSpaceBasis_apply]
rw [add_left_comm]
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux_toAlgHom | null |
δAux_ofComp (x : (Q.comp P).Ring) :
δAux R Q ((Q.ofComp P).toAlgHom x) =
P.toExtension.toKaehler.baseChange T (CotangentSpace.compEquiv Q P
(1 ⊗ₜ[(Q.comp P).Ring] (D R (Q.comp P).Ring) x : _)).2 := by
letI : AddCommGroup (T ⊗[S] Ω[S⁄R]) := inferInstance
have : IsScalarTower (Q.comp P).Ring (Q.comp P).Ring T := IsScalarTower.left _
induction x using MvPolynomial.induction_on with
| C s =>
simp only [algHom_C, δAux_C, derivation_C, Derivation.map_algebraMap,
tmul_zero, map_zero, MvPolynomial.algebraMap_apply, Prod.snd_zero]
| add x₁ x₂ hx₁ hx₂ =>
simp only [map_add, hx₁, hx₂, tmul_add, Prod.snd_add]
| mul_X p n IH =>
simp only [map_mul, Hom.toAlgHom_X, ofComp_val, δAux_mul,
← @IsScalarTower.algebraMap_smul Q.Ring T, algebraMap_apply, Hom.algebraMap_toAlgHom,
algebraMap_self, map_aeval, RingHomCompTriple.comp_eq, comp_val, RingHom.id_apply,
IH, Derivation.leibniz, tmul_add, tmul_smul, ← cotangentSpaceBasis_apply, coe_eval₂Hom,
← @IsScalarTower.algebraMap_smul (Q.comp P).Ring T, aeval_X, LinearEquiv.map_add,
LinearMapClass.map_smul, Prod.snd_add, Prod.smul_snd, LinearMap.map_add]
obtain (n | n) := n
· simp only [Sum.elim_inl, δAux_X, smul_zero, aeval_X,
CotangentSpace.compEquiv, LinearEquiv.trans_apply, Basis.repr_symm_apply, zero_add,
Basis.repr_self, Finsupp.linearCombination_single, Basis.prod_apply, LinearMap.coe_inl,
LinearMap.coe_inr, Function.comp_apply, one_smul, map_zero]
· simp only [Sum.elim_inr, Function.comp_apply, algHom_C, δAux_C,
CotangentSpace.compEquiv, LinearEquiv.trans_apply, Basis.repr_symm_apply,
algebraMap_smul, Basis.repr_self, Finsupp.linearCombination_single, Basis.prod_apply,
LinearMap.coe_inr, Basis.baseChange_apply, one_smul, LinearMap.baseChange_tmul,
toKaehler_cotangentSpaceBasis, add_left_inj, LinearMap.coe_inl]
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δAux_ofComp | null |
map_comp_cotangentComplex_baseChange :
(Extension.CotangentSpace.map (Q.toComp P).toExtensionHom).liftBaseChange T ∘ₗ
P.toExtension.cotangentComplex.baseChange T =
(Q.comp P).toExtension.cotangentComplex ∘ₗ
(Extension.Cotangent.map (Q.toComp P).toExtensionHom).liftBaseChange T := by
ext x; simp [Extension.CotangentSpace.map_cotangentComplex]
open Generators in | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | map_comp_cotangentComplex_baseChange | null |
noncomputable
δ :
Q.toExtension.H1Cotangent →ₗ[T] T ⊗[S] Ω[S⁄R] :=
SnakeLemma.δ'
(P.toExtension.cotangentComplex.baseChange T)
(Q.comp P).toExtension.cotangentComplex
Q.toExtension.cotangentComplex
((Extension.Cotangent.map (toComp Q P).toExtensionHom).liftBaseChange T)
(Extension.Cotangent.map (ofComp Q P).toExtensionHom)
(Cotangent.exact Q P)
((Extension.CotangentSpace.map (toComp Q P).toExtensionHom).liftBaseChange T)
(Extension.CotangentSpace.map (ofComp Q P).toExtensionHom)
(CotangentSpace.exact Q P)
(map_comp_cotangentComplex_baseChange Q P)
(by ext; exact Extension.CotangentSpace.map_cotangentComplex (ofComp Q P).toExtensionHom _)
Q.toExtension.h1Cotangentι
(LinearMap.exact_subtype_ker_map _)
(N₁ := T ⊗[S] P.toExtension.CotangentSpace)
(P.toExtension.toKaehler.baseChange T)
(lTensor_exact T P.toExtension.exact_cotangentComplex_toKaehler
P.toExtension.toKaehler_surjective)
(Cotangent.surjective_map_ofComp Q P)
(CotangentSpace.map_toComp_injective Q P) | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δ | The connecting homomorphism in the Jacobi-Zariski sequence for given presentations.
Given representations `0 → I → R[X] → S → 0` and `0 → K → S[Y] → T → 0`,
we may consider the induced representation `0 → J → R[X, Y] → T → 0`,
and this map is obtained by applying snake lemma to the following diagram
```
T ⊗[S] Ω[S/R] → Ω[T/R] → Ω[T/S] → 0
↑ ↑ ↑
0 → T ⊗[S] (⨁ₓ S dx) → (⨁ₓ T dx) ⊕ (⨁ᵧ T dy) → ⨁ᵧ T dy → 0
↑ ↑ ↑
T ⊗[S] (I/I²) → J/J² → K/K² → 0
↑ ↑
H¹(L_{T/R}) → H¹(L_{T/S})
```
This is independent from the presentations chosen. See `H1Cotangent.δ_comp_equiv`. |
exact_δ_map :
Function.Exact (δ Q P) (mapBaseChange R S T) := by
simp only [δ]
apply SnakeLemma.exact_δ_left (π₂ := (Q.comp P).toExtension.toKaehler)
(hπ₂ := (Q.comp P).toExtension.exact_cotangentComplex_toKaehler)
· apply (P.cotangentSpaceBasis.baseChange T).ext
intro i
simp only [Basis.baseChange_apply, LinearMap.coe_comp, Function.comp_apply,
LinearMap.baseChange_tmul, toKaehler_cotangentSpaceBasis, mapBaseChange_tmul, map_D,
one_smul, LinearMap.liftBaseChange_tmul]
rw [cotangentSpaceBasis_apply]
conv_rhs => enter [2]; tactic => exact Extension.CotangentSpace.map_tmul ..
simp only [map_one, mapBaseChange_tmul, map_D, one_smul]
simp [Extension.Hom.toAlgHom]
· exact LinearMap.lTensor_surjective T P.toExtension.toKaehler_surjective | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | exact_δ_map | null |
δ_eq (x : Q.toExtension.H1Cotangent) (y)
(hy : Extension.Cotangent.map (ofComp Q P).toExtensionHom y = x.1) (z)
(hz : (Extension.CotangentSpace.map (toComp Q P).toExtensionHom).liftBaseChange T z =
(Q.comp P).toExtension.cotangentComplex y) :
δ Q P x = P.toExtension.toKaehler.baseChange T z := by
simp only [δ]
apply SnakeLemma.δ_eq
exacts [hy, hz] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δ_eq | null |
δ_eq_δAux (x : Q.ker) (hx) :
δ Q P ⟨.mk x, hx⟩ = δAux R Q x.1 := by
let y := Extension.Cotangent.mk (P := (Q.comp P).toExtension) (Q.kerCompPreimage P x)
have hy : (Extension.Cotangent.map (Q.ofComp P).toExtensionHom) y = Extension.Cotangent.mk x := by
simp only [y, Extension.Cotangent.map_mk]
congr
exact ofComp_kerCompPreimage Q P x
let z := (CotangentSpace.compEquiv Q P ((Q.comp P).toExtension.cotangentComplex y)).2
rw [H1Cotangent.δ_eq (y := y) (z := z)]
· rw [← ofComp_kerCompPreimage Q P x, δAux_ofComp]
rfl
· exact hy
· rw [← CotangentSpace.compEquiv_symm_inr]
apply (CotangentSpace.compEquiv Q P).injective
simp only [LinearMap.coe_comp, LinearEquiv.coe_coe, LinearMap.coe_inr, Function.comp_apply,
LinearEquiv.apply_symm_apply, z]
ext
swap; · rfl
change 0 = (LinearMap.fst T Q.toExtension.CotangentSpace
(T ⊗[S] P.toExtension.CotangentSpace) ∘ₗ (CotangentSpace.compEquiv Q P).toLinearMap)
((Q.comp P).toExtension.cotangentComplex y)
rw [CotangentSpace.fst_compEquiv, Extension.CotangentSpace.map_cotangentComplex, hy, hx] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δ_eq_δAux | null |
δ_eq_δ : δ Q P = δ Q P' := by
ext ⟨x, hx⟩
obtain ⟨x, rfl⟩ := Extension.Cotangent.mk_surjective x
rw [δ_eq_δAux, δ_eq_δAux] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δ_eq_δ | null |
exact_map_δ :
Function.Exact (Extension.H1Cotangent.map (Q.ofComp P).toExtensionHom) (δ Q P) := by
simp only [δ]
apply SnakeLemma.exact_δ_right
(ι₂ := (Q.comp P).toExtension.h1Cotangentι)
(hι₂ := LinearMap.exact_subtype_ker_map _)
· ext x; rfl
· exact Subtype.val_injective | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | exact_map_δ | null |
δ_map (f : Hom Q' Q) (x) :
δ Q P (Extension.H1Cotangent.map f.toExtensionHom x) = δ Q' P' x := by
letI : AddCommGroup (T ⊗[S] Ω[S⁄R]) := inferInstance
obtain ⟨x, hx⟩ := x
obtain ⟨⟨y, hy⟩, rfl⟩ := Extension.Cotangent.mk_surjective x
change δ _ _ ⟨_, _⟩ = δ _ _ _
replace hx : (1 : T) ⊗ₜ[Q'.Ring] (D S Q'.Ring) y = 0 := by
simpa only [LinearMap.mem_ker, Extension.cotangentComplex_mk, ker, RingHom.mem_ker] using hx
simp only [LinearMap.domRestrict_apply, Extension.Cotangent.map_mk, δ_eq_δAux]
refine (δAux_toAlgHom f _).trans ?_
rw [hx, map_zero, map_zero, add_zero] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δ_map | null |
δ_comp_equiv :
δ Q P ∘ₗ (H1Cotangent.equiv _ _).toLinearMap = δ Q' P' := by
ext x
exact δ_map Q P Q' P' _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | δ_comp_equiv | null |
exact_map_δ' (f : Hom W Q) :
Function.Exact (Extension.H1Cotangent.map f.toExtensionHom) (δ Q P) := by
refine (H1Cotangent.equiv (Q.comp P) W).surjective.comp_exact_iff_exact.mp ?_
change Function.Exact ((Extension.H1Cotangent.map f.toExtensionHom).restrictScalars T ∘ₗ
(Extension.H1Cotangent.map _)) (δ Q P)
rw [← Extension.H1Cotangent.map_comp, Extension.H1Cotangent.map_eq _ (Q.ofComp P).toExtensionHom]
exact exact_map_δ Q P | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | exact_map_δ' | A variant of `exact_map_δ` that takes in an arbitrary map between generators. |
noncomputable
H1Cotangent.δ : H1Cotangent S T →ₗ[T] T ⊗[S] Ω[S⁄R] :=
Generators.H1Cotangent.δ (Generators.self S T) (Generators.self R S) | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | H1Cotangent.δ | The connecting homomorphism in the Jacobi-Zariski sequence. |
H1Cotangent.exact_map_δ : Function.Exact (map R S T T) (δ R S T) :=
Generators.H1Cotangent.exact_map_δ' (Generators.self S T)
(Generators.self R S) (Generators.self R T) (Generators.defaultHom _ _) | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | H1Cotangent.exact_map_δ | Given algebras `R → S → T`, `H¹(L_{T/R}) → H¹(L_{T/S}) → T ⊗[S] Ω[S/R]` is exact. |
H1Cotangent.exact_δ_mapBaseChange : Function.Exact (δ R S T) (mapBaseChange R S T) :=
Generators.H1Cotangent.exact_δ_map (Generators.self S T) (Generators.self R S) | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Extension.Generators",
"Mathlib.Algebra.Module.SnakeLemma"
] | Mathlib/RingTheory/Kaehler/JacobiZariski.lean | H1Cotangent.exact_δ_mapBaseChange | Given algebras `R → S → T`, `H¹(L_{T/S}) → T ⊗[S] Ω[S/R] → Ω[T/R]` is exact. |
KaehlerDifferential.mvPolynomialEquiv (σ : Type*) :
Ω[MvPolynomial σ R⁄R] ≃ₗ[MvPolynomial σ R] σ →₀ MvPolynomial σ R where
__ := (MvPolynomial.mkDerivation _ (Finsupp.single · 1)).liftKaehlerDifferential
invFun := Finsupp.linearCombination (α := σ) _ (fun x ↦ D _ _ (MvPolynomial.X x))
right_inv := by
intro x
induction x using Finsupp.induction_linear with
| zero => simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom]; rw [map_zero, map_zero]
| add => simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, map_add] at *; simp only [*]
| single a b => simp [-map_smul]
left_inv := by
intro x
obtain ⟨x, rfl⟩ := linearCombination_surjective _ _ x
induction x using Finsupp.induction_linear with
| zero =>
simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom]
rw [map_zero, map_zero, map_zero]
| add => simp only [map_add, AddHom.toFun_eq_coe, LinearMap.coe_toAddHom] at *; simp only [*]
| single a b =>
simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, Finsupp.linearCombination_single,
LinearMap.map_smul, Derivation.liftKaehlerDifferential_comp_D]
congr 1
induction a using MvPolynomial.induction_on
· simp only [MvPolynomial.derivation_C, map_zero]
· simp only [map_add, *]
· simp [*] | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialEquiv | The relative differential module of a polynomial algebra `R[σ]` is the free module generated by
`{ dx | x ∈ σ }`. Also see `KaehlerDifferential.mvPolynomialBasis`. |
KaehlerDifferential.mvPolynomialBasis (σ) :
Basis σ (MvPolynomial σ R) Ω[MvPolynomial σ R⁄R] :=
⟨mvPolynomialEquiv R σ⟩ | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis | `{ dx | x ∈ σ }` forms a basis of the relative differential module
of a polynomial algebra `R[σ]`. |
KaehlerDifferential.mvPolynomialBasis_repr_comp_D (σ) :
(mvPolynomialBasis R σ).repr.toLinearMap.compDer (D _ _) =
MvPolynomial.mkDerivation _ (Finsupp.single · 1) :=
Derivation.liftKaehlerDifferential_comp _ | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis_repr_comp_D | null |
KaehlerDifferential.mvPolynomialBasis_repr_D (σ) (x) :
(mvPolynomialBasis R σ).repr (D _ _ x) =
MvPolynomial.mkDerivation R (Finsupp.single · (1 : MvPolynomial σ R)) x :=
Derivation.congr_fun (mvPolynomialBasis_repr_comp_D R σ) x
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis_repr_D | null |
KaehlerDifferential.mvPolynomialBasis_repr_D_X (σ) (i) :
(mvPolynomialBasis R σ).repr (D _ _ (.X i)) = Finsupp.single i 1 := by
simp [mvPolynomialBasis_repr_D]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis_repr_D_X | null |
KaehlerDifferential.mvPolynomialBasis_repr_apply (σ) (x) (i) :
(mvPolynomialBasis R σ).repr (D _ _ x) i = MvPolynomial.pderiv i x := by
classical
suffices ((Finsupp.lapply i).comp
(mvPolynomialBasis R σ).repr.toLinearMap).compDer (D _ _) = MvPolynomial.pderiv i by
rw [← this]; rfl
apply MvPolynomial.derivation_ext
intro j
simp [Finsupp.single_apply, Pi.single_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis_repr_apply | null |
KaehlerDifferential.mvPolynomialBasis_repr_symm_single (σ) (i) (x) :
(mvPolynomialBasis R σ).repr.symm (Finsupp.single i x) = x • D R (MvPolynomial σ R) (.X i) := by
apply (mvPolynomialBasis R σ).repr.injective; simp [LinearEquiv.map_smul, -map_smul]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis_repr_symm_single | null |
KaehlerDifferential.mvPolynomialBasis_apply (σ) (i) :
mvPolynomialBasis R σ i = D R (MvPolynomial σ R) (.X i) :=
(mvPolynomialBasis_repr_symm_single R σ i 1).trans (one_smul _ _) | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.mvPolynomialBasis_apply | null |
KaehlerDifferential.polynomial_D_apply (P : R[X]) :
D R R[X] P = derivative P • D R R[X] X := by
rw [← aeval_X_left_apply P, (D R R[X]).map_aeval, aeval_X_left_apply, aeval_X_left_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.polynomial_D_apply | null |
KaehlerDifferential.polynomialEquiv : Ω[R[X]⁄R] ≃ₗ[R[X]] R[X] where
__ := derivative'.liftKaehlerDifferential
invFun := (Algebra.lsmul R R _).toLinearMap.flip (D R R[X] X)
left_inv := by
intro x
obtain ⟨x, rfl⟩ := linearCombination_surjective _ _ x
induction x using Finsupp.induction_linear with
| zero => simp
| add x y hx hy =>
simp only [map_add, AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, LinearMap.flip_apply,
AlgHom.toLinearMap_apply, lsmul_coe] at *; simp only [*]
| single x y => simp [polynomial_D_apply _ x]
right_inv x := by simp | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.polynomialEquiv | The relative differential module of the univariate polynomial algebra `R[X]` is isomorphic to
`R[X]` as an `R[X]`-module. |
KaehlerDifferential.polynomialEquiv_comp_D :
(polynomialEquiv R).compDer (D R R[X]) = derivative' :=
Derivation.liftKaehlerDifferential_comp _
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.polynomialEquiv_comp_D | null |
KaehlerDifferential.polynomialEquiv_D (P) :
polynomialEquiv R (D R R[X] P) = derivative P :=
Derivation.congr_fun (polynomialEquiv_comp_D R) P
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.polynomialEquiv_D | null |
KaehlerDifferential.polynomialEquiv_symm (P) :
(polynomialEquiv R).symm P = P • D R R[X] X := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.Algebra.Polynomial.Derivation"
] | Mathlib/RingTheory/Kaehler/Polynomial.lean | KaehlerDifferential.polynomialEquiv_symm | null |
noncomputable
mulActionBaseChange : MulAction A (S ⊗[R] Ω[A⁄R]) :=
(TensorProduct.comm R S Ω[A⁄R]).toEquiv.mulAction A
attribute [local instance] mulActionBaseChange
@[simp] | abbrev | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | mulActionBaseChange | (Implementation). `A`-action on `S ⊗[R] Ω[A⁄R]`. |
mulActionBaseChange_smul_tmul (a : A) (s : S) (x : Ω[A⁄R]) :
a • (s ⊗ₜ[R] x) = s ⊗ₜ (a • x) := rfl
@[local simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | mulActionBaseChange_smul_tmul | null |
mulActionBaseChange_smul_zero (a : A) :
a • (0 : S ⊗[R] Ω[A⁄R]) = 0 := by
rw [← zero_tmul _ (0 : Ω[A⁄R]), mulActionBaseChange_smul_tmul, smul_zero]
@[local simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | mulActionBaseChange_smul_zero | null |
mulActionBaseChange_smul_add (a : A) (x y : S ⊗[R] Ω[A⁄R]) :
a • (x + y) = a • x + a • y := by
change (TensorProduct.comm R S Ω[A⁄R]).symm (a • (TensorProduct.comm R S Ω[A⁄R]) (x + y)) = _
rw [map_add, smul_add, map_add]
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | mulActionBaseChange_smul_add | null |
noncomputable
moduleBaseChange :
Module A (S ⊗[R] Ω[A⁄R]) where
__ := (TensorProduct.comm R S Ω[A⁄R]).toEquiv.mulAction A
add_smul r s x := by induction x <;> simp [add_smul, tmul_add, *, add_add_add_comm]
zero_smul x := by induction x <;> simp [*]
smul_zero := by simp
smul_add := by simp
attribute [local instance] moduleBaseChange | abbrev | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | moduleBaseChange | (Implementation). `A`-module structure on `S ⊗[R] Ω[A⁄R]`. |
@[reducible] noncomputable
moduleBaseChange' [Algebra.IsPushout R S A B] :
Module B (S ⊗[R] Ω[A⁄R]) :=
Module.compHom _ (Algebra.pushoutDesc B (Algebra.lsmul R (A := S) S (S ⊗[R] Ω[A⁄R]))
(Algebra.lsmul R (A := A) _ _) (LinearMap.ext <| smul_comm · ·)).toRingHom
attribute [local instance] moduleBaseChange' | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | moduleBaseChange' | (Implementation). `B = S ⊗[R] A`-module structure on `S ⊗[R] Ω[A⁄R]`. |
map_liftBaseChange_smul [h : Algebra.IsPushout R S A B] (b : B) (x) :
((map R S A B).restrictScalars R).liftBaseChange S (b • x) =
b • ((map R S A B).restrictScalars R).liftBaseChange S x := by
induction b using h.1.inductionOn with
| zero => simp only [zero_smul, map_zero]
| smul s b e => rw [smul_assoc, map_smul, e, smul_assoc]
| add b₁ b₂ e₁ e₂ => simp only [map_add, e₁, e₂, add_smul]
| tmul a =>
induction x
· simp only [smul_zero, map_zero]
· simp [smul_comm]
· simp only [map_add, smul_add, *] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | map_liftBaseChange_smul | null |
noncomputable
derivationTensorProduct [h : Algebra.IsPushout R S A B] :
Derivation S B (S ⊗[R] Ω[A⁄R]) where
__ := h.out.lift ((TensorProduct.mk R S Ω[A⁄R] 1).comp (D R A).toLinearMap)
map_one_eq_zero' := by
rw [← (algebraMap A B).map_one]
refine (h.out.lift_eq _ _).trans ?_
dsimp
rw [Derivation.map_one_eq_zero, TensorProduct.tmul_zero]
leibniz' a b := by
induction a using h.out.inductionOn with
| zero => rw [map_zero, zero_smul, smul_zero, zero_add, zero_mul, map_zero]
| smul x y e =>
rw [smul_mul_assoc, map_smul, e, map_smul, smul_add,
smul_comm x b, smul_assoc]
| add b₁ b₂ e₁ e₂ => simp only [add_mul, add_smul, map_add, e₁, e₂, smul_add, add_add_add_comm]
| tmul z =>
dsimp
induction b using h.out.inductionOn with
| zero => rw [map_zero, zero_smul, smul_zero, zero_add, mul_zero, map_zero]
| tmul =>
simp only [AlgHom.toLinearMap_apply, IsScalarTower.coe_toAlgHom',
algebraMap_smul, ← map_mul]
rw [← IsScalarTower.toAlgHom_apply R, ← AlgHom.toLinearMap_apply, h.out.lift_eq,
← IsScalarTower.toAlgHom_apply R, ← AlgHom.toLinearMap_apply, h.out.lift_eq,
← IsScalarTower.toAlgHom_apply R, ← AlgHom.toLinearMap_apply, h.out.lift_eq]
simp only [LinearMap.coe_comp, Derivation.coeFn_coe, Function.comp_apply,
Derivation.leibniz, mk_apply, mulActionBaseChange_smul_tmul, TensorProduct.tmul_add]
| smul _ _ e =>
rw [mul_comm, smul_mul_assoc, map_smul, mul_comm, e,
map_smul, smul_add, smul_comm, smul_assoc]
| add _ _ e₁ e₂ => simp only [mul_add, add_smul, map_add, e₁, e₂, smul_add, add_add_add_comm] | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | derivationTensorProduct | (Implementation).
The `S`-derivation `B = S ⊗[R] A` to `S ⊗[R] Ω[A⁄R]` sending `a ⊗ b` to `a ⊗ d b`. |
derivationTensorProduct_algebraMap [Algebra.IsPushout R S A B] (x) :
derivationTensorProduct R S A B (algebraMap A B x) =
1 ⊗ₜ D _ _ x :=
IsBaseChange.lift_eq _ _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | derivationTensorProduct_algebraMap | null |
tensorKaehlerEquiv_left_inv [Algebra.IsPushout R S A B] :
((derivationTensorProduct R S A B).liftKaehlerDifferential.restrictScalars S).comp
(((map R S A B).restrictScalars R).liftBaseChange S) = LinearMap.id := by
refine LinearMap.restrictScalars_injective R ?_
apply TensorProduct.ext'
intro x y
obtain ⟨y, rfl⟩ := tensorProductTo_surjective _ _ y
induction y
· simp only [map_zero, TensorProduct.tmul_zero]
· simp only [LinearMap.restrictScalars_comp, Derivation.tensorProductTo_tmul, LinearMap.coe_comp,
LinearMap.coe_restrictScalars, Function.comp_apply, LinearMap.liftBaseChange_tmul, map_smul,
map_D, LinearMap.map_smul_of_tower, Derivation.liftKaehlerDifferential_comp_D,
LinearMap.id_coe, id_eq, derivationTensorProduct_algebraMap]
rw [smul_comm, TensorProduct.smul_tmul', smul_eq_mul, mul_one]
rfl
· simp only [map_add, TensorProduct.tmul_add, *] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | tensorKaehlerEquiv_left_inv | null |
@[simps! symm_apply] noncomputable
tensorKaehlerEquiv [h : Algebra.IsPushout R S A B] :
(S ⊗[R] Ω[A⁄R]) ≃ₗ[S] Ω[B⁄S] where
__ := ((map R S A B).restrictScalars R).liftBaseChange S
invFun := (derivationTensorProduct R S A B).liftKaehlerDifferential
left_inv := LinearMap.congr_fun (tensorKaehlerEquiv_left_inv R S A B)
right_inv x := by
obtain ⟨x, rfl⟩ := tensorProductTo_surjective _ _ x
dsimp
induction x with
| zero => simp
| add x y e₁ e₂ => simp only [map_add, e₁, e₂]
| tmul x y =>
dsimp
simp only [Derivation.tensorProductTo_tmul, LinearMap.map_smul,
Derivation.liftKaehlerDifferential_comp_D, map_liftBaseChange_smul]
induction y using h.1.inductionOn
· simp only [map_zero, smul_zero]
· simp only [AlgHom.toLinearMap_apply, IsScalarTower.coe_toAlgHom',
derivationTensorProduct_algebraMap, LinearMap.liftBaseChange_tmul,
LinearMap.coe_restrictScalars, map_D, one_smul]
· simp only [Derivation.map_smul, LinearMap.map_smul, *, smul_comm x]
· simp only [map_add, smul_add, *]
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | tensorKaehlerEquiv | The canonical isomorphism `(S ⊗[R] Ω[A⁄R]) ≃ₗ[S] Ω[B⁄S]` for `B = S ⊗[R] A`. |
tensorKaehlerEquiv_tmul [Algebra.IsPushout R S A B] (a b) :
tensorKaehlerEquiv R S A B (a ⊗ₜ b) = a • map R S A B b :=
LinearMap.liftBaseChange_tmul _ _ _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | tensorKaehlerEquiv_tmul | null |
isBaseChange [h : Algebra.IsPushout R S A B] :
IsBaseChange S ((map R S A B).restrictScalars R) := by
convert (TensorProduct.isBaseChange R Ω[A⁄R] S).comp
(IsBaseChange.ofEquiv (tensorKaehlerEquiv R S A B))
refine LinearMap.ext fun x ↦ ?_
simp only [LinearMap.coe_restrictScalars, LinearMap.coe_comp, LinearEquiv.coe_coe,
Function.comp_apply, mk_apply, tensorKaehlerEquiv_tmul, one_smul] | lemma | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | isBaseChange | If `B` is the tensor product of `S` and `A` over `R`,
then `Ω[B⁄S]` is the base change of `Ω[A⁄R]` along `R → S`. |
isLocalizedModule (p : Submonoid R) [IsLocalization p S]
[IsLocalization (Algebra.algebraMapSubmonoid A p) B] :
IsLocalizedModule p ((map R S A B).restrictScalars R) :=
have := (Algebra.isPushout_of_isLocalization p S A B).symm
(isLocalizedModule_iff_isBaseChange p S _).mpr (isBaseChange R S A B) | instance | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | isLocalizedModule | null |
isLocalizedModule_of_isLocalizedModule (p : Submonoid R) [IsLocalization p S]
[IsLocalizedModule p (IsScalarTower.toAlgHom R A B).toLinearMap] :
IsLocalizedModule p ((map R S A B).restrictScalars R) :=
have : IsLocalization (Algebra.algebraMapSubmonoid A p) B :=
isLocalizedModule_iff_isLocalization.mp inferInstance
inferInstance | instance | RingTheory | [
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Kaehler/TensorProduct.lean | isLocalizedModule_of_isLocalizedModule | null |
noncomputable ringKrullDim (R : Type*) [CommSemiring R] : WithBot ℕ∞ :=
krullDim (PrimeSpectrum R) | def | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim | The ring-theoretic Krull dimension is the Krull dimension of its spectrum ordered by inclusion. |
Ring.KrullDimLE (n : ℕ) (R : Type*) [CommSemiring R] : Prop :=
Order.KrullDimLE n (PrimeSpectrum R)
variable {R S : Type*} [CommSemiring R] [CommSemiring S] | abbrev | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.KrullDimLE | Type class for rings with krull dimension at most `n`. |
Ring.krullDimLE_iff {n : ℕ} :
KrullDimLE n R ↔ ringKrullDim R ≤ n := Order.krullDimLE_iff n (PrimeSpectrum R)
@[nontriviality] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.krullDimLE_iff | null |
ringKrullDim_eq_bot_of_subsingleton [Subsingleton R] :
ringKrullDim R = ⊥ :=
krullDim_eq_bot | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_eq_bot_of_subsingleton | null |
ringKrullDim_nonneg_of_nontrivial [Nontrivial R] :
0 ≤ ringKrullDim R :=
krullDim_nonneg | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_nonneg_of_nontrivial | null |
ringKrullDim_le_of_surjective (f : R →+* S) (hf : Function.Surjective f) :
ringKrullDim S ≤ ringKrullDim R :=
krullDim_le_of_strictMono (fun I ↦ ⟨Ideal.comap f I.asIdeal, inferInstance⟩)
(Monotone.strictMono_of_injective (fun _ _ hab ↦ Ideal.comap_mono hab)
(fun _ _ h => PrimeSpectrum.ext_iff.mpr <| Ideal.comap_injective_of_surjective f hf <| by
simpa using h)) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_le_of_surjective | If `f : R →+* S` is surjective, then `ringKrullDim S ≤ ringKrullDim R`. |
ringKrullDim_quotient_le {R : Type*} [CommRing R] (I : Ideal R) :
ringKrullDim (R ⧸ I) ≤ ringKrullDim R :=
ringKrullDim_le_of_surjective _ Ideal.Quotient.mk_surjective | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_quotient_le | If `I` is an ideal of `R`, then `ringKrullDim (R ⧸ I) ≤ ringKrullDim R`. |
ringKrullDim_eq_of_ringEquiv (e : R ≃+* S) :
ringKrullDim R = ringKrullDim S :=
le_antisymm (ringKrullDim_le_of_surjective e.symm e.symm.surjective)
(ringKrullDim_le_of_surjective e e.surjective)
alias RingEquiv.ringKrullDim := ringKrullDim_eq_of_ringEquiv | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_eq_of_ringEquiv | If `R` and `S` are isomorphic, then `ringKrullDim R = ringKrullDim S`. |
FiniteRingKrullDim (R : Type*) [CommSemiring R] :=
FiniteDimensionalOrder (PrimeSpectrum R) | abbrev | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | FiniteRingKrullDim | A ring has finite Krull dimension if its `PrimeSpectrum` is
finite-dimensional (and non-empty). |
ringKrullDim_ne_top [FiniteRingKrullDim R] :
ringKrullDim R ≠ ⊤ := krullDim_ne_top_of_finiteDimensionalOrder | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_ne_top | null |
ringKrullDim_lt_top [FiniteRingKrullDim R] :
ringKrullDim R < ⊤ := ringKrullDim_ne_top.lt_top | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_lt_top | null |
ringKrullDim_ne_bot [FiniteRingKrullDim R] :
ringKrullDim R ≠ ⊥ := krullDim_ne_bot_of_finiteDimensionalOrder | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | ringKrullDim_ne_bot | null |
finiteRingKrullDim_iff_ne_bot_and_top :
FiniteRingKrullDim R ↔ (ringKrullDim R ≠ ⊥ ∧ ringKrullDim R ≠ ⊤) :=
(Order.finiteDimensionalOrder_iff_krullDim_ne_bot_and_top (α := PrimeSpectrum R)) | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | finiteRingKrullDim_iff_ne_bot_and_top | null |
Nontrivial.of_finiteRingKrullDim [FiniteRingKrullDim R] : Nontrivial R := by
rw [← PrimeSpectrum.nonempty_iff_nontrivial]
exact LTSeries.nonempty_of_finiteDimensionalOrder _
proof_wanted MvPolynomial.fin_ringKrullDim_eq_add_of_isNoetherianRing
[IsNoetherianRing R] (n : ℕ) :
ringKrullDim (MvPolynomial (Fin n) R) = ringKrullDim R + n | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Nontrivial.of_finiteRingKrullDim | null |
Ring.krullDimLE_zero_iff : Ring.KrullDimLE 0 R ↔ ∀ I : Ideal R, I.IsPrime → I.IsMaximal := by
simp_rw [Ring.KrullDimLE, Order.krullDimLE_iff, Nat.cast_zero,
Order.krullDim_nonpos_iff_forall_isMax,
(PrimeSpectrum.equivSubtype R).forall_congr_left, Subtype.forall, PrimeSpectrum.isMax_iff]
rfl | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.krullDimLE_zero_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.