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
.mixin
Source code
Source code
Record
Source code
Source code
Nbhs_isTopological
Source code
(Source code
Type
Source code
)Source code
Nbhs
Source code
T := {Source code
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 ]
}.
#[short
Source code
(Source code
type=
Source code
Source code
"topologicalType"
Source code
)Source code
.
structure
Source code
Source code
Definition
Source code
Source code
Topological
Source code
Source code
{ of Nbhs T & Nbhs_isTopological T}.
#[short
Source code
(Source code
type=
Source code
Source code
"ptopologicalType"
Source code
)Source code
.
structure
Source code
Source code
Definition
Source code
Source code
PointedTopological
Source code
Source code
{ of PointedNbhs T & Nbhs_isTopological T}.
#[short
Source code
(Source code
type=
Source code
Source code
"bpTopologicalType"
Source code
)Source code
.
structure
Source code
Source code
Definition
Source code
Source code
BiPointedTopological
Source code
Source code
{ of BiPointed X & Topological X }.
#[short
Source code
(Source code
type=
Source code
Source code
"subTopologicalType"
Source code
)Source code
.
structure
Source code
Source code
Definition
Source code
Source code
SubTopological
Source code
(Source code
topologicalType
Source code
)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.at_left : forall {R : numFieldType}, R -> set_system R at_left is not universe polymorphic Arguments at_left {R} x%_ring_scope _ at_left is transparent Expands to: Constant mathcomp.analysis.topology_theory.num_topology.at_left Declared in library mathcomp.analysis.topology_theory.num_topology, line 219, characters 11-18
Source code
Definition
basis
Source code
( : set_system T) :=at_right : forall {R : numFieldType}, R -> set_system R at_right is not universe polymorphic Arguments at_right {R} x%_ring_scope _ at_right is transparent Expands to: Constant mathcomp.analysis.topology_theory.num_topology.at_right Declared in library mathcomp.analysis.topology_theory.num_topology, line 220, characters 11-19
Source code
B `<=` open /\ forall , filter_from [set | B U /\ U x] id --> x.
Definition
second_countable
Source code
:= exists2 , countable B & basis B.Source code
Global Instance
nbhs_pfilter
Source code
( : T) : ProperFilter (nbhs p).Source code
Proof.
Lemma
nbhs_filter
Source code
( : T) : Filter (nbhs p).Source code
Proof.
Canonical
nbhs_filter_on
Source code
( : T) := FilterType (nbhs x) (@nbhs_filter x).Source code
Lemma
nbhsE
Source code
( : T) :Source code
nbhs p = [set : set T | exists2 : set T, open_nbhs p B & B `<=` A].
Proof.
Lemma
open_nbhsE
Source code
( : T) ( : set T) : open_nbhs p A = (open A /\ nbhs p A).Source code
Proof.
Definition
interior
Source code
( : set T) := (@nbhs _ T)^~ A.Source code
Local Notation
"A °"
Source code
:= (interior A).Source code
Lemma
interior_subset
Source code
( : set T) : A° `<=` A.Source code
Lemma
openE
Source code
: open = [set : set T | A `<=` A°].Source code
Proof.
Lemma
nbhs_singleton
Source code
( : T) ( : set T) : nbhs p A -> A p.Source code
Proof.
Lemma
nbhs_interior
Source code
( : T) ( : set T) : nbhs p A -> nbhs p A°.Source code
Proof.
Lemma
open0
Source code
: open (set0 : set T).Source code
Proof.
Lemma
openT
Source code
: open (setT : set T).Source code
Lemma
openI
Source code
: setI_closed (@open T).Source code
Proof.
Lemma
bigcup_open
Source code
( : Type) ( : set I) ( : I -> set T) :Source code
(forall , D i -> open (f i)) -> open (\bigcup_( in D) f i).
Proof.
Lemma
openU
Source code
: setU_closed (@open T).Source code
Lemma
open_subsetE
Source code
( : set T) : open A -> (A `<=` B) = (A `<=` B°).Source code
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.
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°.Source code
Proof.
rewrite openE => p; rewrite /interior nbhsE => - [B [Bop Bp]].
by rewrite open_subsetE //; exists B.
Qed.
by rewrite open_subsetE //; exists B.
Qed.
Lemma
interior_bigcup
Source code
( : set I) ( : I -> set T) :Source code
\bigcup_( in D) (f i)° `<=` (\bigcup_( in D) f i)°.
Proof.
Lemma
open_nbhsT
Source code
( : T) : open_nbhs p setT.Source code
Proof.
Lemma
open_nbhsI
Source code
( : T) : setI_closed (open_nbhs p).Source code
Proof.
Lemma
open_nbhs_nbhs
Source code
( : T) ( : set T) : open_nbhs p A -> nbhs p A.Source code
Proof.
Lemma
interiorI
Source code
( : set T) : (A `&` B)° = A° `&` B°.Source code
Proof.
End Topological1.
Lemma
open_in_nearW
Source code
{ : topologicalType} ( : T -> Prop) ( : set T) :Source code
open S -> {in S, forall , P x} -> {in S, forall , \near , P x}.
Proof.
#[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} :Source code
@Filter T^o (@nbhs T^o T x).
Proof.
Global Instance
alias_nbhs_pfilter
Source code
{ : topologicalType} :Source code
@ProperFilter T^o (@nbhs T^o T x).
Proof.
Reserved Notation "A ^°" (at level 1, format "A ^°").
Notation
"A °"
Source code
:= (interior A) : classical_set_scope.Source code
#[deprecated(since="mathcomp-analysis 1.10.0", note="use the notation instead ° instead of ^°")]
Notation
"A ^°"
Source code
:= (A°) (only parsing).Source code
Lemma
continuousP
Source code
( : topologicalType) ( : S -> T) :Source code
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.
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) :Source code
{in f @^-1` D, continuous f} -> open D -> open (f @^-1` D).
Lemma
cvg_fmap
Source code
{: topologicalType} { : topologicalType}Source code
( : 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) :Source code
(\near , P x) -> \near , \near , P x.
Proof.
Lemma
near_bind
Source code
( : topologicalType) ( : set T) ( : T) :Source code
(\near , (\near , P x) -> Q x) -> (\near , P x) -> \near , Q x.
Proof.
Lemma
continuous_cvg
Source code
{ : Type} { : topologicalType}Source code
( : set_system T) ( : Filter F)
( : T -> V) ( : V -> U) ( : V) :
{for a, continuous h} ->
f @ F --> a -> (h \o f) @ F --> h a.
Lemma
continuous_is_cvg
Source code
{ : Type} { : ptopologicalType} [ : set_system T]Source code
( : 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.
by apply: continuous_cvg => //; exact: ach.
Qed.
Lemma
continuous2_cvg
Source code
{ : Type} { : topologicalType}Source code
( : 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.
Lemma
continuous_comp_cvg
Source code
{ : topologicalType}Source code
( : T -> V) ( : V -> U) ( : T) ( : U) :
{for f r, continuous h} ->
(h \o f) x @[ --> r] --> l -> h x @[ --> f r] --> l.
Proof.
Lemma
cvg_near_cst
Source code
( : Type) ( : topologicalType)Source code
( : 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.
by apply: filterS fFl => _ ->; exact: nbhs_singleton.
Qed.
Lemma
is_cvg_near_cst
Source code
( : Type) ( : ptopologicalType)Source code
( : U) ( : T -> U) ( : set_system T) { : Filter F} :
(\forall \near F, f x = l) -> cvg (f @ F).
Proof.
Lemma
near_cst_continuous
Source code
( : topologicalType)Source code
( : 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.
by rewrite (nbhs_singleton eq_f_l).
Qed.
Lemma
cvg_cst
Source code
( : topologicalType) ( : U) ( : Type)Source code
( : set_system T) { : Filter F} :
(fun _ : T => x) @ F --> x.
Proof.
#[global] Hint Extern 0 (_ @ _ --> _) => solve [apply: cvg_cst] : core.
Lemma
is_cvg_cst
Source code
( : ptopologicalType) ( : U) ( : Type)Source code
( : set_system T) { : Filter F} :
cvg ((fun _ : T => x) @ F).
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) :Source code
continuous (fun _ : T => x).
Proof.
Lemma
id_continuous
Source code
{ : topologicalType} : continuous (@id T).Source code
Proof.
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.Source code
Proof.
Definition
locally_of
Source code
( : set_system T -> Prop) & phantom Prop (P (globally A))Source code
:= forall , A x -> P (within A (nbhs x)).
Local Notation
"[ 'locally' P ]"
Source code
:= (@locally_of _ _ _ (Phantom _ P)).Source code
Lemma
within_interior
Source code
( : T) : A° x -> within A (nbhs x) = nbhs x.Source code
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.
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.Source code
Proof.
move=> FF AsubB W; rewrite /within/=; apply: filter_app; rewrite nbhs_simpl.
by apply: filterE => ? + ?; apply; exact: AsubB.
Qed.
by apply: filterE => ? + ?; apply; exact: AsubB.
Qed.
Lemma
withinE
Source code
: Filter F ->Source code
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.
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) :Source code
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.
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)).Source code
Topology defined by a filter
.
factory
Source code
Source code
Record
Source code
Source code
Nbhs_isNbhsTopological
Source code
Source code
Nbhs
Source code
T := {Source code
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
Source code
Context
Source code
Source code
Nbhs_isNbhsTopological
Source code
T.Source code
Definition
open_of_nbhs
Source code
:= [set : set T | A `<=` nbhs^~ A].Source code
Let
nbhsE_subproof
Source code
( : T) :Source code
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.
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].Source code
Proof.
by []. Qed.
.
instance
Source code
Source code
Definition
Source code
Source code
Nbhs_isTopological
Source code
.Build TSource code
nbhs_filter nbhsE_subproof openE_subproof.
.
end
Source code
.Source code
Topology defined by open sets
Definition
nbhs_of_open
Source code
( : Type) ( : set_system T) ( : T) ( : set T) :=Source code
exists , [/\ op B, B p & B `<=` A].
.
factory
Source code
Source code
Record
Source code
Source code
isOpenTopological
Source code
Source code
Choice
Source code
T := {Source code
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
Source code
Context
Source code
Source code
isOpenTopological
Source code
T.Source code
.
instance
Source code
Source code
Definition
Source code
Source code
hasNbhs
Source code
.Build T (nbhs_of_open op).Source code
Let
nbhs_pfilter_subproof
Source code
( : T) : ProperFilter (nbhs p).Source code
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.
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) :Source code
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].Source code
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.
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
Source code
Definition
Source code
Source code
Nbhs_isTopological
Source code
.Build TSource code
nbhs_pfilter_subproof nbhsE_subproof openE_subproof.
.
end
Source code
.Source code
Topology defined by a base of open sets
.
factory
Source code
Source code
Record
Source code
Source code
isBaseTopological
Source code
Source code
Choice
Source code
T := {Source code
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
Source code
( : set I) ( : I -> set T) :=Source code
[set \bigcup_( in D') b i | in subset^~ D].
.
builders
Source code
Source code
Context
Source code
Source code
isBaseTopological
Source code
T.Source code
Local Notation
openU_from
Source code
:= (openU_from D b).Source code
Let
openU_fromT
Source code
: openU_from setT.Source code
Let
openU_fromI
Source code
: setI_closed openU_from.Source code
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.
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) :Source code
(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.
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
Source code
Definition
Source code
Source code
isOpenTopological
Source code
.Build TSource code
openU_fromT openU_fromI openU_from_bigU.
.
end
Source code
.Source code
#[deprecated(since="mathcomp-analysis 1.17.0", use=openU_from)]
Notation
open_from
Source code
:= openU_from (only parsing).Source code
.
factory
Source code
Source code
Record
Source code
Source code
isSubBaseTopological
Source code
Source code
Choice
Source code
T := {Source code
I : pointedType ;
D : set I ;
b : I -> set T
}.
.
builders
Source code
Source code
Context
Source code
Source code
isSubBaseTopological
Source code
T.Source code
Local Notation
finI_from
Source code
:= (open_finI_from D b).Source code
Let
finI_from_cover
Source code
: \bigcup_( in finI_from) A = setT.Source code
Proof.
Let
finI_from_join
Source code
: finI_from A -> finI_from B -> A t -> B t ->Source code
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.
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
Source code
Definition
Source code
Source code
isBaseTopological
Source code
.Build TSource code
finI_from_cover finI_from_join.
.
end
Source code
.Source code
deleted neighborhood
Definition
dnbhs
Source code
{ : topologicalType} ( : T) :=Source code
within (fun => y != x) (nbhs x).
Notation
"x ^'"
Source code
:= (dnbhs x) : classical_set_scope.Source code
Lemma
nbhs_dnbhs_neq
Source code
{ : topologicalType} ( : T) :Source code
\forall \near nbhs p^', x != p.
Proof.
Lemma
nbhs_dnbhs
Source code
{ : topologicalType} ( : T) : x^' `=>` nbhs x.Source code
Proof.
Lemma
dnbhsE
Source code
( : topologicalType) ( : T) :Source code
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.
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^'.Source code
Proof.
Canonical
dnbhs_filter_on
Source code
( : topologicalType) ( : T) :=Source code
FilterType x^' (dnbhs_filter _).
Lemma
cvg_fmap2
Source code
( : Type) ( : T -> U):Source code
forall ( : set_system T), G `=>` F -> f @ G `=>` f @ F.
Proof.
Lemma
cvg_within_filter
Source code
{ } { : T -> U} ( : set_system T) { : (Filter F) }Source code
( : set_system U) ( : set T) : (f @ F) --> G -> (f @ within D F) --> G.
Proof.
Lemma
cvg_app_within
Source code
{} { : ptopologicalType} ( : T -> U) ( : set_system T)Source code
( : set T): Filter F -> cvg (f @ F) -> cvg (f @ within D F).
Proof.
meets
Lemma
meets_openr
Source code
{ : topologicalType} ( : set_system T) ( : T) :Source code
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.
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) :Source code
nbhs x `#` F = open_nbhs x `#` F.
Proof.
Closed sets in topological spaces
Section Closed.
Context { : topologicalType}.
Definition
closure
Source code
( : set T) :=Source code
[set : T | forall , nbhs p B -> A `&` B !=set0].
Lemma
closureEnbhs
Source code
: closure A = [set | globally A `#` nbhs p].Source code
Proof.
Lemma
closureEonbhs
Source code
: closure A = [set | globally A `#` open_nbhs p].Source code
Proof.
Lemma
subset_closure
Source code
( : set T) : A `<=` closure A.Source code
Proof.
Lemma
closure_eq0
Source code
( : set T) : closure A = set0 -> A = set0.Source code
Proof.
Lemma
closureI
Source code
( : set T) : closure (A `&` B) `<=` closure A `&` closure B.Source code
Proof.
by move=> p clABp; split=> ? /clABp [q [[]]]; exists q. Qed.
Definition
limit_point
Source code
:= [set : T |Source code
forall , nbhs t U -> exists , [/\ y != t, E y & U y]].
Lemma
limit_pointEnbhs
Source code
: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.
apply/eq2_forall => x px; apply/eq_exists => y.
by rewrite propeqE; split => [[/eqP ? ?]|[[? /eqP ?]]]; do 2?split.
Qed.
Lemma
limit_pointEonbhs
Source code
:Source code
limit_point E = [set | globally (E `\ p) `#` open_nbhs p].
Proof.
Lemma
subset_limit_point
Source code
: limit_point E `<=` closure E.Source code
Proof.
by move=> t Et U tU; have [p [? ? ?]] := Et _ tU; exists p. Qed.
Lemma
not_limit_pointE
Source code
: (~ limit_point A a) =Source code
exists2 : set T, nbhs a X & A `&` X `<=` [set a].
Proof.
Definition
isolated
Source code
( : set T) ( : T) :=Source code
x \in A /\ exists2 , nbhs x V & V `&` A = [set x].
Lemma
isolatedS
Source code
( : set T) : isolated A `<=` A.Source code
Proof.
Lemma
disjoint_isolated_limit_point
Source code
( : set T) :Source code
[disjoint isolated A & limit_point A].
Proof.
Lemma
closure_isolated_limit_point
Source code
( : set T) :Source code
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.
- 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.Source code
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.
by case; [exact: subset_closure|exact: subset_limit_point].
by rewrite closure_isolated_limit_point => x [/isolatedS|]; [left|right].
Qed.
Definition
closed
Source code
( : set T) := closure D `<=` D.Source code
Lemma
open_closedC
Source code
( : set T) : open D -> closed (~` D).Source code
Proof.
Lemma
closed_bigI
Source code
{} ( : set I) ( : I -> set T) :Source code
(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.
by move=> A /clft [s [/(_ i Di)]]; exists s.
Qed.
Lemma
closedI
Source code
: setI_closed closed.Source code
Proof.
by move=> D E Dcl Ecl p clDEp; split; [apply: Dcl|apply: Ecl];
move=> A /clDEp [q [[]]]; exists q.
Qed.
move=> A /clDEp [q [[]]]; exists q.
Qed.
Lemma
closedT
Source code
: closed setTSource code
Proof.
by []. Qed.
Lemma
closed0
Source code
: closed set0.Source code
Lemma
closedE
Source code
: closed = [set : set T | forall , ~ (\near , ~ A p) -> A p].Source code
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.
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).Source code
Proof.
Lemma
closedC
Source code
( : set T) : closed (~` D) = open D.Source code
Proof.
Lemma
openC
Source code
( : set T) : open (~` D) = closed D.Source code
Lemma
closed_closure
Source code
( : set T) : closed (closure A).Source code
Proof.
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).Source code
Lemma
preimage_closed
Source code
{ : topologicalType} ( : T -> U) ( : set U) :Source code
{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.
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.
Notation
closed_comp
Source code
:= preimage_closed (only parsing).Source code
Lemma
closed_cvg
Source code
{} { : topologicalType} {} { : ProperFilter F}Source code
( : 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.
by move=> /(filterI FAu_) => /filter_ex[t [Au_t u_Bt]]; exists (u_ t).
Qed.
Lemma
continuous_closedP
Source code
( : topologicalType) ( : S -> T) :Source code
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.
by rewrite -openC preimage_setC; apply: ctsf; rewrite openC.
by rewrite -closedC preimage_setC; apply: ctsf; rewrite closedC.
Qed.
Lemma
closedU
Source code
( : topologicalType) : setU_closed (@closed T).Source code
Lemma
bigsetU_closed
Source code
{ : topologicalType} { : eqType} ( : seq I)Source code
( : I -> set T) : (forall , x \in s -> closed (F x)) ->
closed (\big[setU/set0]_( <- s) F x).
Proof.
Notation
closed_bigsetU
Source code
:= bigsetU_closed (only parsing).Source code
Lemma
bigcup_closed
Source code
{ : topologicalType} { : choiceType} ( : set I)Source code
( : 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.
by rewrite in_fset_set// inE; exact: cF.
Qed.
Notation
closed_bigcup
Source code
:= bigcup_closed (only parsing).Source code
Section closure_lemmas.
Context { : topologicalType}.
Implicit Types E A B U : set T.
Lemma
closureS
Source code
: A `<=` B -> closure A `<=` closure B.Source code
Proof.
#[deprecated(since="mathcomp-analysis 1.16.0", note="Use `closureS` instead.")]
Definition
closure_subset
Source code
:= closureS.Source code
Lemma
closureE
Source code
: closure A = smallest closed A.Source code
Proof.
rewrite eqEsubset; split=> [x ? B [cB AB]|]; first exact/cB/(closureS AB).
by apply: smallest_sub; [exact: closed_closure|exact: subset_closure].
Qed.
by apply: smallest_sub; [exact: closed_closure|exact: subset_closure].
Qed.
Lemma
closure_id
Source code
: closed E <-> E = closure E.Source code
Proof.
split=> [?|->]; last exact: closed_closure.
by rewrite eqEsubset; split => //; exact: subset_closure.
Qed.
by rewrite eqEsubset; split => //; exact: subset_closure.
Qed.
End closure_lemmas.
Section regular_open_closed.
Variable : topologicalType.
Definition
regopen
Source code
( : set T) := (closure A)° = A.Source code
Definition
regclosed
Source code
( : set T) := closure (A°) = A.Source code
End regular_open_closed.
Section closure_interior_lemmas.
Variable : topologicalType.
Implicit Types (A B : set T).
Lemma
interiorC
Source code
: (~` A)° = ~` closure A.Source code
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.
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°.Source code
Lemma
interiorS
Source code
: A `<=` B -> A° `<=` B°.Source code
Proof.
move=> AB x.
rewrite /interior nbhsE => -[] U oxU UA.
exists U => //; move: UA AB; exact: subset_trans.
Qed.
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.Source code
Proof.
Lemma
closureT
Source code
: closure [set: T] = [set: T].Source code
Proof.
Lemma
closure0
Source code
: closure (@set0 T) = set0.Source code
Proof.
Lemma
interiorT
Source code
: (@setT T)° = setT.Source code
Proof.
Lemma
interior0
Source code
: (@set0 T)° = set0.Source code
Proof.
Lemma
closureU
Source code
: closure (A `|` B) = closure A `|` closure B.Source code
Lemma
interiorU
Source code
: A° `|` B° `<=` (A `|` B)°.Source code
Lemma
closureEbigcap
Source code
:Source code
closure A = \bigcap_( in [set | closed C /\ A `<=` C]) x.
Proof.
Lemma
interiorEbigcup
Source code
: A° = \bigcup_( in [set | open U /\ U `<=` A]) x.Source code
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.
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°.Source code
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.
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).Source code
Proof.
Lemma
interior_closure_idem
Source code
: @idempotent_fun (set T) (interior \o closure).Source code
Proof.
Lemma
closure_interior_idem
Source code
: @idempotent_fun (set T) (closure \o interior).Source code
Proof.
End closure_interior_lemmas.
#[deprecated(since="mathcomp-analysis 1.17.0", note="renamed to `closureC`")]
Notation
closure_setC
Source code
:= closureC (only parsing).Source code
Definition
dense
Source code
( : topologicalType) ( : set T) :=Source code
forall ( : set T), O !=set0 -> open O -> O `&` S !=set0.
Lemma
denseNE
Source code
( : topologicalType) ( : set T) : ~ dense S ->Source code
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.
move=> /existsNP[X /not_implyP[[x Xx] /not_implyP[ Ox /forallNP A]]].
by exists X; split; [exists x | rewrite -subset0; apply/A].
Qed.
Lemma
denseI
Source code
( : topologicalType) ( : set T) :Source code
open A -> dense A -> dense B -> dense (A `&` B).
Proof.
Lemma
dense0
Source code
{ : ptopologicalType} : ~ dense (@set0 R).Source code
Proof.
apply/existsNP; exists setT.
apply/not_implyP; split; first exact/set0P/setT0.
apply/not_implyP; split; first exact: openT.
by rewrite setTI => -[].
Qed.
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
clopen
Source code
{} ( : set T) := open A /\ closed A.Source code
Lemma
clopenI
Source code
{} : setI_closed (@clopen T).Source code
Lemma
clopenU
Source code
{} : setU_closed (@clopen T).Source code
Lemma
clopenC
Source code
{} ( : set T) : clopen A -> clopen (~`A).Source code
Proof.
Lemma
clopen0
Source code
{} : @clopen T set0.Source code
Lemma
clopenT
Source code
{} : clopen [set: T].Source code
Lemma
preimage_clopen
Source code
{ : topologicalType} ( : T -> U) ( : set U) :Source code
clopen A -> continuous f -> clopen (f @^-1` A).
Proof.
End ClopenSets.
#[deprecated(since="mathcomp-analysis 1.16.0", note="renamed to `preimage_clopen`")]
Notation
clopen_comp
Source code
:= preimage_clopen (only parsing).Source code
.
mixin
Source code
Source code
Record
Source code
Source code
isContinuous
Source code
Source code
nbhsType}
Source code
(f : X -> Y):= {Source code
continuous_fun : continuous f
}.
#[short
Source code
(Source code
type
Source code
Source code
"continuousType"
Source code
)Source code
.
structure
Source code
Source code
Definition
Source code
Source code
Continuous
Source code
Source code
nbhsType}
Source code
:= {Source code
of @isContinuous X Y f
}.
#[deprecated(since="mathcomp-analysis 1.17.0",
note="use `continuous_fun` instead")]
Notation
cts_fun
Source code
:= (continuous_fun) (only parsing).Source code
.
instance
Source code
Source code
Definition
Source code
Source code
topologicalType}
Source code
:=Source code
gen_eqMixin (continuousType X Y).
.
instance
Source code
Source code
Definition
Source code
Source code
topologicalType}
Source code
:=Source code
gen_choiceMixin (continuousType X Y).
Lemma
continuousEP
Source code
{ : nbhsType} ( : continuousType X Y) :Source code
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.
rewrite eqfg in ffun *; congr {| Continuous.sort := _; Continuous.class := {|
Continuous.topology_structure_isContinuous_mixin :=
{|isContinuous.continuous_fun := _|}|}|}.
exact: Prop_irrelevance.
Qed.
Definition
mkcts
Source code
{ : nbhsType} ( : X -> Y) (Source code
f_cts
Source code
: continuous f) := f.Source code
.
instance
Source code
Source code
Definition
Source code
Source code
nbhsType}
Source code
(f: X -> Y) (f_cts : continuous f) :=Source code
@isContinuous.Build X Y (mkcts f_cts) f_cts.
Section continuous_comp.
Context { : topologicalType}
( : continuousType X Y) ( : continuousType Y Z).
#[local] Lemma
cts_fun_comp
Source code
: continuous (g \o f).Source code
Proof.
.
instance
Source code
Source code
Definition
Source code
Source code
@isContinuous
Source code
.Build X Z (g \o f) cts_fun_comp.Source code
End continuous_comp.
Section continuous_id.
Context { : topologicalType}.
.
instance
Source code
Source code
Definition
Source code
Source code
@isContinuous
Source code
.Build X X (@idfun X) id_continuous.Source code
End continuous_id.
Section continuous_const.
Context { : topologicalType} ( : Y).
#[local] Lemma
cts_const
Source code
: continuous (@cst X Y y).Source code
Proof.
.
instance
Source code
Source code
Definition
Source code
Source code
@isContinuous
Source code
.Build X Y (cst y) cts_const.Source code
End continuous_const.