l3lab/ntp-mathlib huggingface dataset:
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ X'✝ Y✝ Y'✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : X'✝ ⟶ Y'✝
⊢ (f✝ ⊗ g✝) ≫ (β Y✝ Y'✝).hom = (β X✝ X'✝).hom ≫ (g✝ ⊗ f✝)

Next tactic:
apply F.map_injective
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ X'✝ Y✝ Y'✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : X'✝ ⟶ Y'✝
⊢ F.map ((f✝ ⊗ g✝) ≫ (β Y✝ Y'✝).hom) = F.map ((β X✝ X'✝).hom ≫ (g✝ ⊗ f✝))

Next tactic:
refine (cancel_epi (F.μ ?_ ?_)).1 ?_
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ X'✝ Y✝ Y'✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : X'✝ ⟶ Y'✝
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ X'✝ ≫ F.map ((f✝ ⊗ g✝) ≫ (β Y✝ Y'✝).hom) =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ X'✝ ≫ F.map ((β X✝ X'✝).hom ≫ (g✝ ⊗ f✝))

Next tactic:
rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
⊢ ∀ (X Y Z : C),
    (α_ X Y Z).hom ≫ (β X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom = ((β X Y).hom ⊗ 𝟙 Z) ≫ (α_ Y X Z).hom ≫ (𝟙 Y ⊗ (β X Z).hom)

Next tactic:
intros
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ (α_ X✝ Y✝ Z✝).hom ≫ (β X✝ (Y✝ ⊗ Z✝)).hom ≫ (α_ Y✝ Z✝ X✝).hom =
    ((β X✝ Y✝).hom ⊗ 𝟙 Z✝) ≫ (α_ Y✝ X✝ Z✝).hom ≫ (𝟙 Y✝ ⊗ (β X✝ Z✝).hom)

Next tactic:
apply F.map_injective
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ F.map ((α_ X✝ Y✝ Z✝).hom ≫ (β X✝ (Y✝ ⊗ Z✝)).hom ≫ (α_ Y✝ Z✝ X✝).hom) =
    F.map (((β X✝ Y✝).hom ⊗ 𝟙 Z✝) ≫ (α_ Y✝ X✝ Z✝).hom ≫ (𝟙 Y✝ ⊗ (β X✝ Z✝).hom))

Next tactic:
refine (cancel_epi (F.μ _ _)).1 ?_
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (X✝ ⊗ Y✝) Z✝ ≫
      F.map ((α_ X✝ Y✝ Z✝).hom ≫ (β X✝ (Y✝ ⊗ Z✝)).hom ≫ (α_ Y✝ Z✝ X✝).hom) =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (X✝ ⊗ Y✝) Z✝ ≫
      F.map (((β X✝ Y✝).hom ⊗ 𝟙 Z✝) ≫ (α_ Y✝ X✝ Z✝).hom ≫ (𝟙 Y✝ ⊗ (β X✝ Z✝).hom))

Next tactic:
refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ Y✝ ⊗ 𝟙 (F.obj Z✝)) ≫
      LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (X✝ ⊗ Y✝) Z✝ ≫
        F.map ((α_ X✝ Y✝ Z✝).hom ≫ (β X✝ (Y✝ ⊗ Z✝)).hom ≫ (α_ Y✝ Z✝ X✝).hom) =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ Y✝ ⊗ 𝟙 (F.obj Z✝)) ≫
      LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (X✝ ⊗ Y✝) Z✝ ≫
        F.map (((β X✝ Y✝).hom ⊗ 𝟙 Z✝) ≫ (α_ Y✝ X✝ Z✝).hom ≫ (𝟙 Y✝ ⊗ (β X✝ Z✝).hom))

Next tactic:
rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← comp_tensor_id_assoc, w,
      comp_tensor_id, assoc, LaxMonoidalFunctor.associativity_assoc,
      LaxMonoidalFunctor.associativity_assoc, ← LaxMonoidalFunctor.μ_natural, Functor.map_id, ←
      id_tensor_comp_assoc, w, id_tensor_comp_assoc, reassoc_of% w, braiding_naturality_assoc,
      LaxMonoidalFunctor.associativity, hexagon_forward_assoc]
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
    rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← comp_tensor_id_assoc, w,
      comp_tensor_id, assoc, LaxMonoidalFunctor.associativity_assoc,
      LaxMonoidalFunctor.associativity_assoc, ← LaxMonoidalFunctor.μ_natural, Functor.map_id, ←
      id_tensor_comp_assoc, w, id_tensor_comp_assoc, reassoc_of% w, braiding_naturality_assoc,
      LaxMonoidalFunctor.associativity, hexagon_forward_assoc]
  hexagon_reverse := by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
⊢ ∀ (X Y Z : C),
    (α_ X Y Z).inv ≫ (β (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv = (𝟙 X ⊗ (β Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((β X Z).hom ⊗ 𝟙 Y)

Next tactic:
intros
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
    rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← comp_tensor_id_assoc, w,
      comp_tensor_id, assoc, LaxMonoidalFunctor.associativity_assoc,
      LaxMonoidalFunctor.associativity_assoc, ← LaxMonoidalFunctor.μ_natural, Functor.map_id, ←
      id_tensor_comp_assoc, w, id_tensor_comp_assoc, reassoc_of% w, braiding_naturality_assoc,
      LaxMonoidalFunctor.associativity, hexagon_forward_assoc]
  hexagon_reverse := by
    intros
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ (α_ X✝ Y✝ Z✝).inv ≫ (β (X✝ ⊗ Y✝) Z✝).hom ≫ (α_ Z✝ X✝ Y✝).inv =
    (𝟙 X✝ ⊗ (β Y✝ Z✝).hom) ≫ (α_ X✝ Z✝ Y✝).inv ≫ ((β X✝ Z✝).hom ⊗ 𝟙 Y✝)

Next tactic:
apply F.toFunctor.map_injective
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
    rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← comp_tensor_id_assoc, w,
      comp_tensor_id, assoc, LaxMonoidalFunctor.associativity_assoc,
      LaxMonoidalFunctor.associativity_assoc, ← LaxMonoidalFunctor.μ_natural, Functor.map_id, ←
      id_tensor_comp_assoc, w, id_tensor_comp_assoc, reassoc_of% w, braiding_naturality_assoc,
      LaxMonoidalFunctor.associativity, hexagon_forward_assoc]
  hexagon_reverse := by
    intros
    apply F.toFunctor.map_injective
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ F.map ((α_ X✝ Y✝ Z✝).inv ≫ (β (X✝ ⊗ Y✝) Z✝).hom ≫ (α_ Z✝ X✝ Y✝).inv) =
    F.map ((𝟙 X✝ ⊗ (β Y✝ Z✝).hom) ≫ (α_ X✝ Z✝ Y✝).inv ≫ ((β X✝ Z✝).hom ⊗ 𝟙 Y✝))

Next tactic:
refine (cancel_epi (F.μ _ _)).1 ?_
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
    rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← comp_tensor_id_assoc, w,
      comp_tensor_id, assoc, LaxMonoidalFunctor.associativity_assoc,
      LaxMonoidalFunctor.associativity_assoc, ← LaxMonoidalFunctor.μ_natural, Functor.map_id, ←
      id_tensor_comp_assoc, w, id_tensor_comp_assoc, reassoc_of% w, braiding_naturality_assoc,
      LaxMonoidalFunctor.associativity, hexagon_forward_assoc]
  hexagon_reverse := by
    intros
    apply F.toFunctor.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ (Y✝ ⊗ Z✝) ≫
      F.map ((α_ X✝ Y✝ Z✝).inv ≫ (β (X✝ ⊗ Y✝) Z✝).hom ≫ (α_ Z✝ X✝ Y✝).inv) =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ (Y✝ ⊗ Z✝) ≫
      F.map ((𝟙 X✝ ⊗ (β Y✝ Z✝).hom) ≫ (α_ X✝ Z✝ Y✝).inv ≫ ((β X✝ Z✝).hom ⊗ 𝟙 Y✝))

Next tactic:
refine (cancel_epi (𝟙 _ ⊗ F.μ _ _)).1 ?_
/--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [Faithful F.toFunctor] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C where
  braiding := β
  braiding_naturality := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ ?_ ?_)).1 ?_
    rw [Functor.map_comp, ← LaxMonoidalFunctor.μ_natural_assoc, w, Functor.map_comp, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.μ_natural]
  hexagon_forward := by
    intros
    apply F.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (F.μ _ _ ⊗ 𝟙 _)).1 ?_
    rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← comp_tensor_id_assoc, w,
      comp_tensor_id, assoc, LaxMonoidalFunctor.associativity_assoc,
      LaxMonoidalFunctor.associativity_assoc, ← LaxMonoidalFunctor.μ_natural, Functor.map_id, ←
      id_tensor_comp_assoc, w, id_tensor_comp_assoc, reassoc_of% w, braiding_naturality_assoc,
      LaxMonoidalFunctor.associativity, hexagon_forward_assoc]
  hexagon_reverse := by
    intros
    apply F.toFunctor.map_injective
    refine (cancel_epi (F.μ _ _)).1 ?_
    refine (cancel_epi (𝟙 _ ⊗ F.μ _ _)).1 ?_
    

Proof state:
case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.38984, u_1} C
inst✝⁴ : Category.{?u.38988, u_2} D
inst✝³ : MonoidalCategory C
inst✝² : MonoidalCategory D
F : MonoidalFunctor C D
inst✝¹ : Faithful F.toFunctor
inst✝ : BraidedCategory D
β : (X Y : C) → X ⊗ Y ≅ Y ⊗ X
w :
  ∀ (X Y : C),
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y ≫ F.map (β X Y).hom =
      (β_ (F.obj X) (F.obj Y)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y X
X✝ Y✝ Z✝ : C
⊢ (𝟙 (F.obj X✝) ⊗ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y✝ Z✝) ≫
      LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ (Y✝ ⊗ Z✝) ≫
        F.map ((α_ X✝ Y✝ Z✝).inv ≫ (β (X✝ ⊗ Y✝) Z✝).hom ≫ (α_ Z✝ X✝ Y✝).inv) =
    (𝟙 (F.obj X✝) ⊗ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y✝ Z✝) ≫
      LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X✝ (Y✝ ⊗ Z✝) ≫
        F.map ((𝟙 X✝ ⊗ (β Y✝ Z✝).hom) ≫ (α_ X✝ Z✝ Y✝).inv ≫ ((β X✝ Z✝).hom ⊗ 𝟙 Y✝))

Next tactic:
rw [Functor.map_comp, Functor.map_comp, Functor.map_comp, Functor.map_comp, ←
      LaxMonoidalFunctor.μ_natural_assoc, Functor.map_id, ← id_tensor_comp_assoc, w,
      id_tensor_comp_assoc, LaxMonoidalFunctor.associativity_inv_assoc,
      LaxMonoidalFunctor.associativity_inv_assoc, ← LaxMonoidalFunctor.μ_natural,
      Functor.map_id, ← comp_tensor_id_assoc, w, comp_tensor_id_assoc, reassoc_of% w,
      braiding_naturality_assoc, LaxMonoidalFunctor.associativity_inv, hexagon_reverse_assoc]