:: WAYBEL_9 semantic presentation

registration
let c1 be non empty RelStr ;
cluster id a1 -> monotone ;
coherence
id c1 is monotone
by YELLOW_2:13;
end;

definition
let c1, c2 be non empty RelStr ;
let c3 be Function of c1,c2;
redefine attr a3 is antitone means :Def1: :: WAYBEL_9:def 1
for b1, b2 being Element of a1 holds
( b1 <= b2 implies a3 . b1 >= a3 . b2 );
compatibility
( c3 is antitone iff for b1, b2 being Element of c1 holds
( b1 <= b2 implies c3 . b1 >= c3 . b2 ) )
proof end;
end;

:: deftheorem Def1 defines antitone WAYBEL_9:def 1 :
for b1, b2 being non empty RelStr
for b3 being Function of b1,b2 holds
( b3 is antitone iff for b4, b5 being Element of b1 holds
( b4 <= b5 implies b3 . b4 >= b3 . b5 ) );

theorem Th1: :: WAYBEL_9:1
for b1, b2 being RelStr
for b3, b4 being non empty RelStr
for b5 being Function of b1,b2
for b6 being Function of b3,b4 holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b3,the InternalRel of b3 #) & RelStr(# the carrier of b2,the InternalRel of b2 #) = RelStr(# the carrier of b4,the InternalRel of b4 #) & b5 = b6 & b5 is monotone implies b6 is monotone )
proof end;

theorem Th2: :: WAYBEL_9:2
for b1, b2 being RelStr
for b3, b4 being non empty RelStr
for b5 being Function of b1,b2
for b6 being Function of b3,b4 holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b3,the InternalRel of b3 #) & RelStr(# the carrier of b2,the InternalRel of b2 #) = RelStr(# the carrier of b4,the InternalRel of b4 #) & b5 = b6 & b5 is antitone implies b6 is antitone )
proof end;

theorem Th3: :: WAYBEL_9:3
for b1, b2 being 1-sorted
for b3 being Subset-Family of b1
for b4 being Subset-Family of b2 holds
( the carrier of b1 = the carrier of b2 & b3 = b4 & b3 is_a_cover_of b1 implies b4 is_a_cover_of b2 )
proof end;

Lemma5: for b1 being reflexive antisymmetric with_infima RelStr
for b2 being Element of b1 holds uparrow b2 = { b3 where B is Element of b1 : b3 "/\" b2 = b2 }
proof end;

theorem Th4: :: WAYBEL_9:4
for b1 being reflexive antisymmetric with_suprema RelStr
for b2 being Element of b1 holds uparrow b2 = {b2} "\/" ([#] b1)
proof end;

Lemma7: for b1 being reflexive antisymmetric with_suprema RelStr
for b2 being Element of b1 holds downarrow b2 = { b3 where B is Element of b1 : b3 "\/" b2 = b2 }
proof end;

theorem Th5: :: WAYBEL_9:5
for b1 being reflexive antisymmetric with_infima RelStr
for b2 being Element of b1 holds downarrow b2 = {b2} "/\" ([#] b1)
proof end;

theorem Th6: :: WAYBEL_9:6
for b1 being reflexive antisymmetric with_infima RelStr
for b2 being Element of b1 holds (b2 "/\" ) .: (uparrow b2) = {b2}
proof end;

theorem Th7: :: WAYBEL_9:7
for b1 being reflexive antisymmetric with_infima RelStr
for b2 being Element of b1 holds (b2 "/\" ) " {b2} = uparrow b2
proof end;

theorem Th8: :: WAYBEL_9:8
for b1 being non empty 1-sorted
for b2 being non empty NetStr of b1 holds b2 is_eventually_in rng the mapping of b2
proof end;

Lemma11: for b1 being non empty reflexive transitive RelStr
for b2 being non empty directed Subset of b1
for b3 being Function of b2,the carrier of b1 holds
NetStr(# b2,(the InternalRel of b1 |_2 b2),b3 #) is net of b1
proof end;

registration
let c1 be non empty reflexive RelStr ;
let c2 be non empty directed Subset of c1;
let c3 be Function of c2,the carrier of c1;
cluster NetStr(# a2,(the InternalRel of a1 |_2 a2),a3 #) -> directed ;
coherence
NetStr(# c2,(the InternalRel of c1 |_2 c2),c3 #) is directed
by WAYBEL_2:19;
end;

registration
let c1 be non empty reflexive transitive RelStr ;
let c2 be non empty directed Subset of c1;
let c3 be Function of c2,the carrier of c1;
cluster NetStr(# a2,(the InternalRel of a1 |_2 a2),a3 #) -> transitive directed ;
coherence
NetStr(# c2,(the InternalRel of c1 |_2 c2),c3 #) is transitive
by Lemma11;
end;

theorem Th9: :: WAYBEL_9:9
for b1 being non empty reflexive transitive RelStr holds
( ( for b2 being Element of b1
for b3 being net of b1 holds
( b3 is eventually-directed implies b2 "/\" (sup b3) = sup ({b2} "/\" (rng (netmap b3,b1))) ) ) implies b1 is satisfying_MC )
proof end;

theorem Th10: :: WAYBEL_9:10
for b1 being non empty RelStr
for b2 being Element of b1
for b3 being net of b1 holds
b2 "/\" b3 is net of b1
proof end;

definition
let c1 be non empty RelStr ;
let c2 be Element of c1;
let c3 be net of c1;
redefine func "/\" as c2 "/\" c3 -> strict net of a1;
coherence
c2 "/\" c3 is strict net of c1
by Th10;
end;

registration
let c1 be non empty RelStr ;
let c2 be Element of c1;
let c3 be non empty reflexive NetStr of c1;
cluster a2 "/\" a3 -> reflexive ;
coherence
c2 "/\" c3 is reflexive
proof end;
end;

registration
let c1 be non empty RelStr ;
let c2 be Element of c1;
let c3 be non empty antisymmetric NetStr of c1;
cluster a2 "/\" a3 -> antisymmetric ;
coherence
c2 "/\" c3 is antisymmetric
proof end;
end;

registration
let c1 be non empty RelStr ;
let c2 be Element of c1;
let c3 be non empty transitive NetStr of c1;
cluster a2 "/\" a3 -> transitive ;
coherence
c2 "/\" c3 is transitive
proof end;
end;

registration
let c1 be non empty RelStr ;
let c2 be set ;
let c3 be Function of c2,the carrier of c1;
cluster FinSups a3 -> transitive ;
coherence
FinSups c3 is transitive
proof end;
end;

definition
let c1 be non empty RelStr ;
let c2 be NetStr of c1;
func inf c2 -> Element of a1 equals :: WAYBEL_9:def 2
Inf ;
coherence
Inf is Element of c1
;
end;

:: deftheorem Def2 defines inf WAYBEL_9:def 2 :
for b1 being non empty RelStr
for b2 being NetStr of b1 holds inf b2 = Inf ;

definition
let c1 be RelStr ;
let c2 be NetStr of c1;
pred ex_sup_of c2 means :Def3: :: WAYBEL_9:def 3
ex_sup_of rng the mapping of a2,a1;
pred ex_inf_of c2 means :Def4: :: WAYBEL_9:def 4
ex_inf_of rng the mapping of a2,a1;
end;

:: deftheorem Def3 defines ex_sup_of WAYBEL_9:def 3 :
for b1 being RelStr
for b2 being NetStr of b1 holds
( ex_sup_of b2 iff ex_sup_of rng the mapping of b2,b1 );

:: deftheorem Def4 defines ex_inf_of WAYBEL_9:def 4 :
for b1 being RelStr
for b2 being NetStr of b1 holds
( ex_inf_of b2 iff ex_inf_of rng the mapping of b2,b1 );

definition
let c1 be RelStr ;
func c1 +id -> strict NetStr of a1 means :Def5: :: WAYBEL_9:def 5
( RelStr(# the carrier of a2,the InternalRel of a2 #) = RelStr(# the carrier of a1,the InternalRel of a1 #) & the mapping of a2 = id a1 );
existence
ex b1 being strict NetStr of c1 st
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of c1,the InternalRel of c1 #) & the mapping of b1 = id c1 )
proof end;
uniqueness
for b1, b2 being strict NetStr of c1 holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of c1,the InternalRel of c1 #) & the mapping of b1 = id c1 & RelStr(# the carrier of b2,the InternalRel of b2 #) = RelStr(# the carrier of c1,the InternalRel of c1 #) & the mapping of b2 = id c1 implies b1 = b2 )
;
end;

:: deftheorem Def5 defines +id WAYBEL_9:def 5 :
for b1 being RelStr
for b2 being strict NetStr of b1 holds
( b2 = b1 +id iff ( RelStr(# the carrier of b2,the InternalRel of b2 #) = RelStr(# the carrier of b1,the InternalRel of b1 #) & the mapping of b2 = id b1 ) );

registration
let c1 be non empty RelStr ;
cluster a1 +id -> non empty strict ;
coherence
not c1 +id is empty
proof end;
end;

registration
let c1 be reflexive RelStr ;
cluster a1 +id -> reflexive strict ;
coherence
c1 +id is reflexive
proof end;
end;

registration
let c1 be antisymmetric RelStr ;
cluster a1 +id -> antisymmetric strict ;
coherence
c1 +id is antisymmetric
proof end;
end;

registration
let c1 be transitive RelStr ;
cluster a1 +id -> transitive strict ;
coherence
c1 +id is transitive
proof end;
end;

registration
let c1 be with_suprema RelStr ;
cluster a1 +id -> non empty strict directed ;
coherence
c1 +id is directed
proof end;
end;

registration
let c1 be directed RelStr ;
cluster a1 +id -> strict directed ;
coherence
c1 +id is directed
proof end;
end;

registration
let c1 be non empty RelStr ;
cluster a1 +id -> non empty strict monotone eventually-directed ;
coherence
( c1 +id is monotone & c1 +id is eventually-directed )
proof end;
end;

definition
let c1 be RelStr ;
func c1 opp+id -> strict NetStr of a1 means :Def6: :: WAYBEL_9:def 6
( the carrier of a2 = the carrier of a1 & the InternalRel of a2 = the InternalRel of a1 ~ & the mapping of a2 = id a1 );
existence
ex b1 being strict NetStr of c1 st
( the carrier of b1 = the carrier of c1 & the InternalRel of b1 = the InternalRel of c1 ~ & the mapping of b1 = id c1 )
proof end;
uniqueness
for b1, b2 being strict NetStr of c1 holds
( the carrier of b1 = the carrier of c1 & the InternalRel of b1 = the InternalRel of c1 ~ & the mapping of b1 = id c1 & the carrier of b2 = the carrier of c1 & the InternalRel of b2 = the InternalRel of c1 ~ & the mapping of b2 = id c1 implies b1 = b2 )
;
end;

:: deftheorem Def6 defines opp+id WAYBEL_9:def 6 :
for b1 being RelStr
for b2 being strict NetStr of b1 holds
( b2 = b1 opp+id iff ( the carrier of b2 = the carrier of b1 & the InternalRel of b2 = the InternalRel of b1 ~ & the mapping of b2 = id b1 ) );

theorem Th11: :: WAYBEL_9:11
for b1 being RelStr holds RelStr(# the carrier of (b1 ~ ),the InternalRel of (b1 ~ ) #) = RelStr(# the carrier of (b1 opp+id ),the InternalRel of (b1 opp+id ) #)
proof end;

registration
let c1 be non empty RelStr ;
cluster a1 opp+id -> non empty strict ;
coherence
not c1 opp+id is empty
proof end;
end;

registration
let c1 be reflexive RelStr ;
cluster a1 opp+id -> reflexive strict ;
coherence
c1 opp+id is reflexive
proof end;
end;

registration
let c1 be antisymmetric RelStr ;
cluster a1 opp+id -> antisymmetric strict ;
coherence
c1 opp+id is antisymmetric
proof end;
end;

registration
let c1 be transitive RelStr ;
cluster a1 opp+id -> transitive strict ;
coherence
c1 opp+id is transitive
proof end;
end;

registration
let c1 be with_infima RelStr ;
cluster a1 opp+id -> non empty strict directed ;
coherence
c1 opp+id is directed
proof end;
end;

registration
let c1 be non empty RelStr ;
cluster a1 opp+id -> non empty strict antitone eventually-filtered ;
coherence
( c1 opp+id is antitone & c1 opp+id is eventually-filtered )
proof end;
end;

definition
let c1 be non empty 1-sorted ;
let c2 be non empty NetStr of c1;
let c3 be Element of c2;
func c2 | c3 -> strict NetStr of a1 means :Def7: :: WAYBEL_9:def 7
( ( for b1 being set holds
( b1 in the carrier of a4 iff ex b2 being Element of a2 st
( b2 = b1 & a3 <= b2 ) ) ) & the InternalRel of a4 = the InternalRel of a2 |_2 the carrier of a4 & the mapping of a4 = the mapping of a2 | the carrier of a4 );
existence
ex b1 being strict NetStr of c1 st
( ( for b2 being set holds
( b2 in the carrier of b1 iff ex b3 being Element of c2 st
( b3 = b2 & c3 <= b3 ) ) ) & the InternalRel of b1 = the InternalRel of c2 |_2 the carrier of b1 & the mapping of b1 = the mapping of c2 | the carrier of b1 )
proof end;
uniqueness
for b1, b2 being strict NetStr of c1 holds
( ( for b3 being set holds
( b3 in the carrier of b1 iff ex b4 being Element of c2 st
( b4 = b3 & c3 <= b4 ) ) ) & the InternalRel of b1 = the InternalRel of c2 |_2 the carrier of b1 & the mapping of b1 = the mapping of c2 | the carrier of b1 & ( for b3 being set holds
( b3 in the carrier of b2 iff ex b4 being Element of c2 st
( b4 = b3 & c3 <= b4 ) ) ) & the InternalRel of b2 = the InternalRel of c2 |_2 the carrier of b2 & the mapping of b2 = the mapping of c2 | the carrier of b2 implies b1 = b2 )
proof end;
end;

:: deftheorem Def7 defines | WAYBEL_9:def 7 :
for b1 being non empty 1-sorted
for b2 being non empty NetStr of b1
for b3 being Element of b2
for b4 being strict NetStr of b1 holds
( b4 = b2 | b3 iff ( ( for b5 being set holds
( b5 in the carrier of b4 iff ex b6 being Element of b2 st
( b6 = b5 & b3 <= b6 ) ) ) & the InternalRel of b4 = the InternalRel of b2 |_2 the carrier of b4 & the mapping of b4 = the mapping of b2 | the carrier of b4 ) );

theorem Th12: :: WAYBEL_9:12
for b1 being non empty 1-sorted
for b2 being non empty NetStr of b1
for b3 being Element of b2 holds the carrier of (b2 | b3) = { b4 where B is Element of b2 : b3 <= b4 }
proof end;

theorem Th13: :: WAYBEL_9:13
for b1 being non empty 1-sorted
for b2 being non empty NetStr of b1
for b3 being Element of b2 holds the carrier of (b2 | b3) c= the carrier of b2
proof end;

theorem Th14: :: WAYBEL_9:14
for b1 being non empty 1-sorted
for b2 being non empty NetStr of b1
for b3 being Element of b2 holds
b2 | b3 is full SubNetStr of b2
proof end;

registration
let c1 be non empty 1-sorted ;
let c2 be non empty reflexive NetStr of c1;
let c3 be Element of c2;
cluster a2 | a3 -> non empty reflexive strict ;
coherence
( not c2 | c3 is empty & c2 | c3 is reflexive )
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be non empty directed NetStr of c1;
let c3 be Element of c2;
cluster a2 | a3 -> non empty strict ;
coherence
not c2 | c3 is empty
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be non empty reflexive antisymmetric NetStr of c1;
let c3 be Element of c2;
cluster a2 | a3 -> non empty reflexive antisymmetric strict ;
coherence
c2 | c3 is antisymmetric
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be non empty antisymmetric directed NetStr of c1;
let c3 be Element of c2;
cluster a2 | a3 -> non empty antisymmetric strict ;
coherence
c2 | c3 is antisymmetric
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be non empty reflexive transitive NetStr of c1;
let c3 be Element of c2;
cluster a2 | a3 -> non empty reflexive transitive strict ;
coherence
c2 | c3 is transitive
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be net of c1;
let c3 be Element of c2;
cluster a2 | a3 -> non empty transitive strict directed ;
coherence
( c2 | c3 is transitive & c2 | c3 is directed )
proof end;
end;

theorem Th15: :: WAYBEL_9:15
for b1 being non empty 1-sorted
for b2 being non empty reflexive NetStr of b1
for b3, b4 being Element of b2
for b5 being Element of (b2 | b3) holds
( b4 = b5 implies b2 . b4 = (b2 | b3) . b5 )
proof end;

theorem Th16: :: WAYBEL_9:16
for b1 being non empty 1-sorted
for b2 being non empty directed NetStr of b1
for b3, b4 being Element of b2
for b5 being Element of (b2 | b3) holds
( b4 = b5 implies b2 . b4 = (b2 | b3) . b5 )
proof end;

theorem Th17: :: WAYBEL_9:17
for b1 being non empty 1-sorted
for b2 being net of b1
for b3 being Element of b2 holds
b2 | b3 is subnet of b2
proof end;

registration
let c1 be non empty 1-sorted ;
let c2 be net of c1;
cluster strict subnet of a2;
existence
ex b1 being subnet of c2 st b1 is strict
proof end;
end;

definition
let c1 be non empty 1-sorted ;
let c2 be net of c1;
let c3 be Element of c2;
redefine func | as c2 | c3 -> strict subnet of a2;
coherence
c2 | c3 is strict subnet of c2
by Th17;
end;

definition
let c1 be non empty 1-sorted ;
let c2 be 1-sorted ;
let c3 be Function of c1,c2;
let c4 be NetStr of c1;
func c3 * c4 -> strict NetStr of a2 means :Def8: :: WAYBEL_9:def 8
( RelStr(# the carrier of a5,the InternalRel of a5 #) = RelStr(# the carrier of a4,the InternalRel of a4 #) & the mapping of a5 = a3 * the mapping of a4 );
existence
ex b1 being strict NetStr of c2 st
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of c4,the InternalRel of c4 #) & the mapping of b1 = c3 * the mapping of c4 )
proof end;
uniqueness
for b1, b2 being strict NetStr of c2 holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of c4,the InternalRel of c4 #) & the mapping of b1 = c3 * the mapping of c4 & RelStr(# the carrier of b2,the InternalRel of b2 #) = RelStr(# the carrier of c4,the InternalRel of c4 #) & the mapping of b2 = c3 * the mapping of c4 implies b1 = b2 )
;
end;

:: deftheorem Def8 defines * WAYBEL_9:def 8 :
for b1 being non empty 1-sorted
for b2 being 1-sorted
for b3 being Function of b1,b2
for b4 being NetStr of b1
for b5 being strict NetStr of b2 holds
( b5 = b3 * b4 iff ( RelStr(# the carrier of b5,the InternalRel of b5 #) = RelStr(# the carrier of b4,the InternalRel of b4 #) & the mapping of b5 = b3 * the mapping of b4 ) );

registration
let c1 be non empty 1-sorted ;
let c2 be 1-sorted ;
let c3 be Function of c1,c2;
let c4 be non empty NetStr of c1;
cluster a3 * a4 -> non empty strict ;
coherence
not c3 * c4 is empty
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be 1-sorted ;
let c3 be Function of c1,c2;
let c4 be reflexive NetStr of c1;
cluster a3 * a4 -> reflexive strict ;
coherence
c3 * c4 is reflexive
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be 1-sorted ;
let c3 be Function of c1,c2;
let c4 be antisymmetric NetStr of c1;
cluster a3 * a4 -> antisymmetric strict ;
coherence
c3 * c4 is antisymmetric
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be 1-sorted ;
let c3 be Function of c1,c2;
let c4 be transitive NetStr of c1;
cluster a3 * a4 -> transitive strict ;
coherence
c3 * c4 is transitive
proof end;
end;

registration
let c1 be non empty 1-sorted ;
let c2 be 1-sorted ;
let c3 be Function of c1,c2;
let c4 be directed NetStr of c1;
cluster a3 * a4 -> strict directed ;
coherence
c3 * c4 is directed
proof end;
end;

theorem Th18: :: WAYBEL_9:18
for b1 being non empty RelStr
for b2 being non empty NetStr of b1
for b3 being Element of b1 holds (b3 "/\" ) * b2 = b3 "/\" b2
proof end;

theorem Th19: :: WAYBEL_9:19
for b1, b2 being TopStruct
for b3 being Subset-Family of b1
for b4 being Subset-Family of b2 holds
( TopStruct(# the carrier of b1,the topology of b1 #) = TopStruct(# the carrier of b2,the topology of b2 #) & b3 = b4 & b3 is open implies b4 is open )
proof end;

theorem Th20: :: WAYBEL_9:20
for b1, b2 being TopStruct
for b3 being Subset-Family of b1
for b4 being Subset-Family of b2 holds
( TopStruct(# the carrier of b1,the topology of b1 #) = TopStruct(# the carrier of b2,the topology of b2 #) & b3 = b4 & b3 is closed implies b4 is closed )
proof end;

definition
attr a1 is strict;
struct TopRelStr -> TopStruct , RelStr ;
aggr TopRelStr(# carrier, InternalRel, topology #) -> TopRelStr ;
end;

registration
let c1 be non empty set ;
let c2 be Relation of c1,c1;
let c3 be Subset-Family of c1;
cluster TopRelStr(# a1,a2,a3 #) -> non empty ;
coherence
not TopRelStr(# c1,c2,c3 #) is empty
proof end;
end;

registration
let c1 be set ;
let c2 be Relation of {c1};
let c3 be Subset-Family of {c1};
cluster TopRelStr(# {a1},a2,a3 #) -> non empty trivial ;
coherence
TopRelStr(# {c1},c2,c3 #) is trivial
proof end;
end;

registration
let c1 be set ;
let c2 be Order of c1;
let c3 be Subset-Family of c1;
cluster TopRelStr(# a1,a2,a3 #) -> reflexive transitive antisymmetric ;
coherence
( TopRelStr(# c1,c2,c3 #) is reflexive & TopRelStr(# c1,c2,c3 #) is transitive & TopRelStr(# c1,c2,c3 #) is antisymmetric )
proof end;
end;

Lemma27: for b1 being Subset-Family of {0}
for b2 being Relation of {0} holds
( b1 = {{} ,{0}} & b2 = {[0,0]} implies ( TopRelStr(# {0},b2,b1 #) is trivial & TopRelStr(# {0},b2,b1 #) is reflexive & not TopRelStr(# {0},b2,b1 #) is empty & TopRelStr(# {0},b2,b1 #) is discrete & TopRelStr(# {0},b2,b1 #) is finite ) )
proof end;

registration
cluster non empty finite trivial discrete reflexive strict TopRelStr ;
existence
ex b1 being TopRelStr st
( b1 is trivial & b1 is reflexive & not b1 is empty & b1 is discrete & b1 is strict & b1 is finite )
proof end;
end;

definition
mode TopLattice is TopSpace-like reflexive transitive antisymmetric with_suprema with_infima TopRelStr ;
end;

registration
cluster non empty finite trivial discrete compact Hausdorff strict TopRelStr ;
existence
ex b1 being TopLattice st
( b1 is strict & not b1 is empty & b1 is trivial & b1 is discrete & b1 is finite & b1 is compact & b1 is being_T2 )
proof end;
end;

registration
let c1 be non empty Hausdorff TopSpace;
cluster non empty -> non empty Hausdorff SubSpace of a1;
coherence
for b1 being non empty SubSpace of c1 holds b1 is being_T2
by TOPMETR:3;
end;

theorem Th21: :: WAYBEL_9:21
for b1 being non empty TopSpace
for b2 being Point of b1
for b3 being Element of (OpenNeighborhoods b2) holds
b3 is a_neighborhood of b2
proof end;

theorem Th22: :: WAYBEL_9:22
for b1 being non empty TopSpace
for b2 being Point of b1
for b3, b4 being Element of (OpenNeighborhoods b2) holds
b3 /\ b4 is Element of (OpenNeighborhoods b2)
proof end;

theorem Th23: :: WAYBEL_9:23
for b1 being non empty TopSpace
for b2 being Point of b1
for b3, b4 being Element of (OpenNeighborhoods b2) holds
b3 \/ b4 is Element of (OpenNeighborhoods b2)
proof end;

theorem Th24: :: WAYBEL_9:24
for b1 being non empty TopSpace
for b2 being Element of b1
for b3 being net of b1 holds
( b2 in Lim b3 implies for b4 being Subset of b1 holds
( b4 = rng the mapping of b3 implies b2 in Cl b4 ) )
proof end;

theorem Th25: :: WAYBEL_9:25
for b1 being Hausdorff TopLattice
for b2 being convergent net of b1
for b3 being Function of b1,b1 holds
( b3 is continuous implies b3 . (lim b2) in Lim (b3 * b2) )
proof end;

theorem Th26: :: WAYBEL_9:26
for b1 being Hausdorff TopLattice
for b2 being convergent net of b1
for b3 being Element of b1 holds
( b3 "/\" is continuous implies b3 "/\" (lim b2) in Lim (b3 "/\" b2) )
proof end;

theorem Th27: :: WAYBEL_9:27
for b1 being Hausdorff TopLattice
for b2 being Element of b1 holds
( ( for b3 being Element of b1 holds b3 "/\" is continuous ) implies uparrow b2 is closed )
proof end;

theorem Th28: :: WAYBEL_9:28
for b1 being compact Hausdorff TopLattice
for b2 being Element of b1 holds
( ( for b3 being Element of b1 holds b3 "/\" is continuous ) implies downarrow b2 is closed )
proof end;

definition
let c1 be non empty TopSpace;
let c2 be non empty NetStr of c1;
let c3 be Point of c1;
pred c3 is_a_cluster_point_of c2 means :Def9: :: WAYBEL_9:def 9
for b1 being a_neighborhood of a3 holds a2 is_often_in b1;
end;

:: deftheorem Def9 defines is_a_cluster_point_of WAYBEL_9:def 9 :
for b1 being non empty TopSpace
for b2 being non empty NetStr of b1
for b3 being Point of b1 holds
( b3 is_a_cluster_point_of b2 iff for b4 being a_neighborhood of b3 holds b2 is_often_in b4 );

theorem Th29: :: WAYBEL_9:29
for b1 being non empty TopSpace
for b2 being net of b1
for b3 being Point of b1 holds
( b3 in Lim b2 implies b3 is_a_cluster_point_of b2 )
proof end;

theorem Th30: :: WAYBEL_9:30
for b1 being non empty compact Hausdorff TopSpace
for b2 being net of b1 holds
ex b3 being Point of b1 st b3 is_a_cluster_point_of b2
proof end;

theorem Th31: :: WAYBEL_9:31
for b1 being non empty TopSpace
for b2 being net of b1
for b3 being subnet of b2
for b4 being Point of b1 holds
( b4 is_a_cluster_point_of b3 implies b4 is_a_cluster_point_of b2 )
proof end;

theorem Th32: :: WAYBEL_9:32
for b1 being non empty TopSpace
for b2 being net of b1
for b3 being Point of b1 holds
not ( b3 is_a_cluster_point_of b2 & ( for b4 being subnet of b2 holds
not b3 in Lim b4 ) )
proof end;

theorem Th33: :: WAYBEL_9:33
for b1 being non empty compact Hausdorff TopSpace
for b2 being net of b1 holds
( ( for b3, b4 being Point of b1 holds
( b3 is_a_cluster_point_of b2 & b4 is_a_cluster_point_of b2 implies b3 = b4 ) ) implies for b3 being Point of b1 holds
( b3 is_a_cluster_point_of b2 implies b3 in Lim b2 ) )
proof end;

theorem Th34: :: WAYBEL_9:34
for b1 being non empty TopSpace
for b2 being Point of b1
for b3 being net of b1
for b4 being Subset of b1 holds
( b2 is_a_cluster_point_of b3 & b4 is closed & rng the mapping of b3 c= b4 implies b2 in b4 )
proof end;

Lemma41: for b1 being compact Hausdorff TopLattice
for b2 being net of b1
for b3 being Point of b1
for b4 being Element of b1 holds
( b3 = b4 & ( for b5 being Element of b1 holds b5 "/\" is continuous ) & b2 is eventually-directed & b3 is_a_cluster_point_of b2 implies b4 is_>=_than rng the mapping of b2 )
proof end;

Lemma42: for b1 being compact Hausdorff TopLattice
for b2 being net of b1
for b3 being Point of b1
for b4 being Element of b1 holds
( b3 = b4 & ( for b5 being Element of b1 holds b5 "/\" is continuous ) & b3 is_a_cluster_point_of b2 implies for b5 being Element of b1 holds
( rng the mapping of b2 is_<=_than b5 implies b4 <= b5 ) )
proof end;

theorem Th35: :: WAYBEL_9:35
for b1 being compact Hausdorff TopLattice
for b2 being Point of b1
for b3 being net of b1 holds
( ( for b4 being Element of b1 holds b4 "/\" is continuous ) & b3 is eventually-directed & b2 is_a_cluster_point_of b3 implies b2 = sup b3 )
proof end;

Lemma44: for b1 being compact Hausdorff TopLattice
for b2 being net of b1
for b3 being Point of b1
for b4 being Element of b1 holds
( b3 = b4 & ( for b5 being Element of b1 holds b5 "/\" is continuous ) & b2 is eventually-filtered & b3 is_a_cluster_point_of b2 implies b4 is_<=_than rng the mapping of b2 )
proof end;

Lemma45: for b1 being compact Hausdorff TopLattice
for b2 being net of b1
for b3 being Point of b1
for b4 being Element of b1 holds
( b3 = b4 & ( for b5 being Element of b1 holds b5 "/\" is continuous ) & b3 is_a_cluster_point_of b2 implies for b5 being Element of b1 holds
( rng the mapping of b2 is_>=_than b5 implies b4 >= b5 ) )
proof end;

theorem Th36: :: WAYBEL_9:36
for b1 being compact Hausdorff TopLattice
for b2 being Point of b1
for b3 being net of b1 holds
( ( for b4 being Element of b1 holds b4 "/\" is continuous ) & b3 is eventually-filtered & b2 is_a_cluster_point_of b3 implies b2 = inf b3 )
proof end;

theorem Th37: :: WAYBEL_9:37
for b1 being Hausdorff TopLattice holds
( ( for b2 being net of b1 holds
( b2 is eventually-directed implies ( ex_sup_of b2 & sup b2 in Lim b2 ) ) ) & ( for b2 being Element of b1 holds b2 "/\" is continuous ) implies b1 is meet-continuous )
proof end;

theorem Th38: :: WAYBEL_9:38
for b1 being compact Hausdorff TopLattice holds
( ( for b2 being Element of b1 holds b2 "/\" is continuous ) implies for b2 being net of b1 holds
( b2 is eventually-directed implies ( ex_sup_of b2 & sup b2 in Lim b2 ) ) )
proof end;

theorem Th39: :: WAYBEL_9:39
for b1 being compact Hausdorff TopLattice holds
( ( for b2 being Element of b1 holds b2 "/\" is continuous ) implies for b2 being net of b1 holds
( b2 is eventually-filtered implies ( ex_inf_of b2 & inf b2 in Lim b2 ) ) )
proof end;

theorem Th40: :: WAYBEL_9:40
for b1 being compact Hausdorff TopLattice holds
( ( for b2 being Element of b1 holds b2 "/\" is continuous ) implies b1 is bounded )
proof end;

theorem Th41: :: WAYBEL_9:41
for b1 being compact Hausdorff TopLattice holds
( ( for b2 being Element of b1 holds b2 "/\" is continuous ) implies b1 is meet-continuous )
proof end;