File: Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean

full_name: CategoryTheory.Limits.Types.sectionsEquiv
code: /--
The equivalence between `K.sections` and `(K ⋙ uliftFunctor.{v, u}).sections`. This is used to show
that `uliftFunctor` preserves limits that are potentially too large to exist in the source
category.
-/
def sectionsEquiv {J : Type*} [Category J] (K : J ⥤ Type u) :
    K.sections ≃ (K ⋙ uliftFunctor.{v, u}).sections 
goal: ↑K.sections ≃ ↑(K.comp CategoryTheory.uliftFunctor.{v, u}).sections

full_name: CategoryTheory.Limits.Types.instPreservesLimitsOfSizeUliftFunctor
code: /--
The functor `uliftFunctor : Type u ⥤ Type (max u v)` preserves limits of arbitrary size.
-/
noncomputable
instance : PreservesLimitsOfSize.{w', w} uliftFunctor.{v, u} 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)}
  CategoryTheory.uliftFunctor.{v, u}

full_name: CategoryTheory.Limits.Types.instCreatesLimitsOfSizeUliftFunctor
code: /--
The functor `uliftFunctor : Type u ⥤ Type (max u v)` creates `u`-small limits.
-/
noncomputable instance : CreatesLimitsOfSize.{w, u} uliftFunctor.{v, u} 
goal: CategoryTheory.CreatesLimitsOfSize.{w, u, u, max u v, u + 1, max (u + 1) (v + 1)} CategoryTheory.uliftFunctor.{v, u}

full_name: CategoryTheory.Limits.Types.coconeOfSet
code: /-- Given a subset of the cocone point of a cocone over the lifted functor,
  produce a cocone over the original functor. -/
def coconeOfSet (ls : Set lc.pt) : Cocone K 
goal: CategoryTheory.Limits.Cocone K

full_name: CategoryTheory.Limits.Types.descSet
code: /-- Given a subset of the cocone point of a cocone over the lifted functor,
  produce a subset of the cocone point of a colimit cocone over the original functor. -/
def descSet (ls : Set lc.pt) : Set c.pt 
goal: Set c.pt

full_name: CategoryTheory.Limits.Types.descSet_spec
code: /-- Characterization the map `descSet hc`: the image of an element in a vertex of the original
  diagram in the cocone point lies in `descSet hc ls` if and only if the image of the corresponding
  element in the lifted diagram lie in `ls`. -/
lemma descSet_spec (s : Set c.pt) (ls : Set lc.pt) :
    descSet hc ls = s ↔ ∀ j x, lc.ι.app j ⟨x⟩ ∈ ls ↔ c.ι.app j x ∈ s 
goal: CategoryTheory.Limits.Types.descSet hc ls = s ↔ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s

full_name: CategoryTheory.Limits.Types.mem_descSet_singleton
code: lemma mem_descSet_singleton {x : lc.pt} {j : J} {y : K.obj j} :
    c.ι.app j y ∈ descSet hc {x} ↔ lc.ι.app j ⟨y⟩ = x 
goal: c.ι.app j y ∈ CategoryTheory.Limits.Types.descSet hc {x} ↔ lc.ι.app j { down := y } = x

full_name: CategoryTheory.Limits.Types.descSet_univ
code: lemma descSet_univ : descSet hc (@Set.univ lc.pt) = Set.univ 
goal: CategoryTheory.Limits.Types.descSet hc Set.univ = Set.univ

full_name: CategoryTheory.Limits.Types.iUnion_descSet_singleton
code: lemma iUnion_descSet_singleton : ⋃ x : lc.pt, descSet hc {x} = Set.univ 
goal: ⋃ x, CategoryTheory.Limits.Types.descSet hc {x} = Set.univ

full_name: CategoryTheory.Limits.Types.descSet_empty
code: lemma descSet_empty : descSet hc (∅ : Set lc.pt) = ∅ 
goal: CategoryTheory.Limits.Types.descSet hc ∅ = ∅

full_name: CategoryTheory.Limits.Types.descSet_inter_of_ne
code: lemma descSet_inter_of_ne (x y : lc.pt) (hn : x ≠ y) : descSet hc {x} ∩ descSet hc {y} = ∅ 
goal: CategoryTheory.Limits.Types.descSet hc {x} ∩ CategoryTheory.Limits.Types.descSet hc {y} = ∅

full_name: CategoryTheory.Limits.Types.exists_unique_mem_descSet
code: lemma exists_unique_mem_descSet (x : c.pt) : ∃! y : lc.pt, x ∈ descSet hc {y} 
goal: ∃! y, x ∈ CategoryTheory.Limits.Types.descSet hc {y}

full_name: CategoryTheory.Limits.Types.descFun
code: /-- Given a colimit cocone in `Type u` and an arbitrary cocone over the diagram lifted to
  `Type (max u v)`, produce a function from the cocone point of the colimit cocone to the
  cocone point of the other cocone, that witnesses the colimit cocone also being a colimit
  in the higher universe. -/
noncomputable def descFun (x : c.pt) : lc.pt 
goal: lc.pt

full_name: CategoryTheory.Limits.Types.descFun_apply_spec
code: lemma descFun_apply_spec {x : c.pt} {y : lc.pt} : descFun hc lc x = y ↔ x ∈ descSet hc {y} 
goal: CategoryTheory.Limits.Types.descFun hc lc x = y ↔ x ∈ CategoryTheory.Limits.Types.descSet hc {y}

full_name: CategoryTheory.Limits.Types.descFun_spec
code: lemma descFun_spec (f : c.pt → lc.pt) :
    f = descFun hc lc ↔ ∀ j, f ∘ c.ι.app j = lc.ι.app j ∘ ULift.up 
goal: f = CategoryTheory.Limits.Types.descFun hc lc ↔ ∀ (j : J), f ∘ c.ι.app j = lc.ι.app j ∘ ULift.up

full_name: CategoryTheory.Limits.Types.instPreservesColimitsOfSizeUliftFunctor
code: /--
The functor `uliftFunctor : Type u ⥤ Type (max u v)` preserves colimits of arbitrary size.
-/
noncomputable instance : PreservesColimitsOfSize.{w', w} uliftFunctor.{v, u} 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)}
  CategoryTheory.uliftFunctor.{v, u}

full_name: CategoryTheory.Limits.Types.instCreatesColimitsOfSizeUliftFunctor
code: /--
The functor `uliftFunctor : Type u ⥤ Type (max u v)` creates `u`-small colimits.
-/
noncomputable instance : CreatesColimitsOfSize.{w, u} uliftFunctor.{v, u} 
goal: CategoryTheory.CreatesColimitsOfSize.{w, u, u, max u v, u + 1, max (u + 1) (v + 1)} CategoryTheory.uliftFunctor.{v, u}