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.