Theorem: CategoryTheory.Equivalence.unit_inverse_comp
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: rw [← id_comp (e.inverse.map _), ← map_id e.inverse, ← counitInv_functor_comp, map_comp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app (e.inverse.obj Y) ≫ e.inverse.map ((counit e).app Y) = 𝟙 (e.inverse.obj Y)

tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app (e.inverse.obj Y) ≫
      (e.inverse.map ((counitInv e).app (e.functor.obj (e.inverse.obj Y))) ≫
          e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
        e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: rw [← Iso.hom_inv_id_assoc (e.unitIso.app _) (e.inverse.map (e.functor.map _)), app_hom, app_inv]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app (e.inverse.obj Y) ≫
      (e.inverse.map ((counitInv e).app (e.functor.obj (e.inverse.obj Y))) ≫
          e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
        e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 2 3 => erw [e.unit.naturality]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app (e.inverse.obj Y) ≫
      (e.inverse.map ((counitInv e).app (e.functor.obj (e.inverse.obj Y))) ≫
          e.unitIso.hom.app
              (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y))))) ≫
            e.unitIso.inv.app
                (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y))))) ≫
              e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
        e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 1 2 => erw [e.unit.naturality]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app (e.inverse.obj Y) ≫
      ((((unit e).app (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj Y))) ≫
              (e.functor ⋙ e.inverse).map
                (e.inverse.toPrefunctor.2 ((counitInv e).app (e.functor.obj (e.inverse.obj Y))))) ≫
            e.unitIso.inv.app
              (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) ≫
          e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
        e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 4 4 =>
  rw [← Iso.hom_inv_id_assoc (e.inverse.mapIso (e.counitIso.app _)) (e.unitInv.app _)]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (((((unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫ (e.functor ⋙ e.inverse).map ((unit e).1 (e.inverse.obj Y))) ≫
            (e.functor ⋙ e.inverse).map
              (e.inverse.toPrefunctor.2 ((counitInv e).app (e.functor.obj (e.inverse.obj Y))))) ≫
          e.unitIso.inv.app
            (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) ≫
        e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
      e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 3 4 =>
  erw [← map_comp e.inverse, e.counit.naturality]
  erw [(e.counitIso.app _).hom_inv_id, map_id]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      (e.functor ⋙ e.inverse).map ((unit e).1 (e.inverse.obj Y)) ≫
        (e.functor ⋙ e.inverse).map (e.inverse.toPrefunctor.2 ((counitInv e).app (e.functor.obj (e.inverse.obj Y)))) ≫
          (((e.inverse.mapIso (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).hom ≫
                (e.inverse.mapIso
                      (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv ≫
                  (unitInv e).app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) ≫
              e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
            e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: erw [id_comp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      (e.functor ⋙ e.inverse).map ((unit e).1 (e.inverse.obj Y)) ≫
        (((𝟙 (e.inverse.obj (e.functor.obj (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj Y))))) ≫
                (e.inverse.mapIso
                    (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv) ≫
              (unitInv e).app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) ≫
            e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
          e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 2 3 => erw [← map_comp e.inverse, e.counitIso.inv.naturality, map_comp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      (e.functor ⋙ e.inverse).map ((unit e).1 (e.inverse.obj Y)) ≫
        (((e.inverse.mapIso (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv ≫
              (unitInv e).app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) ≫
            e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
          e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 3 4 => erw [e.unitInv.naturality]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      (((e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
              e.inverse.map ((e.inverse ⋙ e.functor).map (e.functor.toPrefunctor.2 ((unit e).1 (e.inverse.obj Y))))) ≫
            (unitInv e).app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) ≫
          e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
        e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 4 5 => erw [← map_comp (e.functor ⋙ e.inverse), (e.unitIso.app _).hom_inv_id, map_id]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
        (((unitInv e).app (e.inverse.obj (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
              (𝟭 C).map (e.inverse.map (e.functor.toPrefunctor.2 ((unit e).1 (e.inverse.obj Y))))) ≫
            e.inverse.map (e.functor.map ((unitInv e).app (e.inverse.obj Y)))) ≫
          e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: erw [id_comp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
        (unitInv e).app (e.inverse.obj (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
          𝟙 ((e.functor ⋙ e.inverse).obj ((𝟭 C).obj (e.inverse.obj Y))) ≫ e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 3 4 => erw [← e.unitInv.naturality]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
        (unitInv e).app (e.inverse.obj (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
          e.inverse.map ((counit e).app Y) =
    𝟙 (e.inverse.obj Y)

tactic: slice_lhs 2 3 =>
  erw [← map_comp e.inverse, ← e.counitIso.inv.naturality, (e.counitIso.app _).hom_inv_id,
    map_id]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((𝟭 C).obj (e.inverse.obj Y)))) ≫
        (e.functor ⋙ e.inverse).map (e.inverse.toPrefunctor.2 ((counit e).app Y)) ≫
          (unitInv e).app (e.inverse.toPrefunctor.1 Y) =
    𝟙 (e.inverse.obj Y)

tactic: erw [id_comp, (e.unitIso.app _).hom_inv_id]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ (unit e).app ((𝟭 C).obj (e.inverse.obj Y)) ≫
      𝟙 (e.inverse.obj (e.functor.obj ((𝟭 C).obj (e.inverse.obj Y)))) ≫ (unitInv e).app (e.inverse.toPrefunctor.1 Y) =
    𝟙 (e.inverse.obj Y)

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
Y : D
⊢ 𝟙 ((𝟭 C).obj ((𝟭 C).obj (e.inverse.obj Y))) = 𝟙 (e.inverse.obj Y)