File: Mathlib/CategoryTheory/Filtered/Small.lean

full_name: CategoryTheory.IsFiltered.FilteredClosure.coeq
code: /-- The "filtered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding maxima and coequalizers. -/
inductive FilteredClosure : C → Prop
  | base : (x : α) → FilteredClosure (f x)
  | max : {j j' : C} → FilteredClosure j → FilteredClosure j' → FilteredClosure (max j j')
  | coeq : {j j' : C} → FilteredClosure j → FilteredClosure j' → (f f' : j ⟶ j') →
      FilteredClosure (coeq f f')
goal: CategoryTheory.IsFiltered.FilteredClosure f j →
  CategoryTheory.IsFiltered.FilteredClosure f j' →
    ∀ (f_1 f' : j ⟶ j'), CategoryTheory.IsFiltered.FilteredClosure f (CategoryTheory.IsFiltered.coeq f_1 f')

full_name: CategoryTheory.IsFiltered.FilteredClosure.max
code: /-- The "filtered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding maxima and coequalizers. -/
inductive FilteredClosure : C → Prop
  | base : (x : α) → FilteredClosure (f x)
  | max : {j j' : C} → FilteredClosure j → FilteredClosure j' → FilteredClosure (max j j')
  | coeq : {j j' : C} → FilteredClosure j → FilteredClosure j' → (f f' : j ⟶ j') →
      FilteredClosure (coeq f f')
goal: CategoryTheory.IsFiltered.FilteredClosure f j →
  CategoryTheory.IsFiltered.FilteredClosure f j' →
    CategoryTheory.IsFiltered.FilteredClosure f (CategoryTheory.IsFiltered.max j j')

full_name: CategoryTheory.IsFiltered.FilteredClosure
code: /-- The "filtered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding maxima and coequalizers. -/
inductive FilteredClosure : C → Prop
  | base : (x : α) → FilteredClosure (f x)
  | max : {j j' : C} → FilteredClosure j → FilteredClosure j' → FilteredClosure (max j j')
  | coeq : {j j' : C} → FilteredClosure j → FilteredClosure j' → (f f' : j ⟶ j') →
      FilteredClosure (coeq f f')
goal: C → Prop

full_name: CategoryTheory.IsFiltered.FilteredClosure.base
code: /-- The "filtered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding maxima and coequalizers. -/
inductive FilteredClosure : C → Prop
  | base : (x : α) → FilteredClosure (f x)
  | max : {j j' : C} → FilteredClosure j → FilteredClosure j' → FilteredClosure (max j j')
  | coeq : {j j' : C} → FilteredClosure j → FilteredClosure j' → (f f' : j ⟶ j') →
      FilteredClosure (coeq f f')
goal: CategoryTheory.IsFiltered.FilteredClosure f (f x)

full_name: CategoryTheory.IsFiltered.instIsFilteredOrEmptyFullSubcategoryFilteredClosure
code: /-- The full subcategory induced by the filtered closure of a family of objects is filtered. -/
instance : IsFilteredOrEmpty (FullSubcategory (FilteredClosure f)) 
goal: CategoryTheory.IsFilteredOrEmpty (CategoryTheory.FullSubcategory (CategoryTheory.IsFiltered.FilteredClosure f))

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep.coeq
code: /-- One step of the inductive procedure consists of adjoining all maxima and coequalizers of all
    objects and morphisms obtained so far. This is quite redundant, picking up many objects which we
    already hit in earlier iterations, but this is easier to work with later.  -/
private inductive InductiveStep (n : ℕ) (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) :
    Type (max v w)
  | max : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (X _ hk).1 → (X _ hk').1 → InductiveStep n X
  | coeq : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (j : (X _ hk).1) → (j' : (X _ hk').1) →
      ((X _ hk).2 j ⟶ (X _ hk').2 j') → ((X _ hk).2 j ⟶ (X _ hk').2 j') → InductiveStep n X
goal: ((X k hk).snd j ⟶ (X k' hk').snd j') →
  ((X k hk).snd j ⟶ (X k' hk').snd j') → CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep n X

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep
code: /-- One step of the inductive procedure consists of adjoining all maxima and coequalizers of all
    objects and morphisms obtained so far. This is quite redundant, picking up many objects which we
    already hit in earlier iterations, but this is easier to work with later.  -/
private inductive InductiveStep (n : ℕ) (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) :
    Type (max v w)
  | max : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (X _ hk).1 → (X _ hk').1 → InductiveStep n X
  | coeq : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (j : (X _ hk).1) → (j' : (X _ hk').1) →
      ((X _ hk).2 j ⟶ (X _ hk').2 j') → ((X _ hk).2 j ⟶ (X _ hk').2 j') → InductiveStep n X
goal: Type (max v w)

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep.max
code: /-- One step of the inductive procedure consists of adjoining all maxima and coequalizers of all
    objects and morphisms obtained so far. This is quite redundant, picking up many objects which we
    already hit in earlier iterations, but this is easier to work with later.  -/
private inductive InductiveStep (n : ℕ) (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) :
    Type (max v w)
  | max : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (X _ hk).1 → (X _ hk').1 → InductiveStep n X
  | coeq : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (j : (X _ hk).1) → (j' : (X _ hk').1) →
      ((X _ hk).2 j ⟶ (X _ hk').2 j') → ((X _ hk).2 j ⟶ (X _ hk').2 j') → InductiveStep n X
goal: (X k hk).fst → (X k' hk').fst → CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep n X

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.inductiveStepRealization
code: /-- The realization function sends the abstract maxima and weak coequalizers to the corresponding
    objects in `C`. -/
private noncomputable def inductiveStepRealization (n : ℕ)
    (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) : InductiveStep.{w} n X → C
  
goal: CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep n X → C

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure
code: /-- All steps of building the abstract filtered closure together with the realization function,
    as a function of `ℕ`.

   The function is defined by well-founded recursion, but we really want to use its
   definitional equalities in the proofs below, so lets make it semireducible.  -/
@[semireducible] private noncomputable def bundledAbstractFilteredClosure :
    ℕ → Σ t : Type (max v w), t → C
  
goal: ℕ → (t : Type (max v w)) × (t → C)

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.AbstractFilteredClosure
code: /-- The small type modelling the filtered closure. -/
private noncomputable def AbstractFilteredClosure : Type (max v w) 
goal: Type (max v w)

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization
code: /-- The surjection from the abstract filtered closure to the actual filtered closure in `C`. -/
private noncomputable def abstractFilteredClosureRealization : AbstractFilteredClosure f → C 
goal: CategoryTheory.IsFiltered.FilteredClosureSmall.AbstractFilteredClosure f → C

full_name: CategoryTheory.IsFiltered.small_fullSubcategory_filteredClosure
code: theorem small_fullSubcategory_filteredClosure :
    Small.{max v w} (FullSubcategory (FilteredClosure f)) 
goal: Small.{max v w, u} (CategoryTheory.FullSubcategory (CategoryTheory.IsFiltered.FilteredClosure f))

full_name: CategoryTheory.IsFiltered.instEssentiallySmallFullSubcategoryFilteredClosure
code: instance : EssentiallySmall.{max v w} (FullSubcategory (FilteredClosure f)) 
goal: CategoryTheory.EssentiallySmall.{max v w, v, u}
  (CategoryTheory.FullSubcategory (CategoryTheory.IsFiltered.FilteredClosure f))

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate
code: /-- Every functor from a small category to a filtered category factors fully faithfully through a
    small filtered category. This is that category. -/
def SmallFilteredIntermediate : Type (max u₁ v) 
goal: Type (max u₁ v)

full_name: CategoryTheory.IsFiltered.instSmallCategorySmallFilteredIntermediate
code: noncomputable instance : SmallCategory (SmallFilteredIntermediate F) 
goal: CategoryTheory.SmallCategory (CategoryTheory.IsFiltered.SmallFilteredIntermediate F)

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.factoring
code: /-- The first part of a factoring of a functor from a small category to a filtered category through
    a small filtered category. -/
noncomputable def factoring : D ⥤ SmallFilteredIntermediate F 
goal: CategoryTheory.Functor D (CategoryTheory.IsFiltered.SmallFilteredIntermediate F)

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.inclusion
code: /-- The second, fully faithful part of a factoring of a functor from a small category to a filtered
    category through a small filtered category. -/
noncomputable def inclusion : SmallFilteredIntermediate F ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.IsFiltered.SmallFilteredIntermediate F) C

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.instFaithfulInclusion
code: instance : (inclusion F).Faithful 
goal: (CategoryTheory.IsFiltered.SmallFilteredIntermediate.inclusion F).Faithful

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.instFullInclusion
code: noncomputable instance : (inclusion F).Full 
goal: (CategoryTheory.IsFiltered.SmallFilteredIntermediate.inclusion F).Full

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.factoringCompInclusion
code: /-- The factorization through a small filtered category is in fact a factorization, up to natural
    isomorphism. -/
noncomputable def factoringCompInclusion : factoring F ⋙ inclusion F ≅ F 
goal: (CategoryTheory.IsFiltered.SmallFilteredIntermediate.factoring F).comp
    (CategoryTheory.IsFiltered.SmallFilteredIntermediate.inclusion F) ≅
  F

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.instIsFilteredOrEmpty
code: instance : IsFilteredOrEmpty (SmallFilteredIntermediate F) 
goal: CategoryTheory.IsFilteredOrEmpty (CategoryTheory.IsFiltered.SmallFilteredIntermediate F)

full_name: CategoryTheory.IsFiltered.SmallFilteredIntermediate.instOfNonempty
code: instance [Nonempty D] : IsFiltered (SmallFilteredIntermediate F) 
goal: CategoryTheory.IsFiltered (CategoryTheory.IsFiltered.SmallFilteredIntermediate F)

full_name: CategoryTheory.IsCofiltered.CofilteredClosure.min
code: /-- The "cofiltered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding minima and equalizers. -/
inductive CofilteredClosure : C → Prop
  | base : (x : α) → CofilteredClosure (f x)
  | min : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → CofilteredClosure (min j j')
  | eq : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → (f f' : j ⟶ j') →
      CofilteredClosure (eq f f')
goal: CategoryTheory.IsCofiltered.CofilteredClosure f j →
  CategoryTheory.IsCofiltered.CofilteredClosure f j' →
    CategoryTheory.IsCofiltered.CofilteredClosure f (CategoryTheory.IsCofiltered.min j j')

full_name: CategoryTheory.IsCofiltered.CofilteredClosure.eq
code: /-- The "cofiltered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding minima and equalizers. -/
inductive CofilteredClosure : C → Prop
  | base : (x : α) → CofilteredClosure (f x)
  | min : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → CofilteredClosure (min j j')
  | eq : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → (f f' : j ⟶ j') →
      CofilteredClosure (eq f f')
goal: CategoryTheory.IsCofiltered.CofilteredClosure f j →
  CategoryTheory.IsCofiltered.CofilteredClosure f j' →
    ∀ (f_1 f' : j ⟶ j'), CategoryTheory.IsCofiltered.CofilteredClosure f (CategoryTheory.IsCofiltered.eq f_1 f')

full_name: CategoryTheory.IsCofiltered.CofilteredClosure
code: /-- The "cofiltered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding minima and equalizers. -/
inductive CofilteredClosure : C → Prop
  | base : (x : α) → CofilteredClosure (f x)
  | min : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → CofilteredClosure (min j j')
  | eq : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → (f f' : j ⟶ j') →
      CofilteredClosure (eq f f')
goal: C → Prop

full_name: CategoryTheory.IsCofiltered.CofilteredClosure.base
code: /-- The "cofiltered closure" of an `α`-indexed family of objects in `C` is the set of objects in `C`
    obtained by starting with the family and successively adding minima and equalizers. -/
inductive CofilteredClosure : C → Prop
  | base : (x : α) → CofilteredClosure (f x)
  | min : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → CofilteredClosure (min j j')
  | eq : {j j' : C} → CofilteredClosure j → CofilteredClosure j' → (f f' : j ⟶ j') →
      CofilteredClosure (eq f f')
goal: CategoryTheory.IsCofiltered.CofilteredClosure f (f x)

full_name: CategoryTheory.IsCofiltered.instIsCofilteredOrEmptyFullSubcategoryCofilteredClosure
code: /-- The full subcategory induced by the cofiltered closure of a family is cofiltered. -/
instance : IsCofilteredOrEmpty (FullSubcategory (CofilteredClosure f)) 
goal: CategoryTheory.IsCofilteredOrEmpty (CategoryTheory.FullSubcategory (CategoryTheory.IsCofiltered.CofilteredClosure f))

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min
code: /-- Implementation detail for the instance
    `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`. -/
private inductive InductiveStep (n : ℕ) (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) :
    Type (max v w)
  | min : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (X _ hk).1 → (X _ hk').1 → InductiveStep n X
  | eq : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (j : (X _ hk).1) → (j' : (X _ hk').1) →
      ((X _ hk).2 j ⟶ (X _ hk').2 j') → ((X _ hk).2 j ⟶ (X _ hk').2 j') → InductiveStep n X
goal: (X k hk).fst → (X k' hk').fst → CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep n X

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep
code: /-- Implementation detail for the instance
    `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`. -/
private inductive InductiveStep (n : ℕ) (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) :
    Type (max v w)
  | min : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (X _ hk).1 → (X _ hk').1 → InductiveStep n X
  | eq : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (j : (X _ hk).1) → (j' : (X _ hk').1) →
      ((X _ hk).2 j ⟶ (X _ hk').2 j') → ((X _ hk).2 j ⟶ (X _ hk').2 j') → InductiveStep n X
goal: Type (max v w)

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.eq
code: /-- Implementation detail for the instance
    `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`. -/
private inductive InductiveStep (n : ℕ) (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) :
    Type (max v w)
  | min : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (X _ hk).1 → (X _ hk').1 → InductiveStep n X
  | eq : {k k' : ℕ} → (hk : k < n) → (hk' : k' < n) → (j : (X _ hk).1) → (j' : (X _ hk').1) →
      ((X _ hk).2 j ⟶ (X _ hk').2 j') → ((X _ hk).2 j ⟶ (X _ hk').2 j') → InductiveStep n X
goal: ((X k hk).snd j ⟶ (X k' hk').snd j') →
  ((X k hk).snd j ⟶ (X k' hk').snd j') → CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep n X

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.inductiveStepRealization
code: /-- Implementation detail for the instance
    `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`. -/
private noncomputable def inductiveStepRealization (n : ℕ)
    (X : ∀ (k : ℕ), k < n → Σ t : Type (max v w), t → C) : InductiveStep.{w} n X → C
  
goal: CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep n X → C

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure
code: /-- Implementation detail for the instance
   `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`.

   The function is defined by well-founded recursion, but we really want to use its
   definitional equalities in the proofs below, so lets make it semireducible.  -/
@[semireducible] private noncomputable def bundledAbstractCofilteredClosure :
    ℕ → Σ t : Type (max v w), t → C
  
goal: ℕ → (t : Type (max v w)) × (t → C)

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.AbstractCofilteredClosure
code: /-- Implementation detail for the instance
    `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`. -/
private noncomputable def AbstractCofilteredClosure : Type (max v w) 
goal: Type (max v w)

full_name: _private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization
code: /-- Implementation detail for the instance
    `EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f))`. -/
private noncomputable def abstractCofilteredClosureRealization : AbstractCofilteredClosure f → C 
goal: CategoryTheory.IsCofiltered.CofilteredClosureSmall.AbstractCofilteredClosure f → C

full_name: CategoryTheory.IsCofiltered.small_fullSubcategory_cofilteredClosure
code: theorem small_fullSubcategory_cofilteredClosure :
    Small.{max v w} (FullSubcategory (CofilteredClosure f)) 
goal: Small.{max v w, u} (CategoryTheory.FullSubcategory (CategoryTheory.IsCofiltered.CofilteredClosure f))

full_name: CategoryTheory.IsCofiltered.instEssentiallySmallFullSubcategoryCofilteredClosure
code: instance : EssentiallySmall.{max v w} (FullSubcategory (CofilteredClosure f)) 
goal: CategoryTheory.EssentiallySmall.{max v w, v, u}
  (CategoryTheory.FullSubcategory (CategoryTheory.IsCofiltered.CofilteredClosure f))

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate
code: /-- Every functor from a small category to a cofiltered category factors fully faithfully through a
    small cofiltered category. This is that category. -/
def SmallCofilteredIntermediate : Type (max u₁ v) 
goal: Type (max u₁ v)

full_name: CategoryTheory.IsCofiltered.instSmallCategorySmallCofilteredIntermediate
code: noncomputable instance : SmallCategory (SmallCofilteredIntermediate F) 
goal: CategoryTheory.SmallCategory (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate F)

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.factoring
code: /-- The first part of a factoring of a functor from a small category to a cofiltered category
    through a small filtered category. -/
noncomputable def factoring : D ⥤ SmallCofilteredIntermediate F 
goal: CategoryTheory.Functor D (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate F)

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.inclusion
code: /-- The second, fully faithful part of a factoring of a functor from a small category to a filtered
    category through a small filtered category. -/
noncomputable def inclusion : SmallCofilteredIntermediate F ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate F) C

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.instFaithfulInclusion
code: instance : (inclusion F).Faithful 
goal: (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.inclusion F).Faithful

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.instFullInclusion
code: noncomputable instance : (inclusion F).Full 
goal: (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.inclusion F).Full

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.factoringCompInclusion
code: /-- The factorization through a small filtered category is in fact a factorization, up to natural
    isomorphism. -/
noncomputable def factoringCompInclusion : factoring F ⋙ inclusion F ≅ F 
goal: (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.factoring F).comp
    (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.inclusion F) ≅
  F

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.instIsCofilteredOrEmpty
code: instance : IsCofilteredOrEmpty (SmallCofilteredIntermediate F) 
goal: CategoryTheory.IsCofilteredOrEmpty (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate F)

full_name: CategoryTheory.IsCofiltered.SmallCofilteredIntermediate.instOfNonempty
code: instance [Nonempty D] : IsCofiltered (SmallCofilteredIntermediate F) 
goal: CategoryTheory.IsCofiltered (CategoryTheory.IsCofiltered.SmallCofilteredIntermediate F)