Module mathcomp.analysis.topology_theory.function_spaces
From HB Require Import structures.From mathcomp Require Import boot order algebra interval_inference.
From mathcomp Require Import generic_quotient finmap.
#[warning="-warn-library-file-internal-analysis"]
From mathcomp Require Import unstable.
From mathcomp Require Import boolp classical_sets functions cardinality fsbigop.
From mathcomp Require Import reals.
From mathcomp Require Import topology_structure uniform_structure
supremum_topology initial_topology pseudometric_structure separation_axioms
compact connected subspace_topology product_topology.
Reserved Notation "{ 'uniform`' A -> V }"
(at level 0, A at level 69, format "{ 'uniform`' A -> V }").
Reserved Notation "{ 'uniform' U -> V }"
(at level 0, U at level 69, format "{ 'uniform' U -> V }").
Reserved Notation "{ 'uniform' A , F --> f }"
(at level 0, A at level 69, F at level 69,
format "{ 'uniform' A , F --> f }").
Reserved Notation "{ 'uniform' , F --> f }"
(at level 0, F at level 69,
format "{ 'uniform' , F --> f }").
Reserved Notation "{ 'ptws' U -> V }"
(at level 0, U at level 69, format "{ 'ptws' U -> V }").
Reserved Notation "{ 'ptws' , F --> f }"
(at level 0, F at level 69, format "{ 'ptws' , F --> f }").
Reserved Notation "{ 'family' fam , U -> V }"
(at level 0, U at level 69, format "{ 'family' fam , U -> V }").
Reserved Notation "{ 'family' fam , F --> f }"
(at level 0, F at level 69, format "{ 'family' fam , F --> f }").
Reserved Notation "{ 'compact-open' , U -> V }"
(at level 0, U at level 69, format "{ 'compact-open' , U -> V }").
Reserved Notation "{ 'compact-open' , F --> f }"
(at level 0, F at level 69, format "{ 'compact-open' , F --> f }").
Unset SsrOldRewriteGoalsOrder.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.
Local Obligation Tactic := idtac.
Import Order.TTheory GRing.Theory Num.Theory.
Local Open Scope classical_set_scope.
Local Open Scope ring_scope.
Definition
cauchy : forall {T : uniformType}, set_system T -> Prop cauchy is not universe polymorphic Arguments cauchy {T} F cauchy is transparent Expands to: Constant mathcomp.analysis.topology_theory.uniform_structure.cauchy Declared in library mathcomp.analysis.topology_theory.uniform_structure, line 337, characters 11-17
Source code
Variable : Type.
Definition
Source code
sup_topology (fun => Topological.class
(initial_topology (fun : (forall , T i) => f i))).
.
Source code
Source code
Topological.copy (prod_topology T) (product_topology_def T).
.
Source code
Source code
Uniform.copy (prod_topology T)
(sup_topology (fun => Uniform.class (initial_topology (@proj _ T i)))).
.
Source code
Source code
Source code
(Tc : Ii -> pseudoMetricType R) := PseudoMetric.copy (prod_topology Tc)
(sup_pseudometric (fun => PseudoMetric.class (initial_topology (@proj _ Tc i)))
(countableP _)).
End Product_Topology.
Notation
Source code
Notation
Source code
(cvg_to F (nbhs (f : {ptws _ -> _}))) : classical_set_scope.
Module
Source code
.
Source code
Source code
Source code
Topological.copy (forall : U, T x) (prod_topology T).
.
Source code
Source code
Source code
Uniform.copy (forall : U, T x) (prod_topology T).
.
Source code
Source code
Source code
Topological.copy
(continuousType U T)
(initial_topology (id : continuousType U T -> (U -> T))).
.
Source code
Source code
Source code
Uniform.copy
(continuousType U T)
(initial_topology (id : continuousType U T -> (U -> T))).
End ArrowAsProduct.
Section product_spaces.
Local Import ArrowAsProduct.
Section projection_maps.
Context { : eqType} { : I -> topologicalType}.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
move/(@preimage_subset _ _ (@dfwith _ _ g i))/filterS; apply.
apply: (@filterS _ _ _ ((@dfwith _ _ g i) @^-1` V)); first by exists V.
have [L Lsub /[dup] VL <-] := QfinP _ JV; rewrite preimage_bigcap.
apply: filter_bigI => /= M /[dup] LM /Lsub /set_mem [] w _ [+] + /[dup] + <-.
have [->|wnx] := eqVneq w i => N oN NM.
apply: (@filterS _ _ _ N); first by move=> ? ?; rewrite /= dfwith_in.
apply: open_nbhs_nbhs; split => //; move: Vpz.
by rewrite -VL => /(_ _ LM); rewrite -NM /= dfwith_in.
apply: nearW => y /=; move: Vpz.
by rewrite -VL => /(_ _ LM); rewrite -NM /= ?dfwith_out // eq_sym.
Qed.
Lemma
Source code
Proof.
have {oA} := oA _ Af; rewrite /interior => nAf.
apply: (@filterS _ _ _ ((@dfwith _ _ f i) @^-1` A)).
by move=> w Apw; exists (dfwith f w) => //; rewrite projK.
apply: dfwith_continuous => /=; move: nAf; congr (nbhs _ A).
by apply: functional_extensionality_dep => ?; case: dfwithP.
Qed.
Lemma
Source code
(forall , hausdorff_space (K x)) -> hausdorff_space (forall , K x).
Proof.
apply: hsdfK; move: clstr; rewrite ?cluster_cvgE /= => -[G PG [GtoQ psubG]].
exists (proj x @ G); [exact: fmap_proper_filter|split].
apply: cvg_trans; last exact: (@proj_continuous x q).
by apply: cvg_app; exact: GtoQ.
move/(cvg_app (proj x)): psubG => /cvg_trans; apply.
exact: proj_continuous.
Qed.
End projection_maps.
Lemma
Source code
( : forall , set (T i)) :
(forall , compact (A i)) ->
compact [set : forall , T i | forall , A i (f i)].
Proof.
exact: compact0.
case/set0P => a0 Aa0 Aco; rewrite compact_ultra => F FU FA.
set subst_coord := fun ( : I) ( : T i) ( : forall : I, T x) ( : I) =>
if eqP is ReflectT e then ecast (T i) (esym e) pi else f j.
have subst_coordT i pi f : subst_coord i pi f i = pi.
rewrite /subst_coord; case: eqP => // e.
by rewrite (eq_irrelevance e (erefl _)).
have subst_coordN i pi f j : i != j -> subst_coord i pi f j = f j.
move=> inej; rewrite /subst_coord; case: eqP => // e.
by move: inej; rewrite {1}e => /negP.
have pr_surj i : @^~ i @` [set: forall , T i] = setT.
rewrite predeqE => pi; split=> // _.
by exists (subst_coord i pi a0) => //; rewrite subst_coordT.
pose pF : set_system _ := [set @^~ i @` B | in F].
have pFultra i : UltraFilter (pF i) by exact: ultra_image (pr_surj i).
have pFA i : pF i (A i).
exists [set | forall , A i (g i)] => //.
rewrite predeqE => pi; split; first by move=> [g Ag <-]; apply: Ag.
move=> Aipi; have [f Af] := filter_ex FA.
exists (subst_coord i pi f); last exact: subst_coordT.
move=> j; have [<-{j}|] := eqVneq i j; first by rewrite subst_coordT.
by move=> /subst_coordN ->; exact: Af.
have cvpFA i : A i `&` [set | pF i --> p] !=set0.
by rewrite -ultra_cvg_clusterE; apply: Aco.
exists (fun => xget (a0 i) (A i `&` [set | pF i --> p])).
split=> [i|]; first by have /(xgetPex (a0 i)) [] := cvpFA i.
apply/cvg_sup => i; apply/cvg_image=> //.
by have /(xgetPex (a0 i)) [] := cvpFA i.
Qed.
Lemma
Source code
perfect_set [set: K i] -> perfect_set [set: forall , K i].
Proof.
Lemma
Source code
(forall , exists : K i * K i, xy.1 != xy.2) ->
perfect_set [set: forall , K i].
Proof.
rewrite eqEsubset; split => f // _.
pose distincts ( : nat) := projT1 (sigW (npts i)).
pose derange ( : K i) :=
if z == (distincts i).1 then (distincts i).2 else (distincts i).1.
pose g ( : nat) := if (i < N)%N then f i else derange _ (f i).
have gcvg : g @ \oo --> f.
apply/cvg_sup => N U [V] [[W] oW <-] WfN WU.
by apply: (filterS WU); rewrite nbhs_simpl /g; exists N.+1 => // i /= ->.
move=> A /gcvg; rewrite nbhs_simpl => -[N _ An].
exists (g N); split => //; last by apply: An; rewrite /= leqnn.
apply/eqP => M; suff: g N N != f N by rewrite M; move/eqP.
rewrite /g ltnn /derange eq_sym; have [->|//] := eqVneq (f N) (distincts N).1.
exact: projT2 (sigW (npts N)).
Qed.
Lemma
Source code
(forall , zero_dimensional (T i)) ->
zero_dimensional (forall , T i).
Proof.
have [i/eqP/dctTI [U [clU Ux nUy]]] : exists , x i <> y i.
by apply/existsNP=> W; exact/xneqy/functional_extensionality_dep.
exists (proj i @^-1` U); split => //; apply: preimage_clopen => //.
exact/proj_continuous.
Qed.
Lemma
Source code
( : I -> topologicalType) ( : forall , set (T i)) :
(forall , totally_disconnected (A i)) ->
@totally_disconnected (forall , T i) (fun => forall , A i (f i)).
Proof.
by move=> ? ->; exact: connected_component_refl.
move=> f /= [C /= [Cx CA ctC Cf]]; apply/functional_extensionality_dep => i.
suff : proj i @` C `<=` [set x i] by apply; exists f.
rewrite -(dsctAi i) // => Ti ?; exists (proj i @` C) => //.
split; [by exists x | by move=> ? [r Cr <-]; exact: CA |].
apply/(connected_continuous_connected ctC)/continuous_subspaceT.
exact: proj_continuous.
Qed.
Context { : choiceType} { : topologicalType} { : I -> topologicalType}.
Variable ( : forall , T -> U_ i).
Definition
Source code
closed U -> ~ U x -> exists , ~ (closure (f_ i @` U)) (f_ i x).
Hypothesis
Source code
Hypothesis
Source code
Let
Source code
sup_topology (fun => Topological.on (initial_topology (f_ i))).
Let : topologicalType := prod_topology U_.
Local Notation
Source code
Local Notation
Source code
Local Notation
Source code
Lemma
Source code
Filter F -> (F --> (x : T)) <-> (F --> (x : initialT)).
Proof.
move=> FTx; apply/cvg_sup => i U.
have /= -> := @nbhsE (initial_topology (f_ i)) x.
case=> B [[C oC <- ?]] /filterS; apply; apply: FTx; rewrite /= nbhsE.
by exists (f_ i @^-1` C) => //; split => //; exact: open_comp.
move/cvg_sup => wiFx U; rewrite /= nbhs_simpl nbhsE => [[B [oB ?]]].
move/filterS; apply; have [//|i nclfix] := @sepf _ x (open_closedC oB).
apply: (wiFx i); have /= -> := @nbhsE (initial_topology (f_ i)) x.
exists (f_ i @^-1` (~` closure [set f_ i x | in ~` B])); [split=>//|].
apply: open_comp; last by rewrite ?openC//; exact: closed_closure.
by move=> + _; exact: (@initial_continuous _ _ (f_ i)).
rewrite -interiorC interiorEbigcup preimage_bigcup => z [V [oV]] VnB => /VnB.
by move/forall2NP => /(_ z) [] // /contrapT.
Qed.
Lemma
Source code
Proof.
by have P := initial_sep_cvg x (nbhs_filter (x : initialT)); exact/P.
by have P := initial_sep_cvg x (nbhs_filter (x : T)); exact/P.
Qed.
Lemma
Source code
Proof.
by split => + z => /(_ z); rewrite initial_sep_nbhsE.
Qed.
Definition
Source code
Lemma
Source code
Proof.
by move=> cts x U => /cts; rewrite nbhs_simpl /= -initial_sep_nbhsE.
move=> x; apply/cvg_sup; first exact/fmap_filter/(nbhs_filter (x : initialT)).
move=> i; move: x; apply/(@continuousP _ (initial_topology (@^~ i))) => A [B ? E].
rewrite -E (_ : @^~ i = proj i) //.
have -> : join_product @^-1` (proj i @^-1` B) = f_ i @^-1` B by [].
apply: open_comp => // + _; rewrite /cvg_to => x U.
by rewrite nbhs_simpl /= -initial_sep_nbhsE; move: x U; exact: ctsf.
Qed.
Local Notation
Source code
Lemma
Source code
open ((join_product @` A) : set (subspace (range join_product))).
Proof.
have [// | i nAfiy] := @sepf (~` A) x (open_closedC oA).
pose B : set PU := proj i @^-1` (~` closure (f_ i @` (~` A))).
apply: (@filterS _ _ _ (range join_product `&` B)).
move=> z [[w ?]] wzE Bz; exists w => //.
move: Bz; rewrite /B -wzE -interiorC interiorEbigcup.
case=> K [oK KsubA] /KsubA.
have -> : proj i (join_product w) = f_ i w by [].
by move=> /exists2P/forallNP/(_ w)/not_andP [] // /contrapT.
apply: open_nbhs_nbhs; split; last by rewrite -jxy.
apply: openI; first exact: open_subspaceT.
apply: open_subspaceW; apply: open_comp; last exact/closed_openC/closed_closure.
by move=> + _; exact: proj_continuous.
Qed.
Lemma
Source code
Proof.
have [] := @sepf [set y] x (cl1 y); first exact/eqP.
move=> i P; suff : join_product x i != join_product y i by rewrite jxjy => /eqP.
apply/negP; move: P; apply: contra_not => /eqP; rewrite /join_product => ->.
by apply: subset_closure; exists y.
Qed.
Lemma
Source code
@open T = @open (initial_topology join_product).
Proof.
by move=> [V ? <-]; apply: open_comp => // + _; exact: join_product_continuous.
move=> /join_product_open/open_subspaceP [V oU VU].
exists V => //; have := @f_equal _ _ (preimage join_product) _ _ VU.
rewrite !preimage_setI // !preimage_range !setIT => ->.
rewrite eqEsubset; split; last exact: preimage_image.
by move=> z [w Uw] /inj <- //; rewrite inE.
Qed.
End product_embeddings.
Global Instance
Source code
( : prod_topology T) : ProperFilter (nbhs f).
Proof.
End product_spaces.
Local Open Scope relation_scope.
Variables ( : choiceType) ( : uniformType).
Definition
Source code
(fun => [set | forall : T, P (fg.1 t, fg.2 t)]).
Lemma
Source code
Proof.
move=> A B entA entB.
exists (A `&` B); first exact: filterI.
by move=> fg ABfg; split=> t; have [] := ABfg t.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Definition
Source code
Source code
Source code
Source code
Source code
Source code
Source code
Source code
Source code
fct_ent_filter fct_ent_refl fct_ent_inv fct_ent_split.
End fct_Uniform.
Source code
Source code
Source code
Source code
Pointed.on (arrow_uniform_type T U).
Lemma
Source code
( : set_system (arrow_uniform_type T U)) ( : Filter F)
( : arrow_uniform_type T U) :
F --> f <-> forall , entourage A ->
\forall \near F, forall , A (f t, g t).
Proof.
Section fun_Complete.
Context { : choiceType} { : completeType}.
Lemma
Source code
{ : ProperFilter F} : cauchy F -> cvg F.
Proof.
have /(_ _) /cauchy_cvg /cvg_app_entourageP cvF : cauchy (@^~_ @ F).
move=> t A /= entA; rewrite near_simpl -near2E near_map2.
by apply: Fc; exists A.
apply/cvg_ex; exists (fun => lim (@^~t @ F)).
apply/cvg_fct_entourageP => A entA; near=> f => t; near F => g.
apply: (entourage_split (g t)) => //; first by near: g; apply: cvF.
move: (t); near: g; near: f; apply: nearP_dep; apply: Fc.
by exists (split_ent A)^-1%relation => /=.
Unshelve. all: by end_near. Qed.
.
Source code
Source code
Source code
(arrow_uniform_type T U) fun_complete.
End fun_Complete.
Variable ( : choiceType) ( : numFieldType) ( : pseudoMetricType R).
Definition
Source code
Source code
( : arrow_uniform_type T U) := forall : T, ball (x t) eps (y t).
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Source code
fct_ball x e1 y -> fct_ball y e2 z -> fct_ball x (e1 + e2) z.
Proof.
Source code
Proof.
.
Source code
Source code
Source code
(arrow_uniform_type T U) fct_ball_center fct_ball_sym
fct_ball_triangle fct_entourage.
End fct_PseudoMetric.
Module
Source code
.
Source code
Source code
Source code
Uniform.copy (U -> V) (arrow_uniform_type U V).
.
Source code
Source code
Source code
(V : pseudoMetricType R) :=
PseudoMetric.copy (U -> V) (arrow_uniform_type U V).
.
Source code
Source code
Source code
Uniform.copy
(continuousType U T)
(initial_topology (id : continuousType U T -> (U -> T))).
End ArrowAsUniformType.
Context { : choiceType}.
Local Import ArrowAsUniformType.
Lemma
Source code
{
Source code
Source code
( : T1 -> T2 -> U) ( : T2 -> U) ( : T1 -> U) ( : U) :
f @ F1 --> g -> (forall , f x1 @ F2 --> h x1) -> h @ F1 --> l ->
g @ F2 --> l.
Proof.
near F1 => x1; near=> x2; apply: (entourage_split (h x1)) => //.
by apply/xsectionP; near: x1; exact: hl.
apply: (entourage_split (f x1 x2)) => //.
by apply/xsectionP; near: x2; exact: fh.
move: (x2); near: x1; have /cvg_fct_entourageP /(_ _^-1%relation):= fg; apply.
exact: entourage_inv.
Unshelve. all: by end_near. Qed.
Lemma
Source code
{
Source code
Source code
( : T1 -> T2 -> U) ( : T2 -> U) ( : T1 -> U) :
f @ F1 --> g -> (forall , f x @ F2 --> h x) ->
[cvg h @ F1 in U].
Proof.
rewrite !near_simpl -near2_pair near_map2; near=> x1 y1 => /=; near F2 => x2.
apply: (entourage_split (f x1 x2)) => //.
by apply/xsectionP; near: x2; exact: fh.
apply: (entourage_split (f y1 x2)) => //; last first.
apply/xsectionP; near: x2; apply/(fh _ (xsection _^-1%relation _)).
exact: nbhs_entourage (entourage_inv _).
apply: (entourage_split (g x2)) => //; move: (x2); [near: x1|near: y1].
have /cvg_fct_entourageP /(_ _^-1%relation) := fg; apply.
exact: entourage_inv.
by have /cvg_fct_entourageP := fg; apply.
Unshelve. all: by end_near. Qed.
Lemma
Source code
(
Source code
Source code
( : T1 -> T2 -> U) ( : T2 -> U) ( : T1 -> U) :
f @ F1 --> g -> (forall , f x1 @ F2 --> h x1) ->
exists : U, h @ F1 --> l /\ g @ F2 --> l.
Proof.
by exists (lim (h @ F1)); split=> //; apply: cvg_switch_1 Hfg Hfh hcv.
Qed.
End Cvg_switch.
Definition
one_point_compactification : Type -> Type one_point_compactification is not universe polymorphic Arguments one_point_compactification X%_type_scope one_point_compactification is transparent Expands to: Constant mathcomp.analysis.topology_theory.one_point_compactification.one_point_compactification Declared in library mathcomp.analysis.topology_theory.one_point_compactification, line 23, characters 11-37
Source code
Notation
Source code
Notation
Source code
Notation
Source code
(cvg_to F (nbhs (f : {uniform` A -> _}))) : classical_set_scope.
Notation
Source code
(cvg_to F (nbhs (f : {uniform _ -> _}))) : classical_set_scope.
Definition
one_point_nbhs : forall {X : topologicalType}, one_point_compactification X -> set_system (one_point_compactification X) one_point_nbhs is not universe polymorphic Arguments one_point_nbhs {X} x _ one_point_nbhs is transparent Expands to: Constant mathcomp.analysis.topology_theory.one_point_compactification.one_point_nbhs Declared in library mathcomp.analysis.topology_theory.one_point_compactification, line 33, characters 11-25
Source code
(U -> V) -> arrow_uniform_type A V := @sigL _ V A.
.
Source code
Source code
Source code
Uniform.copy {uniform` A -> V} (initial_topology (@sigL_arrow _ A V)).
Section RestrictedUniformTopology.
Context { : choiceType} ( : set U) { : uniformType} .
Lemma
Source code
nbhs f P <-> (exists , entourage E /\
[set | forall , A y -> E(f y, h y)] `<=` P).
Proof.
rewrite openE /= /interior in oW.
case: (oW _ Wf) => ? [ /= E entE] Esub subW.
exists E; split=> // h Eh; apply/subP/subW/xsectionP/Esub => /= [[u Au]].
by apply: Eh => /=; rewrite -inE.
case : (pselect (exists ( : U), True)); first last.
move=> nU; apply: (filterS subP); apply: (@filterS _ _ _ setT).
by move=> t _ /= y; move: nU; apply: absurd; exists y.
exact: filterT.
case=> u0 _; near=> g; apply: subP => y /mem_set Ay; rewrite -!(sigLE A).
move: (SigSub _); near: g.
have := (@cvg_image _ _ (@sigL_arrow _ A V) _ f (nbhs_filter f)
(image_sigL (f u0))).1 cvg_id [set | forall , E (sigL A f y, h y)].
case.
exists [set | forall , E (fg.1 y, fg.2 y)] => //; first by exists E.
by move=> g /xsectionP.
move=> B nbhsB rBrE; apply: (filterS _ nbhsB) => g Bg [y yA].
by move: rBrE; rewrite eqEsubset; case => [+ _]; apply; exists g.
Unshelve. all: by end_near. Qed.
Lemma
Source code
@entourage {uniform` A -> V} =
filter_from
(@entourage V)
(fun => [set | forall : U, A t -> P (fg.1 t, fg.2 t)]).
Proof.
case=> /= E [F entF FsubE EsubP]; exists F => //; case=> f g Ffg.
by apply/EsubP/FsubE=> [[x p]] /=; apply: Ffg; move/set_mem: (p).
case=> E entE EsubP; exists [set | forall , E (fg.1 t, fg.2 t)].
by exists E.
case=> f g Efg; apply: EsubP => t /mem_set At.
by move: Efg => /= /(_ (@exist _ (fun => in_mem x (mem A)) _ At)).
Qed.
End RestrictedUniformTopology.
Lemma
Source code
( : set_system (U -> V)) ( : U -> V) :
{uniform A, F --> f} = (F --> (f : {uniform` A -> V})).
Proof.
Lemma
Source code
( : set_system (U -> V)) ( : set U) ( : U -> V) :
{ptws, F --> f} = (F --> (f : {ptws U -> V})).
Proof.
Source code
Source code
Notation
Source code
Notation
Source code
(cvg_to F (@nbhs _ {family fam, _ -> _} f)) : type_scope.
.
Source code
Source code
Source code
(fam : set U -> Prop) :=
Uniform.copy {family fam, U -> V} (sup_topology (fun : sigT fam =>
Uniform.class {uniform` projT1 k -> V})).
Section UniformCvgLemmas.
Context { : choiceType} { : uniformType}.
Lemma
Source code
Filter F -> {uniform [set x], F --> f} = (g x @[ --> F] --> f x).
Proof.
move=> + W => /(_ [set | W (t x)]) +.
rewrite -[in X in _ -> X]nbhs_entourageE uniform_nbhs => + [Q entQ subW].
by apply; exists Q; split => // h Qf; exact/subW/xsectionP/Qf.
move=> Ff W; rewrite uniform_nbhs => [[E] [entE subW]].
apply: (filterS subW); move/(nbhs_entourage (f x))/Ff: entE => //=; near_simpl.
by apply: filter_app; apply: nearW=> ? /xsectionP ? ? ->.
Qed.
Lemma
Source code
B `<=` A -> nbhs (f : {uniform` A -> V}) `=>` nbhs (f : {uniform` B -> V}).
Proof.
apply: (filterS EsubP); apply/uniform_nbhs; exists E; split => //.
by move=> h Eh y /BsubA Ay; exact: Eh.
Qed.
Lemma
Source code
Filter F -> B `<=` A -> {uniform A, F --> f} -> {uniform B, F --> f}.
Proof.
by move=> nbhsF Acvg; apply: cvg_trans; [exact: Acvg|exact: nbhsF].
Qed.
Lemma
Source code
Filter F -> {uniform, F --> f} -> {ptws, F --> f}.
Proof.
move=> /(uniform_subset_cvg _ isubT); rewrite uniform_set1.
rewrite cvg_image; first by rewrite eqEsubset; split=> v // _; exists (cst v).
apply: cvg_trans => W /=; rewrite nbhs_simpl; exists (@^~ i @^-1` W) => //.
by rewrite image_preimage // eqEsubset; split=> // j _; exists (fun _ => j).
Qed.
Lemma
Source code
Filter F ->
{uniform A, F --> f} <->
{uniform, sigL A @ F --> sigL A f}.
Proof.
- move=> cvgF P' /uniform_nbhs [E [entE EsubP]].
apply: (filterS EsubP); apply: cvgF => /=.
apply: (filterS (P := [set | forall , A y -> E (f y, h y)])).
+ by move=> h/= Eh [y ?] _; apply Eh; rewrite -inE.
+ by (apply/uniform_nbhs; eexists; split; eauto).
- move=> cvgF P' /= /uniform_nbhs [ E [/= entE EsubP]].
apply: (filterS EsubP).
move: (cvgF [set | (forall , E (sigL A f y, h y))]) => /=.
set Q := (x in (_ -> x) -> _); move=> W.
have: Q by apply W, uniform_nbhs; exists E; split => // h + ?; apply.
rewrite {}/W {}/Q; near_simpl => /= R; apply: (filterS _ R) => h /=.
by rewrite forall_sig /sigL /=.
Qed.
Lemma
Source code
{in A, f =1 g} -> close f g.
Proof.
by rewrite /map_pair/sigL_arrow eqfg; exact: entourage_refl.
Qed.
Lemma
Source code
hausdorff_space V -> close f g = {in A, f =1 g}.
Proof.
rewrite propeqE; split; last exact: eq_in_close.
rewrite entourage_close => C u; rewrite inE => uA; apply: hV.
rewrite /cluster -nbhs_entourageE /= => X Y [X' eX X'X] [Y' eY Y'Y].
exists (g u); split; [apply: X'X| apply: Y'Y]; apply/xsectionP; last first.
exact: entourage_refl.
apply: (C [set | forall , A y -> X' (fg.1 y, fg.2 y)]) => //=.
by rewrite uniform_entourage; exists X'.
Qed.
Lemma
Source code
(nbhs (f : {uniform U -> V})) = nbhs (f : arrow_uniform_type U V).
Proof.
case/uniform_nbhs => E [entE] /filterS; apply.
exists [set | forall , E (fh.1 y, fh.2 y)]; first by exists E.
by move=> ? /xsectionP /=.
case => J [E entE EJ] /filterS; apply; apply/uniform_nbhs; exists E.
by split => // z /= Efz; apply/xsectionP/EJ => t /=; exact: Efz.
Qed.
Lemma
Source code
{uniform A, F --> f} -> {uniform B, F --> f} ->
{uniform (A `|` B), F --> f}.
Proof.
apply: (filterS EsubQ).
rewrite (_: [set | (forall : U, (A `|` B) y -> E (f y, h y))] =
[set | forall , A y -> E (f y, h y)] `&`
[set | forall , B y -> E (f y, h y)]).
- rewrite eqEsubset; split=> h.
+ by move=> R; split=> t ?; apply: R;[left| right].
+ by move=> [R1 R2] y [? | ?]; [apply: R1| apply: R2].
- apply: filterI; [apply: AFf| apply: BFf].
+ by apply/uniform_nbhs; exists E; split.
+ by apply/uniform_nbhs; exists E; split.
Qed.
Lemma
Source code
{uniform set0, F --> f}.
Proof.
suff -> : P = setT by exact: filterT.
rewrite eqEsubset; split => //=.
by apply: subset_trans R => g _ ?.
Qed.
Lemma
Source code
Source code
Filter F -> {family fam, F --> f} <->
(forall : set U, fam A -> {uniform A, F --> f }).
Proof.
Lemma
Source code
Source code
Source code
( : U -> V) : Filter F ->
famA `<=` famB -> {family famB, F --> f} -> {family famA, F --> f}.
Lemma
Source code
Source code
Source code
( : set_system (U -> V)) ( : U -> V) : Filter F ->
(forall , famA P ->
exists ( : choiceType) ,
(forall , famB (f i)) /\ finite_subset_cover [set: I] f P) ->
{family famB, F --> f} -> {family famA, F --> f}.
Proof.
move: ex_finCover => /(_ _ famAA) [R [g [g_famB [D _]]]].
move/uniform_subset_cvg; apply.
elim/finSet_rect: D => X IHX.
have [->|/set0P[x xX]] := eqVneq [set` X] set0.
by rewrite coverE bigcup_set0; apply: cvg_uniform_set0.
rewrite coverE (bigcup_fsetD1 x)//; apply: cvg_uniformU.
exact/rFf/g_famB.
exact/IHX/fproperD1.
Qed.
End UniformCvgLemmas.
Lemma
Source code
( : set_system (U -> V)) ( : U -> V) : Filter F ->
{uniform A, F --> f} <-> {uniform, restrict A @ F --> restrict A f}.
Proof.
- rewrite -sigLK; move/(cvg_app valL) => D.
apply: cvg_trans; first exact: D.
move=> P /uniform_nbhs [E [/=entE EsubP]]; apply: (filterS EsubP).
apply/uniform_nbhs; exists E; split=> //= h /=.
rewrite /sigL => R u _; rewrite oinv_set_val.
by case: insubP=> /= *; [apply: R|apply: entourage_refl].
- move/(@cvg_app _ _ _ _ (sigL A)).
rewrite -fmap_comp sigL_restrict => D.
apply: cvg_trans; first exact: D.
move=> P /uniform_nbhs [E [/=entE EsubP]]; apply: (filterS EsubP).
apply/uniform_nbhs; exists E; split=> //= h /=.
rewrite /sigL => R [u Au] _ /=.
by have := R u I; rewrite /patch Au.
Qed.
Section FamilyConvergence.
Lemma
Source code
( : U -> V)
Source code
{family fam, F --> f} = (F --> (f : {family fam, U -> V})).
Proof.
Lemma
Source code
Source code
( : set U) ( : set (V * V)) ( : {family fam, U -> V}) :
entourage E -> fam A -> nbhs f [set | forall , A y -> E (f y, g y)].
Proof.
by apply uniform_nbhs; exists E; split.
Qed.
Lemma
Source code
( : set U) ( : set V) ( : {family compact, U -> V}) :
open O -> f @` A `<=` O -> compact A -> continuous f ->
nbhs (f : {family compact, U -> V}) [set | forall , A y -> O (g y)].
Proof.
near=> z => /=; (suff: A `<=` [set | O (z y)] by exact); near: z.
apply: cfA => x Ax; have : O (f x) by exact: fAO.
move: (oO); rewrite openE /= => /[apply] /[dup] /ctsf Ofx /=.
rewrite /interior -nbhs_entourageE => -[E entE EfO].
exists (f @^-1` xsection (split_ent E) (f x),
[set | forall , A w -> split_ent E (f w, g w)]).
split => //=; last exact: fam_nbhs.
by apply: ctsf; rewrite /= -nbhs_entourageE; exists (split_ent E).
case=> y g [/= /xsectionP Efxy] AEg Ay; apply/EfO/xsectionP.
by apply: subset_split_ent => //; exists (f y) => //=; exact: AEg.
Unshelve. all: by end_near. Qed.
End FamilyConvergence.
Context { : topologicalType}.
Definition
Source code
Section compact_open_setwise.
Context { : set T}.
Definition
Source code
Definition
Source code
filter_from
[set | f @` K `<=` O /\ open O]
(fun => [set | g @` K `<=` O]).
Global Instance
Source code
ProperFilter (compact_openK_nbhs f).
Proof.
apply: filter_from_filter; first by exists setT; split => //; exact: openT.
move=> P Q [fKP oP] [fKQ oQ]; exists (P `&` Q); first split.
- by move=> ? [z Kz M-]; split; [apply: fKP | apply: fKQ]; exists z.
- exact: openI.
by move=> g /= gPQ; split; exact: (subset_trans gPQ).
Qed.
.
Source code
Source code
Source code
.
Source code
Source code
Source code
Definition
Source code
Lemma
Source code
compact_openK_nbhs p =
[set | exists : set compact_openK,
[/\ compact_open_of_nbhs B, B p & B `<=` A]].
Proof.
Lemma
Source code
compact_open_of_nbhs = [set | A `<=` compact_openK_nbhs^~ A].
Proof.
.
Source code
Source code
Nbhs_isTopological.Build compact_openK compact_openK_nbhs_filter
compact_openK_nbhsE_subproof compact_openK_openE_subproof.
End compact_open_setwise.
Definition
Source code
sup_topology (fun : sigT (@compact T) =>
Topological.class (@compact_openK (projT1 i))).
.
Source code
Source code
Source code
.
Source code
Source code
Source code
Topological.copy compact_open compact_open_def.
Lemma
Source code
( : compact_open) :
Filter F ->
F --> f <-> forall , @compact T K -> @open U O -> f @` K `<=` O ->
F [set | g @` K `<=` O].
Proof.
Lemma
Source code
compact K -> open O -> open ([set | g @` K `<=` O] : set compact_open).
Proof.
End compact_open.
.
Source code
Source code
Source code
Pointed.on (@compact_openK U V K).
.
Source code
Source code
Source code
Pointed.on (@compact_open U V).
Notation
Source code
Notation
Source code
(F --> (f : @compact_open _ _)).
Section compact_open_uniform.
Context { : topologicalType} { : puniformType}.
Let
Source code
Lemma
Source code
continuous f -> Filter F ->
{compact-open, F --> f} <-> {family compact, F --> f}.
Proof.
move=> cptF; apply/compact_open_cvgP => K O cptK oO fKO.
apply: cptF; have := fam_compact_nbhs oO fKO cptK ctsf; apply: filter_app.
by near=> g => /= gKO ? [z Kx <-]; exact: gKO.
move/compact_open_cvgP=> cptOF; apply/cvg_sup => -[K cptK R].
case=> D [[E oE <-] Ekf] /filterS; apply.
move: oE; rewrite openE => /(_ _ Ekf); case => A [J entJ] EKR KfE.
near=> z; apply/KfE/xsectionP/EKR => -[u Kp]; rewrite /sigL_arrow /= /set_val /= /eqincl.
(have Ku : K u by rewrite inE in Kp); move: u Ku {D Kp}; near: z.
move/compact_near_coveringP/near_covering_withinP : (cptK); apply.
move=> u Ku; near (powerset_filter_from (@entourage V)) => E'.
have entE' : entourage E' by exact: (near (near_small_set _)).
pose C := f @^-1` xsection E' (f u).
pose B := \bigcup_( in K `&` closure C) interior (xsection E' (f z)).
have oB : open B by apply: bigcup_open => ? ?; exact: open_interior.
have fKB : f @` (K `&` closure C) `<=` B.
move=> _ [z KCz <-]; exists z => //; rewrite /interior.
by rewrite -nbhs_entourageE; exists E'.
have cptKC : compact (K `&` closure C).
by apply: compact_closedI => //; exact: closed_closure.
have := cptOF (K `&` closure C) B cptKC oB fKB.
exists (C, [set | [set g x | in K `&` closure C] `<=` B]).
split; last exact: cptOF.
by apply: (ctsf) => //; rewrite /filter_of -nbhs_entourageE; exists E'.
case=> z h /= [Cz KB Kz].
case: (KB (h z)); first by exists z; split => //; exact: subset_closure.
move=> w [Kw Cw /interior_subset Jfwhz]; apply: subset_split_ent => //.
exists (f w); last first.
apply: (near (small_ent_sub _) E') => //.
exact/xsectionP.
apply: subset_split_ent => //; exists (f u).
apply/entourage_sym; apply: (near (small_ent_sub _) E') => //.
exact/xsectionP.
have [] := Cw (f @^-1` xsection E' (f w)).
by apply: ctsf; rewrite /= -nbhs_entourageE; exists E'.
move=> r [Cr /= Ewr]; apply: subset_split_ent => //; exists (f r).
apply: (near (small_ent_sub _) E') => //.
exact/xsectionP.
apply/entourage_sym; apply: (near (small_ent_sub _) E') => //.
exact/xsectionP.
Unshelve. all: by end_near. Qed.
End compact_open_uniform.
Module
Source code
.
Source code
Source code
Source code
Topological.copy (U -> V) {compact-open, U -> V}.
.
Source code
Source code
Source code
Topological.copy (continuousType U V)
(initial_topology (id : (continuousType U V) -> (U -> V)) ).
End ArrowAsCompactOpen.
Definition
Source code
[set | B `<=` A /\ compact B].
Lemma
Source code
( : set U) ( : set_system (U -> V)) ( : U -> V) :
Filter F -> compact C ->
{uniform C, F --> f} <-> {family compactly_in C, F --> f}.
Proof.
apply: (iff_trans _ (iff_sym (fam_cvgP _ _ FF))); split.
- by move=> CFf D [/uniform_subset_cvg + _]; apply.
- by apply; split.
Qed.
Section UniformContinuousLimits.
Lemma
Source code
( : set_system (U -> V)) ( : U -> V) :
ProperFilter F -> (\forall \near F, continuous (g : U -> V)) ->
{uniform, F --> f} -> continuous f.
Proof.
apply: (entourage_split (g x)) => //.
by near: g; apply/Ff/uniform_nbhs; exists (split_ent A); split => // ?; exact.
apply: (entourage_split (g y)) => //; near: y; near: g.
by apply: (filterS _ ctsF) => g /(_ x) /cvg_app_entourageP; exact.
apply/Ff/uniform_nbhs; exists (split_ent (split_ent A))^-1%relation.
by split; [exact: entourage_inv | move=> g fg; near_simpl; near=> z; exact: fg].
Unshelve. all: end_near. Qed.
Lemma
Source code
( : set U) ( : set_system (U -> V)) ( : subspace K -> V) :
ProperFilter F -> (\forall \near F, continuous (g : subspace K -> V)) ->
{uniform K, F --> f} -> {within K, continuous f}.
Proof.
by rewrite /restrict => ? ->.
apply: (@uniform_limit_continuous (subspace K) _ (restrict K @ F) _).
apply: (filterS _ ctsF) => g; apply: subspace_eq_continuous.
by rewrite /restrict => ? ->.
by apply (@uniform_restrict_cvg _ _ F ) => //; exact: PF.
Qed.
End UniformContinuousLimits.
Section UniformPointwise.
Context { : topologicalType} { : uniformType}.
Definition
Source code
Lemma
Source code
Filter F -> {ptws, F --> f} = {family @singletons U, F --> f}.
Proof.
rewrite (@fam_cvgP _ _ singletons). (* BUG: slowdown if no arguments *)
rewrite cvg_sup; split.
move=> + A [x _ <-] => /(_ x); rewrite uniform_set1.
rewrite cvg_image; first by rewrite eqEsubset; split=> v // _; exists (cst v).
apply: cvg_trans => W /=; rewrite ?nbhs_simpl /fmap /= => [[W' + <-]].
by apply: filterS => g W'g /=; exists g.
move=> + i; have /[swap] /[apply] : singletons [set i] by exists i.
rewrite uniform_set1.
rewrite cvg_image; first by rewrite eqEsubset; split=> v // _; exists (cst v).
move=> + W //=; rewrite ?nbhs_simpl => Q => /Q Q'; exists (@^~ i @^-1` W) => //.
by rewrite eqEsubset; split => [j [? + <-//]|j Wj]; exists (fun _ => j).
Qed.
Lemma
Source code
Filter F -> {family compact, F --> f} -> {ptws, F --> f}.
Proof.
by move=> A [x _ <-]; exact: compact_set1.
Qed.
Lemma
Source code
Filter F -> {ptws, F --> f} <-> forall ( : U), (fun => g t) @ F --> f t.
Proof.
move/fam_cvgP => + t A At => /(_ [set t]); rewrite uniform_set1; apply => //.
by exists t.
by move=> pf; apply/fam_cvgP => ? [t _ <-]; rewrite uniform_set1; exact: pf.
Qed.
End UniformPointwise.
Section ArzelaAscoli.
Context { : topologicalType} { : puniformType} {
Source code
Implicit Types (I : Type).
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
forall ( : set (Y * Y)), entourage E ->
\forall \near x, forall , W i -> E (d i x, d i y).
Lemma
Source code
{ : I -> X -> Y} { : J -> X -> Y} :
fW @`W `<=` fV @` V -> equicontinuous V fV -> equicontinuous W fW.
Proof.
by case: (WsubV (fW i)); [exists i | move=> j Vj <-; exact: VE].
Qed.
Lemma
Source code
W `<=` V -> equicontinuous V id -> equicontinuous W id.
Proof.
Lemma
Source code
{for x, equicontinuous W fW} -> W i -> {for x, continuous (fW i)}.
Proof.
by near=> y; apply: (near (ectsW _ entE) y).
Unshelve. end_near. Qed.
Lemma
Source code
equicontinuous W fW -> W i -> continuous (fW i).
Proof.
by move=> ?; exact: ectsW.
Qed.
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
forall , precompact [set d i x | in W].
Lemma
Source code
{ : I -> X -> Y} { : J -> X -> Y} :
fW @` W `<=` fV @` V -> pointwise_precompact V fV ->
pointwise_precompact W fW.
Proof.
by case: (WsubV (fW i)); [exists i | move=> j Vj <-; exists j].
Qed.
Lemma
Source code
pointwise_precompact W fW -> precompact ((fW @` W) : set {ptws X -> Y}).
Proof.
pose K := fun => closure [set fW i x | in W].
set R := [set : {ptws X -> Y} | forall : X, K x (f x)].
have C : compact R.
by apply: tychonoff => x; rewrite -precompactE; move: ptwsPreW; exact.
apply: (subclosed_compact _ C); first exact: closed_closure.
have WsubR : (fW @` W) `<=` R.
by move=> f [i Wi <-] x; rewrite /K; apply: subset_closure; exists i.
rewrite closureE; apply: smallest_sub => //.
by apply: compact_closed => //=; exact: hausdorff_product.
Qed.
Lemma
Source code
compact (W : set (@uniform_fun_family X Y compact)) ->
compact (W : set {ptws X -> Y}).
Proof.
move=> + F UF FW => /(_ F UF FW) [h [Wh Fh]]; exists h; split => //.
by move=> Q Fq; apply: (pointwise_cvg_compact_family _ Fh).
Qed.
Lemma
Source code
precompact W -> pointwise_precompact W id.
Proof.
have : compact (proj x @` (closure W)).
apply: continuous_compact => //; apply: continuous_subspaceT=> g.
move=> E nbhsE; have := (@proj_continuous _ _ x g E nbhsE).
exact: (@pointwise_cvg_compact_family _ _ (nbhs g)).
move=> /[dup]/(compact_closed hsdf)/closure_id -> /subclosed_compact.
apply; first exact: closed_closure.
by apply/closureS/image_subset; exact: (@subset_closure _ W).
Qed.
Lemma
Source code
entourage E -> \forall \near f, E (f x, g x).
Proof.
have ? : Filter (nbhs f) by exact: nbhs_pfilter. (* NB: This Filter (nbhs f) used to infer correctly. *)
rewrite pointwise_cvg_family_singleton => /fam_cvgP /(_ [set x]).
rewrite uniform_set1 => /(_ _ [set | E (f x, y)]); apply; first by exists x.
by move: E entE; exact/cvg_entourageP.
Qed.
Lemma
Source code
equicontinuous W id -> equicontinuous (closure W) id.
Proof.
have ? : ProperFilter (within W (nbhs (f : {ptws X -> Y}))).
exact: within_nbhs_proper. (* TODO: This ProperFilter _ also used to infer correctly. *)
near (within W (nbhs (f : {ptws X -> Y}))) => g.
near: g; rewrite near_withinE; near_simpl; near=> g => Wg.
apply: (@entourage_split _ (g x)) => //.
exact: (near (pointwise_cvg_entourage _ _ _)).
apply: (@entourage_split _ (g y)) => //; first exact: (near (@ectsW x _ _)).
by apply/entourage_sym; exact: (near (pointwise_cvg_entourage _ _ _)).
Unshelve. all: by end_near. Qed.
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
Lemma
Source code
ProperFilter F ->
(\forall \near powerset_filter_from F, equicontinuous W id) ->
{ptws, F --> f} <-> {family compact, F --> f}.
Proof.
exact: equicontinuous_subset_id.
move=> W; wlog Wf : f W / W f.
move=> + FW /equicontinuous_closure => /(_ f (closure (W : set {ptws X -> Y}))) Q.
split => Ff; last by apply: pointwise_cvg_compact_family.
apply/Q => //.
by rewrite closureEcvg; exists F; [|split] => // ? /= /filterS; apply.
by apply: (filterS _ FW) => z Wz; apply: subset_closure.
move=> FW ectsW; split=> [ptwsF|]; last exact: pointwise_cvg_compact_family.
apply/fam_cvgP => K ? U /=; rewrite uniform_nbhs => [[E [eE EsubU]]].
suff : \forall \near within W (nbhs (f : {ptws X -> Y})),
forall , K y -> E (f y, g y).
rewrite near_withinE; near_simpl => N; apply: (filter_app _ _ FW).
by apply: ptwsF; near=> g => ?; apply: EsubU; apply: (near N g).
near (powerset_filter_from (@entourage Y)) => E'.
have entE' : entourage E' by exact: (near (near_small_set _)).
pose Q := fun ( : X -> Y) => E' (f x, h x).
apply: (iffLR (compact_near_coveringP K)) => // x Kx.
near=> y g => /=.
apply: (entourage_split (f x) eE).
apply entourage_sym; apply: (near (small_ent_sub _) E') => //.
exact: (near (ectsW x E' entE') y).
apply: (@entourage_split _ (g x)) => //.
apply: (near (small_ent_sub _) E') => //.
near: g; near_simpl; apply: (@cvg_within _ (nbhs (f : {ptws X -> Y}))).
exact: pointwise_cvg_entourage.
apply: (near (small_ent_sub _) E') => //.
apply: (near (ectsW x E' entE')) => //.
exact: (near (withinT _ (nbhs_filter (f : {ptws X -> Y})))).
Unshelve. all: end_near. Qed.
Lemma
Source code
equicontinuous W id ->
closure (W : set {family compact, X -> Y}) =
closure (W : set {ptws X -> Y}).
Proof.
split; move=> [F PF [Fx WF]]; (exists F; last split) => //.
apply/@pointwise_compact_cvg => //; apply/near_powerset_filter_fromP.
exact: equicontinuous_subset_id.
by exists W => //; exact: WF.
apply/@pointwise_compact_cvg => //; apply/near_powerset_filter_fromP.
exact: equicontinuous_subset_id.
by exists W => //; exact: WF.
Qed.
Lemma
Source code
pointwise_precompact W id ->
equicontinuous W id ->
precompact (W : set {family compact, X -> Y }).
Proof.
rewrite ?precompactE compact_ultra compact_ultra pointwise_compact_closure //.
move=> /= + F UF FcW => /(_ F UF); rewrite image_id => /(_ FcW)[p [cWp Fp]].
exists p; split => //; apply/pointwise_compact_cvg => //.
apply/near_powerset_filter_fromP; first exact: equicontinuous_subset_id.
exists (closure (W : set {ptws X -> Y })) => //.
exact: equicontinuous_closure.
Qed.
Section precompact_equicontinuous.
Hypothesis
Source code
Lemma
Source code
(forall , W f -> continuous f) ->
compact (W : set {family compact, X -> Y}) ->
equicontinuous W id.
Proof.
have [//|U UWx [cptU clU]] := @lcptX x; rewrite withinET in UWx.
near (powerset_filter_from (@entourage Y)) => E'.
have entE' : entourage E' by exact: (near (near_small_set _)).
pose Q := fun ( : X) ( : {family compact, X -> Y}) => E' (f x, f y).
apply: (iffLR (compact_near_coveringP W)) => // f Wf; near=> g y => /=.
apply: (entourage_split (f x) entE).
apply/entourage_sym; apply: (near (small_ent_sub _) E') => //.
exact: (near (fam_nbhs _ entE' (@compact_set1 _ x)) g).
apply: (entourage_split (f y) (entourage_split_ent entE)).
apply: (near (small_ent_sub _) E') => //.
by apply/xsectionP; near: y; apply: (@ctsW f Wf x); exact: nbhs_entourage.
apply: (near (small_ent_sub _) E') => //.
by apply: (near (fam_nbhs _ entE' cptU) g) => //; exact: (near UWx y).
Unshelve. all: end_near. Qed.
Lemma
Source code
(forall , W f -> continuous f) ->
precompact (W : set {family compact, X -> Y}) ->
equicontinuous W id.
Proof.
apply: compact_equicontinuous; last by rewrite -precompactE.
move=> f; rewrite closureEcvg => [[G PG [Gf GW]]] x B /=.
rewrite -nbhs_entourageE => -[E entE] /filterS; apply; near_simpl.
suff ctsf : continuous f.
near=> x0; apply/xsectionP; near: x0.
by move: E entE; apply/cvg_app_entourageP; exact: ctsf.
apply/continuous_localP => x'; apply/near_powerset_filter_fromP.
by move=> ? ?; exact: continuous_subspaceW.
case: (@lcptX x') => // U; rewrite withinET => nbhsU [cptU _].
exists U => //; apply: (uniform_limit_continuous_subspace PG _ _).
by near=> g; apply: continuous_subspaceT; near: g; exact: GW.
by move/fam_cvgP/(_ _ cptU) : Gf.
Unshelve. all: end_near. Qed.
End precompact_equicontinuous.
Theorem
Source code
locally_compact [set: X] ->
pointwise_precompact W id /\ equicontinuous W id <->
(forall , W f -> continuous f) /\
precompact (W : set {family compact, X -> Y}).
Proof.
split=> [?|]; first exact: equicontinuous_continuous.
exact: pointwise_precompact_equicontinuous.
split; last exact: precompact_equicontinuous.
exact: precompact_pointwise_precompact.
Qed.
End ArzelaAscoli.
Section currying.
Local Import ArrowAsCompactOpen.
Section cartesian_closed.
Context { : topologicalType}.
Lemma
Source code
continuous f ->
continuous (curry f) /\ forall , continuous (curry f u).
Proof.
by move=> u z; apply: (continuous_comp _ (ctsf (u, z))); exact: cvg_pair.
move=> x; apply/compact_open_cvgP => K O /= cptK oO fKO.
near=> z => w /= [+ + <-]; near: z.
move/compact_near_coveringP/near_covering_withinP : cptK; apply.
move=> v Kv; have [[P Q] [Px Qv] PQfO] : nbhs (x, v) (f @^-1` O).
by apply: ctsf; move: oO; rewrite openE; apply; apply: fKO; exists v.
by exists (Q, P) => // -[b a] /= [Qb Pa] Kb; exact: PQfO.
Unshelve. all: by end_near. Qed.
Lemma
Source code
continuous f -> continuous (curry f).
Proof.
Lemma
Source code
continuous f -> curry f z.1 z.2 @[ --> (u, v)] --> curry f u v.
Proof.
by rewrite -surjective_pairing.
Qed.
Lemma
Source code
locally_compact [set: V] -> @regular_space V -> continuous f ->
(forall , continuous (f u)) -> continuous (uncurry f).
Proof.
apply; have [B] := @lcV v I; rewrite withinET => Bv [cptB clB].
have [R Rv RO] : exists2 , nbhs v R & forall , closure R z -> O (f u z).
have [] := reg v (f u @^-1` O); first by apply: cfp; exact: open_nbhs_nbhs.
by move=> R ? ?; exists R.
exists (f @^-1` [set | g @` (B `&` closure R) `<=` O], B `&` closure R).
split; [apply/cf/open_nbhs_nbhs; split | apply: filterI] => //.
- apply: compact_open_open => //; apply: compact_closedI => //.
exact: closed_closure.
- by move=> ? [x [? + <-]]; apply: RO.
- by apply: filterS; first exact: subset_closure.
by case=> a r /= [fBMO [Br] cmR]; apply: fBMO; exists r.
Qed.
Lemma
Source code
locally_compact [set: V] -> hausdorff_space V -> continuous f ->
(forall , continuous (f u)) -> continuous (uncurry f).
Proof.
move=> v; have [B] := @lcV v I; rewrite withinET => Bv [cptB clB].
by move=> z; exact: (compact_regular _ cptB).
Qed.
Lemma
Source code
{for f, continuous curry}.
Proof.
by apply: fmap_filter; exact: nbhs_filter.
move=> K ? cptK [D OfinIo <-] fKD /=; near=> z => w [+ + <-]; near: z.
move/compact_near_coveringP/near_covering_withinP : (cptK); apply => u Ku.
have [] := fKD (curry f u); first by exists u.
move=> E /[dup] /[swap] /OfinIo [N Asub <- DIN INf].
suff : \forall \near u & \near nbhs f, K x' ->
(\bigcap_( in [set` N]) i) (curry i x').
apply: filter_app; near=> a b => /[apply] ?.
by exists (\bigcap_( in [set` N]) i).
apply: filter_bigI_within => R RN; have /set_mem [[M cptM _]] := Asub _ RN.
have Rfu : R (curry f u) by exact: INf.
move/(_ _ Rfu) => [O [fMO oO] MOR]; near=> p => /= Ki; apply: MOR => + [+ + <-].
move=> _ v Mv; move: v Mv Ki; near: p.
have umb : \forall \near u, (forall , M b -> nbhs (y, b) (f @^-1` O)).
move/compact_near_coveringP/near_covering_withinP : (cptM); apply => v Mv.
have [[P Q] [Pu Qv] PQO] : nbhs (u, v) (f @^-1` O).
by apply: ctsf; apply: open_nbhs_nbhs; split => //; apply: fMO; exists v.
exists (Q, P); [by []| move=> [b a [/= Qb Pa Mb]]].
by apply: ctsf; apply: open_nbhs_nbhs; split => //; exact: PQO.
move/compact_near_coveringP/near_covering_withinP : (cptM); apply => v Mv.
have [P' P'u cPO] := regU u _ umb.
pose L := [set | h @` ((K `&` closure P') `*` M) `<=` O].
exists (setT, P' `*` L).
split => //; [exact: filterT|]; exists (P', L) => //; split => //.
apply: open_nbhs_nbhs; split; first apply: compact_open_open => //.
apply: compact_setX => //; apply: compact_closedI => //.
exact: closed_closure.
by move=> ? [[a b] [[Ka /cPO +] Mb <-]] => /(_ _ Mb)/nbhs_singleton.
move=> [b [a h]] [/= _ [Pa] +] Ma Ka; apply.
by exists (a, b); split => //; split => //; exact/subset_closure.
Unshelve. all: by end_near. Qed.
Lemma
Source code
locally_compact [set: V] -> @regular_space V -> @regular_space U ->
continuous f -> (forall , continuous (f u)) ->
{for f, continuous uncurry}.
Proof.
by apply: fmap_filter; exact:nbhs_filter.
move=> /= K O cptK oO fKO; near=> h => ? [+ + <-]; near: h.
move/compact_near_coveringP/near_covering_withinP: (cptK); apply.
case=> u v Kuv.
have : exists , [/\ closed P, compact Q, nbhs u P,
nbhs v Q & P `*` Q `<=` uncurry f @^-1` O].
have : continuous (uncurry f) by exact: continuous_uncurry_regular.
move/continuousP/(_ _ oO); rewrite openE => /(_ (u, v))[].
by apply: fKO; exists (u, v).
case=> /= P' Q' [P'u Q'v] PQO.
have [B] := @lcV v I; rewrite withinET; move=> Bv [cptB clB].
have [P Pu cPP'] := regU u P' P'u; have [Q Qv cQQ'] := regV v Q' Q'v.
exists (closure P), (B `&` closure Q); split.
- exact: closed_closure.
- by apply: compact_closedI => //; exact: closed_closure.
- by apply: filterS; first exact: subset_closure.
- by apply: filterI=> //; apply: filterS; first exact: subset_closure.
- by case => a b [/cPP' ?] [_ /cQQ' ?]; exact: PQO.
case=> P [Q [clP cptQ Pu Qv PQfO]]; pose R := [set : V -> W | g @` Q `<=` O].
(have oR : open R by exact: compact_open_open); pose P' := f @^-1` R.
pose L := [set : U -> V -> W | h @` (fst @` K `&` P) `<=` R].
exists ((P `&` P') `*` Q, L); first split => /=.
- exists (P `&` P', Q) => //; split => //=; apply: filterI => //.
apply: ctsf; apply: open_nbhs_nbhs; split => // _ [b Qb <-].
by apply: (PQfO (u, b)); split => //; exact: nbhs_singleton.
- rewrite nbhs_simpl /=; apply: open_nbhs_nbhs; split.
apply: compact_open_open => //; apply: compact_closedI => //.
apply: continuous_compact => //; apply: continuous_subspaceT => x.
exact: cvg_fst.
move=> /= _ [a [Kxa Pa] <-] _ [b Qb <-].
by apply: (PQfO (a, b)); split => //; exact: nbhs_singleton.
move=> [[a b h]] [/= [[Pa P'a] Qb Lh] Kab].
apply: (Lh (h a)); first by exists a => //; split => //; exists (a, b).
by exists b.
Unshelve. all: by end_near. Qed.
End cartesian_closed.
End currying.
Section big_continuous.
Context { : topologicalType} { : Type}
( : U -> U -> U) ( : U) ( : pred I).
Hypothesis
Source code
Lemma
Source code
( : I -> T -> U) ( : I -> U) :
Filter F ->
(forall , P i -> Ff i x @[ --> F] --> Fa i) ->
\big[op/x0]_( <- r | P i) (Ff i x) @[ --> F] -->
\big[op/x0]_( <- r | P i) Fa i.
Proof.
elim: r => [|i r IHr].
rewrite big_nil [X in X @ _](_ : _ = cst x0)//.
by apply/funext => t; rewrite big_nil.
rewrite big_cons.
under eq_cvg do rewrite big_cons.
case: ifPn => // Pi.
apply: (@cvg_comp _ _ _
(fun => (Ff i x1, \big[op/x0]_( <- r | P j) Ff j x1)) _ _
(nbhs (Fa i, \big[op/x0]_( <- r | P j) Fa j)) _ _
(continuous_curry_cvg cont_op)).
by apply: cvg_pair => //; exact: cvg_f.
Qed.
Lemma
Source code
( : I -> T -> U) :
(forall , P i -> continuous (F i)) ->
continuous (fun => \big[op/x0]_( <- r | P i) F i x).
Proof.
Lemma
Source code
( : I -> T -> U) :
(forall , P i -> {within A, continuous (F i)}) ->
{within A, continuous (fun => \big[op/x0]_( <- r | P i) F i x)}.
Proof.
End big_continuous.
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
uncurry (id : continuousType X Y -> (X -> Y)).
Section composition.
Local Import ArrowAsCompactOpen.
Lemma
Source code
locally_compact [set: X] -> regular_space X -> continuous (@eval X Y).
Proof.
exact: initial_continuous.
by move=> ?; exact: continuous_fun.
Qed.
Lemma
Source code
locally_compact [set: X] -> @regular_space X ->
locally_compact [set: Y] -> @regular_space Y ->
continuous (uncurry
(comp : continuousType Y Z -> continuousType X Y -> continuousType X Z)).
Proof.
set F := _ \o _.
rewrite -[F]uncurryK; apply: continuous_curry_fun.
pose g := uncurry F \o prodAr \o swap; rewrite /= in g *.
have -> : uncurry F = uncurry F \o prodAr \o prodA by rewrite funeqE => -[[]].
move=> z; apply: continuous_comp; first exact: prodA_continuous.
have -> : uncurry F \o prodAr = uncurry F \o prodAr \o swap \o swap.
by rewrite funeqE => -[[]].
apply: continuous_comp; first exact: swap_continuous.
pose h (
Source code
eval (fxg.2, (eval fxg.1)).
have <- : h = uncurry F \o prodAr \o swap.
by rewrite /h/g/uncurry/swap/F funeqE => -[[]].
rewrite /h.
apply: (@continuous2_cvg _ _ _ _ _ _ snd (eval \o fst) (curry eval)).
- by apply: continuous_curry_cvg; exact: eval_continuous.
- exact: cvg_snd.
- by apply: cvg_comp; [exact: cvg_fst | exact: eval_continuous].
Qed.
End composition.