ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/NatTrans.lean

full_name: CategoryTheory.NatTrans.app
code: /-- `NatTrans F G` represents a natural transformation between functors `F` and `G`.

The field `app` provides the components of the natural transformation.

Naturality is expressed by `α.naturality`.
-/
@[ext]
structure NatTrans (F G : C ⥤ D) : Type max u₁ v₂ where
  /-- The component of a natural transformation. -/
  app : ∀ X : C, F.obj X ⟶ G.obj X
  /-- The naturality square for a given morphism. -/
  naturality : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f := by aesop_cat
goal: F.obj X ⟶ G.obj X

full_name: CategoryTheory.NatTrans.naturality
code: /-- `NatTrans F G` represents a natural transformation between functors `F` and `G`.

The field `app` provides the components of the natural transformation.

Naturality is expressed by `α.naturality`.
-/
@[ext]
structure NatTrans (F G : C ⥤ D) : Type max u₁ v₂ where
  /-- The component of a natural transformation. -/
  app : ∀ X : C, F.obj X ⟶ G.obj X
  /-- The naturality square for a given morphism. -/
  naturality : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.app X) (G.map f)

full_name: CategoryTheory.NatTrans
code: /-- `NatTrans F G` represents a natural transformation between functors `F` and `G`.

The field `app` provides the components of the natural transformation.

Naturality is expressed by `α.naturality`.
-/
@[ext]
structure NatTrans (F G : C ⥤ D) : Type max u₁ v₂ where
  /-- The component of a natural transformation. -/
  app : ∀ X : C, F.obj X ⟶ G.obj X
  /-- The naturality square for a given morphism. -/
  naturality : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f := by aesop_cat
goal: Type (max u₁ v₂)

full_name: CategoryTheory.congr_app
code: theorem congr_app {F G : C ⥤ D} {α β : NatTrans F G} (h : α = β) (X : C) : α.app X = β.app X 
goal: α.app X = β.app X

full_name: CategoryTheory.NatTrans.id
code: /-- `NatTrans.id F` is the identity natural transformation on a functor `F`. -/
protected def id (F : C ⥤ D) : NatTrans F F 
goal: CategoryTheory.NatTrans F F

full_name: CategoryTheory.NatTrans.id_app'
code: @[simp]
theorem id_app' (F : C ⥤ D) (X : C) : (NatTrans.id F).app X = 𝟙 (F.obj X) 
goal: (CategoryTheory.NatTrans.id F).app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.NatTrans.instInhabited
code: instance (F : C ⥤ D) : Inhabited (NatTrans F F) 
goal: Inhabited (CategoryTheory.NatTrans F F)

full_name: CategoryTheory.NatTrans.vcomp
code: /-- `vcomp α β` is the vertical compositions of natural transformations. -/
def vcomp (α : NatTrans F G) (β : NatTrans G H) : NatTrans F H 
goal: CategoryTheory.NatTrans F H

full_name: CategoryTheory.NatTrans.vcomp_app
code: theorem vcomp_app (α : NatTrans F G) (β : NatTrans G H) (X : C) :
    (vcomp α β).app X = α.app X ≫ β.app X 
goal: (α.vcomp β).app X = CategoryTheory.CategoryStruct.comp (α.app X) (β.app X)
File: Mathlib/CategoryTheory/GradedObject/Associator.lean

full_name: CategoryTheory.GradedObject.mapBifunctorAssociator
code: /-- Associator isomorphism for the action of bifunctors on graded objects. -/
noncomputable def mapBifunctorAssociator :
    mapBifunctorMapObj G ρ₁₂.q (mapBifunctorMapObj F₁₂ ρ₁₂.p X₁ X₂) X₃ ≅
      mapBifunctorMapObj F ρ₂₃.q X₁ (mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃) 
goal: CategoryTheory.GradedObject.mapBifunctorMapObj G ρ₁₂.q (CategoryTheory.GradedObject.mapBifunctorMapObj F₁₂ ρ₁₂.p X₁ X₂)
    X₃ ≅
  CategoryTheory.GradedObject.mapBifunctorMapObj F ρ₂₃.q X₁
    (CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)

full_name: CategoryTheory.GradedObject.ι_mapBifunctorAssociator_hom
code: @[reassoc (attr := simp, nolint unusedHavesSuffices)]
lemma ι_mapBifunctorAssociator_hom (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : r (i₁, i₂, i₃) = j) :
    ιMapBifunctor₁₂BifunctorMapObj F₁₂ G ρ₁₂ X₁ X₂ X₃ i₁ i₂ i₃ j h ≫
      (mapBifunctorAssociator associator ρ₁₂ ρ₂₃ X₁ X₂ X₃).hom j =
        ((associator.hom.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
          ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.GradedObject.ιMapBifunctor₁₂BifunctorMapObj F₁₂ G ρ₁₂ X₁ X₂ X₃ i₁ i₂ i₃ j h)
    ((CategoryTheory.GradedObject.mapBifunctorAssociator associator ρ₁₂ ρ₂₃ X₁ X₂ X₃).hom j) =
  CategoryTheory.CategoryStruct.comp (((associator.hom.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃))
    (CategoryTheory.GradedObject.ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h)

full_name: CategoryTheory.GradedObject.ι_mapBifunctorAssociator_inv
code: @[reassoc (attr := simp)]
lemma ι_mapBifunctorAssociator_inv (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : r (i₁, i₂, i₃) = j) :
    ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h ≫
      (mapBifunctorAssociator associator ρ₁₂ ρ₂₃ X₁ X₂ X₃).inv j =
    ((associator.inv.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ιMapBifunctor₁₂BifunctorMapObj F₁₂ G ρ₁₂ X₁ X₂ X₃ i₁ i₂ i₃ j h 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.GradedObject.ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h)
    ((CategoryTheory.GradedObject.mapBifunctorAssociator associator ρ₁₂ ρ₂₃ X₁ X₂ X₃).inv j) =
  CategoryTheory.CategoryStruct.comp (((associator.inv.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃))
    (CategoryTheory.GradedObject.ιMapBifunctor₁₂BifunctorMapObj F₁₂ G ρ₁₂ X₁ X₂ X₃ i₁ i₂ i₃ j h)
File: Mathlib/CategoryTheory/Triangulated/Yoneda.lean

full_name: CategoryTheory.Pretriangulated.instIsHomologicalAddCommGrpObjOppositeFunctorPreadditiveCoyoneda
code: instance (A : Cᵒᵖ) : (preadditiveCoyoneda.obj A).IsHomological 
goal: (CategoryTheory.preadditiveCoyoneda.obj A).IsHomological

full_name: CategoryTheory.Pretriangulated.instIsHomologicalOppositeAddCommGrpObjFunctorPreadditiveYoneda
code: instance (B : C) : (preadditiveYoneda.obj B).IsHomological 
goal: (CategoryTheory.preadditiveYoneda.obj B).IsHomological

full_name: CategoryTheory.Pretriangulated.preadditiveYoneda_map_distinguished
code: lemma preadditiveYoneda_map_distinguished
    (T : Triangle C) (hT : T ∈ distTriang C) (B : C) :
    ((shortComplexOfDistTriangle T hT).op.map (preadditiveYoneda.obj B)).Exact 
goal: ((CategoryTheory.Pretriangulated.shortComplexOfDistTriangle T hT).op.map (CategoryTheory.preadditiveYoneda.obj B)).Exact

full_name: CategoryTheory.Pretriangulated.instShiftSequenceAddCommGrpObjOppositeFunctorPreadditiveCoyonedaInt
code: noncomputable instance (A : Cᵒᵖ) : (preadditiveCoyoneda.obj A).ShiftSequence ℤ 
goal: (CategoryTheory.preadditiveCoyoneda.obj A).ShiftSequence ℤ

full_name: CategoryTheory.Pretriangulated.preadditiveCoyoneda_homologySequenceδ_apply
code: lemma preadditiveCoyoneda_homologySequenceδ_apply
    (A : Cᵒᵖ) (T : Triangle C) (n₀ n₁ : ℤ) (h : n₀ + 1 = n₁) (x : A.unop ⟶ T.obj₃⟦n₀⟧) :
    (preadditiveCoyoneda.obj A).homologySequenceδ T n₀ n₁ h x =
      x ≫ T.mor₃⟦n₀⟧' ≫ (shiftFunctorAdd' C 1 n₀ n₁ (by omega)).inv.app _ 
goal: ((CategoryTheory.preadditiveCoyoneda.obj A).homologySequenceδ T n₀ n₁ h) x =
  CategoryTheory.CategoryStruct.comp x
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n₀).map T.mor₃)
      ((CategoryTheory.shiftFunctorAdd' C 1 n₀ n₁ ⋯).inv.app T.obj₁))
File: Mathlib/CategoryTheory/Monoidal/Conv.lean

full_name: CategoryTheory.Conv
code: /--
The morphisms in `C` between the underlying objects of a pair of bimonoids in `C` naturally has a
(set-theoretic) monoid structure. -/
def Conv (M : Comon_ C) (N : Mon_ C) : Type v₁ 
goal: Type v₁

full_name: CategoryTheory.Conv.instOne
code: instance : One (Conv M N) 
goal: One (CategoryTheory.Conv M N)

full_name: CategoryTheory.Conv.one_eq
code: theorem one_eq : (1 : Conv M N) = M.counit ≫ N.one 
goal: 1 = CategoryTheory.CategoryStruct.comp M.counit N.one

full_name: CategoryTheory.Conv.instMul
code: instance : Mul (Conv M N) 
goal: Mul (CategoryTheory.Conv M N)

full_name: CategoryTheory.Conv.mul_eq
code: theorem mul_eq (f g : Conv M N) : f * g = M.comul ≫ f ▷ M.X ≫ N.X ◁ g ≫ N.mul 
goal: f * g =
  CategoryTheory.CategoryStruct.comp M.comul
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f M.X)
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft N.X g) N.mul))

full_name: CategoryTheory.Conv.instMonoid
code: instance : Monoid (Conv M N) 
goal: Monoid (CategoryTheory.Conv M N)
File: Mathlib/CategoryTheory/Monoidal/Skeleton.lean

full_name: CategoryTheory.monoidOfSkeletalMonoidal
code: /-- If `C` is monoidal and skeletal, it is a monoid.
See note [reducible non-instances]. -/
abbrev monoidOfSkeletalMonoidal (hC : Skeletal C) : Monoid C 
goal: Monoid C

full_name: CategoryTheory.commMonoidOfSkeletalBraided
code: /-- If `C` is braided and skeletal, it is a commutative monoid. -/
def commMonoidOfSkeletalBraided [BraidedCategory C] (hC : Skeletal C) : CommMonoid C 
goal: CommMonoid C

full_name: CategoryTheory.Skeleton.instMonoidalCategory
code: /-- The skeleton of a monoidal category has a monoidal structure itself, induced by the equivalence.
-/
noncomputable instance instMonoidalCategory : MonoidalCategory (Skeleton C) 
goal: CategoryTheory.MonoidalCategory (CategoryTheory.Skeleton C)

full_name: CategoryTheory.Skeleton.instMonoid
code: /--
The skeleton of a monoidal category can be viewed as a monoid, where the multiplication is given by
the tensor product, and satisfies the monoid axioms since it is a skeleton.
-/
noncomputable instance instMonoid : Monoid (Skeleton C) 
goal: Monoid (CategoryTheory.Skeleton C)

full_name: CategoryTheory.Skeleton.instBraidedCategory
code: /-- The skeleton of a braided monoidal category has a braided monoidal structure itself, induced by
the equivalence. -/
noncomputable instance instBraidedCategory [BraidedCategory C] : BraidedCategory (Skeleton C) 
goal: CategoryTheory.BraidedCategory (CategoryTheory.Skeleton C)

full_name: CategoryTheory.Skeleton.instCommMonoid
code: /--
The skeleton of a braided monoidal category can be viewed as a commutative monoid, where the
multiplication is given by the tensor product, and satisfies the monoid axioms since it is a
skeleton.
-/
noncomputable instance instCommMonoid [BraidedCategory C] : CommMonoid (Skeleton C) 
goal: CommMonoid (CategoryTheory.Skeleton C)
File: Mathlib/CategoryTheory/Linear/FunctorCategory.lean

full_name: CategoryTheory.functorCategoryLinear
code: instance functorCategoryLinear : Linear R (C ⥤ D) 
goal: CategoryTheory.Linear R (CategoryTheory.Functor C D)

full_name: CategoryTheory.NatTrans.appLinearMap
code: /-- Application of a natural transformation at a fixed object,
as group homomorphism -/
@[simps]
def appLinearMap (X : C) : (F ⟶ G) →ₗ[R] F.obj X ⟶ G.obj X 
goal: (F ⟶ G) →ₗ[R] F.obj X ⟶ G.obj X

full_name: CategoryTheory.NatTrans.appLinearMap_apply
code: /-- Application of a natural transformation at a fixed object,
as group homomorphism -/
@[simps]
def appLinearMap (X : C) : (F ⟶ G) →ₗ[R] F.obj X ⟶ G.obj X 
goal: (CategoryTheory.NatTrans.appLinearMap X) α = α.app X

full_name: CategoryTheory.NatTrans.app_smul
code: @[simp]
theorem app_smul (X : C) (r : R) (α : F ⟶ G) : (r • α).app X = r • α.app X 
goal: (r • α).app X = r • α.app X
File: Mathlib/CategoryTheory/Monoidal/Tor.lean

full_name: CategoryTheory.Tor_obj
code: /-- We define `Tor C n : C ⥤ C ⥤ C` by left-deriving in the second factor of `(X, Y) ↦ X ⊗ Y`. -/
@[simps]
def Tor (n : ℕ) : C ⥤ C ⥤ C 
goal: (CategoryTheory.Tor C n).obj X = ((CategoryTheory.MonoidalCategory.tensoringLeft C).obj X).leftDerived n

full_name: CategoryTheory.Tor
code: /-- We define `Tor C n : C ⥤ C ⥤ C` by left-deriving in the second factor of `(X, Y) ↦ X ⊗ Y`. -/
@[simps]
def Tor (n : ℕ) : C ⥤ C ⥤ C 
goal: CategoryTheory.Functor C (CategoryTheory.Functor C C)

full_name: CategoryTheory.Tor_map
code: /-- We define `Tor C n : C ⥤ C ⥤ C` by left-deriving in the second factor of `(X, Y) ↦ X ⊗ Y`. -/
@[simps]
def Tor (n : ℕ) : C ⥤ C ⥤ C 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.Tor C n).map f =
    CategoryTheory.NatTrans.leftDerived ((CategoryTheory.MonoidalCategory.tensoringLeft C).map f) n

full_name: CategoryTheory.Tor'_obj_obj
code: /-- An alternative definition of `Tor`, where we left-derive in the first factor instead. -/
@[simps! obj_obj]
def Tor' (n : ℕ) : C ⥤ C ⥤ C 
goal: ((CategoryTheory.Tor' C n).obj k).obj j =
  (((CategoryTheory.MonoidalCategory.tensoringRight C).obj j).leftDerived n).obj k

full_name: CategoryTheory.Tor'
code: /-- An alternative definition of `Tor`, where we left-derive in the first factor instead. -/
@[simps! obj_obj]
def Tor' (n : ℕ) : C ⥤ C ⥤ C 
goal: CategoryTheory.Functor C (CategoryTheory.Functor C C)

full_name: CategoryTheory.Tor'_map_app'
code: @[simp]
lemma Tor'_map_app' (n : ℕ) {X Y : C} (f : X ⟶ Y) (Z : C) :
    ((Tor' C n).map f).app Z = (Functor.leftDerived ((tensoringRight C).obj Z) n).map f 
goal: ((CategoryTheory.Tor' C n).map f).app Z =
  (((CategoryTheory.MonoidalCategory.tensoringRight C).obj Z).leftDerived n).map f

full_name: CategoryTheory.Tor'_obj_map
code: @[simp]
lemma Tor'_obj_map (n : ℕ) {X Y : C} (Z : C) (f : X ⟶ Y) :
    ((Tor' C n).obj Z).map f = (NatTrans.leftDerived ((tensoringRight C).map f) n).app Z 
goal: ((CategoryTheory.Tor' C n).obj Z).map f =
  (CategoryTheory.NatTrans.leftDerived ((CategoryTheory.MonoidalCategory.tensoringRight C).map f) n).app Z

full_name: CategoryTheory.isZero_Tor_succ_of_projective
code: /-- The higher `Tor` groups for `X` and `Y` are zero if `Y` is projective. -/
lemma isZero_Tor_succ_of_projective (X Y : C) [Projective Y] (n : ℕ) :
    IsZero (((Tor C (n + 1)).obj X).obj Y) 
goal: CategoryTheory.Limits.IsZero (((CategoryTheory.Tor C (n + 1)).obj X).obj Y)

full_name: CategoryTheory.isZero_Tor'_succ_of_projective
code: /-- The higher `Tor'` groups for `X` and `Y` are zero if `X` is projective. -/
lemma isZero_Tor'_succ_of_projective (X Y : C) [Projective X] (n : ℕ) :
    IsZero (((Tor' C (n + 1)).obj X).obj Y) 
goal: CategoryTheory.Limits.IsZero (((CategoryTheory.Tor' C (n + 1)).obj X).obj Y)
File: Mathlib/CategoryTheory/Monoidal/Types/Symmetric.lean

full_name: CategoryTheory.typesSymmetric
code: instance typesSymmetric : SymmetricCategory.{u} (Type u) 
goal: CategoryTheory.SymmetricCategory (Type u)

full_name: CategoryTheory.braiding_hom_apply
code: @[simp]
theorem braiding_hom_apply {X Y : Type u} {x : X} {y : Y} :
    ((β_ X Y).hom : X ⊗ Y → Y ⊗ X) (x, y) = (y, x) 
goal: (β_ X Y).hom (x, y) = (y, x)

full_name: CategoryTheory.braiding_inv_apply
code: @[simp]
theorem braiding_inv_apply {X Y : Type u} {x : X} {y : Y} :
    ((β_ X Y).inv : Y ⊗ X → X ⊗ Y) (y, x) = (x, y) 
goal: (β_ X Y).inv (y, x) = (x, y)
File: Mathlib/CategoryTheory/Monoidal/Types/Coyoneda.lean

full_name: CategoryTheory.coyonedaTensorUnit
code: /-- `(𝟙_ C ⟶ -)` is a lax monoidal functor to `Type`. -/
def coyonedaTensorUnit (C : Type u) [Category.{v} C] [MonoidalCategory C] :
    LaxMonoidalFunctor C (Type v) 
goal: CategoryTheory.LaxMonoidalFunctor C (Type v)
File: Mathlib/CategoryTheory/Monoidal/Braided/Opposite.lean

full_name: instBraidedCategoryOpposite
code: instance : BraidedCategory Cᵒᵖ 
goal: CategoryTheory.BraidedCategory Cᵒᵖ

full_name: CategoryTheory.BraidedCategory.unop_tensor_μ
code: @[simp] lemma unop_tensor_μ {C : Type*} [Category C] [MonoidalCategory C]
    [BraidedCategory C] (X Y W Z : Cᵒᵖ) :
    (tensor_μ Cᵒᵖ (X, W) (Y, Z)).unop = tensor_μ C (X.unop, Y.unop) (W.unop, Z.unop) 
goal: (CategoryTheory.tensor_μ Cᵒᵖ (X, W) (Y, Z)).unop =
  CategoryTheory.tensor_μ C (Opposite.unop X, Opposite.unop Y) (Opposite.unop W, Opposite.unop Z)

full_name: CategoryTheory.BraidedCategory.op_tensor_μ
code: @[simp] lemma op_tensor_μ {C : Type*} [Category C] [MonoidalCategory C]
    [BraidedCategory C] (X Y W Z : C) :
    (tensor_μ C (X, W) (Y, Z)).op = tensor_μ Cᵒᵖ (op X, op Y) (op W, op Z) 
goal: (CategoryTheory.tensor_μ C (X, W) (Y, Z)).op =
  CategoryTheory.tensor_μ Cᵒᵖ (Opposite.op X, Opposite.op Y) (Opposite.op W, Opposite.op Z)
File: Mathlib/CategoryTheory/Monoidal/Linear.lean

full_name: CategoryTheory.MonoidalLinear.smul_whiskerRight
code: /-- A category is `MonoidalLinear R` if tensoring is `R`-linear in both factors.
-/
class MonoidalLinear [MonoidalPreadditive C] : Prop where
  whiskerLeft_smul : ∀ (X : C) {Y Z : C} (r : R) (f : Y ⟶ Z) , X ◁ (r • f) = r • (X ◁ f) := by
    aesop_cat
  smul_whiskerRight : ∀ (r : R) {Y Z : C} (f : Y ⟶ Z) (X : C), (r • f) ▷ X = r • (f ▷ X) := by
    aesop_cat
goal: CategoryTheory.MonoidalCategory.whiskerRight (r • f) X = r • CategoryTheory.MonoidalCategory.whiskerRight f X

full_name: CategoryTheory.MonoidalLinear.whiskerLeft_smul
code: /-- A category is `MonoidalLinear R` if tensoring is `R`-linear in both factors.
-/
class MonoidalLinear [MonoidalPreadditive C] : Prop where
  whiskerLeft_smul : ∀ (X : C) {Y Z : C} (r : R) (f : Y ⟶ Z) , X ◁ (r • f) = r • (X ◁ f) := by
    aesop_cat
  smul_whiskerRight : ∀ (r : R) {Y Z : C} (f : Y ⟶ Z) (X : C), (r • f) ▷ X = r • (f ▷ X) := by
    aesop_cat
goal: CategoryTheory.MonoidalCategory.whiskerLeft X (r • f) = r • CategoryTheory.MonoidalCategory.whiskerLeft X f

full_name: CategoryTheory.MonoidalLinear
code: /-- A category is `MonoidalLinear R` if tensoring is `R`-linear in both factors.
-/
class MonoidalLinear [MonoidalPreadditive C] : Prop where
  whiskerLeft_smul : ∀ (X : C) {Y Z : C} (r : R) (f : Y ⟶ Z) , X ◁ (r • f) = r • (X ◁ f) := by
    aesop_cat
  smul_whiskerRight : ∀ (r : R) {Y Z : C} (f : Y ⟶ Z) (X : C), (r • f) ▷ X = r • (f ▷ X) := by
    aesop_cat
goal: Prop

full_name: CategoryTheory.tensorLeft_linear
code: instance tensorLeft_linear (X : C) : (tensorLeft X).Linear R 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.MonoidalCategory.tensorLeft X)

full_name: CategoryTheory.tensorRight_linear
code: instance tensorRight_linear (X : C) : (tensorRight X).Linear R 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.MonoidalCategory.tensorRight X)

full_name: CategoryTheory.tensoringLeft_linear
code: instance tensoringLeft_linear (X : C) : ((tensoringLeft C).obj X).Linear R 
goal: CategoryTheory.Functor.Linear R ((CategoryTheory.MonoidalCategory.tensoringLeft C).obj X)

full_name: CategoryTheory.tensoringRight_linear
code: instance tensoringRight_linear (X : C) : ((tensoringRight C).obj X).Linear R 
goal: CategoryTheory.Functor.Linear R ((CategoryTheory.MonoidalCategory.tensoringRight C).obj X)

full_name: CategoryTheory.monoidalLinearOfFaithful
code: /-- A faithful linear monoidal functor to a linear monoidal category
ensures that the domain is linear monoidal. -/
theorem monoidalLinearOfFaithful {D : Type*} [Category D] [Preadditive D] [Linear R D]
    [MonoidalCategory D] [MonoidalPreadditive D] (F : MonoidalFunctor D C) [F.Faithful]
    [F.toFunctor.Additive] [F.toFunctor.Linear R] : MonoidalLinear R D 
goal: CategoryTheory.MonoidalLinear R D
File: Mathlib/CategoryTheory/Monoidal/Cartesian/Comon_.lean

full_name: cartesianComon_
code: /--
The functor from a cartesian monoidal category to comonoids in that category,
equipping every object with the diagonal map as a comultiplication.
-/
def cartesianComon_ : C ⥤ Comon_ C 
goal: C ⥤ Comon_ C

full_name: counit_eq_from
code: @[simp] theorem counit_eq_from (A : Comon_ C) : A.counit = terminal.from A.X 
goal: A.counit = CategoryTheory.Limits.terminal.from A.X

full_name: comul_eq_diag
code: @[simp] theorem comul_eq_diag (A : Comon_ C) : A.comul = diag A.X 
goal: A.comul = CategoryTheory.Limits.diag A.X

full_name: iso_cartesianComon__inv_hom
code: /--
Every comonoid object in a cartesian monoidal category is equivalent to
the canonical comonoid structure on the underlying object.
-/
@[simps] def iso_cartesianComon_ (A : Comon_ C) : A ≅ (cartesianComon_ C).obj A.X 
goal: (iso_cartesianComon_ A).inv.hom = 𝟙 ((cartesianComon_ C).obj A.X).X

full_name: iso_cartesianComon__hom_hom
code: /--
Every comonoid object in a cartesian monoidal category is equivalent to
the canonical comonoid structure on the underlying object.
-/
@[simps] def iso_cartesianComon_ (A : Comon_ C) : A ≅ (cartesianComon_ C).obj A.X 
goal: (iso_cartesianComon_ A).hom.hom = 𝟙 A.X

full_name: iso_cartesianComon_
code: /--
Every comonoid object in a cartesian monoidal category is equivalent to
the canonical comonoid structure on the underlying object.
-/
@[simps] def iso_cartesianComon_ (A : Comon_ C) : A ≅ (cartesianComon_ C).obj A.X 
goal: A ≅ (cartesianComon_ C).obj A.X

full_name: comonEquiv_functor
code: /--
The category of comonoid objects in a cartesian monoidal category is equivalent
to the category itself, via the forgetful functor.
-/
@[simps] def comonEquiv : Comon_ C ≌ C 
goal: comonEquiv.functor = Comon_.forget C

full_name: comonEquiv
code: /--
The category of comonoid objects in a cartesian monoidal category is equivalent
to the category itself, via the forgetful functor.
-/
@[simps] def comonEquiv : Comon_ C ≌ C 
goal: Comon_ C ≌ C

full_name: comonEquiv_inverse
code: /--
The category of comonoid objects in a cartesian monoidal category is equivalent
to the category itself, via the forgetful functor.
-/
@[simps] def comonEquiv : Comon_ C ≌ C 
goal: comonEquiv.inverse = cartesianComon_ C

full_name: comonEquiv_unitIso
code: /--
The category of comonoid objects in a cartesian monoidal category is equivalent
to the category itself, via the forgetful functor.
-/
@[simps] def comonEquiv : Comon_ C ≌ C 
goal: comonEquiv.unitIso = CategoryTheory.NatIso.ofComponents (fun A => iso_cartesianComon_ A) ⋯

full_name: comonEquiv_counitIso
code: /--
The category of comonoid objects in a cartesian monoidal category is equivalent
to the category itself, via the forgetful functor.
-/
@[simps] def comonEquiv : Comon_ C ≌ C 
goal: comonEquiv.counitIso =
  CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl ((cartesianComon_ C ⋙ Comon_.forget C).obj X)) ⋯
File: Mathlib/CategoryTheory/Monoidal/Rigid/OfEquivalence.lean

full_name: CategoryTheory.exactPairingOfFaithful
code: /-- Given candidate data for an exact pairing,
which is sent by a faithful monoidal functor to an exact pairing,
the equations holds automatically. -/
def exactPairingOfFaithful [F.Faithful] {X Y : C} (eval : Y ⊗ X ⟶ 𝟙_ C)
    (coeval : 𝟙_ C ⟶ X ⊗ Y) [ExactPairing (F.obj X) (F.obj Y)]
    (map_eval : F.map eval = inv (F.μ _ _) ≫ ε_ _ _ ≫ F.ε)
    (map_coeval : F.map coeval = inv F.ε ≫ η_ _ _ ≫ F.μ _ _) : ExactPairing X Y 
goal: CategoryTheory.ExactPairing X Y

full_name: CategoryTheory.exactPairingOfFullyFaithful
code: /-- Given a pair of objects which are sent by a fully faithful functor to a pair of objects
with an exact pairing, we get an exact pairing.
-/
def exactPairingOfFullyFaithful [F.Full] [F.Faithful] (X Y : C)
    [ExactPairing (F.obj X) (F.obj Y)] : ExactPairing X Y 
goal: CategoryTheory.ExactPairing X Y

full_name: CategoryTheory.hasLeftDualOfEquivalence
code: /-- Pull back a left dual along an equivalence. -/
def hasLeftDualOfEquivalence (X : C) [HasLeftDual (F.obj X)] :
    HasLeftDual X 
goal: CategoryTheory.HasLeftDual X

full_name: CategoryTheory.hasRightDualOfEquivalence
code: /-- Pull back a right dual along an equivalence. -/
def hasRightDualOfEquivalence (X : C) [HasRightDual (F.obj X)] :
    HasRightDual X 
goal: CategoryTheory.HasRightDual X

full_name: CategoryTheory.leftRigidCategoryOfEquivalence
code: /-- Pull back a left rigid structure along an equivalence. -/
def leftRigidCategoryOfEquivalence [LeftRigidCategory D] :
    LeftRigidCategory C 
goal: CategoryTheory.LeftRigidCategory C

full_name: CategoryTheory.rightRigidCategoryOfEquivalence
code: /-- Pull back a right rigid structure along an equivalence. -/
def rightRigidCategoryOfEquivalence [RightRigidCategory D] :
    RightRigidCategory C 
goal: CategoryTheory.RightRigidCategory C

full_name: CategoryTheory.rigidCategoryOfEquivalence
code: /-- Pull back a rigid structure along an equivalence. -/
def rigidCategoryOfEquivalence [RigidCategory D] : RigidCategory C 
goal: CategoryTheory.RigidCategory C