ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Adjunction.homEquiv_naturality_left
@[simp, nolint simpNF]
theorem homEquiv_naturality_left (f : X' ⟶ X) (g : F.obj X ⟶ Y) :
    (adj.homEquiv X' Y) (F.map f ≫ g) = f ≫ (adj.homEquiv X Y) g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y : D} (f : X' ⟶ X) (g : F.obj X ⟶ Y)
Goal: (adj.homEquiv X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) =
  CategoryTheory.CategoryStruct.comp f ((adj.homEquiv X Y) g)
-- CategoryTheory.Adjunction.homEquiv_naturality_right
@[simp, nolint simpNF]
theorem homEquiv_naturality_right (f : F.obj X ⟶ Y) (g : Y ⟶ Y') :
    (adj.homEquiv X Y') (f ≫ g) = (adj.homEquiv X Y) f ≫ G.map g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X : C} {Y Y' : D} (f : F.obj X ⟶ Y) (g : Y ⟶ Y')
Goal: (adj.homEquiv X Y') (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y) f) (G.map g)
-- CategoryTheory.Adjunction.homEquiv_naturality_right_symm
@[simp, nolint simpNF]
theorem homEquiv_naturality_right_symm (f : X ⟶ G.obj Y) (g : Y ⟶ Y') :
    (adj.homEquiv X Y').symm (f ≫ G.map g) = (adj.homEquiv X Y).symm f ≫ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y')
Goal: (adj.homEquiv X Y').symm (CategoryTheory.CategoryStruct.comp f (G.map g)) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) g
-- CategoryTheory.Adjunction.homEquiv_naturality_left_square
@[reassoc]
theorem homEquiv_naturality_left_square (f : X' ⟶ X) (g : F.obj X ⟶ Y')
    (h : F.obj X' ⟶ Y) (k : Y ⟶ Y') (w : F.map f ≫ g = h ≫ k) :
    f ≫ (adj.homEquiv X Y') g = (adj.homEquiv X' Y) h ≫ G.map k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X) (g : F.obj X ⟶ Y') (h : F.obj X' ⟶ Y) (k : Y ⟶ Y') (w : CategoryTheory.CategoryStruct.comp (F.map f) g = CategoryTheory.CategoryStruct.comp h k)
Goal: CategoryTheory.CategoryStruct.comp f ((adj.homEquiv X Y') g) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' Y) h) (G.map k)
-- CategoryTheory.Adjunction.homEquiv_naturality_right_square
@[reassoc]
theorem homEquiv_naturality_right_square (f : X' ⟶ X) (g : X ⟶ G.obj Y')
    (h : X' ⟶ G.obj Y) (k : Y ⟶ Y') (w : f ≫ g = h ≫ G.map k) :
    F.map f ≫ (adj.homEquiv X Y').symm g = (adj.homEquiv X' Y).symm h ≫ k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y') (h : X' ⟶ G.obj Y) (k : Y ⟶ Y') (w : CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp h (G.map k))
Goal: CategoryTheory.CategoryStruct.comp (F.map f) ((adj.homEquiv X Y').symm g) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' Y).symm h) k
-- CategoryTheory.Adjunction.homEquiv_naturality_left_square_iff
theorem homEquiv_naturality_left_square_iff (f : X' ⟶ X) (g : F.obj X ⟶ Y')
    (h : F.obj X' ⟶ Y) (k : Y ⟶ Y') :
    (f ≫ (adj.homEquiv X Y') g = (adj.homEquiv X' Y) h ≫ G.map k) ↔
      (F.map f ≫ g = h ≫ k) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X) (g : F.obj X ⟶ Y') (h : F.obj X' ⟶ Y) (k : Y ⟶ Y')
Goal: CategoryTheory.CategoryStruct.comp f ((adj.homEquiv X Y') g) =
    CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' Y) h) (G.map k) ↔
  CategoryTheory.CategoryStruct.comp (F.map f) g = CategoryTheory.CategoryStruct.comp h k
-- CategoryTheory.Adjunction.homEquiv_naturality_right_square_iff
theorem homEquiv_naturality_right_square_iff (f : X' ⟶ X) (g : X ⟶ G.obj Y')
    (h : X' ⟶ G.obj Y) (k : Y ⟶ Y') :
    (F.map f ≫ (adj.homEquiv X Y').symm g = (adj.homEquiv X' Y).symm h ≫ k) ↔
      (f ≫ g = h ≫ G.map k) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y') (h : X' ⟶ G.obj Y) (k : Y ⟶ Y')
Goal: CategoryTheory.CategoryStruct.comp (F.map f) ((adj.homEquiv X Y').symm g) =
    CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' Y).symm h) k ↔
  CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp h (G.map k)
-- CategoryTheory.Adjunction.left_triangle
@[simp]
theorem left_triangle : whiskerRight adj.unit F ≫ whiskerLeft F adj.counit = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight adj.unit F) (CategoryTheory.whiskerLeft F adj.counit) =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id C).comp F)
-- CategoryTheory.Adjunction.right_triangle
@[simp]
theorem right_triangle : whiskerLeft G adj.unit ≫ whiskerRight adj.counit G = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft G adj.unit) (CategoryTheory.whiskerRight adj.counit G) =
  CategoryTheory.CategoryStruct.id (G.comp (CategoryTheory.Functor.id C))
-- CategoryTheory.Adjunction.left_triangle_components
@[reassoc (attr := simp)]
theorem left_triangle_components :
    F.map (adj.unit.app X) ≫ adj.counit.app (F.obj X) = 𝟙 (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : C)
Goal: CategoryTheory.CategoryStruct.comp (F.map (adj.unit.app X)) (adj.counit.app (F.obj X)) =
  CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Adjunction.right_triangle_components
@[reassoc (attr := simp)]
theorem right_triangle_components :
    adj.unit.app (G.obj Y) ≫ G.map (adj.counit.app Y) = 𝟙 (G.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (Y : D)
Goal: CategoryTheory.CategoryStruct.comp (adj.unit.app (G.obj Y)) (G.map (adj.counit.app Y)) =
  CategoryTheory.CategoryStruct.id (G.obj Y)
-- CategoryTheory.Adjunction.counit_naturality
@[reassoc (attr := simp)]
theorem counit_naturality {X Y : D} (f : X ⟶ Y) :
    F.map (G.map f) ≫ adj.counit.app Y = adj.counit.app X ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X Y : D} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (F.map (G.map f)) (adj.counit.app Y) =
  CategoryTheory.CategoryStruct.comp (adj.counit.app X) f
-- CategoryTheory.Adjunction.unit_naturality
@[reassoc (attr := simp)]
theorem unit_naturality {X Y : C} (f : X ⟶ Y) :
    adj.unit.app X ≫ G.map (F.map f) = f ≫ adj.unit.app Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (adj.unit.app X) (G.map (F.map f)) =
  CategoryTheory.CategoryStruct.comp f (adj.unit.app Y)
-- CategoryTheory.Adjunction.homEquiv_apply_eq
theorem homEquiv_apply_eq {A : C} {B : D} (f : F.obj A ⟶ B) (g : A ⟶ G.obj B) :
    adj.homEquiv A B f = g ↔ f = (adj.homEquiv A B).symm g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {A : C} {B : D} (f : F.obj A ⟶ B) (g : A ⟶ G.obj B)
Goal: (adj.homEquiv A B) f = g ↔ f = (adj.homEquiv A B).symm g
-- CategoryTheory.Adjunction.eq_homEquiv_apply
theorem eq_homEquiv_apply {A : C} {B : D} (f : F.obj A ⟶ B) (g : A ⟶ G.obj B) :
    g = adj.homEquiv A B f ↔ (adj.homEquiv A B).symm g = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {A : C} {B : D} (f : F.obj A ⟶ B) (g : A ⟶ G.obj B)
Goal: g = (adj.homEquiv A B) f ↔ (adj.homEquiv A B).symm g = f
-- CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right
-- Porting note(#5171): `has_nonempty_instance` linter not ported yet
-- @[nolint has_nonempty_instance]
structure CoreHomEquiv (F : C ⥤ D) (G : D ⥤ C) where
    homEquiv : ∀ X Y, (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
    homEquiv_naturality_left_symm :
    ∀ {X' X Y} (f : X' ⟶ X) (g : X ⟶ G.obj Y),
      (homEquiv X' Y).symm (f ≫ g) = F.map f ≫ (homEquiv X Y).symm g := by
    aesop_cat
    homEquiv_naturality_right :
    ∀ {X Y Y'} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'),
      (homEquiv X Y') (f ≫ g) = (homEquiv X Y) f ≫ G.map g := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (self : CategoryTheory.Adjunction.CoreHomEquiv F G) {X : C} {Y Y' : D} (f : F.obj X ⟶ Y) (g : Y ⟶ Y')
Goal: (self.homEquiv X Y') (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp ((self.homEquiv X Y) f) (G.map g)
-- CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left_symm
-- Porting note(#5171): `has_nonempty_instance` linter not ported yet
-- @[nolint has_nonempty_instance]
structure CoreHomEquiv (F : C ⥤ D) (G : D ⥤ C) where
    homEquiv : ∀ X Y, (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
    homEquiv_naturality_left_symm :
    ∀ {X' X Y} (f : X' ⟶ X) (g : X ⟶ G.obj Y),
      (homEquiv X' Y).symm (f ≫ g) = F.map f ≫ (homEquiv X Y).symm g := by
    aesop_cat
    homEquiv_naturality_right :
    ∀ {X Y Y'} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'),
      (homEquiv X Y') (f ≫ g) = (homEquiv X Y) f ≫ G.map g := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (self : CategoryTheory.Adjunction.CoreHomEquiv F G) {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y)
Goal: (self.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (F.map f) ((self.homEquiv X Y).symm g)
-- CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left_aux
@[simp]
theorem homEquiv_naturality_left_aux (f : X' ⟶ X) (g : F.obj X ⟶ Y) :
    (adj.homEquiv X' (F.obj X)) (F.map f) ≫ G.map g = f ≫ (adj.homEquiv X Y) g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) {X' X : C} {Y : D} (f : X' ⟶ X) (g : F.obj X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' (F.obj X)) (F.map f)) (G.map g) =
  CategoryTheory.CategoryStruct.comp f ((adj.homEquiv X Y) g)
-- CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left
theorem homEquiv_naturality_left (f : X' ⟶ X) (g : F.obj X ⟶ Y) :
    (adj.homEquiv X' Y) (F.map f ≫ g) = f ≫ (adj.homEquiv X Y) g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) {X' X : C} {Y : D} (f : X' ⟶ X) (g : F.obj X ⟶ Y)
Goal: (adj.homEquiv X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) =
  CategoryTheory.CategoryStruct.comp f ((adj.homEquiv X Y) g)
-- CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right_symm_aux
@[simp]
theorem homEquiv_naturality_right_symm_aux (f : X ⟶ G.obj Y) (g : Y ⟶ Y') :
    F.map f ≫ (adj.homEquiv (G.obj Y) Y').symm (G.map g) = (adj.homEquiv X Y).symm f ≫ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y')
Goal: CategoryTheory.CategoryStruct.comp (F.map f) ((adj.homEquiv (G.obj Y) Y').symm (G.map g)) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) g
-- CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right_symm
theorem homEquiv_naturality_right_symm (f : X ⟶ G.obj Y) (g : Y ⟶ Y') :
    (adj.homEquiv X Y').symm (f ≫ G.map g) = (adj.homEquiv X Y).symm f ≫ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y')
Goal: (adj.homEquiv X Y').symm (CategoryTheory.CategoryStruct.comp f (G.map g)) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) g
-- CategoryTheory.Adjunction.CoreUnitCounit.left_triangle
-- Porting note(#5171): `has_nonempty_instance` linter not ported yet
-- @[nolint has_nonempty_instance]
structure CoreUnitCounit (F : C ⥤ D) (G : D ⥤ C) where
    unit : 𝟭 C ⟶ F.comp G
    counit : G.comp F ⟶ 𝟭 D
    left_triangle :
    whiskerRight unit F ≫ (Functor.associator F G F).hom ≫ whiskerLeft F counit =
      NatTrans.id (𝟭 C ⋙ F) := by
    aesop_cat
    right_triangle :
    whiskerLeft G unit ≫ (Functor.associator G F G).inv ≫ whiskerRight counit G =
      NatTrans.id (G ⋙ 𝟭 C) := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (self : CategoryTheory.Adjunction.CoreUnitCounit F G)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight self.unit F)
    (CategoryTheory.CategoryStruct.comp (F.associator G F).hom (CategoryTheory.whiskerLeft F self.counit)) =
  CategoryTheory.NatTrans.id ((CategoryTheory.Functor.id C).comp F)
-- CategoryTheory.Adjunction.CoreUnitCounit.right_triangle
-- Porting note(#5171): `has_nonempty_instance` linter not ported yet
-- @[nolint has_nonempty_instance]
structure CoreUnitCounit (F : C ⥤ D) (G : D ⥤ C) where
    unit : 𝟭 C ⟶ F.comp G
    counit : G.comp F ⟶ 𝟭 D
    left_triangle :
    whiskerRight unit F ≫ (Functor.associator F G F).hom ≫ whiskerLeft F counit =
      NatTrans.id (𝟭 C ⋙ F) := by
    aesop_cat
    right_triangle :
    whiskerLeft G unit ≫ (Functor.associator G F G).inv ≫ whiskerRight counit G =
      NatTrans.id (G ⋙ 𝟭 C) := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (self : CategoryTheory.Adjunction.CoreUnitCounit F G)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft G self.unit)
    (CategoryTheory.CategoryStruct.comp (G.associator F G).inv (CategoryTheory.whiskerRight self.counit G)) =
  CategoryTheory.NatTrans.id (G.comp (CategoryTheory.Functor.id C))
-- CategoryTheory.Adjunction.mkOfHomEquiv_counit_app
@[simps]
def mkOfHomEquiv (adj : CoreHomEquiv F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) (Y : D)
Goal: (CategoryTheory.Adjunction.mkOfHomEquiv adj).counit.app Y =
  (adj.homEquiv (G.obj Y) ((CategoryTheory.Functor.id D).obj Y)).invFun (CategoryTheory.CategoryStruct.id (G.obj Y))
-- CategoryTheory.Adjunction.mkOfHomEquiv_unit_app
@[simps]
def mkOfHomEquiv (adj : CoreHomEquiv F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) (X : C)
Goal: (CategoryTheory.Adjunction.mkOfHomEquiv adj).unit.app X =
  (adj.homEquiv X (F.obj X)) (CategoryTheory.CategoryStruct.id (F.obj X))
-- CategoryTheory.Adjunction.mkOfHomEquiv_homEquiv
@[simps]
def mkOfHomEquiv (adj : CoreHomEquiv F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreHomEquiv F G) (X : C) (Y : D)
Goal: (CategoryTheory.Adjunction.mkOfHomEquiv adj).homEquiv X Y = adj.homEquiv X Y
-- CategoryTheory.Adjunction.mkOfUnitCounit_unit

@[simps!]
def mkOfUnitCounit (adj : CoreUnitCounit F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreUnitCounit F G)
Goal: (CategoryTheory.Adjunction.mkOfUnitCounit adj).unit = adj.unit
-- CategoryTheory.Adjunction.mkOfUnitCounit_homEquiv_apply

@[simps!]
def mkOfUnitCounit (adj : CoreUnitCounit F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreUnitCounit F G) (X : C) (Y : D) (f : F.obj X ⟶ Y)
Goal: ((CategoryTheory.Adjunction.mkOfUnitCounit adj).homEquiv X Y) f =
  CategoryTheory.CategoryStruct.comp (adj.unit.app X) (G.map f)
-- CategoryTheory.Adjunction.mkOfUnitCounit_homEquiv_symm_apply

@[simps!]
def mkOfUnitCounit (adj : CoreUnitCounit F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreUnitCounit F G) (X : C) (Y : D) (g : X ⟶ G.obj Y)
Goal: ((CategoryTheory.Adjunction.mkOfUnitCounit adj).homEquiv X Y).symm g =
  CategoryTheory.CategoryStruct.comp (F.map g) (adj.counit.app Y)
-- CategoryTheory.Adjunction.mkOfUnitCounit_counit

@[simps!]
def mkOfUnitCounit (adj : CoreUnitCounit F G) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : CategoryTheory.Adjunction.CoreUnitCounit F G)
Goal: (CategoryTheory.Adjunction.mkOfUnitCounit adj).counit = adj.counit
-- CategoryTheory.Adjunction.equivHomsetLeftOfNatIso_apply
@[simps]
def equivHomsetLeftOfNatIso {F F' : C ⥤ D} (iso : F ≅ F') {X : C} {Y : D} :
    (F.obj X ⟶ Y) ≃ (F'.obj X ⟶ Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} (iso : F ≅ F') {X : C} {Y : D} (f : F.obj X ⟶ Y)
Goal: (CategoryTheory.Adjunction.equivHomsetLeftOfNatIso iso) f = CategoryTheory.CategoryStruct.comp (iso.inv.app X) f
-- CategoryTheory.Adjunction.equivHomsetLeftOfNatIso_symm_apply
@[simps]
def equivHomsetLeftOfNatIso {F F' : C ⥤ D} (iso : F ≅ F') {X : C} {Y : D} :
    (F.obj X ⟶ Y) ≃ (F'.obj X ⟶ Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} (iso : F ≅ F') {X : C} {Y : D} (g : F'.obj X ⟶ Y)
Goal: (CategoryTheory.Adjunction.equivHomsetLeftOfNatIso iso).symm g = CategoryTheory.CategoryStruct.comp (iso.hom.app X) g
-- CategoryTheory.Adjunction.equivHomsetRightOfNatIso_apply
@[simps]
def equivHomsetRightOfNatIso {G G' : D ⥤ C} (iso : G ≅ G') {X : C} {Y : D} :
    (X ⟶ G.obj Y) ≃ (X ⟶ G'.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G G' : CategoryTheory.Functor D C} (iso : G ≅ G') {X : C} {Y : D} (f : X ⟶ G.obj Y)
Goal: (CategoryTheory.Adjunction.equivHomsetRightOfNatIso iso) f = CategoryTheory.CategoryStruct.comp f (iso.hom.app Y)
-- CategoryTheory.Adjunction.equivHomsetRightOfNatIso_symm_apply
@[simps]
def equivHomsetRightOfNatIso {G G' : D ⥤ C} (iso : G ≅ G') {X : C} {Y : D} :
    (X ⟶ G.obj Y) ≃ (X ⟶ G'.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G G' : CategoryTheory.Functor D C} (iso : G ≅ G') {X : C} {Y : D} (g : X ⟶ G'.obj Y)
Goal: (CategoryTheory.Adjunction.equivHomsetRightOfNatIso iso).symm g = CategoryTheory.CategoryStruct.comp g (iso.inv.app Y)
-- CategoryTheory.Adjunction.comp_unit_app
@[simp, reassoc]
lemma comp_unit_app (X : C) :
    (adj₁.comp adj₂).unit.app X = adj₁.unit.app X ≫ G.map (adj₂.unit.app (F.obj X)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} {E : Type u₃} [ℰ : CategoryTheory.Category.{v₃, u₃} E] {H : CategoryTheory.Functor D E} {I : CategoryTheory.Functor E D} (adj₁ : F ⊣ G) (adj₂ : H ⊣ I) (X : C)
Goal: (adj₁.comp adj₂).unit.app X = CategoryTheory.CategoryStruct.comp (adj₁.unit.app X) (G.map (adj₂.unit.app (F.obj X)))
-- CategoryTheory.Adjunction.comp_counit_app
@[simp, reassoc]
lemma comp_counit_app (X : E) :
    (adj₁.comp adj₂).counit.app X = H.map (adj₁.counit.app (I.obj X)) ≫ adj₂.counit.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} {E : Type u₃} [ℰ : CategoryTheory.Category.{v₃, u₃} E] {H : CategoryTheory.Functor D E} {I : CategoryTheory.Functor E D} (adj₁ : F ⊣ G) (adj₂ : H ⊣ I) (X : E)
Goal: (adj₁.comp adj₂).counit.app X =
  CategoryTheory.CategoryStruct.comp (H.map (adj₁.counit.app (I.obj X))) (adj₂.counit.app X)
-- CategoryTheory.Adjunction.leftAdjointOfEquiv_map
@[simps!]
def leftAdjointOfEquiv (he : ∀ X Y Y' g h, e X Y' (h ≫ g) = e X Y h ≫ G.map g) : C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G : CategoryTheory.Functor D C} {F_obj : C → D} (e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (he :
  ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y),
    (e X Y') (CategoryTheory.CategoryStruct.comp h g) = CategoryTheory.CategoryStruct.comp ((e X Y) h) (G.map g)) {X X' : C} (f : X ⟶ X')
Goal: (CategoryTheory.Adjunction.leftAdjointOfEquiv e he).map f =
  (e X (F_obj X')).symm
    (CategoryTheory.CategoryStruct.comp f ((e X' (F_obj X')) (CategoryTheory.CategoryStruct.id (F_obj X'))))
-- CategoryTheory.Adjunction.leftAdjointOfEquiv_obj
@[simps!]
def leftAdjointOfEquiv (he : ∀ X Y Y' g h, e X Y' (h ≫ g) = e X Y h ≫ G.map g) : C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {G : CategoryTheory.Functor D C} {F_obj : C → D} (e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (he :
  ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y),
    (e X Y') (CategoryTheory.CategoryStruct.comp h g) = CategoryTheory.CategoryStruct.comp ((e X Y) h) (G.map g))
Goal: ∀ (a : C), (CategoryTheory.Adjunction.leftAdjointOfEquiv e he).obj a = F_obj a