:: WAYBEL10 semantic presentation

scheme :: WAYBEL10:sch 1
s1{ F1() -> non empty RelStr , P1[ set ], F2() -> set } :
ex b1 being non empty strict full SubRelStr of F1() st
for b2 being Element of F1() holds
( b2 is Element of b1 iff P1[b2] )
provided
E1: P1[F2()] and E2: F2() in the carrier of F1()
proof end;

scheme :: WAYBEL10:sch 2
s2{ F1() -> non empty RelStr , F2() -> non empty RelStr , P1[ set ], P2[ set , set ] } :
RelStr(# the carrier of F1(),the InternalRel of F1() #) = RelStr(# the carrier of F2(),the InternalRel of F2() #)
provided
E1: for b1 being set holds
( b1 is Element of F1() iff P1[b1] ) and E2: for b1 being set holds
( b1 is Element of F2() iff P1[b1] ) and E3: for b1, b2 being Element of F1() holds
( b1 <= b2 iff P2[b1,b2] ) and E4: for b1, b2 being Element of F2() holds
( b1 <= b2 iff P2[b1,b2] )
proof end;

scheme :: WAYBEL10:sch 3
s3{ F1() -> non empty RelStr , F2() -> non empty full SubRelStr of F1(), F3() -> non empty full SubRelStr of F1(), P1[ set ] } :
RelStr(# the carrier of F2(),the InternalRel of F2() #) = RelStr(# the carrier of F3(),the InternalRel of F3() #)
provided
E1: for b1 being set holds
( b1 is Element of F2() iff P1[b1] ) and E2: for b1 being set holds
( b1 is Element of F3() iff P1[b1] )
proof end;

scheme :: WAYBEL10:sch 4
s4{ F1() -> non empty RelStr , F2() -> non empty full SubRelStr of F1(), F3() -> non empty full SubRelStr of F1(), P1[ set ] } :
RelStr(# the carrier of F2(),the InternalRel of F2() #) = RelStr(# the carrier of F3(),the InternalRel of F3() #)
provided
E1: for b1 being Element of F1() holds
( b1 is Element of F2() iff P1[b1] ) and E2: for b1 being Element of F1() holds
( b1 is Element of F3() iff P1[b1] )
proof end;

theorem Th1: :: WAYBEL10:1
for b1, b2 being Relation holds
( ( b1 c= b2 implies b1 ~ c= b2 ~ ) & ( b1 ~ c= b2 ~ implies b1 c= b2 ) & ( b1 ~ c= b2 implies b1 c= b2 ~ ) & ( b1 c= b2 ~ implies b1 ~ c= b2 ) )
proof end;

theorem Th2: :: WAYBEL10:2
canceled;

theorem Th3: :: WAYBEL10:3
for b1, b2 being RelStr holds
( ( b2 is SubRelStr of b1 implies b2 opp is SubRelStr of b1 opp ) & ( b2 opp is SubRelStr of b1 opp implies b2 is SubRelStr of b1 ) & ( b2 opp is SubRelStr of b1 implies b2 is SubRelStr of b1 opp ) & ( b2 is SubRelStr of b1 opp implies b2 opp is SubRelStr of b1 ) )
proof end;

theorem Th4: :: WAYBEL10:4
for b1, b2 being RelStr holds
( ( b2 is full SubRelStr of b1 implies b2 opp is full SubRelStr of b1 opp ) & ( b2 opp is full SubRelStr of b1 opp implies b2 is full SubRelStr of b1 ) & ( b2 opp is full SubRelStr of b1 implies b2 is full SubRelStr of b1 opp ) & ( b2 is full SubRelStr of b1 opp implies b2 opp is full SubRelStr of b1 ) )
proof end;

definition
let c1 be RelStr ;
let c2 be full SubRelStr of c1;
redefine func ~ as c2 opp -> strict full SubRelStr of a1 opp ;
coherence
c2 ~ is strict full SubRelStr of c1 opp
by Th4;
end;

registration
let c1 be set ;
let c2 be non empty RelStr ;
cluster K120(a1,a2) -> non-Empty ;
coherence
c1 --> c2 is non-Empty
proof end;
end;

registration
let c1 be RelStr ;
let c2 be non empty reflexive RelStr ;
cluster monotone Relation of the carrier of a1,the carrier of a2;
existence
ex b1 being Function of c1,c2 st b1 is monotone
proof end;
end;

registration
let c1 be non empty RelStr ;
cluster projection -> idempotent monotone Relation of the carrier of a1,the carrier of a1;
coherence
for b1 being Function of c1,c1 holds
( b1 is projection implies ( b1 is monotone & b1 is idempotent ) )
by WAYBEL_1:def 13;
end;

registration
let c1, c2 be non empty reflexive RelStr ;
let c3 be monotone Function of c1,c2;
cluster corestr a3 -> monotone ;
coherence
corestr c3 is monotone
proof end;
end;

registration
let c1 be non empty reflexive RelStr ;
cluster id a1 -> idempotent infs-preserving sups-preserving ;
coherence
( id c1 is sups-preserving & id c1 is infs-preserving )
proof end;
end;

theorem Th5: :: WAYBEL10:5
for b1 being RelStr
for b2 being Subset of b1 holds
( id b2 is Function of (subrelstr b2),b1 & ( for b3 being Function of (subrelstr b2),b1 holds
( b3 = id b2 implies b3 is monotone ) ) )
proof end;

registration
let c1 be non empty reflexive RelStr ;
cluster V5 idempotent monotone infs-preserving sups-preserving closure kernel Relation of the carrier of a1,the carrier of a1;
existence
ex b1 being Function of c1,c1 st
( b1 is sups-preserving & b1 is infs-preserving & b1 is closure & b1 is kernel & b1 is one-to-one )
proof end;
end;

theorem Th6: :: WAYBEL10:6
for b1 being non empty reflexive RelStr
for b2 being closure Function of b1,b1
for b3 being Element of b1 holds b2 . b3 >= b3
proof end;

definition
let c1, c2 be 1-sorted ;
let c3 be Function of the carrier of c1,the carrier of c2;
let c4 be 1-sorted ;
assume E5: the carrier of c4 c= the carrier of c1 ;
func c3 | c4 -> Function of a4,a2 equals :Def1: :: WAYBEL10:def 1
a3 | the carrier of a4;
coherence
c3 | the carrier of c4 is Function of c4,c2
proof end;
correctness
;
end;

:: deftheorem Def1 defines | WAYBEL10:def 1 :
for b1, b2 being 1-sorted
for b3 being Function of the carrier of b1,the carrier of b2
for b4 being 1-sorted holds
( the carrier of b4 c= the carrier of b1 implies b3 | b4 = b3 | the carrier of b4 );

theorem Th7: :: WAYBEL10:7
for b1, b2 being RelStr
for b3 being SubRelStr of b1
for b4 being Function of the carrier of b1,the carrier of b2 holds
( b4 | b3 = b4 | the carrier of b3 & ( for b5 being set holds
( b5 in the carrier of b3 implies (b4 | b3) . b5 = b4 . b5 ) ) )
proof end;

theorem Th8: :: WAYBEL10:8
for b1, b2 being RelStr
for b3 being Function of b1,b2 holds
( b3 is one-to-one implies for b4 being SubRelStr of b1 holds b3 | b4 is one-to-one )
proof end;

registration
let c1, c2 be non empty reflexive RelStr ;
let c3 be monotone Function of c1,c2;
let c4 be SubRelStr of c1;
cluster a3 | a4 -> monotone ;
coherence
c3 | c4 is monotone
proof end;
end;

theorem Th9: :: WAYBEL10:9
for b1, b2 being non empty RelStr
for b3 being non empty SubRelStr of b1
for b4 being Function of b1,b2
for b5 being Function of b2,b1 holds
( b4 is one-to-one & b5 = b4 " implies ( b5 | (Image (b4 | b3)) is Function of (Image (b4 | b3)),b3 & b5 | (Image (b4 | b3)) = (b4 | b3) " ) )
proof end;

registration
let c1 be RelStr ;
let c2 be non empty reflexive RelStr ;
cluster MonMaps a1,a2 -> non empty ;
coherence
not MonMaps c1,c2 is empty
proof end;
end;

theorem Th10: :: WAYBEL10:10
for b1 being RelStr
for b2 being non empty reflexive RelStr
for b3 being set holds
( b3 is Element of (MonMaps b1,b2) iff b3 is monotone Function of b1,b2 )
proof end;

definition
let c1 be non empty reflexive RelStr ;
func ClOpers c1 -> non empty strict full SubRelStr of MonMaps a1,a1 means :Def2: :: WAYBEL10:def 2
for b1 being Function of a1,a1 holds
( b1 is Element of a2 iff b1 is closure );
existence
ex b1 being non empty strict full SubRelStr of MonMaps c1,c1 st
for b2 being Function of c1,c1 holds
( b2 is Element of b1 iff b2 is closure )
proof end;
correctness
uniqueness
for b1, b2 being non empty strict full SubRelStr of MonMaps c1,c1 holds
( ( for b3 being Function of c1,c1 holds
( b3 is Element of b1 iff b3 is closure ) ) & ( for b3 being Function of c1,c1 holds
( b3 is Element of b2 iff b3 is closure ) ) implies b1 = b2 )
;
proof end;
end;

:: deftheorem Def2 defines ClOpers WAYBEL10:def 2 :
for b1 being non empty reflexive RelStr
for b2 being non empty strict full SubRelStr of MonMaps b1,b1 holds
( b2 = ClOpers b1 iff for b3 being Function of b1,b1 holds
( b3 is Element of b2 iff b3 is closure ) );

theorem Th11: :: WAYBEL10:11
for b1 being non empty reflexive RelStr
for b2 being set holds
( b2 is Element of (ClOpers b1) iff b2 is closure Function of b1,b1 )
proof end;

theorem Th12: :: WAYBEL10:12
for b1 being set
for b2 being non empty RelStr
for b3, b4 being Function of b1,the carrier of b2
for b5, b6 being Element of (b2 |^ b1) holds
( b5 = b3 & b6 = b4 implies ( b5 <= b6 iff b3 <= b4 ) )
proof end;

theorem Th13: :: WAYBEL10:13
for b1 being complete LATTICE
for b2, b3 being Function of b1,b1
for b4, b5 being Element of (ClOpers b1) holds
( b4 = b2 & b5 = b3 implies ( b4 <= b5 iff b2 <= b3 ) )
proof end;

theorem Th14: :: WAYBEL10:14
for b1 being reflexive RelStr
for b2, b3 being full SubRelStr of b1 holds
( the carrier of b2 c= the carrier of b3 implies b2 is SubRelStr of b3 )
proof end;

theorem Th15: :: WAYBEL10:15
for b1 being complete LATTICE
for b2, b3 being closure Function of b1,b1 holds
( b2 <= b3 iff Image b3 is SubRelStr of Image b2 )
proof end;

definition
let c1 be RelStr ;
func Sub c1 -> non empty strict RelStr means :Def3: :: WAYBEL10:def 3
( ( for b1 being set holds
( b1 is Element of a2 iff b1 is strict SubRelStr of a1 ) ) & ( for b1, b2 being Element of a2 holds
( b1 <= b2 iff ex b3 being RelStr st
( b2 = b3 & b1 is SubRelStr of b3 ) ) ) );
existence
ex b1 being non empty strict RelStr st
( ( for b2 being set holds
( b2 is Element of b1 iff b2 is strict SubRelStr of c1 ) ) & ( for b2, b3 being Element of b1 holds
( b2 <= b3 iff ex b4 being RelStr st
( b3 = b4 & b2 is SubRelStr of b4 ) ) ) )
proof end;
correctness
uniqueness
for b1, b2 being non empty strict RelStr holds
( ( for b3 being set holds
( b3 is Element of b1 iff b3 is strict SubRelStr of c1 ) ) & ( for b3, b4 being Element of b1 holds
( b3 <= b4 iff ex b5 being RelStr st
( b4 = b5 & b3 is SubRelStr of b5 ) ) ) & ( for b3 being set holds
( b3 is Element of b2 iff b3 is strict SubRelStr of c1 ) ) & ( for b3, b4 being Element of b2 holds
( b3 <= b4 iff ex b5 being RelStr st
( b4 = b5 & b3 is SubRelStr of b5 ) ) ) implies b1 = b2 )
;
proof end;
end;

:: deftheorem Def3 defines Sub WAYBEL10:def 3 :
for b1 being RelStr
for b2 being non empty strict RelStr holds
( b2 = Sub b1 iff ( ( for b3 being set holds
( b3 is Element of b2 iff b3 is strict SubRelStr of b1 ) ) & ( for b3, b4 being Element of b2 holds
( b3 <= b4 iff ex b5 being RelStr st
( b4 = b5 & b3 is SubRelStr of b5 ) ) ) ) );

theorem Th16: :: WAYBEL10:16
for b1, b2 being RelStr
for b3, b4 being Element of (Sub b1) holds
( b4 = b2 implies ( b3 <= b4 iff b3 is SubRelStr of b2 ) )
proof end;

registration
let c1 be RelStr ;
cluster Sub a1 -> non empty strict reflexive transitive antisymmetric ;
coherence
( Sub c1 is reflexive & Sub c1 is antisymmetric & Sub c1 is transitive )
proof end;
end;

registration
let c1 be RelStr ;
cluster Sub a1 -> non empty strict reflexive transitive antisymmetric complete ;
coherence
Sub c1 is complete
proof end;
end;

registration
let c1 be complete LATTICE;
cluster infs-inheriting -> non empty SubRelStr of a1;
coherence
for b1 being SubRelStr of c1 holds
not ( b1 is closure & b1 is empty )
proof end;
cluster sups-inheriting -> non empty SubRelStr of a1;
coherence
for b1 being SubRelStr of c1 holds
not ( b1 is sups-inheriting & b1 is empty )
proof end;
end;

definition
let c1 be RelStr ;
mode System is full SubRelStr of a1;
end;

notation
let c1 be non empty RelStr ;
let c2 be System of c1;
synonym closure c2 for infs-inheriting c2;
end;

registration
let c1 be non empty RelStr ;
cluster subrelstr ([#] a1) -> infs-inheriting sups-inheriting ;
coherence
( subrelstr ([#] c1) is closure & subrelstr ([#] c1) is sups-inheriting )
proof end;
end;

definition
let c1 be non empty RelStr ;
func ClosureSystems c1 -> non empty strict full SubRelStr of Sub a1 means :Def4: :: WAYBEL10:def 4
for b1 being strict SubRelStr of a1 holds
( b1 is Element of a2 iff ( b1 is closure & b1 is full ) );
existence
ex b1 being non empty strict full SubRelStr of Sub c1 st
for b2 being strict SubRelStr of c1 holds
( b2 is Element of b1 iff ( b2 is closure & b2 is full ) )
proof end;
correctness
uniqueness
for b1, b2 being non empty strict full SubRelStr of Sub c1 holds
( ( for b3 being strict SubRelStr of c1 holds
( b3 is Element of b1 iff ( b3 is closure & b3 is full ) ) ) & ( for b3 being strict SubRelStr of c1 holds
( b3 is Element of b2 iff ( b3 is closure & b3 is full ) ) ) implies b1 = b2 )
;
proof end;
end;

:: deftheorem Def4 defines ClosureSystems WAYBEL10:def 4 :
for b1 being non empty RelStr
for b2 being non empty strict full SubRelStr of Sub b1 holds
( b2 = ClosureSystems b1 iff for b3 being strict SubRelStr of b1 holds
( b3 is Element of b2 iff ( b3 is closure & b3 is full ) ) );

theorem Th17: :: WAYBEL10:17
for b1 being non empty RelStr
for b2 being set holds
( b2 is Element of (ClosureSystems b1) iff b2 is strict closure System of b1 )
proof end;

theorem Th18: :: WAYBEL10:18
for b1 being non empty RelStr
for b2 being RelStr
for b3, b4 being Element of (ClosureSystems b1) holds
( b4 = b2 implies ( b3 <= b4 iff b3 is SubRelStr of b2 ) )
proof end;

registration
let c1 be non empty Poset;
let c2 be closure Function of c1,c1;
cluster Image a2 -> infs-inheriting ;
coherence
Image c2 is closure
by WAYBEL_1:56;
end;

definition
let c1 be non empty Poset;
func ClImageMap c1 -> Function of (ClOpers a1),((ClosureSystems a1) opp ) means :Def5: :: WAYBEL10:def 5
for b1 being closure Function of a1,a1 holds a2 . b1 = Image b1;
existence
ex b1 being Function of (ClOpers c1),((ClosureSystems c1) opp ) st
for b2 being closure Function of c1,c1 holds b1 . b2 = Image b2
proof end;
correctness
uniqueness
for b1, b2 being Function of (ClOpers c1),((ClosureSystems c1) opp ) holds
( ( for b3 being closure Function of c1,c1 holds b1 . b3 = Image b3 ) & ( for b3 being closure Function of c1,c1 holds b2 . b3 = Image b3 ) implies b1 = b2 )
;
proof end;
end;

:: deftheorem Def5 defines ClImageMap WAYBEL10:def 5 :
for b1 being non empty Poset
for b2 being Function of (ClOpers b1),((ClosureSystems b1) opp ) holds
( b2 = ClImageMap b1 iff for b3 being closure Function of b1,b1 holds b2 . b3 = Image b3 );

definition
let c1 be non empty RelStr ;
let c2 be SubRelStr of c1;
func closure_op c2 -> Function of a1,a1 means :Def6: :: WAYBEL10:def 6
for b1 being Element of a1 holds a3 . b1 = "/\" ((uparrow b1) /\ the carrier of a2),a1;
existence
ex b1 being Function of c1,c1 st
for b2 being Element of c1 holds b1 . b2 = "/\" ((uparrow b2) /\ the carrier of c2),c1
proof end;
uniqueness
for b1, b2 being Function of c1,c1 holds
( ( for b3 being Element of c1 holds b1 . b3 = "/\" ((uparrow b3) /\ the carrier of c2),c1 ) & ( for b3 being Element of c1 holds b2 . b3 = "/\" ((uparrow b3) /\ the carrier of c2),c1 ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def6 defines closure_op WAYBEL10:def 6 :
for b1 being non empty RelStr
for b2 being SubRelStr of b1
for b3 being Function of b1,b1 holds
( b3 = closure_op b2 iff for b4 being Element of b1 holds b3 . b4 = "/\" ((uparrow b4) /\ the carrier of b2),b1 );

registration
let c1 be complete LATTICE;
let c2 be closure System of c1;
cluster closure_op a2 -> idempotent monotone closure ;
coherence
closure_op c2 is closure
proof end;
end;

theorem Th19: :: WAYBEL10:19
for b1 being complete LATTICE
for b2 being closure System of b1 holds Image (closure_op b2) = RelStr(# the carrier of b2,the InternalRel of b2 #)
proof end;

theorem Th20: :: WAYBEL10:20
for b1 being complete LATTICE
for b2 being closure Function of b1,b1 holds closure_op (Image b2) = b2
proof end;

registration
let c1 be complete LATTICE;
cluster ClImageMap a1 -> V5 ;
coherence
ClImageMap c1 is one-to-one
proof end;
end;

theorem Th21: :: WAYBEL10:21
for b1 being complete LATTICE holds
(ClImageMap b1) " is Function of ((ClosureSystems b1) opp ),(ClOpers b1)
proof end;

theorem Th22: :: WAYBEL10:22
for b1 being complete LATTICE
for b2 being strict closure System of b1 holds ((ClImageMap b1) " ) . b2 = closure_op b2
proof end;

registration
let c1 be complete LATTICE;
cluster ClImageMap a1 -> V5 isomorphic ;
correctness
coherence
ClImageMap c1 is isomorphic
;
proof end;
end;

theorem Th23: :: WAYBEL10:23
for b1 being complete LATTICE holds ClOpers b1,(ClosureSystems b1) opp are_isomorphic
proof end;

theorem Th24: :: WAYBEL10:24
for b1 being RelStr
for b2 being full SubRelStr of b1
for b3 being Subset of b2 holds
( ( b3 is directed Subset of b1 implies b3 is directed ) & ( b3 is filtered Subset of b1 implies b3 is filtered ) )
proof end;

theorem Th25: :: WAYBEL10:25
for b1 being complete LATTICE
for b2 being closure System of b1 holds
( closure_op b2 is directed-sups-preserving iff b2 is directed-sups-inheriting )
proof end;

theorem Th26: :: WAYBEL10:26
for b1 being complete LATTICE
for b2 being closure Function of b1,b1 holds
( b2 is directed-sups-preserving iff Image b2 is directed-sups-inheriting )
proof end;

registration
let c1 be complete LATTICE;
let c2 be closure directed-sups-inheriting System of c1;
cluster closure_op a2 -> idempotent monotone directed-sups-preserving closure ;
coherence
closure_op c2 is directed-sups-preserving
by Th25;
end;

registration
let c1 be complete LATTICE;
let c2 be directed-sups-preserving closure Function of c1,c1;
cluster Image a2 -> infs-inheriting directed-sups-inheriting ;
coherence
Image c2 is directed-sups-inheriting
proof end;
end;

definition
let c1 be non empty reflexive RelStr ;
func DsupClOpers c1 -> non empty strict full SubRelStr of ClOpers a1 means :Def7: :: WAYBEL10:def 7
for b1 being closure Function of a1,a1 holds
( b1 is Element of a2 iff b1 is directed-sups-preserving );
existence
ex b1 being non empty strict full SubRelStr of ClOpers c1 st
for b2 being closure Function of c1,c1 holds
( b2 is Element of b1 iff b2 is directed-sups-preserving )
proof end;
correctness
uniqueness
for b1, b2 being non empty strict full SubRelStr of ClOpers c1 holds
( ( for b3 being closure Function of c1,c1 holds
( b3 is Element of b1 iff b3 is directed-sups-preserving ) ) & ( for b3 being closure Function of c1,c1 holds
( b3 is Element of b2 iff b3 is directed-sups-preserving ) ) implies b1 = b2 )
;
proof end;
end;

:: deftheorem Def7 defines DsupClOpers WAYBEL10:def 7 :
for b1 being non empty reflexive RelStr
for b2 being non empty strict full SubRelStr of ClOpers b1 holds
( b2 = DsupClOpers b1 iff for b3 being closure Function of b1,b1 holds
( b3 is Element of b2 iff b3 is directed-sups-preserving ) );

theorem Th27: :: WAYBEL10:27
for b1 being non empty reflexive RelStr
for b2 being set holds
( b2 is Element of (DsupClOpers b1) iff b2 is directed-sups-preserving closure Function of b1,b1 )
proof end;

definition
let c1 be non empty RelStr ;
func Subalgebras c1 -> non empty strict full SubRelStr of ClosureSystems a1 means :Def8: :: WAYBEL10:def 8
for b1 being strict closure System of a1 holds
( b1 is Element of a2 iff b1 is directed-sups-inheriting );
existence
ex b1 being non empty strict full SubRelStr of ClosureSystems c1 st
for b2 being strict closure System of c1 holds
( b2 is Element of b1 iff b2 is directed-sups-inheriting )
proof end;
correctness
uniqueness
for b1, b2 being non empty strict full SubRelStr of ClosureSystems c1 holds
( ( for b3 being strict closure System of c1 holds
( b3 is Element of b1 iff b3 is directed-sups-inheriting ) ) & ( for b3 being strict closure System of c1 holds
( b3 is Element of b2 iff b3 is directed-sups-inheriting ) ) implies b1 = b2 )
;
proof end;
end;

:: deftheorem Def8 defines Subalgebras WAYBEL10:def 8 :
for b1 being non empty RelStr
for b2 being non empty strict full SubRelStr of ClosureSystems b1 holds
( b2 = Subalgebras b1 iff for b3 being strict closure System of b1 holds
( b3 is Element of b2 iff b3 is directed-sups-inheriting ) );

theorem Th28: :: WAYBEL10:28
for b1 being non empty RelStr
for b2 being set holds
( b2 is Element of (Subalgebras b1) iff b2 is strict closure directed-sups-inheriting System of b1 )
proof end;

theorem Th29: :: WAYBEL10:29
for b1 being complete LATTICE holds Image ((ClImageMap b1) | (DsupClOpers b1)) = (Subalgebras b1) opp
proof end;

registration
let c1 be complete LATTICE;
cluster corestr ((ClImageMap a1) | (DsupClOpers a1)) -> monotone isomorphic ;
coherence
corestr ((ClImageMap c1) | (DsupClOpers c1)) is isomorphic
proof end;
end;

theorem Th30: :: WAYBEL10:30
for b1 being complete LATTICE holds DsupClOpers b1,(Subalgebras b1) opp are_isomorphic
proof end;