File: Mathlib/RingTheory/Ideal/Cotangent.lean

full_name: Ideal.Cotangent
code: /-- `I ⧸ I ^ 2` as a quotient of `I`. -/
def Cotangent : Type _ 
goal: Type u

full_name: Ideal.instAddCommGroupCotangent
code: instance : AddCommGroup I.Cotangent 
goal: AddCommGroup I.Cotangent

full_name: Ideal.cotangentModule
code: instance cotangentModule : Module (R ⧸ I) I.Cotangent 
goal: Module (R ⧸ I) I.Cotangent

full_name: Ideal.instInhabitedCotangent
code: instance : Inhabited I.Cotangent 
goal: Inhabited I.Cotangent

full_name: Ideal.Cotangent.moduleOfTower
code: instance Cotangent.moduleOfTower : Module S I.Cotangent 
goal: Module S I.Cotangent

full_name: Ideal.Cotangent.isScalarTower
code: instance Cotangent.isScalarTower : IsScalarTower S S' I.Cotangent 
goal: IsScalarTower S S' I.Cotangent

full_name: Ideal.instIsNoetherianCotangentOfSubtypeMem
code: instance [IsNoetherian R I] : IsNoetherian R I.Cotangent 
goal: IsNoetherian R I.Cotangent

full_name: Ideal.toCotangent_apply
code: /-- The quotient map from `I` to `I ⧸ I ^ 2`. -/
@[simps! (config := .lemmasOnly) apply]
def toCotangent : I →ₗ[R] I.Cotangent 
goal: ∀ (a : ↥I), I.toCotangent a = Submodule.Quotient.mk a

full_name: Ideal.toCotangent
code: /-- The quotient map from `I` to `I ⧸ I ^ 2`. -/
@[simps! (config := .lemmasOnly) apply]
def toCotangent : I →ₗ[R] I.Cotangent 
goal: ↥I →ₗ[R] I.Cotangent

full_name: Ideal.map_toCotangent_ker
code: theorem map_toCotangent_ker : I.toCotangent.ker.map I.subtype = I ^ 2 
goal: Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent) = I ^ 2

full_name: Ideal.mem_toCotangent_ker
code: theorem mem_toCotangent_ker {x : I} : x ∈ LinearMap.ker I.toCotangent ↔ (x : R) ∈ I ^ 2 
goal: x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ I ^ 2

full_name: Ideal.toCotangent_eq
code: theorem toCotangent_eq {x y : I} : I.toCotangent x = I.toCotangent y ↔ (x - y : R) ∈ I ^ 2 
goal: I.toCotangent x = I.toCotangent y ↔ ↑x - ↑y ∈ I ^ 2

full_name: Ideal.toCotangent_eq_zero
code: theorem toCotangent_eq_zero (x : I) : I.toCotangent x = 0 ↔ (x : R) ∈ I ^ 2 
goal: I.toCotangent x = 0 ↔ ↑x ∈ I ^ 2

full_name: Ideal.toCotangent_surjective
code: theorem toCotangent_surjective : Function.Surjective I.toCotangent 
goal: Function.Surjective ⇑I.toCotangent

full_name: Ideal.toCotangent_range
code: theorem toCotangent_range : LinearMap.range I.toCotangent = ⊤ 
goal: LinearMap.range I.toCotangent = ⊤

full_name: Ideal.cotangent_subsingleton_iff
code: theorem cotangent_subsingleton_iff : Subsingleton I.Cotangent ↔ IsIdempotentElem I 
goal: Subsingleton I.Cotangent ↔ IsIdempotentElem I

full_name: Ideal.cotangentToQuotientSquare
code: /-- The inclusion map `I ⧸ I ^ 2` to `R ⧸ I ^ 2`. -/
def cotangentToQuotientSquare : I.Cotangent →ₗ[R] R ⧸ I ^ 2 
goal: I.Cotangent →ₗ[R] R ⧸ I ^ 2

full_name: Ideal.to_quotient_square_comp_toCotangent
code: theorem to_quotient_square_comp_toCotangent :
    I.cotangentToQuotientSquare.comp I.toCotangent = (I ^ 2).mkQ.comp (Submodule.subtype I) 
goal: I.cotangentToQuotientSquare ∘ₗ I.toCotangent = Submodule.mkQ (I ^ 2) ∘ₗ Submodule.subtype I

full_name: Ideal.toCotangent_to_quotient_square
code: @[simp]
theorem toCotangent_to_quotient_square (x : I) :
    I.cotangentToQuotientSquare (I.toCotangent x) = (I ^ 2).mkQ x 
goal: I.cotangentToQuotientSquare (I.toCotangent x) = (Submodule.mkQ (I ^ 2)) ↑x

full_name: Ideal.cotangentIdeal
code: /-- `I ⧸ I ^ 2` as an ideal of `R ⧸ I ^ 2`. -/
def cotangentIdeal (I : Ideal R) : Ideal (R ⧸ I ^ 2) 
goal: Ideal (R ⧸ I ^ 2)

full_name: Ideal.cotangentIdeal_square
code: theorem cotangentIdeal_square (I : Ideal R) : I.cotangentIdeal ^ 2 = ⊥ 
goal: I.cotangentIdeal ^ 2 = ⊥

full_name: Ideal.to_quotient_square_range
code: theorem to_quotient_square_range :
    LinearMap.range I.cotangentToQuotientSquare = I.cotangentIdeal.restrictScalars R 
goal: LinearMap.range I.cotangentToQuotientSquare = Submodule.restrictScalars R I.cotangentIdeal

full_name: Ideal.cotangentEquivIdeal
code: /-- The equivalence of the two definitions of `I / I ^ 2`, either as the quotient of `I` or the
ideal of `R / I ^ 2`. -/
noncomputable def cotangentEquivIdeal : I.Cotangent ≃ₗ[R] I.cotangentIdeal 
goal: I.Cotangent ≃ₗ[R] ↥I.cotangentIdeal

full_name: Ideal.cotangentEquivIdeal_apply
code: @[simp]
theorem cotangentEquivIdeal_apply (x : I.Cotangent) :
    ↑(I.cotangentEquivIdeal x) = I.cotangentToQuotientSquare x 
goal: ↑(I.cotangentEquivIdeal x) = I.cotangentToQuotientSquare x

full_name: Ideal.cotangentEquivIdeal_symm_apply
code: theorem cotangentEquivIdeal_symm_apply (x : R) (hx : x ∈ I) :
    -- Note: #8386 had to specify `(R₂ := R)` because `I.toCotangent` suggested `R ⧸ I^2` instead
    I.cotangentEquivIdeal.symm ⟨(I ^ 2).mkQ x, Submodule.mem_map_of_mem (R₂ := R) hx⟩ =
      I.toCotangent ⟨x, hx⟩ 
goal: I.cotangentEquivIdeal.symm ⟨(Submodule.mkQ (I ^ 2)) x, ⋯⟩ = I.toCotangent ⟨x, hx⟩

full_name: AlgHom.kerSquareLift
code: /-- The lift of `f : A →ₐ[R] B` to `A ⧸ J ^ 2 →ₐ[R] B` with `J` being the kernel of `f`. -/
def _root_.AlgHom.kerSquareLift (f : A →ₐ[R] B) : A ⧸ RingHom.ker f.toRingHom ^ 2 →ₐ[R] B 
goal: A ⧸ RingHom.ker f.toRingHom ^ 2 →ₐ[R] B

full_name: AlgHom.ker_kerSquareLift
code: theorem _root_.AlgHom.ker_kerSquareLift (f : A →ₐ[R] B) :
    RingHom.ker f.kerSquareLift.toRingHom = f.toRingHom.ker.cotangentIdeal 
goal: RingHom.ker f.kerSquareLift.toRingHom = (RingHom.ker f.toRingHom).cotangentIdeal

full_name: Ideal.quotCotangent
code: /-- The quotient ring of `I ⧸ I ^ 2` is `R ⧸ I`. -/
def quotCotangent : (R ⧸ I ^ 2) ⧸ I.cotangentIdeal ≃+* R ⧸ I 
goal: (R ⧸ I ^ 2) ⧸ I.cotangentIdeal ≃+* R ⧸ I

full_name: Ideal.mapCotangent
code: /-- The map `I/I² → J/J²` if `I ≤ f⁻¹(J)`. -/
def mapCotangent (I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ I₂.comap f) :
    I₁.Cotangent →ₗ[R] I₂.Cotangent 
goal: I₁.Cotangent →ₗ[R] I₂.Cotangent

full_name: Ideal.mapCotangent_toCotangent
code: @[simp]
lemma mapCotangent_toCotangent
    (I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ I₂.comap f) (x : I₁) :
    Ideal.mapCotangent I₁ I₂ f h (Ideal.toCotangent I₁ x) = Ideal.toCotangent I₂ ⟨f x, h x.2⟩ 
goal: (I₁.mapCotangent I₂ f h) (I₁.toCotangent x) = I₂.toCotangent ⟨f ↑x, ⋯⟩

full_name: LocalRing.CotangentSpace
code: /-- The `A ⧸ I`-vector space `I ⧸ I ^ 2`. -/
abbrev CotangentSpace : Type _ 
goal: Type u_1

full_name: LocalRing.instModuleResidueFieldCotangentSpace
code: instance : Module (ResidueField R) (CotangentSpace R) 
goal: Module (LocalRing.ResidueField R) (LocalRing.CotangentSpace R)

full_name: LocalRing.instIsScalarTowerResidueFieldCotangentSpace
code: instance : IsScalarTower R (ResidueField R) (CotangentSpace R) 
goal: IsScalarTower R (LocalRing.ResidueField R) (LocalRing.CotangentSpace R)

full_name: LocalRing.instFiniteDimensionalResidueFieldCotangentSpaceOfIsNoetherianRing
code: instance [IsNoetherianRing R] : FiniteDimensional (ResidueField R) (CotangentSpace R) 
goal: FiniteDimensional (LocalRing.ResidueField R) (LocalRing.CotangentSpace R)

full_name: LocalRing.subsingleton_cotangentSpace_iff
code: lemma subsingleton_cotangentSpace_iff [IsNoetherianRing R] :
    Subsingleton (CotangentSpace R) ↔ IsField R 
goal: Subsingleton (LocalRing.CotangentSpace R) ↔ IsField R

full_name: LocalRing.CotangentSpace.map_eq_top_iff
code: lemma CotangentSpace.map_eq_top_iff [IsNoetherianRing R] {M : Submodule R (maximalIdeal R)} :
    M.map (maximalIdeal R).toCotangent = ⊤ ↔ M = ⊤ 
goal: Submodule.map (LocalRing.maximalIdeal R).toCotangent M = ⊤ ↔ M = ⊤

full_name: LocalRing.CotangentSpace.span_image_eq_top_iff
code: lemma CotangentSpace.span_image_eq_top_iff [IsNoetherianRing R] {s : Set (maximalIdeal R)} :
    Submodule.span (ResidueField R) ((maximalIdeal R).toCotangent '' s) = ⊤ ↔
      Submodule.span R s = ⊤ 
goal: Submodule.span (LocalRing.ResidueField R) (⇑(LocalRing.maximalIdeal R).toCotangent '' s) = ⊤ ↔ Submodule.span R s = ⊤

full_name: LocalRing.finrank_cotangentSpace_eq_zero_iff
code: lemma finrank_cotangentSpace_eq_zero_iff [IsNoetherianRing R] :
    finrank (ResidueField R) (CotangentSpace R) = 0 ↔ IsField R 
goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 0 ↔ IsField R

full_name: LocalRing.finrank_cotangentSpace_eq_zero
code: lemma finrank_cotangentSpace_eq_zero (R) [Field R] :
    finrank (ResidueField R) (CotangentSpace R) = 0 
goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 0

full_name: LocalRing.finrank_cotangentSpace_le_one_iff
code: theorem finrank_cotangentSpace_le_one_iff [IsNoetherianRing R] :
    finrank (ResidueField R) (CotangentSpace R) ≤ 1 ↔ (maximalIdeal R).IsPrincipal 
goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) ≤ 1 ↔
  Submodule.IsPrincipal (LocalRing.maximalIdeal R)