File: Mathlib/CategoryTheory/Preadditive/Opposite.lean

full_name: CategoryTheory.instPreadditiveOpposite
code: instance : Preadditive Cᵒᵖ 
goal: CategoryTheory.Preadditive Cᵒᵖ

full_name: CategoryTheory.moduleEndLeft
code: instance moduleEndLeft {X : Cᵒᵖ} {Y : C} : Module (End X) (unop X ⟶ Y) 
goal: Module (CategoryTheory.End X) (Opposite.unop X ⟶ Y)

full_name: CategoryTheory.unop_add
code: @[simp]
theorem unop_add {X Y : Cᵒᵖ} (f g : X ⟶ Y) : (f + g).unop = f.unop + g.unop 
goal: (f + g).unop = f.unop + g.unop

full_name: CategoryTheory.unop_zsmul
code: @[simp]
theorem unop_zsmul {X Y : Cᵒᵖ} (k : ℤ) (f : X ⟶ Y) : (k • f).unop = k • f.unop 
goal: (k • f).unop = k • f.unop

full_name: CategoryTheory.unop_neg
code: @[simp]
theorem unop_neg {X Y : Cᵒᵖ} (f : X ⟶ Y) : (-f).unop = -f.unop 
goal: (-f).unop = -f.unop

full_name: CategoryTheory.op_add
code: @[simp]
theorem op_add {X Y : C} (f g : X ⟶ Y) : (f + g).op = f.op + g.op 
goal: (f + g).op = f.op + g.op

full_name: CategoryTheory.op_zsmul
code: @[simp]
theorem op_zsmul {X Y : C} (k : ℤ) (f : X ⟶ Y) : (k • f).op = k • f.op 
goal: (k • f).op = k • f.op

full_name: CategoryTheory.op_neg
code: @[simp]
theorem op_neg {X Y : C} (f : X ⟶ Y) : (-f).op = -f.op 
goal: (-f).op = -f.op

full_name: CategoryTheory.unopHom_apply
code: /-- `unop` induces morphisms of monoids on hom groups of a preadditive category -/
@[simps!]
def unopHom (X Y : Cᵒᵖ) : (X ⟶ Y) →+ (Opposite.unop Y ⟶ Opposite.unop X) 
goal: (CategoryTheory.unopHom X Y) f = f.unop

full_name: CategoryTheory.unopHom
code: /-- `unop` induces morphisms of monoids on hom groups of a preadditive category -/
@[simps!]
def unopHom (X Y : Cᵒᵖ) : (X ⟶ Y) →+ (Opposite.unop Y ⟶ Opposite.unop X) 
goal: (X ⟶ Y) →+ (Opposite.unop Y ⟶ Opposite.unop X)

full_name: CategoryTheory.unop_sum
code: @[simp]
theorem unop_sum (X Y : Cᵒᵖ) {ι : Type*} (s : Finset ι) (f : ι → (X ⟶ Y)) :
    (s.sum f).unop = s.sum fun i => (f i).unop 
goal: (s.sum f).unop = ∑ i ∈ s, (f i).unop

full_name: CategoryTheory.opHom
code: /-- `op` induces morphisms of monoids on hom groups of a preadditive category -/
@[simps!]
def opHom (X Y : C) : (X ⟶ Y) →+ (Opposite.op Y ⟶ Opposite.op X) 
goal: (X ⟶ Y) →+ (Opposite.op Y ⟶ Opposite.op X)

full_name: CategoryTheory.opHom_apply
code: /-- `op` induces morphisms of monoids on hom groups of a preadditive category -/
@[simps!]
def opHom (X Y : C) : (X ⟶ Y) →+ (Opposite.op Y ⟶ Opposite.op X) 
goal: (CategoryTheory.opHom X Y) f = f.op

full_name: CategoryTheory.op_sum
code: @[simp]
theorem op_sum (X Y : C) {ι : Type*} (s : Finset ι) (f : ι → (X ⟶ Y)) :
    (s.sum f).op = s.sum fun i => (f i).op 
goal: (s.sum f).op = ∑ i ∈ s, (f i).op

full_name: CategoryTheory.Functor.op_additive
code: instance Functor.op_additive (F : C ⥤ D) [F.Additive] : F.op.Additive 
goal: F.op.Additive

full_name: CategoryTheory.Functor.rightOp_additive
code: instance Functor.rightOp_additive (F : Cᵒᵖ ⥤ D) [F.Additive] : F.rightOp.Additive 
goal: F.rightOp.Additive

full_name: CategoryTheory.Functor.leftOp_additive
code: instance Functor.leftOp_additive (F : C ⥤ Dᵒᵖ) [F.Additive] : F.leftOp.Additive 
goal: F.leftOp.Additive

full_name: CategoryTheory.Functor.unop_additive
code: instance Functor.unop_additive (F : Cᵒᵖ ⥤ Dᵒᵖ) [F.Additive] : F.unop.Additive 
goal: F.unop.Additive