Theorem: CategoryTheory.CategoryOfElements.from_toCostructuredArrow_eq
File: Mathlib/CategoryTheory/Elements.lean

tactic: refine' Functor.ext _ _
state_before: C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
⊢ (toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F = 𝟭 (Functor.Elements F)

tactic: intro X
state_before: case refine'_1
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
⊢ ∀ (X : Functor.Elements F),
    ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 (Functor.Elements F)).obj X

tactic: exact Functor.Elements.ext _ _ rfl (by simp [yonedaEquiv])
state_before: case refine'_1
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X : Functor.Elements F
⊢ ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 (Functor.Elements F)).obj X

tactic: simp [yonedaEquiv]
state_before: C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X : Functor.Elements F
⊢ F.map
      (eqToHom
        (_ :
          (((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X).fst =
            (((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X).fst))
      (((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X).snd =
    ((𝟭 (Functor.Elements F)).obj X).snd

tactic: intro X Y f
state_before: case refine'_2
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
⊢ ∀ (X Y : Functor.Elements F) (f : X ⟶ Y),
    ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).map f =
      eqToHom (_ : ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 (Functor.Elements F)).obj X) ≫
        (𝟭 (Functor.Elements F)).map f ≫
          eqToHom
            (_ : (𝟭 (Functor.Elements F)).obj Y = ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj Y)

tactic: have : ∀ {a b : F.Elements} (H : a = b),
    (eqToHom H).1 = eqToHom (show a.fst = b.fst by cases H; rfl) := by
  rintro _ _ rfl
  simp
state_before: case refine'_2
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
⊢ ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).map f =
    eqToHom (_ : ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 (Functor.Elements F)).obj X) ≫
      (𝟭 (Functor.Elements F)).map f ≫
        eqToHom (_ : (𝟭 (Functor.Elements F)).obj Y = ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj Y)

tactic: ext
state_before: case refine'_2
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
this : ∀ {a b : Functor.Elements F} (H : a = b), ↑(eqToHom H) = eqToHom (_ : a.fst = b.fst)
⊢ ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).map f =
    eqToHom (_ : ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 (Functor.Elements F)).obj X) ≫
      (𝟭 (Functor.Elements F)).map f ≫
        eqToHom (_ : (𝟭 (Functor.Elements F)).obj Y = ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj Y)

tactic: simp [this]
state_before: case refine'_2.w
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
this : ∀ {a b : Functor.Elements F} (H : a = b), ↑(eqToHom H) = eqToHom (_ : a.fst = b.fst)
⊢ ↑(((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).map f) =
    ↑(eqToHom (_ : ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 (Functor.Elements F)).obj X) ≫
        (𝟭 (Functor.Elements F)).map f ≫
          eqToHom
            (_ : (𝟭 (Functor.Elements F)).obj Y = ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj Y))

tactic: cases H
state_before: C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
a b : Functor.Elements F
H : a = b
⊢ a.fst = b.fst

tactic: rfl
state_before: case refl
C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
a : Functor.Elements F
⊢ a.fst = a.fst

tactic: rintro _ _ rfl
state_before: C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
⊢ ∀ {a b : Functor.Elements F} (H : a = b), ↑(eqToHom H) = eqToHom (_ : a.fst = b.fst)

tactic: simp
state_before: C : Type u
inst✝ : Category C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
X Y : Functor.Elements F
f : X ⟶ Y
a✝ : Functor.Elements F
⊢ ↑(eqToHom (_ : a✝ = a✝)) = eqToHom (_ : a✝.fst = a✝.fst)