Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.hexagon_reverse
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Symmetric.lean

tactic: dsimp [tensorHom, Limits.BinaryFan.braiding]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
      (BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
    tensorHom ℬ (𝟙 X) (BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
      (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
        tensorHom ℬ (BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y)
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
      ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
    (ℬ X (ℬ Z Y).cone.pt).isLimit.lift
        (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
          (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
            ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
      (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
        (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
          (BinaryFan.mk
            (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
              ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
            (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))

tactic: apply (ℬ _ _).isLimit.hom_ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
      ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
    (ℬ X (ℬ Z Y).cone.pt).isLimit.lift
        (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
          (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
            ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
      (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
        (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
          (BinaryFan.mk
            (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
              ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
            (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ∀ (j : Discrete WalkingPair),
    ((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
          ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
            (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app j =
      ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
          (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                  ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
                (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app j

tactic: rintro ⟨⟨⟩⟩
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ∀ (j : Discrete WalkingPair),
    ((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
          ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
            (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app j =
      ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
          (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                  ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
                (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app j
state_after: case mk.left
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left } =
    ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
              ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }

case mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.right } =
    ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
              ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.right }

tactic: apply (ℬ _ _).isLimit.hom_ext
state_before: case mk.left
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left } =
    ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
              ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }
state_after: case mk.left
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ∀ (j : Discrete WalkingPair),
    (((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
            ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
              (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
          (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
        (ℬ Z X).cone.π.app j =
      (((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
              (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
                (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                  ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
            (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
              (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
                (BinaryFan.mk
                  (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                    ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
                  (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
          (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
        (ℬ Z X).cone.π.app j

tactic: dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
  Limits.IsLimit.conePointUniqueUpToIso]
state_before: case mk.left.mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ (((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
          ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
            (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
      (ℬ Z X).cone.π.app { as := WalkingPair.right } =
    (((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
          (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                  ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
                (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
      (ℬ Z X).cone.π.app { as := WalkingPair.right }
state_after: case mk.left.mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ (((ℬ (ℬ X Y).cone.pt Z).isLimit.lift (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
          (ℬ Z (tensorObj ℬ X Y)).isLimit.lift (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.snd (ℬ Z X).cone =
    (((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ (ℬ Z Y).isLimit.lift (BinaryFan.swap (ℬ Y Z).cone))) ≫
          (ℬ (ℬ X Z).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ (ℬ Z X).isLimit.lift (BinaryFan.swap (ℬ X Z).cone))
                (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.snd (ℬ Z X).cone

tactic: simp
state_before: case mk.left.mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ (((ℬ (ℬ X Y).cone.pt Z).isLimit.lift (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
          (ℬ Z (tensorObj ℬ X Y)).isLimit.lift (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.snd (ℬ Z X).cone =
    (((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ (ℬ Z Y).isLimit.lift (BinaryFan.swap (ℬ Y Z).cone))) ≫
          (ℬ (ℬ X Z).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
            (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ (ℬ Z X).isLimit.lift (BinaryFan.swap (ℬ X Z).cone))
                (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.snd (ℬ Z X).cone
state_after: no goals

tactic: dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
  Limits.IsLimit.conePointUniqueUpToIso]
state_before: case mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ((BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        ((ℬ (tensorObj ℬ X Y) Z).isLimit.conePointUniqueUpToIso (ℬ Z (tensorObj ℬ X Y)).isLimit.swapBinaryFan).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.right } =
    ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
              ((ℬ Y Z).isLimit.conePointUniqueUpToIso (ℬ Z Y).isLimit.swapBinaryFan).hom)) ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                ((ℬ X Z).isLimit.conePointUniqueUpToIso (ℬ Z X).isLimit.swapBinaryFan).hom)
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.right }
state_after: case mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ((ℬ (ℬ X Y).cone.pt Z).isLimit.lift (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
        (ℬ Z (tensorObj ℬ X Y)).isLimit.lift (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
      BinaryFan.snd (ℬ (ℬ Z X).cone.pt Y).cone =
    ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ (ℬ Z Y).isLimit.lift (BinaryFan.swap (ℬ Y Z).cone))) ≫
        (ℬ (ℬ X Z).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ (ℬ Z X).isLimit.lift (BinaryFan.swap (ℬ X Z).cone))
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      BinaryFan.snd (ℬ (ℬ Z X).cone.pt Y).cone

tactic: simp
state_before: case mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y Z : C
⊢ ((ℬ (ℬ X Y).cone.pt Z).isLimit.lift (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
        (ℬ Z (tensorObj ℬ X Y)).isLimit.lift (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
      BinaryFan.snd (ℬ (ℬ Z X).cone.pt Y).cone =
    ((ℬ X (ℬ Z Y).cone.pt).isLimit.lift
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ (ℬ Z Y).isLimit.lift (BinaryFan.swap (ℬ Y Z).cone))) ≫
        (ℬ (ℬ X Z).cone.pt Y).isLimit.lift (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
          (ℬ (ℬ Z X).cone.pt Y).isLimit.lift
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ (ℬ Z X).isLimit.lift (BinaryFan.swap (ℬ X Z).cone))
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      BinaryFan.snd (ℬ (ℬ Z X).cone.pt Y).cone
state_after: no goals