Module mathcomp.analysis.topology_theory.separation_axioms
From HB Require Import structures.From mathcomp Require Import boot order algebra finmap.
From mathcomp Require Import boolp classical_sets functions wochoice.
From mathcomp Require Import cardinality fsbigop.
From mathcomp Require Import set_interval filter reals interval_inference.
From mathcomp Require Import topology_structure compact subspace_topology.
From mathcomp Require Import discrete_topology order_topology.
From mathcomp Require Import pseudometric_structure num_topology.
From mathcomp Require Import one_point_compactification uniform_structure.
From mathcomp Require Import connected supremum_topology sigT_topology.
Unset SsrOldRewriteGoalsOrder.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.
Import Order.TTheory GRing.Theory Num.Theory.
From mathcomp Require Import mathcomp_extra.
Local Open Scope classical_set_scope.
Local Open Scope ring_scope.
Section set_nbhs.
Context { : topologicalType} ( : set T).
Definition
Source code
Global Instance
Source code
Proof.
Global Instance
Source code
Proof.
Lemma
Source code
set_nbhs B <-> (exists , [/\ open C, A `<=` C & C `<=` B]).
Proof.
by case=> V [? AV /filterS +] x /AV ?; apply; apply: open_nbhs_nbhs.
move=> snB; have Ux x : exists , A x -> [/\ U x, open U & U `<=` B].
have [/snB|?] := pselect (A x); last by exists point.
by rewrite nbhsE => -[V [? ? ?]]; exists V.
exists (\bigcup_( in A) (projT1 (cid (Ux x)))); split.
- by apply: bigcup_open => x Ax; have [] := projT2 (cid (Ux x)).
- by move=> x Ax; exists x => //; have [] := projT2 (cid (Ux x)).
- by move=> x [y Ay]; have [//| _ _] := projT2 (cid (Ux y)); exact.
Qed.
End set_nbhs.
Section point_separation_axioms.
Context { : topologicalType}.
Definition
Source code
exists : set T, (A \in nbhs x /\ y \in ~` A) \/ (A \in nbhs y /\ x \in ~` A).
Definition
Source code
exists : set T, [/\ open A, x \in A & y \in ~` A].
Definition
at_left : forall [R : numFieldType], R -> set_system R at_left is not universe polymorphic Arguments at_left [R] x%_ring_scope _ at_left is transparent Expands to: Constant mathcomp.analysis.topology_theory.num_topology.at_left Declared in library mathcomp.analysis.topology_theory.num_topology, line 155, characters 11-18
Source code
Lemma
Source code
Proof.
have [q [Aq clsAp_q]] := [elaborate Aco _ _ pA]; rewrite (hT p q) //.
by apply: cvg_cluster clsAp_q; apply: cvg_within.
Qed.
Lemma
Source code
hausdorff_space -> compact V -> nbhs x V ->
ProperFilter F -> F V -> cluster F = [set x] -> F --> x.
Proof.
wlog oU : U nbhsU / open U.
rewrite /= nbhsE in nbhsU; case: nbhsU => O oO OsubU /(_ O) WH.
by apply: (filterS OsubU); apply: WH; [exact: open_nbhs_nbhs | by case: oO].
have /compact_near_coveringP : compact (V `\` U).
apply: (subclosed_compact _ cptV) => //.
by apply: closedI; [exact: compact_closed | exact: open_closedC].
move=> /(_ _ (powerset_filter_from F) (fun => ~ W x))[].
move=> z [Vz ?]; have zE : x <> z by move/nbhs_singleton: nbhsU => /[swap] ->.
have : ~ cluster F z by move: zE; apply: contra_not; rewrite clFx1 => ->.
case/existsNP=> C /existsPNP [D] FC /existsNP [Dz] /nonemptyPn.
rewrite setIC => /disjoints_subset CD0; exists (D, [set | F W /\ W `<=` C]).
by split; rewrite //= nbhs_simpl; exact: powerset_filter_fromP.
by case => t W [Dt] [FW] /subsetCP; apply; apply: CD0.
move=> M [MF ME2 [W] MW /(_ _ MW) VUW].
apply: (@filterS _ _ _ (V `&` W)); last by apply: filterI => //; exact: MF.
by move=> t [Vt Wt]; apply: contrapT => Ut; exact: (VUW t).
Qed.
Lemma
Source code
hausdorff_space -> compact A -> precompact A.
Proof.
Lemma
Source code
forall ( : T), x != y ->
exists2 , (x \in AB.1 /\ y \in AB.2) &
[/\ open AB.1, open AB.2 & AB.1 `&` AB.2 == set0].
Proof.
have := contra_not (T_filterT2 x y); rewrite (rwP eqP) (rwP negP).
move=> /[apply] /asboolPn/existsp_asboolPn[A]; rewrite -existsNE => -[B].
rewrite [nbhs _ _ -> _](rwP imply_asboolP) => /negP.
rewrite asbool_imply !negb_imply => /andP[/asboolP xA] /andP[/asboolP yB].
move=> /asboolPn; rewrite -set0P => /negP; rewrite negbK => /eqP AIB_eq0.
move: xA yB; rewrite !nbhsE.
move=> - [oA [oA_open oAx] oAA] [oB [oB_open oBx] oBB].
by exists (oA, oB); rewrite ?inE; split => //; apply: subsetI_eq0 AIB_eq0.
apply: contraPP => /eqP /T_openT2[[/=A B]].
rewrite !inE => - [xA yB] [Aopen Bopen /eqP AIB_eq0].
move=> /(_ A B (open_nbhs_nbhs _) (open_nbhs_nbhs _)).
by rewrite -set0P => /(_ _ _)/negP; apply.
Qed.
Lemma
Source code
Proof.
rewrite setIC => /disjoints_subset VUc; exists U; repeat split => //.
by rewrite inE; apply: VUc; rewrite -inE.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
accessible_space <-> forall : set T, finite_set A -> closed A.
Proof.
rewrite -(fsbig_setU_set1 fA) fsbig_finite//=.
by apply: bigsetU_closed => x xA; exact: accessible_closed_set1.
by exists (~` [set y]); rewrite !inE/=; split;
[rewrite openC; exact: h|exact/eqP|].
Qed.
End point_separation_axioms.
Arguments hausdorff_space : clear implicits.
Arguments accessible_space : clear implicits.
Arguments kolmogorov_space : clear implicits.
Lemma
Source code
accessible_space T -> closed (limit_point A).
Proof.
rewrite /setC/= not_limit_pointE => -[X].
rewrite nbhsE/= => -[U oaU UX] XAa.
rewrite /interior nbhsE/=.
exists U => // x Ux /=.
rewrite not_limit_pointE.
have [xa|xneqa] := eqVneq x a.
exists U; rewrite xa; first exact: open_nbhs_nbhs.
by apply: subset_trans XAa; exact: setIS.
exists (U `&` [set~ a]).
apply: open_nbhs_nbhs; split.
apply: openI; first by case: oaU.
by rewrite openC; exact: accessible_closed_set1.
by split => //; exact/eqP.
apply: (@subset_trans _ (A `&` (X `&` [set~ a]))).
by apply: setIS; exact: setSI.
apply: (@subset_trans _ ([set a] `&` [set~ a])).
by rewrite setIA; exact: setSI.
by rewrite setICr.
Qed.
Lemma
Source code
hausdorff_space T -> hausdorff_space (subspace A).
Proof.
move=> [[P Q]] /= [Px Qx] /= [/open_subspaceW oP /open_subspaceW oQ].
by move=> ?; exists (P, Q); split => //=; [exact: oP | exact: oQ].
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
have /orP[] := le_total p q; rewrite le_eqVlt => /predU1P[->|].
- by rewrite eqxx.
- by move=> ?; exact.
- by rewrite eqxx.
- move=> qp WH; rewrite eq_sym => /(WH _ _ qp)[[P Q] [? ?] [? ? ?]].
by exists (Q, P); split; rewrite // setIC.
move=> plq ?; have [[z /andP[pz zq]]|] := pselect (exists , p < z < q)%O.
exists (`]-oo,z[, `]z,+oo[)%classic.
by split => //=; apply/mem_set; rewrite set_itvE.
split => //= ; apply/eqP; rewrite -subset0 => r; rewrite set_itvE => -[/= rz].
by apply/negP; rewrite in_itv/= andbT -leNgt (ltW rz).
move=> npzq; exists (`]-oo, q[, `]p, +oo[)%classic; split => //=.
- by apply /mem_set; rewrite set_itvE.
- by apply /mem_set; rewrite set_itvE.
- apply/eqP; rewrite -subset0 => r; rewrite !set_itvE => -[/= rz zr].
by apply: npzq; exists r; rewrite rz zr.
Qed.
Section ball_hausdorff.
Variables ( : numDomainType) ( : pseudoMetricType R).
Lemma
Source code
forall ( : T), a != b ->
exists : {posnum R} * {posnum R},
ball a r.1%:num `&` ball b r.2%:num == set0.
Proof.
move=> A B; rewrite 2!inE => [[aA bB] [oA oB /eqP ABeq0]].
have /nbhs_ballP[_/posnumP[r] rA]: nbhs a A by apply: open_nbhs_nbhs.
have /nbhs_ballP[_/posnumP[s] rB]: nbhs b B by apply: open_nbhs_nbhs.
by exists (r, s) => /=; rewrite (subsetI_eq0 _ _ ABeq0).
move=> r s /eqP brs_eq0; exists ((ball a r%:num)°, (ball b s%:num)°) => /=.
split; by rewrite inE; apply: nbhs_singleton; apply: nbhs_interior;
apply/nbhs_ballP; apply: in_filter_from => /=.
split; do ?by apply: open_interior.
by rewrite (subsetI_eq0 _ _ brs_eq0)//; exact: interior_subset.
Qed.
Import numFieldTopology.Exports.
Lemma
Source code
Proof.
Lemma
Source code
locally_compact [set: X] ->
hausdorff_space X ->
hausdorff_space (one_point_compactification X).
Proof.
- move=> clxy; congr Some; apply: hsdfX => U V Ux Vy.
have [] := clxy (Some @` U) (Some @` V).
by apply: filterS Ux; exact: preimage_image.
by apply: filterS Vy; exact: preimage_image.
by case=> [_|] [] /= [// p /[swap] -[] <- Up] [q /[swap] -[] -> Vp]; exists p.
- have [U] := lcpt x I; rewrite withinET => Ux [cU clU].
case/(_ (Some @` U) (Some @` (~` U) `|` [set None])).
+ exact: one_point_compactification_some_nbhs.
+ by exists U.
+ by move=> [?|] [][]// z /[swap] -[] <- ? []//= [? /[swap] -[] ->].
- have [U] := lcpt y I; rewrite withinET => Uy [cU clU].
case/(_ (Some @` (~` U) `|` [set None]) (Some @` U)); first by exists U.
exact: one_point_compactification_some_nbhs.
by case=> [?|] [] [] //= + [] ? // /[swap] -[] -> => -[? /[swap] -[] <-].
Qed.
Section hausdorff_topologicalType.
Variable : topologicalType.
Implicit Types x y : T.
Local Open Scope classical_set_scope.
Definition
Source code
Lemma
Source code
Proof.
by rewrite /cluster; under eq_fun do rewrite -meets_openl.
rewrite clusterEonbhs /close funeqE => y /=; rewrite meetsC /meets.
apply/eq_forall => A; rewrite forall_swap.
by rewrite closureEonbhs/= meets_globallyl.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Hint Resolve close_refl : core.
Lemma
Source code
Proof.
Lemma
Source code
{near F, is_fun f} -> f `@ F --> l -> f `@ F --> l' -> close l l'.
Proof.
suff f_totalfun: {near F, is_totalfun f}.
by apply: cvg_close fFl fFl'; exact: fmapi_proper_filter.
apply: filter_app f_prop; near do split=> //=.
have: (f `@ F) setT by apply: fFl; apply: filterT.
by rewrite fmapiE; apply: filterS => x [y []]; exists y.
Unshelve. all: by end_near. Qed.
Hypothesis
Source code
Lemma
Source code
Proof.
by rewrite closeEnbhs; exact: sep.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Lemma
Source code
Lemma
Source code
{near F, is_fun f} -> is_subset1 [set : T | f `@ F --> x].
Proof.
End hausdorff_topologicalType.
Section hausdorff_ptopologicalType.
Variable : ptopologicalType.
Implicit Types x y : T.
Lemma
Source code
Source code
F1 --> F2 -> F2 --> F1 -> close (lim F1) (lim F2).
Proof.
Hypothesis
Source code
Lemma
Source code
Lemma
Source code
f @ F --> l -> lim (f @ F) = l.
Proof.
Lemma
Source code
(\forall \near F, f x = l) -> lim (f @ F) = l.
Proof.
Lemma
Source code
Proof.
Lemma
Source code
F (fun : U => is_subset1 (f x)) ->
f `@ F --> l -> lim (f `@ F) = l.
Proof.
End hausdorff_ptopologicalType.
#[global] Hint Resolve close_refl : core.
Arguments close_cvg {T} F1 F2 {FF2} _.
Section close_uniform.
Implicit Types (U : uniformType).
Lemma
Source code
close x y = forall , entourage A -> A (x, y).
Proof.
have /entourage_split_ent entsA := entA; rewrite closeEnbhs in cxy.
have yl := nbhs_entourage _ (entourage_inv entsA).
have yr := nbhs_entourage _ entsA.
have [z [/xsectionP zx /xsectionP zy]] := cxy _ _ (yr x) (yl y).
exact: (entourage_split z).
rewrite closeEnbhs => A B /nbhsP[E1 entE1 sE1A] /nbhsP[E2 entE2 sE2B].
exists y; split.
- by apply/sE1A/xsectionP; exact: cxy.
- by apply/sE2B/xsectionP; exact: entourage_refl.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
apply/nbhsP; exists (split_ent A) => // z /xsectionP xz; apply: sAP.
apply/xsectionP; apply: (entourage_split x) => //.
by have := cxy _ (entourage_inv (entourage_split_ent entA)).
Qed.
Lemma
Source code
ProperFilter F ->
F --> l <-> ([cvg F in U] /\ close (lim F) l).
Proof.
by have /cvgP := Fl; split=> //; apply: (@cvg_close _ F).
by apply: cvg_trans (close_cvgxx Cl).
Qed.
Lemma
Source code
close x y = forall
Source code
Proof.
have := [elaborate cxy _ (open_nbhs_ball _ (eps%:num/2)%:pos)].
rewrite closureEonbhs/= meetsC meets_globallyr.
move/(_ _ (open_nbhs_ball _ (eps%:num/2)%:pos)) => [z [zx zy]].
by apply: (@ball_splitl _ _ z); apply: interior_subset.
rewrite closeEnbhs => B A /nbhs_ballP[_/posnumP[e2 e2B]]
/nbhs_ballP[_/posnumP[e1 e1A]].
by exists y; split; [apply/e2B|apply/e1A; exact: ballxx].
Qed.
Section set_separations.
Context { : topologicalType}.
Definition
Source code
forall : set T, closed A ->
filter_from (set_nbhs A) closure `=>` set_nbhs A.
Definition
Source code
forall : T, filter_from (nbhs a) closure --> a.
Lemma
Source code
nbhs x V -> {for x, regular_space}.
Proof.
- apply: filter_from_proper => //; first last.
by move=> ? /nbhs_singleton/subset_closure ?; exists x.
apply: filter_from_filter; first by exists setT; exact: filterT.
move=> P Q Px Qx; exists (P `&` Q); [exact: filterI | exact: closureI].
- by exists V => //; have /closure_id <- : closed V by exact: compact_closed.
rewrite eqEsubset; split; first last.
move=> _ -> A B [C Cx CA /nbhs_singleton Bx]; exists x; split => //.
by apply/CA/subset_closure; exact: nbhs_singleton.
move=> y /=; apply: contraPeq; move: sep; rewrite open_hausdorff => /[apply].
move=> [[B A]]/=; rewrite ?inE; case=> By Ax [oB oA BA0].
apply/existsNP; exists (closure A); apply/existsNP; exists B; apply/not_implyP.
split; first by exists A => //; exact: open_nbhs_nbhs.
apply/not_implyP; split; first exact: open_nbhs_nbhs.
apply/set0P/negP; rewrite negbK; apply/eqP/disjoints_subset.
have /closure_id -> : closed (~` B); first by exact: open_closedC.
by apply/closureS/disjoints_subset; rewrite setIC.
Qed.
Lemma
Source code
forall : set T, A `<=` K° -> {for A, normal_space}.
Proof.
apply/(subclosed_compact clA cptV)/(subset_trans AK).
exact: interior_subset.
have snbC ( : set T) : Filter (filter_from (set_nbhs U) closure).
apply: filter_from_filter; first by exists setT; apply: filterT.
by move=> P Q sAP sAQ; exists (P `&` Q); [apply filterI|exact: closureI].
have [/(congr1 setC)|/set0P[b0 B0]] := eqVneq (~` B) set0.
by rewrite setCK setC0 => ->; exact: filterT.
have PsnA : ProperFilter (filter_from (set_nbhs (~` B)) closure).
apply: filter_from_proper => ? P.
by exists b0; apply/subset_closure; apply: nbhs_singleton; exact: P.
pose F := powerset_filter_from (filter_from (set_nbhs (~` B)) closure).
have PF : Filter F by exact: powerset_filter_from_filter.
have cvP ( : T) : A x -> \forall \near x & \near F, (~` i) x'.
move=> Ax; case/set_nbhsP : snAB => C [oC AC CB].
have [] := @compact_regular x _ hT cptV _ C; first exact: AK.
by rewrite nbhsE /=; exists C => //; split => //; exact: AC.
move=> D /nbhs_interior nD cDC.
have snBD : filter_from (set_nbhs (~` B)) closure (closure (~` closure D)).
exists (closure (~` closure D)) => [z|].
move=> nBZ; apply: filterS; first exact: subset_closure.
apply: open_nbhs_nbhs; split; first exact/closed_openC/closed_closure.
exact/(subsetC _ nBZ)/(subset_trans cDC).
by have := @closed_closure _ (~` closure D); rewrite closure_id => <-.
near=> y U => /=; have Dy : D° y by exact: (near nD _).
have UclD : U `<=` closure (~` closure D).
exact: (near (small_set_sub snBD) U).
move=> Uy; have [z [/= + Dz]] := UclD _ Uy _ Dy.
by apply; exact: subset_closure.
case/(_ _ _ _ _ cvP) : cvA => R /= [RA Rmono [U RU] RBx].
have [V /set_nbhsP [W [oW cBW WV] clVU]] := RA _ RU; exists (~` W).
apply/set_nbhsP; exists (~` closure W); split.
- exact/closed_openC/closed_closure.
- by move=> y /(RBx _ RU) + Wy; apply; exact/clVU/(closureS WV).
- by apply: subsetC; exact/subset_closure.
have : closed (~` W) by exact: open_closedC.
by rewrite closure_id => <-; exact: subsetCl.
Unshelve. all: by end_near. Qed.
Lemma
Source code
Proof.
End set_separations.
Arguments normal_space : clear implicits.
Arguments regular_space : clear implicits.
Local Open Scope relation_scope.
Lemma
Source code
Proof.
pose E' := split_ent E; have eE' : entourage E' by exact: entourage_split_ent.
exists (xsection (E' `&` E'^-1) x).
rewrite -nbhs_entourageE; exists (E' `&` E'^-1) => //.
exact: filterI.
move=> z /= clEz; apply/ER/xsectionP; apply: subset_split_ent => //.
have [] := clEz (xsection (E' `&` E'^-1) z).
rewrite -nbhs_entourageE; exists (E' `&` E'^-1) => //.
exact: filterI.
by move=> y /= [/xsectionP[? ?] /xsectionP[? ?]]; exists y.
Qed.
#[global] Hint Resolve uniform_regular : core.
Section totally_disconnected.
Implicit Types T : topologicalType.
Definition
Source code
forall , A x -> connected_component A x = [set x].
Definition
Source code
(forall , x != y -> exists : set T, [/\ clopen U, U x & ~ U y]).
Lemma
Source code
Proof.
by split; [exact: discrete_open | exact: discrete_closed].
Qed.
Lemma
Source code
zero_dimensional T -> totally_disconnected [set: T].
Proof.
Lemma
Source code
hausdorff_space T -> zero_dimensional T -> compact [set: T] ->
filter_from [set : set T | D x /\ clopen D] id --> x.
Proof.
have FF : Filter F.
apply: filter_from_filter; first by exists setT; split => //; exact: clopenT.
by move=> A B [? ?] [? ?]; exists (A `&` B) => //; split=> //; exact: clopenI.
have PF : ProperFilter F by apply: filter_from_proper; move=> ? [? _]; exists x.
move=> hsdfT zdT cmpT U Ux; rewrite nbhs_simpl -/F.
wlog oU : U Ux / open U.
move: Ux; rewrite /= nbhsE => -[] V [? ?] /filterS + /(_ V) P.
by apply; apply: P => //; exists V.
have /(iffLR (compact_near_coveringP _)) : compact (~` U).
by apply: (subclosed_compact _ cmpT) => //; exact: open_closedC.
move=> /(_ _ _ setC (powerset_filter_from_filter PF))[].
move=> y nUy; have /zdT [C [[oC cC] Cx Cy]] : x != y.
by apply: contra_notN nUy => /eqP <-; exact: nbhs_singleton.
exists (~` C, [set | U `<=` C]); first split.
- by apply: open_nbhs_nbhs; split => //; exact: closed_openC.
- apply/near_powerset_filter_fromP; first by move=> ? ?; exact: subset_trans.
by exists C => //; exists C.
- by case=> i j [? /subsetC]; apply.
by move=> D [DF _ [C DC]]/(_ _ DC)/subsetC2/filterS; apply; exact: DF.
Qed.
Lemma
Source code
(x < y)%O -> zero_dimensional T ->
exists , [/\ clopen U, U y , ~ U x & forall , U r -> ~ U l -> l < r]%O.
Proof.
have [U [clU Uy nUx]] := zt y x xNy.
have := clopen_bigcup_clopen clU Uy; set I := (I in clopen I); case=> ? ?.
pose V := I `|` `[y, +oo[; have Iy : I y.
case: clU => + _; rewrite openE => /(_ _ Uy).
rewrite /interior /= itv_nbhsE /= => -[i [] iy yi iU].
by exists i => //; split => //; exact: itv_open_ends_open.
have IU : I `<=` U by move=> ? [? [+ _ _]] => /subset_trans; exact.
exists V; split; first split.
- suff -> : V = I `|` `]y,+oo[ by exact: openU.
have /mem_set := Iy; rewrite -sub1set => /setUidl <-.
by rewrite -setUA setU1itv.
- by apply: closedU => //; exact: rray_closed.
- by left.
- by move=> [/IU //|]; rewrite set_itvE/= leNgt xy.
- move=> l r Vr Vl; rewrite ltNge; apply/negP; move: Vl; apply: contra_not.
move=> rl; case: Vr; first last.
by rewrite set_itvE => yr; right; rewrite set_itvE; exact: (le_trans yr).
have /orP[|ly] := le_total y l; first by move=> + _; right; rewrite set_itvE.
case=> i [iu oi /= yi ri]; left; exists i; first by split.
move: iu oi => _ _; case: i yi ri => p q /= /andP [py yq] /andP[pr rq].
apply/andP; split.
+ by rewrite (le_trans pr)// bnd_simp.
+ by rewrite (le_trans _ yq)// bnd_simp.
Qed.
End totally_disconnected.
Module
Source code
Section countable_uniform.
Local Open Scope relation_scope.
Context { : realType} { : uniformType}.
Hypothesis
Source code
Let := projT1 (cid2 (iffLR countable_uniformityP cnt_unif)).
Local Lemma
Source code
Proof.
Let
Source code
Proof.
Local Fixpoint : set (T * T) :=
if n is n.+1 then let := split_ent (split_ent (g_ n)) `&` f_ n in W `&` W^-1
else [set: T*T].
Let
Source code
Proof.
by move=> n entg; apply/entourage_invI; exact: filterI.
Qed.
Local Lemma
Source code
Local Lemma
Source code
Proof.
by apply: split_ent_subset; exact: entourage_split_ent.
by apply: subset_trans; last exact: split_ent_subset.
Qed.
Local Lemma
Source code
Proof.
Local Lemma
Source code
Proof.
apply: subset_trans; last exact: subset_split_ent (entG n).
apply: set_compose_subset (g2split); rewrite -[_ n.+1]set_compose_diag.
apply: subset_trans g2split; apply: set_compose_subset => //.
by move=> [_ _] [z _] [<- <-]; exact: entourage_refl.
apply: subset_trans; last exact: subset_split_ent.
by apply: set_compose_subset; apply: subIset; left; apply: subIset; left.
Qed.
Local Lemma
Source code
Local Lemma
Source code
Proof.
Local Open Scope classical_set_scope.
Local Open Scope ring_scope.
Local Definition
initial_topology : forall {S T : Type}, (S -> T) -> Type initial_topology is not universe polymorphic Arguments initial_topology {S T}%_type_scope f%_function_scope initial_topology is transparent Expands to: Constant mathcomp.analysis.topology_theory.initial_topology.initial_topology Declared in library mathcomp.analysis.topology_theory.initial_topology, line 51, characters 11-27
Source code
Local Lemma
Source code
Local Lemma
Source code
Local Lemma
Source code
Proof.
Local Fixpoint
initial_open : forall [S : choiceType] [T : topologicalType], (S -> T) -> set (set S) initial_open is not universe polymorphic Arguments initial_open [S T] f%_function_scope _ initial_open is transparent Expands to: Constant mathcomp.analysis.topology_theory.initial_topology.initial_open Declared in library mathcomp.analysis.topology_theory.initial_topology, line 58, characters 11-23
Source code
if n is n.+1 then exists ,
[/\ n_step_ball n x d1 y,
0 < d1,
0 < d2,
g_ (distN d2) (y, z) &
d1 + d2 = e]
else e > 0 /\ g_ (distN e) (x, z).
Local Definition
sub_initial_topology : forall [V : Type] [S : pred V], subChoiceType (T:=V) S -> Type sub_initial_topology is not universe polymorphic Arguments sub_initial_topology [V]%_type_scope [S] U sub_initial_topology is transparent Expands to: Constant mathcomp.analysis.topology_theory.initial_topology.sub_initial_topology Declared in library mathcomp.analysis.topology_theory.initial_topology, line 111, characters 11-31
Source code
Local Lemma
Source code
Proof.
Local Lemma
Source code
Proof.
Local Lemma
Source code
0 < e -> entourage [set | step_ball xy.1 e xy.2].
Local Lemma
Source code
Proof.
Local Lemma
Source code
Proof.
Local Lemma
Source code
n_step_ball n x d1 y ->
n_step_ball m y d2 z ->
n_step_ball (n + m).+1 x (d1 + d2) z.
Proof.
by exists y, d1, d2; split; rewrite ?addn0 // (n_step_ball_pos Nxy).
move=> [w] [e1] [e2] [Oyw ? ? ? <-].
exists w, (d1 + e1), e2; rewrite addnS addrA.
split => //; last by rewrite addr_gt0//; exact: n_step_ball_pos Oxy.
by case: (IH m w e1 Oxy Oyw) => t [e3] [e4] [] Oxt ? ? ? <-; exists t, e3, e4.
Qed.
Local Lemma
Source code
step_ball x d1 y -> step_ball y d2 z -> step_ball x (d1 + d2) z.
Proof.
Local Lemma
Source code
n_step_ball n x e y -> n_step_ball n y e x.
Proof.
move=> n IH x y e [t] [d1] [d2] [] /IH Oty ? ?.
rewrite addrC -symG -[n]add0n => gty <-; apply: (n_step_ball_triangle _ Oty).
by split => //; exact: gty.
Qed.
Local Lemma
Source code
Proof.
Local Lemma
Source code
e1 <= e2 -> n_step_ball n x e1 `<=` n_step_ball n x e2.
Proof.
move=> x e1 e2 e1e2 y [?] gxy; split; first exact: (lt_le_trans _ e1e2).
by apply: descendG; last (exact: gxy); exact: distN_le.
move=> n IH x e1 e2 e1e2 z [y] [d1] [d2] [] /IH P d1pos d2pos gyz d1d2e1.
exists y, (e2 - d2), d2; split => //.
- by apply: P; rewrite lerBrDr d1d2e1.
- by apply: lt_le_trans d1pos _; rewrite lerBrDr d1d2e1.
- by rewrite subrK.
Qed.
Local Lemma
Source code
e1 <= e2 -> step_ball x e1 `<=` step_ball x e2.
Proof.
Local Lemma
Source code
Proof.
Local Lemma
Source code
0 < e1 -> 0 < e2 -> n_step_ball n.+1 x (e1 + e2) z ->
exists ,
[/\
n_step_ball a x e1 t1,
n_step_ball 0 t1 (e1 + e2) t2,
n_step_ball b t2 e2 z &
(a + b = n)%N
].
Proof.
move=> e1 e2 x z e1pos e2pos [y] [d1] [d2] [] Oxy ? ? gd2yz deE.
case: (pselect (e1 <= d1)).
move=> e1d1; exists x, y, 0%N, 0%N; split.
- exact: n_step_ball_center.
- apply: n_step_ball_le; last exact: Oxy.
by rewrite -deE lerDl; apply: ltW.
- by apply: (@n_step_ball_le _ _ d2); rewrite // -(lerD2l e1) -deE lerD.
- by rewrite addn0.
move=> /negP; rewrite -ltNge//.
move=> e1d1; exists y, z, 0%N, 0%N; split.
- by apply: n_step_ball_le; last (exact: Oxy); exact: ltW.
- by apply: (@n_step_ball_le _ _ d2); rewrite // -deE lerDr ltW.
- exact: n_step_ball_center.
- by rewrite addn0.
move=> n IH e1 e2 x z e1pos e2pos [y] [d1] [d2] [] Od1xy d1pos d2pos gd2yz deE.
case: (pselect (e2 <= d2)).
move=> e2d2; exists y, z, n.+1, 0%N; split.
- by apply: (@n_step_ball_le _ _ d1); rewrite // -(lerD2r e2) -deE lerD.
- by apply: (@n_step_ball_le _ _ d2); rewrite // -deE lerDr; exact: ltW.
- exact: n_step_ball_center.
- by rewrite addn0.
have d1E' : d1 = e1 + (e2 - d2) by rewrite addrA -deE addrK.
move=> /negP; rewrite -ltNge// => d2lee2.
case: (IH e1 (e2 - d2) x y); rewrite ?subr_gt0 // -d1E' //.
move=> t1 [t2] [c1] [c2] [] Oxy1 gt1t2 t2y <-.
exists t1, t2, c1, c2.+1; split => //.
- by apply: (@n_step_ball_le _ _ d1); rewrite -?deE // ?lerDl; exact: ltW.
- by exists y, (e2 - d2), d2; rewrite // ?subr_gt0// subrK.
- by rewrite addnS.
Qed.
Local Lemma
Source code
n_step_ball 0 x n%:R^-1 `<=` [set | g_ n (x,y)].
Proof.
Local Lemma
Source code
n_step_ball n x N.+1%:R^-1 `<=` [set | (g_ N) (x, y)].
Proof.
rewrite leqn0 => /eqP -> N x; apply: subset_trans.
exact: n_step_ball_le_g.
by move=> y ?; exact: descendG.
move=> IH1 + + N x1 x4; case.
by move=> ? [?] P; apply: descendG _ P; rewrite distN_nat.
move=> l ln1 Ox1x4.
case: (@split_n_step_ball l x1 (N.+1%:R^-1/2) (N.+1%:R^-1/2) x4) => //.
by rewrite -splitr.
move=> x2 [x3] [l1] [l2] [] P1 [? +] P3 l1l2; rewrite -splitr distN_nat => ?.
have l1n : (l1 <= n)%N by rewrite (leq_trans (leq_addr l2 l1))// l1l2 -ltnS.
have l2n : (l2 <= n)%N by rewrite (leq_trans (leq_addl l1 l2))// l1l2 -ltnS.
apply: splitG3; exists x3; [exists x2 => //|].
by move/(n_step_ball_le (distN_half N))/(IH1 _ l1n) : P1.
by move/(n_step_ball_le (distN_half N))/(IH1 _ l2n) : P3.
Qed.
Local Lemma
Source code
step_ball x N.+1%:R^-1 `<=` [set | (g_ N) (x, y)].
Proof.
Local Lemma
Source code
Proof.
by case=> e /= epos esubE; apply: (filterS esubE); exact: entourage_nball.
move=> entE; case: (countableBase entE) => N fN.
exists N.+2%:R^-1; first by rewrite /= invr_gt0.
apply: (subset_trans _ fN); apply: subset_trans; last apply: gsubf.
by case=> x y /= N1ball; apply: (@subset_step_ball x N.+1).
Qed.
Definition
initial_ent : forall [pS : choiceType] [U : uniformType] [f : pS -> U], set_system (initial_topology f * initial_topology f) initial_ent is not universe polymorphic Arguments initial_ent [pS U] [f]%_function_scope _ initial_ent is transparent Expands to: Constant mathcomp.analysis.topology_theory.initial_topology.initial_ent Declared in library mathcomp.analysis.topology_theory.initial_topology, line 135, characters 11-22
Source code
Source code
Source code
Source code
Source code
Source code
Source code
Source code
Source code
step_ball_center step_ball_sym step_ball_triangle step_ball_entourage.
Source code
Source code
Source code
Source code
Pointed.copy type (Pointed.Pack q).
Lemma
Source code
Proof.
End countable_uniform.
Module
Source code
End countable_uniform.
Export countable_uniform.Exports.
Notation
Source code
Definition
Source code
( : Ii -> PseudoMetric R T) (
Source code
Section sup_pseudometric.
Variable ( : realType) ( : choiceType) ( : Type).
Variable ( : Ii -> PseudoMetric R T).
Hypothesis
Source code
Local Notation := (sup_pseudometric Tc Icnt).
Let := fun => PseudoMetric.Pack (Tc i).
Let
Source code
(fun => @countable_uniformity_metric _ (TS i)).
.
Source code
Source code
Source code
PseudoMetric.on (countable_uniform countable_uniformityT).
End sup_pseudometric.
Module
Source code
Section gauge.
Local Open Scope relation_scope.
Let
Source code
(split_ent W) `&` (split_ent W)^-1.
Section entourage_gauge.
Context { : uniformType} ( : set (T * T)) (
Source code
Definition
Source code
filter_from [set: nat] (fun => iter n split_sym (E `&` E^-1)).
Lemma
Source code
Proof.
Lemma
Source code
Proof.
by move=> n ? A _ /filterS; apply; apply: filterI; have ? := iter_split_ent n.
Qed.
Lemma
Source code
Proof.
move=> i j _ _; wlog ilej : i j / (i <= j)%N.
by move=> WH; have [|/ltnW] := leqP i j;
[|rewrite (setIC (iter _ _ _))]; exact: WH.
exists j => //; rewrite subsetI; split => //; elim: j i ilej => [i|j IH i].
by rewrite leqn0 => /eqP ->.
rewrite leq_eqVlt => /predU1P[<-//|/ltnSE/IH]; apply: subset_trans.
by move=> x/= [jx _]; apply: split_ent_subset => //; exact: iter_split_ent.
Qed.
Lemma
Source code
Proof.
by apply: entourage_refl; exact: iter_split_ent.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
apply: subset_trans EA; apply: subset_trans; first last.
by apply: subset_split_ent; exact: iter_split_ent.
by case=> a c [b] [] ? ? [] ? ?; exists b.
Qed.
Let
Source code
.
Source code
Source code
Source code
.
Source code
Source code
Source code
Lemma
Source code
Proof.
Definition
Source code
End entourage_gauge.
End gauge.
Module
Source code
End gauge.
Export gauge.Exports.
Lemma
Source code
@entourage T = @sup_ent T { : set (T * T) | @entourage T E}
(fun => Uniform.class (@gauge.type T (projT1 E) (projT2 E))).
Proof.
exists E => //=.
pose pe : {classic { : set (T * T) | _}} * _ := (exist _ E entE, E).
have entPE : `[< @entourage (gauge.type entE) E >].
by apply/asboolP; exists 0%N => // ? [].
exists (fset1 (exist _ pe entPE)) => //=; first by move=> ?; rewrite in_setE.
by rewrite set_fset1 bigcap_set1.
case=> W /= [/= J] _ <- /filterS; apply; apply: filter_bigI => -[] [] [] /= D.
move=> entD G /[dup] /asboolP [n _ + _ _] => /filterS; apply.
exact: gauge.iter_split_ent.
Qed.
Section perfect_sets.
Implicit Types (T : topologicalType).
Definition
Source code
Lemma
Source code
perfect_set A <-> closed A /\ isolated A = set0.
Proof.
- move=> /(congr1 (fun => x `\` limit_point A)).
rewrite setUDK.
by apply/disj_setPS; rewrite disj_set_sym disjoint_isolated_limit_point.
by rewrite limA -(closure_id A).1// setDv.
- by rewrite isoA set0U -(closure_id A).1.
Qed.
Lemma
Source code
Proof.
case=> _; rewrite eqEsubset; case=> _ + x Ox => /(_ x I [set x]).
by case; [by apply: open_nbhs_nbhs; split |] => y [+ _] => /[swap] -> /eqP.
move=> NOx; split; [exact: closedT |]; rewrite eqEsubset; split => x // _.
move=> U; rewrite nbhsE; case=> V [] oV Vx VU.
have Vnx: V != [set x] by apply/eqP => M; apply: (NOx x); rewrite -M.
have /existsNP [y /existsNP [Vy Ynx]] : ~ forall , V y -> y = x.
move/negP: Vnx; apply: contra_not => Vxy; apply/eqP; rewrite eqEsubset.
by split => // ? ->.
by exists y; split => //; [exact/eqP | exact: VU].
Qed.
Lemma
Source code
forall ( : set T), open U -> U !=set0 ->
exists , [/\ U x, U y & x != y] .
Proof.
move=> nx1 U oU [] x Ux; exists x.
have : U <> [set x] by move=> Ux1; apply: (nx1 x); rewrite -Ux1.
apply: contra_notP => /not_existsP/contrapT=> Uyx; rewrite eqEsubset.
by split => [y Uy|? ->//]; have /not_and3P[//|//|/negP/negPn/eqP] := Uyx y.
move=> Unxy x Ox; have [] := Unxy _ Ox; first by exists x.
by move=> y [] ? [->] -> /eqP.
Qed.
End perfect_sets.
Section sigT_separations.
Context { : choiceType} { : I -> topologicalType}.
Lemma
Source code
(forall , hausdorff_space (X i)) -> hausdorff_space { & X i}.
Proof.
have [] := cl (existT X i @` [set: X i]) (existT X j @` [set: X j]);
[by apply: existT_nbhs; exact: filterT..|].
move=> p [/= [_ _ <-] [_ _ [ji]]] _.
rewrite {}ji {j} in x y cl *.
congr existT; apply: hX => U V Ux Vy.
have [] := cl (existT X i @` U) (existT X i @` V); [exact: existT_nbhs..|].
move=> z [] [l Ul <-] [r Vr lr]; exists l; split => //.
by rewrite -(existT_inj2 lr).
Qed.
End sigT_separations.