:: WAYBEL11 semantic presentation

Lemma1: for b1, b2 being RelStr
for b3, b4 being Element of b1
for b5, b6 being Element of b2 holds
( b3 = b5 & b4 = b6 & RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) & b3 <= b4 implies b5 <= b6 )
proof end;

scheme :: WAYBEL11:sch 1
s1{ F1() -> non empty set , F2() -> non empty set , P1[ set ], F3( set ) -> set , F4( set , set ) -> set } :
{ F3(b1) where B is Element of F1() : P1[b1] } = { F4(b1,b2) where B is Element of F2(), B is Element of F1() : P1[b2] }
provided
E2: for b1 being Element of F2()
for b2 being Element of F1() holds F3(b2) = F4(b1,b2)
proof end;

theorem Th1: :: WAYBEL11:1
for b1 being complete LATTICE
for b2, b3 being Subset of b1 holds
( b3 is_coarser_than b2 implies "/\" b2,b1 <= "/\" b3,b1 )
proof end;

theorem Th2: :: WAYBEL11:2
for b1 being complete LATTICE
for b2, b3 being Subset of b1 holds
( b2 is_finer_than b3 implies "\/" b2,b1 <= "\/" b3,b1 )
proof end;

theorem Th3: :: WAYBEL11:3
for b1 being RelStr
for b2 being upper Subset of b1
for b3 being directed Subset of b1 holds b2 /\ b3 is directed
proof end;

registration
let c1 be non empty reflexive RelStr ;
cluster non empty finite directed Element of bool the carrier of a1;
existence
ex b1 being Subset of c1 st
( not b1 is empty & b1 is directed & b1 is finite )
proof end;
end;

theorem Th4: :: WAYBEL11:4
for b1 being with_suprema Poset
for b2 being non empty finite directed Subset of b1 holds sup b2 in b2
proof end;

registration
cluster non empty finite trivial strict reflexive transitive antisymmetric with_suprema with_infima RelStr ;
existence
ex b1 being RelStr st
( b1 is trivial & b1 is reflexive & b1 is transitive & not b1 is empty & b1 is antisymmetric & b1 is with_suprema & b1 is with_infima & b1 is finite & b1 is strict )
proof end;
end;

registration
cluster strict non empty finite 1-sorted ;
existence
ex b1 being 1-sorted st
( b1 is finite & not b1 is empty & b1 is strict )
proof end;
end;

registration
let c1 be finite 1-sorted ;
cluster -> finite Element of bool the carrier of a1;
coherence
for b1 being Subset of c1 holds b1 is finite
proof end;
end;

registration
let c1 be RelStr ;
cluster {} a1 -> lower upper ;
coherence
( {} c1 is lower & {} c1 is upper )
proof end;
end;

registration
let c1 be non empty trivial RelStr ;
cluster -> upper Element of bool the carrier of a1;
coherence
for b1 being Subset of c1 holds b1 is upper
proof end;
end;

theorem Th5: :: WAYBEL11:5
for b1 being non empty RelStr
for b2 being Element of b1
for b3 being upper Subset of b1 holds
( not b2 in b3 implies b3 misses downarrow b2 )
proof end;

theorem Th6: :: WAYBEL11:6
for b1 being non empty RelStr
for b2 being Element of b1
for b3 being lower Subset of b1 holds
( b2 in b3 implies downarrow b2 c= b3 )
proof end;

definition
let c1 be non empty reflexive RelStr ;
let c2 be Subset of c1;
attr a2 is inaccessible_by_directed_joins means :Def1: :: WAYBEL11:def 1
for b1 being non empty directed Subset of a1 holds
not ( sup b1 in a2 & not b1 meets a2 );
attr a2 is closed_under_directed_sups means :Def2: :: WAYBEL11:def 2
for b1 being non empty directed Subset of a1 holds
( b1 c= a2 implies sup b1 in a2 );
attr a2 is property(S) means :Def3: :: WAYBEL11:def 3
for b1 being non empty directed Subset of a1 holds
not ( sup b1 in a2 & ( for b2 being Element of a1 holds
not ( b2 in b1 & ( for b3 being Element of a1 holds
( b3 in b1 & b3 >= b2 implies b3 in a2 ) ) ) ) );
end;

:: deftheorem Def1 defines inaccessible_by_directed_joins WAYBEL11:def 1 :
for b1 being non empty reflexive RelStr
for b2 being Subset of b1 holds
( b2 is inaccessible_by_directed_joins iff for b3 being non empty directed Subset of b1 holds
not ( sup b3 in b2 & not b3 meets b2 ) );

:: deftheorem Def2 defines closed_under_directed_sups WAYBEL11:def 2 :
for b1 being non empty reflexive RelStr
for b2 being Subset of b1 holds
( b2 is closed_under_directed_sups iff for b3 being non empty directed Subset of b1 holds
( b3 c= b2 implies sup b3 in b2 ) );

:: deftheorem Def3 defines property(S) WAYBEL11:def 3 :
for b1 being non empty reflexive RelStr
for b2 being Subset of b1 holds
( b2 is property(S) iff for b3 being non empty directed Subset of b1 holds
not ( sup b3 in b2 & ( for b4 being Element of b1 holds
not ( b4 in b3 & ( for b5 being Element of b1 holds
( b5 in b3 & b5 >= b4 implies b5 in b2 ) ) ) ) ) );

notation
let c1 be non empty reflexive RelStr ;
let c2 be Subset of c1;
synonym inaccessible c2 for inaccessible_by_directed_joins c2;
synonym directly_closed c2 for closed_under_directed_sups c2;
synonym c2 has_the_property_(S) for property(S) c2;
end;

registration
let c1 be non empty reflexive RelStr ;
cluster {} a1 -> lower upper directly_closed property(S) ;
coherence
( {} c1 is property(S) & {} c1 is closed_under_directed_sups )
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
cluster directly_closed property(S) Element of bool the carrier of a1;
existence
ex b1 being Subset of c1 st
( b1 is property(S) & b1 is closed_under_directed_sups )
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
let c2 be property(S) Subset of c1;
cluster a2 ` -> directly_closed ;
coherence
c2 ` is closed_under_directed_sups
proof end;
end;

definition
let c1 be non empty reflexive TopRelStr ;
attr a1 is Scott means :Def4: :: WAYBEL11:def 4
for b1 being Subset of a1 holds
( b1 is open iff ( b1 is inaccessible_by_directed_joins & b1 is upper ) );
end;

:: deftheorem Def4 defines Scott WAYBEL11:def 4 :
for b1 being non empty reflexive TopRelStr holds
( b1 is Scott iff for b2 being Subset of b1 holds
( b2 is open iff ( b2 is inaccessible_by_directed_joins & b2 is upper ) ) );

registration
let c1 be non empty finite reflexive transitive antisymmetric with_suprema RelStr ;
cluster -> finite inaccessible Element of bool the carrier of a1;
coherence
for b1 being Subset of c1 holds b1 is inaccessible_by_directed_joins
proof end;
end;

definition
let c1 be non empty finite reflexive transitive antisymmetric with_suprema TopRelStr ;
redefine attr a1 is Scott means :: WAYBEL11:def 5
for b1 being Subset of a1 holds
( b1 is open iff b1 is upper );
compatibility
( c1 is Scott iff for b1 being Subset of c1 holds
( b1 is open iff b1 is upper ) )
proof end;
end;

:: deftheorem Def5 defines Scott WAYBEL11:def 5 :
for b1 being non empty finite reflexive transitive antisymmetric with_suprema TopRelStr holds
( b1 is Scott iff for b2 being Subset of b1 holds
( b2 is open iff b2 is upper ) );

registration
cluster non empty trivial complete strict Scott TopRelStr ;
existence
ex b1 being TopLattice st
( b1 is trivial & b1 is complete & b1 is strict & not b1 is empty & b1 is Scott )
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
cluster [#] a1 -> inaccessible directly_closed ;
coherence
( [#] c1 is closed_under_directed_sups & [#] c1 is inaccessible_by_directed_joins )
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
cluster lower upper inaccessible directly_closed Element of bool the carrier of a1;
existence
ex b1 being Subset of c1 st
( b1 is closed_under_directed_sups & b1 is lower & b1 is inaccessible_by_directed_joins & b1 is upper )
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
let c2 be inaccessible Subset of c1;
cluster a2 ` -> directly_closed ;
coherence
c2 ` is closed_under_directed_sups
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
let c2 be directly_closed Subset of c1;
cluster a2 ` -> inaccessible ;
coherence
c2 ` is inaccessible_by_directed_joins
proof end;
end;

theorem Th7: :: WAYBEL11:7
for b1 being non empty reflexive transitive up-complete Scott TopRelStr
for b2 being Subset of b1 holds
( b2 is closed iff ( b2 is closed_under_directed_sups & b2 is lower ) )
proof end;

theorem Th8: :: WAYBEL11:8
for b1 being non empty reflexive transitive antisymmetric up-complete TopRelStr
for b2 being Element of b1 holds downarrow b2 is closed_under_directed_sups
proof end;

theorem Th9: :: WAYBEL11:9
for b1 being complete Scott TopLattice
for b2 being Element of b1 holds Cl {b2} = downarrow b2
proof end;

theorem Th10: :: WAYBEL11:10
for b1 being complete Scott TopLattice holds
b1 is T_0-TopSpace
proof end;

theorem Th11: :: WAYBEL11:11
for b1 being non empty reflexive transitive antisymmetric up-complete Scott TopRelStr
for b2 being Element of b1 holds downarrow b2 is closed
proof end;

theorem Th12: :: WAYBEL11:12
for b1 being up-complete Scott TopLattice
for b2 being Element of b1 holds (downarrow b2) ` is open
proof end;

theorem Th13: :: WAYBEL11:13
for b1 being up-complete Scott TopLattice
for b2 being Element of b1
for b3 being upper Subset of b1 holds
( not b2 in b3 implies (downarrow b2) ` is a_neighborhood of b3 )
proof end;

theorem Th14: :: WAYBEL11:14
for b1 being complete Scott TopLattice
for b2 being upper Subset of b1 holds
ex b3 being Subset-Family of b1 st
( b2 = meet b3 & ( for b4 being Subset of b1 holds
( b4 in b3 implies b4 is a_neighborhood of b2 ) ) )
proof end;

theorem Th15: :: WAYBEL11:15
for b1 being Scott TopLattice
for b2 being Subset of b1 holds
( b2 is open iff ( b2 is upper & b2 is property(S) ) )
proof end;

registration
let c1 be complete TopLattice;
cluster lower -> property(S) Element of bool the carrier of a1;
coherence
for b1 being Subset of c1 holds
( b1 is lower implies b1 is property(S) )
proof end;
end;

Lemma17: for b1 being non empty reflexive TopRelStr holds [#] b1 has_the_property_(S)
proof end;

theorem Th16: :: WAYBEL11:16
for b1 being non empty reflexive transitive TopRelStr holds
( the topology of b1 = { b2 where B is Subset of b1 : b2 has_the_property_(S) } implies b1 is TopSpace-like )
proof end;

definition
let c1 be non empty RelStr ;
let c2 be net of c1;
func lim_inf c2 -> Element of a1 equals :: WAYBEL11:def 6
"\/" { ("/\" { (a2 . b2) where B is Element of a2 : b2 >= b1 } ,a1) where B is Element of a2 : verum } ,a1;
correctness
coherence
"\/" { ("/\" { (c2 . b2) where B is Element of c2 : b2 >= b1 } ,c1) where B is Element of c2 : verum } ,c1 is Element of c1
;
;
end;

:: deftheorem Def6 defines lim_inf WAYBEL11:def 6 :
for b1 being non empty RelStr
for b2 being net of b1 holds lim_inf b2 = "\/" { ("/\" { (b2 . b4) where B is Element of b2 : b4 >= b3 } ,b1) where B is Element of b2 : verum } ,b1;

definition
let c1 be non empty reflexive RelStr ;
let c2 be net of c1;
let c3 be Element of c1;
pred c3 is_S-limit_of c2 means :Def7: :: WAYBEL11:def 7
a3 <= lim_inf a2;
end;

:: deftheorem Def7 defines is_S-limit_of WAYBEL11:def 7 :
for b1 being non empty reflexive RelStr
for b2 being net of b1
for b3 being Element of b1 holds
( b3 is_S-limit_of b2 iff b3 <= lim_inf b2 );

definition
let c1 be non empty reflexive RelStr ;
func Scott-Convergence c1 -> Convergence-Class of a1 means :Def8: :: WAYBEL11:def 8
for b1 being strict net of a1 holds
( b1 in NetUniv a1 implies for b2 being Element of a1 holds
( [b1,b2] in a2 iff b2 is_S-limit_of b1 ) );
existence
ex b1 being Convergence-Class of c1 st
for b2 being strict net of c1 holds
( b2 in NetUniv c1 implies for b3 being Element of c1 holds
( [b2,b3] in b1 iff b3 is_S-limit_of b2 ) )
proof end;
uniqueness
for b1, b2 being Convergence-Class of c1 holds
( ( for b3 being strict net of c1 holds
( b3 in NetUniv c1 implies for b4 being Element of c1 holds
( [b3,b4] in b1 iff b4 is_S-limit_of b3 ) ) ) & ( for b3 being strict net of c1 holds
( b3 in NetUniv c1 implies for b4 being Element of c1 holds
( [b3,b4] in b2 iff b4 is_S-limit_of b3 ) ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def8 defines Scott-Convergence WAYBEL11:def 8 :
for b1 being non empty reflexive RelStr
for b2 being Convergence-Class of b1 holds
( b2 = Scott-Convergence b1 iff for b3 being strict net of b1 holds
( b3 in NetUniv b1 implies for b4 being Element of b1 holds
( [b3,b4] in b2 iff b4 is_S-limit_of b3 ) ) );

theorem Th17: :: WAYBEL11:17
for b1 being complete LATTICE
for b2 being net of b1
for b3, b4 being Element of b1 holds
( b3 is_S-limit_of b2 & b2 is_eventually_in downarrow b4 implies b3 <= b4 )
proof end;

theorem Th18: :: WAYBEL11:18
for b1 being complete LATTICE
for b2 being net of b1
for b3, b4 being Element of b1 holds
( b2 is_eventually_in uparrow b4 implies lim_inf b2 >= b4 )
proof end;

definition
let c1 be non empty reflexive RelStr ;
let c2 be non empty NetStr of c1;
redefine attr a2 is monotone means :Def9: :: WAYBEL11:def 9
for b1, b2 being Element of a2 holds
( b1 <= b2 implies a2 . b1 <= a2 . b2 );
compatibility
( c2 is monotone iff for b1, b2 being Element of c2 holds
( b1 <= b2 implies c2 . b1 <= c2 . b2 ) )
proof end;
end;

:: deftheorem Def9 defines monotone WAYBEL11:def 9 :
for b1 being non empty reflexive RelStr
for b2 being non empty NetStr of b1 holds
( b2 is monotone iff for b3, b4 being Element of b2 holds
( b3 <= b4 implies b2 . b3 <= b2 . b4 ) );

definition
let c1 be non empty RelStr ;
let c2 be non empty set ;
let c3 be Function of c2,the carrier of c1;
func Net-Str c2,c3 -> non empty strict NetStr of a1 means :Def10: :: WAYBEL11:def 10
( the carrier of a4 = a2 & the mapping of a4 = a3 & ( for b1, b2 being Element of a4 holds
( b1 <= b2 iff a4 . b1 <= a4 . b2 ) ) );
existence
ex b1 being non empty strict NetStr of c1 st
( the carrier of b1 = c2 & the mapping of b1 = c3 & ( for b2, b3 being Element of b1 holds
( b2 <= b3 iff b1 . b2 <= b1 . b3 ) ) )
proof end;
uniqueness
for b1, b2 being non empty strict NetStr of c1 holds
( the carrier of b1 = c2 & the mapping of b1 = c3 & ( for b3, b4 being Element of b1 holds
( b3 <= b4 iff b1 . b3 <= b1 . b4 ) ) & the carrier of b2 = c2 & the mapping of b2 = c3 & ( for b3, b4 being Element of b2 holds
( b3 <= b4 iff b2 . b3 <= b2 . b4 ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def10 defines Net-Str WAYBEL11:def 10 :
for b1 being non empty RelStr
for b2 being non empty set
for b3 being Function of b2,the carrier of b1
for b4 being non empty strict NetStr of b1 holds
( b4 = Net-Str b2,b3 iff ( the carrier of b4 = b2 & the mapping of b4 = b3 & ( for b5, b6 being Element of b4 holds
( b5 <= b6 iff b4 . b5 <= b4 . b6 ) ) ) );

theorem Th19: :: WAYBEL11:19
for b1 being non empty 1-sorted
for b2 being non empty NetStr of b1 holds rng the mapping of b2 = { (b2 . b3) where B is Element of b2 : verum }
proof end;

theorem Th20: :: WAYBEL11:20
for b1 being non empty RelStr
for b2 being non empty set
for b3 being Function of b2,the carrier of b1 holds
( rng b3 is directed implies Net-Str b2,b3 is directed )
proof end;

registration
let c1 be non empty RelStr ;
let c2 be non empty set ;
let c3 be Function of c2,the carrier of c1;
cluster Net-Str a2,a3 -> non empty strict monotone ;
coherence
Net-Str c2,c3 is monotone
proof end;
end;

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

registration
let c1 be non empty reflexive RelStr ;
let c2 be non empty set ;
let c3 be Function of c2,the carrier of c1;
cluster Net-Str a2,a3 -> non empty reflexive strict monotone ;
coherence
Net-Str c2,c3 is reflexive
proof end;
end;

theorem Th21: :: WAYBEL11:21
for b1 being non empty transitive RelStr
for b2 being non empty set
for b3 being Function of b2,the carrier of b1 holds
( b2 c= the carrier of b1 & Net-Str b2,b3 is directed implies Net-Str b2,b3 in NetUniv b1 )
proof end;

registration
let c1 be LATTICE;
cluster reflexive strict monotone NetStr of a1;
existence
ex b1 being net of c1 st
( b1 is monotone & b1 is reflexive & b1 is strict )
proof end;
end;

theorem Th22: :: WAYBEL11:22
for b1 being complete LATTICE
for b2 being reflexive monotone net of b1 holds lim_inf b2 = sup b2
proof end;

theorem Th23: :: WAYBEL11:23
for b1 being complete LATTICE
for b2 being constant net of b1 holds the_value_of b2 = lim_inf b2
proof end;

theorem Th24: :: WAYBEL11:24
for b1 being complete LATTICE
for b2 being constant net of b1 holds the_value_of b2 is_S-limit_of b2
proof end;

definition
let c1 be non empty 1-sorted ;
let c2 be Element of c1;
func Net-Str c2 -> strict NetStr of a1 means :Def11: :: WAYBEL11:def 11
( the carrier of a3 = {a2} & the InternalRel of a3 = {[a2,a2]} & the mapping of a3 = id {a2} );
existence
ex b1 being strict NetStr of c1 st
( the carrier of b1 = {c2} & the InternalRel of b1 = {[c2,c2]} & the mapping of b1 = id {c2} )
proof end;
uniqueness
for b1, b2 being strict NetStr of c1 holds
( the carrier of b1 = {c2} & the InternalRel of b1 = {[c2,c2]} & the mapping of b1 = id {c2} & the carrier of b2 = {c2} & the InternalRel of b2 = {[c2,c2]} & the mapping of b2 = id {c2} implies b1 = b2 )
;
end;

:: deftheorem Def11 defines Net-Str WAYBEL11:def 11 :
for b1 being non empty 1-sorted
for b2 being Element of b1
for b3 being strict NetStr of b1 holds
( b3 = Net-Str b2 iff ( the carrier of b3 = {b2} & the InternalRel of b3 = {[b2,b2]} & the mapping of b3 = id {b2} ) );

registration
let c1 be non empty 1-sorted ;
let c2 be Element of c1;
cluster Net-Str a2 -> non empty strict ;
coherence
not Net-Str c2 is empty
proof end;
end;

theorem Th25: :: WAYBEL11:25
for b1 being non empty 1-sorted
for b2 being Element of b1
for b3 being Element of (Net-Str b2) holds b3 = b2
proof end;

theorem Th26: :: WAYBEL11:26
for b1 being non empty 1-sorted
for b2 being Element of b1
for b3 being Element of (Net-Str b2) holds (Net-Str b2) . b3 = b2
proof end;

registration
let c1 be non empty 1-sorted ;
let c2 be Element of c1;
cluster Net-Str a2 -> non empty reflexive transitive antisymmetric strict directed ;
coherence
( Net-Str c2 is reflexive & Net-Str c2 is transitive & Net-Str c2 is directed & Net-Str c2 is antisymmetric )
proof end;
end;

theorem Th27: :: WAYBEL11:27
for b1 being non empty 1-sorted
for b2 being Element of b1
for b3 being set holds
( Net-Str b2 is_eventually_in b3 iff b2 in b3 )
proof end;

theorem Th28: :: WAYBEL11:28
for b1 being non empty reflexive antisymmetric RelStr
for b2 being Element of b1 holds b2 = lim_inf (Net-Str b2)
proof end;

theorem Th29: :: WAYBEL11:29
for b1 being non empty reflexive RelStr
for b2 being Element of b1 holds Net-Str b2 in NetUniv b1
proof end;

theorem Th30: :: WAYBEL11:30
for b1 being complete LATTICE
for b2 being net of b1
for b3 being Subset of b1 holds
( b3 = { ("/\" { (b2 . b5) where B is Element of b2 : b5 >= b4 } ,b1) where B is Element of b2 : verum } implies ( not b3 is empty & b3 is directed ) )
proof end;

theorem Th31: :: WAYBEL11:31
for b1 being complete LATTICE
for b2 being Subset of b1 holds
( b2 in the topology of (ConvergenceSpace (Scott-Convergence b1)) iff ( b2 is inaccessible_by_directed_joins & b2 is upper ) )
proof end;

theorem Th32: :: WAYBEL11:32
for b1 being complete Scott TopLattice holds TopStruct(# the carrier of b1,the topology of b1 #) = ConvergenceSpace (Scott-Convergence b1)
proof end;

theorem Th33: :: WAYBEL11:33
for b1 being complete TopLattice holds
( TopStruct(# the carrier of b1,the topology of b1 #) = ConvergenceSpace (Scott-Convergence b1) implies for b2 being Subset of b1 holds
( b2 is open iff ( b2 is inaccessible_by_directed_joins & b2 is upper ) ) )
proof end;

theorem Th34: :: WAYBEL11:34
for b1 being complete TopLattice holds
( TopStruct(# the carrier of b1,the topology of b1 #) = ConvergenceSpace (Scott-Convergence b1) implies b1 is Scott )
proof end;

registration
let c1 be complete LATTICE;
cluster Scott-Convergence a1 -> (CONSTANTS) ;
coherence
Scott-Convergence c1 is (CONSTANTS)
proof end;
end;

registration
let c1 be complete LATTICE;
cluster Scott-Convergence a1 -> (CONSTANTS) (SUBNETS) ;
coherence
Scott-Convergence c1 is (SUBNETS)
proof end;
end;

theorem Th35: :: WAYBEL11:35
for b1 being non empty 1-sorted
for b2 being net of b1
for b3 being set
for b4 being subnet of b2 holds
( b4 = b2 " b3 implies for b5 being Element of b4 holds b4 . b5 in b3 )
proof end;

definition
let c1 be non empty reflexive RelStr ;
func sigma c1 -> Subset-Family of a1 equals :: WAYBEL11:def 12
the topology of (ConvergenceSpace (Scott-Convergence a1));
coherence
the topology of (ConvergenceSpace (Scott-Convergence c1)) is Subset-Family of c1
by YELLOW_6:def 27;
end;

:: deftheorem Def12 defines sigma WAYBEL11:def 12 :
for b1 being non empty reflexive RelStr holds sigma b1 = the topology of (ConvergenceSpace (Scott-Convergence b1));

theorem Th36: :: WAYBEL11:36
for b1 being complete continuous Scott TopLattice
for b2 being Element of b1 holds wayabove b2 is open
proof end;

theorem Th37: :: WAYBEL11:37
for b1 being complete TopLattice holds
( the topology of b1 = sigma b1 implies b1 is Scott )
proof end;

Lemma43: for b1, b2 being TopStruct holds
( TopStruct(# the carrier of b1,the topology of b1 #) = TopStruct(# the carrier of b2,the topology of b2 #) & b1 is TopSpace-like implies b2 is TopSpace-like )
proof end;

Lemma44: for b1, b2 being non empty 1-sorted holds
( the carrier of b1 = the carrier of b2 implies for b3 being strict net of b1 holds
b3 is strict net of b2 )
;

Lemma45: for b1, b2 being non empty 1-sorted holds
( the carrier of b1 = the carrier of b2 implies NetUniv b1 = NetUniv b2 )
proof end;

Lemma46: for b1, b2 being non empty 1-sorted
for b3 being set holds
( the carrier of b1 = the carrier of b2 implies for b4 being net of b1
for b5 being net of b2 holds
( b4 = b5 & b4 is_eventually_in b3 implies b5 is_eventually_in b3 ) )
proof end;

Lemma47: for b1, b2 being non empty TopSpace holds
( TopStruct(# the carrier of b1,the topology of b1 #) = TopStruct(# the carrier of b2,the topology of b2 #) implies for b3 being net of b1
for b4 being net of b2 holds
( b3 = b4 implies for b5 being Point of b1
for b6 being Point of b2 holds
( b5 = b6 & b5 in Lim b3 implies b6 in Lim b4 ) ) )
proof end;

Lemma48: for b1, b2 being non empty TopSpace holds
( TopStruct(# the carrier of b1,the topology of b1 #) = TopStruct(# the carrier of b2,the topology of b2 #) implies Convergence b1 = Convergence b2 )
proof end;

Lemma49: for b1, b2 being non empty RelStr holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) & b1 is LATTICE implies b2 is LATTICE )
proof end;

Lemma50: for b1, b2 being LATTICE
for b3 being set holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b4 being Element of b1
for b5 being Element of b2 holds
( b4 = b5 & b3 is_<=_than b4 implies b3 is_<=_than b5 ) )
proof end;

Lemma51: for b1, b2 being LATTICE
for b3 being set holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b4 being Element of b1
for b5 being Element of b2 holds
( b4 = b5 & b3 is_>=_than b4 implies b3 is_>=_than b5 ) )
proof end;

Lemma52: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b3 being set holds "\/" b3,b1 = "\/" b3,b2 )
proof end;

Lemma53: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b3 being set holds "/\" b3,b1 = "/\" b3,b2 )
proof end;

Lemma54: for b1, b2 being non empty reflexive RelStr holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b3 being Subset of b1
for b4 being Subset of b2 holds
( b3 = b4 & b3 is directed implies b4 is directed ) )
proof end;

Lemma55: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b3, b4 being Element of b1 holds
( b3 << b4 implies for b5, b6 being Element of b2 holds
( b3 = b5 & b4 = b6 implies b5 << b6 ) ) )
proof end;

Lemma56: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b3 being net of b1
for b4 being net of b2 holds
( b3 = b4 implies lim_inf b3 = lim_inf b4 ) )
proof end;

Lemma57: for b1, b2 being non empty reflexive RelStr
for b3 being non empty set holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b4 being net of b1
for b5 being net of b2 holds
( b4 = b5 implies for b6 being net_set of the carrier of b4,b1
for b7 being net_set of the carrier of b5,b2 holds
( b6 = b7 implies Iterated b6 = Iterated b7 ) ) )
proof end;

Lemma58: for b1, b2 being non empty reflexive RelStr
for b3 being non empty set holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies for b4 being net of b1
for b5 being net of b2 holds
( b4 = b5 implies for b6 being net_set of the carrier of b4,b1 holds
b6 is net_set of the carrier of b5,b2 ) )
proof end;

Lemma59: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies Scott-Convergence b1 c= Scott-Convergence b2 )
proof end;

Lemma60: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies Scott-Convergence b1 = Scott-Convergence b2 )
proof end;

Lemma61: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) implies sigma b1 = sigma b2 )
proof end;

Lemma62: for b1, b2 being LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) & b1 is complete implies b2 is complete )
proof end;

Lemma63: for b1, b2 being complete LATTICE holds
( RelStr(# the carrier of b1,the InternalRel of b1 #) = RelStr(# the carrier of b2,the InternalRel of b2 #) & b1 is continuous implies b2 is continuous )
proof end;

registration
let c1 be complete continuous LATTICE;
cluster Scott-Convergence a1 -> (CONSTANTS) (SUBNETS) topological ;
coherence
Scott-Convergence c1 is topological
proof end;
end;

theorem Th38: :: WAYBEL11:38
for b1 being complete continuous Scott TopLattice
for b2 being Element of b1
for b3 being net of b1 holds
( b3 in NetUniv b1 implies ( b2 is_S-limit_of b3 iff b2 in Lim b3 ) )
proof end;

theorem Th39: :: WAYBEL11:39
for b1 being non empty complete Poset holds
( Scott-Convergence b1 is (ITERATED_LIMITS) implies b1 is continuous )
proof end;

theorem Th40: :: WAYBEL11:40
for b1 being complete Scott TopLattice holds
( b1 is continuous iff Convergence b1 = Scott-Convergence b1 )
proof end;

theorem Th41: :: WAYBEL11:41
for b1 being complete Scott TopLattice
for b2 being upper Subset of b1 holds
( b2 is Open implies b2 is open )
proof end;

theorem Th42: :: WAYBEL11:42
for b1 being non empty RelStr
for b2 being upper Subset of b1
for b3 being Element of b1 holds
( b3 in b2 implies uparrow b3 c= b2 )
proof end;

theorem Th43: :: WAYBEL11:43
for b1 being complete continuous Scott TopLattice
for b2 being Element of b1
for b3 being Subset of b1 holds
not ( b3 is open & b2 in b3 & ( for b4 being Element of b1 holds
not ( b4 << b2 & b4 in b3 ) ) )
proof end;

theorem Th44: :: WAYBEL11:44
for b1 being complete continuous Scott TopLattice
for b2 being Element of b1 holds
{ (wayabove b3) where B is Element of b1 : b3 << b2 } is Basis of b2
proof end;

theorem Th45: :: WAYBEL11:45
for b1 being complete continuous Scott TopLattice holds
{ (wayabove b2) where B is Element of b1 : verum } is Basis of b1
proof end;

theorem Th46: :: WAYBEL11:46
for b1 being complete continuous Scott TopLattice
for b2 being upper Subset of b1 holds
( b2 is open iff b2 is Open )
proof end;

theorem Th47: :: WAYBEL11:47
for b1 being complete continuous Scott TopLattice
for b2 being Element of b1 holds Int (uparrow b2) = wayabove b2
proof end;

theorem Th48: :: WAYBEL11:48
for b1 being complete continuous Scott TopLattice
for b2 being Subset of b1 holds Int b2 = union { (wayabove b3) where B is Element of b1 : wayabove b3 c= b2 }
proof end;