File: Mathlib/CategoryTheory/PUnit.lean

full_name: CategoryTheory.Functor.star_map_down_down
code: /-- The constant functor sending everything to `PUnit.star`. -/
@[simps!]
def star : C ⥤ Discrete PUnit.{w + 1} 
goal: ∀ {X Y : C} (x : X ⟶ Y), ⋯ = ⋯

full_name: CategoryTheory.Functor.star
code: /-- The constant functor sending everything to `PUnit.star`. -/
@[simps!]
def star : C ⥤ Discrete PUnit.{w + 1} 
goal: CategoryTheory.Functor C (CategoryTheory.Discrete PUnit.{w + 1})

full_name: CategoryTheory.Functor.star_obj_as
code: /-- The constant functor sending everything to `PUnit.star`. -/
@[simps!]
def star : C ⥤ Discrete PUnit.{w + 1} 
goal: ∀ (x : C), ((CategoryTheory.Functor.star C).obj x).as = PUnit.unit

full_name: CategoryTheory.Functor.punitExt_hom_app_down_down
code: /-- Any two functors to `Discrete PUnit` are isomorphic. -/
@[simps!]
def punitExt (F G : C ⥤ Discrete PUnit.{w + 1}) : F ≅ G 
goal: ⋯ = ⋯

full_name: CategoryTheory.Functor.punitExt
code: /-- Any two functors to `Discrete PUnit` are isomorphic. -/
@[simps!]
def punitExt (F G : C ⥤ Discrete PUnit.{w + 1}) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.Functor.punitExt_inv_app_down_down
code: /-- Any two functors to `Discrete PUnit` are isomorphic. -/
@[simps!]
def punitExt (F G : C ⥤ Discrete PUnit.{w + 1}) : F ≅ G 
goal: ⋯ = ⋯

full_name: CategoryTheory.Functor.punit_ext'
code: /-- Any two functors to `Discrete PUnit` are *equal*.
You probably want to use `punitExt` instead of this. -/
theorem punit_ext' (F G : C ⥤ Discrete PUnit.{w + 1}) : F = G 
goal: F = G

full_name: CategoryTheory.Functor.fromPUnit
code: /-- The functor from `Discrete PUnit` sending everything to the given object. -/
abbrev fromPUnit (X : C) : Discrete PUnit.{w + 1} ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C

full_name: CategoryTheory.Functor.equiv
code: /-- Functors from `Discrete PUnit` are equivalent to the category itself. -/
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
goal: CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C ≌ C

full_name: CategoryTheory.Functor.equiv_inverse
code: /-- Functors from `Discrete PUnit` are equivalent to the category itself. -/
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
goal: CategoryTheory.Functor.equiv.inverse = CategoryTheory.Functor.const (CategoryTheory.Discrete PUnit.{w + 1})

full_name: CategoryTheory.Functor.equiv_counitIso
code: /-- Functors from `Discrete PUnit` are equivalent to the category itself. -/
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
goal: CategoryTheory.Functor.equiv.counitIso = CategoryTheory.NatIso.ofComponents CategoryTheory.Iso.refl ⋯

full_name: CategoryTheory.Functor.equiv_unitIso
code: /-- Functors from `Discrete PUnit` are equivalent to the category itself. -/
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
goal: CategoryTheory.Functor.equiv.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X =>
      CategoryTheory.Discrete.natIso fun i =>
        CategoryTheory.Iso.refl
          (((CategoryTheory.Functor.id (CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C)).obj X).obj
            i))
    ⋯

full_name: CategoryTheory.Functor.equiv_functor_obj
code: /-- Functors from `Discrete PUnit` are equivalent to the category itself. -/
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
goal: CategoryTheory.Functor.equiv.functor.obj F = F.obj { as := PUnit.unit }

full_name: CategoryTheory.Functor.equiv_functor_map
code: /-- Functors from `Discrete PUnit` are equivalent to the category itself. -/
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
goal: ∀ {X Y : CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C} (θ : X ⟶ Y),
  CategoryTheory.Functor.equiv.functor.map θ = θ.app { as := PUnit.unit }

full_name: CategoryTheory.equiv_punit_iff_unique
code: /-- A category being equivalent to `PUnit` is equivalent to it having a unique morphism between
  any two objects. (In fact, such a category is also a groupoid;
  see `CategoryTheory.Groupoid.ofHomUnique`) -/
theorem equiv_punit_iff_unique :
    Nonempty (C ≌ Discrete PUnit.{w + 1}) ↔ Nonempty C ∧ ∀ x y : C, Nonempty <| Unique (x ⟶ y) 
goal: Nonempty (C ≌ CategoryTheory.Discrete PUnit.{w + 1}) ↔ Nonempty C ∧ ∀ (x y : C), Nonempty (Unique (x ⟶ y))