File: Mathlib/Condensed/Light/TopCatAdjunction.lean

full_name: _private.Mathlib.Condensed.Light.TopCatAdjunction.0.LightProfinite.const
code: /-- Auxiliary definition to define the topology on `X(*)` for a light condensed set `X`. -/
private def _root_.LightProfinite.const (S : LightProfinite.{u}) (s : S) :
    LightProfinite.of PUnit.{u+1} ⟶ S 
goal: LightProfinite.of PUnit.{u + 1} ⟶ S

full_name: _private.Mathlib.Condensed.Light.TopCatAdjunction.0.LightCondSet.coinducingCoprod
code: /-- Auxiliary definition to define the topology on `X(*)` for a light condensed set `X`. -/
private def coinducingCoprod :
    (Σ (i : (S : LightProfinite.{u}) × X.val.obj ⟨S⟩), i.fst) →
      X.val.obj ⟨LightProfinite.of PUnit⟩ 
goal: (i : (S : LightProfinite) × X.val.obj (Opposite.op S)) × ↑i.fst.toTop →
  X.val.obj (Opposite.op (LightProfinite.of PUnit.{u + 1}))

full_name: LightCondSet.underlyingTopologicalSpace
code: /-- Let `X` be a light condensed set. We define a topology on `X(*)` as the quotient topology of
all the maps from light profinite sets `S` to `X(*)`, corresponding to elements of `X(S)`.
In other words, the topology coinduced by the map `LightCondSet.coinducingCoprod` above. -/
local instance underlyingTopologicalSpace :
    TopologicalSpace (X.val.obj ⟨LightProfinite.of PUnit⟩) 
goal: TopologicalSpace (X.val.obj (Opposite.op (LightProfinite.of PUnit.{u + 1})))

full_name: LightCondSet.toTopCat
code: /-- The object part of the functor `LightCondSet ⥤ TopCat`  -/
def toTopCat : TopCat.{u} 
goal: TopCat

full_name: LightCondSet.continuous_coinducingCoprod
code: lemma continuous_coinducingCoprod {S : LightProfinite.{u}} (x : X.val.obj ⟨S⟩) :
    Continuous fun a ↦ (X.coinducingCoprod ⟨⟨S, x⟩, a⟩) 
goal: Continuous fun a => LightCondSet.coinducingCoprod X ⟨⟨S, x⟩, a⟩

full_name: LightCondSet.toTopCatMap
code: /-- The map part of the functor `LightCondSet ⥤ TopCat`  -/
@[simps]
def toTopCatMap : X.toTopCat ⟶ Y.toTopCat 
goal: X.toTopCat ⟶ Y.toTopCat

full_name: LightCondSet.toTopCatMap_apply
code: /-- The map part of the functor `LightCondSet ⥤ TopCat`  -/
@[simps]
def toTopCatMap : X.toTopCat ⟶ Y.toTopCat 
goal: ∀ (a : X.val.obj (Opposite.op (LightProfinite.of PUnit.{u + 1}))),
  (LightCondSet.toTopCatMap f) a = f.val.app (Opposite.op (LightProfinite.of PUnit.{u + 1})) a

full_name: lightCondSetToTopCat_map
code: /-- The functor `LightCondSet ⥤ TopCat`  -/
@[simps]
def _root_.lightCondSetToTopCat : LightCondSet.{u} ⥤ TopCat.{u} 
goal: ∀ {X Y : LightCondSet} (f : X ⟶ Y), lightCondSetToTopCat.map f = LightCondSet.toTopCatMap f

full_name: lightCondSetToTopCat_obj
code: /-- The functor `LightCondSet ⥤ TopCat`  -/
@[simps]
def _root_.lightCondSetToTopCat : LightCondSet.{u} ⥤ TopCat.{u} 
goal: lightCondSetToTopCat.obj X = X.toTopCat

full_name: lightCondSetToTopCat
code: /-- The functor `LightCondSet ⥤ TopCat`  -/
@[simps]
def _root_.lightCondSetToTopCat : LightCondSet.{u} ⥤ TopCat.{u} 
goal: LightCondSet ⥤ TopCat

full_name: LightCondSet.topCatAdjunctionCounit
code: /-- The counit of the adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` -/
def topCatAdjunctionCounit (X : TopCat.{u}) : X.toLightCondSet.toTopCat ⟶ X 
goal: X.toLightCondSet.toTopCat ⟶ X

full_name: LightCondSet.topCatAdjunctionCounitEquiv
code: /-- The counit of the adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` is always bijective,
but not an isomorphism in general (the inverse isn't continuous unless `X` is sequential).
-/
def topCatAdjunctionCounitEquiv (X : TopCat.{u}) : X.toLightCondSet.toTopCat ≃ X 
goal: ↑X.toLightCondSet.toTopCat ≃ ↑X

full_name: LightCondSet.topCatAdjunctionCounit_bijective
code: lemma topCatAdjunctionCounit_bijective (X : TopCat.{u}) :
    Function.Bijective (topCatAdjunctionCounit X) 
goal: Function.Bijective ⇑(LightCondSet.topCatAdjunctionCounit X)

full_name: LightCondSet.topCatAdjunctionUnit_val_app_apply
code: /-- The unit of the adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` -/
@[simps val_app val_app_apply]
def topCatAdjunctionUnit (X : LightCondSet.{u}) : X ⟶ X.toTopCat.toLightCondSet 
goal: (X.topCatAdjunctionUnit.val.app S x) s = X.val.map (LightProfinite.const (Opposite.unop S) s).op x

full_name: LightCondSet.topCatAdjunctionUnit_val_app
code: /-- The unit of the adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` -/
@[simps val_app val_app_apply]
def topCatAdjunctionUnit (X : LightCondSet.{u}) : X ⟶ X.toTopCat.toLightCondSet 
goal: X.topCatAdjunctionUnit.val.app S x =
  { toFun := fun s => X.val.map (LightProfinite.const (Opposite.unop S) s).op x, continuous_toFun := ⋯ }

full_name: LightCondSet.topCatAdjunctionUnit
code: /-- The unit of the adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` -/
@[simps val_app val_app_apply]
def topCatAdjunctionUnit (X : LightCondSet.{u}) : X ⟶ X.toTopCat.toLightCondSet 
goal: X ⟶ X.toTopCat.toLightCondSet

full_name: LightCondSet.topCatAdjunction
code: /-- The adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` -/
noncomputable def topCatAdjunction : lightCondSetToTopCat.{u} ⊣ topCatToLightCondSet 
goal: lightCondSetToTopCat ⊣ topCatToLightCondSet

full_name: LightCondSet.instEpiTopCatAppCounitTopCatAdjunction
code: instance (X : TopCat) : Epi (topCatAdjunction.counit.app X) 
goal: CategoryTheory.Epi (LightCondSet.topCatAdjunction.counit.app X)

full_name: LightCondSet.instFaithfulTopCatTopCatToLightCondSet
code: instance : topCatToLightCondSet.Faithful 
goal: topCatToLightCondSet.Faithful

full_name: LightCondSet.instSequentialSpaceαTopologicalSpaceToTopCat
code: instance (X : LightCondSet.{u}) : SequentialSpace X.toTopCat 
goal: SequentialSpace ↑X.toTopCat

full_name: LightCondSet.instSequentialSpaceαTopologicalSpaceObjTopCatLightCondSetToTopCat
code: instance (X : LightCondSet.{u}) : SequentialSpace (lightCondSetToTopCat.obj X) 
goal: SequentialSpace ↑(lightCondSetToTopCat.obj X)

full_name: LightCondSet.lightCondSetToSequential
code: /-- The functor from light condensed sets to topological spaces lands in sequential spaces. -/
def lightCondSetToSequential : LightCondSet.{u} ⥤ Sequential.{u} 
goal: LightCondSet ⥤ Sequential

full_name: LightCondSet.sequentialToLightCondSet
code: /--
The functor from topological spaces to light condensed sets restricted to sequential spaces.
-/
noncomputable def sequentialToLightCondSet :
    Sequential.{u} ⥤ LightCondSet.{u} 
goal: Sequential ⥤ LightCondSet

full_name: LightCondSet.sequentialAdjunction
code: /--
The adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` restricted to sequential
spaces.
-/
noncomputable def sequentialAdjunction :
    lightCondSetToSequential ⊣ sequentialToLightCondSet 
goal: LightCondSet.lightCondSetToSequential ⊣ LightCondSet.sequentialToLightCondSet

full_name: LightCondSet.sequentialAdjunctionHomeo
code: /--
The counit of the adjunction `lightCondSetToSequential ⊣ sequentialToLightCondSet`
is a homeomorphism.

Note: for now, we only have `ℕ∪{∞}` as a light profinite set at universe level 0, which is why we
can only prove this for `X : TopCat.{0}`.
-/
def sequentialAdjunctionHomeo (X : TopCat.{0}) [SequentialSpace X] :
    X.toLightCondSet.toTopCat ≃ₜ X 
goal: ↑X.toLightCondSet.toTopCat ≃ₜ ↑X

full_name: LightCondSet.sequentialAdjunctionCounitIso
code: /--
The counit of the adjunction `lightCondSetToSequential ⊣ sequentialToLightCondSet`
is an isomorphism.

Note: for now, we only have `ℕ∪{∞}` as a light profinite set at universe level 0, which is why we
can only prove this for `X : Sequential.{0}`.
-/
noncomputable def sequentialAdjunctionCounitIso (X : Sequential.{0}) :
    lightCondSetToSequential.obj (sequentialToLightCondSet.obj X) ≅ X 
goal: LightCondSet.lightCondSetToSequential.obj (LightCondSet.sequentialToLightCondSet.obj X) ≅ X

full_name: LightCondSet.instIsIsoFunctorSequentialCounitSequentialAdjunction
code: instance : IsIso sequentialAdjunction.{0}.counit 
goal: CategoryTheory.IsIso LightCondSet.sequentialAdjunction.counit

full_name: LightCondSet.fullyFaithfulSequentialToLightCondSet
code: /--
The functor from topological spaces to light condensed sets restricted to sequential spaces
is fully faithful.

Note: for now, we only have `ℕ∪{∞}` as a light profinite set at universe level 0, which is why we
can only prove this for the functor `Sequential.{0} ⥤ LightCondSet.{0}`.
-/
noncomputable def fullyFaithfulSequentialToLightCondSet :
    sequentialToLightCondSet.{0}.FullyFaithful 
goal: LightCondSet.sequentialToLightCondSet.FullyFaithful