fact
stringlengths 6
3.84k
| type
stringclasses 11
values | library
stringclasses 32
values | imports
listlengths 1
14
| filename
stringlengths 20
95
| symbolic_name
stringlengths 1
90
| docstring
stringlengths 7
20k
⌀ |
|---|---|---|---|---|---|---|
forget_reflectsIsomorphisms : (forget LightProfinite).ReflectsIsomorphisms := by
constructor
intro A B f hf
rw [isIso_iff_bijective] at hf
exact LightProfinite.isIso_of_bijective _ hf
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
forget_reflectsIsomorphisms
| null |
epi_iff_surjective {X Y : LightProfinite.{u}} (f : X ⟶ Y) :
Epi f ↔ Function.Surjective f := by
constructor
· -- Note: in mathlib3 `contrapose` saw through `Function.Surjective`.
dsimp [Function.Surjective]
contrapose!
rintro ⟨y, hy⟩ hf
let C := Set.range f
have hC : IsClosed C := (isCompact_range f.hom.continuous).isClosed
let U := Cᶜ
have hyU : y ∈ U := by
refine Set.mem_compl ?_
rintro ⟨y', hy'⟩
exact hy y' hy'
have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
obtain ⟨V, hV, hyV, hVU⟩ := isTopologicalBasis_isClopen.mem_nhds_iff.mp hUy
classical
let Z := of (ULift.{u} <| Fin 2)
let g : Y ⟶ Z := CompHausLike.ofHom _
⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩
let h : Y ⟶ Z := CompHausLike.ofHom _ ⟨fun _ => ⟨1⟩, continuous_const⟩
have H : h = g := by
rw [← cancel_epi f]
ext x
dsimp [g, LocallyConstant.ofIsClopen]
rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, hom_ofHom, ContinuousMap.coe_mk,
Function.comp_apply, if_neg]
refine mt (fun α => hVU α) ?_
simp [U, C]
apply_fun fun e => (e y).down at H
dsimp [g, LocallyConstant.ofIsClopen] at H
rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
exact top_ne_bot H
· rw [← CategoryTheory.epi_iff_surjective]
apply (forget LightProfinite).epi_of_epi_map
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
epi_iff_surjective
| null |
LightDiagram : Type (u+1) where
/-- The indexing diagram. -/
diagram : ℕᵒᵖ ⥤ FintypeCat
/-- The limit cone. -/
cone : Cone (diagram ⋙ FintypeCat.toProfinite.{u})
/-- The limit cone is limiting. -/
isLimit : IsLimit cone
|
structure
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
LightDiagram
|
A structure containing the data of sequential limit in `Profinite` of finite sets.
|
toProfinite (S : LightDiagram) : Profinite := S.cone.pt
@[simps!]
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
toProfinite
|
The underlying `Profinite` of a `LightDiagram`.
|
hasForget : ConcreteCategory LightDiagram (fun X Y => C(X.toProfinite, Y.toProfinite)) :=
InducedCategory.concreteCategory toProfinite
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
hasForget
| null |
@[simps!]
lightDiagramToProfinite : LightDiagram ⥤ Profinite := inducedFunctor _
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
lightDiagramToProfinite
|
The fully faithful embedding `LightDiagram ⥤ Profinite`
|
instCountableDiscreteQuotient (S : LightProfinite) :
Countable (DiscreteQuotient ((lightToProfinite.obj S))) :=
(DiscreteQuotient.finsetClopens_inj S).countable
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
instCountableDiscreteQuotient
| null |
noncomputable toLightDiagram (S : LightProfinite.{u}) : LightDiagram.{u} where
diagram := IsCofiltered.sequentialFunctor _ ⋙ (lightToProfinite.obj S).fintypeDiagram
cone := (Functor.Initial.limitConeComp (IsCofiltered.sequentialFunctor _)
(lightToProfinite.obj S).lim).cone
isLimit := (Functor.Initial.limitConeComp (IsCofiltered.sequentialFunctor _)
(lightToProfinite.obj S).lim).isLimit
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
toLightDiagram
|
A profinite space which is light gives rise to a light profinite space.
|
@[simps]
noncomputable lightProfiniteToLightDiagram : LightProfinite.{u} ⥤ LightDiagram.{u} where
obj X := X.toLightDiagram
map f := f
open scoped Classical in
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
lightProfiniteToLightDiagram
|
The functor part of the equivalence `LightProfinite ≌ LightDiagram`
|
@[simps obj map]
lightDiagramToLightProfinite : LightDiagram.{u} ⥤ LightProfinite.{u} where
obj X := LightProfinite.of X.cone.pt
map f := f
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
lightDiagramToLightProfinite
|
The inverse part of the equivalence `LightProfinite ≌ LightDiagram`
|
noncomputable LightProfinite.equivDiagram : LightProfinite.{u} ≌ LightDiagram.{u} where
functor := lightProfiniteToLightDiagram
inverse := lightDiagramToLightProfinite
unitIso := Iso.refl _
counitIso := NatIso.ofComponents
(fun _ ↦ lightDiagramToProfinite.preimageIso (Iso.refl _)) (by
intro _ _ f
simp only [Functor.comp_obj, lightDiagramToLightProfinite_obj,
lightProfiniteToLightDiagram_obj, Functor.id_obj, Functor.comp_map,
lightDiagramToLightProfinite_map, lightProfiniteToLightDiagram_map,
lightDiagramToProfinite_obj, Functor.preimageIso_hom, Iso.refl_hom, Functor.id_map]
erw [lightDiagramToProfinite.preimage_id, lightDiagramToProfinite.preimage_id,
Category.comp_id f])
functor_unitIso_comp _ := by simpa using lightDiagramToProfinite.preimage_id
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
LightProfinite.equivDiagram
|
The equivalence of categories `LightProfinite ≌ LightDiagram`
|
LightDiagram' : Type u where
/-- The diagram takes values in a small category equivalent to `FintypeCat`. -/
diagram : ℕᵒᵖ ⥤ FintypeCat.Skeleton.{u}
|
structure
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
LightDiagram'
|
This is an auxiliary definition used to show that `LightDiagram` is essentially small.
Note that below we put a category instance on this structure which is completely different from the
category instance on `ℕᵒᵖ ⥤ FintypeCat.Skeleton.{u}`. Neither the morphisms nor the objects are the
same.
|
LightDiagram'.toProfinite (S : LightDiagram') : Profinite :=
limit (S.diagram ⋙ FintypeCat.Skeleton.equivalence.functor ⋙ FintypeCat.toProfinite.{u})
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
LightDiagram'.toProfinite
|
A `LightDiagram'` yields a `Profinite`.
|
LightDiagram'.toLightFunctor : LightDiagram'.{u} ⥤ LightDiagram.{u} where
obj X := ⟨X.diagram ⋙ Skeleton.equivalence.functor, _, limit.isLimit _⟩
map f := f
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
LightDiagram'.toLightFunctor
|
The functor part of the equivalence of categories `LightDiagram' ≌ LightDiagram`.
|
LightDiagram.equivSmall : LightDiagram.{u} ≌ LightDiagram'.{u} :=
LightDiagram'.toLightFunctor.asEquivalence.symm
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Limits.Shapes.Countable",
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.Topology.ClopenBox"
] |
Mathlib/Topology/Category/LightProfinite/Basic.lean
|
LightDiagram.equivSmall
|
The equivalence between `LightDiagram` and a small category.
|
effectiveEpi_iff_surjective {X Y : LightProfinite.{u}} (f : X ⟶ Y) :
EffectiveEpi f ↔ Function.Surjective f := by
refine ⟨fun h ↦ ?_, fun h ↦ ⟨⟨effectiveEpiStruct f h⟩⟩⟩
rw [← epi_iff_surjective]
infer_instance
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.CompHausLike.EffectiveEpi",
"Mathlib.Topology.Category.LightProfinite.Limits"
] |
Mathlib/Topology/Category/LightProfinite/EffectiveEpi.lean
|
effectiveEpi_iff_surjective
| null |
@[simps]
functor : ℕᵒᵖ ⥤ StructuredArrow c.pt toLightProfinite where
obj i := StructuredArrow.mk (c.π.app i)
map f := StructuredArrow.homMk (F.map f) (c.w f)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
functor
|
Given a sequential cone in `LightProfinite` consisting of finite sets,
we obtain a functor from the indexing category to `StructuredArrow c.pt toLightProfinite`.
|
@[simps! obj map]
functorOp : ℕ ⥤ CostructuredArrow toLightProfinite.op ⟨c.pt⟩ :=
(functor c).rightOp ⋙ StructuredArrow.toCostructuredArrow _ _
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
functorOp
|
Given a sequential cone in `LightProfinite` consisting of finite sets,
we obtain a functor from the opposite of the indexing category to
`CostructuredArrow toProfinite.op ⟨c.pt⟩`.
|
functor_initial (hc : IsLimit c) [∀ i, Epi (c.π.app i)] : Initial (functor c) := by
rw [initial_iff_comp_equivalence _ (StructuredArrow.post _ _ lightToProfinite)]
have : ∀ i, Epi ((lightToProfinite.mapCone c).π.app i) :=
fun i ↦ inferInstanceAs (Epi (lightToProfinite.map (c.π.app i)))
exact Profinite.Extend.functor_initial _ (isLimitOfPreserves lightToProfinite hc)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
functor_initial
|
If the projection maps in the cone are epimorphic and the cone is limiting, then
`LightProfinite.Extend.functor` is initial.
|
functorOp_final (hc : IsLimit c) [∀ i, Epi (c.π.app i)] : Final (functorOp c) := by
have := functor_initial c hc
have : ((StructuredArrow.toCostructuredArrow toLightProfinite c.pt)).IsEquivalence :=
(inferInstance : (structuredArrowOpEquivalence _ _).functor.IsEquivalence )
have : (functor c).rightOp.Final :=
inferInstanceAs ((opOpEquivalence ℕ).inverse ⋙ (functor c).op).Final
exact Functor.final_comp (functor c).rightOp _
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
functorOp_final
|
If the projection maps in the cone are epimorphic and the cone is limiting, then
`LightProfinite.Extend.functorOp` is final.
|
cone (S : LightProfinite) :
Cone (StructuredArrow.proj S toLightProfinite ⋙ toLightProfinite ⋙ G) where
pt := G.obj S
π := {
app := fun i ↦ G.map i.hom
naturality := fun _ _ f ↦ (by
have := f.w
simp only [const_obj_obj, StructuredArrow.left_eq_id, const_obj_map, Category.id_comp,
StructuredArrow.w] at this
simp only [const_obj_obj, comp_obj, StructuredArrow.proj_obj, const_obj_map, Category.id_comp,
Functor.comp_map, StructuredArrow.proj_map, ← map_comp, StructuredArrow.w]) }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
cone
|
Given a functor `G` from `LightProfinite` and `S : LightProfinite`, we obtain a cone on
`(StructuredArrow.proj S toLightProfinite ⋙ toLightProfinite ⋙ G)` with cone point `G.obj S`.
Whiskering this cone with `LightProfinite.Extend.functor c` gives `G.mapCone c` as we check in the
example below.
|
noncomputable
isLimitCone (hc : IsLimit c) [∀ i, Epi (c.π.app i)] (hc' : IsLimit <| G.mapCone c) :
IsLimit (cone G c.pt) := (functor_initial c hc).isLimitWhiskerEquiv _ _ hc'
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
isLimitCone
|
If `c` and `G.mapCone c` are limit cones and the projection maps in `c` are epimorphic,
then `cone G c.pt` is a limit cone.
|
@[simps]
cocone (S : LightProfinite) :
Cocone (CostructuredArrow.proj toLightProfinite.op ⟨S⟩ ⋙ toLightProfinite.op ⋙ G) where
pt := G.obj ⟨S⟩
ι := {
app := fun i ↦ G.map i.hom
naturality := fun _ _ f ↦ (by
have := f.w
simp only [op_obj, const_obj_obj, op_map, CostructuredArrow.right_eq_id, const_obj_map,
Category.comp_id] at this
simp only [comp_obj, CostructuredArrow.proj_obj, op_obj, const_obj_obj, Functor.comp_map,
CostructuredArrow.proj_map, op_map, ← map_comp, this, const_obj_map, Category.comp_id]) }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
cocone
|
Given a functor `G` from `LightProfiniteᵒᵖ` and `S : LightProfinite`, we obtain a cocone on
`(CostructuredArrow.proj toLightProfinite.op ⟨S⟩ ⋙ toLightProfinite.op ⋙ G)` with cocone point
`G.obj ⟨S⟩`.
Whiskering this cocone with `LightProfinite.Extend.functorOp c` gives `G.mapCocone c.op` as we
check in the example below.
|
noncomputable
isColimitCocone (hc : IsLimit c) [∀ i, Epi (c.π.app i)] (hc' : IsColimit <| G.mapCocone c.op) :
IsColimit (cocone G c.pt) :=
haveI := functorOp_final c hc
(Functor.final_comp (opOpEquivalence ℕ).functor (functorOp c)).isColimitWhiskerEquiv _ _ hc'
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
isColimitCocone
|
If `c` is a limit cone, `G.mapCocone c.op` is a colimit cone and the projection maps in `c`
are epimorphic, then `cocone G c.pt` is a colimit cone.
|
fintypeDiagram' : StructuredArrow S toLightProfinite ⥤ FintypeCat :=
StructuredArrow.proj S toLightProfinite
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
fintypeDiagram'
|
A functor `StructuredArrow S toLightProfinite ⥤ FintypeCat` whose limit in `LightProfinite` is
isomorphic to `S`.
|
diagram' : StructuredArrow S toLightProfinite ⥤ LightProfinite :=
S.fintypeDiagram' ⋙ toLightProfinite
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
diagram'
|
An abbreviation for `S.fintypeDiagram' ⋙ toLightProfinite`.
|
asLimitCone' : Cone (S.diagram') := cone (𝟭 _) S
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
asLimitCone'
|
A cone over `S.diagram'` whose cone point is `S`.
|
noncomputable asLimit' : IsLimit S.asLimitCone' := isLimitCone _ (𝟭 _) S.asLimit S.asLimit
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
asLimit'
|
`S.asLimitCone'` is a limit cone.
|
noncomputable lim' : LimitCone S.diagram' := ⟨S.asLimitCone', S.asLimit'⟩
|
def
|
Topology
|
[
"Mathlib.Topology.Category.LightProfinite.AsLimit",
"Mathlib.Topology.Category.Profinite.Extend"
] |
Mathlib/Topology/Category/LightProfinite/Extend.lean
|
lim'
|
A bundled version of `S.asLimitCone'` and `S.asLimit'`.
|
isTerminalPUnit : IsTerminal (LightProfinite.of PUnit.{u + 1}) :=
CompHausLike.isTerminalPUnit
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.CompHausLike.Limits",
"Mathlib.Topology.Category.LightProfinite.Basic"
] |
Mathlib/Topology/Category/LightProfinite/Limits.lean
|
isTerminalPUnit
|
A one-element space is terminal in `Profinite`
|
noncomputable natUnionInftyEmbedding : C(OnePoint ℕ, ℝ) where
toFun
| ∞ => 0
| OnePoint.some n => 1 / (n + 1 : ℝ)
continuous_toFun := OnePoint.continuous_iff_from_nat _ |>.mpr
tendsto_one_div_add_atTop_nhds_zero_nat
|
def
|
Topology
|
[
"Mathlib.Topology.Compactification.OnePoint.Basic",
"Mathlib.Topology.Category.LightProfinite.Basic"
] |
Mathlib/Topology/Category/LightProfinite/Sequence.lean
|
natUnionInftyEmbedding
|
The continuous map from `ℕ∪{∞}` to `ℝ` sending `n` to `1/(n+1)` and `∞` to `0`.
|
isClosedEmbedding_natUnionInftyEmbedding : IsClosedEmbedding natUnionInftyEmbedding := by
refine .of_continuous_injective_isClosedMap
natUnionInftyEmbedding.continuous ?_ ?_
· rintro (_ | n) (_ | m) h
· rfl
· simp only [natUnionInftyEmbedding, one_div, ContinuousMap.coe_mk, zero_eq_inv] at h
assumption_mod_cast
· simp only [natUnionInftyEmbedding, one_div, ContinuousMap.coe_mk, inv_eq_zero] at h
assumption_mod_cast
· simp only [natUnionInftyEmbedding, one_div, ContinuousMap.coe_mk, inv_inj, add_left_inj,
Nat.cast_inj] at h
rw [h]
· exact fun _ hC => (hC.isCompact.image natUnionInftyEmbedding.continuous).isClosed
|
lemma
|
Topology
|
[
"Mathlib.Topology.Compactification.OnePoint.Basic",
"Mathlib.Topology.Category.LightProfinite.Basic"
] |
Mathlib/Topology/Category/LightProfinite/Sequence.lean
|
isClosedEmbedding_natUnionInftyEmbedding
|
The continuous map from `ℕ∪{∞}` to `ℝ` sending `n` to `1/(n+1)` and `∞` to `0` is a closed
embedding.
|
NatUnionInfty : LightProfinite := of (OnePoint ℕ)
@[inherit_doc]
scoped notation "ℕ∪{∞}" => NatUnionInfty
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Compactification.OnePoint.Basic",
"Mathlib.Topology.Category.LightProfinite.Basic"
] |
Mathlib/Topology/Category/LightProfinite/Sequence.lean
|
NatUnionInfty
|
The one point compactification of the natural numbers as a light profinite set.
|
continuous_iff_convergent {Y : Type*} [TopologicalSpace Y] (f : ℕ∪{∞} → Y) :
Continuous f ↔ Tendsto (fun x : ℕ ↦ f x) atTop (𝓝 (f ∞)) :=
continuous_iff_from_nat f
|
lemma
|
Topology
|
[
"Mathlib.Topology.Compactification.OnePoint.Basic",
"Mathlib.Topology.Category.LightProfinite.Basic"
] |
Mathlib/Topology/Category/LightProfinite/Sequence.lean
|
continuous_iff_convergent
| null |
fintypeDiagram : DiscreteQuotient X ⥤ FintypeCat where
obj S := @FintypeCat.of S (Fintype.ofFinite S)
map f := DiscreteQuotient.ofLE f.le
map_comp _ _ := by funext; cat_disch
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
fintypeDiagram
|
The functor `DiscreteQuotient X ⥤ Fintype` whose limit is isomorphic to `X`.
|
diagram : DiscreteQuotient X ⥤ Profinite :=
X.fintypeDiagram ⋙ FintypeCat.toProfinite
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
diagram
|
An abbreviation for `X.fintypeDiagram ⋙ FintypeCat.toProfinite`.
|
asLimitCone : CategoryTheory.Limits.Cone X.diagram :=
{ pt := X
π := { app := fun S => CompHausLike.ofHom (Y := X.diagram.obj S) _
⟨S.proj, IsLocallyConstant.continuous (S.proj_isLocallyConstant)⟩ } }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
asLimitCone
|
A cone over `X.diagram` whose cone point is `X`.
|
isIso_asLimitCone_lift : IsIso ((limitConeIsLimit.{u, u} X.diagram).lift X.asLimitCone) :=
CompHausLike.isIso_of_bijective _
(by
refine ⟨fun a b h => ?_, fun a => ?_⟩
· refine DiscreteQuotient.eq_of_forall_proj_eq fun S => ?_
apply_fun fun f : (limitCone.{u, u} X.diagram).pt => f.val S at h
exact h
· obtain ⟨b, hb⟩ :=
DiscreteQuotient.exists_of_compat (fun S => a.val S) fun _ _ h => a.prop (homOfLE h)
use b
apply Subtype.ext
apply funext
rintro S
apply hb
)
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
isIso_asLimitCone_lift
| null |
isoAsLimitConeLift : X ≅ (limitCone.{u, u} X.diagram).pt :=
asIso <| (limitConeIsLimit.{u, u} _).lift X.asLimitCone
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
isoAsLimitConeLift
|
The isomorphism between `X` and the explicit limit of `X.diagram`,
induced by lifting `X.asLimitCone`.
|
asLimitConeIso : X.asLimitCone ≅ limitCone.{u, u} _ :=
Limits.Cones.ext (isoAsLimitConeLift _) fun _ => rfl
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
asLimitConeIso
|
The isomorphism of cones `X.asLimitCone` and `Profinite.limitCone X.diagram`.
The underlying isomorphism is defeq to `X.isoAsLimitConeLift`.
|
asLimit : CategoryTheory.Limits.IsLimit X.asLimitCone :=
Limits.IsLimit.ofIsoLimit (limitConeIsLimit _) X.asLimitConeIso.symm
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
asLimit
|
`X.asLimitCone` is indeed a limit cone.
|
lim : Limits.LimitCone X.diagram :=
⟨X.asLimitCone, X.asLimit⟩
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.DiscreteQuotient"
] |
Mathlib/Topology/Category/Profinite/AsLimit.lean
|
lim
|
A bundled version of `X.asLimitCone` and `X.asLimit`.
|
and is a fully faithful subcategory of `TopCat`. The fully faithful functor
is called `Profinite.toTop`.
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
and
| null |
Profinite := CompHausLike (fun X ↦ TotallyDisconnectedSpace X)
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
Profinite
|
The type of profinite topological spaces.
|
of (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X]
[TotallyDisconnectedSpace X] : Profinite :=
CompHausLike.of _ X
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
of
|
Construct a term of `Profinite` from a type endowed with the structure of a
compact, Hausdorff and totally disconnected topological space.
|
profiniteToCompHaus : Profinite ⥤ CompHaus :=
compHausLikeToCompHaus _
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
profiniteToCompHaus
|
The fully faithful embedding of `Profinite` in `CompHaus`.
|
Profinite.toTopCat : Profinite ⥤ TopCat :=
CompHausLike.compHausLikeToTop _
|
abbrev
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
Profinite.toTopCat
|
The fully faithful embedding of `Profinite` in `TopCat`.
This is definitionally the same as the obvious composite.
|
@[stacks 0900]
CompHaus.toProfiniteObj (X : CompHaus.{u}) : Profinite.{u} where
toTop := TopCat.of (ConnectedComponents X)
is_compact := Quotient.compactSpace
is_hausdorff := ConnectedComponents.t2
prop := ConnectedComponents.totallyDisconnectedSpace
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
CompHaus.toProfiniteObj
|
(Implementation) The object part of the connected_components functor from compact Hausdorff spaces
to Profinite spaces, given by quotienting a space by its connected components.
|
Profinite.toCompHausEquivalence (X : CompHaus.{u}) (Y : Profinite.{u}) :
(CompHaus.toProfiniteObj X ⟶ Y) ≃ (X ⟶ profiniteToCompHaus.obj Y) where
toFun f := ofHom _ (f.hom.comp ⟨Quotient.mk'', continuous_quotient_mk'⟩)
invFun g := TopCat.ofHom
{ toFun := Continuous.connectedComponentsLift g.hom.2
continuous_toFun := Continuous.connectedComponentsLift_continuous g.hom.2 }
left_inv _ := TopCat.ext <| ConnectedComponents.surjective_coe.forall.2 fun _ => rfl
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
Profinite.toCompHausEquivalence
|
(Implementation) The bijection of homsets to establish the reflective adjunction of Profinite
spaces in compact Hausdorff spaces.
|
CompHaus.toProfinite : CompHaus ⥤ Profinite :=
Adjunction.leftAdjointOfEquiv Profinite.toCompHausEquivalence fun _ _ _ _ _ => rfl
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
CompHaus.toProfinite
|
The connected_components functor from compact Hausdorff spaces to profinite spaces,
left adjoint to the inclusion functor.
|
CompHaus.toProfinite_obj' (X : CompHaus) :
↥(CompHaus.toProfinite.obj X) = ConnectedComponents X :=
rfl
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
CompHaus.toProfinite_obj'
| null |
FintypeCat.botTopology (A : FintypeCat) : TopologicalSpace A := ⊥
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
FintypeCat.botTopology
|
Finite types are given the discrete topology.
|
FintypeCat.discreteTopology (A : FintypeCat) : DiscreteTopology A :=
⟨rfl⟩
attribute [local instance] FintypeCat.discreteTopology
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
FintypeCat.discreteTopology
| null |
@[simps! -isSimp map_hom_apply]
FintypeCat.toProfinite : FintypeCat ⥤ Profinite where
obj A := Profinite.of A
map f := ofHom _ ⟨f, by continuity⟩
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
FintypeCat.toProfinite
|
The natural functor from `Fintype` to `Profinite`, endowing a finite type with the
discrete topology.
|
FintypeCat.toProfiniteFullyFaithful : toProfinite.FullyFaithful where
preimage f := (f : _ → _)
map_preimage _ := rfl
preimage_map _ := rfl
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
FintypeCat.toProfiniteFullyFaithful
|
`FintypeCat.toLightProfinite` is fully faithful.
|
limitCone {J : Type v} [SmallCategory J] (F : J ⥤ Profinite.{max u v}) : Limits.Cone F where
pt :=
{ toTop := (CompHaus.limitCone.{v, u} (F ⋙ profiniteToCompHaus)).pt.toTop
prop := by
change TotallyDisconnectedSpace ({ u : ∀ j : J, F.obj j | _ } : Type _)
exact Subtype.totallyDisconnectedSpace }
π :=
{ app := (CompHaus.limitCone.{v, u} (F ⋙ profiniteToCompHaus)).π.app
naturality := by
intro j k f
ext ⟨g, p⟩
exact (p f).symm }
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
limitCone
|
An explicit limit cone for a functor `F : J ⥤ Profinite`, defined in terms of
`CompHaus.limitCone`, which is defined in terms of `TopCat.limitCone`.
|
limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ Profinite.{max u v}) :
Limits.IsLimit (limitCone F) where
lift S :=
(CompHaus.limitConeIsLimit.{v, u} (F ⋙ profiniteToCompHaus)).lift
(profiniteToCompHaus.mapCone S)
uniq S _ h := (CompHaus.limitConeIsLimit.{v, u} _).uniq (profiniteToCompHaus.mapCone S) _ h
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
limitConeIsLimit
|
The limit cone `Profinite.limitCone F` is indeed a limit cone.
|
toProfiniteAdjToCompHaus : CompHaus.toProfinite ⊣ profiniteToCompHaus :=
Adjunction.adjunctionOfEquivLeft _ _
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
toProfiniteAdjToCompHaus
|
The adjunction between CompHaus.to_Profinite and Profinite.to_CompHaus
|
toCompHaus.reflective : Reflective profiniteToCompHaus where
L := CompHaus.toProfinite
adj := Profinite.toProfiniteAdjToCompHaus
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
toCompHaus.reflective
|
The category of profinite sets is reflective in the category of compact Hausdorff spaces
|
noncomputable toCompHaus.createsLimits : CreatesLimits profiniteToCompHaus :=
monadicCreatesLimits _
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
toCompHaus.createsLimits
| null |
noncomputable toTopCat.reflective : Reflective Profinite.toTopCat :=
Reflective.comp profiniteToCompHaus compHausToTop
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
toTopCat.reflective
| null |
noncomputable toTopCat.createsLimits : CreatesLimits Profinite.toTopCat :=
monadicCreatesLimits _
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
toTopCat.createsLimits
| null |
hasLimits : Limits.HasLimits Profinite :=
hasLimits_of_hasLimits_createsLimits Profinite.toTopCat
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
hasLimits
| null |
hasColimits : Limits.HasColimits Profinite :=
hasColimits_of_reflective profiniteToCompHaus
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
hasColimits
| null |
forget_preservesLimits : Limits.PreservesLimits (forget Profinite) := by
apply Limits.comp_preservesLimits Profinite.toTopCat (forget TopCat)
|
instance
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
forget_preservesLimits
| null |
epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f := by
constructor
· dsimp [Function.Surjective]
contrapose!
rintro ⟨y, hy⟩ hf
let C := Set.range f
have hC : IsClosed C := (isCompact_range f.hom.continuous).isClosed
let U := Cᶜ
have hyU : y ∈ U := by
refine Set.mem_compl ?_
rintro ⟨y', hy'⟩
exact hy y' hy'
have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
obtain ⟨V, hV, hyV, hVU⟩ := isTopologicalBasis_isClopen.mem_nhds_iff.mp hUy
classical
let Z := of (ULift.{u} <| Fin 2)
let g : Y ⟶ Z := ofHom _
⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩
let h : Y ⟶ Z := ofHom _ ⟨fun _ => ⟨1⟩, continuous_const⟩
have H : h = g := by
rw [← cancel_epi f]
ext x
dsimp [g, LocallyConstant.ofIsClopen]
rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, ConcreteCategory.hom_ofHom,
ContinuousMap.coe_mk, Function.comp_apply, if_neg]
refine mt (fun α => hVU α) ?_
simp [U, C]
apply_fun fun e => (e y).down at H
dsimp [g, LocallyConstant.ofIsClopen] at H
rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
exact top_ne_bot H
· rw [← CategoryTheory.epi_iff_surjective]
apply (forget Profinite).epi_of_epi_map
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
epi_iff_surjective
| null |
pi {α : Type u} (β : α → Profinite) : Profinite := .of (Π (a : α), β a)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.FintypeCat",
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.Separation.Profinite"
] |
Mathlib/Topology/Category/Profinite/Basic.lean
|
pi
|
The pi-type of profinite spaces is profinite.
|
exists_isClopen_of_cofiltered {U : Set C.pt} (hC : IsLimit C) (hU : IsClopen U) :
∃ (j : J) (V : Set (F.obj j)), IsClopen V ∧ U = C.π.app j ⁻¹' V := by
have hB := TopCat.isTopologicalBasis_cofiltered_limit.{u, v} (F ⋙ Profinite.toTopCat)
(Profinite.toTopCat.mapCone C) (isLimitOfPreserves _ hC) (fun j => {W | IsClopen W}) ?_
(fun i => isClopen_univ) (fun i U1 U2 hU1 hU2 => hU1.inter hU2) ?_
rotate_left
· intro i
change TopologicalSpace.IsTopologicalBasis {W : Set (F.obj i) | IsClopen W}
apply isTopologicalBasis_isClopen
· rintro i j f V (hV : IsClopen _)
refine ⟨hV.1.preimage ?_, hV.2.preimage ?_⟩ <;> continuity
obtain ⟨S, hS, h⟩ := hB.open_eq_sUnion hU.2
clear hB
let j : S → J := fun s => (hS s.2).choose
let V : ∀ s : S, Set (F.obj (j s)) := fun s => (hS s.2).choose_spec.choose
have hV : ∀ s : S, IsClopen (V s) ∧ s.1 = C.π.app (j s) ⁻¹' V s := fun s =>
(hS s.2).choose_spec.choose_spec
have hUo : ∀ (i : ↑S), IsOpen ((fun s ↦ (C.π.app (j s)) ⁻¹' V s) i) := by
intro s
exact (hV s).1.2.preimage (C.π.app (j s)).hom.continuous
have hsU : U ⊆ ⋃ (i : ↑S), (fun s ↦ C.π.app (j s) ⁻¹' V s) i := by
dsimp only
rw [h]
rintro x ⟨T, hT, hx⟩
refine ⟨_, ⟨⟨T, hT⟩, rfl⟩, ?_⟩
dsimp only
rwa [← (hV ⟨T, hT⟩).2]
have := hU.1.isCompact.elim_finite_subcover (fun s : S => C.π.app (j s) ⁻¹' V s) hUo hsU
obtain ⟨G, hG⟩ := this
classical
obtain ⟨j0, hj0⟩ := IsCofiltered.inf_objs_exists (G.image j)
let f : ∀ s ∈ G, j0 ⟶ j s := fun s hs => (hj0 (Finset.mem_image.mpr ⟨s, hs, rfl⟩)).some
let W : S → Set (F.obj j0) := fun s => if hs : s ∈ G then F.map (f s hs) ⁻¹' V s else Set.univ
refine ⟨j0, ⋃ (s : S) (_ : s ∈ G), W s, ?_, ?_⟩
· apply isClopen_biUnion_finset
intro s hs
dsimp [W]
rw [dif_pos hs]
refine ⟨(hV s).1.1.preimage ?_, (hV s).1.2.preimage ?_⟩ <;> fun_prop
· ext x
constructor
· intro hx
simp_rw [W, Set.preimage_iUnion, Set.mem_iUnion]
obtain ⟨_, ⟨s, rfl⟩, _, ⟨hs, rfl⟩, hh⟩ := hG hx
refine ⟨s, hs, ?_⟩
rwa [dif_pos hs, ← Set.preimage_comp, ← CompHausLike.coe_comp, C.w]
· intro hx
simp_rw [W, Set.preimage_iUnion, Set.mem_iUnion] at hx
obtain ⟨s, hs, hx⟩ := hx
rw [h]
refine ⟨s.1, s.2, ?_⟩
...
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.DiscreteQuotient",
"Mathlib.Topology.Category.TopCat.Limits.Cofiltered",
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] |
Mathlib/Topology/Category/Profinite/CofilteredLimit.lean
|
exists_isClopen_of_cofiltered
|
If `X` is a cofiltered limit of profinite sets, then any clopen subset of `X` arises from
a clopen set in one of the terms in the limit.
|
exists_locallyConstant_fin_two (hC : IsLimit C) (f : LocallyConstant C.pt (Fin 2)) :
∃ (j : J) (g : LocallyConstant (F.obj j) (Fin 2)), f = g.comap (C.π.app _).hom := by
let U := f ⁻¹' {0}
have hU : IsClopen U := f.isLocallyConstant.isClopen_fiber _
obtain ⟨j, V, hV, h⟩ := exists_isClopen_of_cofiltered C hC hU
classical
use j, LocallyConstant.ofIsClopen hV
apply LocallyConstant.locallyConstant_eq_of_fiber_zero_eq
simp only [Fin.isValue, Functor.const_obj_obj, LocallyConstant.coe_comap, Set.preimage_comp,
LocallyConstant.ofIsClopen_fiber_zero]
exact h
open Classical in
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.DiscreteQuotient",
"Mathlib.Topology.Category.TopCat.Limits.Cofiltered",
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] |
Mathlib/Topology/Category/Profinite/CofilteredLimit.lean
|
exists_locallyConstant_fin_two
| null |
exists_locallyConstant_finite_aux {α : Type*} [Finite α] (hC : IsLimit C)
(f : LocallyConstant C.pt α) : ∃ (j : J) (g : LocallyConstant (F.obj j) (α → Fin 2)),
(f.map fun a b => if a = b then (0 : Fin 2) else 1) = g.comap (C.π.app _).hom := by
cases nonempty_fintype α
let ι : α → α → Fin 2 := fun x y => if x = y then 0 else 1
let ff := (f.map ι).flip
have hff := fun a : α => exists_locallyConstant_fin_two _ hC (ff a)
choose j g h using hff
let G : Finset J := Finset.univ.image j
obtain ⟨j0, hj0⟩ := IsCofiltered.inf_objs_exists G
have hj : ∀ a, j a ∈ (Finset.univ.image j : Finset J) := by grind
let fs : ∀ a : α, j0 ⟶ j a := fun a => (hj0 (hj a)).some
let gg : α → LocallyConstant (F.obj j0) (Fin 2) := fun a => (g a).comap (F.map (fs _)).hom
let ggg := LocallyConstant.unflip gg
refine ⟨j0, ggg, ?_⟩
have : f.map ι = LocallyConstant.unflip (f.map ι).flip := by simp
rw [this]; clear this
have :
LocallyConstant.comap (C.π.app j0).hom ggg =
LocallyConstant.unflip (LocallyConstant.comap (C.π.app j0).hom ggg).flip := by
simp
rw [this]; clear this
congr 1
ext1 a
change ff a = _
rw [h]
dsimp
ext1 x
change _ = (g a) ((C.π.app j0 ≫ F.map (fs a)) x)
rw [C.w]; rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.DiscreteQuotient",
"Mathlib.Topology.Category.TopCat.Limits.Cofiltered",
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] |
Mathlib/Topology/Category/Profinite/CofilteredLimit.lean
|
exists_locallyConstant_finite_aux
| null |
exists_locallyConstant_finite_nonempty {α : Type*} [Finite α] [Nonempty α]
(hC : IsLimit C) (f : LocallyConstant C.pt α) :
∃ (j : J) (g : LocallyConstant (F.obj j) α), f = g.comap (C.π.app _).hom := by
inhabit α
obtain ⟨j, gg, h⟩ := exists_locallyConstant_finite_aux _ hC f
classical
let ι : α → α → Fin 2 := fun a b => if a = b then 0 else 1
let σ : (α → Fin 2) → α := fun f => if h : ∃ a : α, ι a = f then h.choose else default
refine ⟨j, gg.map σ, ?_⟩
ext x
simp only [Functor.const_obj_obj, LocallyConstant.coe_comap, LocallyConstant.map_apply,
Function.comp_apply]
dsimp [σ]
have h1 : ι (f x) = gg (C.π.app j x) := by
change f.map (fun a b => if a = b then (0 : Fin 2) else 1) x = _
rw [h]
rfl
have h2 : ∃ a : α, ι a = gg (C.π.app j x) := ⟨f x, h1⟩
rw [dif_pos]
swap
· assumption
apply_fun ι
· rw [h2.choose_spec]
exact h1
· intro a b hh
have hhh := congr_fun hh a
dsimp [ι] at hhh
rw [if_pos rfl] at hhh
split_ifs at hhh with hh1
· exact hh1.symm
· exact False.elim (bot_ne_top hhh)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.DiscreteQuotient",
"Mathlib.Topology.Category.TopCat.Limits.Cofiltered",
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] |
Mathlib/Topology/Category/Profinite/CofilteredLimit.lean
|
exists_locallyConstant_finite_nonempty
| null |
exists_locallyConstant {α : Type*} (hC : IsLimit C) (f : LocallyConstant C.pt α) :
∃ (j : J) (g : LocallyConstant (F.obj j) α), f = g.comap (C.π.app _).hom := by
let S := f.discreteQuotient
let ff : S → α := f.lift
cases isEmpty_or_nonempty S
· suffices ∃ j, IsEmpty (F.obj j) by
refine this.imp fun j hj => ?_
refine ⟨⟨hj.elim, fun A => ?_⟩, ?_⟩
· suffices (fun a ↦ IsEmpty.elim hj a) ⁻¹' A = ∅ by
rw [this]
exact isOpen_empty
exact @Set.eq_empty_of_isEmpty _ hj _
· ext x
exact hj.elim' (C.π.app j x)
by_contra! h
haveI : ∀ j : J, Nonempty ((F ⋙ Profinite.toTopCat).obj j) := h
haveI : ∀ j : J, T2Space ((F ⋙ Profinite.toTopCat).obj j) := fun j =>
(inferInstance : T2Space (F.obj j))
haveI : ∀ j : J, CompactSpace ((F ⋙ Profinite.toTopCat).obj j) := fun j =>
(inferInstance : CompactSpace (F.obj j))
have cond := TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system.{u}
(F ⋙ Profinite.toTopCat)
suffices Nonempty C.pt from IsEmpty.false (S.proj this.some)
let D := Profinite.toTopCat.mapCone C
have hD : IsLimit D := isLimitOfPreserves Profinite.toTopCat hC
have CD := (hD.conePointUniqueUpToIso (TopCat.limitConeIsLimit.{v, max u v} _)).inv
exact cond.map CD
· let f' : LocallyConstant C.pt S := ⟨S.proj, S.proj_isLocallyConstant⟩
obtain ⟨j, g', hj⟩ := exists_locallyConstant_finite_nonempty _ hC f'
refine ⟨j, ⟨ff ∘ g', g'.isLocallyConstant.comp _⟩, ?_⟩
ext1 t
apply_fun fun e => e t at hj
dsimp at hj ⊢
rw [← hj]
rfl
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.LocallyConstant.Basic",
"Mathlib.Topology.DiscreteQuotient",
"Mathlib.Topology.Category.TopCat.Limits.Cofiltered",
"Mathlib.Topology.Category.TopCat.Limits.Konig"
] |
Mathlib/Topology/Category/Profinite/CofilteredLimit.lean
|
exists_locallyConstant
|
Any locally constant function from a cofiltered limit of profinite sets factors through
one of the components.
|
effectiveEpi_tfae
{B X : Profinite.{u}} (π : X ⟶ B) :
TFAE
[ EffectiveEpi π
, Epi π
, Function.Surjective π
] := by
tfae_have 1 → 2 := fun _ ↦ inferInstance
tfae_have 2 ↔ 3 := epi_iff_surjective π
tfae_have 3 → 1 := fun hπ ↦ ⟨⟨CompHausLike.effectiveEpiStruct π hπ⟩⟩
tfae_finish
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Coherent.ReflectsPreregular",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi",
"Mathlib.Topology.Category.Profinite.Limits",
"Mathlib.Topology.Category.Stonean.Basic"
] |
Mathlib/Topology/Category/Profinite/EffectiveEpi.lean
|
effectiveEpi_tfae
| null |
noncomputable profiniteToCompHausEffectivePresentation (X : CompHaus) :
profiniteToCompHaus.EffectivePresentation X where
p := Stonean.toProfinite.obj X.presentation
f := CompHaus.presentation.π X
effectiveEpi := ((CompHaus.effectiveEpi_tfae _).out 0 1).mpr (inferInstance : Epi _)
|
def
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Coherent.ReflectsPreregular",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi",
"Mathlib.Topology.Category.Profinite.Limits",
"Mathlib.Topology.Category.Stonean.Basic"
] |
Mathlib/Topology/Category/Profinite/EffectiveEpi.lean
|
profiniteToCompHausEffectivePresentation
|
An effective presentation of an `X : Profinite` with respect to the inclusion functor from `Stonean`
|
effectiveEpiFamily_tfae
{α : Type} [Finite α] {B : Profinite.{u}}
(X : α → Profinite.{u}) (π : (a : α) → (X a ⟶ B)) :
TFAE
[ EffectiveEpiFamily X π
, Epi (Sigma.desc π)
, ∀ b : B, ∃ (a : α) (x : X a), π a x = b
] := by
tfae_have 2 → 1
| _ => by
simpa [← effectiveEpi_desc_iff_effectiveEpiFamily, (effectiveEpi_tfae (Sigma.desc π)).out 0 1]
tfae_have 1 → 2 := fun _ ↦ inferInstance
tfae_have 3 ↔ 1 := by
erw [((CompHaus.effectiveEpiFamily_tfae
(fun a ↦ profiniteToCompHaus.obj (X a)) (fun a ↦ profiniteToCompHaus.map (π a))).out 2 0 : )]
exact ⟨fun h ↦ profiniteToCompHaus.finite_effectiveEpiFamily_of_map _ _ h,
fun _ ↦ inferInstance⟩
tfae_finish
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Coherent.ReflectsPreregular",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi",
"Mathlib.Topology.Category.Profinite.Limits",
"Mathlib.Topology.Category.Stonean.Basic"
] |
Mathlib/Topology/Category/Profinite/EffectiveEpi.lean
|
effectiveEpiFamily_tfae
| null |
effectiveEpiFamily_of_jointly_surjective
{α : Type} [Finite α] {B : Profinite.{u}}
(X : α → Profinite.{u}) (π : (a : α) → (X a ⟶ B))
(surj : ∀ b : B, ∃ (a : α) (x : X a), π a x = b) :
EffectiveEpiFamily X π :=
((effectiveEpiFamily_tfae X π).out 2 0).mp surj
|
theorem
|
Topology
|
[
"Mathlib.CategoryTheory.Sites.Coherent.ReflectsPreregular",
"Mathlib.Topology.Category.CompHaus.EffectiveEpi",
"Mathlib.Topology.Category.Profinite.Limits",
"Mathlib.Topology.Category.Stonean.Basic"
] |
Mathlib/Topology/Category/Profinite/EffectiveEpi.lean
|
effectiveEpiFamily_of_jointly_surjective
| null |
exists_hom (hc : IsLimit c) {X : FintypeCat} (f : c.pt ⟶ toProfinite.obj X) :
∃ (i : I) (g : F.obj i ⟶ X), f = c.π.app i ≫ toProfinite.map g := by
let _ : TopologicalSpace X := ⊥
have : DiscreteTopology (toProfinite.obj X) := ⟨rfl⟩
let f' : LocallyConstant c.pt (toProfinite.obj X) :=
⟨f, (IsLocallyConstant.iff_continuous _).mpr f.hom.continuous⟩
obtain ⟨i, g, h⟩ := exists_locallyConstant.{_, u} c hc f'
refine ⟨i, (g : _ → _), ?_⟩
ext x
exact LocallyConstant.congr_fun h x
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
exists_hom
|
A continuous map from a profinite set to a finite set factors through one of the components of
the profinite set when written as a cofiltered limit of finite sets.
|
@[simps]
functor : I ⥤ StructuredArrow c.pt toProfinite where
obj i := StructuredArrow.mk (c.π.app i)
map f := StructuredArrow.homMk (F.map f) (c.w f)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
functor
|
Given a cone in `Profinite`, consisting of finite sets and indexed by a cofiltered category,
we obtain a functor from the indexing category to `StructuredArrow c.pt toProfinite`.
|
@[simps! obj map]
functorOp : Iᵒᵖ ⥤ CostructuredArrow toProfinite.op ⟨c.pt⟩ :=
(functor c).op ⋙ StructuredArrow.toCostructuredArrow _ _
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
functorOp
|
Given a cone in `Profinite`, consisting of finite sets and indexed by a cofiltered category,
we obtain a functor from the opposite of the indexing category to
`CostructuredArrow toProfinite.op ⟨c.pt⟩`.
|
functor_initial (hc : IsLimit c) [∀ i, Epi (c.π.app i)] : Initial (functor c) := by
let e : I ≌ ULiftHom.{w} (ULift.{w} I) := ULiftHomULiftCategory.equiv _
suffices (e.inverse ⋙ functor c).Initial from initial_of_equivalence_comp e.inverse (functor c)
rw [initial_iff_of_isCofiltered (F := e.inverse ⋙ functor c)]
constructor
· intro ⟨_, X, (f : c.pt ⟶ _)⟩
obtain ⟨i, g, h⟩ := exists_hom c hc f
exact ⟨⟨i⟩, ⟨StructuredArrow.homMk g h.symm⟩⟩
· intro ⟨_, X, (f : c.pt ⟶ _)⟩ ⟨i⟩ ⟨_, (s : F.obj i ⟶ X), (w : f = c.π.app i ≫ _)⟩
⟨_, (s' : F.obj i ⟶ X), (w' : f = c.π.app i ≫ _)⟩
simp only [StructuredArrow.hom_eq_iff,
StructuredArrow.comp_right]
refine ⟨⟨i⟩, 𝟙 _, ?_⟩
simp only [CategoryTheory.Functor.map_id]
rw [w] at w'
exact toProfinite.map_injective <| Epi.left_cancellation _ _ w'
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
functor_initial
|
If the projection maps in the cone are epimorphic and the cone is limiting, then
`Profinite.Extend.functor` is initial.
TODO: investigate how to weaken the assumption `∀ i, Epi (c.π.app i)` to
`∀ i, ∃ j (_ : j ⟶ i), Epi (c.π.app j)`.
|
functorOp_final (hc : IsLimit c) [∀ i, Epi (c.π.app i)] : Final (functorOp c) := by
have := functor_initial c hc
have : ((StructuredArrow.toCostructuredArrow toProfinite c.pt)).IsEquivalence :=
(inferInstance : (structuredArrowOpEquivalence _ _).functor.IsEquivalence )
exact Functor.final_comp (functor c).op _
|
lemma
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
functorOp_final
|
If the projection maps in the cone are epimorphic and the cone is limiting, then
`Profinite.Extend.functorOp` is final.
|
@[simps]
cone (S : Profinite) :
Cone (StructuredArrow.proj S toProfinite ⋙ toProfinite ⋙ G) where
pt := G.obj S
π := {
app := fun i ↦ G.map i.hom
naturality := fun _ _ f ↦ (by simp [← map_comp]) }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
cone
|
Given a functor `G` from `Profinite` and `S : Profinite`, we obtain a cone on
`(StructuredArrow.proj S toProfinite ⋙ toProfinite ⋙ G)` with cone point `G.obj S`.
Whiskering this cone with `Profinite.Extend.functor c` gives `G.mapCone c` as we check in the
example below.
|
noncomputable
isLimitCone (hc : IsLimit c) [∀ i, Epi (c.π.app i)] (hc' : IsLimit <| G.mapCone c) :
IsLimit (cone G c.pt) := (functor_initial c hc).isLimitWhiskerEquiv _ _ hc'
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
isLimitCone
|
If `c` and `G.mapCone c` are limit cones and the projection maps in `c` are epimorphic,
then `cone G c.pt` is a limit cone.
|
@[simps]
cocone (S : Profinite) :
Cocone (CostructuredArrow.proj toProfinite.op ⟨S⟩ ⋙ toProfinite.op ⋙ G) where
pt := G.obj ⟨S⟩
ι := {
app := fun i ↦ G.map i.hom
naturality := fun _ _ f ↦ (by
have := f.w
simp only [op_obj, const_obj_obj, op_map, CostructuredArrow.right_eq_id, const_obj_map,
Category.comp_id] at this
simp [← map_comp, this]) }
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
cocone
|
Given a functor `G` from `Profiniteᵒᵖ` and `S : Profinite`, we obtain a cocone on
`(CostructuredArrow.proj toProfinite.op ⟨S⟩ ⋙ toProfinite.op ⋙ G)` with cocone point `G.obj ⟨S⟩`.
Whiskering this cocone with `Profinite.Extend.functorOp c` gives `G.mapCocone c.op` as we check in
the example below.
|
noncomputable
isColimitCocone (hc : IsLimit c) [∀ i, Epi (c.π.app i)] (hc' : IsColimit <| G.mapCocone c.op) :
IsColimit (cocone G c.pt) := (functorOp_final c hc).isColimitWhiskerEquiv _ _ hc'
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
isColimitCocone
|
If `c` is a limit cone, `G.mapCocone c.op` is a colimit cone and the projection maps in `c`
are epimorphic, then `cocone G c.pt` is a colimit cone.
|
fintypeDiagram' : StructuredArrow S toProfinite ⥤ FintypeCat :=
StructuredArrow.proj S toProfinite
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
fintypeDiagram'
|
A functor `StructuredArrow S toProfinite ⥤ FintypeCat` whose limit in `Profinite` is isomorphic
to `S`.
|
diagram' : StructuredArrow S toProfinite ⥤ Profinite :=
S.fintypeDiagram' ⋙ toProfinite
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
diagram'
|
An abbreviation for `S.fintypeDiagram' ⋙ toProfinite`.
|
asLimitCone' : Cone (S.diagram') := cone (𝟭 _) S
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
asLimitCone'
|
A cone over `S.diagram'` whose cone point is `S`.
|
noncomputable asLimit' : IsLimit S.asLimitCone' := isLimitCone _ (𝟭 _) S.asLimit S.asLimit
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
asLimit'
|
`S.asLimitCone'` is a limit cone.
|
noncomputable lim' : LimitCone S.diagram' := ⟨S.asLimitCone', S.asLimit'⟩
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.AsLimit",
"Mathlib.Topology.Category.Profinite.CofilteredLimit",
"Mathlib.CategoryTheory.Filtered.Final"
] |
Mathlib/Topology/Category/Profinite/Extend.lean
|
lim'
|
A bundled version of `S.asLimitCone'` and `S.asLimit'`.
|
isTerminalPUnit : IsTerminal (Profinite.of PUnit.{u + 1}) := CompHausLike.isTerminalPUnit
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic",
"Mathlib.Topology.Category.CompHausLike.Limits"
] |
Mathlib/Topology/Category/Profinite/Limits.lean
|
isTerminalPUnit
|
A one-element space is terminal in `Profinite`
|
obj : Set ((i : {i : ι // J i}) → X i) := ContinuousMap.precomp (Subtype.val (p := J)) '' C
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
obj
|
The object part of the functor `indexFunctor : (Finset ι)ᵒᵖ ⥤ Profinite`.
|
π_app : C(C, obj C J) :=
⟨Set.MapsTo.restrict (precomp (Subtype.val (p := J))) _ _ (Set.mapsTo_image _ _),
Continuous.restrict _ (Pi.continuous_precomp' _)⟩
variable {J K}
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
π_app
|
The projection maps in the limit cone `indexCone`.
|
map (h : ∀ i, J i → K i) : C(obj C K, obj C J) :=
⟨Set.MapsTo.restrict (precomp (Set.inclusion h)) _ _ (fun _ hx ↦ by
obtain ⟨y, hy⟩ := hx
rw [← hy.2]
exact ⟨y, hy.1, rfl⟩), Continuous.restrict _ (Pi.continuous_precomp' _)⟩
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
map
|
The morphism part of the functor `indexFunctor : (Finset ι)ᵒᵖ ⥤ Profinite`.
|
surjective_π_app :
Function.Surjective (π_app C J) := by
intro x
obtain ⟨y, hy⟩ := x.prop
exact ⟨⟨y, hy.1⟩, Subtype.ext hy.2⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
surjective_π_app
| null |
map_comp_π_app (h : ∀ i, J i → K i) : map C h ∘ π_app C K = π_app C J := rfl
variable {C}
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
map_comp_π_app
| null |
eq_of_forall_π_app_eq (a b : C)
(h : ∀ (J : Finset ι), π_app C (· ∈ J) a = π_app C (· ∈ J) b) : a = b := by
ext i
specialize h ({i} : Finset ι)
rw [Subtype.ext_iff] at h
simp only [π_app, ContinuousMap.precomp, ContinuousMap.coe_mk,
Set.MapsTo.val_restrict_apply] at h
exact congr_fun h ⟨i, Finset.mem_singleton.mpr rfl⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
eq_of_forall_π_app_eq
| null |
noncomputable
indexFunctor (hC : IsCompact C) : (Finset ι)ᵒᵖ ⥤ Profinite.{u} where
obj J := @Profinite.of (obj C (· ∈ (unop J))) _
(by rw [← isCompact_iff_compactSpace]; exact hC.image (Pi.continuous_precomp' _)) _ _
map h := TopCat.ofHom (map C (leOfHom h.unop))
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
indexFunctor
|
The functor from the poset of finsets of `ι` to `Profinite`, indexing the limit.
|
noncomputable
indexCone (hC : IsCompact C) : Cone (indexFunctor hC) where
pt := @Profinite.of C _ (by rwa [← isCompact_iff_compactSpace]) _ _
π := { app := fun J ↦ TopCat.ofHom (π_app C (· ∈ unop J)) }
variable (hC : IsCompact C)
|
def
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
indexCone
|
The limit cone on `indexFunctor`
|
isIso_indexCone_lift :
IsIso ((limitConeIsLimit.{u, u} (indexFunctor hC)).lift (indexCone hC)) :=
haveI : CompactSpace C := by rwa [← isCompact_iff_compactSpace]
CompHausLike.isIso_of_bijective _
(by
refine ⟨fun a b h ↦ ?_, fun a ↦ ?_⟩
· refine eq_of_forall_π_app_eq a b (fun J ↦ ?_)
apply_fun fun f : (limitCone.{u, u} (indexFunctor hC)).pt => f.val (op J) at h
exact h
· rsuffices ⟨b, hb⟩ : ∃ (x : C), ∀ (J : Finset ι), π_app C (· ∈ J) x = a.val (op J)
· use b
apply Subtype.ext
apply funext
intro J
exact hb (unop J)
have hc : ∀ (J : Finset ι) s, IsClosed ((π_app C (· ∈ J)) ⁻¹' {s}) := by
intro J s
refine IsClosed.preimage (π_app C (· ∈ J)).continuous ?_
exact T1Space.t1 s
have H₁ : ∀ (Q₁ Q₂ : Finset ι), Q₁ ≤ Q₂ →
π_app C (· ∈ Q₁) ⁻¹' {a.val (op Q₁)} ⊇
π_app C (· ∈ Q₂) ⁻¹' {a.val (op Q₂)} := by
intro J K h x hx
simp only [Set.mem_preimage, Set.mem_singleton_iff] at hx ⊢
rw [← map_comp_π_app C h, Function.comp_apply,
hx, ← a.prop (homOfLE h).op]
rfl
obtain ⟨x, hx⟩ :
Set.Nonempty (⋂ (J : Finset ι), π_app C (· ∈ J) ⁻¹' {a.val (op J)}) :=
IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
(fun J : Finset ι => π_app C (· ∈ J) ⁻¹' {a.val (op J)}) (directed_of_isDirected_le H₁)
(fun J => (Set.singleton_nonempty _).preimage (surjective_π_app _))
(fun J => (hc J (a.val (op J))).isCompact) fun J => hc J (a.val (op J))
exact ⟨x, Set.mem_iInter.1 hx⟩)
|
instance
|
Topology
|
[
"Mathlib.Topology.Category.Profinite.Basic"
] |
Mathlib/Topology/Category/Profinite/Product.lean
|
isIso_indexCone_lift
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.