File: Mathlib/CategoryTheory/Category/Bipointed.lean

full_name: Bipointed.toProd
code: /-- The category of bipointed types. -/
structure Bipointed : Type (u + 1) where
  /-- The underlying type of a bipointed type. -/
  protected X : Type u
  /-- The two points of a bipointed type, bundled together as a pair. -/
  toProd : X × X
goal: self.X × self.X

full_name: Bipointed
code: /-- The category of bipointed types. -/
structure Bipointed : Type (u + 1) where
  /-- The underlying type of a bipointed type. -/
  protected X : Type u
  /-- The two points of a bipointed type, bundled together as a pair. -/
  toProd : X × X
goal: Type (u + 1)

full_name: Bipointed.X
code: /-- The category of bipointed types. -/
structure Bipointed : Type (u + 1) where
  /-- The underlying type of a bipointed type. -/
  protected X : Type u
  /-- The two points of a bipointed type, bundled together as a pair. -/
  toProd : X × X
goal: Type u

full_name: Bipointed.instCoeSortType
code: instance : CoeSort Bipointed Type* 
goal: CoeSort Bipointed (Type u_3)

full_name: Bipointed.of
code: /-- Turns a bipointing into a bipointed type. -/
def of {X : Type*} (to_prod : X × X) : Bipointed 
goal: Bipointed

full_name: Bipointed.coe_of
code: @[simp]
theorem coe_of {X : Type*} (to_prod : X × X) : ↥(of to_prod) = X 
goal: (Bipointed.of to_prod).X = X

full_name: Bipointed.instInhabited
code: instance : Inhabited Bipointed 
goal: Inhabited Bipointed

full_name: Bipointed.Hom
code: /-- Morphisms in `Bipointed`. -/
@[ext]
protected structure Hom (X Y : Bipointed.{u}) : Type u where
  /-- The underlying function of a morphism of bipointed types. -/
  toFun : X → Y
  map_fst : toFun X.toProd.1 = Y.toProd.1
  map_snd : toFun X.toProd.2 = Y.toProd.2
goal: Type u

full_name: Bipointed.Hom.toFun
code: /-- Morphisms in `Bipointed`. -/
@[ext]
protected structure Hom (X Y : Bipointed.{u}) : Type u where
  /-- The underlying function of a morphism of bipointed types. -/
  toFun : X → Y
  map_fst : toFun X.toProd.1 = Y.toProd.1
  map_snd : toFun X.toProd.2 = Y.toProd.2
goal: X.X → Y.X

full_name: Bipointed.Hom.map_fst
code: /-- Morphisms in `Bipointed`. -/
@[ext]
protected structure Hom (X Y : Bipointed.{u}) : Type u where
  /-- The underlying function of a morphism of bipointed types. -/
  toFun : X → Y
  map_fst : toFun X.toProd.1 = Y.toProd.1
  map_snd : toFun X.toProd.2 = Y.toProd.2
goal: self.toFun X.toProd.1 = Y.toProd.1

full_name: Bipointed.Hom.map_snd
code: /-- Morphisms in `Bipointed`. -/
@[ext]
protected structure Hom (X Y : Bipointed.{u}) : Type u where
  /-- The underlying function of a morphism of bipointed types. -/
  toFun : X → Y
  map_fst : toFun X.toProd.1 = Y.toProd.1
  map_snd : toFun X.toProd.2 = Y.toProd.2
goal: self.toFun X.toProd.2 = Y.toProd.2

full_name: Bipointed.Hom.id_toFun
code: /-- The identity morphism of `X : Bipointed`. -/
@[simps]
nonrec def id (X : Bipointed) : Bipointed.Hom X X 
goal: (Bipointed.Hom.id X).toFun a = id a

full_name: Bipointed.Hom.id
code: /-- The identity morphism of `X : Bipointed`. -/
@[simps]
nonrec def id (X : Bipointed) : Bipointed.Hom X X 
goal: X.Hom X

full_name: Bipointed.Hom.instInhabited
code: instance (X : Bipointed) : Inhabited (Bipointed.Hom X X) 
goal: Inhabited (X.Hom X)

full_name: Bipointed.Hom.comp_toFun
code: /-- Composition of morphisms of `Bipointed`. -/
@[simps]
def comp {X Y Z : Bipointed.{u}} (f : Bipointed.Hom X Y) (g : Bipointed.Hom Y Z) :
    Bipointed.Hom X Z 
goal: ∀ (a : X.X), (f.comp g).toFun a = (g.toFun ∘ f.toFun) a

full_name: Bipointed.Hom.comp
code: /-- Composition of morphisms of `Bipointed`. -/
@[simps]
def comp {X Y Z : Bipointed.{u}} (f : Bipointed.Hom X Y) (g : Bipointed.Hom Y Z) :
    Bipointed.Hom X Z 
goal: X.Hom Z

full_name: Bipointed.largeCategory
code: instance largeCategory : LargeCategory Bipointed 
goal: CategoryTheory.LargeCategory Bipointed

full_name: Bipointed.concreteCategory
code: instance concreteCategory : ConcreteCategory Bipointed 
goal: CategoryTheory.ConcreteCategory Bipointed

full_name: Bipointed.swap_obj_X
code: /-- Swaps the pointed elements of a bipointed type. `Prod.swap` as a functor. -/
@[simps]
def swap : Bipointed ⥤ Bipointed 
goal: (Bipointed.swap.obj X).X = X.X

full_name: Bipointed.swap_obj_toProd
code: /-- Swaps the pointed elements of a bipointed type. `Prod.swap` as a functor. -/
@[simps]
def swap : Bipointed ⥤ Bipointed 
goal: (Bipointed.swap.obj X).toProd = X.toProd.swap

full_name: Bipointed.swap
code: /-- Swaps the pointed elements of a bipointed type. `Prod.swap` as a functor. -/
@[simps]
def swap : Bipointed ⥤ Bipointed 
goal: Bipointed ⥤ Bipointed

full_name: Bipointed.swap_map_toFun
code: /-- Swaps the pointed elements of a bipointed type. `Prod.swap` as a functor. -/
@[simps]
def swap : Bipointed ⥤ Bipointed 
goal: ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swap.map f).toFun a = f.toFun a

full_name: Bipointed.swapEquiv_counitIso_inv_app_toFun
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: (Bipointed.swapEquiv.counitIso.inv.app X).toFun a = a

full_name: Bipointed.swapEquiv_inverse_obj_toProd
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: (Bipointed.swapEquiv.inverse.obj X).toProd = X.toProd.swap

full_name: Bipointed.swapEquiv_functor_obj_X
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: (Bipointed.swapEquiv.functor.obj X).X = X.X

full_name: Bipointed.swapEquiv
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: Bipointed ≌ Bipointed

full_name: Bipointed.swapEquiv_unitIso_inv_app_toFun
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: ∀ (a : ((Bipointed.swap ⋙ Bipointed.swap).obj X).X),
  (Bipointed.swapEquiv.unitIso.inv.app X).toFun a =
    (Bipointed.swap.map (Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ }) ≫
          Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
            { toFun := id, map_fst := ⋯, map_snd := ⋯ }).toFun
      ((𝟙 (Bipointed.swap.obj (Bipointed.swap.obj X))).toFun a)

full_name: Bipointed.swapEquiv_functor_obj_toProd
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: (Bipointed.swapEquiv.functor.obj X).toProd = X.toProd.swap

full_name: Bipointed.swapEquiv_inverse_obj_X
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: (Bipointed.swapEquiv.inverse.obj X).X = X.X

full_name: Bipointed.swapEquiv_counitIso_hom_app_toFun
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: (Bipointed.swapEquiv.counitIso.hom.app X).toFun a = a

full_name: Bipointed.swapEquiv_unitIso_hom_app_toFun
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: ∀ (a : ((𝟭 Bipointed).obj X).X),
  (Bipointed.swapEquiv.unitIso.hom.app X).toFun a =
    (𝟙 (Bipointed.swap.obj (Bipointed.swap.obj X))).toFun
      (({ toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
            Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
              Bipointed.swap.map (Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ })).toFun
        a)

full_name: Bipointed.swapEquiv_functor_map_toFun
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a

full_name: Bipointed.swapEquiv_inverse_map_toFun
code: /-- The equivalence between `Bipointed` and itself induced by `Prod.swap` both ways. -/
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
goal: ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.inverse.map f).toFun a = f.toFun a

full_name: Bipointed.swapEquiv_symm
code: @[simp]
theorem swapEquiv_symm : swapEquiv.symm = swapEquiv 
goal: Bipointed.swapEquiv.symm = Bipointed.swapEquiv

full_name: bipointedToPointedFst
code: /-- The forgetful functor from `Bipointed` to `Pointed` which forgets about the second point. -/
def bipointedToPointedFst : Bipointed ⥤ Pointed 
goal: Bipointed ⥤ Pointed

full_name: bipointedToPointedSnd
code: /-- The forgetful functor from `Bipointed` to `Pointed` which forgets about the first point. -/
def bipointedToPointedSnd : Bipointed ⥤ Pointed 
goal: Bipointed ⥤ Pointed

full_name: bipointedToPointedFst_comp_forget
code: @[simp]
theorem bipointedToPointedFst_comp_forget :
    bipointedToPointedFst ⋙ forget Pointed = forget Bipointed 
goal: bipointedToPointedFst ⋙ CategoryTheory.forget Pointed = CategoryTheory.forget Bipointed

full_name: bipointedToPointedSnd_comp_forget
code: @[simp]
theorem bipointedToPointedSnd_comp_forget :
    bipointedToPointedSnd ⋙ forget Pointed = forget Bipointed 
goal: bipointedToPointedSnd ⋙ CategoryTheory.forget Pointed = CategoryTheory.forget Bipointed

full_name: swap_comp_bipointedToPointedFst
code: @[simp]
theorem swap_comp_bipointedToPointedFst :
    Bipointed.swap ⋙ bipointedToPointedFst = bipointedToPointedSnd 
goal: Bipointed.swap ⋙ bipointedToPointedFst = bipointedToPointedSnd

full_name: swap_comp_bipointedToPointedSnd
code: @[simp]
theorem swap_comp_bipointedToPointedSnd :
    Bipointed.swap ⋙ bipointedToPointedSnd = bipointedToPointedFst 
goal: Bipointed.swap ⋙ bipointedToPointedSnd = bipointedToPointedFst

full_name: pointedToBipointed
code: /-- The functor from `Pointed` to `Bipointed` which bipoints the point. -/
def pointedToBipointed : Pointed.{u} ⥤ Bipointed 
goal: Pointed ⥤ Bipointed

full_name: pointedToBipointedFst
code: /-- The functor from `Pointed` to `Bipointed` which adds a second point. -/
def pointedToBipointedFst : Pointed.{u} ⥤ Bipointed 
goal: Pointed ⥤ Bipointed

full_name: pointedToBipointedSnd
code: /-- The functor from `Pointed` to `Bipointed` which adds a first point. -/
def pointedToBipointedSnd : Pointed.{u} ⥤ Bipointed 
goal: Pointed ⥤ Bipointed

full_name: pointedToBipointedFst_comp_swap
code: @[simp]
theorem pointedToBipointedFst_comp_swap :
    pointedToBipointedFst ⋙ Bipointed.swap = pointedToBipointedSnd 
goal: pointedToBipointedFst ⋙ Bipointed.swap = pointedToBipointedSnd

full_name: pointedToBipointedSnd_comp_swap
code: @[simp]
theorem pointedToBipointedSnd_comp_swap :
    pointedToBipointedSnd ⋙ Bipointed.swap = pointedToBipointedFst 
goal: pointedToBipointedSnd ⋙ Bipointed.swap = pointedToBipointedFst

full_name: pointedToBipointedCompBipointedToPointedFst_inv_app_toFun
code: /-- `BipointedToPointed_fst` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedFst :
    pointedToBipointed ⋙ bipointedToPointedFst ≅ 𝟭 _ 
goal: (pointedToBipointedCompBipointedToPointedFst.inv.app X).toFun a = a

full_name: pointedToBipointedCompBipointedToPointedFst
code: /-- `BipointedToPointed_fst` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedFst :
    pointedToBipointed ⋙ bipointedToPointedFst ≅ 𝟭 _ 
goal: pointedToBipointed ⋙ bipointedToPointedFst ≅ 𝟭 Pointed

full_name: pointedToBipointedCompBipointedToPointedFst_hom_app_toFun
code: /-- `BipointedToPointed_fst` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedFst :
    pointedToBipointed ⋙ bipointedToPointedFst ≅ 𝟭 _ 
goal: (pointedToBipointedCompBipointedToPointedFst.hom.app X).toFun a = a

full_name: pointedToBipointedCompBipointedToPointedSnd_hom_app_toFun
code: /-- `BipointedToPointed_snd` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedSnd :
    pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 _ 
goal: (pointedToBipointedCompBipointedToPointedSnd.hom.app X).toFun a = a

full_name: pointedToBipointedCompBipointedToPointedSnd
code: /-- `BipointedToPointed_snd` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedSnd :
    pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 _ 
goal: pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 Pointed

full_name: pointedToBipointedCompBipointedToPointedSnd_inv_app_toFun
code: /-- `BipointedToPointed_snd` is inverse to `PointedToBipointed`. -/
@[simps!]
def pointedToBipointedCompBipointedToPointedSnd :
    pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 _ 
goal: (pointedToBipointedCompBipointedToPointedSnd.inv.app X).toFun a = a

full_name: pointedToBipointedFstBipointedToPointedFstAdjunction
code: /-- The free/forgetful adjunction between `PointedToBipointed_fst` and `BipointedToPointed_fst`.
-/
def pointedToBipointedFstBipointedToPointedFstAdjunction :
    pointedToBipointedFst ⊣ bipointedToPointedFst 
goal: pointedToBipointedFst ⊣ bipointedToPointedFst

full_name: pointedToBipointedSndBipointedToPointedSndAdjunction
code: /-- The free/forgetful adjunction between `PointedToBipointed_snd` and `BipointedToPointed_snd`.
-/
def pointedToBipointedSndBipointedToPointedSndAdjunction :
    pointedToBipointedSnd ⊣ bipointedToPointedSnd 
goal: pointedToBipointedSnd ⊣ bipointedToPointedSnd