Top source

Module mathcomp.analysis.topology_theory.topology_structure

From HB Require Import structures.
From mathcomp Require Import boot order algebra finmap.
From mathcomp Require Import all_classical.
From mathcomp Require Export filter.

# Basic topological notions This file develops tools for the manipulation of basic topological notions. The development of topological notions builds on "filtered types" by extending the hierarchy. ## Mathematical structures ### Topology ``` topologicalType == interface type for topological space structure the HB class is Topological. subTopologicalType S == join of SubNbhs and Topological where S has pred V with V a topologicalType the HB class is SubTopological. ptopologicalType == a pointed topologicalType open == set of open sets closed == set of closed sets clopen U == U is both open and closed open_nbhs p == set of open neighbourhoods of p basis B == a family of open sets that converges to each point second_countable T == T has a countable basis [locally P] := forall a, A a -> G (within A (nbhs x)) if P is convertible to G (globally A) U° == all of the points which are locally in U, i.e., the largest open set contained in U This is a notation for `interior U`. closure U == the smallest closed set containing U regopen U == U is regular open, i.e., equal to the interior of its closure regclosed U == U is regular closed, i.e., equal to the closure of its interior open_of_nbhs B == the open sets induced by neighborhoods nbhs_of_open B == the neighborhoods induced by open sets x^' == set of neighbourhoods of x where x is excluded (a "deleted neighborhood") limit_point E == the set of limit points of E isolated A == the set of isolated points of A dense S == the set (S : set T) is dense in T, with T of type topologicalType continuousType == type of continuous functions The HB structures is Continuous. mkcts f_cts == object of type continuousType corresponding to the function f (f_cts : continuous f) ``` ### Factories ``` Nbhs_isNbhsTopological == factory for a topology defined by a filter It builds the mixin for a topological space from the properties of nbhs and hence assumes that the carrier is a filterType. isOpenTopological == factory for a topology defined by open sets It builds the mixin for a topological space from the properties of open sets, nbhs_of_open must be used to declare a filterType. isBaseTopological == factory for a topology defined by a base of open sets It builds the mixin for a topological space from the properties of a base of open sets; the type of indices must be a pointedType isSubBaseTopological == factory for a topology defined by a subbase of open sets It builds the mixin for a topological space from a subbase of open sets b indexed on domain D ```

Reserved Notation "A °" (format "A °").
Reserved Notation "[ 'locally' P ]" (format "[ 'locally' P ]").
Reserved Notation "x ^'" (format "x ^'").

Unset SsrOldRewriteGoalsOrder.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.

Local Open Scope classical_set_scope.
Local Open Scope ring_scope.

Topological spaces
.
Nbhs_isTopological
Source code
() T := {
  open : set_system T;
  nbhs_pfilter_subproof : forall : T, ProperFilter (nbhs p) ;
  nbhsE_subproof : forall : T, nbhs p =
    [set : set T | exists : set T, [/\ open B, B p & B `<=` A] ] ;
  openE_subproof : open = [set : set T | A `<=` nbhs^~ A ]
}.

(
"topologicalType"
Source code
)
.
structure
Source code
Definition
Source code
Topological
Source code

  { of Nbhs T & Nbhs_isTopological T}.

(
"ptopologicalType"
Source code
)
.
structure
Source code
Definition
Source code
PointedTopological
Source code

  { of PointedNbhs T & Nbhs_isTopological T}.

(
"bpTopologicalType"
Source code
)
.
structure
Source code
Definition
Source code
BiPointedTopological
Source code

  { of BiPointed X & Topological X }.

(
"subTopologicalType"
Source code
)
.
structure
Source code
Definition
Source code
SubTopological
Source code
(
topologicalType
Source code
)
  (S : pred V) := { of SubNbhs V S U & Topological U}.

Section Topological1.
Context { : topologicalType}.

Definition
open_nbhs
Source code
( : T) ( : set T) := open A /\ A p.

Definition ( : set_system T) :=
  B `<=` open /\ forall , filter_from [set | B U /\ U x] id --> x.

Definition
second_countable

set_nbhs : forall {T : topologicalType}, set T -> set (set T) set_nbhs is not universe polymorphic Arguments set_nbhs {T} A%_classical_set_scope _ set_nbhs is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.set_nbhs Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 69, characters 11-19


Source code
:= exists2 , countable B & basis B.

Global Instance
nbhs_pfilter
Source code
( : T) : ProperFilter (nbhs p).
Proof.
by apply: nbhs_pfilter_subproof; case: T p => ? []. Qed.
Typeclasses Opaque nbhs.
Lemma
nbhs_filter
Source code
( : T) : Filter (nbhs p).
Proof.
exact: (@nbhs_pfilter). Qed.

Canonical
nbhs_filter_on

kolmogorov_space : topologicalType -> Prop kolmogorov_space is not universe polymorphic Arguments kolmogorov_space T kolmogorov_space is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.kolmogorov_space Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 103, characters 11-27


Source code
( : T) := FilterType (nbhs x) (@nbhs_filter x).

Lemma ( : T) :
  nbhs p = [set : set T | exists2 : set T, open_nbhs p B & B `<=` A].
Proof.
have -> : nbhs p = [set : set T | exists , [/\ open B, B p & B `<=` A] ].
  exact: nbhsE_subproof.
by rewrite predeqE => A; split=> [[B [?]]|[B[]]]; exists B.
Qed.

Lemma
open_nbhsE
Source code
( : T) ( : set T) : open_nbhs p A = (open A /\ nbhs p A).
Proof.
by rewrite nbhsE propeqE; split=> [[? ?]|[? [B [? ?] BA]]]; split => //;
  [exists A | exact: BA].
Qed.

Definition
interior

accessible_space : topologicalType -> Prop accessible_space is not universe polymorphic Arguments accessible_space T accessible_space is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.accessible_space Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 106, characters 11-27


Source code
( : set T) := (@nbhs _ T)^~ A.

Local Notation := (interior A).

Lemma
interior_subset
Source code
( : set T) : A° `<=` A.
Proof.
by move=> p; rewrite /interior nbhsE => -[? [? ?]]; apply.
Qed.

Lemma : open = [set : set T | A `<=` A°].
Proof.
exact: openE_subproof. Qed.

Lemma
nbhs_singleton
Source code
( : T) ( : set T) : nbhs p A -> A p.
Proof.
by rewrite nbhsE => - [? [_ ?]]; apply. Qed.

Lemma
nbhs_interior
Source code
( : T) ( : set T) : nbhs p A -> nbhs p A°.
Proof.
rewrite nbhsE /open_nbhs openE => - [B [Bop Bp] sBA].
by exists B => // q Bq; apply: filterS sBA _; apply: Bop.
Qed.

Lemma : open (set0 : set T).
Proof.
by rewrite openE. Qed.

Lemma : open (setT : set T).
Proof.
by rewrite openE => ??; apply: filterT. Qed.

Lemma : setI_closed (@open T).
Proof.
move=> A B; rewrite openE => Aop Bop p [Ap Bp].
by apply: filterI; [apply: Aop|apply: Bop].
Qed.

Lemma
bigcup_open
Source code
( : Type) ( : set I) ( : I -> set T) :
  (forall , D i -> open (f i)) -> open (\bigcup_( in D) f i).
Proof.
rewrite openE => fop p [i Di].
by have /fop fiop := Di; move/fiop; apply: filterS => ??; exists i.
Qed.

Lemma : setU_closed (@open T).
Proof.
by move=> A B /[!openE] AA BB p [/AA|/BB]; apply: filterS => ? ?; [left|right].
Qed.

Lemma
open_subsetE
Source code
( : set T) : open A -> (A `<=` B) = (A `<=` B°).
Proof.
rewrite openE => Aop; rewrite propeqE; split.
  by move=> sAB p Ap; apply: filterS sAB _; apply: Aop.
by move=> sAB p /sAB /interior_subset.
Qed.

Lemma
open_interior
Source code
( : set T) : open A°.
Proof.
rewrite openE => p; rewrite /interior nbhsE => - [B [Bop Bp]].
by rewrite open_subsetE //; exists B.
Qed.

Lemma
interior_bigcup
Source code
( : set I) ( : I -> set T) :
  \bigcup_( in D) (f i)° `<=` (\bigcup_( in D) f i)°.
Proof.
move=> p [i Di]; rewrite /interior nbhsE => - [B [Bop Bp] sBfi].
by exists B => // ? /sBfi; exists i.
Qed.

Lemma
open_nbhsT
Source code
( : T) : open_nbhs p setT.
Proof.
by split=> //; apply: openT. Qed.

Lemma
open_nbhsI
Source code
( : T) : setI_closed (open_nbhs p).
Proof.
by move=> A B [Aop Ap] [Bop Bp]; split => //; exact: openI. Qed.

Lemma
open_nbhs_nbhs
Source code
( : T) ( : set T) : open_nbhs p A -> nbhs p A.
Proof.
by rewrite nbhsE => p_A; exists A. Qed.

Lemma
interiorI
Source code
( : set T) : (A `&` B)° = A° `&` B°.
Proof.
rewrite /interior predeqE => //= x; rewrite nbhsE; split => [[B0 ?] | []].
- by rewrite subsetI => // -[? ?]; split; exists B0.
- by move=> -[B0 ? ?] [B1 ? ?]; exists (B0 `&` B1);
  [exact: open_nbhsI | rewrite subsetI; split; apply: subIset; [left|right]].
Qed.

End Topological1.

Lemma
open_in_nearW
Source code
{ : topologicalType} ( : T -> Prop) ( : set T) :
  open S -> {in S, forall , P x} -> {in S, forall , \near , P x}.
Proof.
by move=> oS SP z /set_mem Sz; apply: in_nearW SP => //=; exact: open_nbhs_nbhs.
Qed.

#[global] Hint Extern 0 (Filter (nbhs _)) =>
  solve [apply: nbhs_filter] : typeclass_instances.
#[global] Hint Extern 0 (ProperFilter (nbhs _)) =>
  solve [apply: nbhs_pfilter] : typeclass_instances.

Global Instance
alias_nbhs_filter
Source code
{ : topologicalType} :
  @Filter T^o (@nbhs T^o T x).
Proof.
apply: @nbhs_filter T x. Qed.

Global Instance
alias_nbhs_pfilter
Source code
{ : topologicalType} :
  @ProperFilter T^o (@nbhs T^o T x).
Proof.
exact: @nbhs_pfilter T x. Qed.

Reserved Notation "A ^°" (at level 1, format "A ^°").
Notation := (interior A) : classical_set_scope.
#[deprecated(since="mathcomp-analysis 1.10.0", note="use the notation instead ° instead of ^°")]
Notation := (A°) (only parsing).

Lemma
continuousP
Source code
( : topologicalType) ( : S -> T) :
  continuous f <-> forall , open A -> open (f @^-1` A).
Proof.
split=> fcont; first by rewrite !openE => A Aop ? /Aop /fcont.
move=> s A; rewrite nbhs_simpl /= !nbhsE => - [B [Bop Bfs] sBA].
by exists (f @^-1` B); [split=> //; apply/fcont|move=> ? /sBA].
Qed.

Lemma
open_comp
Source code
{ : topologicalType} ( : T -> U) ( : set U) :
  {in f @^-1` D, continuous f} -> open D -> open (f @^-1` D).
Proof.
rewrite !openE => fcont Dop x /= Dfx.
by apply: fcont; [rewrite inE|exact: Dop].
Qed.

Lemma
cvg_fmap
Source code
{: topologicalType} { : topologicalType}
  ( : set_system T) ( : T -> U) :
   {for x, continuous f} -> F --> x -> f @ F --> f x.
Proof.
by move=> cf fx P /cf /fx. Qed.

Lemma
near_join
Source code
( : topologicalType) ( : T) ( : set T) :
  (\near , P x) -> \near , \near , P x.
Proof.
exact: nbhs_interior. Qed.

Lemma
near_bind
Source code
( : topologicalType) ( : set T) ( : T) :
  (\near , (\near , P x) -> Q x) -> (\near , P x) -> \near , Q x.
Proof.
move=> PQ xP; near=> y; apply: (near PQ y) => //;
by apply: (near (near_join xP) y).
Unshelve. all: by end_near. Qed.


Lemma
continuous_cvg
Source code
{ : Type} { : topologicalType}
  ( : set_system T) ( : Filter F)
  ( : T -> V) ( : V -> U) ( : V) :
  {for a, continuous h} ->
  f @ F --> a -> (h \o f) @ F --> h a.
Proof.
move=> h_continuous fa fb; apply: (cvg_trans _ h_continuous).
exact: (cvg_comp _ h fa).
Qed.

Lemma
continuous_is_cvg
Source code
{ : Type} { : ptopologicalType} [ : set_system T]
  ( : Filter F) ( : T -> V) ( : V -> U) :
  (forall , f x @[ --> F] --> l -> {for l, continuous h}) ->
  cvg (f x @[ --> F]) -> cvg ((h \o f) x @[ --> F]).
Proof.
move=> ach /cvg_ex[l fxl]; apply/cvg_ex; exists (h l).
by apply: continuous_cvg => //; exact: ach.
Qed.

Lemma
continuous2_cvg
Source code
{ : Type} { : topologicalType}
  ( : set_system T) ( : Filter F)
  ( : T -> V) ( : T -> W) ( : V -> W -> U) ( : V) ( : W) :
  h z.1 z.2 @[ --> (a, b)] --> h a b ->
  f @ F --> a -> g @ F --> b -> (fun => h (f x) (g x)) @ F --> h a b.
Proof.
move=> h_continuous fa fb; apply: (cvg_trans _ h_continuous).
exact: (cvg_comp _ (fun => h x.1 x.2) (cvg_pair fa fb)).
Qed.

Lemma
cvg_near_cst
Source code
( : Type) ( : topologicalType)
  ( : U) ( : T -> U) ( : set_system T) { : Filter F} :
  (\forall \near F, f x = l) -> f @ F --> l.
Proof.
move=> fFl P /=; rewrite !near_simpl => Pl.
by apply: filterS fFl => _ ->; exact: nbhs_singleton.
Qed.
Arguments cvg_near_cst {T U} l {f F FF}.

Lemma
is_cvg_near_cst
Source code
( : Type) ( : ptopologicalType)
  ( : U) ( : T -> U) ( : set_system T) { : Filter F} :
  (\forall \near F, f x = l) -> cvg (f @ F).
Proof.
by move=> /cvg_near_cst/cvgP. Qed.
Arguments is_cvg_near_cst {T U} l {f F FF}.

Lemma
near_cst_continuous
Source code
( : topologicalType)
  ( : U) ( : T -> U) ( : T) :
  (\forall \near x, f y = l) -> {for x, continuous f}.
Proof.
move=> eq_f_l; apply: cvg_near_cst; apply: filterS (eq_f_l) => y ->.
by rewrite (nbhs_singleton eq_f_l).
Qed.
Arguments near_cst_continuous {T U} l [f x].

Lemma ( : topologicalType) ( : U) ( : Type)
    ( : set_system T) { : Filter F} :
  (fun _ : T => x) @ F --> x.
Proof.
by apply: cvg_near_cst; near=> x0. Unshelve. all: by end_near. Qed.
Arguments cvg_cst {U} x {T F FF}.
#[global] Hint Extern 0 (_ @ _ --> _) => solve [apply: cvg_cst] : core.

Lemma
is_cvg_cst
Source code
( : ptopologicalType) ( : U) ( : Type)
  ( : set_system T) { : Filter F} :
  cvg ((fun _ : T => x) @ F).
Proof.
exact: cvgP (cvg_cst _). Qed.
Arguments is_cvg_cst {U} x {T F FF}.
#[global] Hint Extern 0 (cvg (_ @ _)) => solve [apply: is_cvg_cst] : core.
#[global] Hint Extern 0 (cvgn (_ @ _)) => solve [apply: is_cvg_cst] : core.

Lemma
cst_continuous
Source code
{ : topologicalType} ( : U) :
  continuous (fun _ : T => x).
Proof.
by move=> t; exact: cvg_cst. Qed.

Section within_topologicalType.
Context { : topologicalType} ( : set T).
Implicit Types B : set T.

Lemma
within_nbhsW
Source code
( : T) : A x -> within A (nbhs x) `=>` globally A.
Proof.
move=> Ax P AP; rewrite /within/=; near=> y; apply: AP.
Unshelve. all: by end_near. Qed.

Definition
locally_of

hausdorff_space : topologicalType -> Prop hausdorff_space is not universe polymorphic Arguments hausdorff_space T hausdorff_space is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.hausdorff_space Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 109, characters 11-26 close : forall [T : topologicalType], T -> T -> Prop close is not universe polymorphic Arguments close [T] x y close is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.close Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 315, characters 11-16 normal_space : topologicalType -> Prop normal_space is not universe polymorphic Arguments normal_space T normal_space is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.normal_space Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 479, characters 11-23


Source code
( : set_system T -> Prop) & phantom Prop (P (globally A))
  := forall , A x -> P (within A (nbhs x)).
Local Notation
"[ 'locally' P ]"
Source code
:= (@locally_of _ _ _ (Phantom _ P)).

Lemma
within_interior
Source code
( : T) : A° x -> within A (nbhs x) = nbhs x.
Proof.
move=> Aox; rewrite eqEsubset; split; last exact: cvg_within.
rewrite ?nbhsE => W /= => [[B + BsubW]].
rewrite open_nbhsE => [[oB nbhsB]].
exists (B `&` A°); last by move=> t /= [] /BsubW + /interior_subset; apply.
rewrite open_nbhsE; split; first by apply: openI => //; exact: open_interior.
by apply: filterI => //; have := open_interior A; rewrite openE; exact.
Qed.

Lemma
within_subset
Source code
: Filter F -> A `<=` B -> within A F `=>` within B F.
Proof.
move=> FF AsubB W; rewrite /within/=; apply: filter_app; rewrite nbhs_simpl.
by apply: filterE => ? + ?; apply; exact: AsubB.
Qed.

Lemma : Filter F ->
  within A F = [set | exists2 , F V & U `&` A = V `&` A].
Proof.
move=> FF; rewrite eqEsubset; split=> U.
  move=> Wu; exists [set | A x -> U x] => //.
  by rewrite eqEsubset; split => t [L R]; split=> //; apply: L.
move=> [V FV AU]; rewrite /within /prop_near1 nbhs_simpl/=; near=> w => Aw.
by have []// : (U `&` A) w; rewrite AU; split => //; apply: (near FV).
Unshelve. all: by end_near. Qed.

Lemma
fmap_within_eq
Source code
{ : topologicalType} ( : set_system T) ( : T -> S) :
  Filter F -> {in A, f =1 g} -> f @ within A F --> g @ within A F.
Proof.
move=> FF feq U /=; near_simpl; apply: filter_app.
rewrite ?nbhs_simpl; near_simpl; near=> w; rewrite (feq w) // inE.
exact: (near (withinT A FF) w).
Unshelve. all: by end_near. Qed.

End within_topologicalType.

Notation
"[ 'locally' P ]"
Source code
:= (@locally_of _ _ _ (Phantom _ P)).

Topology defined by a filter

.
Nbhs_isNbhsTopological
Source code
T := {
  nbhs_filter : forall : T, ProperFilter (nbhs p);
  nbhs_singleton : forall ( : T) ( : set T), nbhs p A -> A p;
  nbhs_nbhs : forall ( : T) ( : set T), nbhs p A -> nbhs p (nbhs^~ A);
}.

.
builders
Source code
Context
Source code
Nbhs_isNbhsTopological
Source code
T.

Definition
open_of_nbhs

regular_space : topologicalType -> Prop regular_space is not universe polymorphic Arguments regular_space T regular_space is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.regular_space Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 483, characters 11-24


Source code
:= [set : set T | A `<=` nbhs^~ A].

Let
nbhsE_subproof
Source code
( : T) :
  nbhs p = [set | exists , [/\ open_of_nbhs B, B p & B `<=` A] ].
Proof.
rewrite predeqE => A; split=> [p_A|]; last first.
  move=> [B [Bop Bp sBA]]; apply: filterS sBA _; last exact: Bop.
  exact/nbhs_filter.
exists (nbhs^~ A); split=> //; first by move=> ?; apply: nbhs_nbhs.
by move=> q /nbhs_singleton.
Qed.

Let
openE_subproof
Source code
: open_of_nbhs = [set : set T | A `<=` nbhs^~ A].
Proof.
by []. Qed.

.
instance
Source code
Definition
Source code
Nbhs_isTopological
Source code
.Build T
  nbhs_filter nbhsE_subproof openE_subproof.

..

Topology defined by open sets

Definition
nbhs_of_open

totally_disconnected : forall {T : topologicalType}, set T -> Prop totally_disconnected is not universe polymorphic Arguments totally_disconnected {T} A%_classical_set_scope totally_disconnected is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.totally_disconnected Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 582, characters 11-31


Source code
( : Type) ( : set_system T) ( : T) ( : set T) :=
  exists , [/\ op B, B p & B `<=` A].

.
isOpenTopological
Source code
T := {
  op : set_system T ;
  opT : op setT ;
  opI : setI_closed op ;
  op_bigU : forall ( : Type) ( : I -> set T), (forall , op (f i)) ->
    op (\bigcup_ f i)
}.

.
builders
Source code
Context
Source code
isOpenTopological
Source code
T.

.
instance
Source code
Definition
Source code
hasNbhs
Source code
.Build T (nbhs_of_open op).

Let
nbhs_pfilter_subproof
Source code
( : T) : ProperFilter (nbhs p).
Proof.
apply: Build_ProperFilter_ex.
  by move=> A [B [_ Bp sBA]]; exists p; apply: sBA.
split; first by exists setT; split=> [|//|//]; exact: opT.
  move=> A B [C [Cop Cp sCA]] [D [Dop Dp sDB]].
  exists (C `&` D); split=> //; first exact: opI.
  by move=> q [/sCA Aq /sDB Bq].
move=> A B sAB [C [Cop p_C sCA]].
by exists C; split=> //; apply: subset_trans sAB.
Qed.

Let
nbhsE_subproof
Source code
( : T) :
  nbhs p = [set | exists , [/\ op B, B p & B `<=` A] ].
Proof.
by []. Qed.

Let
openE_subproof
Source code
: op = [set : set T | A `<=` nbhs^~ A].
Proof.
rewrite predeqE => A; split=> [Aop p Ap|Aop].
  by exists A; split=> //; split.
suff -> : A = \bigcup_( : { : set T & op B /\ B `<=` A}) projT1 B.
  by apply: op_bigU => B; have [] := projT2 B.
rewrite predeqE => p; split=> [|[B _ Bp]]; last by have [_] := projT2 B; apply.
by move=> /Aop [B [Bop Bp sBA]]; exists (existT _ B (conj Bop sBA)).
Qed.

.
instance
Source code
Definition
Source code
Nbhs_isTopological
Source code
.Build T
  nbhs_pfilter_subproof nbhsE_subproof openE_subproof.

..

Topology defined by a base of open sets

.
isBaseTopological
Source code
T := {
  I : pointedType ;
  D : set I ;
  b : I -> set T ;
  b_cover : \bigcup_( in D) b i = setT ;
  b_join : forall , D i -> D j -> b i t -> b j t ->
    exists , [/\ D k, b k t & b k `<=` b i `&` b j]
}.

Definition
openU_from

zero_dimensional : topologicalType -> Prop zero_dimensional is not universe polymorphic Arguments zero_dimensional T zero_dimensional is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.zero_dimensional Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 585, characters 11-27 countable_uniform.g_ not a defined object. countable_uniform.distN not a defined object. countable_uniform.n_step_ball not a defined object. countable_uniform.step_ball not a defined object.


Source code
( : set I) ( : I -> set T) :=
  [set \bigcup_( in D') b i | in subset^~ D].

.
builders
Source code
Context
Source code
isBaseTopological
Source code
T.

Local Notation
openU_from
Source code
:= (openU_from D b).

Let
openU_fromT
Source code
: openU_from setT.
Proof.
exists D => //; exact: b_cover. Qed.

Let
openU_fromI
Source code
: setI_closed openU_from.
Proof.
move=> A B [DA sDAD AeUbA] [DB sDBD BeUbB].
have ABU t : (A `&` B) t ->
  exists , [/\ D it, b it t & b it `<=` A `&` B].
  move=> [At Bt].
  have [iA [DiA biAt sbiA]] : exists , [/\ D i, b i t & b i `<=` A].
    move: At; rewrite -AeUbA => - [i DAi bit]; exists i.
    by split => //; [exact: sDAD|exact: bigcup_sup].
  have [iB [DiB biBt sbiB]] : exists , [/\ D i, b i t & b i `<=` B].
    move: Bt; rewrite -BeUbB => - [i DBi bit]; exists i.
    by split=> //; [exact: sDBD|exact: bigcup_sup].
  have [i [Di bit sbiAB]] := b_join DiA DiB biAt biBt.
  by exists i; split=> // s /sbiAB [/sbiA ? /sbiB].
set Dt := fun => [set | [/\ D it, b it t & b it `<=` A `&` B]].
exists [set get (Dt t) | in A `&` B].
  by move=> _ [t ABt <-]; have /ABU/getPex [] := ABt.
rewrite predeqE => t; split=> [[_ [s ABs <-] bDtst]|ABt].
  by have /ABU/getPex [_ _] := ABs; exact.
by exists (get (Dt t)); [exists t| have /ABU/getPex [?]:= ABt].
Qed.

Let
openU_from_bigU
Source code
( : Type) ( : I0 -> set T) :
  (forall , openU_from (f i)) -> openU_from (\bigcup_ f i).
Proof.
set fop := fun => [set | Dj `<=` D /\ f j = \bigcup_( in Dj) b i].
exists (\bigcup_ get (fop j)).
  move=> i [j _ fopji].
  suff /getPex [/(_ _ fopji)] : exists , fop j Dj by [].
  by have [Dj] := H j; exists Dj.
rewrite predeqE => t; split=> [[i [j _ fopji bit]]|[j _]].
  exists j => //; suff /getPex [_ ->] : exists , fop j Dj by exists i.
  by have [Dj] := H j; exists Dj.
have /getPex [_ ->] : exists , fop j Dj by have [Dj] := H j; exists Dj.
by move=> [i]; exists i => //; exists j.
Qed.

.
instance
Source code
Definition
Source code
isOpenTopological
Source code
.Build T
  openU_fromT openU_fromI openU_from_bigU.

..

#[deprecated(since="mathcomp-analysis 1.17.0", use=openU_from)]
Notation
open_from
Source code
:= openU_from (only parsing).

.
isSubBaseTopological
Source code
T := {
  I : pointedType ;
  D : set I ;
  b : I -> set T
}.

.
builders
Source code
Context
Source code
isSubBaseTopological
Source code
T.

Local Notation
finI_from
Source code
:= (open_finI_from D b).

Let
finI_from_cover
Source code
: \bigcup_( in finI_from) A = setT.
Proof.
rewrite predeqE => t; split=> // _; exists setT => //.
by exists fset0 => //; rewrite predeqE.
Qed.

Let
finI_from_join
Source code
: finI_from A -> finI_from B -> A t -> B t ->
  exists , [/\ finI_from k, k t & k `<=` A `&` B].
Proof.
move=> [DA sDAD AeIbA] [DB sDBD BeIbB] At Bt.
exists (A `&` B); split => //.
exists (DA `|` DB)%fset; first by move=> i /fsetUP [/sDAD|/sDBD].
rewrite predeqE => s; split=> [Ifs|[As Bs] i /fsetUP].
  split; first by rewrite -AeIbA => i DAi; apply: Ifs; rewrite /= inE DAi.
  by rewrite -BeIbB => i DBi; apply: Ifs; rewrite /= inE DBi orbC.
by move=> [DAi|DBi];
  [have := As; rewrite -AeIbA; apply|have := Bs; rewrite -BeIbB; apply].
Qed.

.
instance
Source code
Definition
Source code
isBaseTopological
Source code
.Build T
  finI_from_cover finI_from_join.

..

deleted neighborhood

Definition
dnbhs

countable_uniform.type : forall {T : uniformType}, countable_uniformity T -> Type countable_uniform.type is not universe polymorphic Arguments countable_uniform.type {T} cnt_unif countable_uniform.type is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.countable_uniform.type Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 958, characters 11-15


Source code
{ : topologicalType} ( : T) :=
  within (fun => y != x) (nbhs x).
Notation := (dnbhs x) : classical_set_scope.

Lemma
nbhs_dnbhs_neq
Source code
{ : topologicalType} ( : T) :
  \forall \near nbhs p^', x != p.
Proof.
exact: withinT. Qed.

Lemma
nbhs_dnbhs
Source code
{ : topologicalType} ( : T) : x^' `=>` nbhs x.
Proof.
exact: cvg_within. Qed.

Lemma ( : topologicalType) ( : T) :
  nbhs x = x^' `&` principal_filter x.
Proof.
rewrite predeqE => A; split=> [x_A|[+ Ax]].
  by split; [exact: nbhs_dnbhs|apply/principal_filterP; exact: nbhs_singleton].
rewrite /dnbhs !nbhsE => -[B [oB x_B sBA]]; exists B => //.
by move=> y /sBA Ay; case: (eqVneq y x) => [->|//]; exact/principal_filterP.
Qed.

Global Instance
dnbhs_filter
Source code
{ : topologicalType} ( : T) : Filter x^'.
Proof.
exact: within_filter. Qed.
#[global] Typeclasses Opaque dnbhs.

Canonical
dnbhs_filter_on

sup_pseudometric : forall [R : realType] [T Ii : Type], (Ii -> PseudoMetric.axioms_ R T) -> countable (T:=Ii) [set: Ii] -> Type sup_pseudometric is not universe polymorphic Arguments sup_pseudometric [R] [T Ii]%_type_scope Tc%_function_scope Icnt sup_pseudometric is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.sup_pseudometric Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 981, characters 11-27


Source code
( : topologicalType) ( : T) :=
  FilterType x^' (dnbhs_filter _).

Lemma
cvg_fmap2
Source code
( : Type) ( : T -> U):
  forall ( : set_system T), G `=>` F -> f @ G `=>` f @ F.
Proof.
by move=> F G H A fFA ; exact: H (preimage f A) fFA. Qed.

Lemma
cvg_within_filter
Source code
{ } { : T -> U} ( : set_system T) { : (Filter F) }
  ( : set_system U) ( : set T) : (f @ F) --> G -> (f @ within D F) --> G.
Proof.
exact: cvg_trans (cvg_fmap2 (cvg_within _)). Qed.

Lemma
cvg_app_within
Source code
{} { : ptopologicalType} ( : T -> U) ( : set_system T)
  ( : set T): Filter F -> cvg (f @ F) -> cvg (f @ within D F).
Proof.
by move => FF /cvg_ex [l H]; apply/cvg_ex; exists l; exact: cvg_within_filter.
Qed.

meets

Lemma
meets_openr
Source code
{ : topologicalType} ( : set_system T) ( : T) :
  F `#` nbhs x = F `#` open_nbhs x.
Proof.
rewrite propeqE; split; [exact/meetsSr/open_nbhs_nbhs|].
by move=> P A B {}/P P; rewrite nbhsE => -[B' /P + sB]; apply: subsetI_neq0.
Qed.

Lemma
meets_openl
Source code
{ : topologicalType} ( : set_system T) ( : T) :
  nbhs x `#` F = open_nbhs x `#` F.
Proof.
by rewrite meetsC meets_openr meetsC. Qed.
Closed sets in topological spaces

Section Closed.
Context { : topologicalType}.

Definition
closure

gauge.gauge : forall {T : uniformType}, set (T * T) -> set_system (T * T) gauge.gauge is not universe polymorphic Arguments gauge.gauge {T} E%_classical_set_scope _ gauge.gauge is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.gauge.gauge Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 1012, characters 11-16


Source code
( : set T) :=
  [set : T | forall , nbhs p B -> A `&` B !=set0].

Lemma
closureEnbhs
Source code
: closure A = [set | globally A `#` nbhs p].
Proof.
by under eq_fun do rewrite meets_globallyl. Qed.

Lemma
closureEonbhs
Source code
: closure A = [set | globally A `#` open_nbhs p].
Proof.
by under eq_fun do rewrite -meets_openr meets_globallyl. Qed.

Lemma
subset_closure
Source code
( : set T) : A `<=` closure A.
Proof.
by move=> p ??; exists p; split=> //; apply: nbhs_singleton. Qed.

Lemma
closure_eq0
Source code
( : set T) : closure A = set0 -> A = set0.
Proof.
by move=> A0; apply/seteqP; split => //; rewrite -A0; exact: subset_closure.
Qed.

Lemma
closureI
Source code
( : set T) : closure (A `&` B) `<=` closure A `&` closure B.
Proof.
by move=> p clABp; split=> ? /clABp [q [[]]]; exists q. Qed.

Definition
limit_point

gauge.type : forall {T : uniformType} [E : set (T * T)], entourage E -> Type gauge.type is not universe polymorphic Arguments gauge.type {T} [E]%_classical_set_scope entE gauge.type is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.gauge.type Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 1071, characters 11-15


Source code
:= [set : T |
  forall , nbhs t U -> exists , [/\ y != t, E y & U y]].

Lemma
limit_pointEnbhs
Source code
:
  limit_point E = [set | globally (E `\ p) `#` nbhs p].
Proof.
under eq_fun do rewrite meets_globallyl; rewrite funeqE => p /=.
apply/eq2_forall => x px; apply/eq_exists => y.
by rewrite propeqE; split => [[/eqP ? ?]|[[? /eqP ?]]]; do 2?split.
Qed.

Lemma
limit_pointEonbhs
Source code
:
  limit_point E = [set | globally (E `\ p) `#` open_nbhs p].
Proof.
by rewrite limit_pointEnbhs; under eq_fun do rewrite meets_openr. Qed.

Lemma
subset_limit_point
Source code
: limit_point E `<=` closure E.
Proof.
by move=> t Et U tU; have [p [? ? ?]] := Et _ tU; exists p. Qed.

Lemma
not_limit_pointE
Source code
: (~ limit_point A a) =
  exists2 : set T, nbhs a X & A `&` X `<=` [set a].
Proof.
rewrite /limit_point/= -existsNE exists2E; apply: eq_exists => X/=.
rewrite not_implyE -forallNE; congr and; apply: eq_forall => t/=.
rewrite and3E not_andE (propext (rwP negP)) negbK implyE orC.
by rewrite -(propext (rwP eqP)).
Qed.

Definition
isolated

perfect_set : forall {T : topologicalType}, set T -> Prop perfect_set is not universe polymorphic Arguments perfect_set {T} A%_classical_set_scope perfect_set is transparent Expands to: Constant mathcomp.analysis.topology_theory.separation_axioms.perfect_set Declared in library mathcomp.analysis.topology_theory.separation_axioms, line 1099, characters 11-22


Source code
( : set T) ( : T) :=
  x \in A /\ exists2 , nbhs x V & V `&` A = [set x].

Lemma
isolatedS
Source code
( : set T) : isolated A `<=` A.
Proof.
by move=> x [/set_mem]. Qed.

Lemma
disjoint_isolated_limit_point
Source code
( : set T) :
  [disjoint isolated A & limit_point A].
Proof.
apply/disj_setPS => t [[At [V tV]]] /[swap].
move/(_ _ tV) => [x [xt Ax Vx]].
have /[swap] -> : [set x] `<=` V `&` A by move=> ? ->; split.
move/subset_set1 => [/seteqP[/(_ _ erefl)//]|].
by move=> /seteqP[_ /(_ _ erefl)/=]; apply/eqP; rewrite eq_sym.
Qed.

Lemma
closure_isolated_limit_point
Source code
( : set T) :
  closure A = isolated A `|` limit_point A.
Proof.
apply/seteqP; split=> [t At0|t [|]].
- rewrite /setU/= -implyNp => /not_andP[tA U /At0[x [Ux Ax]]|+ U tU].
    by exists x; split => //; contra: tA => <-; exact/mem_set.
  move/forall2NP => /(_ U)[//|/seteqP/not_andP[|]].
    by contra => H x [Ux Ax]; apply/eqP/negPn/negP => /H /(_ Ax).
  have [At tUA|At _] := pselect (A t).
    by absurd: tUA => _ ->; split => //; exact: nbhs_singleton.
  have [x [Ax Ux]] := At0 _ tU.
  by exists x; split => //; contra: At => <-.
- by move/isolatedS; exact: subset_closure.
- exact: subset_limit_point.
Qed.

Lemma
__deprecated__closure_limit_point
Source code
: closure E = E `|` limit_point E.
Proof.
apply/seteqP; split => [|x]; last first.
  by case; [exact: subset_closure|exact: subset_limit_point].
by rewrite closure_isolated_limit_point => x [/isolatedS|]; [left|right].
Qed.

Definition ( : set T) := closure D `<=` D.

Lemma
open_closedC
Source code
( : set T) : open D -> closed (~` D).
Proof.
by rewrite openE => Dop p clNDp /Dop /clNDp [? []]. Qed.

Lemma
closed_bigI
Source code
{} ( : set I) ( : I -> set T) :
  (forall , D i -> closed (f i)) -> closed (\bigcap_( in D) f i).
Proof.
move=> fcl t clft i Di; have /fcl := Di; apply.
by move=> A /clft [s [/(_ i Di)]]; exists s.
Qed.

Lemma : setI_closed closed.
Proof.
by move=> D E Dcl Ecl p clDEp; split; [apply: Dcl|apply: Ecl];
  move=> A /clDEp [q [[]]]; exists q.
Qed.

Lemma : closed setT
Proof.
by []. Qed.

Lemma : closed set0.
Proof.
by move=> ? /(_ setT) [|? []] //; apply: filterT. Qed.

Lemma : closed = [set : set T | forall , ~ (\near , ~ A p) -> A p].
Proof.
rewrite predeqE => A; split=> Acl p; last first.
  by move=> clAp; apply: Acl; rewrite -nbhs_nearE => /clAp [? []].
rewrite -nbhs_nearE nbhsE => /asboolP.
rewrite asbool_neg => /forallp_asboolPn2 clAp.
apply: Acl => B; rewrite nbhsE => - [C [oC pC]].
have /asboolP := clAp C.
rewrite asbool_or 2!asbool_neg => /orP[/asboolP/not_andP[]//|/existsp_asboolPn [q]].
move/asboolP; rewrite asbool_neg => /imply_asboolPn[+ /contrapT Aq sCB] => /sCB.
by exists q.
Qed.

Lemma
closed_openC
Source code
( : set T) : closed D -> open (~` D).
Proof.
rewrite closedE openE => Dcl t nDt; apply: contrapT.
by rewrite /interior nbhs_nearE => /Dcl.
Qed.

Lemma ( : set T) : closed (~` D) = open D.
Proof.
by apply/propext; split=> [/closed_openC|]; [rewrite setCK|exact: open_closedC].
Qed.

Lemma ( : set T) : open (~` D) = closed D.
Proof.
by rewrite -closedC setCK. Qed.

Lemma
closed_closure
Source code
( : set T) : closed (closure A).
Proof.
by move=> p clclAp B /nbhs_interior /clclAp [q [clAq /clAq]]. Qed.

End Closed.
#[deprecated(since="mathcomp-analysis 1.15.0", note="use `closure_isolated_limit_point` instead")]
Notation
closure_limit_point
Source code
:= __deprecated__closure_limit_point (only parsing).

Lemma
preimage_closed
Source code
{ : topologicalType} ( : T -> U) ( : set U) :
  {in ~` f @^-1` D, continuous f} -> closed D -> closed (f @^-1` D).
Proof.
rewrite !closedE=> f_continuous D_cl x /= xDf.
apply: D_cl; apply: contra_not xDf => fxD.
have NDfx : ~ D (f x).
  by move: fxD; rewrite -nbhs_nearE nbhsE => - [A [? ?]]; exact.
by apply: f_continuous fxD; rewrite inE.
Qed.
#[deprecated(since="mathcomp-analysis 1.16.0", note="renamed to `preimage_closed`")]
Notation
closed_comp
Source code
:= preimage_closed (only parsing).

Lemma
closed_cvg
Source code
{} { : topologicalType} {} { : ProperFilter F}
    ( : T -> V) ( : V -> Prop) :
    closed A -> (\forall \near F, A (u_ n)) ->
  forall , u_ @ F --> l -> A l.
Proof.
move=> + FAu_ l u_Fl; apply => B /u_Fl /=; rewrite nbhs_filterE.
by move=> /(filterI FAu_) => /filter_ex[t [Au_t u_Bt]]; exists (u_ t).
Qed.
Arguments closed_cvg {T V F FF u_} _ _ _ _ _.

Lemma
continuous_closedP
Source code
( : topologicalType) ( : S -> T) :
  continuous f <-> forall , closed A -> closed (f @^-1` A).
Proof.
rewrite continuousP; split=> ctsf ? ?.
  by rewrite -openC preimage_setC; apply: ctsf; rewrite openC.
by rewrite -closedC preimage_setC; apply: ctsf; rewrite closedC.
Qed.

Lemma ( : topologicalType) : setU_closed (@closed T).
Proof.
by move=> E D; rewrite -?openC setCU; exact: openI. Qed.

Lemma
bigsetU_closed
Source code
{ : topologicalType} { : eqType} ( : seq I)
    ( : I -> set T) : (forall , x \in s -> closed (F x)) ->
  closed (\big[setU/set0]_( <- s) F x).
Proof.
move=> scF; rewrite big_seq.
by elim/big_ind : _ => //; [exact: closed0|exact: closedU].
Qed.
#[deprecated(since="mathcomp-analysis 1.17.0", use=bigsetU_closed)]
Notation
closed_bigsetU
Source code
:= bigsetU_closed (only parsing).

Lemma
bigcup_closed
Source code
{ : topologicalType} { : choiceType} ( : set I)
    ( : I -> set T) :
    finite_set A -> (forall , A i -> closed (F i)) ->
  closed (\bigcup_( in A) F i).
Proof.
move=> finA cF; rewrite -bigsetU_fset_set//; apply: bigsetU_closed => i.
by rewrite in_fset_set// inE; exact: cF.
Qed.
#[deprecated(since="mathcomp-analysis 1.17.0", use=bigcup_closed)]
Notation
closed_bigcup
Source code
:= bigcup_closed (only parsing).

Section closure_lemmas.
Context { : topologicalType}.
Implicit Types E A B U : set T.

Lemma
closureS
Source code
: A `<=` B -> closure A `<=` closure B.
Proof.
by move=> ? ? CAx ?; move/CAx; exact/subsetI_neq0. Qed.

#[deprecated(since="mathcomp-analysis 1.16.0", note="Use `closureS` instead.")]
Definition
closure_subset
Source code
:= closureS.

Lemma
closureE
Source code
: closure A = smallest closed A.
Proof.
rewrite eqEsubset; split=> [x ? B [cB AB]|]; first exact/cB/(closureS AB).
by apply: smallest_sub; [exact: closed_closure|exact: subset_closure].
Qed.

Lemma
closure_id
Source code
: closed E <-> E = closure E.
Proof.
split=> [?|->]; last exact: closed_closure.
by rewrite eqEsubset; split => //; exact: subset_closure.
Qed.

End closure_lemmas.

Section regular_open_closed.
Variable : topologicalType.

Definition ( : set T) := (closure A)° = A.

Definition
regclosed
Source code
( : set T) := closure (A°) = A.

End regular_open_closed.

Section closure_interior_lemmas.
Variable : topologicalType.
Implicit Types (A B : set T).

Lemma
interiorC
Source code
: (~` A)° = ~` closure A.
Proof.
rewrite eqEsubset; split=> x; rewrite /closure /interior nbhsE /= -existsNE.
  case=> U ? /disjoints_subset UA; exists U; rewrite not_implyE.
  split; first exact/open_nbhs_nbhs.
  by rewrite setIC UA; apply/set0P; rewrite eqxx.
case=> X; rewrite not_implyE nbhsE=> -[] -[] U xU UX AX0.
exists U => //; apply/(subset_trans UX)/disjoints_subset; rewrite setIC.
exact/eqP/negbNE/negP/set0P.
Qed.

Lemma
closureC
Source code
: closure (~` A) = ~` A°.
Proof.
by apply: setC_inj; rewrite -interiorC !setCK. Qed.

Lemma
interiorS
Source code
: A `<=` B -> A° `<=` B°.
Proof.
move=> AB x.
rewrite /interior nbhsE => -[] U oxU UA.
exists U => //; move: UA AB; exact: subset_trans.
Qed.

Lemma
interior_id
Source code
: open A <-> interior A = A.
Proof.
by rewrite -(setCK A) openC interiorC closure_id; split => [ <- | /setC_inj->].
Qed.

Lemma
closureT
Source code
: closure [set: T] = [set: T].
Proof.
exact/esym/closure_id/closedT. Qed.

Lemma
closure0
Source code
: closure (@set0 T) = set0.
Proof.
exact/esym/closure_id/closed0. Qed.

Lemma
interiorT
Source code
: (@setT T)° = setT.
Proof.
exact/interior_id/openT. Qed.

Lemma
interior0
Source code
: (@set0 T)° = set0.
Proof.
exact/interior_id/open0. Qed.

Lemma
closureU
Source code
: closure (A `|` B) = closure A `|` closure B.
Proof.
by apply: setC_inj; rewrite setCU -!interiorC -interiorI setCU. Qed.

Lemma
interiorU
Source code
: A° `|` B° `<=` (A `|` B)°.
Proof.
by apply: subsetC2; rewrite setCU -!closureC setCU; exact: closureI. Qed.

Lemma
closureEbigcap
Source code
:
  closure A = \bigcap_( in [set | closed C /\ A `<=` C]) x.
Proof.
exact: closureE. Qed.

Lemma
interiorEbigcup
Source code
: A° = \bigcup_( in [set | open U /\ U `<=` A]) x.
Proof.
apply: setC_inj; rewrite -closureC closureEbigcap setC_bigcup.
rewrite -[RHS](bigcap_image _ setC idfun) /=.
apply: eq_bigcapl; split => X /=.
  by rewrite -openC -setCS setCK; exists (~` X)=> //; rewrite setCK.
by case=> Y + <-; rewrite closedC setCS.
Qed.

Lemma
interior_closed_regopen
Source code
: closed A -> regopen A°.
Proof.
move=> cA; rewrite /regopen eqEsubset; split=> x.
  rewrite /closure [X in X -> _]/interior nbhsE => -[] U oxU UciA.
  rewrite /interior nbhsE /=; exists U => //.
  apply: (subset_trans UciA) => y /= yA.
  apply: cA => B /yA; apply/subset_nonempty; apply: setSI.
  exact: interior_subset.
rewrite {1}/interior nbhsE=> -[] U [] oU Ux UA.
rewrite {1}/interior nbhsE /=; exists U=> //.
have:= UA; rewrite open_subsetE// => /subset_trans; apply.
exact: subset_closure.
Qed.

Lemma
closure_open_regclosed
Source code
: open A -> regclosed (closure A).
Proof.
rewrite /regclosed -(setCK A) openC => cCA.
by rewrite closureC -[in RHS]interior_closed_regopen// !(closureC, interiorC).
Qed.

Lemma
interior_closure_idem
Source code
: @idempotent_fun (set T) (interior \o closure).
Proof.

Lemma
closure_interior_idem
Source code
: @idempotent_fun (set T) (closure \o interior).
Proof.
move=> ?; exact/closure_open_regclosed/open_interior. Qed.

End closure_interior_lemmas.
#[deprecated(since="mathcomp-analysis 1.17.0", note="renamed to `closureC`")]
Notation
closure_setC
Source code
:= closureC (only parsing).

Definition ( : topologicalType) ( : set T) :=
  forall ( : set T), O !=set0 -> open O -> O `&` S !=set0.

Lemma ( : topologicalType) ( : set T) : ~ dense S ->
  exists , (exists , open_nbhs x O) /\ (O `&` S = set0).
Proof.
rewrite /dense /open_nbhs.
move=> /existsNP[X /not_implyP[[x Xx] /not_implyP[ Ox /forallNP A]]].
by exists X; split; [exists x | rewrite -subset0; apply/A].
Qed.

Lemma ( : topologicalType) ( : set T) :
  open A -> dense A -> dense B -> dense (A `&` B).
Proof.
move=> oA dA dB C C0 oC.
have CA0 : C `&` A !=set0 by exact: dA.
suff: (C `&` A) `&` B !=set0 by rewrite setIA.
by apply: dB => //; exact: openI.
Qed.

Lemma { : ptopologicalType} : ~ dense (@set0 R).
Proof.
apply/existsNP; exists setT.
apply/not_implyP; split; first exact/set0P/setT0.
apply/not_implyP; split; first exact: openT.
by rewrite setTI => -[].
Qed.

Section ClopenSets.
Implicit Type T : topologicalType.

Definition {} ( : set T) := open A /\ closed A.

Lemma {} : setI_closed (@clopen T).
Proof.
by move=> ? ? [] ? ? [] ? ?; split; [exact: openI|exact: closedI]. Qed.

Lemma {} : setU_closed (@clopen T).
Proof.
by move=> ? ? [] ? ? [] ? ?; split; [exact: openU|exact: closedU]. Qed.

Lemma {} ( : set T) : clopen A -> clopen (~`A).
Proof.
by case=> ? ?; split;[exact: closed_openC | exact: open_closedC ]. Qed.

Lemma {} : @clopen T set0.
Proof.
by split; [exact: open0 | exact: closed0]. Qed.

Lemma {} : clopen [set: T].
Proof.
by split; [exact: openT | exact: closedT]. Qed.

Lemma
preimage_clopen
Source code
{ : topologicalType} ( : T -> U) ( : set U) :
 clopen A -> continuous f -> clopen (f @^-1` A).
Proof.
by case=> ? ?; split; [ exact: open_comp | exact: preimage_closed]. Qed.

End ClopenSets.
#[deprecated(since="mathcomp-analysis 1.16.0", note="renamed to `preimage_clopen`")]
Notation
clopen_comp
Source code
:= preimage_clopen (only parsing).

.
isContinuous
Source code
nbhsType}
Source code
(f : X -> Y):= {
  continuous_fun : continuous f
}.

(
"continuousType"
Source code
)
.
structure
Source code
Definition
Source code
Continuous
Source code
nbhsType}
Source code
:= {
   of @isContinuous X Y f
}.

#[deprecated(since="mathcomp-analysis 1.17.0",
             note="use `continuous_fun` instead")]
Notation := (continuous_fun) (only parsing).

.
instance
Source code
Definition
Source code
topologicalType}
Source code
:=
  gen_eqMixin (continuousType X Y).
.
instance
Source code
Definition
Source code
topologicalType}
Source code
:=
  gen_choiceMixin (continuousType X Y).

Lemma
continuousEP
Source code
{ : nbhsType} ( : continuousType X Y) :
  f = g <-> f =1 g.
Proof.
case: f g => [f [[ffun]]] [g [[gfun]]]/=; split=> [[->//]|/funext eqfg].
rewrite eqfg in ffun *; congr {| Continuous.sort := _; Continuous.class := {|
  Continuous.topology_structure_isContinuous_mixin :=
    {|isContinuous.continuous_fun := _|}|}|}.
exact: Prop_irrelevance.
Qed.

Definition { : nbhsType} ( : X -> Y) ( : continuous f) := f.

.
instance
Source code
Definition
Source code
nbhsType}
Source code
(f: X -> Y) (f_cts : continuous f) :=
  @isContinuous.Build X Y (mkcts f_cts) f_cts.

Section continuous_comp.
Context { : topologicalType}.
Context ( : continuousType X Y) ( : continuousType Y Z).

#[local] Lemma
cts_fun_comp
Source code
: continuous (g \o f).
Proof.
move=> x; apply: continuous_comp; exact: continuous_fun. Qed.

.
instance
Source code
Definition
Source code
@isContinuous
Source code
.Build X Z (g \o f) cts_fun_comp.

End continuous_comp.

Section continuous_id.
Context { : topologicalType}.

#[local] Lemma : continuous (@idfun X).
Proof.
by move=> ?. Qed.

.
instance
Source code
Definition
Source code
@isContinuous
Source code
.Build X X (@idfun X) cts_id.

End continuous_id.

Section continuous_const.
Context { : topologicalType} ( : Y).

#[local] Lemma
cts_const
Source code
: continuous (@cst X Y y).
Proof.
by move=> x; exact: cvg_cst. Qed.

.
instance
Source code
Definition
Source code
@isContinuous
Source code
.Build X Y (cst y) cts_const.

End continuous_const.