File: Mathlib/CategoryTheory/Comma/Arrow.lean

full_name: CategoryTheory.Arrow
code: /-- The arrow category of `T` has as objects all morphisms in `T` and as morphisms commutative
     squares in `T`. -/
def Arrow 
goal: Type (max u v)

full_name: CategoryTheory.instCategoryArrow
code: instance : Category (Arrow T) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.Arrow T)

full_name: CategoryTheory.Arrow.inhabited
code: instance Arrow.inhabited [Inhabited T] : Inhabited (Arrow T) 
goal: Inhabited (CategoryTheory.Arrow T)

full_name: CategoryTheory.Arrow.hom_ext
code: @[ext]
lemma hom_ext {X Y : Arrow T} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) :
    f = g 
goal: f = g

full_name: CategoryTheory.Arrow.id_left
code: @[simp]
theorem id_left (f : Arrow T) : CommaMorphism.left (𝟙 f) = 𝟙 f.left 
goal: (CategoryTheory.CategoryStruct.id f).left = CategoryTheory.CategoryStruct.id f.left

full_name: CategoryTheory.Arrow.id_right
code: @[simp]
theorem id_right (f : Arrow T) : CommaMorphism.right (𝟙 f) = 𝟙 f.right 
goal: (CategoryTheory.CategoryStruct.id f).right = CategoryTheory.CategoryStruct.id f.right

full_name: CategoryTheory.Arrow.comp_left
code: @[simp, reassoc]
theorem comp_left {X Y Z : Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).left = f.left ≫ g.left 
goal: (CategoryTheory.CategoryStruct.comp f g).left = CategoryTheory.CategoryStruct.comp f.left g.left

full_name: CategoryTheory.Arrow.comp_right
code: @[simp, reassoc]
theorem comp_right {X Y Z : Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).right = f.right ≫ g.right 
goal: (CategoryTheory.CategoryStruct.comp f g).right = CategoryTheory.CategoryStruct.comp f.right g.right

full_name: CategoryTheory.Arrow.mk_right
code: /-- An object in the arrow category is simply a morphism in `T`. -/
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
goal: (CategoryTheory.Arrow.mk f).right = Y

full_name: CategoryTheory.Arrow.mk_left
code: /-- An object in the arrow category is simply a morphism in `T`. -/
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
goal: (CategoryTheory.Arrow.mk f).left = X

full_name: CategoryTheory.Arrow.mk_hom
code: /-- An object in the arrow category is simply a morphism in `T`. -/
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
goal: (CategoryTheory.Arrow.mk f).hom = f

full_name: CategoryTheory.Arrow.mk
code: /-- An object in the arrow category is simply a morphism in `T`. -/
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T 
goal: CategoryTheory.Arrow T

full_name: CategoryTheory.Arrow.mk_eq
code: @[simp]
theorem mk_eq (f : Arrow T) : Arrow.mk f.hom = f 
goal: CategoryTheory.Arrow.mk f.hom = f

full_name: CategoryTheory.Arrow.mk_injective
code: theorem mk_injective (A B : T) :
    Function.Injective (Arrow.mk : (A ⟶ B) → Arrow T) 
goal: Function.Injective CategoryTheory.Arrow.mk

full_name: CategoryTheory.Arrow.mk_inj
code: theorem mk_inj (A B : T) {f g : A ⟶ B} : Arrow.mk f = Arrow.mk g ↔ f = g 
goal: CategoryTheory.Arrow.mk f = CategoryTheory.Arrow.mk g ↔ f = g

full_name: CategoryTheory.Arrow.instCoeOutHom
code: instance {X Y : T} : CoeOut (X ⟶ Y) (Arrow T) 
goal: CoeOut (X ⟶ Y) (CategoryTheory.Arrow T)

full_name: CategoryTheory.Arrow.homMk_right
code: /-- A morphism in the arrow category is a commutative square connecting two objects of the arrow
    category. -/
@[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 
goal: (CategoryTheory.Arrow.homMk w).right = v

full_name: CategoryTheory.Arrow.homMk
code: /-- A morphism in the arrow category is a commutative square connecting two objects of the arrow
    category. -/
@[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 
goal: f ⟶ g

full_name: CategoryTheory.Arrow.homMk_left
code: /-- A morphism in the arrow category is a commutative square connecting two objects of the arrow
    category. -/
@[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 
goal: (CategoryTheory.Arrow.homMk w).left = u

full_name: CategoryTheory.Arrow.homMk'_left
code: /-- We can also build a morphism in the arrow category out of any commutative square in `T`. -/
@[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 
goal: (CategoryTheory.Arrow.homMk' w).left = u

full_name: CategoryTheory.Arrow.homMk'_right
code: /-- We can also build a morphism in the arrow category out of any commutative square in `T`. -/
@[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 
goal: (CategoryTheory.Arrow.homMk' w).right = v

full_name: CategoryTheory.Arrow.homMk'
code: /-- We can also build a morphism in the arrow category out of any commutative square in `T`. -/
@[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 
goal: CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g

full_name: CategoryTheory.Arrow.w
code: @[reassoc (attr := simp, nolint simpNF)]
theorem w {f g : Arrow T} (sq : f ⟶ g) : sq.left ≫ g.hom = f.hom ≫ sq.right 
goal: CategoryTheory.CategoryStruct.comp sq.left g.hom = CategoryTheory.CategoryStruct.comp f.hom sq.right

full_name: CategoryTheory.Arrow.w_mk_right
code: @[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 
goal: CategoryTheory.CategoryStruct.comp sq.left g = CategoryTheory.CategoryStruct.comp f.hom sq.right

full_name: CategoryTheory.Arrow.isIso_of_isIso_left_of_isIso_right
code: theorem isIso_of_isIso_left_of_isIso_right {f g : Arrow T} (ff : f ⟶ g) [IsIso ff.left]
    [IsIso ff.right] : IsIso ff 
goal: CategoryTheory.IsIso ff

full_name: CategoryTheory.Arrow.isoMk_inv_left
code: /-- Create an isomorphism between arrows,
by providing isomorphisms between the domains and codomains,
and a proof that the square commutes. -/
@[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 
goal: (CategoryTheory.Arrow.isoMk l r h).inv.left = l.inv

full_name: CategoryTheory.Arrow.isoMk_hom_left
code: /-- Create an isomorphism between arrows,
by providing isomorphisms between the domains and codomains,
and a proof that the square commutes. -/
@[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 
goal: (CategoryTheory.Arrow.isoMk l r h).hom.left = l.hom

full_name: CategoryTheory.Arrow.isoMk_hom_right
code: /-- Create an isomorphism between arrows,
by providing isomorphisms between the domains and codomains,
and a proof that the square commutes. -/
@[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 
goal: (CategoryTheory.Arrow.isoMk l r h).hom.right = r.hom

full_name: CategoryTheory.Arrow.isoMk
code: /-- Create an isomorphism between arrows,
by providing isomorphisms between the domains and codomains,
and a proof that the square commutes. -/
@[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 
goal: f ≅ g

full_name: CategoryTheory.Arrow.isoMk_inv_right
code: /-- Create an isomorphism between arrows,
by providing isomorphisms between the domains and codomains,
and a proof that the square commutes. -/
@[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 
goal: (CategoryTheory.Arrow.isoMk l r h).inv.right = r.inv

full_name: CategoryTheory.Arrow.isoMk'
code: /-- A variant of `Arrow.isoMk` that creates an iso between two `Arrow.mk`s with a better type
signature. -/
abbrev isoMk' {W X Y Z : T} (f : W ⟶ X) (g : Y ⟶ Z) (e₁ : W ≅ Y) (e₂ : X ≅ Z)
    (h : e₁.hom ≫ g = f ≫ e₂.hom := by aesop_cat) : Arrow.mk f ≅ Arrow.mk g 
goal: CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g

full_name: CategoryTheory.Arrow.hom.congr_left
code: theorem hom.congr_left {f g : Arrow T} {φ₁ φ₂ : f ⟶ g} (h : φ₁ = φ₂) : φ₁.left = φ₂.left 
goal: φ₁.left = φ₂.left

full_name: CategoryTheory.Arrow.hom.congr_right
code: @[simp]
theorem hom.congr_right {f g : Arrow T} {φ₁ φ₂ : f ⟶ g} (h : φ₁ = φ₂) : φ₁.right = φ₂.right 
goal: φ₁.right = φ₂.right

full_name: CategoryTheory.Arrow.iso_w
code: theorem iso_w {f g : Arrow T} (e : f ≅ g) : g.hom = e.inv.left ≫ f.hom ≫ e.hom.right 
goal: g.hom = CategoryTheory.CategoryStruct.comp e.inv.left (CategoryTheory.CategoryStruct.comp f.hom e.hom.right)

full_name: CategoryTheory.Arrow.iso_w'
code: 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 
goal: g = CategoryTheory.CategoryStruct.comp e.inv.left (CategoryTheory.CategoryStruct.comp f e.hom.right)

full_name: CategoryTheory.Arrow.isIso_left
code: instance isIso_left [IsIso sq] : IsIso sq.left 
goal: CategoryTheory.IsIso sq.left

full_name: CategoryTheory.Arrow.isIso_right
code: instance isIso_right [IsIso sq] : IsIso sq.right 
goal: CategoryTheory.IsIso sq.right

full_name: CategoryTheory.Arrow.inv_left
code: @[simp]
theorem inv_left [IsIso sq] : (inv sq).left = inv sq.left 
goal: (CategoryTheory.inv sq).left = CategoryTheory.inv sq.left

full_name: CategoryTheory.Arrow.inv_right
code: @[simp]
theorem inv_right [IsIso sq] : (inv sq).right = inv sq.right 
goal: (CategoryTheory.inv sq).right = CategoryTheory.inv sq.right

full_name: CategoryTheory.Arrow.left_hom_inv_right
code: theorem left_hom_inv_right [IsIso sq] : sq.left ≫ g.hom ≫ inv sq.right = f.hom 
goal: CategoryTheory.CategoryStruct.comp sq.left (CategoryTheory.CategoryStruct.comp g.hom (CategoryTheory.inv sq.right)) =
  f.hom

full_name: CategoryTheory.Arrow.inv_left_hom_right
code: theorem inv_left_hom_right [IsIso sq] : inv sq.left ≫ f.hom ≫ sq.right = g.hom 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.inv sq.left) (CategoryTheory.CategoryStruct.comp f.hom sq.right) =
  g.hom

full_name: CategoryTheory.Arrow.mono_left
code: instance mono_left [Mono sq] : Mono sq.left 
goal: CategoryTheory.Mono sq.left

full_name: CategoryTheory.Arrow.epi_right
code: instance epi_right [Epi sq] : Epi sq.right 
goal: CategoryTheory.Epi sq.right

full_name: CategoryTheory.Arrow.hom_inv_id_left
code: @[reassoc (attr := simp)]
lemma hom_inv_id_left (e : f ≅ g) : e.hom.left ≫ e.inv.left = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp e.hom.left e.inv.left = CategoryTheory.CategoryStruct.id f.left

full_name: CategoryTheory.Arrow.inv_hom_id_left
code: @[reassoc (attr := simp)]
lemma inv_hom_id_left (e : f ≅ g) : e.inv.left ≫ e.hom.left = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp e.inv.left e.hom.left = CategoryTheory.CategoryStruct.id g.left

full_name: CategoryTheory.Arrow.hom_inv_id_right
code: @[reassoc (attr := simp)]
lemma hom_inv_id_right (e : f ≅ g) : e.hom.right ≫ e.inv.right = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp e.hom.right e.inv.right = CategoryTheory.CategoryStruct.id f.right

full_name: CategoryTheory.Arrow.inv_hom_id_right
code: @[reassoc (attr := simp)]
lemma inv_hom_id_right (e : f ≅ g) : e.inv.right ≫ e.hom.right = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp e.inv.right e.hom.right = CategoryTheory.CategoryStruct.id g.right

full_name: CategoryTheory.Arrow.square_to_iso_invert
code: /-- Given a square from an arrow `i` to an isomorphism `p`, express the source part of `sq`
in terms of the inverse of `p`. -/
@[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 
goal: CategoryTheory.CategoryStruct.comp i.hom (CategoryTheory.CategoryStruct.comp sq.right p.inv) = sq.left

full_name: CategoryTheory.Arrow.square_from_iso_invert
code: /-- Given a square from an isomorphism `i` to an arrow `p`, express the target part of `sq`
in terms of the inverse of `i`. -/
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 
goal: CategoryTheory.CategoryStruct.comp i.inv (CategoryTheory.CategoryStruct.comp sq.left p.hom) = sq.right

full_name: CategoryTheory.Arrow.squareToSnd_right
code: /-- A helper construction: given a square between `i` and `f ≫ g`, produce a square between
`i` and `g`, whose top leg uses `f`:
A  → X
     ↓f
↓i   Y             --> A → Y
     ↓g                ↓i  ↓g
B  → Z                 B → Z
 -/
@[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 
goal: (CategoryTheory.Arrow.squareToSnd sq).right = sq.right

full_name: CategoryTheory.Arrow.squareToSnd
code: /-- A helper construction: given a square between `i` and `f ≫ g`, produce a square between
`i` and `g`, whose top leg uses `f`:
A  → X
     ↓f
↓i   Y             --> A → Y
     ↓g                ↓i  ↓g
B  → Z                 B → Z
 -/
@[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 
goal: i ⟶ CategoryTheory.Arrow.mk g

full_name: CategoryTheory.Arrow.squareToSnd_left
code: /-- A helper construction: given a square between `i` and `f ≫ g`, produce a square between
`i` and `g`, whose top leg uses `f`:
A  → X
     ↓f
↓i   Y             --> A → Y
     ↓g                ↓i  ↓g
B  → Z                 B → Z
 -/
@[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 
goal: (CategoryTheory.Arrow.squareToSnd sq).left = CategoryTheory.CategoryStruct.comp sq.left f

full_name: CategoryTheory.Arrow.leftFunc_map
code: /-- The functor sending an arrow to its source. -/
@[simps!]
def leftFunc : Arrow C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)} (f : X ⟶ Y),
  CategoryTheory.Arrow.leftFunc.map f = f.left

full_name: CategoryTheory.Arrow.leftFunc
code: /-- The functor sending an arrow to its source. -/
@[simps!]
def leftFunc : Arrow C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Arrow C) C

full_name: CategoryTheory.Arrow.leftFunc_obj
code: /-- The functor sending an arrow to its source. -/
@[simps!]
def leftFunc : Arrow C ⥤ C 
goal: CategoryTheory.Arrow.leftFunc.obj X = X.left

full_name: CategoryTheory.Arrow.rightFunc
code: /-- The functor sending an arrow to its target. -/
@[simps!]
def rightFunc : Arrow C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Arrow C) C

full_name: CategoryTheory.Arrow.rightFunc_map
code: /-- The functor sending an arrow to its target. -/
@[simps!]
def rightFunc : Arrow C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)} (f : X ⟶ Y),
  CategoryTheory.Arrow.rightFunc.map f = f.right

full_name: CategoryTheory.Arrow.rightFunc_obj
code: /-- The functor sending an arrow to its target. -/
@[simps!]
def rightFunc : Arrow C ⥤ C 
goal: CategoryTheory.Arrow.rightFunc.obj X = X.right

full_name: CategoryTheory.Arrow.leftToRight_app
code: /-- The natural transformation from `leftFunc` to `rightFunc`, given by the arrow itself. -/
@[simps]
def leftToRight : (leftFunc : Arrow C ⥤ C) ⟶ rightFunc 
goal: CategoryTheory.Arrow.leftToRight.app f = f.hom

full_name: CategoryTheory.Arrow.leftToRight
code: /-- The natural transformation from `leftFunc` to `rightFunc`, given by the arrow itself. -/
@[simps]
def leftToRight : (leftFunc : Arrow C ⥤ C) ⟶ rightFunc 
goal: CategoryTheory.Arrow.leftFunc ⟶ CategoryTheory.Arrow.rightFunc

full_name: CategoryTheory.Functor.mapArrow_map_right
code: /-- A functor `C ⥤ D` induces a functor between the corresponding arrow categories. -/
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
goal: ∀ {X Y : CategoryTheory.Arrow C} (f : X ⟶ Y), (F.mapArrow.map f).right = F.map f.right

full_name: CategoryTheory.Functor.mapArrow_map_left
code: /-- A functor `C ⥤ D` induces a functor between the corresponding arrow categories. -/
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
goal: ∀ {X Y : CategoryTheory.Arrow C} (f : X ⟶ Y), (F.mapArrow.map f).left = F.map f.left

full_name: CategoryTheory.Functor.mapArrow_obj_left
code: /-- A functor `C ⥤ D` induces a functor between the corresponding arrow categories. -/
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
goal: (F.mapArrow.obj a).left = F.obj a.left

full_name: CategoryTheory.Functor.mapArrow
code: /-- A functor `C ⥤ D` induces a functor between the corresponding arrow categories. -/
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
goal: CategoryTheory.Functor (CategoryTheory.Arrow C) (CategoryTheory.Arrow D)

full_name: CategoryTheory.Functor.mapArrow_obj_hom
code: /-- A functor `C ⥤ D` induces a functor between the corresponding arrow categories. -/
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
goal: (F.mapArrow.obj a).hom = F.map a.hom

full_name: CategoryTheory.Functor.mapArrow_obj_right
code: /-- A functor `C ⥤ D` induces a functor between the corresponding arrow categories. -/
@[simps]
def mapArrow (F : C ⥤ D) : Arrow C ⥤ Arrow D 
goal: (F.mapArrow.obj a).right = F.obj a.right

full_name: CategoryTheory.Functor.mapArrowFunctor_map_app_left
code: /-- The functor `(C ⥤ D) ⥤ (Arrow C ⥤ Arrow D)` which sends
a functor `F : C ⥤ D` to `F.mapArrow`. -/
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow 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

full_name: CategoryTheory.Functor.mapArrowFunctor_map_app_right
code: /-- The functor `(C ⥤ D) ⥤ (Arrow C ⥤ Arrow D)` which sends
a functor `F : C ⥤ D` to `F.mapArrow`. -/
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow 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

full_name: CategoryTheory.Functor.mapArrowFunctor_obj
code: /-- The functor `(C ⥤ D) ⥤ (Arrow C ⥤ Arrow D)` which sends
a functor `F : C ⥤ D` to `F.mapArrow`. -/
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow D) 
goal: (CategoryTheory.Functor.mapArrowFunctor C D).obj F = F.mapArrow

full_name: CategoryTheory.Functor.mapArrowFunctor
code: /-- The functor `(C ⥤ D) ⥤ (Arrow C ⥤ Arrow D)` which sends
a functor `F : C ⥤ D` to `F.mapArrow`. -/
@[simps]
def mapArrowFunctor : (C ⥤ D) ⥤ (Arrow C ⥤ Arrow D) 
goal: CategoryTheory.Functor (CategoryTheory.Functor C D)
  (CategoryTheory.Functor (CategoryTheory.Arrow C) (CategoryTheory.Arrow D))

full_name: CategoryTheory.Functor.mapArrowEquivalence
code: /-- The equivalence of categories `Arrow C ≌ Arrow D` induced by an equivalence `C ≌ D`. -/
def mapArrowEquivalence (e : C ≌ D) : Arrow C ≌ Arrow D 
goal: CategoryTheory.Arrow C ≌ CategoryTheory.Arrow D

full_name: CategoryTheory.Functor.isEquivalence_mapArrow
code: instance isEquivalence_mapArrow (F : C ⥤ D) [IsEquivalence F] :
    IsEquivalence F.mapArrow 
goal: F.mapArrow.IsEquivalence

full_name: CategoryTheory.Arrow.isoOfNatIso
code: /-- The images of `f : Arrow C` by two isomorphic functors `F : C ⥤ D` are
isomorphic arrows in `D`. -/
def Arrow.isoOfNatIso {C D : Type*} [Category C] [Category D] {F G : C ⥤ D} (e : F ≅ G)
    (f : Arrow C) : F.mapArrow.obj f ≅ G.mapArrow.obj f 
goal: F.mapArrow.obj f ≅ G.mapArrow.obj f