[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ ((fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X)) X✝).one ≫ A.X.map f =
    ((fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X)) Y✝).one
[PROOFSTEP]
rw [← A.one.naturality, tensorUnit_map]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ 𝟙 (𝟙_ D) ≫ NatTrans.app A.one Y✝ =
    ((fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X)) Y✝).one
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ 𝟙 (𝟙_ D) ≫ NatTrans.app A.one Y✝ = NatTrans.app A.one Y✝
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ ((fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X)) X✝).mul ≫ A.X.map f =
    (A.X.map f ⊗ A.X.map f) ≫ ((fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X)) Y✝).mul
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ NatTrans.app A.mul X✝ ≫ A.X.map f = (A.X.map f ⊗ A.X.map f) ≫ NatTrans.app A.mul Y✝
[PROOFSTEP]
rw [← A.mul.naturality, tensorObj_map]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ { obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
          map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
            map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.obj
        X)
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ ({ obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
            map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
        (𝟙 X)).hom =
    (𝟙
        ({ obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
              map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.obj
          X)).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ A.X.map (𝟙 X) = 𝟙 (A.X.obj X)
[PROOFSTEP]
rw [CategoryTheory.Functor.map_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
          map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
      (f ≫ g) =
    { obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
            map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
        f ≫
      { obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
            map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
        g
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({ obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
            map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
        (f ≫ g)).hom =
    ({ obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
              map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
          f ≫
        { obj := fun X => Mon_.mk (A.X.obj X) (NatTrans.app A.one X) (NatTrans.app A.mul X),
              map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
          g).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ A.X.map (f ≫ g) = A.X.map f ≫ A.X.map g
[PROOFSTEP]
rw [Functor.map_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
⊢ (((NatTrans.mk fun X => (F.obj X).one) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul) =
    (λ_ (F ⋙ Mon_.forget D)).hom
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
X : C
⊢ NatTrans.app (((NatTrans.mk fun X => (F.obj X).one) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul) X =
    NatTrans.app (λ_ (F ⋙ Mon_.forget D)).hom X
[PROOFSTEP]
exact (F.obj X).one_mul
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
⊢ ((𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).one) ≫ NatTrans.mk fun X => (F.obj X).mul) =
    (ρ_ (F ⋙ Mon_.forget D)).hom
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
X : C
⊢ NatTrans.app ((𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).one) ≫ NatTrans.mk fun X => (F.obj X).mul) X =
    NatTrans.app (ρ_ (F ⋙ Mon_.forget D)).hom X
[PROOFSTEP]
exact (F.obj X).mul_one
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
⊢ (((NatTrans.mk fun X => (F.obj X).mul) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul) =
    (α_ (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D)).hom ≫
      (𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).mul) ≫ NatTrans.mk fun X => (F.obj X).mul
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
X : C
⊢ NatTrans.app (((NatTrans.mk fun X => (F.obj X).mul) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul) X =
    NatTrans.app
      ((α_ (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D)).hom ≫
        (𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).mul) ≫ NatTrans.mk fun X => (F.obj X).mul)
      X
[PROOFSTEP]
exact (F.obj X).mul_assoc
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
⊢ ((Inverse.obj X✝).one ≫ NatTrans.mk fun X => (NatTrans.app α X).hom) = (Inverse.obj Y✝).one
[PROOFSTEP]
ext x
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ NatTrans.app ((Inverse.obj X✝).one ≫ NatTrans.mk fun X => (NatTrans.app α X).hom) x =
    NatTrans.app (Inverse.obj Y✝).one x
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ (X✝.obj x).one ≫ (NatTrans.app α x).hom = (Y✝.obj x).one
[PROOFSTEP]
rw [(α.app x).one_hom]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
⊢ ((Inverse.obj X✝).mul ≫ NatTrans.mk fun X => (NatTrans.app α X).hom) =
    ((NatTrans.mk fun X => (NatTrans.app α X).hom) ⊗ NatTrans.mk fun X => (NatTrans.app α X).hom) ≫ (Inverse.obj Y✝).mul
[PROOFSTEP]
ext x
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ NatTrans.app ((Inverse.obj X✝).mul ≫ NatTrans.mk fun X => (NatTrans.app α X).hom) x =
    NatTrans.app
      (((NatTrans.mk fun X => (NatTrans.app α X).hom) ⊗ NatTrans.mk fun X => (NatTrans.app α X).hom) ≫
        (Inverse.obj Y✝).mul)
      x
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ (X✝.obj x).mul ≫ (NatTrans.app α x).hom = ((NatTrans.app α x).hom ⊗ (NatTrans.app α x).hom) ≫ (Y✝.obj x).mul
[PROOFSTEP]
rw [(α.app x).mul_hom]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((𝟭 (Mon_ (C ⥤ D))).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) =
    ((functor ⋙ inverse).obj A).one
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((𝟭 (Mon_ (C ⥤ D))).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) X =
    NatTrans.app ((functor ⋙ inverse).obj A).one X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.one X ≫ 𝟙 (A.X.obj X) = NatTrans.app A.one X
[PROOFSTEP]
simp only [Category.comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((𝟭 (Mon_ (C ⥤ D))).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) =
    ((NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ⊗
        NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ≫
      ((functor ⋙ inverse).obj A).mul
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((𝟭 (Mon_ (C ⥤ D))).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) X =
    NatTrans.app
      (((NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ⊗
          NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ≫
        ((functor ⋙ inverse).obj A).mul)
      X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.mul X ≫ 𝟙 (A.X.obj X) = (𝟙 (A.X.obj X) ⊗ 𝟙 (A.X.obj X)) ≫ NatTrans.app A.mul X
[PROOFSTEP]
simp only [tensor_id, Category.id_comp, Category.comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((functor ⋙ inverse).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) =
    ((𝟭 (Mon_ (C ⥤ D))).obj A).one
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((functor ⋙ inverse).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) X =
    NatTrans.app ((𝟭 (Mon_ (C ⥤ D))).obj A).one X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.one X ≫ 𝟙 (A.X.obj X) = NatTrans.app A.one X
[PROOFSTEP]
simp only [Category.comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((functor ⋙ inverse).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) =
    ((NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ⊗
        NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ≫
      ((𝟭 (Mon_ (C ⥤ D))).obj A).mul
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((functor ⋙ inverse).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) X =
    NatTrans.app
      (((NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ⊗
          NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ≫
        ((𝟭 (Mon_ (C ⥤ D))).obj A).mul)
      X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.mul X ≫ 𝟙 (A.X.obj X) = (𝟙 (A.X.obj X) ⊗ 𝟙 (A.X.obj X)) ≫ NatTrans.app A.mul X
[PROOFSTEP]
simp only [tensor_id, Category.id_comp, Category.comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : Mon_ (C ⥤ D)
f : X✝ ⟶ Y✝
⊢ (𝟭 (Mon_ (C ⥤ D))).map f ≫
      ((fun A =>
            Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
              (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
          Y✝).hom =
    ((fun A =>
            Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
              (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
          X✝).hom ≫
      (functor ⋙ inverse).map f
[PROOFSTEP]
ext X
[GOAL]
case w.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : Mon_ (C ⥤ D)
f : X✝ ⟶ Y✝
X : C
⊢ NatTrans.app
      ((𝟭 (Mon_ (C ⥤ D))).map f ≫
          ((fun A =>
                Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
                  (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
              Y✝).hom).hom
      X =
    NatTrans.app
      (((fun A =>
                Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
                  (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
              X✝).hom ≫
          (functor ⋙ inverse).map f).hom
      X
[PROOFSTEP]
simp only [Functor.id_map, Mon_.comp_hom', NatTrans.comp_app, Category.comp_id, Functor.comp_map, inverse_map_hom_app,
  functor_map_app_hom, Category.id_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : C ⥤ Mon_ D
⊢ ∀ {X Y : C} (f : X ⟶ Y),
    ((inverse ⋙ functor).obj A).map f ≫
        ((fun X =>
              Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ Mon_ D)).obj A).obj X).X)))
            Y).hom =
      ((fun X =>
              Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ Mon_ D)).obj A).obj X).X)))
            X).hom ≫
        ((𝟭 (C ⥤ Mon_ D)).obj A).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
⊢ ∀ {X Y : C ⥤ Mon_ D} (f : X ⟶ Y),
    (inverse ⋙ functor).map f ≫
        ((fun A =>
              NatIso.ofComponents fun X =>
                Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                  (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ Mon_ D)).obj A).obj X).X)))
            Y).hom =
      ((fun A =>
              NatIso.ofComponents fun X =>
                Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                  (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ Mon_ D)).obj A).obj X).X)))
            X).hom ≫
        (𝟭 (C ⥤ Mon_ D)).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : C ⥤ CommMon_ D
src✝ : Mon_ (C ⥤ D) := (monFunctorCategoryEquivalence C D).inverse.obj (F ⋙ CommMon_.forget₂Mon_ D)
⊢ (β_ (Mon_.mk src✝.X src✝.one src✝.mul).X (Mon_.mk src✝.X src✝.one src✝.mul).X).hom ≫
      (Mon_.mk src✝.X src✝.one src✝.mul).mul =
    (Mon_.mk src✝.X src✝.one src✝.mul).mul
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : C ⥤ CommMon_ D
src✝ : Mon_ (C ⥤ D) := (monFunctorCategoryEquivalence C D).inverse.obj (F ⋙ CommMon_.forget₂Mon_ D)
X : C
⊢ NatTrans.app
      ((β_ (Mon_.mk src✝.X src✝.one src✝.mul).X (Mon_.mk src✝.X src✝.one src✝.mul).X).hom ≫
        (Mon_.mk src✝.X src✝.one src✝.mul).mul)
      X =
    NatTrans.app (Mon_.mk src✝.X src✝.one src✝.mul).mul X
[PROOFSTEP]
exact (F.obj X).mul_comm
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
⊢ (((𝟭 (CommMon_ (C ⥤ D))).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)) =
    ((functor ⋙ inverse).obj A).one
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((𝟭 (CommMon_ (C ⥤ D))).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x))
      X =
    NatTrans.app ((functor ⋙ inverse).obj A).one X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.one X ≫ 𝟙 (A.X.obj X) = NatTrans.app A.one X
[PROOFSTEP]
simp only [Category.comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
⊢ (((𝟭 (CommMon_ (C ⥤ D))).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)) =
    ((NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)) ⊗
        NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)) ≫
      ((functor ⋙ inverse).obj A).mul
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((𝟭 (CommMon_ (C ⥤ D))).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x))
      X =
    NatTrans.app
      (((NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)) ⊗
          NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)) ≫
        ((functor ⋙ inverse).obj A).mul)
      X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.mul X ≫ 𝟙 (A.X.obj X) = (𝟙 (A.X.obj X) ⊗ 𝟙 (A.X.obj X)) ≫ NatTrans.app A.mul X
[PROOFSTEP]
simp only [tensor_id, Category.id_comp, Category.comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
⊢ (((functor ⋙ inverse).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) =
    ((𝟭 (CommMon_ (C ⥤ D))).obj A).one
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((functor ⋙ inverse).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) X =
    NatTrans.app ((𝟭 (CommMon_ (C ⥤ D))).obj A).one X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.one X ≫ 𝟙 ((CommMon_.forget₂Mon_ D).obj ((functor.obj A).obj X)).X = NatTrans.app A.one X
[PROOFSTEP]
simp only [Category.comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
⊢ (((functor ⋙ inverse).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) =
    ((NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ⊗
        NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ≫
      ((𝟭 (CommMon_ (C ⥤ D))).obj A).mul
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app (((functor ⋙ inverse).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) X =
    NatTrans.app
      (((NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ⊗
          NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ≫
        ((𝟭 (CommMon_ (C ⥤ D))).obj A).mul)
      X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : CommMon_ (C ⥤ D)
X : C
⊢ NatTrans.app A.mul X ≫ 𝟙 ((CommMon_.forget₂Mon_ D).obj ((functor.obj A).obj X)).X =
    (𝟙 ((CommMon_.forget₂Mon_ D).obj ((functor.obj A).obj X)).X ⊗
        𝟙 ((CommMon_.forget₂Mon_ D).obj ((functor.obj A).obj X)).X) ≫
      NatTrans.app A.mul X
[PROOFSTEP]
simp only [tensor_id, Category.id_comp, Category.comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝ Y✝ : CommMon_ (C ⥤ D)
f : X✝ ⟶ Y✝
⊢ (𝟭 (CommMon_ (C ⥤ D))).map f ≫
      ((fun A =>
            Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)))
              (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
          Y✝).hom =
    ((fun A =>
            Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)))
              (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
          X✝).hom ≫
      (functor ⋙ inverse).map f
[PROOFSTEP]
ext X
[GOAL]
case h.w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝ Y✝ : CommMon_ (C ⥤ D)
f : X✝ ⟶ Y✝
X : C
⊢ NatTrans.app
      ((𝟭 (CommMon_ (C ⥤ D))).map f ≫
          ((fun A =>
                Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)))
                  (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
              Y✝).hom).hom
      X =
    NatTrans.app
      (((fun A =>
                Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (CommMon_ (C ⥤ D))).obj A).X.obj x)))
                  (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
              X✝).hom ≫
          (functor ⋙ inverse).map f).hom
      X
[PROOFSTEP]
dsimp
[GOAL]
case h.w.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝ Y✝ : CommMon_ (C ⥤ D)
f : X✝ ⟶ Y✝
X : C
⊢ NatTrans.app f.hom X ≫ 𝟙 (Y✝.X.obj X) = 𝟙 (X✝.X.obj X) ≫ NatTrans.app f.hom X
[PROOFSTEP]
simp only [Category.id_comp, Category.comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
A : C ⥤ CommMon_ D
⊢ ∀ {X Y : C} (f : X ⟶ Y),
    ((inverse ⋙ functor).obj A).map f ≫
        ((fun X =>
              Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ CommMon_ D)).obj A).obj X).X)))
            Y).hom =
      ((fun X =>
              Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ CommMon_ D)).obj A).obj X).X)))
            X).hom ≫
        ((𝟭 (C ⥤ CommMon_ D)).obj A).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
⊢ ∀ {X Y : C ⥤ CommMon_ D} (f : X ⟶ Y),
    (inverse ⋙ functor).map f ≫
        ((fun A =>
              NatIso.ofComponents fun X =>
                Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                  (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ CommMon_ D)).obj A).obj X).X)))
            Y).hom =
      ((fun A =>
              NatIso.ofComponents fun X =>
                Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                  (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ CommMon_ D)).obj A).obj X).X)))
            X).hom ≫
        (𝟭 (C ⥤ CommMon_ D)).map f
[PROOFSTEP]
aesop_cat
