l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem of_isoOfHomeo {X Y : TopCat.{u}} (f : X ≃ₜ Y) : homeoOfIso (isoOfHomeo f) = f := by
  -- Porting note: unfold some defs now
  dsimp [homeoOfIso, isoOfHomeo]
  

Proof state:
X Y : TopCat
f : ↑X ≃ₜ ↑Y
⊢ Homeomorph.mk
      { toFun := ⇑(Homeomorph.toContinuousMap f), invFun := ⇑(Homeomorph.toContinuousMap (Homeomorph.symm f)),
        left_inv :=
          (_ :
            ∀ (x : ↑X),
              (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).2
                  ((Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).1 x) =
                x),
        right_inv :=
          (_ :
            ∀ (x : ↑Y),
              (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).1
                  ((Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).2 x) =
                x) } =
    f

Next tactic:
ext
@[simp]
theorem of_isoOfHomeo {X Y : TopCat.{u}} (f : X ≃ₜ Y) : homeoOfIso (isoOfHomeo f) = f := by
  -- Porting note: unfold some defs now
  dsimp [homeoOfIso, isoOfHomeo]
  ext
  

Proof state:
case H
X Y : TopCat
f : ↑X ≃ₜ ↑Y
x✝ : ↑X
⊢ (Homeomorph.mk
        { toFun := ⇑(Homeomorph.toContinuousMap f), invFun := ⇑(Homeomorph.toContinuousMap (Homeomorph.symm f)),
          left_inv :=
            (_ :
              ∀ (x : ↑X),
                (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).2
                    ((Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).1 x) =
                  x),
          right_inv :=
            (_ :
              ∀ (x : ↑Y),
                (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).1
                    ((Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).2 x) =
                  x) })
      x✝ =
    f x✝

Next tactic:
rfl
@[simp]
theorem of_homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : isoOfHomeo (homeoOfIso f) = f := by
  -- Porting note: unfold some defs now
  

Proof state:
X Y : TopCat
f : X ≅ Y
⊢ isoOfHomeo (homeoOfIso f) = f

Next tactic:
dsimp [homeoOfIso, isoOfHomeo]
@[simp]
theorem of_homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : isoOfHomeo (homeoOfIso f) = f := by
  -- Porting note: unfold some defs now
  dsimp [homeoOfIso, isoOfHomeo]
  

Proof state:
X Y : TopCat
f : X ≅ Y
⊢ Iso.mk
      (Homeomorph.toContinuousMap
        (Homeomorph.mk
          { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := (_ : ∀ (x : ↑X), f.2 (f.1 x) = x),
            right_inv := (_ : ∀ (x : ↑Y), f.1 (f.2 x) = x) }))
      (Homeomorph.toContinuousMap
        (Homeomorph.symm
          (Homeomorph.mk
            { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := (_ : ∀ (x : ↑X), f.2 (f.1 x) = x),
              right_inv := (_ : ∀ (x : ↑Y), f.1 (f.2 x) = x) }))) =
    f

Next tactic:
ext
@[simp]
theorem of_homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : isoOfHomeo (homeoOfIso f) = f := by
  -- Porting note: unfold some defs now
  dsimp [homeoOfIso, isoOfHomeo]
  ext
  

Proof state:
case w.w
X Y : TopCat
f : X ≅ Y
x✝ : (forget TopCat).obj X
⊢ (Iso.mk
          (Homeomorph.toContinuousMap
            (Homeomorph.mk
              { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := (_ : ∀ (x : ↑X), f.2 (f.1 x) = x),
                right_inv := (_ : ∀ (x : ↑Y), f.1 (f.2 x) = x) }))
          (Homeomorph.toContinuousMap
            (Homeomorph.symm
              (Homeomorph.mk
                { toFun := ⇑f.hom, invFun := ⇑f.inv, left_inv := (_ : ∀ (x : ↑X), f.2 (f.1 x) = x),
                  right_inv := (_ : ∀ (x : ↑Y), f.1 (f.2 x) = x) })))).hom
      x✝ =
    f.hom x✝

Next tactic:
rfl
@[simp]
theorem openEmbedding_iff_comp_isIso' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding f := by
  

Proof state:
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso g
⊢ OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding ⇑f

Next tactic:
simp only [← Functor.map_comp]
@[simp]
theorem openEmbedding_iff_comp_isIso' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding f := by
  simp only [← Functor.map_comp]
  

Proof state:
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso g
⊢ OpenEmbedding ((forget TopCat).map (f ≫ g)) ↔ OpenEmbedding ⇑f

Next tactic:
exact openEmbedding_iff_comp_isIso f g
theorem openEmbedding_iff_isIso_comp {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding g := by
  

Proof state:
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ⇑(f ≫ g) ↔ OpenEmbedding ⇑g

Next tactic:
constructor
theorem openEmbedding_iff_isIso_comp {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding g := by
  constructor
  · 

Proof state:
case mp
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ⇑(f ≫ g) → OpenEmbedding ⇑g

Next tactic:
intro h
theorem openEmbedding_iff_isIso_comp {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding g := by
  constructor
  · intro h
    

Proof state:
case mp
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
h : OpenEmbedding ⇑(f ≫ g)
⊢ OpenEmbedding ⇑g

Next tactic:
convert h.comp (TopCat.homeoOfIso (asIso f).symm).openEmbedding
theorem openEmbedding_iff_isIso_comp {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding g := by
  constructor
  · intro h
    convert h.comp (TopCat.homeoOfIso (asIso f).symm).openEmbedding
    

Proof state:
case h.e'_5.h
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
h : OpenEmbedding ⇑(f ≫ g)
e_1✝ : (forget TopCat).obj Y = ↑Y
⊢ ⇑g = ⇑(f ≫ g) ∘ ⇑(homeoOfIso (asIso f).symm)

Next tactic:
exact congrArg _ (IsIso.inv_hom_id_assoc f g).symm
theorem openEmbedding_iff_isIso_comp {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding g := by
  constructor
  · intro h
    convert h.comp (TopCat.homeoOfIso (asIso f).symm).openEmbedding
    exact congrArg _ (IsIso.inv_hom_id_assoc f g).symm
  · 

Proof state:
case mpr
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ⇑g → OpenEmbedding ⇑(f ≫ g)

Next tactic:
exact fun h => h.comp (TopCat.homeoOfIso (asIso f)).openEmbedding
@[simp]
theorem openEmbedding_iff_isIso_comp' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding g := by
  

Proof state:
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding ⇑g

Next tactic:
simp only [← Functor.map_comp]
@[simp]
theorem openEmbedding_iff_isIso_comp' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding g := by
  simp only [← Functor.map_comp]
  

Proof state:
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map (f ≫ g)) ↔ OpenEmbedding ⇑g

Next tactic:
exact openEmbedding_iff_isIso_comp f g
instance : ConcreteCategory CompleteLat := by
  

Proof state:
⊢ ConcreteCategory CompleteLat

Next tactic:
dsimp [CompleteLat]
instance : ConcreteCategory CompleteLat := by
  dsimp [CompleteLat]; 

Proof state:
⊢ ConcreteCategory (Bundled CompleteLattice)

Next tactic:
infer_instance
/-- Constructs an isomorphism of complete lattices from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : CompleteLat.{u}} (e : α ≃o β) : α ≅ β where
  hom := (e : CompleteLatticeHom _ _) -- Porting note: TODO, wrong?
  inv := (e.symm : CompleteLatticeHom _ _)
  hom_inv_id := by 

Proof state:
α β : CompleteLat
e : ↑α ≃o ↑β
⊢ { tosInfHom := { toFun := ⇑e, map_sInf' := (_ : ∀ (s : Set ↑α), e (sInf s) = sInf (⇑e '' s)) },
        map_sSup' := (_ : ∀ (s : Set ↑α), e (sSup s) = sSup (⇑e '' s)) } ≫
      {
        tosInfHom :=
          { toFun := ⇑(OrderIso.symm e),
            map_sInf' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sInf s) = sInf (⇑(OrderIso.symm e) '' s)) },
        map_sSup' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sSup s) = sSup (⇑(OrderIso.symm e) '' s)) } =
    𝟙 α

Next tactic:
ext
/-- Constructs an isomorphism of complete lattices from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : CompleteLat.{u}} (e : α ≃o β) : α ≅ β where
  hom := (e : CompleteLatticeHom _ _) -- Porting note: TODO, wrong?
  inv := (e.symm : CompleteLatticeHom _ _)
  hom_inv_id := by ext; 

Proof state:
case w
α β : CompleteLat
e : ↑α ≃o ↑β
x✝ : (forget CompleteLat).obj α
⊢ ({ tosInfHom := { toFun := ⇑e, map_sInf' := (_ : ∀ (s : Set ↑α), e (sInf s) = sInf (⇑e '' s)) },
          map_sSup' := (_ : ∀ (s : Set ↑α), e (sSup s) = sSup (⇑e '' s)) } ≫
        {
          tosInfHom :=
            { toFun := ⇑(OrderIso.symm e),
              map_sInf' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sInf s) = sInf (⇑(OrderIso.symm e) '' s)) },
          map_sSup' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sSup s) = sSup (⇑(OrderIso.symm e) '' s)) })
      x✝ =
    (𝟙 α) x✝

Next tactic:
exact e.symm_apply_apply _
/-- Constructs an isomorphism of complete lattices from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : CompleteLat.{u}} (e : α ≃o β) : α ≅ β where
  hom := (e : CompleteLatticeHom _ _) -- Porting note: TODO, wrong?
  inv := (e.symm : CompleteLatticeHom _ _)
  hom_inv_id := by ext; exact e.symm_apply_apply _
  inv_hom_id := by 

Proof state:
α β : CompleteLat
e : ↑α ≃o ↑β
⊢ {
        tosInfHom :=
          { toFun := ⇑(OrderIso.symm e),
            map_sInf' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sInf s) = sInf (⇑(OrderIso.symm e) '' s)) },
        map_sSup' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sSup s) = sSup (⇑(OrderIso.symm e) '' s)) } ≫
      { tosInfHom := { toFun := ⇑e, map_sInf' := (_ : ∀ (s : Set ↑α), e (sInf s) = sInf (⇑e '' s)) },
        map_sSup' := (_ : ∀ (s : Set ↑α), e (sSup s) = sSup (⇑e '' s)) } =
    𝟙 β

Next tactic:
ext
/-- Constructs an isomorphism of complete lattices from an order isomorphism between them. -/
@[simps]
def Iso.mk {α β : CompleteLat.{u}} (e : α ≃o β) : α ≅ β where
  hom := (e : CompleteLatticeHom _ _) -- Porting note: TODO, wrong?
  inv := (e.symm : CompleteLatticeHom _ _)
  hom_inv_id := by ext; exact e.symm_apply_apply _
  inv_hom_id := by ext; 

Proof state:
case w
α β : CompleteLat
e : ↑α ≃o ↑β
x✝ : (forget CompleteLat).obj β
⊢ ({
          tosInfHom :=
            { toFun := ⇑(OrderIso.symm e),
              map_sInf' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sInf s) = sInf (⇑(OrderIso.symm e) '' s)) },
          map_sSup' := (_ : ∀ (s : Set ↑β), (OrderIso.symm e) (sSup s) = sSup (⇑(OrderIso.symm e) '' s)) } ≫
        { tosInfHom := { toFun := ⇑e, map_sInf' := (_ : ∀ (s : Set ↑α), e (sInf s) = sInf (⇑e '' s)) },
          map_sSup' := (_ : ∀ (s : Set ↑α), e (sSup s) = sSup (⇑e '' s)) })
      x✝ =
    (𝟙 β) x✝

Next tactic:
exact e.apply_symm_apply _
/-- The trivial commutative monoid object. We later show this is initial in `CommMon_ C`.
-/
@[simps!]
def trivial : CommMon_ C :=
  { Mon_.trivial C with mul_comm := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
src✝ : Mon_ C := Mon_.trivial C
⊢ (β_ (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

Next tactic:
dsimp
/-- The trivial commutative monoid object. We later show this is initial in `CommMon_ C`.
-/
@[simps!]
def trivial : CommMon_ C :=
  { Mon_.trivial C with mul_comm := by dsimp; 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
src✝ : Mon_ C := Mon_.trivial C
⊢ (β_ (𝟙_ C) (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom = (λ_ (𝟙_ C)).hom

Next tactic:
rw [braiding_leftUnitor, unitors_equal]
/-- A lax braided functor takes commutative monoid objects to commutative monoid objects.

That is, a lax braided functor `F : C ⥤ D` induces a functor `CommMon_ C ⥤ CommMon_ D`.
-/
@[simps!]
def mapCommMon (F : LaxBraidedFunctor C D) : CommMon_ C ⥤ CommMon_ D where
  obj A :=
    { F.toLaxMonoidalFunctor.mapMon.obj A.toMon_ with
      mul_comm := by
        

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
⊢ (β_ (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

Next tactic:
dsimp
/-- A lax braided functor takes commutative monoid objects to commutative monoid objects.

That is, a lax braided functor `F : C ⥤ D` induces a functor `CommMon_ C ⥤ CommMon_ D`.
-/
@[simps!]
def mapCommMon (F : LaxBraidedFunctor C D) : CommMon_ C ⥤ CommMon_ D where
  obj A :=
    { F.toLaxMonoidalFunctor.mapMon.obj A.toMon_ with
      mul_comm := by
        dsimp
        

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
⊢ (β_ (F.obj A.X) (F.obj A.X)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X ≫ F.map A.mul =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X ≫ F.map A.mul

Next tactic:
have := F.braided
/-- A lax braided functor takes commutative monoid objects to commutative monoid objects.

That is, a lax braided functor `F : C ⥤ D` induces a functor `CommMon_ C ⥤ CommMon_ D`.
-/
@[simps!]
def mapCommMon (F : LaxBraidedFunctor C D) : CommMon_ C ⥤ CommMon_ D where
  obj A :=
    { F.toLaxMonoidalFunctor.mapMon.obj A.toMon_ with
      mul_comm := by
        dsimp
        have := F.braided
        

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
this :
  ∀ (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
⊢ (β_ (F.obj A.X) (F.obj A.X)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X ≫ F.map A.mul =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X ≫ F.map A.mul

Next tactic:
slice_lhs 1 2 => rw [← this]
/-- A lax braided functor takes commutative monoid objects to commutative monoid objects.

That is, a lax braided functor `F : C ⥤ D` induces a functor `CommMon_ C ⥤ CommMon_ D`.
-/
@[simps!]
def mapCommMon (F : LaxBraidedFunctor C D) : CommMon_ C ⥤ CommMon_ D where
  obj A :=
    { F.toLaxMonoidalFunctor.mapMon.obj A.toMon_ with
      mul_comm := by
        dsimp
        have := F.braided
        slice_lhs 1 2 => 

Proof state:
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
this :
  ∀ (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
| (β_ (F.obj A.X) (F.obj A.X)).hom ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
this :
  ∀ (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
| F.map A.mul

Next tactic:
rw [← this]
/-- A lax braided functor takes commutative monoid objects to commutative monoid objects.

That is, a lax braided functor `F : C ⥤ D` induces a functor `CommMon_ C ⥤ CommMon_ D`.
-/
@[simps!]
def mapCommMon (F : LaxBraidedFunctor C D) : CommMon_ C ⥤ CommMon_ D where
  obj A :=
    { F.toLaxMonoidalFunctor.mapMon.obj A.toMon_ with
      mul_comm := by
        dsimp
        have := F.braided
        slice_lhs 1 2 => rw [← this]
        

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
this :
  ∀ (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
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X ≫ F.map (β_ A.X A.X).hom) ≫ F.map A.mul =
    LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X ≫ F.map A.mul

Next tactic:
slice_lhs 2 3 => rw [← CategoryTheory.Functor.map_comp, A.mul_comm]
/-- A lax braided functor takes commutative monoid objects to commutative monoid objects.

That is, a lax braided functor `F : C ⥤ D` induces a functor `CommMon_ C ⥤ CommMon_ D`.
-/
@[simps!]
def mapCommMon (F : LaxBraidedFunctor C D) : CommMon_ C ⥤ CommMon_ D where
  obj A :=
    { F.toLaxMonoidalFunctor.mapMon.obj A.toMon_ with
      mul_comm := by
        dsimp
        have := F.braided
        slice_lhs 1 2 => rw [← this]
        slice_lhs 2 3 => 

Proof state:
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
this :
  ∀ (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
| F.map (β_ A.X A.X).hom ≫ F.map A.mul
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
src✝ : Mon_ D := (LaxMonoidalFunctor.mapMon F.toLaxMonoidalFunctor).obj A.toMon_
this :
  ∀ (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
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor A.X A.X

Next tactic:
rw [← CategoryTheory.Functor.map_comp, A.mul_comm]
/-- `mapCommMon` is functorial in the lax braided functor. -/
@[simps]
def mapCommMonFunctor : LaxBraidedFunctor C D ⥤ CommMon_ C ⥤ CommMon_ D where
  obj := mapCommMon
  map α :=
    { app := fun A => { hom := α.app A.X }
      naturality := by 

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝ Y✝ : LaxBraidedFunctor C D
α : X✝ ⟶ Y✝
⊢ ∀ ⦃X Y : CommMon_ C⦄ (f : X ⟶ Y),
    (mapCommMon X✝).map f ≫ (fun A => Mon_.Hom.mk (α.app A.X)) Y =
      (fun A => Mon_.Hom.mk (α.app A.X)) X ≫ (mapCommMon Y✝).map f

Next tactic:
intros
/-- `mapCommMon` is functorial in the lax braided functor. -/
@[simps]
def mapCommMonFunctor : LaxBraidedFunctor C D ⥤ CommMon_ C ⥤ CommMon_ D where
  obj := mapCommMon
  map α :=
    { app := fun A => { hom := α.app A.X }
      naturality := by intros; 

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝¹ Y✝¹ : LaxBraidedFunctor C D
α : X✝¹ ⟶ Y✝¹
X✝ Y✝ : CommMon_ C
f✝ : X✝ ⟶ Y✝
⊢ (mapCommMon X✝¹).map f✝ ≫ (fun A => Mon_.Hom.mk (α.app A.X)) Y✝ =
    (fun A => Mon_.Hom.mk (α.app A.X)) X✝ ≫ (mapCommMon Y✝¹).map f✝

Next tactic:
ext
/-- `mapCommMon` is functorial in the lax braided functor. -/
@[simps]
def mapCommMonFunctor : LaxBraidedFunctor C D ⥤ CommMon_ C ⥤ CommMon_ D where
  obj := mapCommMon
  map α :=
    { app := fun A => { hom := α.app A.X }
      naturality := by intros; ext; 

Proof state:
case h
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝¹ Y✝¹ : LaxBraidedFunctor C D
α : X✝¹ ⟶ Y✝¹
X✝ Y✝ : CommMon_ C
f✝ : X✝ ⟶ Y✝
⊢ ((mapCommMon X✝¹).map f✝ ≫ (fun A => Mon_.Hom.mk (α.app A.X)) Y✝).hom =
    ((fun A => Mon_.Hom.mk (α.app A.X)) X✝ ≫ (mapCommMon Y✝¹).map f✝).hom

Next tactic:
simp
/-- Implementation of `CommMon_.equivLaxBraidedFunctorPunit`. -/
@[simps]
def commMonToLaxBraided : CommMon_ C ⥤ LaxBraidedFunctor (Discrete PUnit.{u + 1}) C where
  obj A :=
    { obj := fun _ => A.X
      map := fun _ => 𝟙 _
      ε := A.one
      μ := fun _ _ => A.mul
      map_id := fun _ => rfl
      map_comp := fun _ _ => (Category.id_comp (𝟙 A.X)).symm }
  map f :=
    { app := fun _ => f.hom
      naturality := fun _ _ _ => by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : CommMon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ ((fun A =>
              LaxBraidedFunctor.mk
                (LaxMonoidalFunctor.mk
                  (CategoryTheory.Functor.mk { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X) }) A.one
                  fun x x => A.mul))
            X✝).map
        x✝ ≫
      (fun x => f.hom) x✝¹ =
    (fun x => f.hom) x✝² ≫
      ((fun A =>
              LaxBraidedFunctor.mk
                (LaxMonoidalFunctor.mk
                  (CategoryTheory.Functor.mk { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X) }) A.one
                  fun x x => A.mul))
            Y✝).map
        x✝

Next tactic:
dsimp
/-- Implementation of `CommMon_.equivLaxBraidedFunctorPunit`. -/
@[simps]
def commMonToLaxBraided : CommMon_ C ⥤ LaxBraidedFunctor (Discrete PUnit.{u + 1}) C where
  obj A :=
    { obj := fun _ => A.X
      map := fun _ => 𝟙 _
      ε := A.one
      μ := fun _ _ => A.mul
      map_id := fun _ => rfl
      map_comp := fun _ _ => (Category.id_comp (𝟙 A.X)).symm }
  map f :=
    { app := fun _ => f.hom
      naturality := fun _ _ _ => by dsimp; 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : CommMon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ 𝟙 X✝.X ≫ f.hom = f.hom ≫ 𝟙 Y✝.X

Next tactic:
rw [Category.id_comp, Category.comp_id]
/-- Implementation of `CommMon_.equivLaxBraidedFunctorPunit`. -/
@[simps!]
def unitIso :
    𝟭 (LaxBraidedFunctor (Discrete PUnit.{u + 1}) C) ≅
      laxBraidedToCommMon C ⋙ commMonToLaxBraided C :=
  NatIso.ofComponents
    (fun F =>
      LaxBraidedFunctor.mkIso
        (MonoidalNatIso.ofComponents
          (fun _ => F.toLaxMonoidalFunctor.toFunctor.mapIso (eqToIso (by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
F : LaxBraidedFunctor (Discrete PUnit.{u + 1}) C
x✝ : Discrete PUnit.{u + 1}
⊢ x✝ = (trivial (Discrete PUnit.{u + 1})).toMon_.X

Next tactic:
ext