Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.associator_naturality
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

tactic: dsimp [tensorHom]
state_before: C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ tensorHom ℬ (tensorHom ℬ f₁ f₂) f₃ ≫ (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom =
    (BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫ tensorHom ℬ f₁ (tensorHom ℬ f₂ f₃)

tactic: apply IsLimit.hom_ext (ℬ _ _).isLimit
state_before: C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
        (BinaryFan.mk
          (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
            IsLimit.lift (ℬ Y₁ Y₂).isLimit
              (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
          (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
      (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom =
    (BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
      IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
        (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
          (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
            IsLimit.lift (ℬ Y₂ Y₃).isLimit
              (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))

tactic: rintro ⟨⟨⟩⟩
state_before: C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ ∀ (j : Discrete WalkingPair),
    (IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
                IsLimit.lift (ℬ Y₁ Y₂).isLimit
                  (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
              (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
          (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom) ≫
        (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app j =
      ((BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
          IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
              (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
                IsLimit.lift (ℬ Y₂ Y₃).isLimit
                  (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))) ≫
        (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app j

tactic: simp
state_before: case mk.left
C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ (IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
          (BinaryFan.mk
            (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
              IsLimit.lift (ℬ Y₁ Y₂).isLimit
                (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
            (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
        (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom) ≫
      (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.left } =
    ((BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
        IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
            (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
              IsLimit.lift (ℬ Y₂ Y₃).isLimit
                (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))) ≫
      (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.left }

tactic: apply IsLimit.hom_ext (ℬ _ _).isLimit
state_before: case mk.right
C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ (IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
          (BinaryFan.mk
            (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
              IsLimit.lift (ℬ Y₁ Y₂).isLimit
                (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
            (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
        (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom) ≫
      (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right } =
    ((BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
        IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
            (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
              IsLimit.lift (ℬ Y₂ Y₃).isLimit
                (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))) ≫
      (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }

tactic: rintro ⟨⟨⟩⟩
state_before: case mk.right
C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ ∀ (j : Discrete WalkingPair),
    ((IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
                  IsLimit.lift (ℬ Y₁ Y₂).isLimit
                    (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
                (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
            (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom) ≫
          (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }) ≫
        (ℬ Y₂ Y₃).cone.π.app j =
      (((BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
            IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
              (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
                (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
                  IsLimit.lift (ℬ Y₂ Y₃).isLimit
                    (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))) ≫
          (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }) ≫
        (ℬ Y₂ Y₃).cone.π.app j

tactic: simp
state_before: case mk.right.mk.left
C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ ((IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
                IsLimit.lift (ℬ Y₁ Y₂).isLimit
                  (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
              (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
          (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom) ≫
        (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }) ≫
      (ℬ Y₂ Y₃).cone.π.app { as := WalkingPair.left } =
    (((BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
          IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
              (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
                IsLimit.lift (ℬ Y₂ Y₃).isLimit
                  (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))) ≫
        (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }) ≫
      (ℬ Y₂ Y₃).cone.π.app { as := WalkingPair.left }

tactic: simp
state_before: case mk.right.mk.right
C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ X₃ Y₁ Y₂ Y₃ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ ((IsLimit.lift (ℬ (tensorObj ℬ Y₁ Y₂) Y₃).isLimit
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫
                IsLimit.lift (ℬ Y₁ Y₂).isLimit
                  (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ f₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ f₂)))
              (BinaryFan.snd (ℬ (tensorObj ℬ X₁ X₂) X₃).cone ≫ f₃)) ≫
          (BinaryFan.associatorOfLimitCone ℬ Y₁ Y₂ Y₃).hom) ≫
        (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }) ≫
      (ℬ Y₂ Y₃).cone.π.app { as := WalkingPair.right } =
    (((BinaryFan.associatorOfLimitCone ℬ X₁ X₂ X₃).hom ≫
          IsLimit.lift (ℬ Y₁ (tensorObj ℬ Y₂ Y₃)).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫ f₁)
              (BinaryFan.snd (ℬ X₁ (ℬ X₂ X₃).cone.pt).cone ≫
                IsLimit.lift (ℬ Y₂ Y₃).isLimit
                  (BinaryFan.mk (BinaryFan.fst (ℬ X₂ X₃).cone ≫ f₂) (BinaryFan.snd (ℬ X₂ X₃).cone ≫ f₃))))) ≫
        (ℬ Y₁ (ℬ Y₂ Y₃).cone.pt).cone.π.app { as := WalkingPair.right }) ≫
      (ℬ Y₂ Y₃).cone.π.app { as := WalkingPair.right }