-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
theorem ext {F F' : MonoFactorisation f} (hI : F.I = F'.I)
    (hm : F.m = eqToHom hI ≫ F'.m) : F = F'

Proof state:
case mk.mk.refl
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ mk I✝ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Tactic:
congr

Result:
case mk.mk.refl.e_e
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ e✝¹ = e✝

Proof state:
case mk.mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝¹ : C
Fm : I✝¹ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝¹
Ffac : e✝¹ ≫ Fm = f
I✝ : C
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hI : (mk I✝¹ Fm e✝¹ Ffac).I = (mk I✝ Fm' e✝ Ffac').I
hm : (mk I✝¹ Fm e✝¹ Ffac).m = eqToHom hI ≫ (mk I✝ Fm' e✝ Ffac').m
⊢ mk I✝¹ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Tactic:
cases hI

Result:
case mk.mk.refl
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : (mk I✝ Fm e✝¹ Ffac).m = eqToHom ⋯ ≫ (mk I✝ Fm' e✝ Ffac').m
⊢ mk I✝ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Proof state:
case mk.mk.refl
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : (mk I✝ Fm e✝¹ Ffac).m = eqToHom ⋯ ≫ (mk I✝ Fm' e✝ Ffac').m
⊢ mk I✝ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Tactic:
simp only [eqToHom_refl, Category.id_comp] at hm

Result:
case mk.mk.refl
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ mk I✝ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Proof state:
case mk.mk.refl
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : (mk I✝ Fm e✝¹ Ffac).m = eqToHom ⋯ ≫ (mk I✝ Fm' e✝ Ffac').m
⊢ mk I✝ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Tactic:
simp? at hm says simp only [eqToHom_refl, Category.id_comp] at hm

Result:
case mk.mk.refl
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ mk I✝ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Proof state:
case mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F' : MonoFactorisation f
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝ : Mono Fm
e✝ : X ⟶ I✝
Ffac : e✝ ≫ Fm = f
hI : (mk I✝ Fm e✝ Ffac).I = F'.I
hm : (mk I✝ Fm e✝ Ffac).m = eqToHom hI ≫ F'.m
⊢ mk I✝ Fm e✝ Ffac = F'

Tactic:
obtain ⟨_, Fm', _, Ffac'⟩ := F'

Result:
case mk.mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝¹ : C
Fm : I✝¹ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝¹
Ffac : e✝¹ ≫ Fm = f
I✝ : C
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hI : (mk I✝¹ Fm e✝¹ Ffac).I = (mk I✝ Fm' e✝ Ffac').I
hm : (mk I✝¹ Fm e✝¹ Ffac).m = eqToHom hI ≫ (mk I✝ Fm' e✝ Ffac').m
⊢ mk I✝¹ Fm e✝¹ Ffac = mk I✝ Fm' e✝ Ffac'

Proof state:
case mk.mk.refl.e_e
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ e✝¹ = e✝

Tactic:
apply (cancel_mono Fm).1

Result:
case mk.mk.refl.e_e
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ e✝¹ ≫ Fm = e✝ ≫ Fm

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hI : F.I = F'.I
hm : F.m = eqToHom hI ≫ F'.m
⊢ F = F'

Tactic:
obtain ⟨_, Fm, _, Ffac⟩ := F

Result:
case mk
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F' : MonoFactorisation f
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝ : Mono Fm
e✝ : X ⟶ I✝
Ffac : e✝ ≫ Fm = f
hI : (mk I✝ Fm e✝ Ffac).I = F'.I
hm : (mk I✝ Fm e✝ Ffac).m = eqToHom hI ≫ F'.m
⊢ mk I✝ Fm e✝ Ffac = F'

Proof state:
case mk.mk.refl.e_e
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
I✝ : C
Fm : I✝ ⟶ Y
m_mono✝¹ : Mono Fm
e✝¹ : X ⟶ I✝
Ffac : e✝¹ ≫ Fm = f
Fm' : I✝ ⟶ Y
m_mono✝ : Mono Fm'
e✝ : X ⟶ I✝
Ffac' : e✝ ≫ Fm' = f
hm : Fm = Fm'
⊢ e✝¹ ≫ Fm = e✝ ≫ Fm

Tactic:
rw [Ffac, hm, Ffac']

Result:
no goals