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 ⌀ |
|---|---|---|---|---|---|---|
isTerminalPUnit : IsTerminal (CompHaus.of PUnit.{u + 1}) := CompHausLike.isTerminalPUnit | abbrev | Topology | [
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHaus/Limits.lean | isTerminalPUnit | A one-element space is terminal in `CompHaus` |
noncomputable terminalIsoPUnit : ⊤_ CompHaus.{u} ≅ CompHaus.of PUnit :=
terminalIsTerminal.uniqueUpToIso CompHaus.isTerminalPUnit | def | Topology | [
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHaus/Limits.lean | terminalIsoPUnit | The isomorphism from an arbitrary terminal object of `CompHaus` to a one-element space. |
projective_ultrafilter (X : Type*) : Projective (of <| Ultrafilter X) where
factors {Y Z} f g hg := by
rw [epi_iff_surjective] at hg
obtain ⟨g', hg'⟩ := hg.hasRightInverse
let t : X → Y := g' ∘ f ∘ (pure : X → Ultrafilter X)
let h : Ultrafilter X → Y := Ultrafilter.extend t
have hh : Continuous h := continuous_ultrafilter_extend _
use CompHausLike.ofHom _ ⟨h, hh⟩
apply ConcreteCategory.coe_ext
have : g.hom ∘ g' = id := hg'.comp_eq_id
convert denseRange_pure.equalizer (g.hom.continuous.comp hh) f.hom.continuous _
rw [comp_assoc, ultrafilter_extend_extends, ← comp_assoc, this, id_comp]
rfl | instance | Topology | [
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Compactification.StoneCech",
"Mathlib.CategoryTheory.Preadditive.Projective.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono"
] | Mathlib/Topology/Category/CompHaus/Projective.lean | projective_ultrafilter | null |
projectivePresentation (X : CompHaus) : ProjectivePresentation X where
p := of <| Ultrafilter X
f := CompHausLike.ofHom _ ⟨_, continuous_ultrafilter_extend id⟩
projective := CompHaus.projective_ultrafilter X
epi :=
ConcreteCategory.epi_of_surjective _ fun x =>
⟨(pure x : Ultrafilter X), congr_fun (ultrafilter_extend_extends (𝟙 X)) x⟩ | def | Topology | [
"Mathlib.Topology.Category.CompHaus.Basic",
"Mathlib.Topology.Compactification.StoneCech",
"Mathlib.CategoryTheory.Preadditive.Projective.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.EpiMono"
] | Mathlib/Topology/Category/CompHaus/Projective.lean | projectivePresentation | For any compact Hausdorff space `X`,
the natural map `Ultrafilter X → X` is a projective presentation. |
CompHaus where
toTop : TopCat
[is_compact : CompactSpace toTop]
[is_hausdorff : T2Space toTop]
```
and give it the category structure induced from topological spaces. Then the category of profinite
spaces was defined as follows:
```lean | structure | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | CompHaus | null |
Profinite where
toCompHaus : CompHaus
[isTotallyDisconnected : TotallyDisconnectedSpace toCompHaus]
```
The categories `Stonean` consisting of extremally disconnected compact Hausdorff spaces and
`LightProfinite` consisting of totally disconnected, second countable compact Hausdorff spaces were
defined in a similar way. This resulted in code duplication, and reducing this duplication was part
of the motivation for introducing `CompHausLike`.
Using `CompHausLike`, we can now define
`CompHaus := CompHausLike (fun _ ↦ True)`
`Profinite := CompHausLike (fun X ↦ TotallyDisconnectedSpace X)`.
`Stonean := CompHausLike (fun X ↦ ExtremallyDisconnected X)`.
`LightProfinite := CompHausLike (fun X ↦ TotallyDisconnectedSpace X ∧ SecondCountableTopology X)`.
These four categories are important building blocks of condensed objects (see the files
`Condensed.Basic` and `Condensed.Light.Basic`). These categories share many properties and often,
one wants to argue about several of them simultaneously. This is the other part of the motivation
for introducing `CompHausLike`. On paper, one would say "let `C` be on of the categories `CompHaus`
or `Profinite`, then the following holds: ...". This was not possible in Lean using the old
definitions. Using the new definitions, this becomes a matter of identifying what common property
of `CompHaus` and `Profinite` is used in the proof in question, and then proving the theorem for
`CompHausLike P` satisfying that property, and it will automatically apply to both `CompHaus` and
`Profinite`.
-/
universe u
open CategoryTheory
variable (P : TopCat.{u} → Prop) | structure | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | Profinite | null |
CompHausLike where
/-- The underlying topological space of an object of `CompHausLike P`. -/
toTop : TopCat
/-- The underlying topological space is compact. -/
[is_compact : CompactSpace toTop]
/-- The underlying topological space is T2. -/
[is_hausdorff : T2Space toTop]
/-- The underlying topological space satisfies P. -/
prop : P toTop | structure | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | CompHausLike | The type of Compact Hausdorff topological spaces satisfying an additional property `P`. |
category : Category (CompHausLike P) :=
InducedCategory.category toTop | instance | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | category | null |
concreteCategory : ConcreteCategory (CompHausLike P) (C(·, ·)) :=
InducedCategory.concreteCategory toTop | instance | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | concreteCategory | null |
hasForget₂ : HasForget₂ (CompHausLike P) TopCat :=
InducedCategory.hasForget₂ _
variable (X : Type u) [TopologicalSpace X] [CompactSpace X] [T2Space X] | instance | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | hasForget₂ | null |
HasProp : Prop where
hasProp : P (TopCat.of X) | class | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | HasProp | This wraps the predicate `P : TopCat → Prop` in a typeclass. |
of : CompHausLike P where
toTop := TopCat.of X
is_compact := ‹_›
is_hausdorff := ‹_›
prop := HasProp.hasProp | abbrev | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | of | A constructor for objects of the category `CompHausLike P`,
taking a type, and bundling the compact Hausdorff topology
found by typeclass inference. |
coe_of : (CompHausLike.of P X : Type _) = X := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | coe_of | null |
coe_id (X : CompHausLike P) : (𝟙 X : X → X) = id :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | coe_id | null |
coe_comp {X Y Z : CompHausLike P} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g : X → Z) = g ∘ f :=
rfl | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | coe_comp | null |
ofHom (f : C(X, Y)) : of P X ⟶ of P Y := ConcreteCategory.ofHom f
@[simp] lemma hom_ofHom (f : C(X, Y)) : ConcreteCategory.hom (ofHom P f) = f := rfl
@[simp] lemma ofHom_id : ofHom P (ContinuousMap.id X) = 𝟙 (of _ X) := rfl
@[simp] lemma ofHom_comp (f : C(X, Y)) (g : C(Y, Z)) :
ofHom P (g.comp f) = ofHom _ f ≫ ofHom _ g := rfl | abbrev | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | ofHom | Typecheck a continuous map as a morphism in the category `CompHausLike P`. |
@[simps map]
toCompHausLike {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
CompHausLike P ⥤ CompHausLike P' where
obj X :=
have : HasProp P' X := ⟨(h _ X.prop)⟩
CompHausLike.of _ X
map f := f | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | toCompHausLike | If `P` implies `P'`, then there is a functor from `CompHausLike P` to `CompHausLike P'`. |
fullyFaithfulToCompHausLike : (toCompHausLike h).FullyFaithful :=
fullyFaithfulInducedFunctor _ | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | fullyFaithfulToCompHausLike | If `P` implies `P'`, then the functor from `CompHausLike P` to `CompHausLike P'` is fully
faithful. |
@[simps! map]
compHausLikeToTop : CompHausLike.{u} P ⥤ TopCat.{u} :=
inducedFunctor _ | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | compHausLikeToTop | The fully faithful embedding of `CompHausLike P` in `TopCat`. |
fullyFaithfulCompHausLikeToTop : (compHausLikeToTop P).FullyFaithful :=
fullyFaithfulInducedFunctor _ | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | fullyFaithfulCompHausLikeToTop | The functor from `CompHausLike P` to `TopCat` is fully faithful. |
epi_of_surjective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) (hf : Function.Surjective f) :
Epi f := by
rw [← CategoryTheory.epi_iff_surjective] at hf
exact (forget (CompHausLike P)).epi_of_epi_map hf | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | epi_of_surjective | null |
mono_iff_injective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) :
Mono f ↔ Function.Injective f := by
constructor
· intro hf x₁ x₂ h
let g₁ : X ⟶ X := ofHom _ ⟨fun _ => x₁, continuous_const⟩
let g₂ : X ⟶ X := ofHom _ ⟨fun _ => x₂, continuous_const⟩
have : g₁ ≫ f = g₂ ≫ f := by ext; exact h
exact CategoryTheory.congr_fun ((cancel_mono _).mp this) x₁
· rw [← CategoryTheory.mono_iff_injective]
apply (forget (CompHausLike P)).mono_of_mono_map | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | mono_iff_injective | null |
isClosedMap {X Y : CompHausLike.{u} P} (f : X ⟶ Y) : IsClosedMap f := fun _ hC =>
(hC.isCompact.image f.hom.continuous).isClosed | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | isClosedMap | Any continuous function on compact Hausdorff spaces is a closed map. |
isIso_of_bijective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) (bij : Function.Bijective f) :
IsIso f := by
let E := Equiv.ofBijective _ bij
have hE : Continuous E.symm := by
rw [continuous_iff_isClosed]
intro S hS
rw [← E.image_eq_preimage]
exact isClosedMap f S hS
refine ⟨⟨ofHom _ ⟨E.symm, hE⟩, ?_, ?_⟩⟩
· ext x
apply E.symm_apply_apply
· ext x
apply E.apply_symm_apply | theorem | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | isIso_of_bijective | Any continuous bijection of compact Hausdorff spaces is an isomorphism. |
forget_reflectsIsomorphisms :
(forget (CompHausLike.{u} P)).ReflectsIsomorphisms :=
⟨by intro A B f hf; rw [isIso_iff_bijective] at hf; exact isIso_of_bijective _ hf⟩ | instance | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | forget_reflectsIsomorphisms | null |
noncomputable isoOfBijective {X Y : CompHausLike.{u} P} (f : X ⟶ Y)
(bij : Function.Bijective f) : X ≅ Y :=
letI := isIso_of_bijective _ bij
asIso f | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | isoOfBijective | Any continuous bijection of compact Hausdorff spaces induces an isomorphism. |
@[simps!]
isoOfHomeo {X Y : CompHausLike.{u} P} (f : X ≃ₜ Y) : X ≅ Y :=
(fullyFaithfulCompHausLikeToTop P).preimageIso (TopCat.isoOfHomeo f) | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | isoOfHomeo | Construct an isomorphism from a homeomorphism. |
@[simps!]
homeoOfIso {X Y : CompHausLike.{u} P} (f : X ≅ Y) : X ≃ₜ Y :=
TopCat.homeoOfIso <| (compHausLikeToTop P).mapIso f | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | homeoOfIso | Construct a homeomorphism from an isomorphism. |
@[simps]
isoEquivHomeo {X Y : CompHausLike.{u} P} : (X ≅ Y) ≃ (X ≃ₜ Y) where
toFun := homeoOfIso
invFun := isoOfHomeo | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | isoEquivHomeo | The equivalence between isomorphisms in `CompHaus` and homeomorphisms
of topological spaces. |
const {P : TopCat.{u} → Prop}
(T : CompHausLike.{u} P) {S : CompHausLike.{u} P} (s : S) : T ⟶ S :=
ofHom _ (ContinuousMap.const _ s) | def | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | const | A constant map as a morphism in `CompHausLike` |
const_comp {P : TopCat.{u} → Prop} {S T U : CompHausLike.{u} P}
(s : S) (g : S ⟶ U) : T.const s ≫ g = T.const (g s) :=
rfl | lemma | Topology | [
"Mathlib.Topology.Category.TopCat.Basic",
"Mathlib.CategoryTheory.Functor.EpiMono",
"Mathlib.CategoryTheory.Functor.ReflectsIso.Basic"
] | Mathlib/Topology/Category/CompHausLike/Basic.lean | const_comp | null |
noncomputable
effectiveEpiStruct {B X : CompHausLike P} (π : X ⟶ B) (hπ : Function.Surjective π) :
EffectiveEpiStruct π where
desc e h := ofHom _ ((IsQuotientMap.of_surjective_continuous hπ π.hom.continuous).lift e.hom
fun a b hab ↦
CategoryTheory.congr_fun (h
(ofHom _ ⟨fun _ ↦ a, continuous_const⟩)
(ofHom _ ⟨fun _ ↦ b, continuous_const⟩)
(by ext; exact hab)) a)
fac e h := TopCat.hom_ext ((IsQuotientMap.of_surjective_continuous hπ π.hom.continuous).lift_comp
e.hom
fun a b hab ↦ CategoryTheory.congr_fun (h
(ofHom _ ⟨fun _ ↦ a, continuous_const⟩)
(ofHom _ ⟨fun _ ↦ b, continuous_const⟩)
(by ext; exact hab)) a)
uniq e h g hm := by
suffices g = ofHom _ ((IsQuotientMap.of_surjective_continuous hπ π.hom.continuous).liftEquiv
⟨e.hom,
fun a b hab ↦ CategoryTheory.congr_fun
(h
(ofHom _ ⟨fun _ ↦ a, continuous_const⟩)
(ofHom _ ⟨fun _ ↦ b, continuous_const⟩)
(by ext; exact hab))
a⟩) by assumption
apply ConcreteCategory.ext
rw [hom_ofHom,
← Equiv.symm_apply_eq (IsQuotientMap.of_surjective_continuous hπ π.hom.continuous).liftEquiv]
ext
simp only [IsQuotientMap.liftEquiv_symm_apply_coe, ContinuousMap.comp_apply, ← hm]
rfl | def | Topology | [
"Mathlib.CategoryTheory.Sites.Coherent.Comparison",
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHausLike/EffectiveEpi.lean | effectiveEpiStruct | If `π` is a surjective morphism in `CompHausLike P`, then it is an effective epi. |
preregular [HasExplicitPullbacks P]
(hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective f) :
Preregular (CompHausLike P) where
exists_fac := by
intro X Y Z f π hπ
refine ⟨pullback f π, pullback.fst f π, ⟨⟨effectiveEpiStruct _ ?_⟩⟩, pullback.snd f π,
(pullback.condition _ _).symm⟩
intro y
obtain ⟨z, hz⟩ := hs π hπ (f y)
exact ⟨⟨(y, z), hz.symm⟩, rfl⟩ | theorem | Topology | [
"Mathlib.CategoryTheory.Sites.Coherent.Comparison",
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHausLike/EffectiveEpi.lean | preregular | null |
precoherent [HasExplicitPullbacks P] [HasExplicitFiniteCoproducts.{0} P]
(hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective f) :
Precoherent (CompHausLike P) := by
have : Preregular (CompHausLike P) := preregular hs
infer_instance | theorem | Topology | [
"Mathlib.CategoryTheory.Sites.Coherent.Comparison",
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHausLike/EffectiveEpi.lean | precoherent | null |
HasExplicitFiniteCoproduct := HasProp P (Σ (a : α), X a)
variable [HasExplicitFiniteCoproduct X] | abbrev | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | HasExplicitFiniteCoproduct | A typeclass describing the property that forming the disjoint union is stable under the
property `P`. |
finiteCoproduct : CompHausLike P := CompHausLike.of P (Σ (a : α), X a) | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct | The coproduct of a finite family of objects in `CompHaus`, constructed as the disjoint
union with its usual topology. |
finiteCoproduct.ι (a : α) : X a ⟶ finiteCoproduct X :=
ofHom _
{ toFun := fun x ↦ ⟨a, x⟩
continuous_toFun := continuous_sigmaMk (σ := fun a ↦ X a) } | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.ι | The inclusion of one of the factors into the explicit finite coproduct. |
finiteCoproduct.desc {B : CompHausLike P} (e : (a : α) → (X a ⟶ B)) :
finiteCoproduct X ⟶ B :=
ofHom _
{ toFun := fun ⟨a, x⟩ ↦ e a x
continuous_toFun := by
apply continuous_sigma
intro a; exact (e a).hom.continuous }
@[reassoc (attr := simp)] | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.desc | To construct a morphism from the explicit finite coproduct, it suffices to
specify a morphism from each of its factors.
This is essentially the universal property of the coproduct. |
finiteCoproduct.ι_desc {B : CompHausLike P} (e : (a : α) → (X a ⟶ B)) (a : α) :
finiteCoproduct.ι X a ≫ finiteCoproduct.desc X e = e a := rfl | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.ι_desc | null |
finiteCoproduct.hom_ext {B : CompHausLike P} (f g : finiteCoproduct X ⟶ B)
(h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g := by
ext ⟨a, x⟩
specialize h a
apply_fun (fun q ↦ q x) at h
exact h | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.hom_ext | null |
finiteCoproduct.cofan : Limits.Cofan X :=
Cofan.mk (finiteCoproduct X) (finiteCoproduct.ι X) | abbrev | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.cofan | The coproduct cocone associated to the explicit finite coproduct. |
finiteCoproduct.isColimit : Limits.IsColimit (finiteCoproduct.cofan X) :=
mkCofanColimit _
(fun s ↦ desc _ fun a ↦ s.inj a)
(fun _ _ ↦ ι_desc _ _ _)
fun _ _ hm ↦ finiteCoproduct.hom_ext _ _ _ fun a ↦
(ConcreteCategory.hom_ext _ _ fun t ↦ congrFun (congrArg _ (hm a)) t) | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.isColimit | The explicit finite coproduct cocone is a colimit cocone. |
finiteCoproduct.ι_injective (a : α) : Function.Injective (finiteCoproduct.ι X a) := by
intro x y hxy
exact eq_of_heq (Sigma.ext_iff.mp hxy).2 | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.ι_injective | null |
finiteCoproduct.ι_jointly_surjective (R : finiteCoproduct X) :
∃ (a : α) (r : X a), R = finiteCoproduct.ι X a r := ⟨R.fst, R.snd, rfl⟩ | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.ι_jointly_surjective | null |
finiteCoproduct.ι_desc_apply {B : CompHausLike P} {π : (a : α) → X a ⟶ B} (a : α) :
∀ x, finiteCoproduct.desc X π (finiteCoproduct.ι X a x) = π a x := by
intro x
change (ι X a ≫ desc X π) _ = _
simp only [ι_desc] | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.ι_desc_apply | null |
HasExplicitFiniteCoproducts : Prop where
hasProp {α : Type w} [Finite α] (X : α → CompHausLike.{max u w} P) : HasExplicitFiniteCoproduct X
/-
This linter complains that the universes `u` and `w` only occur together, but `w` appears by itself
in the indexing type of the coproduct. In almost all cases, `w` will be either `0` or `u`, but we
want to allow both possibilities.
-/
attribute [nolint checkUnivs] HasExplicitFiniteCoproducts
attribute [instance] HasExplicitFiniteCoproducts.hasProp | class | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | HasExplicitFiniteCoproducts | A typeclass describing the property that forming all finite disjoint unions is stable under the
property `P`. |
finiteCoproduct.isOpenEmbedding_ι (a : α) :
IsOpenEmbedding (finiteCoproduct.ι X a) :=
.sigmaMk (σ := fun a ↦ X a) | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | finiteCoproduct.isOpenEmbedding_ι | The inclusion maps into the explicit finite coproduct are open embeddings. |
Sigma.isOpenEmbedding_ι (a : α) :
IsOpenEmbedding (Sigma.ι X a) := by
refine IsOpenEmbedding.of_comp _ (homeoOfIso ((colimit.isColimit _).coconePointUniqueUpToIso
(finiteCoproduct.isColimit X))).isOpenEmbedding ?_
convert finiteCoproduct.isOpenEmbedding_ι X a
ext x
change (Sigma.ι X a ≫ _) x = _
simp | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | Sigma.isOpenEmbedding_ι | The inclusion maps into the abstract finite coproduct are open embeddings. |
HasExplicitPullback := HasProp P { xy : X × Y | f xy.fst = g xy.snd }
variable [HasExplicitPullback f g] -- (hP : P (TopCat.of { xy : X × Y | f xy.fst = g xy.snd })) | abbrev | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | HasExplicitPullback | The functor to `TopCat` preserves finite coproducts if they exist. -/
instance (P) [HasExplicitFiniteCoproducts.{0} P] :
PreservesFiniteCoproducts (compHausLikeToTop P) := by
refine ⟨fun _ ↦ ⟨fun {F} ↦ ?_⟩⟩
suffices PreservesColimit (Discrete.functor (F.obj ∘ Discrete.mk)) (compHausLikeToTop P) from
preservesColimit_of_iso_diagram _ Discrete.natIsoFunctor.symm
apply preservesColimit_of_preserves_colimit_cocone (CompHausLike.finiteCoproduct.isColimit _)
exact TopCat.sigmaCofanIsColimit _
/-- The functor to another `CompHausLike` preserves finite coproducts if they exist. -/
noncomputable instance {P' : TopCat.{u} → Prop}
(h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
PreservesFiniteCoproducts (toCompHausLike h) := by
have : PreservesFiniteCoproducts (toCompHausLike h ⋙ compHausLikeToTop P') :=
inferInstanceAs (PreservesFiniteCoproducts (compHausLikeToTop _))
exact preservesFiniteCoproducts_of_reflects_of_preserves (toCompHausLike h) (compHausLikeToTop P')
end FiniteCoproducts
section Pullbacks
variable {P : TopCat.{u} → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B)
/--
A typeclass describing the property that an explicit pullback is stable under the property `P`. |
pullback : CompHausLike P :=
letI set := { xy : X × Y | f xy.fst = g xy.snd }
haveI : CompactSpace set :=
isCompact_iff_compactSpace.mp (isClosed_eq (f.hom.continuous.comp continuous_fst)
(g.hom.continuous.comp continuous_snd)).isCompact
CompHausLike.of P set | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback | The pullback of two morphisms `f,g` in `CompHaus`, constructed explicitly as the set of
pairs `(x,y)` such that `f x = g y`, with the topology induced by the product. |
pullback.fst : pullback f g ⟶ X :=
TopCat.ofHom
{ toFun := fun ⟨⟨x, _⟩, _⟩ ↦ x
continuous_toFun := Continuous.comp continuous_fst continuous_subtype_val } | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.fst | The projection from the pullback to the first component. |
pullback.snd : pullback f g ⟶ Y :=
TopCat.ofHom
{ toFun := fun ⟨⟨_,y⟩,_⟩ ↦ y
continuous_toFun := Continuous.comp continuous_snd continuous_subtype_val }
@[reassoc] | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.snd | The projection from the pullback to the second component. |
pullback.condition : pullback.fst f g ≫ f = pullback.snd f g ≫ g := by
ext ⟨_,h⟩; exact h | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.condition | null |
pullback.lift {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
Z ⟶ pullback f g :=
TopCat.ofHom
{ toFun := fun z ↦ ⟨⟨a z, b z⟩, by apply_fun (fun q ↦ q z) at w; exact w⟩
continuous_toFun := by fun_prop }
@[reassoc (attr := simp)] | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.lift | Construct a morphism to the explicit pullback given morphisms to the factors
which are compatible with the maps to the base.
This is essentially the universal property of the pullback. |
pullback.lift_fst {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
pullback.lift f g a b w ≫ pullback.fst f g = a := rfl
@[reassoc (attr := simp)] | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.lift_fst | null |
pullback.lift_snd {Z : CompHausLike P} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
pullback.lift f g a b w ≫ pullback.snd f g = b := rfl | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.lift_snd | null |
pullback.hom_ext {Z : CompHausLike P} (a b : Z ⟶ pullback f g)
(hfst : a ≫ pullback.fst f g = b ≫ pullback.fst f g)
(hsnd : a ≫ pullback.snd f g = b ≫ pullback.snd f g) : a = b := by
ext z
apply_fun (fun q ↦ q z) at hfst hsnd
apply Subtype.ext
apply Prod.ext
· exact hfst
· exact hsnd | lemma | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.hom_ext | null |
@[simps! pt π]
pullback.cone : Limits.PullbackCone f g :=
Limits.PullbackCone.mk (pullback.fst f g) (pullback.snd f g) (pullback.condition f g) | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.cone | The pullback cone whose cone point is the explicit pullback. |
@[simps! lift]
pullback.isLimit : Limits.IsLimit (pullback.cone f g) :=
Limits.PullbackCone.isLimitAux _
(fun s ↦ pullback.lift f g s.fst s.snd s.condition)
(fun _ ↦ pullback.lift_fst _ _ _ _ _)
(fun _ ↦ pullback.lift_snd _ _ _ _ _)
(fun _ _ hm ↦ pullback.hom_ext _ _ _ _ (hm .left) (hm .right)) | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | pullback.isLimit | The explicit pullback cone is a limit cone. |
HasExplicitPullbacks : Prop where
hasProp {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) : HasExplicitPullback f g
attribute [instance] HasExplicitPullbacks.hasProp | class | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | HasExplicitPullbacks | The functor to `TopCat` creates pullbacks if they exist. -/
noncomputable instance : CreatesLimit (cospan f g) (compHausLikeToTop P) := by
refine createsLimitOfFullyFaithfulOfIso (pullback f g)
(((TopCat.pullbackConeIsLimit f g).conePointUniqueUpToIso
(limit.isLimit _)) ≪≫ Limits.lim.mapIso (?_ ≪≫ (diagramIsoCospan _).symm))
exact Iso.refl _
/-- The functor to `TopCat` preserves pullbacks. -/
noncomputable instance : PreservesLimit (cospan f g) (compHausLikeToTop P) :=
preservesLimit_of_createsLimit_and_hasLimit _ _
/-- The functor to another `CompHausLike` preserves pullbacks. -/
noncomputable instance {P' : TopCat → Prop}
(h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
PreservesLimit (cospan f g) (toCompHausLike h) := by
have : PreservesLimit (cospan f g) (toCompHausLike h ⋙ compHausLikeToTop P') :=
inferInstanceAs (PreservesLimit _ (compHausLikeToTop _))
exact preservesLimit_of_reflects_of_preserves (toCompHausLike h) (compHausLikeToTop P')
variable (P) in
/--
A typeclass describing the property that forming all explicit pullbacks is stable under the
property `P`. |
HasExplicitPullbacksOfInclusions [HasExplicitFiniteCoproducts.{0} P] : Prop where
hasProp : ∀ {X Y Z : CompHausLike P} (f : Z ⟶ X ⨿ Y), HasExplicitPullback coprod.inl f
attribute [instance] HasExplicitPullbacksOfInclusions.hasProp | class | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | HasExplicitPullbacksOfInclusions | A typeclass describing the property that explicit pullbacks along inclusion maps into disjoint
unions is stable under the property `P`. |
hasPullbacksOfInclusions
(hP' : ∀ ⦃X Y B : CompHausLike.{u} P⦄ (f : X ⟶ B) (g : Y ⟶ B)
(_ : IsOpenEmbedding f), HasExplicitPullback f g) :
HasExplicitPullbacksOfInclusions P :=
{ hasProp := by
intro _ _ _ f
apply hP'
exact Sigma.isOpenEmbedding_ι _ _ } | theorem | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | hasPullbacksOfInclusions | null |
isTerminalPUnit [HasProp P PUnit.{u + 1}] :
IsTerminal (CompHausLike.of P PUnit.{u + 1}) :=
haveI : ∀ X, Unique (X ⟶ CompHausLike.of P PUnit.{u + 1}) := fun _ ↦
⟨⟨ofHom _ ⟨fun _ ↦ PUnit.unit, continuous_const⟩⟩, fun _ ↦ rfl⟩
Limits.IsTerminal.ofUnique _ | def | Topology | [
"Mathlib.CategoryTheory.Extensive",
"Mathlib.CategoryTheory.Limits.Preserves.Finite",
"Mathlib.Topology.Category.CompHausLike.Basic"
] | Mathlib/Topology/Category/CompHausLike/Limits.lean | isTerminalPUnit | The functor to `TopCat` preserves pullbacks of inclusions if they exist. -/
noncomputable instance [HasExplicitPullbacksOfInclusions P] :
PreservesPullbacksOfInclusions (compHausLikeToTop P) :=
{ preservesPullbackInl := by
intro X Y Z f
infer_instance }
instance [HasExplicitPullbacksOfInclusions P] : FinitaryExtensive (CompHausLike P) :=
finitaryExtensive_of_preserves_and_reflects (compHausLikeToTop P)
theorem finitaryExtensive (hP' : ∀ ⦃X Y B : CompHausLike.{u} P⦄ (f : X ⟶ B) (g : Y ⟶ B)
(_ : IsOpenEmbedding f), HasExplicitPullback f g) :
FinitaryExtensive (CompHausLike P) :=
have := hasPullbacksOfInclusions hP'
finitaryExtensive_of_preserves_and_reflects (compHausLikeToTop P)
end FiniteCoproducts
section Terminal
variable {P : TopCat.{u} → Prop}
/-- A one-element space is terminal in `CompHaus` |
sigmaComparison : X.obj ⟨(of P ((a : α) × σ a))⟩ ⟶ ((a : α) → X.obj ⟨of P (σ a)⟩) :=
fun x a ↦ X.map (ofHom _ ⟨Sigma.mk a, continuous_sigmaMk⟩).op x | def | Topology | [
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean | sigmaComparison | The comparison map from the value of a condensed set on a finite coproduct to the product of the
values on the components. |
sigmaComparison_eq_comp_isos : sigmaComparison X σ =
(X.mapIso (opCoproductIsoProduct'
(finiteCoproduct.isColimit.{u, u} (fun a ↦ of P (σ a)))
(productIsProduct fun x ↦ Opposite.op (of P (σ x))))).hom ≫
(PreservesProduct.iso X fun a ↦ ⟨of P (σ a)⟩).hom ≫
(Types.productIso.{u, max u w} fun a ↦ X.obj ⟨of P (σ a)⟩).hom := by
ext x a
simp only [Cofan.mk_pt, Fan.mk_pt, Functor.mapIso_hom,
PreservesProduct.iso_hom, types_comp_apply, Types.productIso_hom_comp_eval_apply]
have := congrFun (piComparison_comp_π X (fun a ↦ ⟨of P (σ a)⟩) a)
simp only [types_comp_apply] at this
rw [this, ← FunctorToTypes.map_comp_apply]
simp only [sigmaComparison]
apply congrFun
congr 2
rw [← opCoproductIsoProduct_inv_comp_ι]
simp only [Opposite.unop_op, unop_comp, Quiver.Hom.unop_op, Category.assoc]
simp only [opCoproductIsoProduct, ← unop_comp, opCoproductIsoProduct'_comp_self]
erw [IsColimit.fac]
rfl | theorem | Topology | [
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean | sigmaComparison_eq_comp_isos | null |
isIsoSigmaComparison : IsIso <| sigmaComparison X σ := by
rw [sigmaComparison_eq_comp_isos]
infer_instance | instance | Topology | [
"Mathlib.Topology.Category.CompHausLike.Limits"
] | Mathlib/Topology/Category/CompHausLike/SigmaComparison.lean | isIsoSigmaComparison | null |
fintypeDiagram : ℕᵒᵖ ⥤ FintypeCat := S.toLightDiagram.diagram | abbrev | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | fintypeDiagram | The functor `ℕᵒᵖ ⥤ FintypeCat` whose limit is isomorphic to `S`. |
diagram : ℕᵒᵖ ⥤ LightProfinite := S.fintypeDiagram ⋙ FintypeCat.toLightProfinite | abbrev | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | diagram | An abbreviation for `S.fintypeDiagram ⋙ FintypeCat.toProfinite`. |
asLimitConeAux : Cone S.diagram :=
let c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
let hc : IsLimit c := S.toLightDiagram.isLimit
liftLimit hc | def | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | asLimitConeAux | A cone over `S.diagram` whose cone point is isomorphic to `S`.
(Auxiliary definition, use `S.asLimitCone` instead.) |
isoMapCone : lightToProfinite.mapCone S.asLimitConeAux ≅ S.toLightDiagram.cone :=
let c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
let hc : IsLimit c := S.toLightDiagram.isLimit
liftedLimitMapsToOriginal hc | def | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | isoMapCone | An auxiliary isomorphism of cones used to prove that `S.asLimitConeAux` is a limit cone. |
asLimitAux : IsLimit S.asLimitConeAux :=
let hc : IsLimit (lightToProfinite.mapCone S.asLimitConeAux) :=
S.toLightDiagram.isLimit.ofIsoLimit S.isoMapCone.symm
isLimitOfReflects lightToProfinite hc | def | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | asLimitAux | `S.asLimitConeAux` is indeed a limit cone.
(Auxiliary definition, use `S.asLimit` instead.) |
asLimitCone : Cone S.diagram where
pt := S
π := {
app := fun n ↦ (lightToProfiniteFullyFaithful.preimageIso <|
(Cones.forget _).mapIso S.isoMapCone).inv ≫ S.asLimitConeAux.π.app n
naturality := fun _ _ _ ↦ by simp only [Category.assoc, S.asLimitConeAux.w]; rfl } | def | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | asLimitCone | A cone over `S.diagram` whose cone point is `S`. |
asLimit : IsLimit S.asLimitCone := S.asLimitAux.ofIsoLimit <|
Cones.ext (lightToProfiniteFullyFaithful.preimageIso <|
(Cones.forget _).mapIso S.isoMapCone) (fun _ ↦ by rw [← @Iso.inv_comp_eq]; rfl) | def | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | asLimit | `S.asLimitCone` is indeed a limit cone. |
lim : Limits.LimitCone S.diagram := ⟨S.asLimitCone, S.asLimit⟩ | def | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | lim | A bundled version of `S.asLimitCone` and `S.asLimit`. |
proj (n : ℕ) : S ⟶ S.diagram.obj ⟨n⟩ := S.asLimitCone.π.app ⟨n⟩ | abbrev | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | proj | The projection from `S` to the `n`th component of `S.diagram`. |
lightToProfinite_map_proj_eq (n : ℕ) : lightToProfinite.map (S.proj n) =
(lightToProfinite.obj S).asLimitCone.π.app _ := by
simp only [Functor.comp_obj, toCompHausLike_map]
let c : Cone (S.diagram ⋙ lightToProfinite) := S.toLightDiagram.cone
let hc : IsLimit c := S.toLightDiagram.isLimit
exact liftedLimitMapsToOriginal_inv_map_π hc _ | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | lightToProfinite_map_proj_eq | null |
proj_surjective (n : ℕ) : Function.Surjective (S.proj n) := by
change Function.Surjective (lightToProfinite.map (S.proj n))
rw [lightToProfinite_map_proj_eq]
exact DiscreteQuotient.proj_surjective _ | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | proj_surjective | null |
component (n : ℕ) : LightProfinite := S.diagram.obj ⟨n⟩ | abbrev | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | component | An abbreviation for the `n`th component of `S.diagram`. |
transitionMap (n : ℕ) : S.component (n + 1) ⟶ S.component n :=
S.diagram.map ⟨homOfLE (Nat.le_succ _)⟩ | abbrev | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | transitionMap | The transition map from `S_{n+1}` to `S_n` in `S.diagram`. |
transitionMapLE {n m : ℕ} (h : n ≤ m) : S.component m ⟶ S.component n :=
S.diagram.map ⟨homOfLE h⟩ | abbrev | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | transitionMapLE | The transition map from `S_m` to `S_n` in `S.diagram`, when `m ≤ n`. |
proj_comp_transitionMap (n : ℕ) :
S.proj (n + 1) ≫ S.diagram.map ⟨homOfLE (Nat.le_succ _)⟩ = S.proj n :=
S.asLimitCone.w (homOfLE (Nat.le_succ n)).op | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | proj_comp_transitionMap | null |
proj_comp_transitionMap' (n : ℕ) : S.transitionMap n ∘ S.proj (n + 1) = S.proj n := by
rw [← S.proj_comp_transitionMap n]
rfl | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | proj_comp_transitionMap' | null |
proj_comp_transitionMapLE {n m : ℕ} (h : n ≤ m) :
S.proj m ≫ S.diagram.map ⟨homOfLE h⟩ = S.proj n :=
S.asLimitCone.w (homOfLE h).op | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | proj_comp_transitionMapLE | null |
proj_comp_transitionMapLE' {n m : ℕ} (h : n ≤ m) :
S.transitionMapLE h ∘ S.proj m = S.proj n := by
rw [← S.proj_comp_transitionMapLE h]
rfl | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | proj_comp_transitionMapLE' | null |
surjective_transitionMap (n : ℕ) : Function.Surjective (S.transitionMap n) := by
apply Function.Surjective.of_comp (g := S.proj (n + 1))
simpa only [proj_comp_transitionMap'] using S.proj_surjective n | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | surjective_transitionMap | null |
surjective_transitionMapLE {n m : ℕ} (h : n ≤ m) :
Function.Surjective (S.transitionMapLE h) := by
apply Function.Surjective.of_comp (g := S.proj m)
simpa only [proj_comp_transitionMapLE'] using S.proj_surjective n | lemma | Topology | [
"Mathlib.Topology.Category.LightProfinite.Basic"
] | Mathlib/Topology/Category/LightProfinite/AsLimit.lean | surjective_transitionMapLE | null |
LightProfinite := CompHausLike
(fun X ↦ TotallyDisconnectedSpace X ∧ SecondCountableTopology X) | abbrev | 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 | `LightProfinite` is the category of second countable profinite spaces. |
of (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X]
[TotallyDisconnectedSpace X] [SecondCountableTopology X] : LightProfinite :=
CompHausLike.of _ X | abbrev | 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 | of | Construct a term of `LightProfinite` from a type endowed with the structure of a compact,
Hausdorff, totally disconnected and second countable topological space. |
lightToProfinite : LightProfinite ⥤ Profinite :=
CompHausLike.toCompHausLike (fun _ ↦ inferInstance) | abbrev | 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 | lightToProfinite | The fully faithful embedding of `LightProfinite` in `Profinite`. |
lightToProfiniteFullyFaithful : lightToProfinite.FullyFaithful :=
fullyFaithfulToCompHausLike _ | abbrev | 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 | lightToProfiniteFullyFaithful | `lightToProfinite` is fully faithful. |
lightProfiniteToCompHaus : LightProfinite ⥤ CompHaus :=
compHausLikeToCompHaus _ | abbrev | 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 | lightProfiniteToCompHaus | The fully faithful embedding of `LightProfinite` in `CompHaus`. |
LightProfinite.toTopCat : LightProfinite ⥤ TopCat :=
CompHausLike.compHausLikeToTop _ | abbrev | 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.toTopCat | The fully faithful embedding of `LightProfinite` in `TopCat`.
This is definitionally the same as the obvious composite. |
@[simps! -isSimp map_hom_apply]
FintypeCat.toLightProfinite : FintypeCat ⥤ LightProfinite where
obj A := LightProfinite.of A
map f := CompHausLike.ofHom _ ⟨f, by continuity⟩ | 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 | FintypeCat.toLightProfinite | The natural functor from `Fintype` to `LightProfinite`, endowing a finite type with the
discrete topology. |
FintypeCat.toLightProfiniteFullyFaithful : toLightProfinite.FullyFaithful where
preimage f := (f : _ → _)
map_preimage _ := rfl
preimage_map _ := rfl | 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 | FintypeCat.toLightProfiniteFullyFaithful | `FintypeCat.toLightProfinite` is fully faithful. |
limitCone {J : Type v} [SmallCategory J] [CountableCategory J]
(F : J ⥤ LightProfinite.{max u v}) :
Limits.Cone F where
pt :=
{ toTop := (CompHaus.limitCone.{v, u} (F ⋙ lightProfiniteToCompHaus)).pt.toTop
prop := by
constructor
· infer_instance
· change SecondCountableTopology ({ u : ∀ j : J, F.obj j | _ } : Type _)
apply IsInducing.subtypeVal.secondCountableTopology }
π :=
{ app := (CompHaus.limitCone.{v, u} (F ⋙ lightProfiniteToCompHaus)).π.app
naturality := by
intro j k f
ext ⟨g, p⟩
exact (p f).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 | limitCone | An explicit limit cone for a functor `F : J ⥤ LightProfinite`, for a countable category `J`
defined in terms of `CompHaus.limitCone`, which is defined in terms of `TopCat.limitCone`. |
limitConeIsLimit {J : Type v} [SmallCategory J] [CountableCategory J]
(F : J ⥤ LightProfinite.{max u v}) :
Limits.IsLimit (limitCone F) where
lift S :=
(CompHaus.limitConeIsLimit.{v, u} (F ⋙ lightProfiniteToCompHaus)).lift
(lightProfiniteToCompHaus.mapCone S)
uniq S _ h := (CompHaus.limitConeIsLimit.{v, u} _).uniq (lightProfiniteToCompHaus.mapCone S) _ h | 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 | limitConeIsLimit | The limit cone `LightProfinite.limitCone F` is indeed a limit cone. |
noncomputable createsCountableLimits {J : Type v} [SmallCategory J] [CountableCategory J] :
CreatesLimitsOfShape J lightToProfinite.{max v u} where
CreatesLimit {F} :=
createsLimitOfFullyFaithfulOfIso (limitCone.{v, u} F).pt <|
(Profinite.limitConeIsLimit.{v, u} (F ⋙ lightToProfinite)).conePointUniqueUpToIso
(limit.isLimit _) | 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 | createsCountableLimits | null |
isClosedMap : IsClosedMap f :=
CompHausLike.isClosedMap _ | 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 | isClosedMap | Any morphism of light profinite spaces is a closed map. |
isIso_of_bijective (bij : Function.Bijective f) : IsIso f :=
haveI := CompHausLike.isIso_of_bijective (lightProfiniteToCompHaus.map f) bij
isIso_of_fully_faithful lightProfiniteToCompHaus _ | 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 | isIso_of_bijective | Any continuous bijection of light profinite spaces induces an isomorphism. |
noncomputable isoOfBijective (bij : Function.Bijective f) : X ≅ Y :=
letI := LightProfinite.isIso_of_bijective f bij
asIso 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 | isoOfBijective | Any continuous bijection of light profinite spaces induces an isomorphism. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.