File: Mathlib/Condensed/TopCatAdjunction.lean

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

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

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

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

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

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

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

full_name: condensedSetToTopCat_map
code: /-- The functor `CondensedSet ⥤ TopCat`  -/
@[simps]
def condensedSetToTopCat : CondensedSet.{u} ⥤ TopCat.{u+1} 
goal: ∀ {X Y : CondensedSet} (f : X ⟶ Y), condensedSetToTopCat.map f = CondensedSet.toTopCatMap f

full_name: condensedSetToTopCat
code: /-- The functor `CondensedSet ⥤ TopCat`  -/
@[simps]
def condensedSetToTopCat : CondensedSet.{u} ⥤ TopCat.{u+1} 
goal: CondensedSet ⥤ TopCat

full_name: condensedSetToTopCat_obj
code: /-- The functor `CondensedSet ⥤ TopCat`  -/
@[simps]
def condensedSetToTopCat : CondensedSet.{u} ⥤ TopCat.{u+1} 
goal: condensedSetToTopCat.obj X = X.toTopCat

full_name: CondensedSet.topCatAdjunctionCounit_apply
code: /-- The counit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` -/
@[simps]
def topCatAdjunctionCounit (X : TopCat.{u+1}) : X.toCondensedSet.toTopCat ⟶ X 
goal: (CondensedSet.topCatAdjunctionCounit X) x = x.toFun PUnit.unit

full_name: CondensedSet.topCatAdjunctionCounit
code: /-- The counit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` -/
@[simps]
def topCatAdjunctionCounit (X : TopCat.{u+1}) : X.toCondensedSet.toTopCat ⟶ X 
goal: X.toCondensedSet.toTopCat ⟶ X

full_name: CondensedSet.topCatAdjunctionCounitEquiv
code: /-- The counit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` is always bijective,
but not an isomorphism in general (the inverse isn't continuous unless `X` is compactly generated).
-/
def topCatAdjunctionCounitEquiv (X : TopCat.{u+1}) : X.toCondensedSet.toTopCat ≃ X 
goal: ↑X.toCondensedSet.toTopCat ≃ ↑X

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

full_name: CondensedSet.topCatAdjunctionUnit
code: /-- The unit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` -/
@[simps val_app val_app_apply]
def topCatAdjunctionUnit (X : CondensedSet.{u}) : X ⟶ X.toTopCat.toCondensedSet 
goal: X ⟶ X.toTopCat.toCondensedSet

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

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

full_name: CondensedSet.topCatAdjunction
code: /-- The adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` -/
noncomputable def topCatAdjunction : condensedSetToTopCat.{u} ⊣ topCatToCondensedSet 
goal: condensedSetToTopCat ⊣ topCatToCondensedSet

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

full_name: CondensedSet.instFaithfulTopCatTopCatToCondensedSet
code: instance : topCatToCondensedSet.Faithful 
goal: topCatToCondensedSet.Faithful

full_name: CondensedSet.instUCompactlyGeneratedSpaceαTopologicalSpaceToTopCat
code: instance (X : CondensedSet.{u}) : UCompactlyGeneratedSpace.{u, u+1} X.toTopCat 
goal: UCompactlyGeneratedSpace ↑X.toTopCat

full_name: CondensedSet.instUCompactlyGeneratedSpaceαTopologicalSpaceObjTopCatCondensedSetToTopCat
code: instance (X : CondensedSet.{u}) : UCompactlyGeneratedSpace.{u, u+1} (condensedSetToTopCat.obj X) 
goal: UCompactlyGeneratedSpace ↑(condensedSetToTopCat.obj X)

full_name: CondensedSet.condensedSetToCompactlyGenerated
code: /-- The functor from condensed sets to topological spaces lands in compactly generated spaces. -/
def condensedSetToCompactlyGenerated : CondensedSet.{u} ⥤ CompactlyGenerated.{u, u+1} 
goal: CondensedSet ⥤ CompactlyGenerated

full_name: CondensedSet.compactlyGeneratedToCondensedSet
code: /--
The functor from topological spaces to condensed sets restricted to compactly generated spaces.
-/
noncomputable def compactlyGeneratedToCondensedSet :
    CompactlyGenerated.{u, u+1} ⥤ CondensedSet.{u} 
goal: CompactlyGenerated ⥤ CondensedSet

full_name: CondensedSet.compactlyGeneratedAdjunction
code: /--
The adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` restricted to compactly generated
spaces.
-/
noncomputable def compactlyGeneratedAdjunction :
    condensedSetToCompactlyGenerated ⊣ compactlyGeneratedToCondensedSet 
goal: CondensedSet.condensedSetToCompactlyGenerated ⊣ CondensedSet.compactlyGeneratedToCondensedSet

full_name: CondensedSet.compactlyGeneratedAdjunctionCounitHomeo
code: /--
The counit of the adjunction `condensedSetToCompactlyGenerated ⊣ compactlyGeneratedToCondensedSet`
is a homeomorphism.
-/
def compactlyGeneratedAdjunctionCounitHomeo (X : TopCat.{u+1}) [UCompactlyGeneratedSpace.{u} X] :
    X.toCondensedSet.toTopCat ≃ₜ X 
goal: ↑X.toCondensedSet.toTopCat ≃ₜ ↑X

full_name: CondensedSet.compactlyGeneratedAdjunctionCounitIso
code: /--
The counit of the adjunction `condensedSetToCompactlyGenerated ⊣ compactlyGeneratedToCondensedSet`
is an isomorphism.
-/
noncomputable def compactlyGeneratedAdjunctionCounitIso (X : CompactlyGenerated.{u, u+1}) :
    condensedSetToCompactlyGenerated.obj (compactlyGeneratedToCondensedSet.obj X) ≅ X 
goal: CondensedSet.condensedSetToCompactlyGenerated.obj (CondensedSet.compactlyGeneratedToCondensedSet.obj X) ≅ X

full_name: CondensedSet.instIsIsoFunctorCompactlyGeneratedCounitCompactlyGeneratedAdjunction
code: instance : IsIso compactlyGeneratedAdjunction.counit 
goal: CategoryTheory.IsIso CondensedSet.compactlyGeneratedAdjunction.counit

full_name: CondensedSet.fullyFaithfulCompactlyGeneratedToCondensedSet
code: /--
The functor from topological spaces to condensed sets restricted to compactly generated spaces
is fully faithful.
-/
noncomputable def fullyFaithfulCompactlyGeneratedToCondensedSet :
    compactlyGeneratedToCondensedSet.FullyFaithful 
goal: CondensedSet.compactlyGeneratedToCondensedSet.FullyFaithful