ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Functor.initial_iff_isCofiltered_costructuredArrow
theorem Functor.initial_iff_isCofiltered_costructuredArrow [IsCofilteredOrEmpty C] :
    Initial F ↔ ∀ d, IsCofiltered (CostructuredArrow F d) 
Arguments: {C : Type v₁} [CategoryTheory.Category.{v₁, v₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.IsCofilteredOrEmpty C]
Goal: F.Initial ↔ ∀ (d : D), CategoryTheory.IsCofiltered (CategoryTheory.CostructuredArrow F d)
-- CategoryTheory.Arrow.hom_ext
@[ext]
lemma hom_ext {X Y : Arrow T} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) :
    f = g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : CategoryTheory.Arrow T} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right)
Goal: f = g
-- CategoryTheory.Arrow.id_left
@[simp]
theorem id_left (f : Arrow T) : CommaMorphism.left (𝟙 f) = 𝟙 f.left 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] (f : CategoryTheory.Arrow T)
Goal: (CategoryTheory.CategoryStruct.id f).left = CategoryTheory.CategoryStruct.id f.left
-- CategoryTheory.Arrow.id_right
@[simp]
theorem id_right (f : Arrow T) : CommaMorphism.right (𝟙 f) = 𝟙 f.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] (f : CategoryTheory.Arrow T)
Goal: (CategoryTheory.CategoryStruct.id f).right = CategoryTheory.CategoryStruct.id f.right
-- CategoryTheory.Arrow.comp_left
@[simp, reassoc]
theorem comp_left {X Y Z : Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).left = f.left ≫ g.left 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y Z : CategoryTheory.Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left
-- CategoryTheory.Arrow.comp_right
@[simp, reassoc]
theorem comp_right {X Y Z : Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).right = f.right ≫ g.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y Z : CategoryTheory.Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right
-- CategoryTheory.Arrow.mk_right
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Arrow.mk f).right = Y
-- CategoryTheory.Arrow.mk_left
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Arrow.mk f).left = X
-- CategoryTheory.Arrow.mk_hom
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : T} (f : X ⟶ Y)
Goal: (CategoryTheory.Arrow.mk f).hom = f
-- CategoryTheory.Arrow.mk_eq
@[simp]
theorem mk_eq (f : Arrow T) : Arrow.mk f.hom = f 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] (f : CategoryTheory.Arrow T)
Goal: CategoryTheory.Arrow.mk f.hom = f
-- CategoryTheory.Arrow.mk_injective
theorem mk_injective (A B : T) :
    Function.Injective (Arrow.mk : (A ⟶ B) → Arrow T) 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] (A B : T)
Goal: Function.Injective CategoryTheory.Arrow.mk
-- CategoryTheory.Arrow.mk_inj
theorem mk_inj (A B : T) {f g : A ⟶ B} : Arrow.mk f = Arrow.mk g ↔ f = g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] (A B : T) {f g : A ⟶ B}
Goal: CategoryTheory.Arrow.mk f = CategoryTheory.Arrow.mk g ↔ f = g
-- CategoryTheory.Arrow.homMk_right
@[simps]
def homMk {f g : Arrow T} {u : f.left ⟶ g.left} {v : f.right ⟶ g.right}
    (w : u ≫ g.hom = f.hom ≫ v) : f ⟶ g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} {u : f.left ⟶ g.left} {v : f.right ⟶ g.right} (w : CategoryTheory.CategoryStruct.comp u g.hom = CategoryTheory.CategoryStruct.comp f.hom v)
Goal: (CategoryTheory.Arrow.homMk w).right = v
-- CategoryTheory.Arrow.homMk_left
@[simps]
def homMk {f g : Arrow T} {u : f.left ⟶ g.left} {v : f.right ⟶ g.right}
    (w : u ≫ g.hom = f.hom ≫ v) : f ⟶ g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} {u : f.left ⟶ g.left} {v : f.right ⟶ g.right} (w : CategoryTheory.CategoryStruct.comp u g.hom = CategoryTheory.CategoryStruct.comp f.hom v)
Goal: (CategoryTheory.Arrow.homMk w).left = u
-- CategoryTheory.Arrow.homMk'_left
@[simps]
def homMk' {X Y : T} {f : X ⟶ Y} {P Q : T} {g : P ⟶ Q} {u : X ⟶ P} {v : Y ⟶ Q} (w : u ≫ g = f ≫ v) :
    Arrow.mk f ⟶ Arrow.mk g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : T} {f : X ⟶ Y} {P Q : T} {g : P ⟶ Q} {u : X ⟶ P} {v : Y ⟶ Q} (w : CategoryTheory.CategoryStruct.comp u g = CategoryTheory.CategoryStruct.comp f v)
Goal: (CategoryTheory.Arrow.homMk' w).left = u
-- CategoryTheory.Arrow.homMk'_right
@[simps]
def homMk' {X Y : T} {f : X ⟶ Y} {P Q : T} {g : P ⟶ Q} {u : X ⟶ P} {v : Y ⟶ Q} (w : u ≫ g = f ≫ v) :
    Arrow.mk f ⟶ Arrow.mk g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : T} {f : X ⟶ Y} {P Q : T} {g : P ⟶ Q} {u : X ⟶ P} {v : Y ⟶ Q} (w : CategoryTheory.CategoryStruct.comp u g = CategoryTheory.CategoryStruct.comp f v)
Goal: (CategoryTheory.Arrow.homMk' w).right = v
-- CategoryTheory.Arrow.w
@[reassoc (attr := simp, nolint simpNF)]
theorem w {f g : Arrow T} (sq : f ⟶ g) : sq.left ≫ g.hom = f.hom ≫ sq.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g)
Goal: CategoryTheory.CategoryStruct.comp sq.left g.hom = CategoryTheory.CategoryStruct.comp f.hom sq.right
-- CategoryTheory.Arrow.w_mk_right
@[reassoc (attr := simp)]
theorem w_mk_right {f : Arrow T} {X Y : T} {g : X ⟶ Y} (sq : f ⟶ mk g) :
    sq.left ≫ g = f.hom ≫ sq.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f : CategoryTheory.Arrow T} {X Y : T} {g : X ⟶ Y} (sq : f ⟶ CategoryTheory.Arrow.mk g)
Goal: CategoryTheory.CategoryStruct.comp sq.left g = CategoryTheory.CategoryStruct.comp f.hom sq.right
-- CategoryTheory.Arrow.isIso_of_isIso_left_of_isIso_right
theorem isIso_of_isIso_left_of_isIso_right {f g : Arrow T} (ff : f ⟶ g) [IsIso ff.left]
    [IsIso ff.right] : IsIso ff 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (ff : f ⟶ g) [CategoryTheory.IsIso ff.left] [CategoryTheory.IsIso ff.right]
Goal: CategoryTheory.IsIso ff
-- CategoryTheory.Arrow.isoMk_inv_left
@[simps!]
def isoMk {f g : Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right)
    (h : l.hom ≫ g.hom = f.hom ≫ r.hom := by aesop_cat) : f ≅ g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right) (h : CategoryTheory.CategoryStruct.comp l.hom g.hom = CategoryTheory.CategoryStruct.comp f.hom r.hom := by aesop_cat)
Goal: (CategoryTheory.Arrow.isoMk l r h).inv.left = l.inv
-- CategoryTheory.Arrow.isoMk_hom_left
@[simps!]
def isoMk {f g : Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right)
    (h : l.hom ≫ g.hom = f.hom ≫ r.hom := by aesop_cat) : f ≅ g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right) (h : CategoryTheory.CategoryStruct.comp l.hom g.hom = CategoryTheory.CategoryStruct.comp f.hom r.hom := by aesop_cat)
Goal: (CategoryTheory.Arrow.isoMk l r h).hom.left = l.hom
-- CategoryTheory.Arrow.isoMk_hom_right
@[simps!]
def isoMk {f g : Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right)
    (h : l.hom ≫ g.hom = f.hom ≫ r.hom := by aesop_cat) : f ≅ g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right) (h : CategoryTheory.CategoryStruct.comp l.hom g.hom = CategoryTheory.CategoryStruct.comp f.hom r.hom := by aesop_cat)
Goal: (CategoryTheory.Arrow.isoMk l r h).hom.right = r.hom
-- CategoryTheory.Arrow.isoMk_inv_right
@[simps!]
def isoMk {f g : Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right)
    (h : l.hom ≫ g.hom = f.hom ≫ r.hom := by aesop_cat) : f ≅ g 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (l : f.left ≅ g.left) (r : f.right ≅ g.right) (h : CategoryTheory.CategoryStruct.comp l.hom g.hom = CategoryTheory.CategoryStruct.comp f.hom r.hom := by aesop_cat)
Goal: (CategoryTheory.Arrow.isoMk l r h).inv.right = r.inv
-- CategoryTheory.Arrow.hom.congr_left
theorem hom.congr_left {f g : Arrow T} {φ₁ φ₂ : f ⟶ g} (h : φ₁ = φ₂) : φ₁.left = φ₂.left 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} {φ₁ φ₂ : f ⟶ g} (h : φ₁ = φ₂)
Goal: φ₁.left = φ₂.left
-- CategoryTheory.Arrow.hom.congr_right
@[simp]
theorem hom.congr_right {f g : Arrow T} {φ₁ φ₂ : f ⟶ g} (h : φ₁ = φ₂) : φ₁.right = φ₂.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} {φ₁ φ₂ : f ⟶ g} (h : φ₁ = φ₂)
Goal: φ₁.right = φ₂.right
-- CategoryTheory.Arrow.iso_w
theorem iso_w {f g : Arrow T} (e : f ≅ g) : g.hom = e.inv.left ≫ f.hom ≫ e.hom.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (e : f ≅ g)
Goal: g.hom = CategoryTheory.CategoryStruct.comp e.inv.left (CategoryTheory.CategoryStruct.comp f.hom e.hom.right)
-- CategoryTheory.Arrow.iso_w'
theorem iso_w' {W X Y Z : T} {f : W ⟶ X} {g : Y ⟶ Z} (e : Arrow.mk f ≅ Arrow.mk g) :
    g = e.inv.left ≫ f ≫ e.hom.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {W X Y Z : T} {f : W ⟶ X} {g : Y ⟶ Z} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g)
Goal: g = CategoryTheory.CategoryStruct.comp e.inv.left (CategoryTheory.CategoryStruct.comp f e.hom.right)
-- CategoryTheory.Arrow.inv_left
@[simp]
theorem inv_left [IsIso sq] : (inv sq).left = inv sq.left 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (CategoryTheory.inv sq).left = CategoryTheory.inv sq.left
-- CategoryTheory.Arrow.inv_right
@[simp]
theorem inv_right [IsIso sq] : (inv sq).right = inv sq.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (CategoryTheory.inv sq).right = CategoryTheory.inv sq.right
-- CategoryTheory.Arrow.left_hom_inv_right
theorem left_hom_inv_right [IsIso sq] : sq.left ≫ g.hom ≫ inv sq.right = f.hom 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: CategoryTheory.CategoryStruct.comp sq.left (CategoryTheory.CategoryStruct.comp g.hom (CategoryTheory.inv sq.right)) =
  f.hom
-- CategoryTheory.Arrow.inv_left_hom_right
theorem inv_left_hom_right [IsIso sq] : inv sq.left ≫ f.hom ≫ sq.right = g.hom 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.inv sq.left) (CategoryTheory.CategoryStruct.comp f.hom sq.right) =
  g.hom
-- CategoryTheory.Arrow.hom_inv_id_left
@[reassoc (attr := simp)]
lemma hom_inv_id_left (e : f ≅ g) : e.hom.left ≫ e.inv.left = 𝟙 _ 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (e : f ≅ g)
Goal: CategoryTheory.CategoryStruct.comp e.hom.left e.inv.left = CategoryTheory.CategoryStruct.id f.left
-- CategoryTheory.Arrow.inv_hom_id_left
@[reassoc (attr := simp)]
lemma inv_hom_id_left (e : f ≅ g) : e.inv.left ≫ e.hom.left = 𝟙 _ 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (e : f ≅ g)
Goal: CategoryTheory.CategoryStruct.comp e.inv.left e.hom.left = CategoryTheory.CategoryStruct.id g.left
-- CategoryTheory.Arrow.hom_inv_id_right
@[reassoc (attr := simp)]
lemma hom_inv_id_right (e : f ≅ g) : e.hom.right ≫ e.inv.right = 𝟙 _ 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (e : f ≅ g)
Goal: CategoryTheory.CategoryStruct.comp e.hom.right e.inv.right = CategoryTheory.CategoryStruct.id f.right
-- CategoryTheory.Arrow.inv_hom_id_right
@[reassoc (attr := simp)]
lemma inv_hom_id_right (e : f ≅ g) : e.inv.right ≫ e.hom.right = 𝟙 _ 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (e : f ≅ g)
Goal: CategoryTheory.CategoryStruct.comp e.inv.right e.hom.right = CategoryTheory.CategoryStruct.id g.right
-- CategoryTheory.Arrow.square_to_iso_invert
@[simp]
theorem square_to_iso_invert (i : Arrow T) {X Y : T} (p : X ≅ Y) (sq : i ⟶ Arrow.mk p.hom) :
    i.hom ≫ sq.right ≫ p.inv = sq.left 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] (i : CategoryTheory.Arrow T) {X Y : T} (p : X ≅ Y) (sq : i ⟶ CategoryTheory.Arrow.mk p.hom)
Goal: CategoryTheory.CategoryStruct.comp i.hom (CategoryTheory.CategoryStruct.comp sq.right p.inv) = sq.left
-- CategoryTheory.Arrow.square_from_iso_invert
theorem square_from_iso_invert {X Y : T} (i : X ≅ Y) (p : Arrow T) (sq : Arrow.mk i.hom ⟶ p) :
    i.inv ≫ sq.left ≫ p.hom = sq.right 
Arguments: {T : Type u} [CategoryTheory.Category.{v, u} T] {X Y : T} (i : X ≅ Y) (p : CategoryTheory.Arrow T) (sq : CategoryTheory.Arrow.mk i.hom ⟶ p)
Goal: CategoryTheory.CategoryStruct.comp i.inv (CategoryTheory.CategoryStruct.comp sq.left p.hom) = sq.right
-- CategoryTheory.Arrow.squareToSnd_right
@[simps]
def squareToSnd {X Y Z : C} {i : Arrow C} {f : X ⟶ Y} {g : Y ⟶ Z} (sq : i ⟶ Arrow.mk (f ≫ g)) :
    i ⟶ Arrow.mk g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {i : CategoryTheory.Arrow C} {f : X ⟶ Y} {g : Y ⟶ Z} (sq : i ⟶ CategoryTheory.Arrow.mk (CategoryTheory.CategoryStruct.comp f g))
Goal: (CategoryTheory.Arrow.squareToSnd sq).right = sq.right
-- CategoryTheory.Arrow.squareToSnd_left
@[simps]
def squareToSnd {X Y Z : C} {i : Arrow C} {f : X ⟶ Y} {g : Y ⟶ Z} (sq : i ⟶ Arrow.mk (f ≫ g)) :
    i ⟶ Arrow.mk g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {i : CategoryTheory.Arrow C} {f : X ⟶ Y} {g : Y ⟶ Z} (sq : i ⟶ CategoryTheory.Arrow.mk (CategoryTheory.CategoryStruct.comp f g))
Goal: (CategoryTheory.Arrow.squareToSnd sq).left = CategoryTheory.CategoryStruct.comp sq.left f
-- CategoryTheory.Arrow.leftFunc_map
@[simps!]
def leftFunc : Arrow C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)} (f : X ⟶ Y),
  CategoryTheory.Arrow.leftFunc.map f = f.left
-- CategoryTheory.Arrow.leftFunc_obj
@[simps!]
def leftFunc : Arrow C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C))
Goal: CategoryTheory.Arrow.leftFunc.obj X = X.left
-- CategoryTheory.Arrow.rightFunc_map
@[simps!]
def rightFunc : Arrow C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)} (f : X ⟶ Y),
  CategoryTheory.Arrow.rightFunc.map f = f.right
-- CategoryTheory.Arrow.rightFunc_obj
@[simps!]
def rightFunc : Arrow C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C))
Goal: CategoryTheory.Arrow.rightFunc.obj X = X.right
-- CategoryTheory.Arrow.leftToRight_app
@[simps]
def leftToRight : (leftFunc : Arrow C ⥤ C) ⟶ rightFunc 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C)
Goal: CategoryTheory.Arrow.leftToRight.app f = f.hom
-- CategoryTheory.Functor.mapArrow_map_right
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Arrow C} (f : X ⟶ Y), (F.mapArrow.map f).right = F.map f.right
-- CategoryTheory.Functor.mapArrow_map_left
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Arrow C} (f : X ⟶ Y), (F.mapArrow.map f).left = F.map f.left
-- CategoryTheory.Functor.mapArrow_obj_left
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (a : CategoryTheory.Arrow C)
Goal: (F.mapArrow.obj a).left = F.obj a.left
-- CategoryTheory.Functor.mapArrow_obj_hom
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (a : CategoryTheory.Arrow C)
Goal: (F.mapArrow.obj a).hom = F.map a.hom
-- CategoryTheory.Functor.mapArrow_obj_right
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (a : CategoryTheory.Arrow C)
Goal: (F.mapArrow.obj a).right = F.obj a.right
-- CategoryTheory.Functor.mapArrowFunctor_map_app_left
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : CategoryTheory.Functor C D} (τ : X ⟶ Y) (f : CategoryTheory.Arrow C),
  (((CategoryTheory.Functor.mapArrowFunctor C D).map τ).app f).left = τ.app f.left
-- CategoryTheory.Functor.mapArrowFunctor_map_app_right
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D]
Goal: ∀ {X Y : CategoryTheory.Functor C D} (τ : X ⟶ Y) (f : CategoryTheory.Arrow C),
  (((CategoryTheory.Functor.mapArrowFunctor C D).map τ).app f).right = τ.app f.right
-- CategoryTheory.Functor.mapArrowFunctor_obj
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow D) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D)
Goal: (CategoryTheory.Functor.mapArrowFunctor C D).obj F = F.mapArrow
-- CategoryTheory.prod.associator_obj
@[simps]
def associator : (C × D) × E ⥤ C × D × E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E] (X : (C × D) × E)
Goal: (CategoryTheory.prod.associator C D E).obj X = (X.1.1, X.1.2, X.2)
-- CategoryTheory.prod.associator_map
@[simps]
def associator : (C × D) × E ⥤ C × D × E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E]
Goal: ∀ (x x_1 : (C × D) × E) (f : x ⟶ x_1), (CategoryTheory.prod.associator C D E).map f = (f.1.1, f.1.2, f.2)
-- CategoryTheory.prod.inverseAssociator_obj
@[simps]
def inverseAssociator : C × D × E ⥤ (C × D) × E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E] (X : C × D × E)
Goal: (CategoryTheory.prod.inverseAssociator C D E).obj X = ((X.1, X.2.1), X.2.2)
-- CategoryTheory.prod.inverseAssociator_map
@[simps]
def inverseAssociator : C × D × E ⥤ (C × D) × E 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [CategoryTheory.Category.{v₂, u₂} D] (E : Type u₃) [CategoryTheory.Category.{v₃, u₃} E]
Goal: ∀ (x x_1 : C × D × E) (f : x ⟶ x_1), (CategoryTheory.prod.inverseAssociator C D E).map f = ((f.1, f.2.1), f.2.2)
-- CategoryTheory.Iso.app_inv
@[simps]
def app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
    F.obj X ≅ G.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) (X : C)
Goal: (α.app X).inv = α.inv.app X
-- CategoryTheory.Iso.app_hom
@[simps]
def app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
    F.obj X ≅ G.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) (X : C)
Goal: (α.app X).hom = α.hom.app X
-- CategoryTheory.Iso.hom_inv_id_app
@[reassoc (attr := simp)]
theorem hom_inv_id_app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
    α.hom.app X ≫ α.inv.app X = 𝟙 (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) (X : C)
Goal: α.hom.app X ≫ α.inv.app X = 𝟙 (F.obj X)
-- CategoryTheory.Iso.inv_hom_id_app
@[reassoc (attr := simp)]
theorem inv_hom_id_app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
    α.inv.app X ≫ α.hom.app X = 𝟙 (G.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) (X : C)
Goal: α.inv.app X ≫ α.hom.app X = 𝟙 (G.obj X)
-- CategoryTheory.NatIso.trans_app
@[simp]
theorem trans_app {F G H : C ⥤ D} (α : F ≅ G) (β : G ≅ H) (X : C) :
    (α ≪≫ β).app X = α.app X ≪≫ β.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G H : C ⥤ D} (α : F ≅ G) (β : G ≅ H) (X : C)
Goal: (α ≪≫ β).app X = α.app X ≪≫ β.app X
-- CategoryTheory.NatIso.app_hom
theorem app_hom {F G : C ⥤ D} (α : F ≅ G) (X : C) : (α.app X).hom = α.hom.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) (X : C)
Goal: (α.app X).hom = α.hom.app X
-- CategoryTheory.NatIso.app_inv
theorem app_inv {F G : C ⥤ D} (α : F ≅ G) (X : C) : (α.app X).inv = α.inv.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) (X : C)
Goal: (α.app X).inv = α.inv.app X
-- CategoryTheory.NatIso.cancel_natIso_hom_left
@[simp]
theorem cancel_natIso_hom_left {X : C} {Z : D} (g g' : G.obj X ⟶ Z) :
    α.hom.app X ≫ g = α.hom.app X ≫ g' ↔ g = g' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) {X : C} {Z : D} (g g' : G.obj X ⟶ Z)
Goal: α.hom.app X ≫ g = α.hom.app X ≫ g' ↔ g = g'
-- CategoryTheory.NatIso.cancel_natIso_inv_left
@[simp]
theorem cancel_natIso_inv_left {X : C} {Z : D} (g g' : F.obj X ⟶ Z) :
    α.inv.app X ≫ g = α.inv.app X ≫ g' ↔ g = g' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) {X : C} {Z : D} (g g' : F.obj X ⟶ Z)
Goal: α.inv.app X ≫ g = α.inv.app X ≫ g' ↔ g = g'
-- CategoryTheory.NatIso.cancel_natIso_hom_right
@[simp]
theorem cancel_natIso_hom_right {X : D} {Y : C} (f f' : X ⟶ F.obj Y) :
    f ≫ α.hom.app Y = f' ≫ α.hom.app Y ↔ f = f' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) {X : D} {Y : C} (f f' : X ⟶ F.obj Y)
Goal: f ≫ α.hom.app Y = f' ≫ α.hom.app Y ↔ f = f'
-- CategoryTheory.NatIso.cancel_natIso_inv_right
@[simp]
theorem cancel_natIso_inv_right {X : D} {Y : C} (f f' : X ⟶ G.obj Y) :
    f ≫ α.inv.app Y = f' ≫ α.inv.app Y ↔ f = f' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) {X : D} {Y : C} (f f' : X ⟶ G.obj Y)
Goal: f ≫ α.inv.app Y = f' ≫ α.inv.app Y ↔ f = f'
-- CategoryTheory.NatIso.cancel_natIso_hom_right_assoc
@[simp]
theorem cancel_natIso_hom_right_assoc {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ F.obj Y)
    (f' : W ⟶ X') (g' : X' ⟶ F.obj Y) :
    f ≫ g ≫ α.hom.app Y = f' ≫ g' ≫ α.hom.app Y ↔ f ≫ g = f' ≫ g' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G) {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ F.obj Y) (f' : W ⟶ X') (g' : X' ⟶ F.obj Y)
Goal: f ≫ g ≫ α.hom.app Y = f' ≫ g' ≫ α.hom.app Y ↔ f ≫ g = f' ≫ g'