Module mathcomp.analysis.topology_theory.topology_structure
From HB Require Import structures.From mathcomp Require Import all_ssreflect_compat all_algebra finmap.
From mathcomp Require Import all_classical.
From mathcomp Require Export filter.
Reserved Notation "A °" (format "A °").
Reserved Notation "[ 'locally' P ]" (format "[ 'locally' P ]").
Reserved Notation "x ^'" (format "x ^'").
Set SsrOldRewriteGoalsOrder.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.
Local Open Scope classical_set_scope.
Local Open Scope ring_scope.
Source code
Source code
Source code
Source code
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 ]
}.
Source code
Source code
Source code
.
Source code
Source code
Source code
{ of Nbhs T & Nbhs_isTopological T}.
Source code
Source code
Source code
.
Source code
Source code
Source code
{ of PointedNbhs T & Nbhs_isTopological T}.
Source code
Source code
Source code
.
Source code
Source code
Source code
{ of BiPointed X & Topological X }.
Section Topological1.
Context { : topologicalType}.
Definition
Source code
Definition
Source code
B `<=` open /\ forall , filter_from [set | B U /\ U x] id --> x.
Definition
Source code
Global Instance
Source code
Proof.
Lemma
Source code
Proof.
Canonical
Source code
Lemma
Source code
nbhs p = [set : set T | exists2 : set T, open_nbhs p B & B `<=` A].
Proof.
Lemma
Source code
Proof.
Definition
Source code
Local Notation
Source code
Lemma
Source code
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Lemma
Source code
Proof.
Lemma
Source code
(forall , D i -> open (f i)) -> open (\bigcup_( in D) f i).
Proof.
Lemma
Source code
Lemma
Source code
Proof.
by move=> sAB p Ap; apply: filterS sAB _; apply: Aop.
by move=> sAB p /sAB /interior_subset.
Qed.
Lemma
Source code
Proof.
by rewrite open_subsetE //; exists B.
Qed.
Lemma
Source code
\bigcup_( in D) (f i)° `<=` (\bigcup_( in D) f i)°.
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
End Topological1.
Lemma
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
Source code
@Filter T^o (@nbhs T^o T x).
Proof.
Global Instance
Source code
@ProperFilter T^o (@nbhs T^o T x).
Proof.
Reserved Notation "A ^°" (at level 1, format "A ^°").
Notation
Source code
#[deprecated(since="mathcomp-analysis 1.10.0", note="use the notation instead ° instead of ^°")]
Notation
Source code
Lemma
Source code
continuous f <-> forall , open A -> open (f @^-1` A).
Proof.
move=> s A; rewrite nbhs_simpl /= !nbhsE => - [B [Bop Bfs] sBA].
by exists (f @^-1` B); [split=> //; apply/fcont|move=> ? /sBA].
Qed.
Lemma
Source code
{for x, continuous f} -> {for (f x), continuous g} ->
{for x, continuous (g \o f)}.
Proof.
Lemma
Source code
{in f @^-1` D, continuous f} -> open D -> open (f @^-1` D).
Lemma
Source code
( : set_system T) ( : T -> U) :
{for x, continuous f} -> F --> x -> f @ F --> f x.
Proof.
Lemma
Source code
(\near , P x) -> \near , \near , P x.
Proof.
Lemma
Source code
(\near , (\near , P x) -> Q x) -> (\near , P x) -> \near , Q x.
Proof.
Lemma
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
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.
by apply: continuous_cvg => //; exact: ach.
Qed.
Lemma
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
Source code
( : U) ( : T -> U) ( : set_system T) { : Filter F} :
(\forall \near F, f x = l) -> f @ F --> l.
Proof.
by apply: filterS fFl => _ ->; exact: nbhs_singleton.
Qed.
Lemma
Source code
( : U) ( : T -> U) ( : set_system T) { : Filter F} :
(\forall \near F, f x = l) -> cvg (f @ F).
Proof.
Lemma
Source code
( : U) ( : T -> U) ( : T) :
(\forall \near x, f y = l) -> {for x, continuous f}.
Proof.
by rewrite (nbhs_singleton eq_f_l).
Qed.
Lemma
Source code
( : set_system T) { : Filter F} :
(fun _ : T => x) @ F --> x.
Proof.
#[global] Hint Resolve cvg_cst : core.
Lemma
Source code
( : set_system T) { : Filter F} :
cvg ((fun _ : T => x) @ F).
Arguments is_cvg_cst {U} x {T F FF}.
#[global] Hint Resolve is_cvg_cst : core.
Lemma
Source code
continuous (fun _ : T => x).
Proof.
Section within_topologicalType.
Context { : topologicalType} ( : set T).
Implicit Types B : set T.
Lemma
Source code
Proof.
Definition
Source code
:= forall , A x -> P (within A (nbhs x)).
Local Notation
Source code
Lemma
Source code
Proof.
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
Source code
Proof.
by apply: filterE => ? + ?; apply; exact: AsubB.
Qed.
Lemma
Source code
within A F = [set | exists2 , F V & U `&` A = V `&` A].
Proof.
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
Source code
Filter F -> {in A, f =1 g} -> f @ within A F --> g @ within A F.
Proof.
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
Source code
.
Source code
Source code
Source code
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);
}.
.
Source code
Source code
Source code
Definition
Source code
Let
Source code
nbhs p = [set | exists , [/\ open_of_nbhs B, B p & B `<=` A] ].
Proof.
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
Source code
Proof.
.
Source code
Source code
Source code
nbhs_filter nbhsE_subproof openE_subproof.
.
Source code
Definition
Source code
exists , [/\ op B, B p & B `<=` A].
.
Source code
Source code
Source code
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)
}.
.
Source code
Source code
Source code
.
Source code
Source code
Source code
Let
Source code
Proof.
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
Source code
nbhs p = [set | exists , [/\ op B, B p & B `<=` A] ].
Proof.
Let
Source code
Proof.
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.
.
Source code
Source code
Source code
nbhs_pfilter_subproof nbhsE_subproof openE_subproof.
.
Source code
.
Source code
Source code
Source code
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];
}.
.
Source code
Source code
Source code
Definition
Source code
Let
Source code
Let
Source code
open_from (A `&` B).
Proof.
have ABU : forall , (A `&` B) t ->
exists , D it /\ b it t /\ b it `<=` A `&` B.
move=> t [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; [apply: sDAD|split=> // ?; exists i].
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; [apply: sDBD|split=> // ?; exists i].
have [i [Di bit sbiAB]] := b_join DiA DiB biAt biBt.
by exists i; split=> //; 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; apply.
by exists (get (Dt t)); [exists t| have /ABU/getPex [? []]:= ABt].
Qed.
Let
Source code
(forall , open_from (f i)) -> open_from (\bigcup_ f i).
Proof.
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.
.
Source code
Source code
Source code
open_fromT open_fromI open_from_bigU.
.
Source code
.
Source code
Source code
Source code
Source code
I : pointedType;
D : set I;
b : I -> (set T);
}.
.
Source code
Source code
Source code
Local Notation
Source code
Let
Source code
Proof.
Let
Source code
exists , [/\ finI_from k, k t & k `<=` A `&` B].
Proof.
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.
.
Source code
Source code
Source code
finI_from_cover finI_from_join.
.
Source code
Definition
connected : forall {T : topologicalType}, set T -> Prop connected is not universe polymorphic Arguments connected {T} A%classical_set_scope connected is transparent Expands to: Constant mathcomp.analysis.topology_theory.connected.connected Declared in library mathcomp.analysis.topology_theory.connected, line 30, characters 11-20
Source code
within (fun => y != x) (nbhs x).
Notation
Source code
Lemma
Source code
\forall \near nbhs p^', x != p.
Proof.
Lemma
Source code
Proof.
Lemma
Source code
nbhs x = x^' `&` principal_filter x.
Proof.
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
Source code
Proof.
Canonical
separated : forall [T : topologicalType], set T -> set T -> Prop separated is not universe polymorphic Arguments separated [T] (A B)%classical_set_scope separated is transparent Expands to: Constant mathcomp.analysis.topology_theory.connected.separated Declared in library mathcomp.analysis.topology_theory.connected, line 37, characters 11-20
Source code
FilterType x^' (dnbhs_filter _).
Lemma
Source code
forall ( : set_system T), G `=>` F -> f @ G `=>` f @ F.
Proof.
Lemma
Source code
( : set_system U) ( : set T) : (f @ F) --> G -> (f @ within D F) --> G.
Proof.
Lemma
Source code
( : set T): Filter F -> cvg (f @ F) -> cvg (f @ within D F).
Proof.
Lemma
Source code
F `#` nbhs x = F `#` open_nbhs x.
Proof.
by move=> P A B {}/P P; rewrite nbhsE => -[B' /P + sB]; apply: subsetI_neq0.
Qed.
Lemma
Source code
nbhs x `#` F = open_nbhs x `#` F.
Proof.
Section Closed.
Context { : topologicalType}.
Definition
connected_component : forall {T : topologicalType}, set T -> T -> set T connected_component is not universe polymorphic Arguments connected_component {T} A%classical_set_scope x _ connected_component is transparent Expands to: Constant mathcomp.analysis.topology_theory.connected.connected_component Declared in library mathcomp.analysis.topology_theory.connected, line 160, characters 11-30
Source code
[set : T | forall , nbhs p B -> A `&` B !=set0].
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Definition
Source code
forall , nbhs t U -> exists , [/\ y != t, E y & U y]].
Lemma
Source code
limit_point E = [set | globally (E `\ p) `#` nbhs p].
Proof.
apply/eq2_forall => x px; apply/eq_exists => y.
by rewrite propeqE; split => [[/eqP ? ?]|[[? /eqP ?]]]; do 2?split.
Qed.
Lemma
Source code
limit_point E = [set | globally (E `\ p) `#` open_nbhs p].
Proof.
Lemma
Source code
Proof.
Lemma
Source code
exists2 : set T, nbhs a X & A `&` X `<=` [set a].
Proof.
Definition
Source code
x \in A /\ exists2 , nbhs x V & V `&` A = [set x].
Lemma
Source code
Proof.
Lemma
Source code
[disjoint isolated A & limit_point A].
Proof.
Lemma
Source code
closure A = isolated A `|` limit_point A.
Proof.
- 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
Source code
Proof.
by case; [exact: subset_closure|exact: subset_limit_point].
by rewrite closure_isolated_limit_point => x [/isolatedS|]; [left|right].
Qed.
Definition
Source code
Lemma
Source code
Proof.
Lemma
Source code
(forall , D i -> closed (f i)) -> closed (\bigcap_( in D) f i).
Proof.
by move=> A /clft [s [/(_ i Di)]]; exists s.
Qed.
Lemma
Source code
Proof.
move=> A /clDEp [q [[]]]; exists q.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Lemma
Source code
Proof.
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
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Lemma
Source code
Proof.
End Closed.
#[deprecated(since="mathcomp-analysis 1.15.0", note="use `closure_limit_point_isolated` instead")]
Notation
Source code
Lemma
Source code
{in ~` f @^-1` D, continuous f} -> closed D -> closed (f @^-1` D).
Proof.
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
Source code
Lemma
Source code
( : T -> V) ( : V -> Prop) :
closed A -> (\forall \near F, A (u_ n)) ->
forall , u_ @ F --> l -> A l.
Proof.
by move=> /(filterI FAu_) => /filter_ex[t [Au_t u_Bt]]; exists (u_ t).
Qed.
Lemma
Source code
continuous f <-> forall , closed A -> closed (f @^-1` A).
Proof.
by rewrite -openC preimage_setC; apply: ctsf; rewrite openC.
by rewrite -closedC preimage_setC; apply: ctsf; rewrite closedC.
Qed.
Lemma
Source code
Lemma
Source code
( : I -> set T) : (forall , x \in s -> closed (F x)) ->
closed (\big[setU/set0]_( <- s) F x).
Proof.
Lemma
Source code
( : I -> set T) :
finite_set A -> (forall , A i -> closed (F i)) ->
closed (\bigcup_( in A) F i).
Proof.
by rewrite in_fset_set// inE; exact: cF.
Qed.
Section closure_lemmas.
Variable : topologicalType.
Implicit Types E A B U : set T.
Lemma
Source code
Proof.
#[deprecated(since="mathcomp-analysis 1.16.0", note="Use `closureS` instead.")]
Definition
Source code
Lemma
Source code
Proof.
exact: (smallest_sub (@closed_closure _ _) (@subset_closure _ _)).
Qed.
Lemma
Source code
Proof.
rewrite eqEsubset; split => //; exact: subset_closure.
Qed.
End closure_lemmas.
Section regular_open_closed.
Variable : topologicalType.
Definition
Source code
Definition
Source code
End regular_open_closed.
Section closure_interior_lemmas.
Variable : topologicalType.
Implicit Types (A B : set T).
Lemma
Source code
Proof.
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
Source code
Lemma
Source code
Proof.
rewrite /interior nbhsE => -[] U oxU UA.
exists U => //; move: UA AB; exact: subset_trans.
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
Lemma
Source code
Lemma
Source code
Proof.
Lemma
Source code
closure A = \bigcap_( in [set | closed C /\ A `<=` C]) x.
Proof.
Lemma
Source code
A° = \bigcup_( in [set | open U /\ U `<=` A]) x.
Proof.
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
Source code
Proof.
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
Source code
Proof.
rewrite closure_setC -[in RHS]interior_closed_regopen//.
by rewrite !(closure_setC, interiorC).
Qed.
Lemma
Source code
Proof.
Lemma
Source code
Proof.
End closure_interior_lemmas.
Lemma
Source code
~` closure E = \bigcup_( in [set | open U /\ U `<=` ~` E]) x.
Proof.
Notation
Source code
Definition
Source code
forall ( : set T), O !=set0 -> open O -> O `&` S !=set0.
Lemma
Source code
exists , (exists , open_nbhs x O) /\ (O `&` S = set0).
Proof.
move=> /existsNP[X /not_implyP[[x Xx] /not_implyP[ Ox /forallNP A]]].
by exists X; split; [exists x | rewrite -subset0; apply/A].
Qed.
Lemma
Source code
open A -> dense A -> dense B -> dense (A `&` B).
Proof.
Lemma
Source code
Proof.
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
Source code
Lemma
Source code
Lemma
Source code
Lemma
Source code
Proof.
Lemma
Source code
Lemma
Source code
Lemma
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
Source code
.
Source code
Source code
Source code
Source code
cts_fun : continuous f
}.
Source code
Source code
Source code
.
Source code
Source code
Source code
Source code
of @isContinuous X Y f
}.
.
Source code
Source code
Source code
gen_eqMixin (continuousType X Y).
.
Source code
Source code
Source code
gen_choiceMixin (continuousType X Y).
Lemma
Source code
f = g <-> f =1 g.
Proof.
rewrite eqfg in ffun *; congr {| Continuous.sort := _; Continuous.class := {|
Continuous.topology_structure_isContinuous_mixin :=
{|isContinuous.cts_fun := _|}|}|}.
exact: Prop_irrelevance.
Qed.
Definition
Source code
Source code
.
Source code
Source code
Source code
@isContinuous.Build X Y (mkcts f_cts) f_cts.
Section continuous_comp.
Context { : topologicalType}.
Context ( : continuousType X Y) ( : continuousType Y Z).
Local Lemma
Source code
Proof.
.
Source code
Source code
Source code
End continuous_comp.
Section continuous_id.
Context { : topologicalType}.
Local Lemma
Source code
Proof.
.
Source code
Source code
Source code
End continuous_id.
Section continuous_const.
Context { : topologicalType} ( : Y).
Local Lemma
Source code
Proof.
.
Source code
Source code
Source code
End continuous_const.