File: Mathlib/CategoryTheory/Functor/Currying.lean

full_name: CategoryTheory.uncurry
code: /-- The uncurrying functor, taking a functor `C ⥤ (D ⥤ E)` and producing a functor `(C × D) ⥤ E`.
-/
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
goal: CategoryTheory.Functor (CategoryTheory.Functor C (CategoryTheory.Functor D E)) (CategoryTheory.Functor (C × D) E)

full_name: CategoryTheory.uncurry_obj_obj
code: /-- The uncurrying functor, taking a functor `C ⥤ (D ⥤ E)` and producing a functor `(C × D) ⥤ E`.
-/
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
goal: (CategoryTheory.uncurry.obj F).obj X = (F.obj X.1).obj X.2

full_name: CategoryTheory.uncurry_obj_map
code: /-- The uncurrying functor, taking a functor `C ⥤ (D ⥤ E)` and producing a functor `(C × D) ⥤ E`.
-/
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
goal: (CategoryTheory.uncurry.obj F).map f = CategoryTheory.CategoryStruct.comp ((F.map f.1).app X.2) ((F.obj Y.1).map f.2)

full_name: CategoryTheory.uncurry_map_app
code: /-- The uncurrying functor, taking a functor `C ⥤ (D ⥤ E)` and producing a functor `(C × D) ⥤ E`.
-/
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
goal: ∀ {X Y : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (T : X ⟶ Y) (X_1 : C × D),
  (CategoryTheory.uncurry.map T).app X_1 = (T.app X_1.1).app X_1.2

full_name: CategoryTheory.curryObj
code: /-- The object level part of the currying functor. (See `curry` for the functorial version.)
-/
def curryObj (F : C × D ⥤ E) : C ⥤ D ⥤ E 
goal: CategoryTheory.Functor C (CategoryTheory.Functor D E)

full_name: CategoryTheory.curry_obj_map_app
code: /-- The currying functor, taking a functor `(C × D) ⥤ E` and producing a functor `C ⥤ (D ⥤ E)`.
-/
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
goal: ∀ {X Y : C} (f : X ⟶ Y) (Y_1 : D),
  ((CategoryTheory.curry.obj F).map f).app Y_1 = F.map (f, CategoryTheory.CategoryStruct.id Y_1)

full_name: CategoryTheory.curry_obj_obj_obj
code: /-- The currying functor, taking a functor `(C × D) ⥤ E` and producing a functor `C ⥤ (D ⥤ E)`.
-/
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
goal: ((CategoryTheory.curry.obj F).obj X).obj Y = F.obj (X, Y)

full_name: CategoryTheory.curry_obj_obj_map
code: /-- The currying functor, taking a functor `(C × D) ⥤ E` and producing a functor `C ⥤ (D ⥤ E)`.
-/
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
goal: ∀ {X_1 Y : D} (g : X_1 ⟶ Y), ((CategoryTheory.curry.obj F).obj X).map g = F.map (CategoryTheory.CategoryStruct.id X, g)

full_name: CategoryTheory.curry_map_app_app
code: /-- The currying functor, taking a functor `(C × D) ⥤ E` and producing a functor `C ⥤ (D ⥤ E)`.
-/
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
goal: ∀ {X Y : CategoryTheory.Functor (C × D) E} (T : X ⟶ Y) (X_1 : C) (Y_1 : D),
  ((CategoryTheory.curry.map T).app X_1).app Y_1 = T.app (X_1, Y_1)

full_name: CategoryTheory.curry
code: /-- The currying functor, taking a functor `(C × D) ⥤ E` and producing a functor `C ⥤ (D ⥤ E)`.
-/
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
goal: CategoryTheory.Functor (CategoryTheory.Functor (C × D) E) (CategoryTheory.Functor C (CategoryTheory.Functor D E))

full_name: CategoryTheory.currying
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: CategoryTheory.Functor C (CategoryTheory.Functor D E) ≌ CategoryTheory.Functor (C × D) E

full_name: CategoryTheory.currying_unitIso_hom_app_app_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ (X_1 : C) (X_2 : D),
  ((CategoryTheory.currying.unitIso.hom.app X).app X_1).app X_2 = CategoryTheory.CategoryStruct.id ((X.obj X_1).obj X_2)

full_name: CategoryTheory.currying_inverse_obj_map_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ {X Y : C} (f : X ⟶ Y) (Y_1 : D),
  ((CategoryTheory.currying.inverse.obj F).map f).app Y_1 = F.map (f, CategoryTheory.CategoryStruct.id Y_1)

full_name: CategoryTheory.currying_unitIso_inv_app_app_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ (X_1 : C) (X_2 : D),
  ((CategoryTheory.currying.unitIso.inv.app X).app X_1).app X_2 = CategoryTheory.CategoryStruct.id ((X.obj X_1).obj X_2)

full_name: CategoryTheory.currying_functor_obj_obj
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: (CategoryTheory.currying.functor.obj F).obj X = (F.obj X.1).obj X.2

full_name: CategoryTheory.currying_counitIso_inv_app_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ (X_1 : C × D),
  (CategoryTheory.currying.counitIso.inv.app X).app X_1 = CategoryTheory.CategoryStruct.id (X.obj (X_1.1, X_1.2))

full_name: CategoryTheory.currying_functor_obj_map
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: (CategoryTheory.currying.functor.obj F).map f =
  CategoryTheory.CategoryStruct.comp ((F.map f.1).app X.2) ((F.obj Y.1).map f.2)

full_name: CategoryTheory.currying_functor_map_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ {X Y : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (T : X ⟶ Y) (X_1 : C × D),
  (CategoryTheory.currying.functor.map T).app X_1 = (T.app X_1.1).app X_1.2

full_name: CategoryTheory.currying_inverse_obj_obj_obj
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ((CategoryTheory.currying.inverse.obj F).obj X).obj Y = F.obj (X, Y)

full_name: CategoryTheory.currying_inverse_obj_obj_map
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ {X_1 Y : D} (g : X_1 ⟶ Y),
  ((CategoryTheory.currying.inverse.obj F).obj X).map g = F.map (CategoryTheory.CategoryStruct.id X, g)

full_name: CategoryTheory.currying_inverse_map_app_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ {X Y : CategoryTheory.Functor (C × D) E} (T : X ⟶ Y) (X_1 : C) (Y_1 : D),
  ((CategoryTheory.currying.inverse.map T).app X_1).app Y_1 = T.app (X_1, Y_1)

full_name: CategoryTheory.currying_counitIso_hom_app_app
code: /-- The equivalence of functor categories given by currying/uncurrying.
-/
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
goal: ∀ (X_1 : C × D),
  (CategoryTheory.currying.counitIso.hom.app X).app X_1 = CategoryTheory.CategoryStruct.id (X.obj (X_1.1, X_1.2))

full_name: CategoryTheory.flipIsoCurrySwapUncurry
code: /-- `F.flip` is isomorphic to uncurrying `F`, swapping the variables, and currying. -/
@[simps!]
def flipIsoCurrySwapUncurry (F : C ⥤ D ⥤ E) : F.flip ≅ curry.obj (Prod.swap _ _ ⋙ uncurry.obj F) 
goal: F.flip ≅ CategoryTheory.curry.obj ((CategoryTheory.Prod.swap D C).comp (CategoryTheory.uncurry.obj F))

full_name: CategoryTheory.flipIsoCurrySwapUncurry_hom_app_app
code: /-- `F.flip` is isomorphic to uncurrying `F`, swapping the variables, and currying. -/
@[simps!]
def flipIsoCurrySwapUncurry (F : C ⥤ D ⥤ E) : F.flip ≅ curry.obj (Prod.swap _ _ ⋙ uncurry.obj F) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.flipIsoCurrySwapUncurry F).hom.app X).app X_1 = CategoryTheory.CategoryStruct.id ((F.obj X_1).obj X)

full_name: CategoryTheory.flipIsoCurrySwapUncurry_inv_app_app
code: /-- `F.flip` is isomorphic to uncurrying `F`, swapping the variables, and currying. -/
@[simps!]
def flipIsoCurrySwapUncurry (F : C ⥤ D ⥤ E) : F.flip ≅ curry.obj (Prod.swap _ _ ⋙ uncurry.obj F) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.flipIsoCurrySwapUncurry F).inv.app X).app X_1 = CategoryTheory.CategoryStruct.id ((F.obj X_1).obj X)

full_name: CategoryTheory.uncurryObjFlip_hom_app
code: /-- The uncurrying of `F.flip` is isomorphic to
swapping the factors followed by the uncurrying of `F`. -/
@[simps!]
def uncurryObjFlip (F : C ⥤ D ⥤ E) : uncurry.obj F.flip ≅ Prod.swap _ _ ⋙ uncurry.obj F 
goal: (CategoryTheory.uncurryObjFlip F).hom.app X = CategoryTheory.CategoryStruct.id ((F.obj X.2).obj X.1)

full_name: CategoryTheory.uncurryObjFlip_inv_app
code: /-- The uncurrying of `F.flip` is isomorphic to
swapping the factors followed by the uncurrying of `F`. -/
@[simps!]
def uncurryObjFlip (F : C ⥤ D ⥤ E) : uncurry.obj F.flip ≅ Prod.swap _ _ ⋙ uncurry.obj F 
goal: (CategoryTheory.uncurryObjFlip F).inv.app X = CategoryTheory.CategoryStruct.id ((F.obj X.2).obj X.1)

full_name: CategoryTheory.uncurryObjFlip
code: /-- The uncurrying of `F.flip` is isomorphic to
swapping the factors followed by the uncurrying of `F`. -/
@[simps!]
def uncurryObjFlip (F : C ⥤ D ⥤ E) : uncurry.obj F.flip ≅ Prod.swap _ _ ⋙ uncurry.obj F 
goal: CategoryTheory.uncurry.obj F.flip ≅ (CategoryTheory.Prod.swap D C).comp (CategoryTheory.uncurry.obj F)

full_name: CategoryTheory.whiskeringRight₂_obj_obj_obj_map
code: /-- A version of `CategoryTheory.whiskeringRight` for bifunctors, obtained by uncurrying,
applying `whiskeringRight` and currying back
-/
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
goal: ∀ (X_1 : CategoryTheory.Functor B C) (Y : CategoryTheory.Functor B D) {X_2 Y_1 : B} (f : X_2 ⟶ Y_1),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).obj X_1).obj Y).map f =
    CategoryTheory.CategoryStruct.comp ((X.map (X_1.map f)).app (Y.obj X_2)) ((X.obj (X_1.obj Y_1)).map (Y.map f))

full_name: CategoryTheory.whiskeringRight₂
code: /-- A version of `CategoryTheory.whiskeringRight` for bifunctors, obtained by uncurrying,
applying `whiskeringRight` and currying back
-/
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
goal: CategoryTheory.Functor (CategoryTheory.Functor C (CategoryTheory.Functor D E))
  (CategoryTheory.Functor (CategoryTheory.Functor B C)
    (CategoryTheory.Functor (CategoryTheory.Functor B D) (CategoryTheory.Functor B E)))

full_name: CategoryTheory.whiskeringRight₂_map_app_app_app
code: /-- A version of `CategoryTheory.whiskeringRight` for bifunctors, obtained by uncurrying,
applying `whiskeringRight` and currying back
-/
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
goal: ∀ {X Y : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (f : X ⟶ Y) (X_1 : CategoryTheory.Functor B C)
  (Y_1 : CategoryTheory.Functor B D) (c : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).map f).app X_1).app Y_1).app c = (f.app (X_1.obj c)).app (Y_1.obj c)

full_name: CategoryTheory.whiskeringRight₂_obj_map_app_app
code: /-- A version of `CategoryTheory.whiskeringRight` for bifunctors, obtained by uncurrying,
applying `whiskeringRight` and currying back
-/
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
goal: ∀ {X_1 Y : CategoryTheory.Functor B C} (f : X_1 ⟶ Y) (Y_1 : CategoryTheory.Functor B D) (X_2 : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).map f).app Y_1).app X_2 = (X.map (f.app X_2)).app (Y_1.obj X_2)

full_name: CategoryTheory.whiskeringRight₂_obj_obj_map_app
code: /-- A version of `CategoryTheory.whiskeringRight` for bifunctors, obtained by uncurrying,
applying `whiskeringRight` and currying back
-/
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
goal: ∀ (X_1 : CategoryTheory.Functor B C) {X_2 Y : CategoryTheory.Functor B D} (g : X_2 ⟶ Y) (X_3 : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).obj X_1).map g).app X_3 = (X.obj (X_1.obj X_3)).map (g.app X_3)

full_name: CategoryTheory.whiskeringRight₂_obj_obj_obj_obj
code: /-- A version of `CategoryTheory.whiskeringRight` for bifunctors, obtained by uncurrying,
applying `whiskeringRight` and currying back
-/
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
goal: ∀ (X_1 : CategoryTheory.Functor B C) (Y : CategoryTheory.Functor B D) (X_2 : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).obj X_1).obj Y).obj X_2 = (X.obj (X_1.obj X_2)).obj (Y.obj X_2)

full_name: CategoryTheory.Functor.uncurry_obj_curry_obj
code: lemma uncurry_obj_curry_obj (F : B × C ⥤ D) : uncurry.obj (curry.obj F) = F 
goal: CategoryTheory.uncurry.obj (CategoryTheory.curry.obj F) = F

full_name: CategoryTheory.Functor.curry_obj_injective
code: lemma curry_obj_injective {F₁ F₂ : C × D ⥤ E} (h : curry.obj F₁ = curry.obj F₂) :
    F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.Functor.curry_obj_uncurry_obj
code: lemma curry_obj_uncurry_obj (F : B ⥤ C ⥤ D) : curry.obj (uncurry.obj F) = F 
goal: CategoryTheory.curry.obj (CategoryTheory.uncurry.obj F) = F

full_name: CategoryTheory.Functor.uncurry_obj_injective
code: lemma uncurry_obj_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : uncurry.obj F₁ = uncurry.obj F₂) :
    F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.Functor.flip_flip
code: lemma flip_flip (F : B ⥤ C ⥤ D) : F.flip.flip = F 
goal: F.flip.flip = F

full_name: CategoryTheory.Functor.flip_injective
code: lemma flip_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : F₁.flip = F₂.flip) :
    F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip
code: lemma uncurry_obj_curry_obj_flip_flip (F₁ : B ⥤ C) (F₂ : D ⥤ E) (G : C × E ⥤ H) :
    uncurry.obj (F₂ ⋙ (F₁ ⋙ curry.obj G).flip).flip = (F₁.prod F₂) ⋙ G 
goal: CategoryTheory.uncurry.obj (F₂.comp (F₁.comp (CategoryTheory.curry.obj G)).flip).flip = (F₁.prod F₂).comp G

full_name: CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip'
code: lemma uncurry_obj_curry_obj_flip_flip' (F₁ : B ⥤ C) (F₂ : D ⥤ E) (G : C × E ⥤ H) :
    uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip) = (F₁.prod F₂) ⋙ G 
goal: CategoryTheory.uncurry.obj (F₁.comp (F₂.comp (CategoryTheory.curry.obj G).flip).flip) = (F₁.prod F₂).comp G