File: Mathlib/CategoryTheory/Category/TwoP.lean

full_name: TwoP.toTwoPointing
code: /-- The category of two-pointed types. -/
structure TwoP : Type (u + 1) where
  /-- The underlying type of a two-pointed type. -/
  protected X : Type u
  /-- The two points of a bipointed type, bundled together as a pair of distinct elements. -/
  toTwoPointing : TwoPointing X
goal: TwoPointing self.X

full_name: TwoP
code: /-- The category of two-pointed types. -/
structure TwoP : Type (u + 1) where
  /-- The underlying type of a two-pointed type. -/
  protected X : Type u
  /-- The two points of a bipointed type, bundled together as a pair of distinct elements. -/
  toTwoPointing : TwoPointing X
goal: Type (u + 1)

full_name: TwoP.X
code: /-- The category of two-pointed types. -/
structure TwoP : Type (u + 1) where
  /-- The underlying type of a two-pointed type. -/
  protected X : Type u
  /-- The two points of a bipointed type, bundled together as a pair of distinct elements. -/
  toTwoPointing : TwoPointing X
goal: Type u

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

full_name: TwoP.of
code: /-- Turns a two-pointing into a two-pointed type. -/
def of {X : Type*} (toTwoPointing : TwoPointing X) : TwoP 
goal: TwoP

full_name: TwoP.coe_of
code: @[simp]
theorem coe_of {X : Type*} (toTwoPointing : TwoPointing X) : ↥(of toTwoPointing) = X 
goal: (TwoP.of toTwoPointing).X = X

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

full_name: TwoP.toBipointed
code: /-- Turns a two-pointed type into a bipointed type, by forgetting that the pointed elements are
distinct. -/
noncomputable def toBipointed (X : TwoP) : Bipointed 
goal: Bipointed

full_name: TwoP.coe_toBipointed
code: @[simp]
theorem coe_toBipointed (X : TwoP) : ↥X.toBipointed = ↥X 
goal: X.toBipointed.X = X.X

full_name: TwoP.largeCategory
code: noncomputable instance largeCategory : LargeCategory TwoP 
goal: CategoryTheory.LargeCategory TwoP

full_name: TwoP.concreteCategory
code: noncomputable instance concreteCategory : ConcreteCategory TwoP 
goal: CategoryTheory.ConcreteCategory TwoP

full_name: TwoP.hasForgetToBipointed
code: noncomputable instance hasForgetToBipointed : HasForget₂ TwoP Bipointed 
goal: CategoryTheory.HasForget₂ TwoP Bipointed

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

full_name: TwoP.swap_obj_toTwoPointing
code: /-- Swaps the pointed elements of a two-pointed type. `TwoPointing.swap` as a functor. -/
@[simps]
noncomputable def swap : TwoP ⥤ TwoP 
goal: (TwoP.swap.obj X).toTwoPointing = X.toTwoPointing.swap

full_name: TwoP.swap
code: /-- Swaps the pointed elements of a two-pointed type. `TwoPointing.swap` as a functor. -/
@[simps]
noncomputable def swap : TwoP ⥤ TwoP 
goal: TwoP ⥤ TwoP

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

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

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

full_name: TwoP.swapEquiv_functor_obj_toTwoPointing_toProd
code: /-- The equivalence between `TwoP` and itself induced by `Prod.swap` both ways. -/
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
goal: (TwoP.swapEquiv.functor.obj X).toTwoPointing.toProd = (X.toTwoPointing.toProd.2, X.toTwoPointing.toProd.1)

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

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

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

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

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

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

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

full_name: TwoP.swapEquiv_inverse_obj_toTwoPointing_toProd
code: /-- The equivalence between `TwoP` and itself induced by `Prod.swap` both ways. -/
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
goal: (TwoP.swapEquiv.inverse.obj X).toTwoPointing.toProd = (X.toTwoPointing.toProd.2, X.toTwoPointing.toProd.1)

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

full_name: TwoP_swap_comp_forget_to_Bipointed
code: @[simp]
theorem TwoP_swap_comp_forget_to_Bipointed :
    TwoP.swap ⋙ forget₂ TwoP Bipointed = forget₂ TwoP Bipointed ⋙ Bipointed.swap 
goal: TwoP.swap ⋙ CategoryTheory.forget₂ TwoP Bipointed = CategoryTheory.forget₂ TwoP Bipointed ⋙ Bipointed.swap

full_name: pointedToTwoPFst
code: /-- The functor from `Pointed` to `TwoP` which adds a second point. -/
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
goal: Pointed ⥤ TwoP

full_name: pointedToTwoPFst_map_toFun
code: /-- The functor from `Pointed` to `TwoP` which adds a second point. -/
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : Option X.X), (pointedToTwoPFst.map f).toFun a = Option.map f.toFun a

full_name: pointedToTwoPFst_obj_toTwoPointing_toProd
code: /-- The functor from `Pointed` to `TwoP` which adds a second point. -/
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
goal: (pointedToTwoPFst.obj X).toTwoPointing.toProd = (some X.point, none)

full_name: pointedToTwoPFst_obj_X
code: /-- The functor from `Pointed` to `TwoP` which adds a second point. -/
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
goal: (pointedToTwoPFst.obj X).X = Option X.X

full_name: pointedToTwoPSnd_map_toFun
code: /-- The functor from `Pointed` to `TwoP` which adds a first point. -/
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : Option X.X), (pointedToTwoPSnd.map f).toFun a = Option.map f.toFun a

full_name: pointedToTwoPSnd
code: /-- The functor from `Pointed` to `TwoP` which adds a first point. -/
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
goal: Pointed ⥤ TwoP

full_name: pointedToTwoPSnd_obj_X
code: /-- The functor from `Pointed` to `TwoP` which adds a first point. -/
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
goal: (pointedToTwoPSnd.obj X).X = Option X.X

full_name: pointedToTwoPSnd_obj_toTwoPointing_toProd
code: /-- The functor from `Pointed` to `TwoP` which adds a first point. -/
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
goal: (pointedToTwoPSnd.obj X).toTwoPointing.toProd = (none, some X.point)

full_name: pointedToTwoPFst_comp_swap
code: @[simp]
theorem pointedToTwoPFst_comp_swap : pointedToTwoPFst ⋙ TwoP.swap = pointedToTwoPSnd 
goal: pointedToTwoPFst ⋙ TwoP.swap = pointedToTwoPSnd

full_name: pointedToTwoPSnd_comp_swap
code: @[simp]
theorem pointedToTwoPSnd_comp_swap : pointedToTwoPSnd ⋙ TwoP.swap = pointedToTwoPFst 
goal: pointedToTwoPSnd ⋙ TwoP.swap = pointedToTwoPFst

full_name: pointedToTwoPFst_comp_forget_to_bipointed
code: @[simp]
theorem pointedToTwoPFst_comp_forget_to_bipointed :
    pointedToTwoPFst ⋙ forget₂ TwoP Bipointed = pointedToBipointedFst 
goal: pointedToTwoPFst ⋙ CategoryTheory.forget₂ TwoP Bipointed = pointedToBipointedFst

full_name: pointedToTwoPSnd_comp_forget_to_bipointed
code: @[simp]
theorem pointedToTwoPSnd_comp_forget_to_bipointed :
    pointedToTwoPSnd ⋙ forget₂ TwoP Bipointed = pointedToBipointedSnd 
goal: pointedToTwoPSnd ⋙ CategoryTheory.forget₂ TwoP Bipointed = pointedToBipointedSnd

full_name: pointedToTwoPFstForgetCompBipointedToPointedFstAdjunction
code: /-- Adding a second point is left adjoint to forgetting the second point. -/
noncomputable def pointedToTwoPFstForgetCompBipointedToPointedFstAdjunction :
    pointedToTwoPFst ⊣ forget₂ TwoP Bipointed ⋙ bipointedToPointedFst 
goal: pointedToTwoPFst ⊣ CategoryTheory.forget₂ TwoP Bipointed ⋙ bipointedToPointedFst

full_name: pointedToTwoPSndForgetCompBipointedToPointedSndAdjunction
code: /-- Adding a first point is left adjoint to forgetting the first point. -/
noncomputable def pointedToTwoPSndForgetCompBipointedToPointedSndAdjunction :
    pointedToTwoPSnd ⊣ forget₂ TwoP Bipointed ⋙ bipointedToPointedSnd 
goal: pointedToTwoPSnd ⊣ CategoryTheory.forget₂ TwoP Bipointed ⋙ bipointedToPointedSnd