Theorem: CategoryTheory.Functor.toMonoidalFunctorOfHasFiniteProducts_toLaxMonoidalFunctor_μ
File: Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean

Proof steps:
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y : C
f : X ⟶ Y
X' : C
⊢ MonoidalCategory.whiskerRight (F.map f) (F.obj X') ≫ (fun X Y => (asIso (prodComparison F X Y)).inv) Y X' =
    (fun X Y => (asIso (prodComparison F X Y)).inv) X X' ≫ F.map (MonoidalCategory.whiskerRight f X')
state_after: no goals
tactic: simpa using (prodComparison_inv_natural F f (𝟙 X')).symm
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y X' : C
g : X ⟶ Y
⊢ MonoidalCategory.whiskerLeft (F.obj X') (F.map g) ≫ (fun X Y => (asIso (prodComparison F X Y)).inv) X' Y =
    (fun X Y => (asIso (prodComparison F X Y)).inv) X' X ≫ F.map (MonoidalCategory.whiskerLeft X' g)
state_after: no goals
tactic: simpa using (prodComparison_inv_natural F (𝟙 X') g).symm
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ MonoidalCategory.whiskerRight ((fun X Y => (asIso (prodComparison F X Y)).inv) X Y) (F.obj Z) ≫
      (fun X Y => (asIso (prodComparison F X Y)).inv) (MonoidalCategory.tensorObj X Y) Z ≫
        F.map (MonoidalCategory.associator X Y Z).hom =
    (MonoidalCategory.associator (F.obj X) (F.obj Y) (F.obj Z)).hom ≫
      MonoidalCategory.whiskerLeft (F.obj X) ((fun X Y => (asIso (prodComparison F X Y)).inv) Y Z) ≫
        (fun X Y => (asIso (prodComparison F X Y)).inv) X (MonoidalCategory.tensorObj Y Z)
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ MonoidalCategory.whiskerRight (asIso (prodComparison F X Y)).inv (F.obj Z) ≫
      (asIso (prodComparison F (MonoidalCategory.tensorObj X Y) Z)).inv ≫
        F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd) ≫
      MonoidalCategory.whiskerLeft (F.obj X) (asIso (prodComparison F Y Z)).inv ≫
        (asIso (prodComparison F X (MonoidalCategory.tensorObj Y Z))).inv
tactic: dsimp only [monoidalOfHasFiniteProducts.associator_hom]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ MonoidalCategory.whiskerRight (asIso (prodComparison F X Y)).inv (F.obj Z) ≫
      (asIso (prodComparison F (MonoidalCategory.tensorObj X Y) Z)).inv ≫
        F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd) ≫
      MonoidalCategory.whiskerLeft (F.obj X) (asIso (prodComparison F Y Z)).inv ≫
        (asIso (prodComparison F X (MonoidalCategory.tensorObj Y Z))).inv
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      MonoidalCategory.whiskerRight (asIso (prodComparison F X Y)).inv (F.obj Z) ≫
        (asIso (prodComparison F (MonoidalCategory.tensorObj X Y) Z)).inv ≫
          F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd) ≫
        MonoidalCategory.whiskerLeft (F.obj X) (asIso (prodComparison F Y Z)).inv ≫
          (asIso (prodComparison F X (MonoidalCategory.tensorObj Y Z))).inv
tactic: rw [← cancel_epi (prod.map (prodComparison F X Y) (𝟙 (F.obj Z)))]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      MonoidalCategory.whiskerRight (asIso (prodComparison F X Y)).inv (F.obj Z) ≫
        (asIso (prodComparison F (MonoidalCategory.tensorObj X Y) Z)).inv ≫
          F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd) ≫
        MonoidalCategory.whiskerLeft (F.obj X) (asIso (prodComparison F Y Z)).inv ≫
          (asIso (prodComparison F X (MonoidalCategory.tensorObj Y Z))).inv
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      prod.map (CategoryTheory.inv (prodComparison F X Y)) (𝟙 (F.obj Z)) ≫
        CategoryTheory.inv (prodComparison F (X ⨯ Y) Z) ≫
          F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd) ≫
        prod.map (𝟙 (F.obj X)) (CategoryTheory.inv (prodComparison F Y Z)) ≫
          CategoryTheory.inv (prodComparison F X (Y ⨯ Z))
tactic: dsimp
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      prod.map (CategoryTheory.inv (prodComparison F X Y)) (𝟙 (F.obj Z)) ≫
        CategoryTheory.inv (prodComparison F (X ⨯ Y) Z) ≫
          F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
      prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd) ≫
        prod.map (𝟙 (F.obj X)) (CategoryTheory.inv (prodComparison F Y Z)) ≫
          CategoryTheory.inv (prodComparison F X (Y ⨯ Z))
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prodComparison F (X ⨯ Y) Z ≫
      prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
        prod.lift (prod.fst ≫ prod.fst)
            (prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z)) ≫
          CategoryTheory.inv (prodComparison F X (Y ⨯ Z))
tactic: simp only [prod.map_map_assoc, IsIso.hom_inv_id, Category.comp_id, prod.map_id_id,
      Category.id_comp, prod.lift_map_assoc, IsIso.inv_comp_eq]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) =
    prodComparison F (X ⨯ Y) Z ≫
      prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
        prod.lift (prod.fst ≫ prod.fst)
            (prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z)) ≫
          CategoryTheory.inv (prodComparison F X (Y ⨯ Z))
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) ≫ prodComparison F X (Y ⨯ Z) =
    (prodComparison F (X ⨯ Y) Z ≫
        prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
          prod.lift (prod.fst ≫ prod.fst)
              (prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z)) ≫
            CategoryTheory.inv (prodComparison F X (Y ⨯ Z))) ≫
      prodComparison F X (Y ⨯ Z)
tactic: rw [← cancel_mono (prodComparison F X (Y ⨯ Z))]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) ≫ prodComparison F X (Y ⨯ Z) =
    (prodComparison F (X ⨯ Y) Z ≫
        prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
          prod.lift (prod.fst ≫ prod.fst)
              (prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z)) ≫
            CategoryTheory.inv (prodComparison F X (Y ⨯ Z))) ≫
      prodComparison F X (Y ⨯ Z)
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) ≫ prodComparison F X (Y ⨯ Z) =
    prod.lift (F.map prod.fst ≫ F.map prod.fst)
      (prodComparison F (X ⨯ Y) Z ≫
        prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
          prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z))
tactic: simp only [Category.assoc, IsIso.inv_hom_id, Category.comp_id, prod.comp_lift,
      prod.map_fst_assoc, prodComparison_fst, prodComparison_fst_assoc]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) ≫ prodComparison F X (Y ⨯ Z) =
    prod.lift (F.map prod.fst ≫ F.map prod.fst)
      (prodComparison F (X ⨯ Y) Z ≫
        prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
          prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z))
state_after: case h₁
C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ (F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) ≫ prodComparison F X (Y ⨯ Z)) ≫
      prod.fst =
    prod.lift (F.map prod.fst ≫ F.map prod.fst)
        (prodComparison F (X ⨯ Y) Z ≫
          prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
            prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z)) ≫
      prod.fst

case h₂
C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X Y Z : C
⊢ (F.map (prod.lift (prod.fst ≫ prod.fst) (prod.lift (prod.fst ≫ prod.snd) prod.snd)) ≫ prodComparison F X (Y ⨯ Z)) ≫
      prod.snd =
    prod.lift (F.map prod.fst ≫ F.map prod.fst)
        (prodComparison F (X ⨯ Y) Z ≫
          prod.map (prodComparison F X Y) (𝟙 (F.obj Z)) ≫
            prod.lift (prod.fst ≫ prod.snd) prod.snd ≫ CategoryTheory.inv (prodComparison F Y Z)) ≫
      prod.snd
tactic: ext
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ (MonoidalCategory.leftUnitor (F.obj Y)).hom =
    MonoidalCategory.whiskerRight (asIso (terminalComparison F)).inv (F.obj Y) ≫
      (fun X Y => (asIso (prodComparison F X Y)).inv) (𝟙_ C) Y ≫ F.map (MonoidalCategory.leftUnitor Y).hom
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫ (MonoidalCategory.leftUnitor (F.obj Y)).hom =
    prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫
      MonoidalCategory.whiskerRight (asIso (terminalComparison F)).inv (F.obj Y) ≫
        (fun X Y => (asIso (prodComparison F X Y)).inv) (𝟙_ C) Y ≫ F.map (MonoidalCategory.leftUnitor Y).hom
tactic: rw [← cancel_epi (prod.map (terminalComparison F) (𝟙 (F.obj Y)))]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫ (MonoidalCategory.leftUnitor (F.obj Y)).hom =
    prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫
      MonoidalCategory.whiskerRight (asIso (terminalComparison F)).inv (F.obj Y) ≫
        (fun X Y => (asIso (prodComparison F X Y)).inv) (𝟙_ C) Y ≫ F.map (MonoidalCategory.leftUnitor Y).hom
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫ prod.snd =
    prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫
      prod.map (CategoryTheory.inv (terminalComparison F)) (𝟙 (F.obj Y)) ≫
        CategoryTheory.inv (prodComparison F (⊤_ C) Y) ≫ F.map prod.snd
tactic: dsimp
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫ prod.snd =
    prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫
      prod.map (CategoryTheory.inv (terminalComparison F)) (𝟙 (F.obj Y)) ≫
        CategoryTheory.inv (prodComparison F (⊤_ C) Y) ≫ F.map prod.snd
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ prodComparison F (⊤_ C) Y ≫ prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫ prod.snd = F.map prod.snd
tactic: simp only [prod.map_map_assoc, IsIso.hom_inv_id, Category.comp_id, prod.map_id_id,
      Category.id_comp, IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X Y✝ : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
Y : C
⊢ prodComparison F (⊤_ C) Y ≫ prod.map (terminalComparison F) (𝟙 (F.obj Y)) ≫ prod.snd = F.map prod.snd
state_after: no goals
tactic: erw [prod.map_snd, Category.comp_id, prodComparison_snd]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ (MonoidalCategory.rightUnitor (F.obj X)).hom =
    MonoidalCategory.whiskerLeft (F.obj X) (asIso (terminalComparison F)).inv ≫
      (fun X Y => (asIso (prodComparison F X Y)).inv) X (𝟙_ C) ≫ F.map (MonoidalCategory.rightUnitor X).hom
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫ (MonoidalCategory.rightUnitor (F.obj X)).hom =
    prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫
      MonoidalCategory.whiskerLeft (F.obj X) (asIso (terminalComparison F)).inv ≫
        (fun X Y => (asIso (prodComparison F X Y)).inv) X (𝟙_ C) ≫ F.map (MonoidalCategory.rightUnitor X).hom
tactic: rw [← cancel_epi (prod.map (𝟙 (F.obj X)) (terminalComparison F))]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫ (MonoidalCategory.rightUnitor (F.obj X)).hom =
    prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫
      MonoidalCategory.whiskerLeft (F.obj X) (asIso (terminalComparison F)).inv ≫
        (fun X Y => (asIso (prodComparison F X Y)).inv) X (𝟙_ C) ≫ F.map (MonoidalCategory.rightUnitor X).hom
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫ prod.fst =
    prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫
      prod.map (𝟙 (F.obj X)) (CategoryTheory.inv (terminalComparison F)) ≫
        CategoryTheory.inv (prodComparison F X (⊤_ C)) ≫ F.map prod.fst
tactic: dsimp
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫ prod.fst =
    prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫
      prod.map (𝟙 (F.obj X)) (CategoryTheory.inv (terminalComparison F)) ≫
        CategoryTheory.inv (prodComparison F X (⊤_ C)) ≫ F.map prod.fst
state_after: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ prodComparison F X (⊤_ C) ≫ prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫ prod.fst = F.map prod.fst
tactic: simp only [prod.map_map_assoc, Category.comp_id, IsIso.hom_inv_id, prod.map_id_id,
      Category.id_comp, IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X✝ Y : C
D : Type u_1
inst✝⁶ : Category.{?u.241337, u_1} D
F : C ⥤ D
inst✝⁵ : HasTerminal C
inst✝⁴ : HasBinaryProducts C
inst✝³ : HasTerminal D
inst✝² : HasBinaryProducts D
inst✝¹ : PreservesLimit (empty C) F
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
X : C
⊢ prodComparison F X (⊤_ C) ≫ prod.map (𝟙 (F.obj X)) (terminalComparison F) ≫ prod.fst = F.map prod.fst
state_after: no goals
tactic: erw [prod.map_fst, Category.comp_id, prodComparison_fst]