l3lab/ntp-mathlib huggingface dataset:
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    

Proof state:
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 ≫
            (IsLimit.conePointUniqueUpToIso (ℬ (tensorObj ℬ X Y) Z).isLimit
                  (IsLimit.swapBinaryFan (ℬ Z (tensorObj ℬ X Y)).isLimit)).hom ≫
              (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
          (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
        (ℬ Z X).cone.π.app j =
      ((IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
              (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
                (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                  (IsLimit.conePointUniqueUpToIso (ℬ Y Z).isLimit (IsLimit.swapBinaryFan (ℬ Z Y).isLimit)).hom)) ≫
            (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
              IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
                (BinaryFan.mk
                  (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                    (IsLimit.conePointUniqueUpToIso (ℬ X Z).isLimit (IsLimit.swapBinaryFan (ℬ Z X).isLimit)).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

Next tactic:
rintro ⟨⟨⟩⟩
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    rintro ⟨⟨⟩⟩ <;>
      · 

Proof state:
case mk.left.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 ≫
          (IsLimit.conePointUniqueUpToIso (ℬ (tensorObj ℬ X Y) Z).isLimit
                (IsLimit.swapBinaryFan (ℬ Z (tensorObj ℬ X Y)).isLimit)).hom ≫
            (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
      (ℬ Z X).cone.π.app { as := WalkingPair.left } =
    ((IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                (IsLimit.conePointUniqueUpToIso (ℬ Y Z).isLimit (IsLimit.swapBinaryFan (ℬ Z Y).isLimit)).hom)) ≫
          (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
            IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                  (IsLimit.conePointUniqueUpToIso (ℬ X Z).isLimit (IsLimit.swapBinaryFan (ℬ Z X).isLimit)).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.left }

Next tactic:
dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
          Limits.IsLimit.conePointUniqueUpToIso]
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    rintro ⟨⟨⟩⟩ <;>
      · dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
          Limits.IsLimit.conePointUniqueUpToIso]
        

Proof state:
case mk.left.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
⊢ ((IsLimit.lift (ℬ (ℬ X Y).cone.pt Z).isLimit (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
          IsLimit.lift (ℬ Z (tensorObj ℬ X Y)).isLimit (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
            IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
              (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.fst (ℬ Z X).cone =
    ((IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ IsLimit.lift (ℬ Z Y).isLimit (BinaryFan.swap (ℬ Y Z).cone))) ≫
          IsLimit.lift (ℬ (ℬ X Z).cone.pt Y).isLimit (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
            IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ IsLimit.lift (ℬ Z X).isLimit (BinaryFan.swap (ℬ X Z).cone))
                (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.fst (ℬ Z X).cone

Next tactic:
simp
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    rintro ⟨⟨⟩⟩ <;>
      · 

Proof state:
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 ≫
          (IsLimit.conePointUniqueUpToIso (ℬ (tensorObj ℬ X Y) Z).isLimit
                (IsLimit.swapBinaryFan (ℬ Z (tensorObj ℬ X Y)).isLimit)).hom ≫
            (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
        (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.left }) ≫
      (ℬ Z X).cone.π.app { as := WalkingPair.right } =
    ((IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
                (IsLimit.conePointUniqueUpToIso (ℬ Y Z).isLimit (IsLimit.swapBinaryFan (ℬ Z Y).isLimit)).hom)) ≫
          (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
            IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                  (IsLimit.conePointUniqueUpToIso (ℬ X Z).isLimit (IsLimit.swapBinaryFan (ℬ Z X).isLimit)).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 }

Next tactic:
dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
          Limits.IsLimit.conePointUniqueUpToIso]
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    rintro ⟨⟨⟩⟩ <;>
      · dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
          Limits.IsLimit.conePointUniqueUpToIso]
        

Proof state:
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
⊢ ((IsLimit.lift (ℬ (ℬ X Y).cone.pt Z).isLimit (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
          IsLimit.lift (ℬ Z (tensorObj ℬ X Y)).isLimit (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
            IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
              (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
        BinaryFan.fst (ℬ (ℬ Z X).cone.pt Y).cone) ≫
      BinaryFan.snd (ℬ Z X).cone =
    ((IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
            (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
              (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ IsLimit.lift (ℬ Z Y).isLimit (BinaryFan.swap (ℬ Y Z).cone))) ≫
          IsLimit.lift (ℬ (ℬ X Z).cone.pt Y).isLimit (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
            IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
              (BinaryFan.mk
                (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ IsLimit.lift (ℬ Z X).isLimit (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

Next tactic:
simp
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    rintro ⟨⟨⟩⟩ <;>
      · dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
          Limits.IsLimit.conePointUniqueUpToIso]
        simp
  · 

Proof state:
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 ≫
        (IsLimit.conePointUniqueUpToIso (ℬ (tensorObj ℬ X Y) Z).isLimit
              (IsLimit.swapBinaryFan (ℬ Z (tensorObj ℬ X Y)).isLimit)).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.right } =
    (IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫
              (IsLimit.conePointUniqueUpToIso (ℬ Y Z).isLimit (IsLimit.swapBinaryFan (ℬ Z Y).isLimit)).hom)) ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫
                (IsLimit.conePointUniqueUpToIso (ℬ X Z).isLimit (IsLimit.swapBinaryFan (ℬ Z X).isLimit)).hom)
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      (ℬ (ℬ Z X).cone.pt Y).cone.π.app { as := WalkingPair.right }

Next tactic:
dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
      Limits.IsLimit.conePointUniqueUpToIso]
theorem hexagon_reverse (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).inv ≫
        (Limits.BinaryFan.braiding (ℬ (tensorObj ℬ X Y) Z).isLimit
              (ℬ Z (tensorObj ℬ X Y)).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Z X Y).inv =
      tensorHom ℬ (𝟙 X) (Limits.BinaryFan.braiding (ℬ Y Z).isLimit (ℬ Z Y).isLimit).hom ≫
        (BinaryFan.associatorOfLimitCone ℬ X Z Y).inv ≫
          tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom (𝟙 Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext; rintro ⟨⟨⟩⟩
  · apply (ℬ _ _).isLimit.hom_ext
    rintro ⟨⟨⟩⟩ <;>
      · dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
          Limits.IsLimit.conePointUniqueUpToIso]
        simp
  · dsimp [BinaryFan.associatorOfLimitCone, BinaryFan.associator,
      Limits.IsLimit.conePointUniqueUpToIso]
    

Proof state:
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
⊢ (IsLimit.lift (ℬ (ℬ X Y).cone.pt Z).isLimit (BinaryFan.assocInv (ℬ X Y).isLimit (ℬ X (ℬ Y Z).cone.pt).cone) ≫
        IsLimit.lift (ℬ Z (tensorObj ℬ X Y)).isLimit (BinaryFan.swap (ℬ (tensorObj ℬ X Y) Z).cone) ≫
          IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit (BinaryFan.assocInv (ℬ Z X).isLimit (ℬ Z (ℬ X Y).cone.pt).cone)) ≫
      BinaryFan.snd (ℬ (ℬ Z X).cone.pt Y).cone =
    (IsLimit.lift (ℬ X (ℬ Z Y).cone.pt).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ X (ℬ Y Z).cone.pt).cone ≫ 𝟙 X)
            (BinaryFan.snd (ℬ X (ℬ Y Z).cone.pt).cone ≫ IsLimit.lift (ℬ Z Y).isLimit (BinaryFan.swap (ℬ Y Z).cone))) ≫
        IsLimit.lift (ℬ (ℬ X Z).cone.pt Y).isLimit (BinaryFan.assocInv (ℬ X Z).isLimit (ℬ X (ℬ Z Y).cone.pt).cone) ≫
          IsLimit.lift (ℬ (ℬ Z X).cone.pt Y).isLimit
            (BinaryFan.mk
              (BinaryFan.fst (ℬ (ℬ X Z).cone.pt Y).cone ≫ IsLimit.lift (ℬ Z X).isLimit (BinaryFan.swap (ℬ X Z).cone))
              (BinaryFan.snd (ℬ (ℬ X Z).cone.pt Y).cone ≫ 𝟙 Y))) ≫
      BinaryFan.snd (ℬ (ℬ Z X).cone.pt Y).cone

Next tactic:
simp
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y : C
⊢ (BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫ (BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
    𝟙 (tensorObj ℬ X Y)

Next tactic:
dsimp [tensorHom, Limits.BinaryFan.braiding]
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y : C
⊢ (IsLimit.conePointUniqueUpToIso (ℬ X Y).isLimit (IsLimit.swapBinaryFan (ℬ Y X).isLimit)).hom ≫
      (IsLimit.conePointUniqueUpToIso (ℬ Y X).isLimit (IsLimit.swapBinaryFan (ℬ X Y).isLimit)).hom =
    𝟙 (tensorObj ℬ X Y)

Next tactic:
apply (ℬ _ _).isLimit.hom_ext
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext;
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X Y : C
⊢ ∀ (j : Discrete WalkingPair),
    ((IsLimit.conePointUniqueUpToIso (ℬ X Y).isLimit (IsLimit.swapBinaryFan (ℬ Y X).isLimit)).hom ≫
          (IsLimit.conePointUniqueUpToIso (ℬ Y X).isLimit (IsLimit.swapBinaryFan (ℬ X Y).isLimit)).hom) ≫
        (ℬ X Y).cone.π.app j =
      𝟙 (tensorObj ℬ X Y) ≫ (ℬ X Y).cone.π.app j

Next tactic:
rintro ⟨⟨⟩⟩
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext;
  rintro ⟨⟨⟩⟩ <;> · 

Proof state:
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 : C
⊢ ((IsLimit.conePointUniqueUpToIso (ℬ X Y).isLimit (IsLimit.swapBinaryFan (ℬ Y X).isLimit)).hom ≫
        (IsLimit.conePointUniqueUpToIso (ℬ Y X).isLimit (IsLimit.swapBinaryFan (ℬ X Y).isLimit)).hom) ≫
      (ℬ X Y).cone.π.app { as := WalkingPair.left } =
    𝟙 (tensorObj ℬ X Y) ≫ (ℬ X Y).cone.π.app { as := WalkingPair.left }

Next tactic:
dsimp [Limits.IsLimit.conePointUniqueUpToIso]
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext;
  rintro ⟨⟨⟩⟩ <;> · dsimp [Limits.IsLimit.conePointUniqueUpToIso]; 

Proof state:
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 : C
⊢ (IsLimit.lift (ℬ Y X).isLimit (BinaryFan.swap (ℬ X Y).cone) ≫
        IsLimit.lift (ℬ X Y).isLimit (BinaryFan.swap (ℬ Y X).cone)) ≫
      BinaryFan.fst (ℬ X Y).cone =
    𝟙 (tensorObj ℬ X Y) ≫ BinaryFan.fst (ℬ X Y).cone

Next tactic:
simp
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext;
  rintro ⟨⟨⟩⟩ <;> · 

Proof state:
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 : C
⊢ ((IsLimit.conePointUniqueUpToIso (ℬ X Y).isLimit (IsLimit.swapBinaryFan (ℬ Y X).isLimit)).hom ≫
        (IsLimit.conePointUniqueUpToIso (ℬ Y X).isLimit (IsLimit.swapBinaryFan (ℬ X Y).isLimit)).hom) ≫
      (ℬ X Y).cone.π.app { as := WalkingPair.right } =
    𝟙 (tensorObj ℬ X Y) ≫ (ℬ X Y).cone.π.app { as := WalkingPair.right }

Next tactic:
dsimp [Limits.IsLimit.conePointUniqueUpToIso]
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y) := by
  dsimp [tensorHom, Limits.BinaryFan.braiding]
  apply (ℬ _ _).isLimit.hom_ext;
  rintro ⟨⟨⟩⟩ <;> · dsimp [Limits.IsLimit.conePointUniqueUpToIso]; 

Proof state:
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 : C
⊢ (IsLimit.lift (ℬ Y X).isLimit (BinaryFan.swap (ℬ X Y).cone) ≫
        IsLimit.lift (ℬ X Y).isLimit (BinaryFan.swap (ℬ Y X).cone)) ≫
      BinaryFan.snd (ℬ X Y).cone =
    𝟙 (tensorObj ℬ X Y) ≫ BinaryFan.snd (ℬ X Y).cone

Next tactic:
simp
@[to_additive]
instance [SMul M N] [IsScalarTower M N α] : IsScalarTower M N (Option α) :=
  ⟨fun a b x => by
    

Proof state:
M : Type u_1
N : Type u_2
α : Type u_3
inst✝³ : SMul M α
inst✝² : SMul N α
a✝ : M
b✝ : α
x✝ : Option α
inst✝¹ : SMul M N
inst✝ : IsScalarTower M N α
a : M
b : N
x : Option α
⊢ (a • b) • x = a • b • x

Next tactic:
cases x
@[to_additive]
instance [SMul M N] [IsScalarTower M N α] : IsScalarTower M N (Option α) :=
  ⟨fun a b x => by
    cases x
    

Proof state:
case none
M : Type u_1
N : Type u_2
α : Type u_3
inst✝³ : SMul M α
inst✝² : SMul N α
a✝ : M
b✝ : α
x : Option α
inst✝¹ : SMul M N
inst✝ : IsScalarTower M N α
a : M
b : N
⊢ (a • b) • none = a • b • none
case some
M : Type u_1
N : Type u_2
α : Type u_3
inst✝³ : SMul M α
inst✝² : SMul N α
a✝ : M
b✝ : α
x : Option α
inst✝¹ : SMul M N
inst✝ : IsScalarTower M N α
a : M
b : N
val✝ : α
⊢ (a • b) • some val✝ = a • b • some val✝

Next tactic:
exacts [rfl, congr_arg some (smul_assoc _ _ _)]
@[to_additive]
instance [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] : IsCentralScalar M (Option α) :=
  ⟨fun a x => by
    

Proof state:
M : Type u_1
N : Type u_2
α : Type u_3
inst✝³ : SMul M α
inst✝² : SMul N α
a✝ : M
b : α
x✝ : Option α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
a : M
x : Option α
⊢ MulOpposite.op a • x = a • x

Next tactic:
cases x
@[to_additive]
instance [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] : IsCentralScalar M (Option α) :=
  ⟨fun a x => by
    cases x
    

Proof state:
case none
M : Type u_1
N : Type u_2
α : Type u_3
inst✝³ : SMul M α
inst✝² : SMul N α
a✝ : M
b : α
x : Option α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
a : M
⊢ MulOpposite.op a • none = a • none
case some
M : Type u_1
N : Type u_2
α : Type u_3
inst✝³ : SMul M α
inst✝² : SMul N α
a✝ : M
b : α
x : Option α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
a : M
val✝ : α
⊢ MulOpposite.op a • some val✝ = a • some val✝

Next tactic:
exacts [rfl, congr_arg some (op_smul_eq_smul _ _)]
@[to_additive]
instance [FaithfulSMul M α] : FaithfulSMul M (Option α) :=
  ⟨fun h => eq_of_smul_eq_smul fun b : α => by 

Proof state:
M : Type u_1
N : Type u_2
α : Type u_3
inst✝² : SMul M α
inst✝¹ : SMul N α
a : M
b✝ : α
x : Option α
inst✝ : FaithfulSMul M α
m₁✝ m₂✝ : M
h : ∀ (a : Option α), m₁✝ • a = m₂✝ • a
b : α
⊢ m₁✝ • b = m₂✝ • b

Next tactic:
injection h (some b)
instance [Monoid M] [MulAction M α] :
    MulAction M (Option α) where
  smul := (· • ·)
  one_smul b := by
    

Proof state:
M : Type u_1
N : Type u_2
α : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
b : Option α
⊢ 1 • b = b

Next tactic:
cases b
instance [Monoid M] [MulAction M α] :
    MulAction M (Option α) where
  smul := (· • ·)
  one_smul b := by
    cases b
    

Proof state:
case none
M : Type u_1
N : Type u_2
α : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
⊢ 1 • none = none
case some
M : Type u_1
N : Type u_2
α : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
val✝ : α
⊢ 1 • some val✝ = some val✝

Next tactic:
exacts [rfl, congr_arg some (one_smul _ _)]
instance [Monoid M] [MulAction M α] :
    MulAction M (Option α) where
  smul := (· • ·)
  one_smul b := by
    cases b
    exacts [rfl, congr_arg some (one_smul _ _)]
  mul_smul a₁ a₂ b := by
    

Proof state:
M : Type u_1
N : Type u_2
α : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
a₁ a₂ : M
b : Option α
⊢ (a₁ * a₂) • b = a₁ • a₂ • b

Next tactic:
cases b
instance [Monoid M] [MulAction M α] :
    MulAction M (Option α) where
  smul := (· • ·)
  one_smul b := by
    cases b
    exacts [rfl, congr_arg some (one_smul _ _)]
  mul_smul a₁ a₂ b := by
    cases b
    

Proof state:
case none
M : Type u_1
N : Type u_2
α : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
a₁ a₂ : M
⊢ (a₁ * a₂) • none = a₁ • a₂ • none
case some
M : Type u_1
N : Type u_2
α : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
a₁ a₂ : M
val✝ : α
⊢ (a₁ * a₂) • some val✝ = a₁ • a₂ • some val✝

Next tactic:
exacts [rfl, congr_arg some (mul_smul _ _ _)]
instance orderedStructure_LE [LE M] : OrderedStructure Language.order M := by
  

Proof state:
L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ OrderedStructure Language.order M

Next tactic:
rw [orderedStructure_iff, orderLHom_order]
instance orderedStructure_LE [LE M] : OrderedStructure Language.order M := by
  rw [orderedStructure_iff, orderLHom_order]
  

Proof state:
L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ LHom.IsExpansionOn (LHom.id Language.order) M

Next tactic:
exact LHom.id_isExpansionOn M