File: Mathlib/Algebra/Homology/Opposite.lean

full_name: imageToKernel_op
code: theorem imageToKernel_op {X Y Z : V} (f : X ⟶ Y) (g : Y ⟶ Z) (w : f ≫ g = 0) :
    imageToKernel g.op f.op (by rw [← op_comp, w, op_zero]) =
      (imageSubobjectIso _ ≪≫ (imageOpOp _).symm).hom ≫
        (cokernel.desc f (factorThruImage g)
              (by rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp])).op ≫
          (kernelSubobjectIso _ ≪≫ kernelOpOp _).inv 
goal: imageToKernel g.op f.op ⋯ =
  (CategoryTheory.Limits.imageSubobjectIso g.op ≪≫ (CategoryTheory.imageOpOp g).symm).hom ≫
    (CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.factorThruImage g) ⋯).op ≫
      (CategoryTheory.Limits.kernelSubobjectIso f.op ≪≫ CategoryTheory.kernelOpOp f).inv

full_name: imageToKernel_unop
code: theorem imageToKernel_unop {X Y Z : Vᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) (w : f ≫ g = 0) :
    imageToKernel g.unop f.unop (by rw [← unop_comp, w, unop_zero]) =
      (imageSubobjectIso _ ≪≫ (imageUnopUnop _).symm).hom ≫
        (cokernel.desc f (factorThruImage g)
              (by rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp])).unop ≫
          (kernelSubobjectIso _ ≪≫ kernelUnopUnop _).inv 
goal: imageToKernel g.unop f.unop ⋯ =
  (CategoryTheory.Limits.imageSubobjectIso g.unop ≪≫ (CategoryTheory.imageUnopUnop g).symm).hom ≫
    (CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.factorThruImage g) ⋯).unop ≫
      (CategoryTheory.Limits.kernelSubobjectIso f.unop ≪≫ CategoryTheory.kernelUnopUnop f).inv

full_name: HomologicalComplex.op
code: /-- Sends a complex `X` with objects in `V` to the corresponding complex with objects in `Vᵒᵖ`. -/
@[simps]
protected def op (X : HomologicalComplex V c) : HomologicalComplex Vᵒᵖ c.symm 
goal: HomologicalComplex Vᵒᵖ c.symm

full_name: HomologicalComplex.op_X
code: /-- Sends a complex `X` with objects in `V` to the corresponding complex with objects in `Vᵒᵖ`. -/
@[simps]
protected def op (X : HomologicalComplex V c) : HomologicalComplex Vᵒᵖ c.symm 
goal: X.op.X i = Opposite.op (X.X i)

full_name: HomologicalComplex.op_d
code: /-- Sends a complex `X` with objects in `V` to the corresponding complex with objects in `Vᵒᵖ`. -/
@[simps]
protected def op (X : HomologicalComplex V c) : HomologicalComplex Vᵒᵖ c.symm 
goal: X.op.d i j = (X.d j i).op

full_name: HomologicalComplex.opSymm_X
code: /-- Sends a complex `X` with objects in `V` to the corresponding complex with objects in `Vᵒᵖ`. -/
@[simps]
protected def opSymm (X : HomologicalComplex V c.symm) : HomologicalComplex Vᵒᵖ c 
goal: X.opSymm.X i = Opposite.op (X.X i)

full_name: HomologicalComplex.opSymm_d
code: /-- Sends a complex `X` with objects in `V` to the corresponding complex with objects in `Vᵒᵖ`. -/
@[simps]
protected def opSymm (X : HomologicalComplex V c.symm) : HomologicalComplex Vᵒᵖ c 
goal: X.opSymm.d i j = (X.d j i).op

full_name: HomologicalComplex.opSymm
code: /-- Sends a complex `X` with objects in `V` to the corresponding complex with objects in `Vᵒᵖ`. -/
@[simps]
protected def opSymm (X : HomologicalComplex V c.symm) : HomologicalComplex Vᵒᵖ c 
goal: HomologicalComplex Vᵒᵖ c

full_name: HomologicalComplex.unop_d
code: /-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unop (X : HomologicalComplex Vᵒᵖ c) : HomologicalComplex V c.symm 
goal: X.unop.d i j = (X.d j i).unop

full_name: HomologicalComplex.unop
code: /-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unop (X : HomologicalComplex Vᵒᵖ c) : HomologicalComplex V c.symm 
goal: HomologicalComplex V c.symm

full_name: HomologicalComplex.unop_X
code: /-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unop (X : HomologicalComplex Vᵒᵖ c) : HomologicalComplex V c.symm 
goal: X.unop.X i = Opposite.unop (X.X i)

full_name: HomologicalComplex.unopSymm_d
code: /-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unopSymm (X : HomologicalComplex Vᵒᵖ c.symm) : HomologicalComplex V c 
goal: X.unopSymm.d i j = (X.d j i).unop

full_name: HomologicalComplex.unopSymm
code: /-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unopSymm (X : HomologicalComplex Vᵒᵖ c.symm) : HomologicalComplex V c 
goal: HomologicalComplex V c

full_name: HomologicalComplex.unopSymm_X
code: /-- Sends a complex `X` with objects in `Vᵒᵖ` to the corresponding complex with objects in `V`. -/
@[simps]
protected def unopSymm (X : HomologicalComplex Vᵒᵖ c.symm) : HomologicalComplex V c 
goal: X.unopSymm.X i = Opposite.unop (X.X i)

full_name: HomologicalComplex.opFunctor_map_f
code: /-- Auxiliary definition for `opEquivalence`. -/
@[simps]
def opFunctor : (HomologicalComplex V c)ᵒᵖ ⥤ HomologicalComplex Vᵒᵖ c.symm 
goal: ∀ {X Y : (HomologicalComplex V c)ᵒᵖ} (f : X ⟶ Y) (i : ι),
  ((HomologicalComplex.opFunctor V c).map f).f i = (f.unop.f i).op

full_name: HomologicalComplex.opFunctor
code: /-- Auxiliary definition for `opEquivalence`. -/
@[simps]
def opFunctor : (HomologicalComplex V c)ᵒᵖ ⥤ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex V c)ᵒᵖ ⥤ HomologicalComplex Vᵒᵖ c.symm

full_name: HomologicalComplex.opFunctor_obj
code: /-- Auxiliary definition for `opEquivalence`. -/
@[simps]
def opFunctor : (HomologicalComplex V c)ᵒᵖ ⥤ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex.opFunctor V c).obj X = (Opposite.unop X).op

full_name: HomologicalComplex.opInverse_map
code: /-- Auxiliary definition for `opEquivalence`. -/
@[simps]
def opInverse : HomologicalComplex Vᵒᵖ c.symm ⥤ (HomologicalComplex V c)ᵒᵖ 
goal: ∀ {X Y : HomologicalComplex Vᵒᵖ c.symm} (f : X ⟶ Y),
  (HomologicalComplex.opInverse V c).map f = Quiver.Hom.op { f := fun i => (f.f i).unop, comm' := ⋯ }

full_name: HomologicalComplex.opInverse_obj
code: /-- Auxiliary definition for `opEquivalence`. -/
@[simps]
def opInverse : HomologicalComplex Vᵒᵖ c.symm ⥤ (HomologicalComplex V c)ᵒᵖ 
goal: (HomologicalComplex.opInverse V c).obj X = Opposite.op X.unopSymm

full_name: HomologicalComplex.opInverse
code: /-- Auxiliary definition for `opEquivalence`. -/
@[simps]
def opInverse : HomologicalComplex Vᵒᵖ c.symm ⥤ (HomologicalComplex V c)ᵒᵖ 
goal: HomologicalComplex Vᵒᵖ c.symm ⥤ (HomologicalComplex V c)ᵒᵖ

full_name: HomologicalComplex.opUnitIso
code: /-- Auxiliary definition for `opEquivalence`. -/
def opUnitIso : 𝟭 (HomologicalComplex V c)ᵒᵖ ≅ opFunctor V c ⋙ opInverse V c 
goal: 𝟭 (HomologicalComplex V c)ᵒᵖ ≅ HomologicalComplex.opFunctor V c ⋙ HomologicalComplex.opInverse V c

full_name: HomologicalComplex.opCounitIso
code: /-- Auxiliary definition for `opEquivalence`. -/
def opCounitIso : opInverse V c ⋙ opFunctor V c ≅ 𝟭 (HomologicalComplex Vᵒᵖ c.symm) 
goal: HomologicalComplex.opInverse V c ⋙ HomologicalComplex.opFunctor V c ≅ 𝟭 (HomologicalComplex Vᵒᵖ c.symm)

full_name: HomologicalComplex.opEquivalence_functor
code: /-- Given a category of complexes with objects in `V`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `Vᵒᵖ`. -/
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex.opEquivalence V c).functor = HomologicalComplex.opFunctor V c

full_name: HomologicalComplex.opEquivalence_unitIso
code: /-- Given a category of complexes with objects in `V`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `Vᵒᵖ`. -/
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex.opEquivalence V c).unitIso = HomologicalComplex.opUnitIso V c

full_name: HomologicalComplex.opEquivalence
code: /-- Given a category of complexes with objects in `V`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `Vᵒᵖ`. -/
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm

full_name: HomologicalComplex.opEquivalence_inverse
code: /-- Given a category of complexes with objects in `V`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `Vᵒᵖ`. -/
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex.opEquivalence V c).inverse = HomologicalComplex.opInverse V c

full_name: HomologicalComplex.opEquivalence_counitIso
code: /-- Given a category of complexes with objects in `V`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `Vᵒᵖ`. -/
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
goal: (HomologicalComplex.opEquivalence V c).counitIso = HomologicalComplex.opCounitIso V c

full_name: HomologicalComplex.unopFunctor_obj
code: /-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopFunctor : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ⥤ HomologicalComplex V c.symm 
goal: (HomologicalComplex.unopFunctor V c).obj X = (Opposite.unop X).unop

full_name: HomologicalComplex.unopFunctor
code: /-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopFunctor : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ⥤ HomologicalComplex V c.symm 
goal: (HomologicalComplex Vᵒᵖ c)ᵒᵖ ⥤ HomologicalComplex V c.symm

full_name: HomologicalComplex.unopFunctor_map_f
code: /-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopFunctor : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ⥤ HomologicalComplex V c.symm 
goal: ∀ {X Y : (HomologicalComplex Vᵒᵖ c)ᵒᵖ} (f : X ⟶ Y) (i : ι),
  ((HomologicalComplex.unopFunctor V c).map f).f i = (f.unop.f i).unop

full_name: HomologicalComplex.unopInverse_obj
code: /-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopInverse : HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ 
goal: (HomologicalComplex.unopInverse V c).obj X = Opposite.op X.opSymm

full_name: HomologicalComplex.unopInverse_map
code: /-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopInverse : HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ 
goal: ∀ {X Y : HomologicalComplex V c.symm} (f : X ⟶ Y),
  (HomologicalComplex.unopInverse V c).map f = Quiver.Hom.op { f := fun i => (f.f i).op, comm' := ⋯ }

full_name: HomologicalComplex.unopInverse
code: /-- Auxiliary definition for `unopEquivalence`. -/
@[simps]
def unopInverse : HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ 
goal: HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ

full_name: HomologicalComplex.unopUnitIso
code: /-- Auxiliary definition for `unopEquivalence`. -/
def unopUnitIso : 𝟭 (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≅ unopFunctor V c ⋙ unopInverse V c 
goal: 𝟭 (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≅ HomologicalComplex.unopFunctor V c ⋙ HomologicalComplex.unopInverse V c

full_name: HomologicalComplex.unopCounitIso
code: /-- Auxiliary definition for `unopEquivalence`. -/
def unopCounitIso : unopInverse V c ⋙ unopFunctor V c ≅ 𝟭 (HomologicalComplex V c.symm) 
goal: HomologicalComplex.unopInverse V c ⋙ HomologicalComplex.unopFunctor V c ≅ 𝟭 (HomologicalComplex V c.symm)

full_name: HomologicalComplex.unopEquivalence_functor
code: /-- Given a category of complexes with objects in `Vᵒᵖ`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `V`. -/
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
goal: (HomologicalComplex.unopEquivalence V c).functor = HomologicalComplex.unopFunctor V c

full_name: HomologicalComplex.unopEquivalence_counitIso
code: /-- Given a category of complexes with objects in `Vᵒᵖ`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `V`. -/
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
goal: (HomologicalComplex.unopEquivalence V c).counitIso = HomologicalComplex.unopCounitIso V c

full_name: HomologicalComplex.unopEquivalence
code: /-- Given a category of complexes with objects in `Vᵒᵖ`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `V`. -/
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
goal: (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm

full_name: HomologicalComplex.unopEquivalence_unitIso
code: /-- Given a category of complexes with objects in `Vᵒᵖ`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `V`. -/
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
goal: (HomologicalComplex.unopEquivalence V c).unitIso = HomologicalComplex.unopUnitIso V c

full_name: HomologicalComplex.unopEquivalence_inverse
code: /-- Given a category of complexes with objects in `Vᵒᵖ`, there is a natural equivalence between its
opposite category and a category of complexes with objects in `V`. -/
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
goal: (HomologicalComplex.unopEquivalence V c).inverse = HomologicalComplex.unopInverse V c

full_name: HomologicalComplex.instHasHomologyOppositeOp
code: instance (K : HomologicalComplex V c) (i : ι) [K.HasHomology i] :
    K.op.HasHomology i 
goal: K.op.HasHomology i

full_name: HomologicalComplex.instHasHomologyUnopOfOpposite
code: instance (K : HomologicalComplex Vᵒᵖ c) (i : ι) [K.HasHomology i] :
    K.unop.HasHomology i 
goal: K.unop.HasHomology i

full_name: HomologicalComplex.homologyOp
code: /-- If `K` is a homological complex, then the homology of `K.op` identifies to
the opposite of the homology of `K`. -/
def homologyOp (K : HomologicalComplex V c) (i : ι) [K.HasHomology i] :
    K.op.homology i ≅ op (K.homology i) 
goal: K.op.homology i ≅ Opposite.op (K.homology i)

full_name: HomologicalComplex.homologyUnop
code: /-- If `K` is a homological complex in the opposite category,
then the homology of `K.unop` identifies to the opposite of the homology of `K`. -/
def homologyUnop (K : HomologicalComplex Vᵒᵖ c) (i : ι) [K.HasHomology i] :
    K.unop.homology i ≅ unop (K.homology i) 
goal: K.unop.homology i ≅ Opposite.unop (K.homology i)

full_name: HomologicalComplex.opFunctor_additive
code: instance opFunctor_additive : (@opFunctor ι V _ c _).Additive 
goal: (HomologicalComplex.opFunctor V c).Additive

full_name: HomologicalComplex.unopFunctor_additive
code: instance unopFunctor_additive : (@unopFunctor ι V _ c _).Additive 
goal: (HomologicalComplex.unopFunctor V c).Additive