Documentation

Mathlib.CategoryTheory.Products.Basic

Cartesian products of categories #

We define the category instance on C × D when C and D are categories.

We define:

We further define evaluation : C ⥤ (C ⥤ D) ⥤ D and evaluationUncurried : C × (C ⥤ D) ⥤ D, and products of functors and natural transformations, written F.prod G and α.prod β.

prod C D gives the cartesian product of two categories.

Stacks Tag 001K

Equations
    @[simp]
    theorem CategoryTheory.prod_comp_fst (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {X✝ Y✝ Z✝ : C × D} (f : (X✝.1 Y✝.1) × (X✝.2 Y✝.2)) (g : (Y✝.1 Z✝.1) × (Y✝.2 Z✝.2)) :
    @[simp]
    theorem CategoryTheory.prod_comp_snd (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {X✝ Y✝ Z✝ : C × D} (f : (X✝.1 Y✝.1) × (X✝.2 Y✝.2)) (g : (Y✝.1 Z✝.1) × (Y✝.2 Z✝.2)) :
    @[simp]
    theorem CategoryTheory.prod_Hom (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (X Y : C × D) :
    (X Y) = ((X.1 Y.1) × (X.2 Y.2))
    theorem CategoryTheory.prod.hom_ext (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {X Y : C × D} {f g : X Y} (h₁ : f.1 = g.1) (h₂ : f.2 = g.2) :
    f = g
    theorem CategoryTheory.prod.hom_ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {X Y : C × D} {f g : X Y} :
    f = g f.1 = g.1 f.2 = g.2
    @[simp]

    Two rfl lemmas that cannot be generated by @[simps].

    @[simp]
    theorem CategoryTheory.prod_comp (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {P Q R : C} {S T U : D} (f : (P, S) (Q, T)) (g : (Q, T) (R, U)) :
    @[reducible, inline]
    abbrev CategoryTheory.Prod.mkHom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {X₁ X₂ : C} {Y₁ Y₂ : D} (f : X₁ X₂) (g : Y₁ Y₂) :
    (X₁, Y₁) (X₂, Y₂)

    Construct a morphism in a product category by giving its constituent components. This constructor should be preferred over Prod.mk, because lean infers better the source and target of the resulting morphism.

    Equations
      Instances For

        Construct a morphism in a product category by giving its constituent components. This constructor should be preferred over Prod.mk, because lean infers better the source and target of the resulting morphism.

        Equations
          Instances For
            theorem CategoryTheory.isIso_prod_iff (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {P Q : C} {S T : D} {f : (P, S) (Q, T)} :
            IsIso f IsIso f.1 IsIso f.2
            def CategoryTheory.prod.etaIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (X : C × D) :
            (X.1, X.2) X

            The isomorphism between (X.1, X.2) and X.

            Equations
              Instances For
                def CategoryTheory.Iso.prod {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {P Q : C} {S T : D} (f : P Q) (g : S T) :
                (P, S) (Q, T)

                Construct an isomorphism in C × D out of two isomorphisms in C and D.

                Equations
                  Instances For
                    @[simp]
                    theorem CategoryTheory.Iso.prod_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {P Q : C} {S T : D} (f : P Q) (g : S T) :
                    (f.prod g).hom = (f.hom, g.hom)
                    @[simp]
                    theorem CategoryTheory.Iso.prod_inv {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {P Q : C} {S T : D} (f : P Q) (g : S T) :
                    (f.prod g).inv = (f.inv, g.inv)

                    Category.uniformProd C D is an additional instance specialised so both factors have the same universe levels. This helps typeclass resolution.

                    Equations
                      def CategoryTheory.Prod.sectL (C : Type u₁) [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (Z : D) :
                      Functor C (C × D)

                      sectL C Z is the functor C ⥤ C × D given by X ↦ (X, Z).

                      Equations
                        Instances For
                          @[simp]
                          theorem CategoryTheory.Prod.sectL_obj (C : Type u₁) [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (Z : D) (X : C) :
                          (sectL C Z).obj X = (X, Z)
                          @[simp]
                          theorem CategoryTheory.Prod.sectL_map (C : Type u₁) [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (Z : D) {X✝ Y✝ : C} (f : X✝ Y✝) :
                          def CategoryTheory.Prod.sectR {C : Type u₁} [Category.{v₁, u₁} C] (Z : C) (D : Type u₂) [Category.{v₂, u₂} D] :
                          Functor D (C × D)

                          sectR Z D is the functor D ⥤ C × D given by Y ↦ (Z, Y) .

                          Equations
                            Instances For
                              @[simp]
                              theorem CategoryTheory.Prod.sectR_obj {C : Type u₁} [Category.{v₁, u₁} C] (Z : C) (D : Type u₂) [Category.{v₂, u₂} D] (X : D) :
                              (sectR Z D).obj X = (Z, X)
                              @[simp]
                              theorem CategoryTheory.Prod.sectR_map {C : Type u₁} [Category.{v₁, u₁} C] (Z : C) (D : Type u₂) [Category.{v₂, u₂} D] {X✝ Y✝ : D} (f : X✝ Y✝) :

                              fst is the functor (X, Y) ↦ X.

                              Equations
                                Instances For
                                  @[simp]
                                  theorem CategoryTheory.Prod.fst_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {X✝ Y✝ : C × D} (f : X✝ Y✝) :
                                  (fst C D).map f = f.1
                                  @[simp]
                                  theorem CategoryTheory.Prod.fst_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (X : C × D) :
                                  (fst C D).obj X = X.1

                                  snd is the functor (X, Y) ↦ Y.

                                  Equations
                                    Instances For
                                      @[simp]
                                      theorem CategoryTheory.Prod.snd_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {X✝ Y✝ : C × D} (f : X✝ Y✝) :
                                      (snd C D).map f = f.2
                                      @[simp]
                                      theorem CategoryTheory.Prod.snd_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (X : C × D) :
                                      (snd C D).obj X = X.2

                                      The functor swapping the factors of a cartesian product of categories, C × D ⥤ D × C.

                                      Equations
                                        Instances For
                                          @[simp]
                                          theorem CategoryTheory.Prod.swap_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {X✝ Y✝ : C × D} (f : X✝ Y✝) :
                                          (swap C D).map f = (f.2, f.1)
                                          @[simp]
                                          theorem CategoryTheory.Prod.swap_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (X : C × D) :
                                          (swap C D).obj X = (X.2, X.1)

                                          Swapping the factors of a cartesian product of categories twice is naturally isomorphic to the identity functor.

                                          Equations
                                            Instances For

                                              The equivalence, given by swapping factors, between C × D and D × C.

                                              Equations
                                                Instances For
                                                  theorem CategoryTheory.Prod.fac {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {x y : C × D} (f : x y) :

                                                  Any morphism in a product factors as a morphsim whose left component is an identity followed by a morphism whose right component is an identity.

                                                  theorem CategoryTheory.Prod.fac' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {x y : C × D} (f : x y) :

                                                  Any morphism in a product factors as a morphsim whose right component is an identity followed by a morphism whose left component is an identity.

                                                  The "evaluation at X" functor, such that (evaluation.obj X).obj F = F.obj X, which is functorial in both X and F.

                                                  Equations
                                                    Instances For
                                                      @[simp]
                                                      theorem CategoryTheory.evaluation_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (X : C) (F : Functor C D) :
                                                      ((evaluation C D).obj X).obj F = F.obj X
                                                      @[simp]
                                                      theorem CategoryTheory.evaluation_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {x✝ x✝¹ : C} (f : x✝ x✝¹) (F : Functor C D) :
                                                      ((evaluation C D).map f).app F = F.map f
                                                      @[simp]
                                                      theorem CategoryTheory.evaluation_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (X : C) {X✝ Y✝ : Functor C D} (α : X✝ Y✝) :
                                                      ((evaluation C D).obj X).map α = α.app X

                                                      The "evaluation of F at X" functor, as a functor C × (C ⥤ D) ⥤ D.

                                                      Equations
                                                        Instances For
                                                          @[simp]
                                                          theorem CategoryTheory.evaluationUncurried_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] {x y : C × Functor C D} (f : x y) :
                                                          (evaluationUncurried C D).map f = CategoryStruct.comp (x.2.map f.1) (f.2.app y.1)

                                                          The constant functor followed by the evaluation functor is just the identity.

                                                          Equations
                                                            Instances For
                                                              def CategoryTheory.Functor.prod {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (F : Functor A B) (G : Functor C D) :
                                                              Functor (A × C) (B × D)

                                                              The cartesian product of two functors.

                                                              Equations
                                                                Instances For
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.prod_map {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (F : Functor A B) (G : Functor C D) {X✝ Y✝ : A × C} (f : X✝ Y✝) :
                                                                  (F.prod G).map f = (F.map f.1, G.map f.2)
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.prod_obj {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (F : Functor A B) (G : Functor C D) (X : A × C) :
                                                                  (F.prod G).obj X = (F.obj X.1, G.obj X.2)
                                                                  def CategoryTheory.Functor.prod' {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A B) (G : Functor A C) :
                                                                  Functor A (B × C)

                                                                  Similar to prod, but both functors start from the same category A

                                                                  Equations
                                                                    Instances For
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.prod'_obj {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A B) (G : Functor A C) (a : A) :
                                                                      (F.prod' G).obj a = (F.obj a, G.obj a)
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.prod'_map {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A B) (G : Functor A C) {X✝ Y✝ : A} (f : X✝ Y✝) :
                                                                      (F.prod' G).map f = (F.map f, G.map f)
                                                                      def CategoryTheory.Functor.prod'CompFst {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A B) (G : Functor A C) :
                                                                      (F.prod' G).comp (Prod.fst B C) F

                                                                      The product F.prod' G followed by projection on the first component is isomorphic to F

                                                                      Equations
                                                                        Instances For
                                                                          @[simp]
                                                                          @[simp]
                                                                          def CategoryTheory.Functor.prod'CompSnd {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A B) (G : Functor A C) :
                                                                          (F.prod' G).comp (Prod.snd B C) G

                                                                          The product F.prod' G followed by projection on the second component is isomorphic to G

                                                                          Equations
                                                                            Instances For
                                                                              @[simp]
                                                                              @[simp]

                                                                              The diagonal functor.

                                                                              Equations
                                                                                Instances For
                                                                                  @[simp]
                                                                                  theorem CategoryTheory.Functor.diag_map (C : Type u₃) [Category.{v₃, u₃} C] {X✝ Y✝ : C} (f : X✝ Y✝) :
                                                                                  (diag C).map f = (f, f)
                                                                                  @[simp]
                                                                                  theorem CategoryTheory.Functor.diag_obj (C : Type u₃) [Category.{v₃, u₃} C] (a : C) :
                                                                                  (diag C).obj a = (a, a)
                                                                                  def CategoryTheory.NatTrans.prod {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {F G : Functor A B} {H I : Functor C D} (α : F G) (β : H I) :
                                                                                  F.prod H G.prod I

                                                                                  The cartesian product of two natural transformations.

                                                                                  Equations
                                                                                    Instances For
                                                                                      @[simp]
                                                                                      theorem CategoryTheory.NatTrans.prod_app_snd {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {F G : Functor A B} {H I : Functor C D} (α : F G) (β : H I) (X : A × C) :
                                                                                      ((prod α β).app X).2 = β.app X.2
                                                                                      @[simp]
                                                                                      theorem CategoryTheory.NatTrans.prod_app_fst {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {F G : Functor A B} {H I : Functor C D} (α : F G) (β : H I) (X : A × C) :
                                                                                      ((prod α β).app X).1 = α.app X.1
                                                                                      def CategoryTheory.NatTrans.prod' {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {F G : Functor A B} {H K : Functor A C} (α : F G) (β : H K) :
                                                                                      F.prod' H G.prod' K

                                                                                      The cartesian product of two natural transformations where both functors have the same source.

                                                                                      Equations
                                                                                        Instances For
                                                                                          @[simp]
                                                                                          theorem CategoryTheory.NatTrans.prod'_app_fst {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {F G : Functor A B} {H K : Functor A C} (α : F G) (β : H K) (X : A) :
                                                                                          ((prod' α β).app X).1 = α.app X
                                                                                          @[simp]
                                                                                          theorem CategoryTheory.NatTrans.prod'_app_snd {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {F G : Functor A B} {H K : Functor A C} (α : F G) (β : H K) (X : A) :
                                                                                          ((prod' α β).app X).2 = β.app X

                                                                                          The cartesian product functor between functor categories

                                                                                          Equations
                                                                                            Instances For
                                                                                              @[simp]
                                                                                              theorem CategoryTheory.prodFunctor_map {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {X✝ Y✝ : Functor A B × Functor C D} (nm : X✝ Y✝) :
                                                                                              @[simp]
                                                                                              theorem CategoryTheory.prodFunctor_obj {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (FG : Functor A B × Functor C D) :
                                                                                              prodFunctor.obj FG = FG.1.prod FG.2
                                                                                              def CategoryTheory.NatIso.prod {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {F F' : Functor A B} {G G' : Functor C D} (e₁ : F F') (e₂ : G G') :
                                                                                              F.prod G F'.prod G'

                                                                                              The cartesian product of two natural isomorphisms.

                                                                                              Equations
                                                                                                Instances For
                                                                                                  @[simp]
                                                                                                  theorem CategoryTheory.NatIso.prod_hom {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {F F' : Functor A B} {G G' : Functor C D} (e₁ : F F') (e₂ : G G') :
                                                                                                  (prod e₁ e₂).hom = NatTrans.prod e₁.hom e₂.hom
                                                                                                  @[simp]
                                                                                                  theorem CategoryTheory.NatIso.prod_inv {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {F F' : Functor A B} {G G' : Functor C D} (e₁ : F F') (e₂ : G G') :
                                                                                                  (prod e₁ e₂).inv = NatTrans.prod e₁.inv e₂.inv
                                                                                                  def CategoryTheory.Equivalence.prod {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (E₁ : A B) (E₂ : C D) :
                                                                                                  A × C B × D

                                                                                                  The cartesian product of two equivalences of categories.

                                                                                                  Equations
                                                                                                    Instances For
                                                                                                      @[simp]
                                                                                                      theorem CategoryTheory.Equivalence.prod_functor {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (E₁ : A B) (E₂ : C D) :
                                                                                                      (E₁.prod E₂).functor = E₁.functor.prod E₂.functor
                                                                                                      @[simp]
                                                                                                      theorem CategoryTheory.Equivalence.prod_counitIso {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (E₁ : A B) (E₂ : C D) :
                                                                                                      @[simp]
                                                                                                      theorem CategoryTheory.Equivalence.prod_inverse {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (E₁ : A B) (E₂ : C D) :
                                                                                                      (E₁.prod E₂).inverse = E₁.inverse.prod E₂.inverse
                                                                                                      @[simp]
                                                                                                      theorem CategoryTheory.Equivalence.prod_unitIso {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] (E₁ : A B) (E₂ : C D) :
                                                                                                      (E₁.prod E₂).unitIso = NatIso.prod E₁.unitIso E₂.unitIso
                                                                                                      def CategoryTheory.flipCompEvaluation {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A (Functor B C)) (a : A) :
                                                                                                      F.flip.comp ((evaluation A C).obj a) F.obj a

                                                                                                      F.flip composed with evaluation is the same as evaluating F.

                                                                                                      Equations
                                                                                                        Instances For
                                                                                                          @[simp]
                                                                                                          @[simp]
                                                                                                          theorem CategoryTheory.flip_comp_evaluation {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A (Functor B C)) (a : A) :
                                                                                                          F.flip.comp ((evaluation A C).obj a) = F.obj a
                                                                                                          def CategoryTheory.compEvaluation {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A (Functor B C)) (b : B) :
                                                                                                          F.comp ((evaluation B C).obj b) F.flip.obj b

                                                                                                          F composed with evaluation is the same as evaluating F.flip.

                                                                                                          Equations
                                                                                                            Instances For
                                                                                                              @[simp]
                                                                                                              theorem CategoryTheory.compEvaluation_inv_app {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A (Functor B C)) (b : B) (X : A) :
                                                                                                              @[simp]
                                                                                                              theorem CategoryTheory.compEvaluation_hom_app {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A (Functor B C)) (b : B) (X : A) :
                                                                                                              theorem CategoryTheory.comp_evaluation {A : Type u₁} [Category.{v₁, u₁} A] {B : Type u₂} [Category.{v₂, u₂} B] {C : Type u₃} [Category.{v₃, u₃} C] (F : Functor A (Functor B C)) (b : B) :
                                                                                                              F.comp ((evaluation B C).obj b) = F.flip.obj b

                                                                                                              Whiskering by F and then evaluating at a is the same as evaluating at F.obj a.

                                                                                                              Equations
                                                                                                                Instances For
                                                                                                                  @[simp]

                                                                                                                  Whiskering by F and then evaluating at a is the same as evaluating at F.obj a.

                                                                                                                  Whiskering by F and then evaluating at a is the same as evaluating at F and then applying F.

                                                                                                                  Equations
                                                                                                                    Instances For
                                                                                                                      @[simp]

                                                                                                                      Whiskering by F and then evaluating at a is the same as evaluating at F and then applying F.

                                                                                                                      The forward direction for functorProdFunctorEquiv

                                                                                                                      Equations
                                                                                                                        Instances For

                                                                                                                          The backward direction for functorProdFunctorEquiv

                                                                                                                          Equations
                                                                                                                            Instances For

                                                                                                                              The equivalence of categories between (A ⥤ B) × (A ⥤ C) and A ⥤ (B × C)

                                                                                                                              Equations
                                                                                                                                Instances For

                                                                                                                                  The equivalence between the opposite of a product and the product of the opposites.

                                                                                                                                  Equations
                                                                                                                                    Instances For
                                                                                                                                      @[simp]
                                                                                                                                      theorem CategoryTheory.prodOpEquiv_functor_map (C : Type u₃) [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {X✝ Y✝ : (C × D)ᵒᵖ} (f : X✝ Y✝) :
                                                                                                                                      @[simp]
                                                                                                                                      theorem CategoryTheory.prodOpEquiv_inverse_map (C : Type u₃) [Category.{v₃, u₃} C] {D : Type u₄} [Category.{v₄, u₄} D] {X✝ Y✝ : Cᵒᵖ × Dᵒᵖ} (x✝ : X✝ Y✝) :