:: YELLOW_0 semantic presentation

scheme :: YELLOW_0:sch 1
RelStrEx{ F₁() -> non empty set , P₁[ set , set ] } :

ex L being non empty strict RelStr st
( the carrier of L = F₁() & ( for a, b being Element of L holds
( a <= b iff P₁[a,b] ) ) )

proof end;

definition

let A be non empty RelStr ;
redefine attr A is reflexive means :: YELLOW_0:def 1
for x being Element of A holds x <= x;
compatibility

proof end;

end;

:: deftheorem defines reflexive YELLOW_0:def 1 :

definition

let A be RelStr ;
redefine attr A is transitive means :: YELLOW_0:def 2
for x, y, z being Element of A st x <= y & y <= z holds
x <= z;
compatibility

proof end;

redefine attr A is antisymmetric means :: YELLOW_0:def 3
for x, y being Element of A st x <= y & y <= x holds
x = y;
compatibility

proof end;

end;

:: deftheorem defines transitive YELLOW_0:def 2 :

:: deftheorem defines antisymmetric YELLOW_0:def 3 :

registration

cluster non empty complete -> non empty with_suprema with_infima RelStr ;
coherence by LATTICE3:12;
cluster non empty reflexive trivial -> non empty reflexive transitive antisymmetric complete RelStr ;
coherence

proof end;

end;

registration

let x be set ;
let R be Relation of {x};
cluster RelStr(# {x},R #) -> trivial ;
coherence

proof end;

end;

registration

cluster non empty strict reflexive transitive antisymmetric with_suprema with_infima complete trivial RelStr ;
existence

proof end;

end;

theorem Th1: :: YELLOW_0:1

for P1, P2 being RelStr st RelStr(# the carrier of P1,the InternalRel of P1 #) = RelStr(# the carrier of P2,the InternalRel of P2 #) holds
for a1, b1 being Element of P1
for a2, b2 being Element of P2 st a1 = a2 & b1 = b2 holds
( ( a1 <= b1 implies a2 <= b2 ) & ( a1 < b1 implies a2 < b2 ) )

proof end;

theorem Th2: :: YELLOW_0:2

for P1, P2 being RelStr st RelStr(# the carrier of P1,the InternalRel of P1 #) = RelStr(# the carrier of P2,the InternalRel of P2 #) holds
for X being set
for a1 being Element of P1
for a2 being Element of P2 st a1 = a2 holds
( ( X is_<=_than a1 implies X is_<=_than a2 ) & ( X is_>=_than a1 implies X is_>=_than a2 ) )

proof end;

theorem :: YELLOW_0:3

for P1, P2 being RelStr st RelStr(# the carrier of P1,the InternalRel of P1 #) = RelStr(# the carrier of P2,the InternalRel of P2 #) & P1 is complete holds
P2 is complete

proof end;

theorem Th4: :: YELLOW_0:4

for L being transitive RelStr
for x, y being Element of L st x <= y holds
for X being set holds
( ( y is_<=_than X implies x is_<=_than X ) & ( x is_>=_than X implies y is_>=_than X ) )

proof end;

theorem Th5: :: YELLOW_0:5

for L being non empty RelStr
for X being set
for x being Element of L holds
( ( x is_>=_than X implies x is_>=_than X /\ the carrier of L ) & ( x is_>=_than X /\ the carrier of L implies x is_>=_than X ) & ( x is_<=_than X implies x is_<=_than X /\ the carrier of L ) & ( x is_<=_than X /\ the carrier of L implies x is_<=_than X ) )

proof end;

theorem Th6: :: YELLOW_0:6

for L being RelStr
for a being Element of L holds
( {} is_<=_than a & {} is_>=_than a )

proof end;

theorem Th7: :: YELLOW_0:7

for L being RelStr
for a, b being Element of L holds
( ( a is_<=_than {b} implies a <= b ) & ( a <= b implies a is_<=_than {b} ) & ( a is_>=_than {b} implies b <= a ) & ( b <= a implies a is_>=_than {b} ) )

proof end;

theorem Th8: :: YELLOW_0:8

for L being RelStr
for a, b, c being Element of L holds
( ( a is_<=_than {b,c} implies ( a <= b & a <= c ) ) & ( a <= b & a <= c implies a is_<=_than {b,c} ) & ( a is_>=_than {b,c} implies ( b <= a & c <= a ) ) & ( b <= a & c <= a implies a is_>=_than {b,c} ) )

proof end;

theorem Th9: :: YELLOW_0:9

for L being RelStr
for X, Y being set st X c= Y holds
for x being Element of L holds
( ( x is_<=_than Y implies x is_<=_than X ) & ( x is_>=_than Y implies x is_>=_than X ) )

proof end;

theorem Th10: :: YELLOW_0:10

for L being RelStr
for X, Y being set
for x being Element of L holds
( ( x is_<=_than X & x is_<=_than Y implies x is_<=_than X \/ Y ) & ( x is_>=_than X & x is_>=_than Y implies x is_>=_than X \/ Y ) )

proof end;

theorem Th11: :: YELLOW_0:11

for L being transitive RelStr
for X being set
for x, y being Element of L st X is_<=_than x & x <= y holds
X is_<=_than y

proof end;

theorem Th12: :: YELLOW_0:12

for L being transitive RelStr
for X being set
for x, y being Element of L st X is_>=_than x & x >= y holds
X is_>=_than y

proof end;

registration

let L be non empty RelStr ;
cluster [#] L -> non empty ;
coherence by PRE_TOPC:12;

end;

definition

let L be RelStr ;
attr L is lower-bounded means :Def4: :: YELLOW_0:def 4
ex x being Element of L st x is_<=_than the carrier of L;
attr L is upper-bounded means :Def5: :: YELLOW_0:def 5
ex x being Element of L st x is_>=_than the carrier of L;

end;

:: deftheorem Def4 defines lower-bounded YELLOW_0:def 4 :

:: deftheorem Def5 defines upper-bounded YELLOW_0:def 5 :

definition

let L be RelStr ;
attr L is bounded means :: YELLOW_0:def 6
( L is lower-bounded & L is upper-bounded );

end;

:: deftheorem defines bounded YELLOW_0:def 6 :

theorem :: YELLOW_0:13

for P1, P2 being RelStr st RelStr(# the carrier of P1,the InternalRel of P1 #) = RelStr(# the carrier of P2,the InternalRel of P2 #) holds
( ( P1 is lower-bounded implies P2 is lower-bounded ) & ( P1 is upper-bounded implies P2 is upper-bounded ) )

proof end;

registration

cluster non empty complete -> non empty bounded RelStr ;
coherence

proof end;

cluster bounded -> lower-bounded upper-bounded RelStr ;
coherence

proof end;

cluster lower-bounded upper-bounded -> bounded RelStr ;
coherence

proof end;

end;

registration

cluster non empty with_suprema with_infima complete lower-bounded upper-bounded bounded RelStr ;
existence

proof end;

end;

definition

let L be RelStr ;
let X be set ;
pred ex_sup_of X,L means :Def7: :: YELLOW_0:def 7
ex a being Element of L st
( X is_<=_than a & ( for b being Element of L st X is_<=_than b holds
b >= a ) & ( for c being Element of L st X is_<=_than c & ( for b being Element of L st X is_<=_than b holds
b >= c ) holds
c = a ) );
pred ex_inf_of X,L means :Def8: :: YELLOW_0:def 8
ex a being Element of L st
( X is_>=_than a & ( for b being Element of L st X is_>=_than b holds
b <= a ) & ( for c being Element of L st X is_>=_than c & ( for b being Element of L st X is_>=_than b holds
b <= c ) holds
c = a ) );

end;

:: deftheorem Def7 defines ex_sup_of YELLOW_0:def 7 :

:: deftheorem Def8 defines ex_inf_of YELLOW_0:def 8 :

theorem Th14: :: YELLOW_0:14

for L1, L2 being RelStr st RelStr(# the carrier of L1,the InternalRel of L1 #) = RelStr(# the carrier of L2,the InternalRel of L2 #) holds
for X being set holds
( ( ex_sup_of X,L1 implies ex_sup_of X,L2 ) & ( ex_inf_of X,L1 implies ex_inf_of X,L2 ) )

proof end;

theorem Th15: :: YELLOW_0:15

for L being antisymmetric RelStr
for X being set holds
( ex_sup_of X,L iff ex a being Element of L st
( X is_<=_than a & ( for b being Element of L st X is_<=_than b holds
a <= b ) ) )

proof end;

theorem Th16: :: YELLOW_0:16

for L being antisymmetric RelStr
for X being set holds
( ex_inf_of X,L iff ex a being Element of L st
( X is_>=_than a & ( for b being Element of L st X is_>=_than b holds
a >= b ) ) )

proof end;

theorem Th17: :: YELLOW_0:17

for L being non empty antisymmetric complete RelStr
for X being set holds
( ex_sup_of X,L & ex_inf_of X,L )

proof end;

theorem Th18: :: YELLOW_0:18

for L being antisymmetric RelStr
for a, b, c being Element of L holds
( c = a "\/" b & ex_sup_of {a,b},L iff ( c >= a & c >= b & ( for d being Element of L st d >= a & d >= b holds
c <= d ) ) )

proof end;

theorem Th19: :: YELLOW_0:19

for L being antisymmetric RelStr
for a, b, c being Element of L holds
( c = a "/\" b & ex_inf_of {a,b},L iff ( c <= a & c <= b & ( for d being Element of L st d <= a & d <= b holds
c >= d ) ) )

proof end;

theorem Th20: :: YELLOW_0:20

for L being antisymmetric RelStr holds
( L is with_suprema iff for a, b being Element of L holds ex_sup_of {a,b},L )

proof end;

theorem Th21: :: YELLOW_0:21

for L being antisymmetric RelStr holds
( L is with_infima iff for a, b being Element of L holds ex_inf_of {a,b},L )

proof end;

theorem Th22: :: YELLOW_0:22

for L being antisymmetric with_suprema RelStr
for a, b, c being Element of L holds
( c = a "\/" b iff ( c >= a & c >= b & ( for d being Element of L st d >= a & d >= b holds
c <= d ) ) )

proof end;

theorem Th23: :: YELLOW_0:23

for L being antisymmetric with_infima RelStr
for a, b, c being Element of L holds
( c = a "/\" b iff ( c <= a & c <= b & ( for d being Element of L st d <= a & d <= b holds
c >= d ) ) )

proof end;

theorem :: YELLOW_0:24

for L being reflexive antisymmetric with_suprema RelStr
for a, b being Element of L holds
( a = a "\/" b iff a >= b )

proof end;

theorem :: YELLOW_0:25

for L being reflexive antisymmetric with_infima RelStr
for a, b being Element of L holds
( a = a "/\" b iff a <= b )

proof end;

definition

let L be RelStr ;
let X be set ;
func "\/" X,L -> Element of L means :Def9: :: YELLOW_0:def 9
( X is_<=_than it & ( for a being Element of L st X is_<=_than a holds
it <= a ) ) if ex_sup_of X,L
;
uniqueness

proof end;

existence

proof end;

correctness ;
func "/\" X,L -> Element of L means :Def10: :: YELLOW_0:def 10
( X is_>=_than it & ( for a being Element of L st X is_>=_than a holds
a <= it ) ) if ex_inf_of X,L
;
uniqueness

proof end;

existence

proof end;

correctness ;

end;

:: deftheorem Def9 defines "\/" YELLOW_0:def 9 :

:: deftheorem Def10 defines "/\" YELLOW_0:def 10 :

theorem :: YELLOW_0:26

for L1, L2 being RelStr st RelStr(# the carrier of L1,the InternalRel of L1 #) = RelStr(# the carrier of L2,the InternalRel of L2 #) holds
for X being set st ex_sup_of X,L1 holds
"\/" X,L1 = "\/" X,L2

proof end;

theorem :: YELLOW_0:27

for L1, L2 being RelStr st RelStr(# the carrier of L1,the InternalRel of L1 #) = RelStr(# the carrier of L2,the InternalRel of L2 #) holds
for X being set st ex_inf_of X,L1 holds
"/\" X,L1 = "/\" X,L2

proof end;

theorem :: YELLOW_0:28

for L being non empty complete Poset
for X being set holds
( "\/" X,L = "\/" X,(latt L) & "/\" X,L = "/\" X,(latt L) )

proof end;

theorem :: YELLOW_0:29

for L being complete Lattice
for X being set holds
( "\/" X,L = "\/" X,(LattPOSet L) & "/\" X,L = "/\" X,(LattPOSet L) )

proof end;

theorem Th30: :: YELLOW_0:30

for L being antisymmetric RelStr
for a being Element of L
for X being set holds
( a = "\/" X,L & ex_sup_of X,L iff ( a is_>=_than X & ( for b being Element of L st b is_>=_than X holds
a <= b ) ) )

proof end;

theorem Th31: :: YELLOW_0:31

for L being antisymmetric RelStr
for a being Element of L
for X being set holds
( a = "/\" X,L & ex_inf_of X,L iff ( a is_<=_than X & ( for b being Element of L st b is_<=_than X holds
a >= b ) ) )

proof end;

theorem :: YELLOW_0:32

for L being non empty antisymmetric complete RelStr
for a being Element of L
for X being set holds
( a = "\/" X,L iff ( a is_>=_than X & ( for b being Element of L st b is_>=_than X holds
a <= b ) ) )

proof end;

theorem :: YELLOW_0:33

for L being non empty antisymmetric complete RelStr
for a being Element of L
for X being set holds
( a = "/\" X,L iff ( a is_<=_than X & ( for b being Element of L st b is_<=_than X holds
a >= b ) ) )

proof end;

theorem Th34: :: YELLOW_0:34

for L being RelStr
for X, Y being set st X c= Y & ex_sup_of X,L & ex_sup_of Y,L holds
"\/" X,L <= "\/" Y,L

proof end;

theorem Th35: :: YELLOW_0:35

for L being RelStr
for X, Y being set st X c= Y & ex_inf_of X,L & ex_inf_of Y,L holds
"/\" X,L >= "/\" Y,L

proof end;

theorem :: YELLOW_0:36

for L being transitive antisymmetric RelStr
for X, Y being set st ex_sup_of X,L & ex_sup_of Y,L & ex_sup_of X \/ Y,L holds
"\/" (X \/ Y),L = ("\/" X,L) "\/" ("\/" Y,L)

proof end;

theorem :: YELLOW_0:37

for L being transitive antisymmetric RelStr
for X, Y being set st ex_inf_of X,L & ex_inf_of Y,L & ex_inf_of X \/ Y,L holds
"/\" (X \/ Y),L = ("/\" X,L) "/\" ("/\" Y,L)

proof end;

notation

let L be RelStr ;
let X be Subset of L;
synonym sup X for "\/" X,L;
synonym inf X for "/\" X,L;

end;

theorem Th38: :: YELLOW_0:38

for L being non empty reflexive antisymmetric RelStr
for a being Element of L holds
( ex_sup_of {a},L & ex_inf_of {a},L )

proof end;

theorem :: YELLOW_0:39

for L being non empty reflexive antisymmetric RelStr
for a being Element of L holds
( sup {a} = a & inf {a} = a )

proof end;

theorem Th40: :: YELLOW_0:40

for L being with_infima Poset
for a, b being Element of L holds inf {a,b} = a "/\" b

proof end;

theorem Th41: :: YELLOW_0:41

for L being with_suprema Poset
for a, b being Element of L holds sup {a,b} = a "\/" b

proof end;

theorem Th42: :: YELLOW_0:42

for L being non empty antisymmetric lower-bounded RelStr holds
( ex_sup_of {} ,L & ex_inf_of the carrier of L,L )

proof end;

theorem Th43: :: YELLOW_0:43

for L being non empty antisymmetric upper-bounded RelStr holds
( ex_inf_of {} ,L & ex_sup_of the carrier of L,L )

proof end;

definition

let L be RelStr ;
func Bottom L -> Element of L equals :: YELLOW_0:def 11
"\/" {} ,L;
correctness ;
func Top L -> Element of L equals :: YELLOW_0:def 12
"/\" {} ,L;
correctness ;

end;

:: deftheorem defines Bottom YELLOW_0:def 11 :

:: deftheorem defines Top YELLOW_0:def 12 :

theorem :: YELLOW_0:44

for L being non empty antisymmetric lower-bounded RelStr
for x being Element of L holds Bottom L <= x

proof end;

theorem :: YELLOW_0:45

for L being non empty antisymmetric upper-bounded RelStr
for x being Element of L holds x <= Top L

proof end;

theorem Th46: :: YELLOW_0:46

for L being non empty RelStr
for X, Y being set st ( for x being Element of L holds
( x is_>=_than X iff x is_>=_than Y ) ) & ex_sup_of X,L holds
ex_sup_of Y,L

proof end;

theorem Th47: :: YELLOW_0:47

for L being non empty RelStr
for X, Y being set st ex_sup_of X,L & ( for x being Element of L holds
( x is_>=_than X iff x is_>=_than Y ) ) holds
"\/" X,L = "\/" Y,L

proof end;

theorem Th48: :: YELLOW_0:48

for L being non empty RelStr
for X, Y being set st ( for x being Element of L holds
( x is_<=_than X iff x is_<=_than Y ) ) & ex_inf_of X,L holds
ex_inf_of Y,L

proof end;

theorem Th49: :: YELLOW_0:49

for L being non empty RelStr
for X, Y being set st ex_inf_of X,L & ( for x being Element of L holds
( x is_<=_than X iff x is_<=_than Y ) ) holds
"/\" X,L = "/\" Y,L

proof end;

theorem Th50: :: YELLOW_0:50

for L being non empty RelStr
for X being set holds
( ( ex_sup_of X,L implies ex_sup_of X /\ the carrier of L,L ) & ( ex_sup_of X /\ the carrier of L,L implies ex_sup_of X,L ) & ( ex_inf_of X,L implies ex_inf_of X /\ the carrier of L,L ) & ( ex_inf_of X /\ the carrier of L,L implies ex_inf_of X,L ) )

proof end;

theorem :: YELLOW_0:51

for L being non empty RelStr
for X being set st ( ex_sup_of X,L or ex_sup_of X /\ the carrier of L,L ) holds
"\/" X,L = "\/" (X /\ the carrier of L),L

proof end;

theorem :: YELLOW_0:52

for L being non empty RelStr
for X being set st ( ex_inf_of X,L or ex_inf_of X /\ the carrier of L,L ) holds
"/\" X,L = "/\" (X /\ the carrier of L),L

proof end;

theorem :: YELLOW_0:53

for L being non empty RelStr st ( for X being Subset of L holds ex_sup_of X,L ) holds
L is complete

proof end;

theorem :: YELLOW_0:54

for L being non empty Poset holds
( L is with_suprema iff for X being non empty finite Subset of L holds ex_sup_of X,L )

proof end;

theorem :: YELLOW_0:55

for L being non empty Poset holds
( L is with_infima iff for X being non empty finite Subset of L holds ex_inf_of X,L )

proof end;

theorem Th56: :: YELLOW_0:56

for X being set
for R being Relation of X holds R = R |_2 X

proof end;

definition

let L be RelStr ;
mode SubRelStr of L -> RelStr means :Def13: :: YELLOW_0:def 13
( the carrier of it c= the carrier of L & the InternalRel of it c= the InternalRel of L );
existence ;

end;

:: deftheorem Def13 defines SubRelStr YELLOW_0:def 13 :

definition

let L be RelStr ;
let S be SubRelStr of L;
attr S is full means :Def14: :: YELLOW_0:def 14
the InternalRel of S = the InternalRel of L |_2 the carrier of S;

end;

:: deftheorem Def14 defines full YELLOW_0:def 14 :

registration

let L be RelStr ;
cluster strict full SubRelStr of L;
existence

proof end;

end;

registration

let L be non empty RelStr ;
cluster non empty strict full SubRelStr of L;
existence

proof end;

end;

theorem Th57: :: YELLOW_0:57

for L being RelStr
for X being Subset of L holds RelStr(# X,(the InternalRel of L |_2 X) #) is full SubRelStr of L

proof end;

theorem Th58: :: YELLOW_0:58

for L being RelStr
for S1, S2 being full SubRelStr of L st the carrier of S1 = the carrier of S2 holds
RelStr(# the carrier of S1,the InternalRel of S1 #) = RelStr(# the carrier of S2,the InternalRel of S2 #)

proof end;

definition

let L be RelStr ;
let X be Subset of L;
func subrelstr X -> strict full SubRelStr of L means :: YELLOW_0:def 15
the carrier of it = X;
uniqueness by Th58;
existence

proof end;

end;

:: deftheorem defines subrelstr YELLOW_0:def 15 :

theorem Th59: :: YELLOW_0:59

for L being non empty RelStr
for S being non empty SubRelStr of L
for x being Element of S holds x is Element of L

proof end;

theorem Th60: :: YELLOW_0:60

for L being RelStr
for S being SubRelStr of L
for a, b being Element of L
for x, y being Element of S st x = a & y = b & x <= y holds
a <= b

proof end;

theorem Th61: :: YELLOW_0:61

for L being RelStr
for S being full SubRelStr of L
for a, b being Element of L
for x, y being Element of S st x = a & y = b & a <= b & x in the carrier of S & y in the carrier of S holds
x <= y

proof end;

theorem Th62: :: YELLOW_0:62

for L being non empty RelStr
for S being non empty full SubRelStr of L
for X being set
for a being Element of L
for x being Element of S st x = a holds
( ( a is_<=_than X implies x is_<=_than X ) & ( a is_>=_than X implies x is_>=_than X ) )

proof end;

theorem Th63: :: YELLOW_0:63

for L being non empty RelStr
for S being non empty SubRelStr of L
for X being Subset of S
for a being Element of L
for x being Element of S st x = a holds
( ( x is_<=_than X implies a is_<=_than X ) & ( x is_>=_than X implies a is_>=_than X ) )

proof end;

registration

let L be reflexive RelStr ;
cluster full -> reflexive full SubRelStr of L;
coherence

proof end;

end;

registration

let L be transitive RelStr ;
cluster full -> transitive full SubRelStr of L;
coherence

proof end;

end;

registration

let L be antisymmetric RelStr ;
cluster full -> antisymmetric full SubRelStr of L;
coherence

proof end;

end;

definition

let L be non empty RelStr ;
let S be SubRelStr of L;
attr S is meet-inheriting means :Def16: :: YELLOW_0:def 16
for x, y being Element of L st x in the carrier of S & y in the carrier of S & ex_inf_of {x,y},L holds
inf {x,y} in the carrier of S;
attr S is join-inheriting means :Def17: :: YELLOW_0:def 17
for x, y being Element of L st x in the carrier of S & y in the carrier of S & ex_sup_of {x,y},L holds
sup {x,y} in the carrier of S;

end;

:: deftheorem Def16 defines meet-inheriting YELLOW_0:def 16 :

:: deftheorem Def17 defines join-inheriting YELLOW_0:def 17 :

definition

let L be non empty RelStr ;
let S be SubRelStr of L;
attr S is infs-inheriting means :: YELLOW_0:def 18
for X being Subset of S st ex_inf_of X,L holds
"/\" X,L in the carrier of S;
attr S is sups-inheriting means :: YELLOW_0:def 19
for X being Subset of S st ex_sup_of X,L holds
"\/" X,L in the carrier of S;

end;

:: deftheorem defines infs-inheriting YELLOW_0:def 18 :

:: deftheorem defines sups-inheriting YELLOW_0:def 19 :

registration

let L be non empty RelStr ;
cluster infs-inheriting -> meet-inheriting SubRelStr of L;
coherence

proof end;

cluster sups-inheriting -> join-inheriting SubRelStr of L;
coherence

proof end;

end;

registration

let L be non empty RelStr ;
cluster non empty strict full meet-inheriting join-inheriting infs-inheriting sups-inheriting SubRelStr of L;
existence

proof end;

end;

theorem Th64: :: YELLOW_0:64

for L being non empty transitive RelStr
for S being non empty full SubRelStr of L
for X being Subset of S st ex_inf_of X,L & "/\" X,L in the carrier of S holds
( ex_inf_of X,S & "/\" X,S = "/\" X,L )

proof end;

theorem Th65: :: YELLOW_0:65

for L being non empty transitive RelStr
for S being non empty full SubRelStr of L
for X being Subset of S st ex_sup_of X,L & "\/" X,L in the carrier of S holds
( ex_sup_of X,S & "\/" X,S = "\/" X,L )

proof end;

theorem :: YELLOW_0:66

for L being non empty transitive RelStr
for S being non empty full SubRelStr of L
for x, y being Element of S st ex_inf_of {x,y},L & "/\" {x,y},L in the carrier of S holds
( ex_inf_of {x,y},S & "/\" {x,y},S = "/\" {x,y},L ) by Th64;

theorem :: YELLOW_0:67

for L being non empty transitive RelStr
for S being non empty full SubRelStr of L
for x, y being Element of S st ex_sup_of {x,y},L & "\/" {x,y},L in the carrier of S holds
( ex_sup_of {x,y},S & "\/" {x,y},S = "\/" {x,y},L ) by Th65;

registration

let L be transitive antisymmetric with_infima RelStr ;
cluster non empty full meet-inheriting -> non empty transitive antisymmetric with_infima full meet-inheriting SubRelStr of L;
coherence

proof end;

end;

registration

let L be transitive antisymmetric with_suprema RelStr ;
cluster non empty full join-inheriting -> non empty transitive antisymmetric with_suprema full join-inheriting SubRelStr of L;
coherence

proof end;

end;

theorem :: YELLOW_0:68

for L being non empty complete Poset
for S being non empty full SubRelStr of L
for X being Subset of S st "/\" X,L in the carrier of S holds
"/\" X,S = "/\" X,L

proof end;

theorem :: YELLOW_0:69

for L being non empty complete Poset
for S being non empty full SubRelStr of L
for X being Subset of S st "\/" X,L in the carrier of S holds
"\/" X,S = "\/" X,L

proof end;

theorem :: YELLOW_0:70

for L being with_infima Poset
for S being non empty full meet-inheriting SubRelStr of L
for x, y being Element of S
for a, b being Element of L st a = x & b = y holds
x "/\" y = a "/\" b

proof end;

theorem :: YELLOW_0:71

for L being with_suprema Poset
for S being non empty full join-inheriting SubRelStr of L
for x, y being Element of S
for a, b being Element of L st a = x & b = y holds
x "\/" y = a "\/" b

proof end;