The sheaf of locally constant maps on CompHausLike P

This file proves that under suitable conditions, the functor from the category of sets to the category of sheaves for the coherent topology on CompHausLike P, given by mapping a set to the sheaf of locally constant maps to it, is left adjoint to the "underlying set" functor (evaluation at the point).

We apply this to prove that the constant sheaf functor into (light) condensed sets is isomorphic to the functor of sheaves of locally constant maps described above.

Proof sketch

The hard part of this adjunction is to define the counit. Its components are defined as follows:

Let S : CompHausLike P and let Y be a finite-product preserving presheaf on CompHausLike P (e.g. a sheaf for the coherent topology). We need to define a map LocallyConstant S Y(*) ⟶ Y(S). Given a locally constant map f : S → Y(*), let S = S₁ ⊔ ⋯ ⊔ Sₙ be the corresponding decomposition of S into the fibers. Let yᵢ ∈ Y(*) denote the value of f on Sᵢ and denote by gᵢ the canonical map Y(*) → Y(Sᵢ). Our map then takes f to the image of (g₁(y₁), ⋯, gₙ(yₙ)) under the isomorphism Y(S₁) × ⋯ × Y(Sₙ) ≅ Y(S₁ ⊔ ⋯ ⊔ Sₙ) = Y(S).

Now we need to prove that the counit is natural in S : CompHausLike P and Y : Sheaf (coherentTopology (CompHausLike P)) (Type _). There are two key lemmas in all naturality proofs in this file (both lemmas are in the CompHausLike.LocallyConstant namespace):

• presheaf_ext: given S, Y and f : LocallyConstant S Y(*) like above, another presheaf X, and two elements x y : X(S), to prove that x = y it suffices to prove that for every inclusion map ιᵢ : Sᵢ ⟶ S, X(ιᵢ)(x) = X(ιᵢ)(y). Here it is important that we set everything up in such a way that the Sᵢ are literally subtypes of S.

• incl_of_counitAppApp: given S, Y and f : LocallyConstant S Y(*) like above, we have Y(ιᵢ)(ε_{S, Y}(f)) = gᵢ(yᵢ) where ε denotes the counit and the other notation is like above.

Main definitions

• CompHausLike.LocallyConstant.functor: the functor from the category of sets to the category of sheaves for the coherent topology on CompHausLike P, which takes a set X to LocallyConstant - X

  • CondensedSet.LocallyConstant.functor is the above functor in the case of condensed sets.
  • LightCondSet.LocallyConstant.functor is the above functor in the case of light condensed sets.

• CompHausLike.LocallyConstant.adjunction: the functor described above is left adjoint to the "underlying set" functor (sheafSections _ _).obj ⟨CompHausLike.of P PUnit.{u + 1}⟩, which takes a sheaf X to the set X(*).

• CondensedSet.LocallyConstant.iso: the functor CondensedSet.LocallyConstant.functor is isomorphic to the functor Condensed.discrete (Type _) (the constant sheaf functor from sets to condensed sets).

• LightCondSet.LocallyConstant.iso: the functor LightCondSet.LocallyConstant.functor is isomorphic to the functor LightCondensed.discrete (Type _) (the constant sheaf functor from sets to light condensed sets).

def CompHausLike.LocallyConstant.functorToPresheaves {P : TopCat → Prop} : CategoryTheory.Functor (Type (max u w)) (CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w)))

The functor from the category of sets to presheaves on CompHausLike P given by locally constant maps.

@[simp]

theorem CompHausLike.LocallyConstant.functorToPresheaves_obj_map {P : TopCat → Prop} (X : Type (max u w)) {X✝ Y✝ : (CompHausLike P)ᵒᵖ} (f : X✝ ⟶ Y✝) (g : match X✝ with | Opposite.op S => LocallyConstant (↑S.toTop) X) : (functorToPresheaves.obj X).map f g = LocallyConstant.comap (TopCat.Hom.hom f.unop) g

@[simp]

theorem CompHausLike.LocallyConstant.functorToPresheaves_obj_obj {P : TopCat → Prop} (X : Type (max u w)) (x✝ : (CompHausLike P)ᵒᵖ) : (functorToPresheaves.obj X).obj x✝ = match x✝ with | Opposite.op S => LocallyConstant (↑S.toTop) X

@[simp]

theorem CompHausLike.LocallyConstant.functorToPresheaves_map_app {P : TopCat → Prop} {X✝ Y✝ : Type (max u w)} (f : X✝ ⟶ Y✝) (x✝ : (CompHausLike P)ᵒᵖ) (t : { obj := fun (x : (CompHausLike P)ᵒᵖ) => match x with | Opposite.op S => LocallyConstant (↑S.toTop) X✝, map := fun {X Y : (CompHausLike P)ᵒᵖ} (f : X ⟶ Y) (g : match X with | Opposite.op S => LocallyConstant (↑S.toTop) X✝) => LocallyConstant.comap (TopCat.Hom.hom f.unop) g, map_id := ⋯, map_comp := ⋯ }.obj x✝) : (functorToPresheaves.map f).app x✝ t = LocallyConstant.map f t

def CompHausLike.LocallyConstant.locallyConstantIsoContinuousMap (Y : Type u_1) (X : Type u_2) [TopologicalSpace Y] : LocallyConstant Y X ≅ C(Y, ↑(TopCat.discrete.obj X))

Locally constant maps are the same as continuous maps when the target is equipped with the discrete topology

@[simp]

theorem CompHausLike.LocallyConstant.locallyConstantIsoContinuousMap_hom (Y : Type u_1) (X : Type u_2) [TopologicalSpace Y] (f : LocallyConstant Y X) : (locallyConstantIsoContinuousMap Y X).hom f = ↑f

@[simp]

theorem CompHausLike.LocallyConstant.locallyConstantIsoContinuousMap_inv_apply (Y : Type u_1) (X : Type u_2) [TopologicalSpace Y] (f : C(Y, ↑(TopCat.discrete.obj X))) (a : Y) : ((locallyConstantIsoContinuousMap Y X).inv f) a = f a

def CompHausLike.LocallyConstant.fiber {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r) : CompHausLike P

A fiber of a locally constant map as a CompHausLike P.

instance CompHausLike.LocallyConstant.instHasPropCarrierToTopFiber {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r) : HasProp P ↑(fiber r a).toTop

def CompHausLike.LocallyConstant.sigmaIncl {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r) : fiber r a ⟶ Q

The inclusion map from a component of the coproduct induced by f into S.

noncomputable def CompHausLike.LocallyConstant.sigmaIso {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) [HasExplicitFiniteCoproducts P] : finiteCoproduct (fiber r) ≅ Q

The canonical map from the coproduct induced by f to S as an isomorphism in CompHausLike P.

theorem CompHausLike.LocallyConstant.sigmaComparison_comp_sigmaIso {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r) [HasExplicitFiniteCoproducts P] (X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) : CategoryTheory.CategoryStruct.comp (X.mapIso (sigmaIso r).op).hom (CategoryTheory.CategoryStruct.comp (sigmaComparison X fun (a : Function.Fiber ⇑r) => ↑(fiber r a).toTop) fun (g : (a : Function.Fiber ⇑r) → X.obj (Opposite.op (of P ↑(fiber r a).toTop))) => g a) = X.map (sigmaIncl r a).op

noncomputable def CompHausLike.LocallyConstant.counitAppAppImage {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} [HasProp P PUnit.{u + 1}] (f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (of P PUnit.{u + 1})))) (a : Function.Fiber ⇑f) : Y.obj (Opposite.op (fiber f a))

The projection of the counit.

noncomputable def CompHausLike.LocallyConstant.counitAppApp {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] (S : CompHausLike P) (Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) [CategoryTheory.Limits.PreservesFiniteProducts Y] [HasExplicitFiniteCoproducts P] : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (of P PUnit.{u + 1}))) ⟶ Y.obj (Opposite.op S)

The counit is defined as follows: given a locally constant map f : S → Y(*), let S = S₁ ⊔ ⋯ ⊔ Sₙ be the corresponding decomposition of S into the fibers. We need to provide an element of Y(S). It suffices to provide an element of Y(Sᵢ) for all i. Let yᵢ ∈ Y(*) denote the value of f on Sᵢ. Our desired element is the image of yᵢ under the canonical map Y(*) → Y(Sᵢ).

theorem CompHausLike.LocallyConstant.presheaf_ext {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} [HasProp P PUnit.{u + 1}] (f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (of P PUnit.{u + 1})))) (X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) [CategoryTheory.Limits.PreservesFiniteProducts X] (x y : X.obj (Opposite.op S)) [HasExplicitFiniteCoproducts P] (h : ∀ (a : Function.Fiber ⇑f), X.map (sigmaIncl f a).op x = X.map (sigmaIncl f a).op y) : x = y

To check equality of two elements of X(S), it suffices to check equality after composing with each X(S) → X(Sᵢ).

theorem CompHausLike.LocallyConstant.incl_of_counitAppApp {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} [HasProp P PUnit.{u + 1}] (f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (of P PUnit.{u + 1})))) [CategoryTheory.Limits.PreservesFiniteProducts Y] [HasExplicitFiniteCoproducts P] (a : Function.Fiber ⇑f) : Y.map (sigmaIncl f a).op (counitAppApp S Y f) = counitAppAppImage f a

def CompHausLike.LocallyConstant.componentHom {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} [HasProp P PUnit.{u + 1}] (f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (of P PUnit.{u + 1})))) {T : CompHausLike P} (g : T ⟶ S) (a : Function.Fiber ⇑(LocallyConstant.comap (TopCat.Hom.hom g) f)) : fiber (LocallyConstant.comap (TopCat.Hom.hom g) f) a ⟶ fiber f (Function.Fiber.mk (⇑f) ((CategoryTheory.ConcreteCategory.hom g) (Function.Fiber.preimage (⇑(LocallyConstant.comap (TopCat.Hom.hom g) f)) a)))

This is an auxiliary definition, the details do not matter. What's important is that this map exists so that the lemma incl_comap works.

theorem CompHausLike.LocallyConstant.incl_comap {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} [HasProp P PUnit.{u + 1}] {S T : (CompHausLike P)ᵒᵖ} (f : LocallyConstant (↑(Opposite.unop S).toTop) (Y.obj (Opposite.op (of P PUnit.{u + 1})))) (g : S ⟶ T) (a : Function.Fiber ⇑(LocallyConstant.comap (TopCat.Hom.hom g.unop) f)) : CategoryTheory.CategoryStruct.comp g (sigmaIncl (LocallyConstant.comap (TopCat.Hom.hom g.unop) f) a).op = CategoryTheory.CategoryStruct.comp (sigmaIncl f (Function.Fiber.mk (⇑f) ((CategoryTheory.ConcreteCategory.hom g.unop) (Function.Fiber.preimage (⇑(LocallyConstant.comap (TopCat.Hom.hom g.unop) f)) a)))).op (componentHom f g.unop a).op

noncomputable def CompHausLike.LocallyConstant.counitApp {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] (Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) [CategoryTheory.Limits.PreservesFiniteProducts Y] : functorToPresheaves.obj (Y.obj (Opposite.op (of P PUnit.{u + 1}))) ⟶ Y

The counit is natural in S : CompHausLike P

@[simp]

theorem CompHausLike.LocallyConstant.counitApp_app {P : TopCat → Prop} [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] (Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) [CategoryTheory.Limits.PreservesFiniteProducts Y] (x✝ : (CompHausLike P)ᵒᵖ) (a✝ : (functorToPresheaves.obj (Y.obj (Opposite.op (of P PUnit.{u + 1})))).obj x✝) : (counitApp Y).app x✝ a✝ = counitAppApp (Opposite.unop x✝) Y a✝

noncomputable def CompHausLike.LocallyConstant.functorToPresheavesIso (P : TopCat → Prop) [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) (X : Type (max u w)) : functorToPresheaves.obj X ≅ (TopCat.toSheafCompHausLike P (TopCat.discrete.obj X) hs).val

locallyConstantIsoContinuousMap is a natural isomorphism.

def CompHausLike.LocallyConstant.functor (P : TopCat → Prop) [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) : CategoryTheory.Functor (Type (max u w)) (CategoryTheory.Sheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w)))

CompHausLike.LocallyConstant.functorToPresheaves lands in sheaves.

@[simp]

theorem CompHausLike.LocallyConstant.functor_obj_val (P : TopCat → Prop) [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) (X : Type (max u w)) : ((functor P hs).obj X).val = functorToPresheaves.obj X

@[simp]

theorem CompHausLike.LocallyConstant.functor_map_val (P : TopCat → Prop) [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) {X✝ Y✝ : Type (max u w)} (f : X✝ ⟶ Y✝) : ((functor P hs).map f).val = functorToPresheaves.map f

noncomputable def CompHausLike.LocallyConstant.functorIso (P : TopCat → Prop) [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) : functor P hs ≅ TopCat.discrete.comp (topCatToSheafCompHausLike P hs)

CompHausLike.LocallyConstant.functor is naturally isomorphic to the restriction of topCatToSheafCompHausLike to discrete topological spaces.

noncomputable def CompHausLike.LocallyConstant.counit (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] : ((CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))).obj (Opposite.op (of P PUnit.{u + 1}))).comp (functor P hs) ⟶ CategoryTheory.Functor.id (CategoryTheory.Sheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w)))

The counit is natural in both S : CompHausLike P and Y : Sheaf (coherentTopology (CompHausLike P)) (Type (max u w))

@[simp]

theorem CompHausLike.LocallyConstant.counit_app_val (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] (X : CategoryTheory.Sheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))) : ((counit P hs).app X).val = counitApp X.val

def CompHausLike.LocallyConstant.unit (P : TopCat → Prop) [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) : CategoryTheory.Functor.id (Type (max u u_1)) ⟶ (functor P hs).comp ((CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u u_1))).obj (Opposite.op (of P PUnit.{u + 1})))

The unit of the adjunction is given by mapping each element to the corresponding constant map.

@[simp]

theorem CompHausLike.LocallyConstant.unit_app (P : TopCat → Prop) [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) (x✝ : Type (max u u_1)) (x : (CategoryTheory.Functor.id (Type (max u u_1))).obj x✝) : (unit P hs).app x✝ x = LocallyConstant.const (↑(of P PUnit.{u + 1}).toTop) x

noncomputable def CompHausLike.LocallyConstant.unitIso (P : TopCat → Prop) [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) : CategoryTheory.Functor.id (Type (max u w)) ≅ (functor P hs).comp ((CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))).obj (Opposite.op (of P PUnit.{u + 1})))

The unit of the adjunction is an iso.

theorem CompHausLike.LocallyConstant.adjunction_left_triangle (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] (X : Type (max u w)) : CategoryTheory.CategoryStruct.comp (functorToPresheaves.map ((unit P hs).app X)) ((counit P hs).app ((functor P hs).obj X)).val = CategoryTheory.CategoryStruct.id (functorToPresheaves.obj X)

noncomputable def CompHausLike.LocallyConstant.adjunction (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] : functor P hs ⊣ (CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))).obj (Opposite.op (of P PUnit.{u + 1}))

CompHausLike.LocallyConstant.functor is left adjoint to the forgetful functor.

@[simp]

theorem CompHausLike.LocallyConstant.adjunction_unit (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] : (adjunction P hs).unit = unit P hs

@[simp]

theorem CompHausLike.LocallyConstant.adjunction_counit (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] : (adjunction P hs).counit = counit P hs

instance CompHausLike.LocallyConstant.instIsIsoFunctorTypeUnitSheafCoherentTopologyAdjunction (P : TopCat → Prop) [∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)] [HasProp P PUnit.{u + 1}] [HasExplicitFiniteCoproducts P] [HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) [HasExplicitFiniteCoproducts P] : CategoryTheory.IsIso (adjunction P hs).unit

@[reducible, inline]

abbrev CondensedSet.LocallyConstant.functor : CategoryTheory.Functor (Type (u + 1)) CondensedSet

The functor from sets to condensed sets given by locally constant maps into the set.

noncomputable def CondensedSet.LocallyConstant.iso : functor ≅ Condensed.discrete (Type (u + 1))

CondensedSet.LocallyConstant.functor is isomorphic to Condensed.discrete (by uniqueness of adjoints).

noncomputable def CondensedSet.LocallyConstant.functorFullyFaithful : functor.FullyFaithful

CondensedSet.LocallyConstant.functor is fully faithful.

instance CondensedSet.LocallyConstant.instFaithfulFunctor : functor.Faithful

instance CondensedSet.LocallyConstant.instFullFunctor : functor.Full

instance CondensedSet.LocallyConstant.instFaithfulCondensedTypeDiscrete : (Condensed.discrete (Type (u_1 + 1))).Faithful

instance CondensedSet.LocallyConstant.instFullCondensedTypeDiscrete : (Condensed.discrete (Type (u_1 + 1))).Full

@[reducible, inline]

abbrev LightCondSet.LocallyConstant.functor : CategoryTheory.Functor (Type u) LightCondSet

The functor from sets to light condensed sets given by locally constant maps into the set.

instance LightCondSet.LocallyConstant.instHasPropAndTotallyDisconnectedSpaceCarrierSecondCountableTopologySubtypeToTop (S : LightProfinite) (p : ↑S.toTop → Prop) : CompHausLike.HasProp (fun (X : TopCat) => TotallyDisconnectedSpace ↑X ∧ SecondCountableTopology ↑X) (Subtype p)

noncomputable def LightCondSet.LocallyConstant.iso : functor ≅ LightCondensed.discrete (Type u)

LightCondSet.LocallyConstant.functor is isomorphic to LightCondensed.discrete (by uniqueness of adjoints).

noncomputable def LightCondSet.LocallyConstant.functorFullyFaithful : functor.FullyFaithful

LightCondSet.LocallyConstant.functor is fully faithful.

instance LightCondSet.LocallyConstant.instFaithfulFunctor : functor.Faithful

instance LightCondSet.LocallyConstant.instFullFunctor : functor.Full

instance LightCondSet.LocallyConstant.instFaithfulLightCondensedTypeDiscrete : (LightCondensed.discrete (Type u)).Faithful

instance LightCondSet.LocallyConstant.instFullLightCondensedTypeDiscrete : (LightCondensed.discrete (Type u)).Full