ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Under.mapComp_eq
theorem mapComp_eq {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    map (f ≫ g) = (map g) ⋙ (map f) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X Y Z : T} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.Under.map (CategoryTheory.CategoryStruct.comp f g) =
  (CategoryTheory.Under.map g).comp (CategoryTheory.Under.map f)
-- CategoryTheory.Under.mapFunctor_map
@[simps] def mapFunctor : Tᵒᵖ  ⥤ Cat 
Arguments: (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T]
Goal: ∀ {X Y : Tᵒᵖ} (f : X ⟶ Y), (CategoryTheory.Under.mapFunctor T).map f = CategoryTheory.Under.map f.unop
-- CategoryTheory.Under.mapFunctor_obj
@[simps] def mapFunctor : Tᵒᵖ  ⥤ Cat 
Arguments: (T : Type u₁) [CategoryTheory.Category.{v₁, u₁} T] (X : Tᵒᵖ)
Goal: (CategoryTheory.Under.mapFunctor T).obj X = CategoryTheory.Cat.of (CategoryTheory.Under (Opposite.unop X))
-- CategoryTheory.Under.mono_of_mono_right
theorem mono_of_mono_right {f g : Under X} (k : f ⟶ g) [hk : Mono k.right] : Mono k 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (k : f ⟶ g) [hk : CategoryTheory.Mono k.right]
Goal: CategoryTheory.Mono k
-- CategoryTheory.Under.epi_of_epi_right
theorem epi_of_epi_right {f g : Under X} (k : f ⟶ g) [hk : Epi k.right] : Epi k 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (k : f ⟶ g) [hk : CategoryTheory.Epi k.right]
Goal: CategoryTheory.Epi k
-- CategoryTheory.Under.post_obj
@[simps]
def post {X : T} (F : T ⥤ D) : Under X ⥤ Under (F.obj X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D) (Y : CategoryTheory.Under X)
Goal: (CategoryTheory.Under.post F).obj Y = CategoryTheory.Under.mk (F.map Y.hom)
-- CategoryTheory.Under.post_map
@[simps]
def post {X : T} (F : T ⥤ D) : Under X ⥤ Under (F.obj X) 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : T} (F : CategoryTheory.Functor T D)
Goal: ∀ {X_1 Y : CategoryTheory.Under X} (f : X_1 ⟶ Y),
  (CategoryTheory.Under.post F).map f = CategoryTheory.Under.homMk (F.map f.right) ⋯
-- CategoryTheory.StructuredArrow.toUnder_obj_left
@[simps!]
def toUnder (X : T) (F : D ⥤ T) : StructuredArrow X F ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T)
Goal: ∀ (X_1 : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))),
  ((CategoryTheory.StructuredArrow.toUnder X F).obj X_1).left = X_1.left
-- CategoryTheory.StructuredArrow.toUnder_map_right
@[simps!]
def toUnder (X : T) (F : D ⥤ T) : StructuredArrow X F ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T)
Goal: ∀ {X_1 Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))}
  (f : X_1 ⟶ Y), ((CategoryTheory.StructuredArrow.toUnder X F).map f).right = F.map f.right
-- CategoryTheory.StructuredArrow.toUnder_obj_right
@[simps!]
def toUnder (X : T) (F : D ⥤ T) : StructuredArrow X F ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T)
Goal: ∀ (X_1 : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))),
  ((CategoryTheory.StructuredArrow.toUnder X F).obj X_1).right = F.obj X_1.right
-- CategoryTheory.StructuredArrow.toUnder_obj_hom
@[simps!]
def toUnder (X : T) (F : D ⥤ T) : StructuredArrow X F ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T)
Goal: ∀ (X_1 : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))),
  ((CategoryTheory.StructuredArrow.toUnder X F).obj X_1).hom = X_1.hom
-- CategoryTheory.StructuredArrow.toUnder_map_left
@[simps!]
def toUnder (X : T) (F : D ⥤ T) : StructuredArrow X F ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (X : T) (F : CategoryTheory.Functor D T)
Goal: ∀ {X_1 Y : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit X) (F.comp (CategoryTheory.Functor.id T))}
  (f : X_1 ⟶ Y), ((CategoryTheory.StructuredArrow.toUnder X F).map f).left = CategoryTheory.CategoryStruct.id X_1.left
-- CategoryTheory.Functor.toOver_map_left
@[simps! obj_left map_left]
def toOver (F : S ⥤ T) (X : T) (f : (Y : S) → F.obj Y ⟶ X)
    (h : ∀ {Y Z : S} (g : Y ⟶ Z), F.map g ≫ f Z = f Y) : S ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y)
Goal: ∀ {X_1 Y : S} (g : X_1 ⟶ Y), ((F.toOver X f h).map g).left = F.map g
-- CategoryTheory.Functor.toOver_obj_left
@[simps! obj_left map_left]
def toOver (F : S ⥤ T) (X : T) (f : (Y : S) → F.obj Y ⟶ X)
    (h : ∀ {Y Z : S} (g : Y ⟶ Z), F.map g ≫ f Z = f Y) : S ⥤ Over X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y) (Y : S)
Goal: ((F.toOver X f h).obj Y).left = F.obj Y
-- CategoryTheory.Functor.toOver_comp_forget
@[simp]
lemma toOver_comp_forget (F : S ⥤ T) (X : T) (f : (Y : S) → F.obj Y ⟶ X)
    (h : ∀ {Y Z : S} (g : Y ⟶ Z), F.map g ≫ f Z = f Y) : F.toOver X f h ⋙ Over.forget _ = F 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → F.obj Y ⟶ X) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map g) (f Z) = f Y)
Goal: (F.toOver X f ⋯).comp (CategoryTheory.Over.forget X) = F
-- CategoryTheory.Functor.toUnder_map_right
@[simps! obj_right map_right]
def toUnder (F : S ⥤ T) (X : T) (f : (Y : S) → X ⟶ F.obj Y)
    (h : ∀ {Y Z : S} (g : Y ⟶ Z), f Y ≫ F.map g = f Z) : S ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z)
Goal: ∀ {X_1 Y : S} (g : X_1 ⟶ Y), ((F.toUnder X f h).map g).right = F.map g
-- CategoryTheory.Functor.toUnder_obj_right
@[simps! obj_right map_right]
def toUnder (F : S ⥤ T) (X : T) (f : (Y : S) → X ⟶ F.obj Y)
    (h : ∀ {Y Z : S} (g : Y ⟶ Z), f Y ≫ F.map g = f Z) : S ⥤ Under X 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z) (Y : S)
Goal: ((F.toUnder X f h).obj Y).right = F.obj Y
-- CategoryTheory.Functor.toUnder_comp_forget
@[simp]
lemma toUnder_comp_forget (F : S ⥤ T) (X : T) (f : (Y : S) → X ⟶ F.obj Y)
    (h : ∀ {Y Z : S} (g : Y ⟶ Z), f Y ≫ F.map g = f Z) : F.toUnder X f h ⋙ Under.forget _ = F 
Arguments: {T : Type u₁} [CategoryTheory.Category.{v₁, u₁} T] {S : Type u₂} [CategoryTheory.Category.{v₂, u₂} S] (F : CategoryTheory.Functor S T) (X : T) (f : (Y : S) → X ⟶ F.obj Y) (h : ∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map g) = f Z)
Goal: (F.toUnder X f ⋯).comp (CategoryTheory.Under.forget X) = F
-- CategoryTheory.mateEquiv_apply
@[simps]
def mateEquiv : (G ⋙ L₂ ⟶ L₁ ⋙ H) ≃ (R₁ ⋙ G ⟶ H ⋙ R₂) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} {F : Type u₄} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Category.{v₄, u₄} F] {G : CategoryTheory.Functor C E} {H : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} {L₂ : CategoryTheory.Functor E F} {R₂ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : G.comp L₂ ⟶ L₁.comp H)
Goal: (CategoryTheory.mateEquiv adj₁ adj₂) α =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft (R₁.comp G) adj₂.unit)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft R₁ α) R₂)
      (CategoryTheory.whiskerRight adj₁.counit (H.comp R₂)))
-- CategoryTheory.mateEquiv_symm_apply
@[simps]
def mateEquiv : (G ⋙ L₂ ⟶ L₁ ⋙ H) ≃ (R₁ ⋙ G ⟶ H ⋙ R₂) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} {F : Type u₄} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Category.{v₄, u₄} F] {G : CategoryTheory.Functor C E} {H : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} {L₂ : CategoryTheory.Functor E F} {R₂ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (β : R₁.comp G ⟶ H.comp R₂)
Goal: (CategoryTheory.mateEquiv adj₁ adj₂).symm β =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight adj₁.unit (G.comp L₂))
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft L₁ β) L₂)
      (CategoryTheory.whiskerLeft (L₁.comp H) adj₂.counit))
-- CategoryTheory.mateEquiv_counit
theorem mateEquiv_counit (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (d : D) :
    L₂.map ((mateEquiv adj₁ adj₂ α).app _) ≫ adj₂.counit.app _ =
      α.app _ ≫ H.map (adj₁.counit.app d) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} {F : Type u₄} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Category.{v₄, u₄} F] {G : CategoryTheory.Functor C E} {H : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} {L₂ : CategoryTheory.Functor E F} {R₂ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : G.comp L₂ ⟶ L₁.comp H) (d : D)
Goal: CategoryTheory.CategoryStruct.comp (L₂.map (((CategoryTheory.mateEquiv adj₁ adj₂) α).app d))
    (adj₂.counit.app (H.obj d)) =
  CategoryTheory.CategoryStruct.comp (α.app (R₁.obj d)) (H.map (adj₁.counit.app d))
-- CategoryTheory.mateEquiv_counit_symm
theorem mateEquiv_counit_symm (α : R₁ ⋙ G ⟶ H ⋙ R₂) (d : D) :
    L₂.map (α.app _) ≫ adj₂.counit.app _ =
      ((mateEquiv adj₁ adj₂).symm α).app _ ≫ H.map (adj₁.counit.app d) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} {F : Type u₄} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Category.{v₄, u₄} F] {G : CategoryTheory.Functor C E} {H : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} {L₂ : CategoryTheory.Functor E F} {R₂ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : R₁.comp G ⟶ H.comp R₂) (d : D)
Goal: CategoryTheory.CategoryStruct.comp (L₂.map (α.app d)) (adj₂.counit.app (H.obj d)) =
  CategoryTheory.CategoryStruct.comp (((CategoryTheory.mateEquiv adj₁ adj₂).symm α).app (R₁.obj d))
    (H.map (adj₁.counit.app d))
-- CategoryTheory.unit_mateEquiv
theorem unit_mateEquiv (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (c : C) :
    G.map (adj₁.unit.app c) ≫ (mateEquiv adj₁ adj₂ α).app _ =
      adj₂.unit.app _ ≫ R₂.map (α.app _) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} {F : Type u₄} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Category.{v₄, u₄} F] {G : CategoryTheory.Functor C E} {H : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} {L₂ : CategoryTheory.Functor E F} {R₂ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : G.comp L₂ ⟶ L₁.comp H) (c : C)
Goal: CategoryTheory.CategoryStruct.comp (G.map (adj₁.unit.app c)) (((CategoryTheory.mateEquiv adj₁ adj₂) α).app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app (G.obj ((CategoryTheory.Functor.id C).obj c)))
    (R₂.map (α.app ((CategoryTheory.Functor.id C).obj c)))
-- CategoryTheory.unit_mateEquiv_symm
theorem unit_mateEquiv_symm (α : R₁ ⋙ G ⟶ H ⋙ R₂) (c : C) :
    G.map (adj₁.unit.app c) ≫ α.app _ =
      adj₂.unit.app _ ≫ R₂.map (((mateEquiv adj₁ adj₂).symm α).app _) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} {F : Type u₄} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] [CategoryTheory.Category.{v₄, u₄} F] {G : CategoryTheory.Functor C E} {H : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} {L₂ : CategoryTheory.Functor E F} {R₂ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : R₁.comp G ⟶ H.comp R₂) (c : C)
Goal: CategoryTheory.CategoryStruct.comp (G.map (adj₁.unit.app c)) (α.app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app (G.obj ((CategoryTheory.Functor.id C).obj c)))
    (R₂.map (((CategoryTheory.mateEquiv adj₁ adj₂).symm α).app ((CategoryTheory.Functor.id C).obj c)))
-- CategoryTheory.mateEquiv_vcomp
theorem mateEquiv_vcomp
    (α : G₁ ⋙ L₂ ⟶ L₁ ⋙ H₁) (β : G₂ ⋙ L₃ ⟶ L₂ ⋙ H₂) :
    (mateEquiv (G := G₁ ⋙ G₂) (H := H₁ ⋙ H₂) adj₁ adj₃) (leftAdjointSquare.vcomp α β) =
      rightAdjointSquare.vcomp (mateEquiv adj₁ adj₂ α) (mateEquiv adj₂ adj₃ β) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] {G₁ : CategoryTheory.Functor A C} {G₂ : CategoryTheory.Functor C E} {H₁ : CategoryTheory.Functor B D} {H₂ : CategoryTheory.Functor D F} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor C D} {R₂ : CategoryTheory.Functor D C} {L₃ : CategoryTheory.Functor E F} {R₃ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : G₁.comp L₂ ⟶ L₁.comp H₁) (β : G₂.comp L₃ ⟶ L₂.comp H₂)
Goal: (CategoryTheory.mateEquiv adj₁ adj₃) (CategoryTheory.leftAdjointSquare.vcomp α β) =
  CategoryTheory.rightAdjointSquare.vcomp ((CategoryTheory.mateEquiv adj₁ adj₂) α)
    ((CategoryTheory.mateEquiv adj₂ adj₃) β)
-- CategoryTheory.mateEquiv_hcomp
theorem mateEquiv_hcomp
    (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (β : H ⋙ L₄ ⟶ L₃ ⋙ K) :
    (mateEquiv (adj₁.comp adj₃) (adj₂.comp adj₄)) (leftAdjointSquare.hcomp α β) =
      rightAdjointSquare.hcomp (mateEquiv adj₁ adj₂ α) (mateEquiv adj₃ adj₄ β) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] {G : CategoryTheory.Functor A D} {H : CategoryTheory.Functor B E} {K : CategoryTheory.Functor C F} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor D E} {R₂ : CategoryTheory.Functor E D} {L₃ : CategoryTheory.Functor B C} {R₃ : CategoryTheory.Functor C B} {L₄ : CategoryTheory.Functor E F} {R₄ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (adj₄ : L₄ ⊣ R₄) (α : G.comp L₂ ⟶ L₁.comp H) (β : H.comp L₄ ⟶ L₃.comp K)
Goal: (CategoryTheory.mateEquiv (adj₁.comp adj₃) (adj₂.comp adj₄)) (CategoryTheory.leftAdjointSquare.hcomp α β) =
  CategoryTheory.rightAdjointSquare.hcomp ((CategoryTheory.mateEquiv adj₁ adj₂) α)
    ((CategoryTheory.mateEquiv adj₃ adj₄) β)
-- CategoryTheory.leftAdjointSquare.comp_vhcomp
theorem leftAdjointSquare.comp_vhcomp
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    leftAdjointSquare.comp α β γ δ =
      leftAdjointSquare.vcomp (leftAdjointSquare.hcomp α β) (leftAdjointSquare.hcomp γ δ) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} {X : Type u₇} {Y : Type u₈} {Z : Type u₉} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] [CategoryTheory.Category.{v₇, u₇} X] [CategoryTheory.Category.{v₈, u₈} Y] [CategoryTheory.Category.{v₉, u₉} Z] {G₁ : CategoryTheory.Functor A D} {H₁ : CategoryTheory.Functor B E} {K₁ : CategoryTheory.Functor C F} {G₂ : CategoryTheory.Functor D X} {H₂ : CategoryTheory.Functor E Y} {K₂ : CategoryTheory.Functor F Z} {L₁ : CategoryTheory.Functor A B} {L₂ : CategoryTheory.Functor B C} {L₃ : CategoryTheory.Functor D E} {L₄ : CategoryTheory.Functor E F} {L₅ : CategoryTheory.Functor X Y} {L₆ : CategoryTheory.Functor Y Z} (α : G₁.comp L₃ ⟶ L₁.comp H₁) (β : H₁.comp L₄ ⟶ L₂.comp K₁) (γ : G₂.comp L₅ ⟶ L₃.comp H₂) (δ : H₂.comp L₆ ⟶ L₄.comp K₂)
Goal: CategoryTheory.leftAdjointSquare.comp α β γ δ =
  CategoryTheory.leftAdjointSquare.vcomp (CategoryTheory.leftAdjointSquare.hcomp α β)
    (CategoryTheory.leftAdjointSquare.hcomp γ δ)
-- CategoryTheory.leftAdjointSquare.comp_hvcomp
theorem leftAdjointSquare.comp_hvcomp
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    leftAdjointSquare.comp α β γ δ =
      leftAdjointSquare.hcomp (leftAdjointSquare.vcomp α γ) (leftAdjointSquare.vcomp β δ) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} {X : Type u₇} {Y : Type u₈} {Z : Type u₉} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] [CategoryTheory.Category.{v₇, u₇} X] [CategoryTheory.Category.{v₈, u₈} Y] [CategoryTheory.Category.{v₉, u₉} Z] {G₁ : CategoryTheory.Functor A D} {H₁ : CategoryTheory.Functor B E} {K₁ : CategoryTheory.Functor C F} {G₂ : CategoryTheory.Functor D X} {H₂ : CategoryTheory.Functor E Y} {K₂ : CategoryTheory.Functor F Z} {L₁ : CategoryTheory.Functor A B} {L₂ : CategoryTheory.Functor B C} {L₃ : CategoryTheory.Functor D E} {L₄ : CategoryTheory.Functor E F} {L₅ : CategoryTheory.Functor X Y} {L₆ : CategoryTheory.Functor Y Z} (α : G₁.comp L₃ ⟶ L₁.comp H₁) (β : H₁.comp L₄ ⟶ L₂.comp K₁) (γ : G₂.comp L₅ ⟶ L₃.comp H₂) (δ : H₂.comp L₆ ⟶ L₄.comp K₂)
Goal: CategoryTheory.leftAdjointSquare.comp α β γ δ =
  CategoryTheory.leftAdjointSquare.hcomp (CategoryTheory.leftAdjointSquare.vcomp α γ)
    (CategoryTheory.leftAdjointSquare.vcomp β δ)
-- CategoryTheory.rightAdjointSquare.comp_vhcomp
theorem rightAdjointSquare.comp_vhcomp
    (α : R₁ ⋙ G₁ ⟶ H₁ ⋙ R₃) (β : R₂ ⋙ H₁ ⟶ K₁ ⋙ R₄)
    (γ : R₃ ⋙ G₂ ⟶ H₂ ⋙ R₅) (δ : R₄ ⋙ H₂ ⟶ K₂ ⋙ R₆) :
    rightAdjointSquare.comp α β γ δ =
    rightAdjointSquare.vcomp (rightAdjointSquare.hcomp α β) (rightAdjointSquare.hcomp γ δ) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} {X : Type u₇} {Y : Type u₈} {Z : Type u₉} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] [CategoryTheory.Category.{v₇, u₇} X] [CategoryTheory.Category.{v₈, u₈} Y] [CategoryTheory.Category.{v₉, u₉} Z] {G₁ : CategoryTheory.Functor A D} {H₁ : CategoryTheory.Functor B E} {K₁ : CategoryTheory.Functor C F} {G₂ : CategoryTheory.Functor D X} {H₂ : CategoryTheory.Functor E Y} {K₂ : CategoryTheory.Functor F Z} {R₁ : CategoryTheory.Functor B A} {R₂ : CategoryTheory.Functor C B} {R₃ : CategoryTheory.Functor E D} {R₄ : CategoryTheory.Functor F E} {R₅ : CategoryTheory.Functor Y X} {R₆ : CategoryTheory.Functor Z Y} (α : R₁.comp G₁ ⟶ H₁.comp R₃) (β : R₂.comp H₁ ⟶ K₁.comp R₄) (γ : R₃.comp G₂ ⟶ H₂.comp R₅) (δ : R₄.comp H₂ ⟶ K₂.comp R₆)
Goal: CategoryTheory.rightAdjointSquare.comp α β γ δ =
  CategoryTheory.rightAdjointSquare.vcomp (CategoryTheory.rightAdjointSquare.hcomp α β)
    (CategoryTheory.rightAdjointSquare.hcomp γ δ)
-- CategoryTheory.rightAdjointSquare.comp_hvcomp
theorem rightAdjointSquare.comp_hvcomp
    (α : R₁ ⋙ G₁ ⟶ H₁ ⋙ R₃) (β : R₂ ⋙ H₁ ⟶ K₁ ⋙ R₄)
    (γ : R₃ ⋙ G₂ ⟶ H₂ ⋙ R₅) (δ : R₄ ⋙ H₂ ⟶ K₂ ⋙ R₆) :
    rightAdjointSquare.comp α β γ δ =
    rightAdjointSquare.hcomp (rightAdjointSquare.vcomp α γ) (rightAdjointSquare.vcomp β δ) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} {X : Type u₇} {Y : Type u₈} {Z : Type u₉} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] [CategoryTheory.Category.{v₇, u₇} X] [CategoryTheory.Category.{v₈, u₈} Y] [CategoryTheory.Category.{v₉, u₉} Z] {G₁ : CategoryTheory.Functor A D} {H₁ : CategoryTheory.Functor B E} {K₁ : CategoryTheory.Functor C F} {G₂ : CategoryTheory.Functor D X} {H₂ : CategoryTheory.Functor E Y} {K₂ : CategoryTheory.Functor F Z} {R₁ : CategoryTheory.Functor B A} {R₂ : CategoryTheory.Functor C B} {R₃ : CategoryTheory.Functor E D} {R₄ : CategoryTheory.Functor F E} {R₅ : CategoryTheory.Functor Y X} {R₆ : CategoryTheory.Functor Z Y} (α : R₁.comp G₁ ⟶ H₁.comp R₃) (β : R₂.comp H₁ ⟶ K₁.comp R₄) (γ : R₃.comp G₂ ⟶ H₂.comp R₅) (δ : R₄.comp H₂ ⟶ K₂.comp R₆)
Goal: CategoryTheory.rightAdjointSquare.comp α β γ δ =
  CategoryTheory.rightAdjointSquare.hcomp (CategoryTheory.rightAdjointSquare.vcomp α γ)
    (CategoryTheory.rightAdjointSquare.vcomp β δ)
-- CategoryTheory.mateEquiv_square
theorem mateEquiv_square
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    (mateEquiv (G := G₁ ⋙ G₂) (H := K₁ ⋙ K₂) (adj₁.comp adj₂) (adj₅.comp adj₆))
        (leftAdjointSquare.comp α β γ δ) =
      rightAdjointSquare.comp
        (mateEquiv adj₁ adj₃ α) (mateEquiv adj₂ adj₄ β)
        (mateEquiv adj₃ adj₅ γ) (mateEquiv adj₄ adj₆ δ) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} {X : Type u₇} {Y : Type u₈} {Z : Type u₉} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] [CategoryTheory.Category.{v₅, u₅} E] [CategoryTheory.Category.{v₆, u₆} F] [CategoryTheory.Category.{v₇, u₇} X] [CategoryTheory.Category.{v₈, u₈} Y] [CategoryTheory.Category.{v₉, u₉} Z] {G₁ : CategoryTheory.Functor A D} {H₁ : CategoryTheory.Functor B E} {K₁ : CategoryTheory.Functor C F} {G₂ : CategoryTheory.Functor D X} {H₂ : CategoryTheory.Functor E Y} {K₂ : CategoryTheory.Functor F Z} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor B C} {R₂ : CategoryTheory.Functor C B} {L₃ : CategoryTheory.Functor D E} {R₃ : CategoryTheory.Functor E D} {L₄ : CategoryTheory.Functor E F} {R₄ : CategoryTheory.Functor F E} {L₅ : CategoryTheory.Functor X Y} {R₅ : CategoryTheory.Functor Y X} {L₆ : CategoryTheory.Functor Y Z} {R₆ : CategoryTheory.Functor Z Y} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (adj₄ : L₄ ⊣ R₄) (adj₅ : L₅ ⊣ R₅) (adj₆ : L₆ ⊣ R₆) (α : G₁.comp L₃ ⟶ L₁.comp H₁) (β : H₁.comp L₄ ⟶ L₂.comp K₁) (γ : G₂.comp L₅ ⟶ L₃.comp H₂) (δ : H₂.comp L₆ ⟶ L₄.comp K₂)
Goal: (CategoryTheory.mateEquiv (adj₁.comp adj₂) (adj₅.comp adj₆)) (CategoryTheory.leftAdjointSquare.comp α β γ δ) =
  CategoryTheory.rightAdjointSquare.comp ((CategoryTheory.mateEquiv adj₁ adj₃) α)
    ((CategoryTheory.mateEquiv adj₂ adj₄) β) ((CategoryTheory.mateEquiv adj₃ adj₅) γ)
    ((CategoryTheory.mateEquiv adj₄ adj₆) δ)