File: Mathlib/CategoryTheory/Category/Grpd.lean

full_name: CategoryTheory.Grpd
code: /-- Category of groupoids -/
@[nolint checkUnivs]
def Grpd 
goal: Type (max (u + 1) u (v + 1))

full_name: CategoryTheory.Grpd.instInhabited
code: instance : Inhabited Grpd 
goal: Inhabited CategoryTheory.Grpd

full_name: CategoryTheory.Grpd.str'
code: instance str' (C : Grpd.{v, u}) : Groupoid.{v, u} C.α 
goal: CategoryTheory.Groupoid ↑C

full_name: CategoryTheory.Grpd.instCoeSortType
code: instance : CoeSort Grpd Type* 
goal: CoeSort CategoryTheory.Grpd (Type u_1)

full_name: CategoryTheory.Grpd.of
code: /-- Construct a bundled `Grpd` from the underlying type and the typeclass `Groupoid`. -/
def of (C : Type u) [Groupoid.{v} C] : Grpd.{v, u} 
goal: CategoryTheory.Grpd

full_name: CategoryTheory.Grpd.coe_of
code: @[simp]
theorem coe_of (C : Type u) [Groupoid C] : (of C : Type u) = C 
goal: ↑(CategoryTheory.Grpd.of C) = C

full_name: CategoryTheory.Grpd.category
code: /-- Category structure on `Grpd` -/
instance category : LargeCategory.{max v u} Grpd.{v, u} 
goal: CategoryTheory.LargeCategory CategoryTheory.Grpd

full_name: CategoryTheory.Grpd.objects
code: /-- Functor that gets the set of objects of a groupoid. It is not
called `forget`, because it is not a faithful functor. -/
def objects : Grpd.{v, u} ⥤ Type u 
goal: CategoryTheory.Functor CategoryTheory.Grpd (Type u)

full_name: CategoryTheory.Grpd.forgetToCat
code: /-- Forgetting functor to `Cat` -/
def forgetToCat : Grpd.{v, u} ⥤ Cat.{v, u} 
goal: CategoryTheory.Functor CategoryTheory.Grpd CategoryTheory.Cat

full_name: CategoryTheory.Grpd.forgetToCat_full
code: instance forgetToCat_full : forgetToCat.Full 
goal: CategoryTheory.Grpd.forgetToCat.Full

full_name: CategoryTheory.Grpd.forgetToCat_faithful
code: instance forgetToCat_faithful : forgetToCat.Faithful 
goal: CategoryTheory.Grpd.forgetToCat.Faithful

full_name: CategoryTheory.Grpd.hom_to_functor
code: /-- Convert arrows in the category of groupoids to functors,
which sometimes helps in applying simp lemmas -/
theorem hom_to_functor {C D E : Grpd.{v, u}} (f : C ⟶ D) (g : D ⟶ E) : f ≫ g = f ⋙ g 
goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.Functor.comp f g

full_name: CategoryTheory.Grpd.id_to_functor
code: /-- Converts identity in the category of groupoids to the functor identity -/
theorem id_to_functor {C : Grpd.{v, u}} : 𝟭 C = 𝟙 C 
goal: CategoryTheory.Functor.id ↑C = CategoryTheory.CategoryStruct.id C

full_name: CategoryTheory.Grpd.piLimitFan
code: /-- Construct the product over an indexed family of groupoids, as a fan. -/
def piLimitFan ⦃J : Type u⦄ (F : J → Grpd.{u, u}) : Limits.Fan F 
goal: CategoryTheory.Limits.Fan F

full_name: CategoryTheory.Grpd.piLimitFanIsLimit
code: /-- The product fan over an indexed family of groupoids, is a limit cone. -/
def piLimitFanIsLimit ⦃J : Type u⦄ (F : J → Grpd.{u, u}) : Limits.IsLimit (piLimitFan F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Grpd.piLimitFan F)

full_name: CategoryTheory.Grpd.has_pi
code: instance has_pi : Limits.HasProducts.{u} Grpd.{u, u} 
goal: CategoryTheory.Limits.HasProducts CategoryTheory.Grpd

full_name: CategoryTheory.Grpd.piIsoPi
code: /-- The product of a family of groupoids is isomorphic
to the product object in the category of Groupoids -/
noncomputable def piIsoPi (J : Type u) (f : J → Grpd.{u, u}) : @of (∀ j, f j) _ ≅ ∏ᶜ f 
goal: CategoryTheory.Grpd.of ((j : J) → ↑(f j)) ≅ ∏ᶜ f

full_name: CategoryTheory.Grpd.piIsoPi_hom_π
code: @[simp]
theorem piIsoPi_hom_π (J : Type u) (f : J → Grpd.{u, u}) (j : J) :
    (piIsoPi J f).hom ≫ Limits.Pi.π f j = CategoryTheory.Pi.eval _ j 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Grpd.piIsoPi J f).hom (CategoryTheory.Limits.Pi.π f j) =
  CategoryTheory.Pi.eval (fun i => ↑(f i)) j