File: Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean

full_name: CategoryTheory.ShortComplex.instPreservesHomologyModuleCatAbForget₂
code: noncomputable instance : (forget₂ (ModuleCat.{v} R) Ab).PreservesHomology 
goal: (CategoryTheory.forget₂ (ModuleCat R) Ab).PreservesHomology

full_name: CategoryTheory.ShortComplex.moduleCatMk_X₁
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
linear maps `f` and `g` and the vanishing of their composition. -/
@[simps]
def moduleCatMk {X₁ X₂ X₃ : Type v} [AddCommGroup X₁] [AddCommGroup X₂] [AddCommGroup X₃]
    [Module R X₁] [Module R X₂] [Module R X₃] (f : X₁ →ₗ[R] X₂) (g : X₂ →ₗ[R] X₃)
    (hfg : g.comp f = 0) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMk f g hfg).X₁ = ModuleCat.of R X₁

full_name: CategoryTheory.ShortComplex.moduleCatMk_g
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
linear maps `f` and `g` and the vanishing of their composition. -/
@[simps]
def moduleCatMk {X₁ X₂ X₃ : Type v} [AddCommGroup X₁] [AddCommGroup X₂] [AddCommGroup X₃]
    [Module R X₁] [Module R X₂] [Module R X₃] (f : X₁ →ₗ[R] X₂) (g : X₂ →ₗ[R] X₃)
    (hfg : g.comp f = 0) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMk f g hfg).g = ModuleCat.ofHom g

full_name: CategoryTheory.ShortComplex.moduleCatMk_f
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
linear maps `f` and `g` and the vanishing of their composition. -/
@[simps]
def moduleCatMk {X₁ X₂ X₃ : Type v} [AddCommGroup X₁] [AddCommGroup X₂] [AddCommGroup X₃]
    [Module R X₁] [Module R X₂] [Module R X₃] (f : X₁ →ₗ[R] X₂) (g : X₂ →ₗ[R] X₃)
    (hfg : g.comp f = 0) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMk f g hfg).f = ModuleCat.ofHom f

full_name: CategoryTheory.ShortComplex.moduleCatMk_X₃
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
linear maps `f` and `g` and the vanishing of their composition. -/
@[simps]
def moduleCatMk {X₁ X₂ X₃ : Type v} [AddCommGroup X₁] [AddCommGroup X₂] [AddCommGroup X₃]
    [Module R X₁] [Module R X₂] [Module R X₃] (f : X₁ →ₗ[R] X₂) (g : X₂ →ₗ[R] X₃)
    (hfg : g.comp f = 0) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMk f g hfg).X₃ = ModuleCat.of R X₃

full_name: CategoryTheory.ShortComplex.moduleCatMk_X₂
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
linear maps `f` and `g` and the vanishing of their composition. -/
@[simps]
def moduleCatMk {X₁ X₂ X₃ : Type v} [AddCommGroup X₁] [AddCommGroup X₂] [AddCommGroup X₃]
    [Module R X₁] [Module R X₂] [Module R X₃] (f : X₁ →ₗ[R] X₂) (g : X₂ →ₗ[R] X₃)
    (hfg : g.comp f = 0) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMk f g hfg).X₂ = ModuleCat.of R X₂

full_name: CategoryTheory.ShortComplex.moduleCatMk
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
linear maps `f` and `g` and the vanishing of their composition. -/
@[simps]
def moduleCatMk {X₁ X₂ X₃ : Type v} [AddCommGroup X₁] [AddCommGroup X₂] [AddCommGroup X₃]
    [Module R X₁] [Module R X₂] [Module R X₃] (f : X₁ →ₗ[R] X₂) (g : X₂ →ₗ[R] X₃)
    (hfg : g.comp f = 0) : ShortComplex (ModuleCat.{v} R) 
goal: CategoryTheory.ShortComplex (ModuleCat R)

full_name: CategoryTheory.ShortComplex.moduleCat_zero_apply
code: @[simp]
lemma moduleCat_zero_apply (x : S.X₁) : S.g (S.f x) = 0 
goal: S.g (S.f x) = 0

full_name: CategoryTheory.ShortComplex.moduleCat_exact_iff
code: lemma moduleCat_exact_iff :
    S.Exact ↔ ∀ (x₂ : S.X₂) (_ : S.g x₂ = 0), ∃ (x₁ : S.X₁), S.f x₁ = x₂ 
goal: S.Exact ↔ ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂

full_name: CategoryTheory.ShortComplex.moduleCat_exact_iff_ker_sub_range
code: lemma moduleCat_exact_iff_ker_sub_range :
    S.Exact ↔ LinearMap.ker S.g ≤ LinearMap.range S.f 
goal: S.Exact ↔ LinearMap.ker S.g ≤ LinearMap.range S.f

full_name: CategoryTheory.ShortComplex.moduleCat_exact_iff_range_eq_ker
code: lemma moduleCat_exact_iff_range_eq_ker :
    S.Exact ↔ LinearMap.range S.f = LinearMap.ker S.g 
goal: S.Exact ↔ LinearMap.range S.f = LinearMap.ker S.g

full_name: CategoryTheory.ShortComplex.Exact.moduleCat_range_eq_ker
code: lemma Exact.moduleCat_range_eq_ker (hS : S.Exact) :
    LinearMap.range S.f = LinearMap.ker S.g 
goal: LinearMap.range S.f = LinearMap.ker S.g

full_name: CategoryTheory.ShortComplex.ShortExact.moduleCat_injective_f
code: lemma ShortExact.moduleCat_injective_f (hS : S.ShortExact) :
    Function.Injective S.f 
goal: Function.Injective ⇑S.f

full_name: CategoryTheory.ShortComplex.ShortExact.moduleCat_surjective_g
code: lemma ShortExact.moduleCat_surjective_g (hS : S.ShortExact) :
    Function.Surjective S.g 
goal: Function.Surjective ⇑S.g

full_name: CategoryTheory.ShortComplex.ShortExact.moduleCat_exact_iff_function_exact
code: lemma ShortExact.moduleCat_exact_iff_function_exact :
    S.Exact ↔ Function.Exact S.f S.g 
goal: S.Exact ↔ Function.Exact ⇑S.f ⇑S.g

full_name: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
morphisms `f` and `g` and the assumption `LinearMap.range f ≤ LinearMap.ker g`. -/
@[simps]
def moduleCatMkOfKerLERange {X₁ X₂ X₃ : ModuleCat.{v} R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
    (hfg : LinearMap.range f ≤ LinearMap.ker g) : ShortComplex (ModuleCat.{v} R) 
goal: CategoryTheory.ShortComplex (ModuleCat R)

full_name: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_X₃
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
morphisms `f` and `g` and the assumption `LinearMap.range f ≤ LinearMap.ker g`. -/
@[simps]
def moduleCatMkOfKerLERange {X₁ X₂ X₃ : ModuleCat.{v} R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
    (hfg : LinearMap.range f ≤ LinearMap.ker g) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMkOfKerLERange f g hfg).X₃ = X₃

full_name: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_f
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
morphisms `f` and `g` and the assumption `LinearMap.range f ≤ LinearMap.ker g`. -/
@[simps]
def moduleCatMkOfKerLERange {X₁ X₂ X₃ : ModuleCat.{v} R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
    (hfg : LinearMap.range f ≤ LinearMap.ker g) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMkOfKerLERange f g hfg).f = f

full_name: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_X₂
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
morphisms `f` and `g` and the assumption `LinearMap.range f ≤ LinearMap.ker g`. -/
@[simps]
def moduleCatMkOfKerLERange {X₁ X₂ X₃ : ModuleCat.{v} R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
    (hfg : LinearMap.range f ≤ LinearMap.ker g) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMkOfKerLERange f g hfg).X₂ = X₂

full_name: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_g
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
morphisms `f` and `g` and the assumption `LinearMap.range f ≤ LinearMap.ker g`. -/
@[simps]
def moduleCatMkOfKerLERange {X₁ X₂ X₃ : ModuleCat.{v} R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
    (hfg : LinearMap.range f ≤ LinearMap.ker g) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMkOfKerLERange f g hfg).g = g

full_name: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_X₁
code: /-- Constructor for short complexes in `ModuleCat.{v} R` taking as inputs
morphisms `f` and `g` and the assumption `LinearMap.range f ≤ LinearMap.ker g`. -/
@[simps]
def moduleCatMkOfKerLERange {X₁ X₂ X₃ : ModuleCat.{v} R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
    (hfg : LinearMap.range f ≤ LinearMap.ker g) : ShortComplex (ModuleCat.{v} R) 
goal: (CategoryTheory.ShortComplex.moduleCatMkOfKerLERange f g hfg).X₁ = X₁

full_name: CategoryTheory.ShortComplex.Exact.moduleCat_of_range_eq_ker
code: lemma Exact.moduleCat_of_range_eq_ker {X₁ X₂ X₃ : ModuleCat.{v} R}
    (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃) (hfg : LinearMap.range f = LinearMap.ker g) :
    (moduleCatMkOfKerLERange f g (by rw [hfg])).Exact 
goal: (CategoryTheory.ShortComplex.moduleCatMkOfKerLERange f g ⋯).Exact

full_name: CategoryTheory.ShortComplex.moduleCatToCycles
code: /-- The canonical linear map `S.X₁ →ₗ[R] LinearMap.ker S.g` induced by `S.f`. -/
@[simps]
def moduleCatToCycles : S.X₁ →ₗ[R] LinearMap.ker S.g 
goal: ↑S.X₁ →ₗ[R] ↥(LinearMap.ker S.g)

full_name: CategoryTheory.ShortComplex.moduleCatToCycles_apply_coe
code: /-- The canonical linear map `S.X₁ →ₗ[R] LinearMap.ker S.g` induced by `S.f`. -/
@[simps]
def moduleCatToCycles : S.X₁ →ₗ[R] LinearMap.ker S.g 
goal: ↑(S.moduleCatToCycles x) = S.f x

full_name: CategoryTheory.ShortComplex.moduleCatHomology
code: /-- The homology of `S`, defined as the quotient of the kernel of `S.g` by
the image of `S.moduleCatToCycles` -/
abbrev moduleCatHomology 
goal: ModuleCat R

full_name: CategoryTheory.ShortComplex.moduleCatHomologyπ
code: /-- The canonical map `ModuleCat.of R (LinearMap.ker S.g) ⟶ S.moduleCatHomology`. -/
abbrev moduleCatHomologyπ : ModuleCat.of R (LinearMap.ker S.g) ⟶ S.moduleCatHomology 
goal: ModuleCat.of R ↥(LinearMap.ker S.g) ⟶ S.moduleCatHomology

full_name: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_i
code: /-- The explicit left homology data of a short complex of modules that is
given by a kernel and a quotient given by the `LinearMap` API. -/
@[simps]
def moduleCatLeftHomologyData : S.LeftHomologyData 
goal: S.moduleCatLeftHomologyData.i = (LinearMap.ker S.g).subtype

full_name: CategoryTheory.ShortComplex.moduleCatLeftHomologyData
code: /-- The explicit left homology data of a short complex of modules that is
given by a kernel and a quotient given by the `LinearMap` API. -/
@[simps]
def moduleCatLeftHomologyData : S.LeftHomologyData 
goal: S.LeftHomologyData

full_name: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_H
code: /-- The explicit left homology data of a short complex of modules that is
given by a kernel and a quotient given by the `LinearMap` API. -/
@[simps]
def moduleCatLeftHomologyData : S.LeftHomologyData 
goal: S.moduleCatLeftHomologyData.H = S.moduleCatHomology

full_name: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_π
code: /-- The explicit left homology data of a short complex of modules that is
given by a kernel and a quotient given by the `LinearMap` API. -/
@[simps]
def moduleCatLeftHomologyData : S.LeftHomologyData 
goal: S.moduleCatLeftHomologyData.π = S.moduleCatHomologyπ

full_name: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_K
code: /-- The explicit left homology data of a short complex of modules that is
given by a kernel and a quotient given by the `LinearMap` API. -/
@[simps]
def moduleCatLeftHomologyData : S.LeftHomologyData 
goal: S.moduleCatLeftHomologyData.K = ModuleCat.of R ↥(LinearMap.ker S.g)

full_name: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_f'
code: @[simp]
lemma moduleCatLeftHomologyData_f' :
    S.moduleCatLeftHomologyData.f' = S.moduleCatToCycles 
goal: S.moduleCatLeftHomologyData.f' = S.moduleCatToCycles

full_name: CategoryTheory.ShortComplex.instEpiModuleCatModuleCatHomologyπ
code: instance : Epi S.moduleCatHomologyπ 
goal: CategoryTheory.Epi S.moduleCatHomologyπ

full_name: CategoryTheory.ShortComplex.moduleCatCyclesIso
code: /-- Given a short complex `S` of modules, this is the isomorphism between
the abstract `S.cycles` of the homology API and the more concrete description as
`LinearMap.ker S.g`. -/
noncomputable def moduleCatCyclesIso : S.cycles ≅ ModuleCat.of R (LinearMap.ker S.g) 
goal: S.cycles ≅ ModuleCat.of R ↥(LinearMap.ker S.g)

full_name: CategoryTheory.ShortComplex.moduleCatCyclesIso_hom_subtype
code: @[reassoc (attr := simp, elementwise)]
lemma moduleCatCyclesIso_hom_subtype :
    S.moduleCatCyclesIso.hom ≫ (LinearMap.ker S.g).subtype = S.iCycles 
goal: CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.hom (LinearMap.ker S.g).subtype = S.iCycles

full_name: CategoryTheory.ShortComplex.moduleCatCyclesIso_inv_iCycles
code: @[reassoc (attr := simp, elementwise)]
lemma moduleCatCyclesIso_inv_iCycles :
    S.moduleCatCyclesIso.inv ≫ S.iCycles = (LinearMap.ker S.g).subtype 
goal: CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.inv S.iCycles = (LinearMap.ker S.g).subtype

full_name: CategoryTheory.ShortComplex.toCycles_moduleCatCyclesIso_hom
code: @[reassoc (attr := simp, elementwise)]
lemma toCycles_moduleCatCyclesIso_hom :
    S.toCycles ≫ S.moduleCatCyclesIso.hom = S.moduleCatToCycles 
goal: CategoryTheory.CategoryStruct.comp S.toCycles S.moduleCatCyclesIso.hom = S.moduleCatToCycles

full_name: CategoryTheory.ShortComplex.moduleCatHomologyIso
code: /-- Given a short complex `S` of modules, this is the isomorphism between
the abstract `S.homology` of the homology API and the more explicit
quotient of `LinearMap.ker S.g` by the image of
`S.moduleCatToCycles : S.X₁ →ₗ[R] LinearMap.ker S.g`. -/
noncomputable def moduleCatHomologyIso :
    S.homology ≅ S.moduleCatHomology 
goal: S.homology ≅ S.moduleCatHomology

full_name: CategoryTheory.ShortComplex.π_moduleCatCyclesIso_hom
code: @[reassoc (attr := simp, elementwise)]
lemma π_moduleCatCyclesIso_hom :
    S.homologyπ ≫ S.moduleCatHomologyIso.hom =
      S.moduleCatCyclesIso.hom ≫ S.moduleCatHomologyπ 
goal: CategoryTheory.CategoryStruct.comp S.homologyπ S.moduleCatHomologyIso.hom =
  CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.hom S.moduleCatHomologyπ

full_name: CategoryTheory.ShortComplex.moduleCatCyclesIso_inv_π
code: @[reassoc (attr := simp, elementwise)]
lemma moduleCatCyclesIso_inv_π :
    S.moduleCatCyclesIso.inv ≫ S.homologyπ =
       S.moduleCatHomologyπ ≫ S.moduleCatHomologyIso.inv 
goal: CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.inv S.homologyπ =
  CategoryTheory.CategoryStruct.comp S.moduleCatHomologyπ S.moduleCatHomologyIso.inv

full_name: CategoryTheory.ShortComplex.exact_iff_surjective_moduleCatToCycles
code: lemma exact_iff_surjective_moduleCatToCycles :
    S.Exact ↔ Function.Surjective S.moduleCatToCycles 
goal: S.Exact ↔ Function.Surjective ⇑S.moduleCatToCycles