File: Mathlib/CategoryTheory/Bicategory/LocallyDiscrete.lean

full_name: CategoryTheory.LocallyDiscrete
code: /-- A wrapper for promoting any category to a bicategory,
with the only 2-morphisms being equalities.
-/
@[ext]
structure LocallyDiscrete (C : Type u) where
  /-- A wrapper for promoting any category to a bicategory,
  with the only 2-morphisms being equalities.
  -/
  as : C
goal: Type u

full_name: CategoryTheory.LocallyDiscrete.as
code: /-- A wrapper for promoting any category to a bicategory,
with the only 2-morphisms being equalities.
-/
@[ext]
structure LocallyDiscrete (C : Type u) where
  /-- A wrapper for promoting any category to a bicategory,
  with the only 2-morphisms being equalities.
  -/
  as : C
goal: C

full_name: CategoryTheory.LocallyDiscrete.mk_as
code: @[simp]
theorem mk_as (a : LocallyDiscrete C) : mk a.as = a 
goal: { as := a.as } = a

full_name: CategoryTheory.LocallyDiscrete.locallyDiscreteEquiv
code: /-- `LocallyDiscrete C` is equivalent to the original type `C`. -/
@[simps]
def locallyDiscreteEquiv : LocallyDiscrete C ≃ C 
goal: CategoryTheory.LocallyDiscrete C ≃ C

full_name: CategoryTheory.LocallyDiscrete.locallyDiscreteEquiv_symm_apply_as
code: /-- `LocallyDiscrete C` is equivalent to the original type `C`. -/
@[simps]
def locallyDiscreteEquiv : LocallyDiscrete C ≃ C 
goal: (CategoryTheory.LocallyDiscrete.locallyDiscreteEquiv.symm as).as = as

full_name: CategoryTheory.LocallyDiscrete.locallyDiscreteEquiv_apply
code: /-- `LocallyDiscrete C` is equivalent to the original type `C`. -/
@[simps]
def locallyDiscreteEquiv : LocallyDiscrete C ≃ C 
goal: CategoryTheory.LocallyDiscrete.locallyDiscreteEquiv self = self.as

full_name: CategoryTheory.LocallyDiscrete.instDecidableEq
code: instance [DecidableEq C] : DecidableEq (LocallyDiscrete C) 
goal: DecidableEq (CategoryTheory.LocallyDiscrete C)

full_name: CategoryTheory.LocallyDiscrete.instInhabited
code: instance [Inhabited C] : Inhabited (LocallyDiscrete C) 
goal: Inhabited (CategoryTheory.LocallyDiscrete C)

full_name: CategoryTheory.LocallyDiscrete.categoryStruct
code: instance categoryStruct [CategoryStruct.{v} C] : CategoryStruct (LocallyDiscrete C) 
goal: CategoryTheory.CategoryStruct.{v, u} (CategoryTheory.LocallyDiscrete C)

full_name: CategoryTheory.LocallyDiscrete.id_as
code: @[simp]
lemma id_as (a : LocallyDiscrete C) : (𝟙 a : Discrete (a.as ⟶ a.as)).as = 𝟙 a.as 
goal: (CategoryTheory.CategoryStruct.id a).as = CategoryTheory.CategoryStruct.id a.as

full_name: CategoryTheory.LocallyDiscrete.comp_as
code: @[simp]
lemma comp_as {a b c : LocallyDiscrete C} (f : a ⟶ b) (g : b ⟶ c) : (f ≫ g).as = f.as ≫ g.as 
goal: (CategoryTheory.CategoryStruct.comp f g).as = CategoryTheory.CategoryStruct.comp f.as g.as

full_name: CategoryTheory.LocallyDiscrete.homSmallCategory
code: instance (priority := 900) homSmallCategory (a b : LocallyDiscrete C) : SmallCategory (a ⟶ b) 
goal: CategoryTheory.SmallCategory (a ⟶ b)

full_name: CategoryTheory.LocallyDiscrete.subsingleton2Hom
code: instance subsingleton2Hom {a b : LocallyDiscrete C} (f g : a ⟶ b) : Subsingleton (f ⟶ g) 
goal: Subsingleton (f ⟶ g)

full_name: CategoryTheory.LocallyDiscrete.eq_of_hom
code: /-- Extract the equation from a 2-morphism in a locally discrete 2-category. -/
theorem eq_of_hom {X Y : LocallyDiscrete C} {f g : X ⟶ Y} (η : f ⟶ g) : f = g 
goal: f = g

full_name: CategoryTheory.locallyDiscreteBicategory
code: /-- The locally discrete bicategory on a category is a bicategory in which the objects and the
1-morphisms are the same as those in the underlying category, and the 2-morphisms are the
equalities between 1-morphisms.
-/
instance locallyDiscreteBicategory : Bicategory (LocallyDiscrete C) 
goal: CategoryTheory.Bicategory (CategoryTheory.LocallyDiscrete C)

full_name: CategoryTheory.locallyDiscreteBicategory.strict
code: /-- A locally discrete bicategory is strict. -/
instance locallyDiscreteBicategory.strict : Strict (LocallyDiscrete C) 
goal: CategoryTheory.Bicategory.Strict (CategoryTheory.LocallyDiscrete C)

full_name: CategoryTheory.Functor.toPseudoFunctor_toPrelaxFunctor_toPrelaxFunctorStruct_map₂
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to a pseudofunctor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toPseudoFunctor (F : I ⥤ B) : Pseudofunctor (LocallyDiscrete I) B 
goal: ∀ {a b : CategoryTheory.LocallyDiscrete I} {f g : a ⟶ b} (η : f ⟶ g),
  F.toPseudoFunctor.map₂ η = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Functor.toPseudoFunctor_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_map
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to a pseudofunctor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toPseudoFunctor (F : I ⥤ B) : Pseudofunctor (LocallyDiscrete I) B 
goal: ∀ {X Y : CategoryTheory.LocallyDiscrete I} (f : X ⟶ Y), F.toPseudoFunctor.map f = F.map f.as

full_name: CategoryTheory.Functor.toPseudoFunctor_mapId
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to a pseudofunctor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toPseudoFunctor (F : I ⥤ B) : Pseudofunctor (LocallyDiscrete I) B 
goal: F.toPseudoFunctor.mapId i = CategoryTheory.eqToIso ⋯

full_name: CategoryTheory.Functor.toPseudoFunctor_mapComp
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to a pseudofunctor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toPseudoFunctor (F : I ⥤ B) : Pseudofunctor (LocallyDiscrete I) B 
goal: ∀ {a b c : CategoryTheory.LocallyDiscrete I} (f : a ⟶ b) (g : b ⟶ c),
  F.toPseudoFunctor.mapComp f g = CategoryTheory.eqToIso ⋯

full_name: CategoryTheory.Functor.toPseudoFunctor
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to a pseudofunctor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toPseudoFunctor (F : I ⥤ B) : Pseudofunctor (LocallyDiscrete I) B 
goal: CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete I) B

full_name: CategoryTheory.Functor.toPseudoFunctor_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to a pseudofunctor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toPseudoFunctor (F : I ⥤ B) : Pseudofunctor (LocallyDiscrete I) B 
goal: F.toPseudoFunctor.obj i = F.obj i.as

full_name: CategoryTheory.Functor.toOplaxFunctor_toPrelaxFunctor_toPrelaxFunctorStruct_map₂
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to an oplax functor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toOplaxFunctor (F : I ⥤ B) : OplaxFunctor (LocallyDiscrete I) B 
goal: ∀ {a b : CategoryTheory.LocallyDiscrete I} {f g : a ⟶ b} (η : f ⟶ g), F.toOplaxFunctor.map₂ η = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Functor.toOplaxFunctor_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to an oplax functor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toOplaxFunctor (F : I ⥤ B) : OplaxFunctor (LocallyDiscrete I) B 
goal: F.toOplaxFunctor.obj i = F.obj i.as

full_name: CategoryTheory.Functor.toOplaxFunctor_mapId
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to an oplax functor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toOplaxFunctor (F : I ⥤ B) : OplaxFunctor (LocallyDiscrete I) B 
goal: F.toOplaxFunctor.mapId i = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Functor.toOplaxFunctor
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to an oplax functor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toOplaxFunctor (F : I ⥤ B) : OplaxFunctor (LocallyDiscrete I) B 
goal: CategoryTheory.OplaxFunctor (CategoryTheory.LocallyDiscrete I) B

full_name: CategoryTheory.Functor.toOplaxFunctor_mapComp
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to an oplax functor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toOplaxFunctor (F : I ⥤ B) : OplaxFunctor (LocallyDiscrete I) B 
goal: ∀ {a b c : CategoryTheory.LocallyDiscrete I} (f : a ⟶ b) (g : b ⟶ c),
  F.toOplaxFunctor.mapComp f g = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Functor.toOplaxFunctor_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_map
code: /--
If `B` is a strict bicategory and `I` is a (1-)category, any functor (of 1-categories) `I ⥤ B` can
be promoted to an oplax functor from `LocallyDiscrete I` to `B`.
-/
@[simps]
def Functor.toOplaxFunctor (F : I ⥤ B) : OplaxFunctor (LocallyDiscrete I) B 
goal: ∀ {X Y : CategoryTheory.LocallyDiscrete I} (f : X ⟶ Y), F.toOplaxFunctor.map f = F.map f.as

full_name: CategoryTheory.PrelaxFunctor.map₂_eqToHom
code: @[simp]
lemma PrelaxFunctor.map₂_eqToHom (F : PrelaxFunctor B C) {a b : B} {f g : a ⟶ b} (h : f = g) :
    F.map₂ (eqToHom h) = eqToHom (F.congr_map h) 
goal: F.map₂ (CategoryTheory.eqToHom h) = CategoryTheory.eqToHom ⋯

full_name: Quiver.Hom.toLoc
code: /-- The 1-morphism in `LocallyDiscrete C` associated to a given morphism `f : a ⟶ b` in `C` -/
@[simps]
def toLoc {a b : C} (f : a ⟶ b) : LocallyDiscrete.mk a ⟶ LocallyDiscrete.mk b 
goal: { as := a } ⟶ { as := b }

full_name: Quiver.Hom.toLoc_as
code: /-- The 1-morphism in `LocallyDiscrete C` associated to a given morphism `f : a ⟶ b` in `C` -/
@[simps]
def toLoc {a b : C} (f : a ⟶ b) : LocallyDiscrete.mk a ⟶ LocallyDiscrete.mk b 
goal: f.toLoc.as = f

full_name: Quiver.Hom.id_toLoc
code: @[simp]
lemma id_toLoc (a : C) : (𝟙 a).toLoc = 𝟙 (LocallyDiscrete.mk a) 
goal: (CategoryTheory.CategoryStruct.id a).toLoc = CategoryTheory.CategoryStruct.id { as := a }

full_name: Quiver.Hom.comp_toLoc
code: @[simp]
lemma comp_toLoc {a b c : C} (f : a ⟶ b) (g : b ⟶ c) : (f ≫ g).toLoc = f.toLoc ≫ g.toLoc 
goal: (CategoryTheory.CategoryStruct.comp f g).toLoc = CategoryTheory.CategoryStruct.comp f.toLoc g.toLoc

full_name: CategoryTheory.LocallyDiscrete.eqToHom_toLoc
code: @[simp]
lemma CategoryTheory.LocallyDiscrete.eqToHom_toLoc {C : Type u} [Category.{v} C] {a b : C}
    (h : a = b) : (eqToHom h).toLoc = eqToHom (congrArg LocallyDiscrete.mk h) 
goal: (CategoryTheory.eqToHom h).toLoc = CategoryTheory.eqToHom ⋯