l3lab/ntp-mathlib huggingface dataset:
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        

Proof state:
case f.α_hom.w.h
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ ((tensorFunc C).map ⟦Hom.α_hom X₁ X₂ X₃⟧ ≫ (normalizeIsoAux C (tensor X₁ (tensor X₂ X₃))).hom).app n =
    ((normalizeIsoAux C (tensor (tensor X₁ X₂) X₃)).hom ≫ (normalize' C).map ⟦Hom.α_hom X₁ X₂ X₃⟧).app n

Next tactic:
dsimp
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        

Proof state:
case f.α_hom.w.h
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ ((Discrete.natTrans fun n => 𝟙 (inclusionObj n.as) ⊗ ⟦Hom.α_hom X₁ X₂ X₃⟧) ≫
          (NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) X₁ (X₂ ⊗ X₃)).symm ≪≫
                (normalizeIsoApp C X₁ x ⊗ Iso.refl (X₂ ⊗ X₃)) ≪≫
                  (α_ (inclusionObj (normalizeObj X₁ x.as).as) X₂ X₃).symm ≪≫
                    (normalizeIsoApp C X₂ (normalizeObj X₁ x.as) ⊗ Iso.refl X₃) ≪≫
                      normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ x.as).as)).hom).app
      n =
    ((NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) (X₁ ⊗ X₂) X₃).symm ≪≫
                ((α_ (inclusionObj x.as) X₁ X₂).symm ≪≫
                      (normalizeIsoApp C X₁ x ⊗ Iso.refl X₂) ≪≫ normalizeIsoApp C X₂ (normalizeObj X₁ x.as) ⊗
                    Iso.refl X₃) ≪≫
                  normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ x.as).as)).hom ≫
          ((whiskeringRight (Discrete (NormalMonoidalObject C)) (Discrete (NormalMonoidalObject C)) (F C)).obj
                (Discrete.functor inclusionObj)).map
            (Discrete.natTrans fun x =>
              𝟙 ((Discrete.functor fun x => normalizeObj X₃ (normalizeObj X₂ (normalizeObj X₁ x).as).as).obj x))).app
      n

Next tactic:
rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        

Proof state:
case f.α_hom.w.h
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (Discrete.natTrans fun n => 𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).hom).app n ≫
      (NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) X₁ (X₂ ⊗ X₃)).symm ≪≫
                (normalizeIsoApp C X₁ x ⊗ Iso.refl (X₂ ⊗ X₃)) ≪≫
                  (α_ (inclusionObj (normalizeObj X₁ x.as).as) X₂ X₃).symm ≪≫
                    (normalizeIsoApp C X₂ (normalizeObj X₁ x.as) ⊗ Iso.refl X₃) ≪≫
                      normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ x.as).as)).hom.app
        n =
    (NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) (X₁ ⊗ X₂) X₃).symm ≪≫
                ((α_ (inclusionObj x.as) X₁ X₂).symm ≪≫
                      (normalizeIsoApp C X₁ x ⊗ Iso.refl X₂) ≪≫ normalizeIsoApp C X₂ (normalizeObj X₁ x.as) ⊗
                    Iso.refl X₃) ≪≫
                  normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ x.as).as)).hom.app
        n ≫
      (((whiskeringRight (Discrete (NormalMonoidalObject C)) (Discrete (NormalMonoidalObject C)) (F C)).obj
                (Discrete.functor inclusionObj)).map
            (Discrete.natTrans fun x =>
              𝟙 ((Discrete.functor fun x => normalizeObj X₃ (normalizeObj X₂ (normalizeObj X₁ x).as).as).obj x))).app
        n

Next tactic:
dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        

Proof state:
case f.α_hom.w.h
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).hom) ≫
      (α_ (inclusionObj n.as) X₁ (X₂ ⊗ X₃)).inv ≫
        ((normalizeIsoApp C X₁ n).hom ⊗ 𝟙 (X₂ ⊗ X₃)) ≫
          (α_ (inclusionObj (normalizeObj X₁ n.as).as) X₂ X₃).inv ≫
            ((normalizeIsoApp C X₂ (normalizeObj X₁ n.as)).hom ⊗ 𝟙 X₃) ≫
              (normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ n.as).as)).hom =
    ((α_ (inclusionObj n.as) (X₁ ⊗ X₂) X₃).inv ≫
        ((α_ (inclusionObj n.as) X₁ X₂).inv ≫
              ((normalizeIsoApp C X₁ n).hom ⊗ 𝟙 X₂) ≫ (normalizeIsoApp C X₂ (normalizeObj X₁ n.as)).hom ⊗
            𝟙 X₃) ≫
          (normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ n.as).as)).hom) ≫
      𝟙
        (inclusionObj
          ((Discrete.functor fun x => normalizeObj X₃ (normalizeObj X₂ (normalizeObj X₁ x).as).as).obj n).as)

Next tactic:
simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        

Proof state:
case f.α_hom.w.h
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).hom) ≫
      (α_ (inclusionObj n.as) X₁ (X₂ ⊗ X₃)).inv ≫
        ((normalizeIsoApp C X₁ n).hom ⊗ 𝟙 (X₂ ⊗ X₃)) ≫
          (α_ (inclusionObj (normalizeObj X₁ n.as).as) X₂ X₃).inv ≫
            ((normalizeIsoApp C X₂ (normalizeObj X₁ n.as)).hom ⊗ 𝟙 X₃) ≫
              (normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ n.as).as)).hom =
    (α_ (inclusionObj n.as) (X₁ ⊗ X₂) X₃).inv ≫
      (((α_ (inclusionObj n.as) X₁ X₂).inv ⊗ 𝟙 X₃) ≫
          ((α_ (inclusionObj n.as ⊗ X₁) X₂ X₃).hom ≫
              ((normalizeIsoApp C X₁ n).hom ⊗ 𝟙 (X₂ ⊗ X₃)) ≫
                (α_ (inclusionObj ((Discrete.functor (normalizeObj X₁)).obj n).as) X₂ X₃).inv) ≫
            ((normalizeIsoApp C X₂ (normalizeObj X₁ n.as)).hom ⊗ 𝟙 X₃)) ≫
        (normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ n.as).as)).hom

Next tactic:
simp only [← Category.assoc]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        

Proof state:
case f.α_hom.w.h
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (((((𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).hom) ≫ (α_ (inclusionObj n.as) X₁ (X₂ ⊗ X₃)).inv) ≫
            ((normalizeIsoApp C X₁ n).hom ⊗ 𝟙 (X₂ ⊗ X₃))) ≫
          (α_ (inclusionObj (normalizeObj X₁ n.as).as) X₂ X₃).inv) ≫
        ((normalizeIsoApp C X₂ (normalizeObj X₁ n.as)).hom ⊗ 𝟙 X₃)) ≫
      (normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ n.as).as)).hom =
    ((((((α_ (inclusionObj n.as) (X₁ ⊗ X₂) X₃).inv ≫ ((α_ (inclusionObj n.as) X₁ X₂).inv ⊗ 𝟙 X₃)) ≫
              (α_ (inclusionObj n.as ⊗ X₁) X₂ X₃).hom) ≫
            ((normalizeIsoApp C X₁ n).hom ⊗ 𝟙 (X₂ ⊗ X₃))) ≫
          (α_ (inclusionObj ((Discrete.functor (normalizeObj X₁)).obj n).as) X₂ X₃).inv) ≫
        ((normalizeIsoApp C X₂ (normalizeObj X₁ n.as)).hom ⊗ 𝟙 X₃)) ≫
      (normalizeIsoApp C X₃ (normalizeObj X₂ (normalizeObj X₁ n.as).as)).hom

Next tactic:
congr 4
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        congr 4
        

Proof state:
case f.α_hom.w.h.e_a.e_a.e_a.e_a
C : Type u
X Y X₁ X₂ X₃ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).hom) ≫ (α_ (inclusionObj n.as) X₁ (X₂ ⊗ X₃)).inv =
    ((α_ (inclusionObj n.as) (X₁ ⊗ X₂) X₃).inv ≫ ((α_ (inclusionObj n.as) X₁ X₂).inv ⊗ 𝟙 X₃)) ≫
      (α_ (inclusionObj n.as ⊗ X₁) X₂ X₃).hom

Next tactic:
simp only [Category.assoc, ← cancel_epi (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).inv),
          pentagon_inv_assoc (inclusionObj n.as) X₁ X₂ X₃,
          tensor_inv_hom_id_assoc, tensor_id, Category.id_comp, Iso.inv_hom_id,
          Category.comp_id]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        congr 4
        simp only [Category.assoc, ← cancel_epi (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).inv),
          pentagon_inv_assoc (inclusionObj n.as) X₁ X₂ X₃,
          tensor_inv_hom_id_assoc, tensor_id, Category.id_comp, Iso.inv_hom_id,
          Category.comp_id]
      · 

Proof state:
case f.α_inv
C : Type u
X Y X✝ Y✝ Z✝ : F C
⊢ (tensorFunc C).map ⟦Hom.α_inv X✝ Y✝ Z✝⟧ ≫ (normalizeIsoAux C (tensor (tensor X✝ Y✝) Z✝)).hom =
    (normalizeIsoAux C (tensor X✝ (tensor Y✝ Z✝))).hom ≫ (normalize' C).map ⟦Hom.α_inv X✝ Y✝ Z✝⟧

Next tactic:
ext n
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        congr 4
        simp only [Category.assoc, ← cancel_epi (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).inv),
          pentagon_inv_assoc (inclusionObj n.as) X₁ X₂ X₃,
          tensor_inv_hom_id_assoc, tensor_id, Category.id_comp, Iso.inv_hom_id,
          Category.comp_id]
      · ext n
        

Proof state:
case f.α_inv.w.h
C : Type u
X Y X✝ Y✝ Z✝ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ ((tensorFunc C).map ⟦Hom.α_inv X✝ Y✝ Z✝⟧ ≫ (normalizeIsoAux C (tensor (tensor X✝ Y✝) Z✝)).hom).app n =
    ((normalizeIsoAux C (tensor X✝ (tensor Y✝ Z✝))).hom ≫ (normalize' C).map ⟦Hom.α_inv X✝ Y✝ Z✝⟧).app n

Next tactic:
dsimp
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        congr 4
        simp only [Category.assoc, ← cancel_epi (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).inv),
          pentagon_inv_assoc (inclusionObj n.as) X₁ X₂ X₃,
          tensor_inv_hom_id_assoc, tensor_id, Category.id_comp, Iso.inv_hom_id,
          Category.comp_id]
      · ext n
        dsimp
        

Proof state:
case f.α_inv.w.h
C : Type u
X Y X✝ Y✝ Z✝ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ ((Discrete.natTrans fun n => 𝟙 (inclusionObj n.as) ⊗ ⟦Hom.α_inv X✝ Y✝ Z✝⟧) ≫
          (NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) (X✝ ⊗ Y✝) Z✝).symm ≪≫
                ((α_ (inclusionObj x.as) X✝ Y✝).symm ≪≫
                      (normalizeIsoApp C X✝ x ⊗ Iso.refl Y✝) ≪≫ normalizeIsoApp C Y✝ (normalizeObj X✝ x.as) ⊗
                    Iso.refl Z✝) ≪≫
                  normalizeIsoApp C Z✝ (normalizeObj Y✝ (normalizeObj X✝ x.as).as)).hom).app
      n =
    ((NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) X✝ (Y✝ ⊗ Z✝)).symm ≪≫
                (normalizeIsoApp C X✝ x ⊗ Iso.refl (Y✝ ⊗ Z✝)) ≪≫
                  (α_ (inclusionObj (normalizeObj X✝ x.as).as) Y✝ Z✝).symm ≪≫
                    (normalizeIsoApp C Y✝ (normalizeObj X✝ x.as) ⊗ Iso.refl Z✝) ≪≫
                      normalizeIsoApp C Z✝ (normalizeObj Y✝ (normalizeObj X✝ x.as).as)).hom ≫
          ((whiskeringRight (Discrete (NormalMonoidalObject C)) (Discrete (NormalMonoidalObject C)) (F C)).obj
                (Discrete.functor inclusionObj)).map
            (Discrete.natTrans fun x =>
              𝟙 ((Discrete.functor fun x => normalizeObj Z✝ (normalizeObj Y✝ (normalizeObj X✝ x).as).as).obj x))).app
      n

Next tactic:
rw [mk_α_inv, NatTrans.comp_app, NatTrans.comp_app]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        congr 4
        simp only [Category.assoc, ← cancel_epi (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).inv),
          pentagon_inv_assoc (inclusionObj n.as) X₁ X₂ X₃,
          tensor_inv_hom_id_assoc, tensor_id, Category.id_comp, Iso.inv_hom_id,
          Category.comp_id]
      · ext n
        dsimp
        rw [mk_α_inv, NatTrans.comp_app, NatTrans.comp_app]
        

Proof state:
case f.α_inv.w.h
C : Type u
X Y X✝ Y✝ Z✝ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (Discrete.natTrans fun n => 𝟙 (inclusionObj n.as) ⊗ (α_ X✝ Y✝ Z✝).inv).app n ≫
      (NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) (X✝ ⊗ Y✝) Z✝).symm ≪≫
                ((α_ (inclusionObj x.as) X✝ Y✝).symm ≪≫
                      (normalizeIsoApp C X✝ x ⊗ Iso.refl Y✝) ≪≫ normalizeIsoApp C Y✝ (normalizeObj X✝ x.as) ⊗
                    Iso.refl Z✝) ≪≫
                  normalizeIsoApp C Z✝ (normalizeObj Y✝ (normalizeObj X✝ x.as).as)).hom.app
        n =
    (NatIso.ofComponents fun x =>
              (α_ (inclusionObj x.as) X✝ (Y✝ ⊗ Z✝)).symm ≪≫
                (normalizeIsoApp C X✝ x ⊗ Iso.refl (Y✝ ⊗ Z✝)) ≪≫
                  (α_ (inclusionObj (normalizeObj X✝ x.as).as) Y✝ Z✝).symm ≪≫
                    (normalizeIsoApp C Y✝ (normalizeObj X✝ x.as) ⊗ Iso.refl Z✝) ≪≫
                      normalizeIsoApp C Z✝ (normalizeObj Y✝ (normalizeObj X✝ x.as).as)).hom.app
        n ≫
      (((whiskeringRight (Discrete (NormalMonoidalObject C)) (Discrete (NormalMonoidalObject C)) (F C)).obj
                (Discrete.functor inclusionObj)).map
            (Discrete.natTrans fun x =>
              𝟙 ((Discrete.functor fun x => normalizeObj Z✝ (normalizeObj Y✝ (normalizeObj X✝ x).as).as).obj x))).app
        n

Next tactic:
dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
/-- The isomorphism between `n ⊗ X` and `normalize X n` is natural (in both `X` and `n`, but
    naturality in `n` is trivial and was "proved" in `normalizeIsoAux`). This is the real heart
    of our proof of the coherence theorem. -/
def normalizeIso : tensorFunc C ≅ normalize' C :=
  NatIso.ofComponents (normalizeIsoAux C)
    (by -- porting note: the proof has been mostly rewritten
      rintro X Y f
      induction' f using Quotient.recOn with f; swap; rfl
      induction' f with _ X₁ X₂ X₃ _ _ _ _ _ _ _ _ _ _ _ _ h₁ h₂ X₁ X₂ Y₁ Y₂ f g h₁ h₂
      · simp only [mk_id, Functor.map_id, Category.comp_id, Category.id_comp]
      · ext n
        dsimp
        rw [mk_α_hom, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        simp only [comp_tensor_id, associator_conjugation, tensor_id,
          Category.comp_id]
        simp only [← Category.assoc]
        congr 4
        simp only [Category.assoc, ← cancel_epi (𝟙 (inclusionObj n.as) ⊗ (α_ X₁ X₂ X₃).inv),
          pentagon_inv_assoc (inclusionObj n.as) X₁ X₂ X₃,
          tensor_inv_hom_id_assoc, tensor_id, Category.id_comp, Iso.inv_hom_id,
          Category.comp_id]
      · ext n
        dsimp
        rw [mk_α_inv, NatTrans.comp_app, NatTrans.comp_app]
        dsimp [NatIso.ofComponents, normalizeMapAux, whiskeringRight, whiskerRight, Functor.comp]
        

Proof state:
case f.α_inv.w.h
C : Type u
X Y X✝ Y✝ Z✝ : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (𝟙 (inclusionObj n.as) ⊗ (α_ X✝ Y✝ Z✝).inv) ≫
      (α_ (inclusionObj n.as) (X✝ ⊗ Y✝) Z✝).inv ≫
        ((α_ (inclusionObj n.as) X✝ Y✝).inv ≫
              ((normalizeIsoApp C X✝ n).hom ⊗ 𝟙 Y✝) ≫ (normalizeIsoApp C Y✝ (normalizeObj X✝ n.as)).hom ⊗
            𝟙 Z✝) ≫
          (normalizeIsoApp C Z✝ (normalizeObj Y✝ (normalizeObj X✝ n.as).as)).hom =
    ((α_ (inclusionObj n.as) X✝ (Y✝ ⊗ Z✝)).inv ≫
        ((normalizeIsoApp C X✝ n).hom ⊗ 𝟙 (Y✝ ⊗ Z✝)) ≫
          (α_ (inclusionObj (normalizeObj X✝ n.as).as) Y✝ Z✝).inv ≫
            ((normalizeIsoApp C Y✝ (normalizeObj X✝ n.as)).hom ⊗ 𝟙 Z✝) ≫
              (normalizeIsoApp C Z✝ (normalizeObj Y✝ (normalizeObj X✝ n.as).as)).hom) ≫
      𝟙
        (inclusionObj
          ((Discrete.functor fun x => normalizeObj Z✝ (normalizeObj Y✝ (normalizeObj X✝ x).as).as).obj n).as)

Next tactic:
simp only [Category.assoc, comp_tensor_id, tensor_id, Category.comp_id,
          pentagon_inv_assoc, ← associator_inv_naturality_assoc]