File: Mathlib/RingTheory/Kaehler/CotangentComplex.lean

full_name: Algebra.Generators.CotangentSpace
code: /--
The cotangent space on `P = R[X]`.
This is isomorphic to `Sⁿ` with `n` being the number of variables of `P`.
-/
abbrev CotangentSpace : Type _ 
goal: Type (max (max u w) v)

full_name: Algebra.Generators.cotangentSpaceBasis
code: /-- The canonical basis on the `CotangentSpace`. -/
noncomputable
def cotangentSpaceBasis : Basis P.vars S P.CotangentSpace 
goal: Basis P.vars S P.CotangentSpace

full_name: Algebra.Generators.cotangentSpaceBasis_repr_tmul
code: @[simp]
lemma cotangentSpaceBasis_repr_tmul (r x i) :
    P.cotangentSpaceBasis.repr (r ⊗ₜ .D _ _ x) i = r * aeval P.val (pderiv i x) 
goal: (P.cotangentSpaceBasis.repr (r ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) x)) i =
  r * (MvPolynomial.aeval P.val) ((MvPolynomial.pderiv i) x)

full_name: Algebra.Generators.cotangentSpaceBasis_repr_one_tmul
code: lemma cotangentSpaceBasis_repr_one_tmul (x i) :
    P.cotangentSpaceBasis.repr (1 ⊗ₜ .D _ _ x) i = aeval P.val (pderiv i x) 
goal: (P.cotangentSpaceBasis.repr (1 ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) x)) i =
  (MvPolynomial.aeval P.val) ((MvPolynomial.pderiv i) x)

full_name: Algebra.Generators.cotangentSpaceBasis_apply
code: lemma cotangentSpaceBasis_apply i :
    P.cotangentSpaceBasis i = 1 ⊗ₜ .D _ _ (.X i) 
goal: P.cotangentSpaceBasis i = 1 ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) (MvPolynomial.X i)

full_name: Algebra.Generators.cotangentComplex
code: /-- The cotangent complex given by a presentation `R[X] → S` (i.e. a closed embedding `S ↪ Aⁿ`). -/
noncomputable
def cotangentComplex : P.Cotangent →ₗ[S] P.CotangentSpace 
goal: P.Cotangent →ₗ[S] P.CotangentSpace

full_name: Algebra.Generators.cotangentComplex_mk
code: @[simp]
lemma cotangentComplex_mk (x) : P.cotangentComplex (.mk x) = 1 ⊗ₜ .D _ _ x 
goal: P.cotangentComplex (Algebra.Generators.Cotangent.mk x) = 1 ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) ↑x

full_name: Algebra.Generators.CotangentSpace.map
code: /--
This is the map on the cotangent space associated to a map of presentation.
The matrix associated to this map is the Jacobian matrix. See `CotangentSpace.repr_map`.
-/
protected noncomputable
def map (f : Hom P P') : P.CotangentSpace →ₗ[S] P'.CotangentSpace 
goal: P.CotangentSpace →ₗ[S] P'.CotangentSpace

full_name: Algebra.Generators.CotangentSpace.map_tmul
code: @[simp]
lemma map_tmul (f : Hom P P') (x y) :
    CotangentSpace.map f (x ⊗ₜ .D _ _ y) = (algebraMap _ _ x) ⊗ₜ .D _ _ (f.toAlgHom y) 
goal: (Algebra.Generators.CotangentSpace.map f) (x ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) y) =
  (algebraMap S S') x ⊗ₜ[P'.Ring] (KaehlerDifferential.D R' P'.Ring) (f.toAlgHom y)

full_name: Algebra.Generators.CotangentSpace.repr_map
code: @[simp]
lemma repr_map (f : Hom P P') (i j) :
    P'.cotangentSpaceBasis.repr (CotangentSpace.map f (P.cotangentSpaceBasis i)) j =
      aeval P'.val (pderiv j (f.val i)) 
goal: (P'.cotangentSpaceBasis.repr ((Algebra.Generators.CotangentSpace.map f) (P.cotangentSpaceBasis i))) j =
  (MvPolynomial.aeval P'.val) ((MvPolynomial.pderiv j) (f.val i))

full_name: Algebra.Generators.CotangentSpace.map_id
code: @[simp]
lemma map_id :
    CotangentSpace.map (.id P) = LinearMap.id 
goal: Algebra.Generators.CotangentSpace.map (Algebra.Generators.Hom.id P) = LinearMap.id

full_name: Algebra.Generators.CotangentSpace.map_comp
code: lemma map_comp (f : Hom P P') (g : Hom P' P'') :
    CotangentSpace.map (g.comp f) =
      (CotangentSpace.map g).restrictScalars S ∘ₗ CotangentSpace.map f 
goal: Algebra.Generators.CotangentSpace.map (g.comp f) =
  ↑S (Algebra.Generators.CotangentSpace.map g) ∘ₗ Algebra.Generators.CotangentSpace.map f

full_name: Algebra.Generators.CotangentSpace.map_comp_apply
code: lemma map_comp_apply (f : Hom P P') (g : Hom P' P'') (x) :
    CotangentSpace.map (g.comp f) x = .map g (.map f x) 
goal: (Algebra.Generators.CotangentSpace.map (g.comp f)) x =
  (Algebra.Generators.CotangentSpace.map g) ((Algebra.Generators.CotangentSpace.map f) x)

full_name: Algebra.Generators.CotangentSpace.map_cotangentComplex
code: lemma map_cotangentComplex (f : Hom P P') (x) :
    CotangentSpace.map f (P.cotangentComplex x) = P'.cotangentComplex (.map f x) 
goal: (Algebra.Generators.CotangentSpace.map f) (P.cotangentComplex x) =
  P'.cotangentComplex ((Algebra.Generators.Cotangent.map f) x)

full_name: Algebra.Generators.CotangentSpace.map_comp_cotangentComplex
code: lemma map_comp_cotangentComplex (f : Hom P P') :
    CotangentSpace.map f ∘ₗ P.cotangentComplex =
      P'.cotangentComplex.restrictScalars S ∘ₗ Cotangent.map f 
goal: Algebra.Generators.CotangentSpace.map f ∘ₗ P.cotangentComplex =
  ↑S P'.cotangentComplex ∘ₗ Algebra.Generators.Cotangent.map f

full_name: Algebra.Generators.Hom.sub_aux
code: lemma Hom.sub_aux (f g : Hom P P') (x y) :
    letI := ((algebraMap S S').comp (algebraMap P.Ring S)).toAlgebra
    f.toAlgHom (x * y) - g.toAlgHom (x * y) -
        (P'.σ ((algebraMap P.Ring S') x) * (f.toAlgHom y - g.toAlgHom y) +
          P'.σ ((algebraMap P.Ring S') y) * (f.toAlgHom x - g.toAlgHom x)) ∈
      P'.ker ^ 2 
goal: f.toAlgHom (x * y) - g.toAlgHom (x * y) -
    (P'.σ ((algebraMap P.Ring S') x) * (f.toAlgHom y - g.toAlgHom y) +
      P'.σ ((algebraMap P.Ring S') y) * (f.toAlgHom x - g.toAlgHom x)) ∈
  P'.ker ^ 2

full_name: Algebra.Generators.Hom.subToKer
code: /--
If `f` and `g` are two maps `P → P'` between presentations,
then the image of `f - g` is in the kernel of `P' → S`.
-/
@[simps! apply_coe]
noncomputable
def Hom.subToKer (f g : Hom P P') : P.Ring →ₗ[R] P'.ker 
goal: P.Ring →ₗ[R] ↥P'.ker

full_name: Algebra.Generators.Hom.subToKer_apply_coe
code: /--
If `f` and `g` are two maps `P → P'` between presentations,
then the image of `f - g` is in the kernel of `P' → S`.
-/
@[simps! apply_coe]
noncomputable
def Hom.subToKer (f g : Hom P P') : P.Ring →ₗ[R] P'.ker 
goal: ↑((f.subToKer g) c) = f.toAlgHom c - g.toAlgHom c

full_name: Algebra.Generators.Hom.sub
code: /--
If `f` and `g` are two maps `P → P'` between presentations,
their difference induces a map `P.CotangentSpace →ₗ[S] P'.Cotangent` that makes two maps
between the cotangent complexes homotopic.
-/
noncomputable
def Hom.sub (f g : Hom P P') : P.CotangentSpace →ₗ[S] P'.Cotangent 
goal: P.CotangentSpace →ₗ[S] P'.Cotangent

full_name: Algebra.Generators.Hom.sub_one_tmul
code: lemma Hom.sub_one_tmul (f g : Hom P P') (x) :
    f.sub g (1 ⊗ₜ .D _ _ x) = Cotangent.mk (f.subToKer g x) 
goal: (f.sub g) (1 ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) x) = Algebra.Generators.Cotangent.mk ((f.subToKer g) x)

full_name: Algebra.Generators.Hom.sub_tmul
code: @[simp]
lemma Hom.sub_tmul (f g : Hom P P') (r x) :
    f.sub g (r ⊗ₜ .D _ _ x) = r • Cotangent.mk (f.subToKer g x) 
goal: (f.sub g) (r ⊗ₜ[P.Ring] (KaehlerDifferential.D R P.Ring) x) = r • Algebra.Generators.Cotangent.mk ((f.subToKer g) x)

full_name: Algebra.Generators.CotangentSpace.map_sub_map
code: lemma CotangentSpace.map_sub_map (f g : Hom P P') :
    CotangentSpace.map f - CotangentSpace.map g =
      P'.cotangentComplex.restrictScalars S ∘ₗ (f.sub g) 
goal: Algebra.Generators.CotangentSpace.map f - Algebra.Generators.CotangentSpace.map g = ↑S P'.cotangentComplex ∘ₗ f.sub g

full_name: Algebra.Generators.Cotangent.map_sub_map
code: lemma Cotangent.map_sub_map (f g : Hom P P') :
    map f - map g = (f.sub g) ∘ₗ P.cotangentComplex 
goal: Algebra.Generators.Cotangent.map f - Algebra.Generators.Cotangent.map g = f.sub g ∘ₗ P.cotangentComplex

full_name: Algebra.Generators.toKaehler
code: /-- The projection map from the relative cotangent space to the module of differentials. -/
noncomputable
abbrev toKaehler : P.CotangentSpace →ₗ[S] Ω[S⁄R] 
goal: P.CotangentSpace →ₗ[S] Ω[S⁄R]

full_name: Algebra.Generators.toKaehler_cotangentSpaceBasis
code: @[simp]
lemma toKaehler_cotangentSpaceBasis (i) :
    P.toKaehler (P.cotangentSpaceBasis i) = D R S (P.val i) 
goal: P.toKaehler (P.cotangentSpaceBasis i) = (KaehlerDifferential.D R S) (P.val i)

full_name: Algebra.Generators.toKaehler_surjective
code: lemma toKaehler_surjective : Function.Surjective P.toKaehler 
goal: Function.Surjective ⇑P.toKaehler

full_name: Algebra.Generators.exact_cotangentComplex_toKaehler
code: lemma exact_cotangentComplex_toKaehler : Function.Exact P.cotangentComplex P.toKaehler 
goal: Function.Exact ⇑P.cotangentComplex ⇑P.toKaehler