Theorem: CategoryTheory.FreeBicategory.normalizeAux_congr
File: Mathlib/CategoryTheory/Bicategory/Coherence.lean

tactic: rcases η with ⟨η'⟩
state_before: B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
⊢ normalizeAux p f = normalizeAux p g
state_after: case mk
B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
η' : Hom₂ f g
⊢ normalizeAux p f = normalizeAux p g

tactic: apply @congr_fun _ _ fun p => normalizeAux p f
state_before: case mk
B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
η' : Hom₂ f g
⊢ normalizeAux p f = normalizeAux p g
state_after: case mk.h
B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
η' : Hom₂ f g
⊢ (fun p => normalizeAux p f) = fun p => normalizeAux p g

tactic: clear p η
state_before: case mk.h
B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
η' : Hom₂ f g
⊢ (fun p => normalizeAux p f) = fun p => normalizeAux p g
state_after: case mk.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
η' : Hom₂ f g
⊢ (fun p => normalizeAux p f) = fun p => normalizeAux p g

tactic: induction η' with
| vcomp _ _ _ _ => apply Eq.trans <;> assumption
| whisker_left _ _ ih => funext; apply congr_fun ih
| whisker_right _ _ ih => funext; apply congr_arg₂ _ (congr_fun ih _) rfl
| _ => funext; rfl
state_before: case mk.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
η' : Hom₂ f g
⊢ (fun p => normalizeAux p f) = fun p => normalizeAux p g
state_after: no goals

tactic: apply Eq.trans <;> assumption
state_before: case mk.h.vcomp
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ g✝ h✝ : a✝ ⟶ b✝
η✝ : Hom₂ f✝ g✝
θ✝ : Hom₂ g✝ h✝
η_ih✝ : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
θ_ih✝ : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
⊢ (fun p => normalizeAux p f✝) = fun p => normalizeAux p h✝
state_after: no goals

tactic: funext
state_before: case mk.h.whisker_left
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : Hom₂ g✝ h✝
ih : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
⊢ (fun p => normalizeAux p (f✝ ≫ g✝)) = fun p => normalizeAux p (f✝ ≫ h✝)
state_after: case mk.h.whisker_left.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : Hom₂ g✝ h✝
ih : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
x✝ : Path a a✝
⊢ normalizeAux x✝ (f✝ ≫ g✝) = normalizeAux x✝ (f✝ ≫ h✝)

tactic: apply congr_fun ih
state_before: case mk.h.whisker_left.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : Hom₂ g✝ h✝
ih : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
x✝ : Path a a✝
⊢ normalizeAux x✝ (f✝ ≫ g✝) = normalizeAux x✝ (f✝ ≫ h✝)
state_after: no goals

tactic: funext
state_before: case mk.h.whisker_right
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
h✝ : b✝ ⟶ c✝
η✝ : Hom₂ f✝ g✝
ih : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
⊢ (fun p => normalizeAux p (Hom.comp f✝ h✝)) = fun p => normalizeAux p (Hom.comp g✝ h✝)
state_after: case mk.h.whisker_right.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
h✝ : b✝ ⟶ c✝
η✝ : Hom₂ f✝ g✝
ih : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
x✝ : Path a a✝
⊢ normalizeAux x✝ (Hom.comp f✝ h✝) = normalizeAux x✝ (Hom.comp g✝ h✝)

tactic: apply congr_arg₂ _ (congr_fun ih _) rfl
state_before: case mk.h.whisker_right.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
h✝ : b✝ ⟶ c✝
η✝ : Hom₂ f✝ g✝
ih : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
x✝ : Path a a✝
⊢ normalizeAux x✝ (Hom.comp f✝ h✝) = normalizeAux x✝ (Hom.comp g✝ h✝)
state_after: no goals

tactic: funext
state_before: case mk.h.left_unitor_inv
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
⊢ (fun p => normalizeAux p f✝) = fun p => normalizeAux p (𝟙 a✝ ≫ f✝)
state_after: case mk.h.left_unitor_inv.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
x✝ : Path a a✝
⊢ normalizeAux x✝ f✝ = normalizeAux x✝ (𝟙 a✝ ≫ f✝)

tactic: rfl
state_before: case mk.h.left_unitor_inv.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
x✝ : Path a a✝
⊢ normalizeAux x✝ f✝ = normalizeAux x✝ (𝟙 a✝ ≫ f✝)
state_after: no goals