l3lab/ntp-mathlib huggingface dataset:
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]
  leftUnitor_naturality {X Y : D} f := F.map_injective <| by
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
X Y : D
f : X ⟶ Y
⊢ F.map ((𝟙 (𝟙_ D) ⊗ f) ≫ (λ_ Y).hom) = F.map ((λ_ X).hom ≫ f)

Next tactic:
have := leftUnitor_naturality (F.map f)
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]
  leftUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := leftUnitor_naturality (F.map f)
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
X Y : D
f : X ⟶ Y
this : (𝟙 (𝟙_ C) ⊗ F.map f) ≫ (λ_ (F.obj Y)).hom = (λ_ (F.obj X)).hom ≫ F.map f
⊢ F.map ((𝟙 (𝟙_ D) ⊗ f) ≫ (λ_ Y).hom) = F.map ((λ_ X).hom ≫ f)

Next tactic:
simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.leftUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]
  leftUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := leftUnitor_naturality (F.map f)
    simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.leftUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
X Y : D
f : X ⟶ Y
this : (𝟙 (𝟙_ C) ⊗ F.map f) ≫ (λ_ (F.obj Y)).hom = (λ_ (F.obj X)).hom ≫ F.map f
⊢ (fData.εIso.inv ⊗ F.map f) ≫ (λ_ (F.obj Y)).hom = (fData.εIso.inv ⊗ 𝟙 (F.obj X)) ≫ (λ_ (F.obj X)).hom ≫ F.map f

Next tactic:
rw [← this, ← assoc, ← tensor_comp, id_comp, comp_id]
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]
  leftUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := leftUnitor_naturality (F.map f)
    simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.leftUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    rw [← this, ← assoc, ← tensor_comp, id_comp, comp_id]
  rightUnitor_naturality {X Y : D} f := F.map_injective <| by
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
X Y : D
f : X ⟶ Y
⊢ F.map ((f ⊗ 𝟙 (𝟙_ D)) ≫ (ρ_ Y).hom) = F.map ((ρ_ X).hom ≫ f)

Next tactic:
have := rightUnitor_naturality (F.map f)
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]
  leftUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := leftUnitor_naturality (F.map f)
    simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.leftUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    rw [← this, ← assoc, ← tensor_comp, id_comp, comp_id]
  rightUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := rightUnitor_naturality (F.map f)
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
X Y : D
f : X ⟶ Y
this : (F.map f ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ (F.obj Y)).hom = (ρ_ (F.obj X)).hom ≫ F.map f
⊢ F.map ((f ⊗ 𝟙 (𝟙_ D)) ≫ (ρ_ Y).hom) = F.map ((ρ_ X).hom ≫ f)

Next tactic:
simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.rightUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, tensor_id_comp_id_tensor_assoc, Iso.cancel_iso_inv_left]
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]
  leftUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := leftUnitor_naturality (F.map f)
    simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.leftUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    rw [← this, ← assoc, ← tensor_comp, id_comp, comp_id]
  rightUnitor_naturality {X Y : D} f := F.map_injective <| by
    have := rightUnitor_naturality (F.map f)
    simp only [Functor.map_comp, fData.tensorHom_eq, Functor.map_id, fData.rightUnitor_eq,
      Iso.trans_assoc, Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, assoc,
      Iso.hom_inv_id_assoc, tensor_id_comp_id_tensor_assoc, Iso.cancel_iso_inv_left]
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
X Y : D
f : X ⟶ Y
this : (F.map f ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ (F.obj Y)).hom = (ρ_ (F.obj X)).hom ≫ F.map f
⊢ (F.map f ⊗ fData.εIso.inv) ≫ (ρ_ (F.obj Y)).hom = (𝟙 (F.obj X) ⊗ fData.εIso.inv) ≫ (ρ_ (F.obj X)).hom ≫ F.map f

Next tactic:
rw [← this, ← assoc, ← tensor_comp, id_comp, comp_id]
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
W X Y Z : D
⊢ F.map (((α_ W X Y).hom ⊗ 𝟙 Z) ≫ (α_ W (X ⊗ Y) Z).hom ≫ (𝟙 W ⊗ (α_ X Y Z).hom)) =
    F.map ((α_ (W ⊗ X) Y Z).hom ≫ (α_ W X (Y ⊗ Z)).hom)

Next tactic:
simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
W X Y Z : D
⊢ ((InducingFunctorData.μIso fData (W ⊗ X) Y).inv ⊗ 𝟙 (F.obj Z)) ≫
      (α_ (F.obj (W ⊗ X)) (F.obj Y) (F.obj Z)).hom ≫
        ((InducingFunctorData.μIso fData W X).inv ⊗ 𝟙 (F.obj Y ⊗ F.obj Z)) ≫
          (α_ (F.obj W ⊗ F.obj X) (F.obj Y) (F.obj Z)).inv ≫
            ((α_ (F.obj W) (F.obj X) (F.obj Y)).hom ⊗ 𝟙 (F.obj Z)) ≫
              (α_ (F.obj W) (F.obj X ⊗ F.obj Y) (F.obj Z)).hom ≫
                (𝟙 (F.obj W) ⊗ (InducingFunctorData.μIso fData X Y).hom ⊗ 𝟙 (F.obj Z)) ≫
                  (𝟙 (F.obj W) ⊗ (InducingFunctorData.μIso fData X Y).inv ⊗ 𝟙 (F.obj Z)) ≫
                    (𝟙 (F.obj W) ⊗ (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom) ≫
                      (𝟙 (F.obj W) ⊗ 𝟙 (F.obj X) ⊗ (InducingFunctorData.μIso fData Y Z).hom) ≫
                        (𝟙 (F.obj W) ⊗ (InducingFunctorData.μIso fData X (Y ⊗ Z)).hom) ≫
                          (InducingFunctorData.μIso fData W (X ⊗ Y ⊗ Z)).hom =
    ((InducingFunctorData.μIso fData (W ⊗ X) Y).inv ⊗ 𝟙 (F.obj Z)) ≫
      (α_ (F.obj (W ⊗ X)) (F.obj Y) (F.obj Z)).hom ≫
        ((InducingFunctorData.μIso fData W X).inv ⊗ (InducingFunctorData.μIso fData Y Z).hom) ≫
          (α_ (F.obj W) (F.obj X) (F.obj (Y ⊗ Z))).hom ≫
            (𝟙 (F.obj W) ⊗ (InducingFunctorData.μIso fData X (Y ⊗ Z)).hom) ≫
              (InducingFunctorData.μIso fData W (X ⊗ Y ⊗ Z)).hom

Next tactic:
slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
/--
Induce the lawfulness of the monoidal structure along an faithful functor of (plain) categories,
where the operations are already defined on the destination type `D`.

The functor `F` must preserve all the data parts of the monoidal structure between the two
categories.

-/
abbrev induced [MonoidalCategoryStruct D] (F : D ⥤ C) [Faithful F]
    (fData : InducingFunctorData F) :
    MonoidalCategory.{v₂} D where
  tensorHom_def {X₁ Y₁ X₂ Y₂} f g := F.map_injective <| by
    rw [fData.tensorHom_eq, Functor.map_comp, fData.whiskerRight_eq, fData.whiskerLeft_eq]
    simp only [tensorHom_def, assoc, Iso.hom_inv_id_assoc]
  tensor_id X₁ X₂ := F.map_injective <| by cases fData; aesop_cat
  tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂} f₁ f₂ g₁ g₂ := F.map_injective <| by cases fData; aesop_cat
  whiskerLeft_id X Y := F.map_injective <| by simp [fData.whiskerLeft_eq]
  id_whiskerRight X Y := F.map_injective <| by simp [fData.whiskerRight_eq]
  triangle X Y := F.map_injective <| by cases fData; aesop_cat
  pentagon W X Y Z := F.map_injective <| by
    simp only [Functor.map_comp, fData.tensorHom_eq, fData.associator_eq, Iso.trans_assoc,
      Iso.trans_hom, Iso.symm_hom, tensorIso_hom, Iso.refl_hom, Functor.map_id, comp_tensor_id,
      associator_conjugation, tensor_id, assoc, id_tensor_comp, Iso.hom_inv_id_assoc,
      tensor_hom_inv_id_assoc, id_comp, hom_inv_id_tensor_assoc, Iso.inv_hom_id_assoc,
      id_tensor_comp_tensor_id_assoc, Iso.cancel_iso_inv_left]
    slice_lhs 6 8 =>
      rw [← id_tensor_comp, hom_inv_id_tensor, tensor_id, comp_id,
        tensor_id]
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategoryStruct D
F : D ⥤ C
inst✝ : Faithful F
fData : InducingFunctorData F
W X Y Z : D
⊢ ((InducingFunctorData.μIso fData (W ⊗ X) Y).inv ⊗ 𝟙 (F.obj Z)) ≫
      (α_ (F.obj (W ⊗ X)) (F.obj Y) (F.obj Z)).hom ≫
        ((InducingFunctorData.μIso fData W X).inv ⊗ 𝟙 (F.obj Y ⊗ F.obj Z)) ≫
          (α_ (F.obj W ⊗ F.obj X) (F.obj Y) (F.obj Z)).inv ≫
            ((α_ (F.obj W) (F.obj X) (F.obj Y)).hom ⊗ 𝟙 (F.obj Z)) ≫
              (((((α_ (F.obj W) (F.obj X ⊗ F.obj Y) (F.obj Z)).hom ≫ 𝟙 (F.obj W ⊗ (F.obj X ⊗ F.obj Y) ⊗ F.obj Z)) ≫
                      (𝟙 (F.obj W) ⊗ (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom)) ≫
                    (𝟙 (F.obj W) ⊗ 𝟙 (F.obj X) ⊗ (InducingFunctorData.μIso fData Y Z).hom)) ≫
                  (𝟙 (F.obj W) ⊗ (InducingFunctorData.μIso fData X (Y ⊗ Z)).hom)) ≫
                (InducingFunctorData.μIso fData W (X ⊗ Y ⊗ Z)).hom =
    ((InducingFunctorData.μIso fData (W ⊗ X) Y).inv ⊗ 𝟙 (F.obj Z)) ≫
      (α_ (F.obj (W ⊗ X)) (F.obj Y) (F.obj Z)).hom ≫
        ((InducingFunctorData.μIso fData W X).inv ⊗ (InducingFunctorData.μIso fData Y Z).hom) ≫
          (α_ (F.obj W) (F.obj X) (F.obj (Y ⊗ Z))).hom ≫
            (𝟙 (F.obj W) ⊗ (InducingFunctorData.μIso fData X (Y ⊗ Z)).hom) ≫
              (InducingFunctorData.μIso fData W (X ⊗ Y ⊗ Z)).hom

Next tactic:
simp only [comp_id, assoc, pentagon_assoc, Iso.inv_hom_id_assoc,
      ← associator_naturality_assoc, tensor_id, tensor_id_comp_id_tensor_assoc]