Theorem: CategoryTheory.Paths.ext_functor
File: Mathlib/CategoryTheory/PathCategory.lean

tactic: fapply Functor.ext
state_before: V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
⊢ F = G

tactic: intro X
state_before: case h_obj
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
⊢ ∀ (X : Paths V), F.obj X = G.obj X

tactic: rw [h_obj]
state_before: case h_obj
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
X : Paths V
⊢ F.obj X = G.obj X

tactic: intro X Y f
state_before: case h_map
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
⊢ autoParam
    (∀ (X Y : Paths V) (f : X ⟶ Y),
      F.map f = eqToHom (_ : F.obj X = G.obj X) ≫ G.map f ≫ eqToHom (_ : G.obj Y = F.obj Y))
    _auto✝

tactic: induction' f with Y' Z' g e ih
state_before: case h_map
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
X Y : Paths V
f : X ⟶ Y
⊢ F.map f = eqToHom (_ : F.obj X = G.obj X) ≫ G.map f ≫ eqToHom (_ : G.obj Y = F.obj Y)

tactic: erw [F.map_id, G.map_id, Category.id_comp, eqToHom_trans, eqToHom_refl]
state_before: case h_map.nil
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
X Y : Paths V
⊢ F.map Quiver.Path.nil = eqToHom (_ : F.obj X = G.obj X) ≫ G.map Quiver.Path.nil ≫ eqToHom (_ : G.obj X = F.obj X)

tactic: erw [F.map_comp g (Quiver.Hom.toPath e), G.map_comp g (Quiver.Hom.toPath e), ih, h]
state_before: case h_map.cons
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
X Y Y' Z' : Paths V
g : Quiver.Path X Y'
e : Y' ⟶ Z'
ih : F.map g = eqToHom (_ : F.obj X = G.obj X) ≫ G.map g ≫ eqToHom (_ : G.obj Y' = F.obj Y')
⊢ F.map (Quiver.Path.cons g e) =
    eqToHom (_ : F.obj X = G.obj X) ≫ G.map (Quiver.Path.cons g e) ≫ eqToHom (_ : G.obj Z' = F.obj Z')

tactic: simp only [Category.id_comp, eqToHom_refl, eqToHom_trans_assoc, Category.assoc]
state_before: case h_map.cons
V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
F G : Paths V ⥤ C
h_obj : F.obj = G.obj
h :
  ∀ (a b : V) (e : a ⟶ b),
    F.map (Quiver.Hom.toPath e) =
      eqToHom (_ : F.obj a = G.obj a) ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj b = F.obj b)
X Y Y' Z' : Paths V
g : Quiver.Path X Y'
e : Y' ⟶ Z'
ih : F.map g = eqToHom (_ : F.obj X = G.obj X) ≫ G.map g ≫ eqToHom (_ : G.obj Y' = F.obj Y')
⊢ (eqToHom (_ : F.obj X = G.obj X) ≫ G.map g ≫ eqToHom (_ : G.obj Y' = F.obj Y')) ≫
      eqToHom (_ : F.obj Y' = G.obj Y') ≫ G.map (Quiver.Hom.toPath e) ≫ eqToHom (_ : G.obj Z' = F.obj Z') =
    eqToHom (_ : F.obj X = G.obj X) ≫ (G.map g ≫ G.map (Quiver.Hom.toPath e)) ≫ eqToHom (_ : G.obj Z' = F.obj Z')