Theorem: CategoryTheory.Monoidal.fromInduced_toLaxMonoidalFunctor_toFunctor
File: Mathlib/CategoryTheory/Monoidal/Transport.lean

Proof steps:
state_before: 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✝ : F.Faithful
fData : InducingFunctorData F
this : MonoidalCategory D := induced F fData
⊢ ∀ {X Y : D} (f : X ⟶ Y) (X' : D),
    F.map f ▷ F.obj X' ≫ (fun X Y => (fData.μIso X Y).hom) Y X' =
      (fun X Y => (fData.μIso X Y).hom) X X' ≫ F.map (f ▷ X')
state_after: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ {X Y : D} (f : X ⟶ Y) (X' : D),
    F.map f ▷ F.obj X' ≫
        (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          Y X' =
      (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          X X' ≫
        F.map (f ▷ X')
tactic: cases fData
state_before: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ {X Y : D} (f : X ⟶ Y) (X' : D),
    F.map f ▷ F.obj X' ≫
        (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          Y X' =
      (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          X X' ≫
        F.map (f ▷ X')
state_after: no goals
tactic: aesop_cat
state_before: 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✝ : F.Faithful
fData : InducingFunctorData F
this : MonoidalCategory D := induced F fData
⊢ ∀ {X Y : D} (X' : D) (f : X ⟶ Y),
    F.obj X' ◁ F.map f ≫ (fun X Y => (fData.μIso X Y).hom) X' Y =
      (fun X Y => (fData.μIso X Y).hom) X' X ≫ F.map (X' ◁ f)
state_after: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ {X Y : D} (X' : D) (f : X ⟶ Y),
    F.obj X' ◁ F.map f ≫
        (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          X' Y =
      (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          X' X ≫
        F.map (X' ◁ f)
tactic: cases fData
state_before: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ {X Y : D} (X' : D) (f : X ⟶ Y),
    F.obj X' ◁ F.map f ≫
        (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          X' Y =
      (fun X Y =>
            ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                    tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                    leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                X Y).hom)
          X' X ≫
        F.map (X' ◁ f)
state_after: no goals
tactic: aesop_cat
state_before: 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✝ : F.Faithful
fData : InducingFunctorData F
this : MonoidalCategory D := induced F fData
⊢ ∀ (X Y Z : D),
    (fun X Y => (fData.μIso X Y).hom) X Y ▷ F.obj Z ≫
        (fun X Y => (fData.μIso X Y).hom) (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
      (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫
        F.obj X ◁ (fun X Y => (fData.μIso X Y).hom) Y Z ≫ (fun X Y => (fData.μIso X Y).hom) X (Y ⊗ Z)
state_after: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ (X Y Z : D),
    (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            X Y ▷
          F.obj Z ≫
        (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            (X ⊗ Y) Z ≫
          F.map (α_ X Y Z).hom =
      (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫
        F.obj X ◁
            (fun X Y =>
                ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                        tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                        leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                    X Y).hom)
              Y Z ≫
          (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            X (Y ⊗ Z)
tactic: cases fData
state_before: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ (X Y Z : D),
    (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            X Y ▷
          F.obj Z ≫
        (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            (X ⊗ Y) Z ≫
          F.map (α_ X Y Z).hom =
      (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫
        F.obj X ◁
            (fun X Y =>
                ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                        tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                        leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                    X Y).hom)
              Y Z ≫
          (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            X (Y ⊗ Z)
state_after: no goals
tactic: aesop_cat
state_before: 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✝ : F.Faithful
fData : InducingFunctorData F
this : MonoidalCategory D := induced F fData
⊢ ∀ (X : D),
    (λ_ (F.obj X)).hom = fData.εIso.hom ▷ F.obj X ≫ (fun X Y => (fData.μIso X Y).hom) (𝟙_ D) X ≫ F.map (λ_ X).hom
state_after: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ (X : D),
    (λ_ (F.obj X)).hom =
      { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.εIso.hom ▷
          F.obj X ≫
        (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            (𝟙_ D) X ≫
          F.map (λ_ X).hom
tactic: cases fData
state_before: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ (X : D),
    (λ_ (F.obj X)).hom =
      { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.εIso.hom ▷
          F.obj X ≫
        (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            (𝟙_ D) X ≫
          F.map (λ_ X).hom
state_after: no goals
tactic: aesop_cat
state_before: 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✝ : F.Faithful
fData : InducingFunctorData F
this : MonoidalCategory D := induced F fData
⊢ ∀ (X : D),
    (ρ_ (F.obj X)).hom = F.obj X ◁ fData.εIso.hom ≫ (fun X Y => (fData.μIso X Y).hom) X (𝟙_ D) ≫ F.map (ρ_ X).hom
state_after: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ (X : D),
    (ρ_ (F.obj X)).hom =
      F.obj X ◁
          { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.εIso.hom ≫
        (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            X (𝟙_ D) ≫
          F.map (ρ_ X).hom
tactic: cases fData
state_before: case mk
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✝ : F.Faithful
μIso✝ : (X Y : D) → F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
whiskerLeft_eq✝ :
  ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂), F.map (X ◁ f) = (μIso✝ X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (μIso✝ X Y₂).hom
whiskerRight_eq✝ :
  ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D), F.map (f ▷ Y) = (μIso✝ X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (μIso✝ X₂ Y).hom
tensorHom_eq✝ :
  ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso✝ X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso✝ Y₁ Y₂).hom
εIso✝ : 𝟙_ C ≅ F.obj (𝟙_ D)
associator_eq✝ :
  ∀ (X Y Z : D),
    F.map (α_ X Y Z).hom =
      (((μIso✝ (X ⊗ Y) Z).symm ≪≫ ((μIso✝ X Y).symm ⊗ Iso.refl (F.obj Z))) ≪≫
          α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫ (Iso.refl (F.obj X) ⊗ μIso✝ Y Z) ≪≫ μIso✝ X (Y ⊗ Z)).hom
leftUnitor_eq✝ :
  ∀ (X : D), F.map (λ_ X).hom = (((μIso✝ (𝟙_ D) X).symm ≪≫ (εIso✝.symm ⊗ Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
rightUnitor_eq✝ :
  ∀ (X : D), F.map (ρ_ X).hom = (((μIso✝ X (𝟙_ D)).symm ≪≫ (Iso.refl (F.obj X) ⊗ εIso✝.symm)) ≪≫ ρ_ (F.obj X)).hom
this : MonoidalCategory D :=
  induced F
    { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝, leftUnitor_eq := leftUnitor_eq✝,
      rightUnitor_eq := rightUnitor_eq✝ }
⊢ ∀ (X : D),
    (ρ_ (F.obj X)).hom =
      F.obj X ◁
          { μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.εIso.hom ≫
        (fun X Y =>
              ({ μIso := μIso✝, whiskerLeft_eq := whiskerLeft_eq✝, whiskerRight_eq := whiskerRight_eq✝,
                      tensorHom_eq := tensorHom_eq✝, εIso := εIso✝, associator_eq := associator_eq✝,
                      leftUnitor_eq := leftUnitor_eq✝, rightUnitor_eq := rightUnitor_eq✝ }.μIso
                  X Y).hom)
            X (𝟙_ D) ≫
          F.map (ρ_ X).hom
state_after: no goals
tactic: aesop_cat