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 ⌀ |
|---|---|---|---|---|---|---|
isSimpleRing_iff_isTwoSided_imp {R : Type*} [Ring R] :
IsSimpleRing R ↔ Nontrivial R ∧ ∀ I : Ideal R, I.IsTwoSided → I = ⊥ ∨ I = ⊤ := by
let e := orderIsoIsTwoSided (R := R)
simp_rw [isSimpleRing_iff, isSimpleOrder_iff, orderIsoRingCon.toEquiv.nontrivial_congr,
RingCon.nontrivial_iff, e.forall_congr_left, Subtype.forall, ← e.injective.eq_iff]
simp [e, Subtype.ext_iff] | theorem | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/SimpleRing/Congr.lean | isSimpleRing_iff_isTwoSided_imp | null |
@[mk_iff] IsSimpleRing (R : Type*) [NonUnitalNonAssocRing R] : Prop where
simple : IsSimpleOrder (TwoSidedIdeal R)
attribute [instance] IsSimpleRing.simple | class | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/RingTheory/SimpleRing/Defs.lean | IsSimpleRing | A ring `R` is **simple** if it has only two two-sided ideals, namely `⊥` and `⊤`. |
isField_center (A : Type*) [Ring A] [IsSimpleRing A] : IsField (Subring.center A) where
exists_pair_ne := ⟨0, 1, zero_ne_one⟩
mul_comm := mul_comm
mul_inv_cancel := by
rintro ⟨x, hx1⟩ hx2
rw [Subring.mem_center_iff] at hx1
replace hx2 : x ≠ 0 := by simpa [Subtype.ext_iff] using hx2
let I := TwoSidedIdeal.mk' (Set.range (x * ·)) ⟨0, by simp⟩
(by rintro _ _ ⟨x, rfl⟩ ⟨y, rfl⟩; exact ⟨x + y, mul_add _ _ _⟩)
(by rintro _ ⟨x, rfl⟩; exact ⟨-x, by simp⟩)
(by rintro a _ ⟨c, rfl⟩; exact ⟨a * c, by dsimp; rw [← mul_assoc, ← hx1, mul_assoc]⟩)
(by rintro _ b ⟨a, rfl⟩; exact ⟨a * b, by dsimp; rw [← mul_assoc, ← hx1, mul_assoc]⟩)
have mem : 1 ∈ I := one_mem_of_ne_zero_mem I hx2 (by simpa [I, mem_mk'] using ⟨1, by simp⟩)
simp only [TwoSidedIdeal.mem_mk', Set.mem_range, I] at mem
obtain ⟨y, hy⟩ := mem
refine ⟨⟨y, Subring.mem_center_iff.2 fun a ↦ ?_⟩, by ext; exact hy⟩
calc a * y
_ = (x * y) * a * y := by rw [hy, one_mul]
_ = (y * x) * a * y := by rw [hx1]
_ = y * (x * a) * y := by rw [mul_assoc y x a]
_ = y * (a * x) * y := by rw [hx1]
_ = y * ((a * x) * y) := by rw [mul_assoc]
_ = y * (a * (x * y)) := by rw [mul_assoc a x y]
_ = y * a := by rw [hy, mul_one] | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Basic",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.Algebra.Field.Equiv"
] | Mathlib/RingTheory/SimpleRing/Field.lean | isField_center | null |
isSimpleRing_iff_isField (A : Type*) [CommRing A] : IsSimpleRing A ↔ IsField A :=
⟨fun _ ↦ Subring.topEquiv.symm.toMulEquiv.isField <| by
rw [← Subring.center_eq_top A]; exact IsSimpleRing.isField_center A,
fun h ↦ letI := h.toField; inferInstance⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Basic",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.Algebra.Field.Equiv"
] | Mathlib/RingTheory/SimpleRing/Field.lean | isSimpleRing_iff_isField | null |
matrix [IsSimpleRing A] : IsSimpleRing (Matrix ι ι A) where
simple := letI := Classical.decEq ι; TwoSidedIdeal.orderIsoMatrix |>.symm.isSimpleOrder | instance | RingTheory | [
"Mathlib.LinearAlgebra.Matrix.Ideal",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/SimpleRing/Matrix.lean | matrix | null |
IsPrincipalIdealRing.of_isSimpleRing :
IsPrincipalIdealRing R :=
((isSimpleRing_iff_isField _).mp ‹_›).isPrincipalIdealRing | instance | RingTheory | [
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.RingTheory.SimpleRing.Field",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/SimpleRing/Principal.lean | IsPrincipalIdealRing.of_isSimpleRing | null |
IsDomain.of_isSimpleRing :
IsDomain R :=
((isSimpleRing_iff_isField _).mp ‹_›).isDomain | instance | RingTheory | [
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.RingTheory.SimpleRing.Field",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/SimpleRing/Principal.lean | IsDomain.of_isSimpleRing | null |
@[mk_iff, stacks 00TI]
FormallySmooth : Prop where
comp_surjective :
∀ ⦃B : Type u⦄ [CommRing B],
∀ [Algebra R B] (I : Ideal B) (_ : I ^ 2 = ⊥),
Function.Surjective ((Ideal.Quotient.mkₐ R I).comp : (A →ₐ[R] B) → A →ₐ[R] B ⧸ I) | class | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | FormallySmooth | An `R` algebra `A` is formally smooth if for every `R`-algebra, every square-zero ideal
`I : Ideal B` and `f : A →ₐ[R] B ⧸ I`, there exists at least one lift `A →ₐ[R] B`. |
exists_lift {B : Type u} [CommRing B] [_RB : Algebra R B]
[FormallySmooth R A] (I : Ideal B) (hI : IsNilpotent I) (g : A →ₐ[R] B ⧸ I) :
∃ f : A →ₐ[R] B, (Ideal.Quotient.mkₐ R I).comp f = g := by
revert g
change Function.Surjective (Ideal.Quotient.mkₐ R I).comp
revert _RB
apply Ideal.IsNilpotent.induction_on (S := B) I hI
· intro B _ I hI _; exact FormallySmooth.comp_surjective I hI
· intro B _ I J hIJ h₁ h₂ _ g
let this : ((B ⧸ I) ⧸ J.map (Ideal.Quotient.mk I)) ≃ₐ[R] B ⧸ J :=
{
(DoubleQuot.quotQuotEquivQuotSup I J).trans
(Ideal.quotEquivOfEq (sup_eq_right.mpr hIJ)) with
commutes' := fun x => rfl }
obtain ⟨g', e⟩ := h₂ (this.symm.toAlgHom.comp g)
obtain ⟨g', rfl⟩ := h₁ g'
replace e := congr_arg this.toAlgHom.comp e
conv_rhs at e =>
rw [← AlgHom.comp_assoc, AlgEquiv.toAlgHom_eq_coe, AlgEquiv.toAlgHom_eq_coe,
AlgEquiv.comp_symm, AlgHom.id_comp]
exact ⟨g', e⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | exists_lift | null |
noncomputable lift [FormallySmooth R A] (I : Ideal B) (hI : IsNilpotent I)
(g : A →ₐ[R] B ⧸ I) : A →ₐ[R] B :=
(FormallySmooth.exists_lift I hI g).choose
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | lift | For a formally smooth `R`-algebra `A` and a map `f : A →ₐ[R] B ⧸ I` with `I` square-zero,
this is an arbitrary lift `A →ₐ[R] B`. |
comp_lift [FormallySmooth R A] (I : Ideal B) (hI : IsNilpotent I)
(g : A →ₐ[R] B ⧸ I) : (Ideal.Quotient.mkₐ R I).comp (FormallySmooth.lift I hI g) = g :=
(FormallySmooth.exists_lift I hI g).choose_spec
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | comp_lift | null |
mk_lift [FormallySmooth R A] (I : Ideal B) (hI : IsNilpotent I)
(g : A →ₐ[R] B ⧸ I) (x : A) : Ideal.Quotient.mk I (FormallySmooth.lift I hI g x) = g x :=
AlgHom.congr_fun (FormallySmooth.comp_lift I hI g :) x
variable {C : Type u} [CommRing C] [Algebra R C] | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | mk_lift | null |
noncomputable liftOfSurjective [FormallySmooth R A] (f : A →ₐ[R] C)
(g : B →ₐ[R] C) (hg : Function.Surjective g) (hg' : IsNilpotent <| RingHom.ker (g : B →+* C)) :
A →ₐ[R] B :=
FormallySmooth.lift _ hg' ((Ideal.quotientKerAlgEquivOfSurjective hg).symm.toAlgHom.comp f)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | liftOfSurjective | For a formally smooth `R`-algebra `A` and a map `f : A →ₐ[R] B ⧸ I` with `I` nilpotent,
this is an arbitrary lift `A →ₐ[R] B`. |
liftOfSurjective_apply [FormallySmooth R A] (f : A →ₐ[R] C) (g : B →ₐ[R] C)
(hg : Function.Surjective g) (hg' : IsNilpotent <| RingHom.ker g) (x : A) :
g (FormallySmooth.liftOfSurjective f g hg hg' x) = f x := by
apply (Ideal.quotientKerAlgEquivOfSurjective hg).symm.injective
conv_rhs => rw [← AlgHom.coe_coe, ← AlgHom.comp_apply, ← FormallySmooth.mk_lift (A := A) _ hg']
apply (Ideal.quotientKerAlgEquivOfSurjective hg).injective
rw [AlgEquiv.apply_symm_apply, Ideal.quotientKerAlgEquivOfSurjective_apply]
simp only [liftOfSurjective, ← RingHom.ker_coe_toRingHom g, RingHom.kerLift_mk,
AlgEquiv.toAlgHom_eq_coe, RingHom.coe_coe]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | liftOfSurjective_apply | null |
comp_liftOfSurjective [FormallySmooth R A] (f : A →ₐ[R] C) (g : B →ₐ[R] C)
(hg : Function.Surjective g) (hg' : IsNilpotent <| RingHom.ker (g : B →+* C)) :
g.comp (FormallySmooth.liftOfSurjective f g hg hg') = f :=
AlgHom.ext (FormallySmooth.liftOfSurjective_apply f g hg hg') | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | comp_liftOfSurjective | null |
of_equiv [FormallySmooth R A] (e : A ≃ₐ[R] B) : FormallySmooth R B := by
constructor
intro C _ _ I hI f
use (FormallySmooth.lift I ⟨2, hI⟩ (f.comp e : A →ₐ[R] C ⧸ I)).comp e.symm
rw [← AlgHom.comp_assoc, FormallySmooth.comp_lift, AlgHom.comp_assoc, AlgEquiv.comp_symm,
AlgHom.comp_id] | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | of_equiv | null |
iff_of_equiv (e : A ≃ₐ[R] B) : FormallySmooth R A ↔ FormallySmooth R B :=
⟨fun _ ↦ of_equiv e, fun _ ↦ of_equiv e.symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | iff_of_equiv | null |
mvPolynomial (σ : Type u) : FormallySmooth R (MvPolynomial σ R) := by
constructor
intro C _ _ I _ f
have : ∀ s : σ, ∃ c : C, Ideal.Quotient.mk I c = f (MvPolynomial.X s) := fun s =>
Ideal.Quotient.mk_surjective _
choose g hg using this
refine ⟨MvPolynomial.aeval g, ?_⟩
ext s
rw [← hg, AlgHom.comp_apply, MvPolynomial.aeval_X]
rfl | instance | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | mvPolynomial | null |
polynomial : FormallySmooth R R[X] :=
FormallySmooth.of_equiv (MvPolynomial.pUnitAlgEquiv R) | instance | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | polynomial | null |
comp [FormallySmooth R A] [FormallySmooth A B] : FormallySmooth R B := by
constructor
intro C _ _ I hI f
obtain ⟨f', e⟩ := FormallySmooth.comp_surjective I hI (f.comp (IsScalarTower.toAlgHom R A B))
letI := f'.toRingHom.toAlgebra
obtain ⟨f'', e'⟩ :=
FormallySmooth.comp_surjective I hI { f.toRingHom with commutes' := AlgHom.congr_fun e.symm }
apply_fun AlgHom.restrictScalars R at e'
exact ⟨f''.restrictScalars _, e'.trans (AlgHom.ext fun _ => rfl)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | comp | null |
of_split [FormallySmooth R P] (g : A →ₐ[R] P ⧸ (RingHom.ker f.toRingHom) ^ 2)
(hg : f.kerSquareLift.comp g = AlgHom.id R A) : FormallySmooth R A := by
constructor
intro C _ _ I hI i
let l : P ⧸ (RingHom.ker f.toRingHom) ^ 2 →ₐ[R] C := by
refine Ideal.Quotient.liftₐ _ (FormallySmooth.lift I ⟨2, hI⟩ (i.comp f)) ?_
have : RingHom.ker f ≤ I.comap (FormallySmooth.lift I ⟨2, hI⟩ (i.comp f)) := by
rintro x (hx : f x = 0)
have : _ = i (f x) := (FormallySmooth.mk_lift I ⟨2, hI⟩ (i.comp f) x :)
rwa [hx, map_zero, ← Ideal.Quotient.mk_eq_mk, Submodule.Quotient.mk_eq_zero] at this
intro x hx
have := (Ideal.pow_right_mono this 2).trans (Ideal.le_comap_pow _ 2) hx
rwa [hI] at this
have : i.comp f.kerSquareLift = (Ideal.Quotient.mkₐ R _).comp l := by
apply AlgHom.coe_ringHom_injective
apply Ideal.Quotient.ringHom_ext
ext x
exact (FormallySmooth.mk_lift I ⟨2, hI⟩ (i.comp f) x).symm
exact ⟨l.comp g, by rw [← AlgHom.comp_assoc, ← this, AlgHom.comp_assoc, hg, AlgHom.comp_id]⟩
variable (hf : Function.Surjective f)
include hf | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | of_split | null |
iff_split_surjection [FormallySmooth R P] :
FormallySmooth R A ↔ ∃ g, f.kerSquareLift.comp g = AlgHom.id R A := by
constructor
· intro
have surj : Function.Surjective f.kerSquareLift := fun x =>
⟨Submodule.Quotient.mk (hf x).choose, (hf x).choose_spec⟩
have sqz : RingHom.ker f.kerSquareLift.toRingHom ^ 2 = 0 := by
rw [AlgHom.ker_kerSquareLift, Ideal.cotangentIdeal_square, Ideal.zero_eq_bot]
dsimp only [AlgHom.toRingHom_eq_coe, RingHom.ker_coe_toRingHom] at sqz
refine
⟨FormallySmooth.lift _ ⟨2, sqz⟩ (Ideal.quotientKerAlgEquivOfSurjective surj).symm.toAlgHom,
?_⟩
dsimp only [AlgHom.toRingHom_eq_coe, AlgEquiv.toAlgHom_eq_coe]
ext x
have :=
(Ideal.quotientKerAlgEquivOfSurjective surj).congr_arg
(FormallySmooth.mk_lift (R := R) _ ⟨2, sqz⟩
(Ideal.quotientKerAlgEquivOfSurjective surj).symm x)
dsimp only [AlgHom.toRingHom_eq_coe, AlgHom.coe_coe] at this
rw [AlgEquiv.apply_symm_apply] at this
conv_rhs => rw [← this, AlgHom.id_apply]
rfl
· rintro ⟨g, hg⟩; exact FormallySmooth.of_split f g hg | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | iff_split_surjection | Let `P →ₐ[R] A` be a surjection with kernel `J`, and `P` a formally smooth `R`-algebra,
then `A` is formally smooth over `R` iff the surjection `P ⧸ J ^ 2 →ₐ[R] A` has a section.
Geometric intuition: we require that a first-order thickening of `Spec A` inside `Spec P` admits
a retraction. |
base_change [FormallySmooth R A] : FormallySmooth B (B ⊗[R] A) := by
constructor
intro C _ _ I hI f
letI := ((algebraMap B C).comp (algebraMap R B)).toAlgebra
haveI : IsScalarTower R B C := IsScalarTower.of_algebraMap_eq' rfl
refine ⟨TensorProduct.productLeftAlgHom (Algebra.ofId B C) ?_, ?_⟩
· exact FormallySmooth.lift I ⟨2, hI⟩ ((f.restrictScalars R).comp TensorProduct.includeRight)
· apply AlgHom.restrictScalars_injective R
apply TensorProduct.ext'
intro b a
suffices algebraMap B _ b * f (1 ⊗ₜ[R] a) = f (b ⊗ₜ[R] a) by simpa [Algebra.ofId_apply]
rw [← Algebra.smul_def, ← map_smul, TensorProduct.smul_tmul', smul_eq_mul, mul_one] | instance | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | base_change | null |
of_isLocalization : FormallySmooth R Rₘ := by
constructor
intro Q _ _ I e f
have : ∀ x : M, IsUnit (algebraMap R Q x) := by
intro x
apply (IsNilpotent.isUnit_quotient_mk_iff ⟨2, e⟩).mp
convert (IsLocalization.map_units Rₘ x).map f
simp only [Ideal.Quotient.mk_algebraMap, AlgHom.commutes]
let this : Rₘ →ₐ[R] Q :=
{ IsLocalization.lift this with commutes' := IsLocalization.lift_eq this }
use this
apply AlgHom.coe_ringHom_injective
refine IsLocalization.ringHom_ext M ?_
ext
simp | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | of_isLocalization | null |
localization_base [FormallySmooth R Sₘ] : FormallySmooth Rₘ Sₘ := by
constructor
intro Q _ _ I e f
letI := ((algebraMap Rₘ Q).comp (algebraMap R Rₘ)).toAlgebra
letI : IsScalarTower R Rₘ Q := IsScalarTower.of_algebraMap_eq' rfl
let f : Sₘ →ₐ[Rₘ] Q := by
refine { FormallySmooth.lift I ⟨2, e⟩ (f.restrictScalars R) with commutes' := ?_ }
intro r
change
(RingHom.comp (FormallySmooth.lift I ⟨2, e⟩ (f.restrictScalars R) : Sₘ →+* Q)
(algebraMap _ _))
r =
algebraMap _ _ r
congr 1
refine IsLocalization.ringHom_ext M ?_
rw [RingHom.comp_assoc, ← IsScalarTower.algebraMap_eq, ← IsScalarTower.algebraMap_eq,
AlgHom.comp_algebraMap]
use f
ext
simp [f] | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | localization_base | null |
localization_map [FormallySmooth R S] : FormallySmooth Rₘ Sₘ := by
haveI : FormallySmooth S Sₘ := FormallySmooth.of_isLocalization (M.map (algebraMap R S))
haveI : FormallySmooth R Sₘ := FormallySmooth.comp R S Sₘ
exact FormallySmooth.localization_base M | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | localization_map | null |
@[stacks 00T2 "In the stacks project, the definition of smooth is completely different, and tag
<https://stacks.math.columbia.edu/tag/00TN> proves that their definition is equivalent to this.",
mk_iff]
Smooth [CommSemiring R] (A : Type u) [Semiring A] [Algebra R A] : Prop where
formallySmooth : FormallySmooth R A := by infer_instance
finitePresentation : FinitePresentation R A := by infer_instance | class | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | Smooth | An `R` algebra `A` is smooth if it is formally smooth and of finite presentation. |
of_equiv [Smooth R A] (e : A ≃ₐ[R] B) : Smooth R B where
formallySmooth := FormallySmooth.of_equiv e
finitePresentation := FinitePresentation.equiv e | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | of_equiv | Being smooth is transported via algebra isomorphisms. |
of_isLocalization_Away (r : R) [IsLocalization.Away r A] : Smooth R A where
formallySmooth := Algebra.FormallySmooth.of_isLocalization (Submonoid.powers r)
finitePresentation := IsLocalization.Away.finitePresentation r | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | of_isLocalization_Away | Localization at an element is smooth. |
comp [Algebra A B] [IsScalarTower R A B] [Smooth R A] [Smooth A B] : Smooth R B where
formallySmooth := FormallySmooth.comp R A B
finitePresentation := FinitePresentation.trans R A B | theorem | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | comp | Smooth is stable under composition. |
baseChange [Smooth R A] : Smooth B (B ⊗[R] A) where | instance | RingTheory | [
"Mathlib.RingTheory.FinitePresentation",
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Smooth/Basic.lean | baseChange | Smooth is stable under base change. |
@[simps]
derivationOfSectionOfKerSqZero (f : P →ₐ[R] S) (hf' : (RingHom.ker f) ^ 2 = ⊥) (g : S →ₐ[R] P)
(hg : f.comp g = AlgHom.id R S) : Derivation R P (RingHom.ker f) where
toFun x := ⟨x - g (f x), by
simpa [RingHom.mem_ker, sub_eq_zero] using AlgHom.congr_fun hg.symm (f x)⟩
map_add' x y := by simp only [map_add, AddMemClass.mk_add_mk, Subtype.mk.injEq]; ring
map_smul' x y := by
ext
simp only [Algebra.smul_def, map_mul, AlgHom.commutes,
RingHom.id_apply, Submodule.coe_smul_of_tower]
ring
map_one_eq_zero' := by simp only [LinearMap.coe_mk, AddHom.coe_mk, map_one, sub_self,
Submodule.mk_eq_zero]
leibniz' a b := by
have : (a - g (f a)) * (b - g (f b)) = 0 := by
rw [← Ideal.mem_bot, ← hf', pow_two]
apply Ideal.mul_mem_mul
· simpa [RingHom.mem_ker, sub_eq_zero] using AlgHom.congr_fun hg.symm (f a)
· simpa [RingHom.mem_ker, sub_eq_zero] using AlgHom.congr_fun hg.symm (f b)
ext
rw [← sub_eq_zero]
conv_rhs => rw [← neg_zero, ← this]
simp only [LinearMap.coe_mk, AddHom.coe_mk, map_mul, SetLike.mk_smul_mk, smul_eq_mul, mul_sub,
AddMemClass.mk_add_mk, sub_mul, neg_sub]
ring
variable (hf' : (RingHom.ker (algebraMap P S)) ^ 2 = ⊥)
(hg : (IsScalarTower.toAlgHom R P S).comp g = AlgHom.id R S)
include hf' hg | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | derivationOfSectionOfKerSqZero | Given a surjective algebra homomorphism `f : P →ₐ[R] S` with square-zero kernel `I`,
and a section `g : S →ₐ[R] P` (as an algebra homomorphism),
we get an `R`-derivation `P → I` via `x ↦ x - g (f x)`. |
isScalarTower_of_section_of_ker_sqZero :
letI := g.toRingHom.toAlgebra; IsScalarTower P S (RingHom.ker (algebraMap P S)) := by
letI := g.toRingHom.toAlgebra
constructor
intro p s m
ext
change g (p • s) * m = p * (g s * m)
simp only [Algebra.smul_def, map_mul, mul_assoc, mul_left_comm _ (g s)]
congr 1
rw [← sub_eq_zero, ← Ideal.mem_bot, ← hf', pow_two, ← sub_mul]
refine Ideal.mul_mem_mul ?_ m.2
simpa [RingHom.mem_ker, sub_eq_zero] using AlgHom.congr_fun hg (algebraMap P S p) | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | isScalarTower_of_section_of_ker_sqZero | null |
noncomputable
retractionOfSectionOfKerSqZero : S ⊗[P] Ω[P⁄R] →ₗ[P] RingHom.ker (algebraMap P S) :=
letI := g.toRingHom.toAlgebra
haveI := isScalarTower_of_section_of_ker_sqZero g hf' hg
letI f : _ →ₗ[P] RingHom.ker (algebraMap P S) := (derivationOfSectionOfKerSqZero
(IsScalarTower.toAlgHom R P S) hf' g hg).liftKaehlerDifferential
(f.liftBaseChange S).restrictScalars P
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | retractionOfSectionOfKerSqZero | Given a surjective algebra hom `f : P →ₐ[R] S` with square-zero kernel `I`,
and a section `g : S →ₐ[R] P` (as algebra homs),
we get a retraction of the injection `I → S ⊗[P] Ω[P/R]`. |
retractionOfSectionOfKerSqZero_tmul_D (s : S) (t : P) :
retractionOfSectionOfKerSqZero g hf' hg (s ⊗ₜ .D _ _ t) =
g s * t - g s * g (algebraMap _ _ t) := by
letI := g.toRingHom.toAlgebra
haveI := isScalarTower_of_section_of_ker_sqZero g hf' hg
simp only [retractionOfSectionOfKerSqZero, AlgHom.toRingHom_eq_coe, LinearMap.coe_restrictScalars,
LinearMap.liftBaseChange_tmul, SetLike.val_smul_of_tower]
erw [Derivation.liftKaehlerDifferential_comp_D]
exact mul_sub (g s) t (g (algebraMap P S t)) | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | retractionOfSectionOfKerSqZero_tmul_D | null |
retractionOfSectionOfKerSqZero_comp_kerToTensor :
(retractionOfSectionOfKerSqZero g hf' hg).comp (kerToTensor R P S) = LinearMap.id := by
ext x; simp [RingHom.mem_ker.mp x.2] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | retractionOfSectionOfKerSqZero_comp_kerToTensor | null |
sectionOfRetractionKerToTensorAux_prop (x y) (h : algebraMap P S x = algebraMap P S y) :
x - l (1 ⊗ₜ .D _ _ x) = y - l (1 ⊗ₜ .D _ _ y) := by
rw [sub_eq_iff_eq_add, sub_add_comm, ← sub_eq_iff_eq_add, ← Submodule.coe_sub,
← map_sub, ← tmul_sub, ← map_sub]
exact congr_arg Subtype.val (LinearMap.congr_fun hl.symm ⟨x - y, by simp [RingHom.mem_ker, h]⟩)
variable [Algebra R S] [IsScalarTower R P S]
variable (hf' : (RingHom.ker (algebraMap P S)) ^ 2 = ⊥)
include hf' | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | sectionOfRetractionKerToTensorAux_prop | null |
noncomputable
sectionOfRetractionKerToTensorAux : S →ₐ[R] P where
toFun x := σ x - l (1 ⊗ₜ .D _ _ (σ x))
map_one' := by simp [sectionOfRetractionKerToTensorAux_prop l hl (σ 1) 1 (by simp [hσ])]
map_mul' a b := by
have (x y : _) : (l x).1 * (l y).1 = 0 := by
rw [← Ideal.mem_bot, ← hf', pow_two]; exact Ideal.mul_mem_mul (l x).2 (l y).2
simp only [sectionOfRetractionKerToTensorAux_prop l hl (σ (a * b)) (σ a * σ b) (by simp [hσ]),
Derivation.leibniz, tmul_add, tmul_smul, map_add, map_smul, Submodule.coe_add,
SetLike.val_smul, smul_eq_mul, mul_sub, sub_mul, this, sub_zero]
ring
map_add' a b := by
simp only [sectionOfRetractionKerToTensorAux_prop l hl (σ (a + b)) (σ a + σ b) (by simp [hσ]),
map_add, tmul_add, Submodule.coe_add, add_sub_add_comm]
map_zero' := by simp [sectionOfRetractionKerToTensorAux_prop l hl (σ 0) 0 (by simp [hσ])]
commutes' r := by
simp [sectionOfRetractionKerToTensorAux_prop l hl
(σ (algebraMap R S r)) (algebraMap R P r) (by simp [hσ, ← IsScalarTower.algebraMap_apply])] | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | sectionOfRetractionKerToTensorAux | Given a surjective algebra homomorphism `f : P →ₐ[R] S` with square-zero kernel `I`.
Let `σ` be an arbitrary (set-theoretic) section of `f`.
Suppose we have a retraction `l` of the injection `I →ₗ[P] S ⊗[P] Ω[P/R]`, then
`x ↦ σ x - l (1 ⊗ D (σ x))` is an algebra homomorphism and a section to `f`. |
sectionOfRetractionKerToTensorAux_algebraMap (x : P) :
sectionOfRetractionKerToTensorAux l hl σ hσ hf' (algebraMap P S x) = x - l (1 ⊗ₜ .D _ _ x) :=
sectionOfRetractionKerToTensorAux_prop l hl _ x (by simp [hσ])
variable (hf : Surjective (algebraMap P S))
include hf | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | sectionOfRetractionKerToTensorAux_algebraMap | null |
toAlgHom_comp_sectionOfRetractionKerToTensorAux :
(IsScalarTower.toAlgHom R P S).comp
(sectionOfRetractionKerToTensorAux l hl σ hσ hf') = AlgHom.id _ _ := by
ext x
obtain ⟨x, rfl⟩ := hf x
simp [sectionOfRetractionKerToTensorAux_algebraMap, RingHom.mem_ker.mp] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | toAlgHom_comp_sectionOfRetractionKerToTensorAux | null |
noncomputable sectionOfRetractionKerToTensor : S →ₐ[R] P :=
sectionOfRetractionKerToTensorAux l hl _ (fun x ↦ (hf x).choose_spec) hf'
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | sectionOfRetractionKerToTensor | Given a surjective algebra homomorphism `f : P →ₐ[R] S` with square-zero kernel `I`.
Suppose we have a retraction `l` of the injection `I →ₗ[P] S ⊗[P] Ω[P/R]`, then
`x ↦ σ x - l (1 ⊗ D (σ x))` is an algebra homomorphism and a section to `f`,
where `σ` is an arbitrary (set-theoretic) section of `f` |
sectionOfRetractionKerToTensor_algebraMap (x : P) :
sectionOfRetractionKerToTensor l hl hf' hf (algebraMap P S x) = x - l (1 ⊗ₜ .D _ _ x) :=
sectionOfRetractionKerToTensorAux_algebraMap l hl _ _ hf' x
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | sectionOfRetractionKerToTensor_algebraMap | null |
toAlgHom_comp_sectionOfRetractionKerToTensor :
(IsScalarTower.toAlgHom R P S).comp
(sectionOfRetractionKerToTensor l hl hf' hf) = AlgHom.id _ _ :=
toAlgHom_comp_sectionOfRetractionKerToTensorAux (hf := hf) .. | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | toAlgHom_comp_sectionOfRetractionKerToTensor | null |
noncomputable
retractionKerToTensorEquivSection :
{ l // l ∘ₗ (kerToTensor R P S) = LinearMap.id } ≃
{ g // (IsScalarTower.toAlgHom R P S).comp g = AlgHom.id R S } where
toFun l := ⟨_, toAlgHom_comp_sectionOfRetractionKerToTensor _ l.2 hf' hf⟩
invFun g := ⟨_, retractionOfSectionOfKerSqZero_comp_kerToTensor _ hf' g.2⟩
left_inv l := by
ext s p
obtain ⟨s, rfl⟩ := hf s
have (x y : _) : (l.1 x).1 * (l.1 y).1 = 0 := by
rw [← Ideal.mem_bot, ← hf', pow_two]; exact Ideal.mul_mem_mul (l.1 x).2 (l.1 y).2
simp only [AlgebraTensorModule.curry_apply,
Derivation.coe_comp, LinearMap.coe_comp, LinearMap.coe_restrictScalars, Derivation.coeFn_coe,
Function.comp_apply, curry_apply, retractionOfSectionOfKerSqZero_tmul_D,
sectionOfRetractionKerToTensor_algebraMap, ← mul_sub, sub_sub_cancel]
rw [sub_mul]
simp only [this, Algebra.algebraMap_eq_smul_one, ← smul_tmul', LinearMapClass.map_smul,
SetLike.val_smul, smul_eq_mul, sub_zero]
right_inv g := by ext s; obtain ⟨s, rfl⟩ := hf s; simp
variable (R P S) in | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | retractionKerToTensorEquivSection | Given a surjective algebra homomorphism `f : P →ₐ[R] S` with square-zero kernel `I`,
there is a one-to-one correspondence between `P`-linear retractions of `I →ₗ[P] S ⊗[P] Ω[P/R]`
and algebra homomorphism sections of `f`. |
noncomputable
derivationQuotKerSq :
Derivation R (P ⧸ (RingHom.ker (algebraMap P S) ^ 2)) (S ⊗[P] Ω[P⁄R]) := by
letI := Submodule.liftQ ((RingHom.ker (algebraMap P S) ^ 2).restrictScalars R)
(((mk P S _ 1).restrictScalars R).comp (KaehlerDifferential.D R P).toLinearMap)
refine ⟨this ?_, ?_, ?_⟩
· rintro x hx
simp only [Submodule.restrictScalars_mem, pow_two] at hx
simp only [LinearMap.mem_ker, LinearMap.coe_comp, LinearMap.coe_restrictScalars,
Derivation.coeFn_coe, Function.comp_apply, mk_apply]
refine Submodule.smul_induction_on hx ?_ ?_
· intro x hx y hy
simp only [smul_eq_mul, Derivation.leibniz, tmul_add, ← smul_tmul, Algebra.smul_def,
mul_one, RingHom.mem_ker.mp hx, RingHom.mem_ker.mp hy, zero_tmul, zero_add]
· intro x y hx hy; simp only [map_add, hx, hy, tmul_add, zero_add]
· change (1 : S) ⊗ₜ[P] KaehlerDifferential.D R P 1 = 0; simp
· intro a b
obtain ⟨a, rfl⟩ := Submodule.Quotient.mk_surjective _ a
obtain ⟨b, rfl⟩ := Submodule.Quotient.mk_surjective _ b
change (1 : S) ⊗ₜ[P] KaehlerDifferential.D R P (a * b) =
Ideal.Quotient.mk _ a • ((1 : S) ⊗ₜ[P] KaehlerDifferential.D R P b) +
Ideal.Quotient.mk _ b • ((1 : S) ⊗ₜ[P] KaehlerDifferential.D R P a)
simp only [← Ideal.Quotient.algebraMap_eq, IsScalarTower.algebraMap_smul,
Derivation.leibniz, tmul_add, tmul_smul]
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | derivationQuotKerSq | Given a tower of algebras `S/P/R`, with `I = ker(P → S)`,
this is the `R`-derivative `P/I² → S ⊗[P] Ω[P⁄R]` given by `[x] ↦ 1 ⊗ D x`. |
derivationQuotKerSq_mk (x : P) :
derivationQuotKerSq R P S x = 1 ⊗ₜ .D R P x := rfl
variable (R P S) in | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | derivationQuotKerSq_mk | null |
noncomputable
tensorKaehlerQuotKerSqEquiv :
S ⊗[P ⧸ (RingHom.ker (algebraMap P S) ^ 2)] Ω[(P ⧸ (RingHom.ker (algebraMap P S) ^ 2))⁄R] ≃ₗ[S]
S ⊗[P] Ω[P⁄R] :=
letI f₁ := (derivationQuotKerSq R P S).liftKaehlerDifferential
letI f₂ := AlgebraTensorModule.lift ((LinearMap.ringLmapEquivSelf S S _).symm f₁)
letI f₃ := KaehlerDifferential.map R R P (P ⧸ (RingHom.ker (algebraMap P S) ^ 2))
letI f₄ := ((mk (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S _ 1).restrictScalars P).comp f₃
letI f₅ := AlgebraTensorModule.lift ((LinearMap.ringLmapEquivSelf S S _).symm f₄)
{ __ := f₂
invFun := f₅
left_inv := by
suffices f₅.comp f₂ = LinearMap.id from LinearMap.congr_fun this
ext a
obtain ⟨a, rfl⟩ := Ideal.Quotient.mk_surjective a
simp [f₁, f₂, f₃, f₄, f₅]
right_inv := by
suffices f₂.comp f₅ = LinearMap.id from LinearMap.congr_fun this
ext a
simp [f₁, f₂, f₃, f₄, f₅] }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | tensorKaehlerQuotKerSqEquiv | Given a tower of algebras `S/P/R`, with `I = ker(P → S)` and `Q := P/I²`,
there is an isomorphism of `S`-modules `S ⊗[Q] Ω[Q/R] ≃ S ⊗[P] Ω[P/R]`. |
tensorKaehlerQuotKerSqEquiv_tmul_D (s t) :
tensorKaehlerQuotKerSqEquiv R P S (s ⊗ₜ .D _ _ (Ideal.Quotient.mk _ t)) = s ⊗ₜ .D _ _ t := by
change s • (derivationQuotKerSq R P S).liftKaehlerDifferential
(.D _ _ (Ideal.Quotient.mk _ t)) = _
simp [smul_tmul']
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | tensorKaehlerQuotKerSqEquiv_tmul_D | null |
tensorKaehlerQuotKerSqEquiv_symm_tmul_D (s t) :
(tensorKaehlerQuotKerSqEquiv R P S).symm (s ⊗ₜ .D _ _ t) =
s ⊗ₜ .D _ _ (Ideal.Quotient.mk _ t) := by
apply (tensorKaehlerQuotKerSqEquiv R P S).injective
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | tensorKaehlerQuotKerSqEquiv_symm_tmul_D | null |
noncomputable
retractionKerCotangentToTensorEquivSection :
{ l // l ∘ₗ (kerCotangentToTensor R P S) = LinearMap.id } ≃
{ g // (IsScalarTower.toAlgHom R P S).kerSquareLift.comp g = AlgHom.id R S } := by
let P' := P ⧸ (RingHom.ker (algebraMap P S) ^ 2)
have h₁ : Surjective (algebraMap P' S) := Function.Surjective.of_comp (g := algebraMap P P') hf
have h₂ : RingHom.ker (algebraMap P' S) ^ 2 = ⊥ := by
rw [RingHom.algebraMap_toAlgebra, AlgHom.ker_kerSquareLift, Ideal.cotangentIdeal_square]
let e₁ : (RingHom.ker (algebraMap P S)).Cotangent ≃ₗ[P] (RingHom.ker (algebraMap P' S)) :=
(Ideal.cotangentEquivIdeal _).trans ((LinearEquiv.ofEq _ _
(IsScalarTower.toAlgHom R P S).ker_kerSquareLift.symm).restrictScalars P)
let e₂ : S ⊗[P'] Ω[P'⁄R] ≃ₗ[P] S ⊗[P] Ω[P⁄R] :=
(tensorKaehlerQuotKerSqEquiv R P S).restrictScalars P
have H : kerCotangentToTensor R P S =
e₂.toLinearMap ∘ₗ (kerToTensor R P' S ).restrictScalars P ∘ₗ e₁.toLinearMap := by
ext x
obtain ⟨x, rfl⟩ := Ideal.toCotangent_surjective _ x
exact (tensorKaehlerQuotKerSqEquiv_tmul_D 1 x.1).symm
refine Equiv.trans ?_ (retractionKerToTensorEquivSection (R := R) h₂ h₁)
refine ⟨fun ⟨l, hl⟩ ↦ ⟨⟨e₁.toLinearMap ∘ₗ l ∘ₗ e₂.toLinearMap, ?_⟩, ?_⟩,
fun ⟨l, hl⟩ ↦ ⟨e₁.symm.toLinearMap ∘ₗ l.restrictScalars P ∘ₗ e₂.symm.toLinearMap, ?_⟩, ?_, ?_⟩
· rintro x y
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
simp only [P', ← Ideal.Quotient.algebraMap_eq, IsScalarTower.algebraMap_smul]
exact (e₁.toLinearMap ∘ₗ l ∘ₗ e₂.toLinearMap).map_smul x y
· ext1 x
rw [H] at hl
obtain ⟨x, rfl⟩ := e₁.surjective x
exact DFunLike.congr_arg e₁ (LinearMap.congr_fun hl x)
· ext x
rw [H]
apply e₁.injective
simp only [LinearMap.coe_comp, LinearEquiv.coe_coe, LinearMap.coe_restrictScalars,
Function.comp_apply, LinearEquiv.symm_apply_apply, LinearMap.id_coe, id_eq,
LinearEquiv.apply_symm_apply]
exact LinearMap.congr_fun hl (e₁ x)
· intro f
ext x
simp only [AlgebraTensorModule.curry_apply, Derivation.coe_comp, LinearMap.coe_comp,
LinearMap.coe_restrictScalars, Derivation.coeFn_coe, Function.comp_apply, curry_apply,
LinearEquiv.coe_coe, LinearMap.coe_mk, AddHom.coe_coe,
LinearEquiv.apply_symm_apply, LinearEquiv.symm_apply_apply]
· intro f
ext x
simp only [AlgebraTensorModule.curry_apply, Derivation.coe_comp, LinearMap.coe_comp,
LinearMap.coe_restrictScalars, Derivation.coeFn_coe, Function.comp_apply, curry_apply,
LinearMap.coe_mk, AddHom.coe_coe, LinearEquiv.coe_coe,
LinearEquiv.symm_apply_apply, LinearEquiv.apply_symm_apply]
variable [Algebra.FormallySmooth R P]
include hf in | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | retractionKerCotangentToTensorEquivSection | Given a surjective algebra homomorphism `f : P →ₐ[R] S` with kernel `I`,
there is a one-to-one correspondence between `P`-linear retractions of `I/I² →ₗ[P] S ⊗[P] Ω[P/R]`
and algebra homomorphism sections of `f‾ : P/I² → S`. |
@[stacks 031I]
Algebra.FormallySmooth.iff_split_injection :
Algebra.FormallySmooth R S ↔ ∃ l, l ∘ₗ (kerCotangentToTensor R P S) = LinearMap.id := by
have := (retractionKerCotangentToTensorEquivSection (R := R) hf).nonempty_congr
simp only [nonempty_subtype] at this
rw [this, ← Algebra.FormallySmooth.iff_split_surjection _ hf] | theorem | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Algebra.FormallySmooth.iff_split_injection | Given a formally smooth `R`-algebra `P` and a surjective algebra homomorphism `f : P →ₐ[R] S`
with kernel `I` (typically a presentation `R[X] → S`),
`S` is formally smooth iff the `P`-linear map `I/I² → S ⊗[P] Ω[P⁄R]` is split injective.
Also see `Algebra.Extension.formallySmooth_iff_split_injection`
for the version in terms of `Extension`. |
@[stacks 031I]
Algebra.Extension.formallySmooth_iff_split_injection
(P : Algebra.Extension.{u} R S) [FormallySmooth R P.Ring] :
Algebra.FormallySmooth R S ↔ ∃ l, l ∘ₗ P.cotangentComplex = LinearMap.id := by
refine (Algebra.FormallySmooth.iff_split_injection P.algebraMap_surjective).trans ?_
let e : P.ker.Cotangent ≃ₗ[P.Ring] P.Cotangent :=
{ __ := AddEquiv.refl _, map_smul' r m := by ext1; simp; rfl }
constructor
· intro ⟨l, hl⟩
exact ⟨(e.comp l).extendScalarsOfSurjective P.algebraMap_surjective,
LinearMap.ext (DFunLike.congr_fun hl : _)⟩
· intro ⟨l, hl⟩
exact ⟨e.symm.toLinearMap ∘ₗ l.restrictScalars P.Ring,
LinearMap.ext (DFunLike.congr_fun hl : _)⟩
include hf in | theorem | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Algebra.Extension.formallySmooth_iff_split_injection | Given a formally smooth `R`-algebra `P` and a surjective algebra homomorphism `f : P →ₐ[R] S`
with kernel `I` (typically a presentation `R[X] → S`),
`S` is formally smooth iff the `P`-linear map `I/I² → S ⊗[P] Ω[P⁄R]` is split injective. |
Algebra.FormallySmooth.iff_injective_and_split :
Algebra.FormallySmooth R S ↔ Function.Injective (kerCotangentToTensor R P S) ∧
∃ l, (KaehlerDifferential.mapBaseChange R P S) ∘ₗ l = LinearMap.id := by
rw [Algebra.FormallySmooth.iff_split_injection hf]
refine (and_iff_right (KaehlerDifferential.mapBaseChange_surjective R _ _ hf)).symm.trans ?_
refine Iff.trans (((exact_kerCotangentToTensor_mapBaseChange R _ _ hf).split_tfae'
(g := (KaehlerDifferential.mapBaseChange R P S).restrictScalars P)).out 1 0)
(and_congr Iff.rfl ?_)
rw [(LinearMap.extendScalarsOfSurjectiveEquiv hf).surjective.exists]
simp only [LinearMap.ext_iff, LinearMap.coe_comp, LinearMap.coe_restrictScalars,
Function.comp_apply, LinearMap.extendScalarsOfSurjective_apply, LinearMap.id_coe, id_eq] | theorem | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Algebra.FormallySmooth.iff_injective_and_split | Given a formally smooth `R`-algebra `P` and a surjective algebra homomorphism `f : P →ₐ[R] S`
with kernel `I` (typically a presentation `R[X] → S`),
then `S` is formally smooth iff `I/I² → S ⊗[P] Ω[S⁄R]` is injective and
`S ⊗[P] Ω[P⁄R] → Ω[S⁄R]` is split surjective. |
private Algebra.FormallySmooth.iff_injective_and_projective' :
letI : Algebra (MvPolynomial S R) S := (MvPolynomial.aeval _root_.id).toAlgebra
Algebra.FormallySmooth R S ↔
Function.Injective (kerCotangentToTensor R (MvPolynomial S R) S) ∧
Module.Projective S Ω[S⁄R] := by
letI : Algebra (MvPolynomial S R) S := (MvPolynomial.aeval _root_.id).toAlgebra
have : Function.Surjective (algebraMap (MvPolynomial S R) S) :=
fun x ↦ ⟨.X x, MvPolynomial.aeval_X _ _⟩
rw [Algebra.FormallySmooth.iff_injective_and_split this,
← Module.Projective.iff_split_of_projective]
exact KaehlerDifferential.mapBaseChange_surjective _ _ _ this | theorem | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Algebra.FormallySmooth.iff_injective_and_projective' | null |
Algebra.FormallySmooth.iff_injective_and_projective :
Algebra.FormallySmooth R S ↔
Function.Injective (kerCotangentToTensor R P S) ∧ Module.Projective S Ω[S⁄R] := by
rw [Algebra.FormallySmooth.iff_injective_and_split hf,
← Module.Projective.iff_split_of_projective]
exact KaehlerDifferential.mapBaseChange_surjective _ _ _ hf | theorem | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Algebra.FormallySmooth.iff_injective_and_projective | Given a formally smooth `R`-algebra `P` and a surjective algebra homomorphism `f : P →ₐ[R] S`
with kernel `I` (typically a presentation `R[X] → S`),
then `S` is formally smooth iff `I/I² → S ⊗[P] Ω[P⁄R]` is injective and `Ω[S/R]` is projective. |
@[stacks 031J]
Algebra.FormallySmooth.iff_subsingleton_and_projective :
Algebra.FormallySmooth R S ↔
Subsingleton (Algebra.H1Cotangent R S) ∧ Module.Projective S Ω[S⁄R] := by
refine (Algebra.FormallySmooth.iff_injective_and_projective
(Generators.self R S).algebraMap_surjective).trans (and_congr ?_ Iff.rfl)
change Function.Injective (Generators.self R S).toExtension.cotangentComplex ↔ _
rw [← LinearMap.ker_eq_bot, ← Submodule.subsingleton_iff_eq_bot]
simp [H1Cotangent, Extension.H1Cotangent] | theorem | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Algebra.FormallySmooth.iff_subsingleton_and_projective | An algebra is formally smooth if and only if `H¹(L_{R/S}) = 0` and `Ω_{S/R}` is projective. |
CotangentSpace.map_toInfinitesimal_bijective (P : Extension.{u} R S) :
Function.Bijective (CotangentSpace.map P.toInfinitesimal) := by
suffices CotangentSpace.map P.toInfinitesimal =
(tensorKaehlerQuotKerSqEquiv _ _ _).symm.toLinearMap by
rw [this]; exact(tensorKaehlerQuotKerSqEquiv _ _ _).symm.bijective
letI : Algebra P.Ring P.infinitesimal.Ring := inferInstanceAs (Algebra P.Ring (P.Ring ⧸ _))
have : IsScalarTower P.Ring P.infinitesimal.Ring S := .of_algebraMap_eq' rfl
apply LinearMap.restrictScalars_injective P.Ring
ext x a
dsimp
simp only [map_tmul, algebraMap_self, RingHom.id_apply, Hom.toAlgHom_apply]
exact (tensorKaehlerQuotKerSqEquiv_symm_tmul_D _ _).symm | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | CotangentSpace.map_toInfinitesimal_bijective | null |
Cotangent.map_toInfinitesimal_bijective (P : Extension.{u} R S) :
Function.Bijective (Cotangent.map P.toInfinitesimal) := by
constructor
· rw [injective_iff_map_eq_zero]
intro x hx
obtain ⟨x, rfl⟩ := Cotangent.mk_surjective x
have hx : x.1 ∈ P.ker ^ 2 := by
apply_fun Cotangent.val at hx
simp only [map_mk, Hom.toAlgHom_apply, val_mk, val_zero, Ideal.toCotangent_eq_zero,
Extension.ker_infinitesimal] at hx
rw [Ideal.cotangentIdeal_square] at hx
simpa only [toInfinitesimal, Ideal.mem_bot, infinitesimal,
Ideal.Quotient.eq_zero_iff_mem] using hx
ext
simpa [Ideal.toCotangent_eq_zero]
· intro x
obtain ⟨⟨x, hx⟩, rfl⟩ := Cotangent.mk_surjective x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
rw [ker_infinitesimal, Ideal.mk_mem_cotangentIdeal] at hx
exact ⟨.mk ⟨x, hx⟩, rfl⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | Cotangent.map_toInfinitesimal_bijective | null |
H1Cotangent.map_toInfinitesimal_bijective (P : Extension.{u} R S) :
Function.Bijective (H1Cotangent.map P.toInfinitesimal) := by
constructor
· intro x y e
ext1
exact (Cotangent.map_toInfinitesimal_bijective P).1 (congr_arg Subtype.val e)
· intro ⟨x, hx⟩
obtain ⟨x, rfl⟩ := (Cotangent.map_toInfinitesimal_bijective P).2 x
refine ⟨⟨x, ?_⟩, rfl⟩
simpa [← CotangentSpace.map_cotangentComplex,
map_eq_zero_iff _ (CotangentSpace.map_toInfinitesimal_bijective P).injective] using hx | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | H1Cotangent.map_toInfinitesimal_bijective | null |
noncomputable
homInfinitesimal (P₁ P₂ : Extension R S) [FormallySmooth R P₁.Ring] :
P₁.infinitesimal.Hom P₂.infinitesimal :=
letI lift : P₁.Ring →ₐ[R] P₂.infinitesimal.Ring := FormallySmooth.liftOfSurjective
(IsScalarTower.toAlgHom R P₁.Ring S)
(IsScalarTower.toAlgHom R P₂.infinitesimal.Ring S)
P₂.infinitesimal.algebraMap_surjective
⟨2, show P₂.infinitesimal.ker ^ 2 = ⊥ by
rw [ker_infinitesimal]; exact Ideal.cotangentIdeal_square _⟩
{ toRingHom := (Ideal.Quotient.liftₐ (P₁.ker ^ 2) lift (by
change P₁.ker ^ 2 ≤ RingHom.ker lift
rw [pow_two, Ideal.mul_le]
have : ∀ r ∈ P₁.ker, lift r ∈ P₂.infinitesimal.ker :=
fun r hr ↦ (FormallySmooth.liftOfSurjective_apply _
(IsScalarTower.toAlgHom R P₂.infinitesimal.Ring S) _ _ r).trans hr
intro r hr s hs
rw [RingHom.mem_ker, map_mul, ← Ideal.mem_bot, ← P₂.ker.cotangentIdeal_square,
← ker_infinitesimal, pow_two]
exact Ideal.mul_mem_mul (this r hr) (this s hs))).toRingHom
toRingHom_algebraMap := by simp
algebraMap_toRingHom x := by
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
exact FormallySmooth.liftOfSurjective_apply _
(IsScalarTower.toAlgHom R P₂.infinitesimal.Ring S) _ _ x } | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | homInfinitesimal | Given extensions `0 → I₁ → P₁ → S → 0` and `0 → I₂ → P₂ → S → 0` with `P₁` formally smooth,
this is an arbitrarily chosen map `P₁/I₁² → P₂/I₂²` of extensions. |
noncomputable
H1Cotangent.equivOfFormallySmooth (P₁ P₂ : Extension R S)
[FormallySmooth R P₁.Ring] [FormallySmooth R P₂.Ring] :
P₁.H1Cotangent ≃ₗ[S] P₂.H1Cotangent :=
.ofBijective _ (H1Cotangent.map_toInfinitesimal_bijective P₁) ≪≫ₗ
H1Cotangent.equiv (Extension.homInfinitesimal _ _) (Extension.homInfinitesimal _ _)
≪≫ₗ .symm (.ofBijective _ (H1Cotangent.map_toInfinitesimal_bijective P₂)) | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | H1Cotangent.equivOfFormallySmooth | Formally smooth extensions have isomorphic `H¹(L_P)`. |
H1Cotangent.equivOfFormallySmooth_toLinearMap {P₁ P₂ : Extension R S} (f : P₁.Hom P₂)
[FormallySmooth R P₁.Ring] [FormallySmooth R P₂.Ring] :
(H1Cotangent.equivOfFormallySmooth P₁ P₂).toLinearMap = map f := by
ext1 x
refine (LinearEquiv.symm_apply_eq _).mpr ?_
change ((map (P₁.homInfinitesimal P₂)).restrictScalars S ∘ₗ map P₁.toInfinitesimal) x =
((map P₂.toInfinitesimal).restrictScalars S ∘ₗ map f) x
rw [← map_comp, ← map_comp, map_eq] | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | H1Cotangent.equivOfFormallySmooth_toLinearMap | null |
H1Cotangent.equivOfFormallySmooth_apply {P₁ P₂ : Extension R S} (f : P₁.Hom P₂)
[FormallySmooth R P₁.Ring] [FormallySmooth R P₂.Ring] (x) :
H1Cotangent.equivOfFormallySmooth P₁ P₂ x = map f x := by
rw [← equivOfFormallySmooth_toLinearMap]; rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | H1Cotangent.equivOfFormallySmooth_apply | null |
H1Cotangent.equivOfFormallySmooth_symm (P₁ P₂ : Extension R S)
[FormallySmooth R P₁.Ring] [FormallySmooth R P₂.Ring] :
(equivOfFormallySmooth P₁ P₂).symm = equivOfFormallySmooth P₂ P₁ := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | H1Cotangent.equivOfFormallySmooth_symm | null |
noncomputable
equivH1CotangentOfFormallySmooth (P : Extension R S) [FormallySmooth R P.Ring] :
P.H1Cotangent ≃ₗ[S] H1Cotangent R S :=
have : FormallySmooth R (Generators.self R S).toExtension.Ring :=
inferInstanceAs (FormallySmooth R (MvPolynomial _ _))
H1Cotangent.equivOfFormallySmooth _ _ | def | RingTheory | [
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.Basic",
"Mathlib.Algebra.Module.Projective",
"Mathlib.Tactic.StacksAttribute"
] | Mathlib/RingTheory/Smooth/Kaehler.lean | equivH1CotangentOfFormallySmooth | Any formally smooth extension can be used to calculate `H¹(L_{S/R})`. |
Algebra.FormallySmooth.iff_injective_lTensor_residueField {R S} [CommRing R]
[CommRing S] [IsLocalRing S] [Algebra R S] (P : Algebra.Extension R S)
[FormallySmooth R P.Ring]
[Module.Free P.Ring Ω[P.Ring⁄R]] [Module.Finite P.Ring Ω[P.Ring⁄R]]
(h' : P.ker.FG) :
Algebra.FormallySmooth R S ↔
Function.Injective (P.cotangentComplex.lTensor (ResidueField S)) := by
have : Module.Finite P.Ring P.Cotangent :=
have : Module.Finite P.Ring P.ker := ⟨(Submodule.fg_top _).mpr h'⟩
.of_surjective _ Extension.Cotangent.mk_surjective
have : Module.Finite S P.Cotangent := Module.Finite.of_restrictScalars_finite P.Ring _ _
rw [← IsLocalRing.split_injective_iff_lTensor_residueField_injective,
P.formallySmooth_iff_split_injection] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Module",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.TensorProduct.Free"
] | Mathlib/RingTheory/Smooth/Local.lean | Algebra.FormallySmooth.iff_injective_lTensor_residueField | The **Jacobian criterion** for smoothness of local algebras.
Suppose `S` is a local `R`-algebra, and `0 → I → P → S → 0` is a presentation such that
`P` is formally-smooth over `R`, `Ω[P⁄R]` is finite free over `P`,
(typically satisfied when `P` is the localization of a polynomial ring of finite type)
and `I` is finitely generated.
Then `S` is formally smooth iff `k ⊗ₛ I/I² → k ⊗ₚ Ω[P/R]` is injective,
where `k` is the residue field of `S`. |
@[stacks 00TB]
IsSmoothAt (p : Ideal A) [p.IsPrime] : Prop :=
Algebra.FormallySmooth R (Localization.AtPrime p) | abbrev | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | IsSmoothAt | An `R`-algebra `A` is smooth at a prime `p` of `A` if `Aₚ` is formally smooth over `R`.
This does not imply `Aₚ` is smooth over `R` under the mathlib definition
even if `A` is finitely presented,
but it can be shown that this is equivalent to the stacks project definition that `A` is smooth
at `p` if and only if there exists `f ∉ p` such that `A_f` is smooth over `R`.
See `Algebra.basicOpen_subset_smoothLocus_iff_smooth` and `Algebra.isOpen_smoothLocus`. |
smoothLocus : Set (PrimeSpectrum A) := { p | IsSmoothAt R p.asIdeal }
variable {R A}
attribute [local instance] Module.finitePresentation_of_projective in | def | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | smoothLocus | `Algebra.smoothLocus R A` is the set of primes `p` of `A`
such that `Aₚ` is formally smooth over `R`. |
smoothLocus_eq_compl_support_inter [EssFiniteType R A] :
smoothLocus R A = (Module.support A (H1Cotangent R A))ᶜ ∩ Module.freeLocus A Ω[A⁄R] := by
ext p
simp only [Set.mem_inter_iff, Set.mem_compl_iff, Module.notMem_support_iff,
Module.mem_freeLocus]
refine Algebra.FormallySmooth.iff_subsingleton_and_projective.trans ?_
congr! 1
· have := IsLocalizedModule.iso p.asIdeal.primeCompl
(H1Cotangent.map R R A (Localization.AtPrime p.asIdeal))
exact this.subsingleton_congr.symm
· trans Module.Free (Localization.AtPrime p.asIdeal) Ω[Localization.AtPrime p.asIdeal⁄R]
· have : EssFiniteType A (Localization.AtPrime p.asIdeal) :=
.of_isLocalization _ p.asIdeal.primeCompl
have : EssFiniteType R (Localization.AtPrime p.asIdeal) := .comp _ A _
exact ⟨fun _ ↦ Module.free_of_flat_of_isLocalRing, fun _ ↦ inferInstance⟩
· have := IsLocalizedModule.iso p.asIdeal.primeCompl
(KaehlerDifferential.map R R A (Localization.AtPrime p.asIdeal))
have := this.extendScalarsOfIsLocalization
p.asIdeal.primeCompl (Localization.AtPrime p.asIdeal)
exact ⟨fun H ↦ H.of_equiv' this.symm, fun H ↦ H.of_equiv' this⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | smoothLocus_eq_compl_support_inter | null |
basicOpen_subset_smoothLocus_iff [FinitePresentation R A] {f : A} :
↑(PrimeSpectrum.basicOpen f) ⊆ smoothLocus R A ↔
Algebra.FormallySmooth R (Localization.Away f) := by
rw [smoothLocus_eq_compl_support_inter, Set.subset_inter_iff, Set.subset_compl_comm,
PrimeSpectrum.basicOpen_eq_zeroLocus_compl, compl_compl,
← LocalizedModule.subsingleton_iff_support_subset,
Algebra.FormallySmooth.iff_subsingleton_and_projective]
congr! 1
· have := IsLocalizedModule.iso (.powers f) (H1Cotangent.map R R A (Localization.Away f))
rw [this.subsingleton_congr]
· rw [← PrimeSpectrum.basicOpen_eq_zeroLocus_compl, Module.basicOpen_subset_freeLocus_iff]
have := IsLocalizedModule.iso (.powers f)
(KaehlerDifferential.map R R A (Localization.Away f))
have := this.extendScalarsOfIsLocalization (.powers f) (Localization.Away f)
exact ⟨fun _ ↦ .of_equiv this, fun _ ↦ .of_equiv this.symm⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | basicOpen_subset_smoothLocus_iff | null |
basicOpen_subset_smoothLocus_iff_smooth [FinitePresentation R A] {f : A} :
↑(PrimeSpectrum.basicOpen f) ⊆ smoothLocus R A ↔
Algebra.Smooth R (Localization.Away f) := by
have : FinitePresentation A (Localization.Away f) := IsLocalization.Away.finitePresentation f
rw [basicOpen_subset_smoothLocus_iff]
exact ⟨fun H ↦ ⟨H, .trans _ A _⟩, fun H ↦ H.1⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | basicOpen_subset_smoothLocus_iff_smooth | null |
smoothLocus_eq_univ_iff [FinitePresentation R A] :
smoothLocus R A = Set.univ ↔ Algebra.FormallySmooth R A := by
have := IsLocalization.atUnits A (.powers 1) (S := Localization.Away (1 : A)) (by simp)
rw [Algebra.FormallySmooth.iff_of_equiv (this.restrictScalars R),
← basicOpen_subset_smoothLocus_iff]
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | smoothLocus_eq_univ_iff | null |
smoothLocus_comap_of_isLocalization {Af : Type u} [CommRing Af] [Algebra A Af] [Algebra R Af]
[IsScalarTower R A Af] (f : A) [IsLocalization.Away f Af] :
PrimeSpectrum.comap (algebraMap A Af) ⁻¹' smoothLocus R A = smoothLocus R Af := by
ext p
let q := PrimeSpectrum.comap (algebraMap A Af) p
have : IsLocalization.AtPrime (Localization.AtPrime p.asIdeal) q.asIdeal :=
IsLocalization.isLocalization_isLocalization_atPrime_isLocalization (.powers f) _ p.asIdeal
refine Algebra.FormallySmooth.iff_of_equiv ?_
exact (IsLocalization.algEquiv q.asIdeal.primeCompl _ _).restrictScalars R
open PrimeSpectrum in | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | smoothLocus_comap_of_isLocalization | null |
isOpen_smoothLocus [FinitePresentation R A] : IsOpen (smoothLocus R A) := by
rw [isOpen_iff_forall_mem_open]
intro x hx
obtain ⟨_, ⟨_, ⟨f, rfl⟩, rfl⟩, hxf, hf⟩ :=
isBasis_basic_opens.exists_subset_of_mem_open
(smoothLocus_eq_compl_support_inter.le hx).2 Module.isOpen_freeLocus
rw [Module.basicOpen_subset_freeLocus_iff] at hf
let Af := Localization.Away f
have : Algebra.FinitePresentation A (Localization.Away f) :=
IsLocalization.Away.finitePresentation f
have : Algebra.FinitePresentation R (Localization.Away f) :=
.trans _ A _
have : IsOpen (smoothLocus R Af) := by
have := IsLocalizedModule.iso (.powers f)
(KaehlerDifferential.map R R A (Localization.Away f))
have := this.extendScalarsOfIsLocalization (.powers f) (Localization.Away f)
have := Module.Projective.of_equiv this
rw [smoothLocus_eq_compl_support_inter, Module.support_eq_zeroLocus]
exact (isClosed_zeroLocus _).isOpen_compl.inter Module.isOpen_freeLocus
rw [← smoothLocus_comap_of_isLocalization f] at this
replace this := (PrimeSpectrum.localization_away_isOpenEmbedding Af f).isOpenMap _ this
rw [Set.image_preimage_eq_inter_range, localization_away_comap_range Af f] at this
exact ⟨_, Set.inter_subset_left, this, hx, hxf⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Spectrum.Prime.FreeLocus",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Smooth/Locus.lean | isOpen_smoothLocus | null |
of_pi [FormallySmooth R (Π i, A i)] (i) :
FormallySmooth R (A i) := by
classical
fapply FormallySmooth.of_split (Pi.evalAlgHom R A i)
· apply AlgHom.ofLinearMap
((Ideal.Quotient.mkₐ R _).toLinearMap.comp (LinearMap.single _ _ i))
· change Ideal.Quotient.mk _ (Pi.single i 1) = 1
rw [← (Ideal.Quotient.mk _).map_one, ← sub_eq_zero, ← map_sub,
Ideal.Quotient.eq_zero_iff_mem]
have : Pi.single i 1 - 1 ∈ RingHom.ker (Pi.evalAlgHom R A i).toRingHom := by
simp [RingHom.mem_ker]
convert neg_mem (Ideal.pow_mem_pow this 2) using 1
simp [pow_two, sub_mul, mul_sub, ← Pi.single_mul]
· intro x y
change Ideal.Quotient.mk _ _ = Ideal.Quotient.mk _ _ * Ideal.Quotient.mk _ _
simp only [AlgHom.toRingHom_eq_coe, LinearMap.coe_single, Pi.single_mul, map_mul]
· ext x
change (Pi.single i x) i = x
simp | theorem | RingTheory | [
"Mathlib.RingTheory.Idempotents",
"Mathlib.RingTheory.Smooth.Basic"
] | Mathlib/RingTheory/Smooth/Pi.lean | of_pi | null |
pi_iff [Finite I] :
FormallySmooth R (Π i, A i) ↔ ∀ i, FormallySmooth R (A i) := by
classical
cases nonempty_fintype I
constructor
· exact fun _ ↦ of_pi A
· intro H
constructor
intro B _ _ J hJ g
have hJ' (x) (hx : x ∈ RingHom.ker (Ideal.Quotient.mk J)) : IsNilpotent x := by
refine ⟨2, show x ^ 2 ∈ (⊥ : Ideal B) from ?_⟩
rw [← hJ]
exact Ideal.pow_mem_pow (by simpa using hx) 2
obtain ⟨e, he, he'⟩ := ((CompleteOrthogonalIdempotents.single A).map
g.toRingHom).lift_of_isNilpotent_ker (Ideal.Quotient.mk J) hJ'
fun _ ↦ Ideal.Quotient.mk_surjective _
replace he' : ∀ i, Ideal.Quotient.mk J (e i) = g (Pi.single i 1) := congr_fun he'
let iso : B ≃ₐ[R] ∀ i, B ⧸ Ideal.span {1 - e i} :=
{ __ := Pi.algHom _ _ fun i ↦ Ideal.Quotient.mkₐ R _
__ := Equiv.ofBijective _ he.bijective_pi }
let J' := fun i ↦ J.map (Ideal.Quotient.mk (Ideal.span {1 - e i}))
let ι : ∀ i, (B ⧸ J →ₐ[R] (B ⧸ _) ⧸ J' i) := fun i ↦ Ideal.quotientMapₐ _
(IsScalarTower.toAlgHom R B _) Ideal.le_comap_map
have hι : ∀ i x, ι i x = 0 → (e i) * x = 0 := by
intro i x hix
have : x ∈ (Ideal.span {1 - e i}).map (Ideal.Quotient.mk J) := by
rw [← Ideal.ker_quotientMap_mk]; exact hix
rw [Ideal.map_span, Set.image_singleton, Ideal.mem_span_singleton] at this
obtain ⟨c, rfl⟩ := this
rw [← mul_assoc, ← map_mul, mul_sub, mul_one, (he.idem i).eq, sub_self, map_zero, zero_mul]
have : ∀ i : I, ∃ a : A i →ₐ[R] B ⧸ Ideal.span {1 - e i}, ∀ x,
Ideal.Quotient.mk (J' i) (a x) = ι i (g (Pi.single i x)) := by
intro i
let g' : A i →ₐ[R] (B ⧸ _) ⧸ (J' i) := by
apply AlgHom.ofLinearMap (((ι i).comp g).toLinearMap ∘ₗ LinearMap.single _ _ i)
· suffices Ideal.Quotient.mk (Ideal.span {1 - e i}) (e i) = 1 by simp [ι, ← he', this]
rw [← (Ideal.Quotient.mk _).map_one, eq_comm, Ideal.Quotient.mk_eq_mk_iff_sub_mem,
Ideal.mem_span_singleton]
· intro x y; simp [Pi.single_mul]
obtain ⟨a, ha⟩ := FormallySmooth.comp_surjective (I := J' i)
(by rw [← Ideal.map_pow, hJ, Ideal.map_bot]) g'
exact ⟨a, AlgHom.congr_fun ha⟩
choose a ha using this
use iso.symm.toAlgHom.comp (Pi.algHom _ _ fun i ↦ (a i).comp (Pi.evalAlgHom R A i))
ext x; rw [← AlgHom.toLinearMap_apply, ← AlgHom.toLinearMap_apply]; congr 1
ext i x
simp only [AlgEquiv.toAlgHom_eq_coe, AlgHom.comp_toLinearMap, AlgEquiv.toAlgHom_toLinearMap,
LinearMap.coe_comp, LinearMap.coe_single, Function.comp_apply, AlgHom.toLinearMap_apply,
AlgEquiv.toLinearMap_apply, Ideal.Quotient.mkₐ_eq_mk]
obtain ⟨y, hy⟩ := Ideal.Quotient.mk_surjective (a i x)
have hy' : Ideal.Quotient.mk (Ideal.span {1 - e i}) (y * e i) = a i x := by
... | theorem | RingTheory | [
"Mathlib.RingTheory.Idempotents",
"Mathlib.RingTheory.Smooth.Basic"
] | Mathlib/RingTheory/Smooth/Pi.lean | pi_iff | null |
IsStandardSmooth : Prop where
out : ∃ (ι σ : Type) (_ : Finite σ), Finite ι ∧ Nonempty (SubmersivePresentation R S ι σ)
variable [Finite σ] | class | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmooth | An `R`-algebra `S` is called standard smooth, if there
exists a submersive presentation. |
SubmersivePresentation.isStandardSmooth [Finite ι] (P : SubmersivePresentation R S ι σ) :
IsStandardSmooth R S := by
exact ⟨_, _, _, inferInstance, ⟨P.reindex (Fintype.equivFin _).symm (Fintype.equivFin _).symm⟩⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | SubmersivePresentation.isStandardSmooth | null |
noncomputable IsStandardSmooth.relativeDimension [IsStandardSmooth R S] : ℕ :=
letI := ‹IsStandardSmooth R S›.out.choose_spec.choose_spec.choose
‹IsStandardSmooth R S›.out.choose_spec.choose_spec.choose_spec.2.some.dimension | def | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmooth.relativeDimension | The relative dimension of a standard smooth `R`-algebra `S` is
the dimension of an arbitrarily chosen submersive `R`-presentation of `S`.
Note: If `S` is non-trivial, this number is independent of the choice of the presentation as it is
equal to the `S`-rank of `Ω[S/R]`
(see `IsStandardSmoothOfRelativeDimension.rank_kaehlerDifferential`). |
IsStandardSmoothOfRelativeDimension : Prop where
out : ∃ (ι σ : Type) (_ : Finite σ) (_ : Finite ι) (P : SubmersivePresentation R S ι σ),
P.dimension = n | class | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension | An `R`-algebra `S` is called standard smooth of relative dimension `n`, if there exists
a submersive presentation of dimension `n`. |
SubmersivePresentation.isStandardSmoothOfRelativeDimension [Finite ι]
(P : SubmersivePresentation R S ι σ) (hP : P.dimension = n) :
IsStandardSmoothOfRelativeDimension n R S := by
refine ⟨⟨_, _, _, inferInstance,
P.reindex (Fintype.equivFin _).symm (Fintype.equivFin σ).symm, ?_⟩⟩
simp [hP]
variable {R} {S} | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | SubmersivePresentation.isStandardSmoothOfRelativeDimension | null |
IsStandardSmoothOfRelativeDimension.isStandardSmooth
[H : IsStandardSmoothOfRelativeDimension n R S] : IsStandardSmooth R S :=
⟨_, _, _, H.out.choose_spec.choose_spec.choose_spec.choose,
H.out.choose_spec.choose_spec.choose_spec.choose_spec.nonempty⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.isStandardSmooth | null |
IsStandardSmoothOfRelativeDimension.of_algebraMap_bijective
(h : Function.Bijective (algebraMap R S)) :
IsStandardSmoothOfRelativeDimension 0 R S :=
⟨_, _, _, inferInstance,
SubmersivePresentation.ofBijectiveAlgebraMap h, Presentation.ofBijectiveAlgebraMap_dimension h⟩
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.of_algebraMap_bijective | null |
IsStandardSmoothOfRelativeDimension.id :
IsStandardSmoothOfRelativeDimension 0 R R :=
IsStandardSmoothOfRelativeDimension.of_algebraMap_bijective Function.bijective_id | instance | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.id | null |
IsStandardSmooth.trans [IsStandardSmooth R S] [IsStandardSmooth S T] :
IsStandardSmooth R T where
out := by
obtain ⟨_, _, _, _, ⟨P⟩⟩ := ‹IsStandardSmooth R S›
obtain ⟨_, _, _, _, ⟨Q⟩⟩ := ‹IsStandardSmooth S T›
exact ⟨_, _, _, inferInstance, ⟨Q.comp P⟩⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmooth.trans | null |
IsStandardSmoothOfRelativeDimension.trans [IsStandardSmoothOfRelativeDimension n R S]
[IsStandardSmoothOfRelativeDimension m S T] :
IsStandardSmoothOfRelativeDimension (m + n) R T where
out := by
obtain ⟨_, _, _, _, P, hP⟩ := ‹IsStandardSmoothOfRelativeDimension n R S›
obtain ⟨_, _, _, _, Q, hQ⟩ := ‹IsStandardSmoothOfRelativeDimension m S T›
refine ⟨_, _, _, inferInstance, Q.comp P, hP ▸ hQ ▸ ?_⟩
apply PreSubmersivePresentation.dimension_comp_eq_dimension_add_dimension | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.trans | null |
IsStandardSmooth.localization_away (r : R) [IsLocalization.Away r S] :
IsStandardSmooth R S where
out := ⟨_, _, _, inferInstance, ⟨SubmersivePresentation.localizationAway S r⟩⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmooth.localization_away | null |
IsStandardSmoothOfRelativeDimension.localization_away (r : R) [IsLocalization.Away r S] :
IsStandardSmoothOfRelativeDimension 0 R S where
out := ⟨_, _, _, inferInstance, SubmersivePresentation.localizationAway S r,
Presentation.localizationAway_dimension_zero r⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.localization_away | null |
IsStandardSmooth.baseChange [IsStandardSmooth R S] :
IsStandardSmooth T (T ⊗[R] S) where
out := by
obtain ⟨ι, σ, _, _, ⟨P⟩⟩ := ‹IsStandardSmooth R S›
exact ⟨ι, σ, _, inferInstance, ⟨P.baseChange T⟩⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmooth.baseChange | null |
IsStandardSmoothOfRelativeDimension.baseChange
[IsStandardSmoothOfRelativeDimension n R S] :
IsStandardSmoothOfRelativeDimension n T (T ⊗[R] S) where
out := by
obtain ⟨_, _, _, _, P, hP⟩ := ‹IsStandardSmoothOfRelativeDimension n R S›
exact ⟨_, _, _, inferInstance, P.baseChange T, hP⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Extension.Presentation.Submersive"
] | Mathlib/RingTheory/Smooth/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.baseChange | null |
noncomputable cotangentComplexAux [Finite σ] (P : PreSubmersivePresentation R S ι σ) :
P.toExtension.Cotangent →ₗ[S] σ → S :=
Finsupp.linearEquivFunOnFinite S S σ ∘ₗ Finsupp.lcomapDomain _ P.map_inj ∘ₗ
P.cotangentSpaceBasis.repr.toLinearMap ∘ₗ P.toExtension.cotangentComplex | def | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentComplexAux | Given a pre-submersive presentation, this is the composition
`I ⧸ I ^ 2 → ⊕ S dxᵢ → ⊕ S dxᵢ` where the second direct sum runs over
all `i : σ` induced by the injection `P.map : σ → ι`.
If `P` is submersive, this is an isomorphism. See `SubmersivePresentation.cotangentEquiv`. |
cotangentComplexAux_apply [Finite σ] (P : PreSubmersivePresentation R S ι σ)
(x : P.ker) (i : σ) :
P.cotangentComplexAux (Cotangent.mk x) i = (aeval P.val) (pderiv (P.map i) x.val) := by
dsimp only [cotangentComplexAux, LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply,
cotangentComplex_mk]
simp only [Generators.toExtension_Ring, Finsupp.lcomapDomain_apply,
Finsupp.linearEquivFunOnFinite_apply, Finsupp.comapDomain_apply,
Generators.cotangentSpaceBasis_repr_tmul, one_mul] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentComplexAux_apply | null |
cotangentComplexAux_zero_iff [Finite σ] {P : PreSubmersivePresentation R S ι σ} (x : P.ker) :
P.cotangentComplexAux (Cotangent.mk x) = 0 ↔
∀ i : σ, (aeval P.val) (pderiv (P.map i) x.val) = 0 := by
rw [funext_iff]
simp_rw [cotangentComplexAux_apply, Pi.zero_apply] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentComplexAux_zero_iff | null |
cotangentComplexAux_injective [Finite σ] : Function.Injective P.cotangentComplexAux := by
rw [← LinearMap.ker_eq_bot, eq_bot_iff]
intro x hx
obtain ⟨(x : P.ker), rfl⟩ := Cotangent.mk_surjective x
rw [Submodule.mem_bot, Cotangent.mk_eq_zero_iff]
rw [LinearMap.mem_ker, P.cotangentComplexAux_zero_iff] at hx
have : x.val ∈ Ideal.span (Set.range P.relation) := by
rw [P.span_range_relation_eq_ker]
exact x.property
obtain ⟨c, hc⟩ := Finsupp.mem_ideal_span_range_iff_exists_finsupp.mp this
have heq (i : σ) :
aeval P.val (pderiv (P.map i) <| c.sum fun i a ↦ a * P.relation i) = 0 := by
rw [hc]
apply hx
simp only [Finsupp.sum, map_sum, Derivation.leibniz, smul_eq_mul, map_add, map_mul,
Presentation.aeval_val_relation, zero_mul, add_zero] at heq
have heq2 : ∑ i ∈ c.support,
aeval P.val (c i) • (fun j ↦ aeval P.val (pderiv (P.map j) (P.relation i))) = 0 := by
ext j
simp only [Finset.sum_apply, Pi.smul_apply, smul_eq_mul, Pi.zero_apply]
apply heq
have (i : σ) : aeval P.val (c i) = 0 := by
have := P.linearIndependent_aeval_val_pderiv_relation
rw [linearIndependent_iff''] at this
have := this c.support (fun i ↦ aeval P.val (c i))
(by intro i; simp only [Finsupp.mem_support_iff, ne_eq, not_not]; intro h; simp [h]) heq2
exact this i
change _ ∈ P.ker ^ 2
rw [← hc]
apply Ideal.sum_mem
intro i hi
rw [pow_two]
apply Ideal.mul_mem_mul
· rw [P.ker_eq_ker_aeval_val]
simpa using this i
· exact P.relation_mem_ker i | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentComplexAux_injective | null |
cotangentComplexAux_surjective [Finite σ] : Function.Surjective P.cotangentComplexAux := by
rw [← LinearMap.range_eq_top, _root_.eq_top_iff, ← P.basisDeriv.span_eq, Submodule.span_le]
rintro - ⟨i, rfl⟩
use Cotangent.mk ⟨P.relation i, P.relation_mem_ker i⟩
ext j
rw [P.cotangentComplexAux_apply]
simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentComplexAux_surjective | null |
@[simps! apply]
noncomputable cotangentEquiv : P.toExtension.Cotangent ≃ₗ[S] σ → S :=
LinearEquiv.ofBijective _ ⟨P.cotangentComplexAux_injective, P.cotangentComplexAux_surjective⟩ | def | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentEquiv | The isomorphism of `S`-modules between `I ⧸ I ^ 2` and `σ → S` given
by `P.relation i ↦ ∂ⱼ (P.relation i)`. |
cotangentComplex_injective : Function.Injective P.toExtension.cotangentComplex := by
have := P.cotangentComplexAux_injective
simp only [PreSubmersivePresentation.cotangentComplexAux, LinearMap.coe_comp,
LinearEquiv.coe_coe] at this
exact Function.Injective.of_comp (Function.Injective.of_comp <| Function.Injective.of_comp this) | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | cotangentComplex_injective | null |
subsingleton_h1Cotangent : Subsingleton P.toExtension.H1Cotangent := by
rw [Algebra.Extension.subsingleton_h1Cotangent]
exact cotangentComplex_injective P | instance | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | subsingleton_h1Cotangent | If `P` is a submersive presentation, `H¹` of the associated cotangent complex vanishes. |
@[stacks 00T7 "(3)"]
noncomputable basisCotangent : Basis σ S P.toExtension.Cotangent :=
P.basisDeriv.map P.cotangentEquiv.symm | def | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | basisCotangent | The classes of `P.relation i` form a basis of `I ⧸ I ^ 2`. |
basisCotangent_apply (r : σ) :
P.basisCotangent r = Extension.Cotangent.mk ⟨P.relation r, P.relation_mem_ker r⟩ := by
symm
apply P.cotangentEquiv.injective
ext
simp_rw [basisCotangent, Basis.map_apply, LinearEquiv.apply_symm_apply, basisDeriv_apply]
apply P.toPreSubmersivePresentation.cotangentComplexAux_apply _ _
@[stacks 00T7 "(3)"] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | basisCotangent_apply | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.