:: MSSUBFAM semantic presentation

definition
let c1 be set ;
let c2 be ManySortedFunction of c1;
redefine func doms as doms c2 -> ManySortedSet of a1;
coherence
doms c2 is ManySortedSet of c1
proof end;
redefine func rngs as rngs c2 -> ManySortedSet of a1;
coherence
rngs c2 is ManySortedSet of c1
proof end;
end;

scheme :: MSSUBFAM:sch 1
s1{ F1() -> set , F2() -> ManySortedSet of F1(), F3() -> ManySortedSet of F1(), P1[ set , set , set ] } :
ex b1 being ManySortedFunction of F2(),F3() st
for b2 being set holds
not ( b2 in F1() & ( for b3 being Function of F2() . b2,F3() . b2 holds
not ( b3 = b1 . b2 & ( for b4 being set holds
( b4 in F2() . b2 implies P1[b3 . b4,b4,b2] ) ) ) ) )
provided
E1: for b1 being set holds
( b1 in F1() implies for b2 being set holds
not ( b2 in F2() . b1 & ( for b3 being set holds
not ( b3 in F3() . b1 & P1[b3,b2,b1] ) ) ) )
proof end;

theorem Th1: :: MSSUBFAM:1
for b1 being set
for b2 being Subset-Family of b1 holds
( b2 <> {} implies Intersect b2 c= union b2 )
proof end;

theorem Th2: :: MSSUBFAM:2
for b1, b2 being set
for b3 being Subset-Family of b1 holds
( b2 in b3 implies Intersect b3 c= b2 )
proof end;

theorem Th3: :: MSSUBFAM:3
for b1 being set
for b2 being Subset-Family of b1 holds
( {} in b2 implies Intersect b2 = {} )
proof end;

theorem Th4: :: MSSUBFAM:4
for b1 being set
for b2 being Subset-Family of b1
for b3 being Subset of b1 holds
( ( for b4 being set holds
( b4 in b2 implies b3 c= b4 ) ) implies b3 c= Intersect b2 )
proof end;

theorem Th5: :: MSSUBFAM:5
for b1, b2 being set
for b3 being Subset-Family of b1 holds
( b3 <> {} & ( for b4 being set holds
( b4 in b3 implies b2 c= b4 ) ) implies b2 c= Intersect b3 )
proof end;

theorem Th6: :: MSSUBFAM:6
for b1, b2, b3 being set
for b4 being Subset-Family of b1 holds
( b2 in b4 & b2 c= b3 implies Intersect b4 c= b3 )
proof end;

theorem Th7: :: MSSUBFAM:7
for b1, b2, b3 being set
for b4 being Subset-Family of b1 holds
( b2 in b4 & b2 misses b3 implies Intersect b4 misses b3 )
proof end;

theorem Th8: :: MSSUBFAM:8
for b1 being set
for b2, b3, b4 being Subset-Family of b1 holds
( b2 = b3 \/ b4 implies Intersect b2 = (Intersect b3) /\ (Intersect b4) )
proof end;

theorem Th9: :: MSSUBFAM:9
for b1 being set
for b2 being Subset-Family of b1
for b3 being Subset of b1 holds
( b2 = {b3} implies Intersect b2 = b3 )
proof end;

theorem Th10: :: MSSUBFAM:10
for b1 being set
for b2 being Subset-Family of b1
for b3, b4 being Subset of b1 holds
( b2 = {b3,b4} implies Intersect b2 = b3 /\ b4 )
proof end;

theorem Th11: :: MSSUBFAM:11
for b1 being set
for b2, b3 being ManySortedSet of b1 holds
( b2 in b3 implies b2 is Element of b3 )
proof end;

theorem Th12: :: MSSUBFAM:12
for b1 being set
for b2 being ManySortedSet of b1
for b3 being V5 ManySortedSet of b1 holds
( b2 is Element of b3 implies b2 in b3 )
proof end;

theorem Th13: :: MSSUBFAM:13
for b1, b2 being set
for b3 being ManySortedFunction of b2
for b4 being Function holds
( b1 in b2 & b4 = b3 . b1 implies (rngs b3) . b1 = rng b4 )
proof end;

theorem Th14: :: MSSUBFAM:14
for b1, b2 being set
for b3 being ManySortedFunction of b2
for b4 being Function holds
( b1 in b2 & b4 = b3 . b1 implies (doms b3) . b1 = dom b4 )
proof end;

theorem Th15: :: MSSUBFAM:15
for b1 being set
for b2, b3 being ManySortedFunction of b1 holds
b3 ** b2 is ManySortedFunction of b1
proof end;

theorem Th16: :: MSSUBFAM:16
for b1 being set
for b2 being V5 ManySortedSet of b1
for b3 being ManySortedFunction of b2, [0] b1 holds b3 = [0] b1
proof end;

theorem Th17: :: MSSUBFAM:17
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being ManySortedFunction of b1 holds
( b2 is_transformable_to b3 & b4 is ManySortedFunction of b2,b3 implies ( doms b4 = b2 & rngs b4 c= b3 ) )
proof end;

registration
let c1 be set ;
cluster V6 -> locally-finite ManySortedSet of a1;
coherence
for b1 being ManySortedSet of c1 holds
( b1 is empty-yielding implies b1 is locally-finite )
proof end;
end;

registration
let c1 be set ;
cluster [0] a1 -> V6 locally-finite ;
coherence
( [0] c1 is empty-yielding & [0] c1 is locally-finite )
;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster V6 locally-finite ManySortedSubset of a2;
existence
ex b1 being ManySortedSubset of c2 st
( b1 is empty-yielding & b1 is locally-finite )
proof end;
end;

theorem Th18: :: MSSUBFAM:18
for b1 being set
for b2, b3 being ManySortedSet of b1 holds
( b2 c= b3 & b3 is locally-finite implies b2 is locally-finite )
proof end;

registration
let c1 be set ;
let c2 be locally-finite ManySortedSet of c1;
cluster -> locally-finite ManySortedSubset of a2;
coherence
for b1 being ManySortedSubset of c2 holds b1 is locally-finite
proof end;
end;

registration
let c1 be set ;
let c2, c3 be locally-finite ManySortedSet of c1;
cluster a2 \/ a3 -> locally-finite ;
coherence
c2 \/ c3 is locally-finite
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
let c3 be locally-finite ManySortedSet of c1;
cluster a2 /\ a3 -> locally-finite ;
coherence
c2 /\ c3 is locally-finite
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
let c3 be locally-finite ManySortedSet of c1;
cluster a3 /\ a2 -> locally-finite ;
coherence
c3 /\ c2 is locally-finite
;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
let c3 be locally-finite ManySortedSet of c1;
cluster a3 \ a2 -> locally-finite ;
coherence
c3 \ c2 is locally-finite
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedFunction of c1;
let c3 be locally-finite ManySortedSet of c1;
cluster a2 .:.: a3 -> locally-finite ;
coherence
c2 .:.: c3 is locally-finite
proof end;
end;

registration
let c1 be set ;
let c2, c3 be locally-finite ManySortedSet of c1;
cluster [|a2,a3|] -> locally-finite ;
coherence
[|c2,c3|] is locally-finite
proof end;
end;

theorem Th19: :: MSSUBFAM:19
for b1 being set
for b2, b3 being ManySortedSet of b1 holds
( b2 is non-empty & [|b3,b2|] is locally-finite implies b3 is locally-finite )
proof end;

theorem Th20: :: MSSUBFAM:20
for b1 being set
for b2, b3 being ManySortedSet of b1 holds
( b2 is non-empty & [|b2,b3|] is locally-finite implies b3 is locally-finite )
proof end;

theorem Th21: :: MSSUBFAM:21
for b1 being set
for b2 being ManySortedSet of b1 holds
( b2 is locally-finite iff bool b2 is locally-finite )
proof end;

registration
let c1 be set ;
let c2 be locally-finite ManySortedSet of c1;
cluster bool a2 -> locally-finite ;
coherence
bool c2 is locally-finite
by Th21;
end;

theorem Th22: :: MSSUBFAM:22
for b1 being set
for b2 being V5 ManySortedSet of b1 holds
( b2 is locally-finite & ( for b3 being ManySortedSet of b1 holds
( b3 in b2 implies b3 is locally-finite ) ) implies union b2 is locally-finite )
proof end;

theorem Th23: :: MSSUBFAM:23
for b1 being set
for b2 being ManySortedSet of b1 holds
( union b2 is locally-finite implies ( b2 is locally-finite & ( for b3 being ManySortedSet of b1 holds
( b3 in b2 implies b3 is locally-finite ) ) ) )
proof end;

theorem Th24: :: MSSUBFAM:24
for b1 being set
for b2 being ManySortedFunction of b1 holds
( doms b2 is locally-finite implies rngs b2 is locally-finite )
proof end;

theorem Th25: :: MSSUBFAM:25
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of b1 holds
( b2 c= rngs b3 & ( for b4 being set
for b5 being Function holds
( b4 in b1 & b5 = b3 . b4 implies b5 " (b2 . b4) is finite ) ) implies b2 is locally-finite )
proof end;

registration
let c1 be set ;
let c2, c3 be locally-finite ManySortedSet of c1;
cluster MSFuncs a2,a3 -> locally-finite ;
coherence
MSFuncs c2,c3 is locally-finite
proof end;
end;

registration
let c1 be set ;
let c2, c3 be locally-finite ManySortedSet of c1;
cluster a2 \+\ a3 -> locally-finite ;
coherence
c2 \+\ c3 is locally-finite
;
end;

theorem Th26: :: MSSUBFAM:26
for b1 being set
for b2, b3, b4 being ManySortedSet of b1 holds
not ( b2 is locally-finite & b2 c= [|b3,b4|] & ( for b5, b6 being ManySortedSet of b1 holds
not ( b5 is locally-finite & b5 c= b3 & b6 is locally-finite & b6 c= b4 & b2 c= [|b5,b6|] ) ) )
proof end;

theorem Th27: :: MSSUBFAM:27
for b1 being set
for b2, b3, b4 being ManySortedSet of b1 holds
not ( b2 is locally-finite & b3 is locally-finite & b2 c= [|b4,b3|] & ( for b5 being ManySortedSet of b1 holds
not ( b5 is locally-finite & b5 c= b4 & b2 c= [|b5,b3|] ) ) )
proof end;

theorem Th28: :: MSSUBFAM:28
for b1 being set
for b2 being V5 locally-finite ManySortedSet of b1 holds
not ( ( for b3, b4 being ManySortedSet of b1 holds
not ( b3 in b2 & b4 in b2 & not b3 c= b4 & not b4 c= b3 ) ) & ( for b3 being ManySortedSet of b1 holds
not ( b3 in b2 & ( for b4 being ManySortedSet of b1 holds
( b4 in b2 implies b3 c= b4 ) ) ) ) )
proof end;

theorem Th29: :: MSSUBFAM:29
for b1 being set
for b2 being V5 locally-finite ManySortedSet of b1 holds
not ( ( for b3, b4 being ManySortedSet of b1 holds
not ( b3 in b2 & b4 in b2 & not b3 c= b4 & not b4 c= b3 ) ) & ( for b3 being ManySortedSet of b1 holds
not ( b3 in b2 & ( for b4 being ManySortedSet of b1 holds
( b4 in b2 implies b4 c= b3 ) ) ) ) )
proof end;

theorem Th30: :: MSSUBFAM:30
for b1 being set
for b2 being ManySortedFunction of b1
for b3 being ManySortedSet of b1 holds
not ( b3 is locally-finite & b3 c= rngs b2 & ( for b4 being ManySortedSet of b1 holds
not ( b4 c= doms b2 & b4 is locally-finite & b2 .:.: b4 = b3 ) ) )
proof end;

definition
let c1 be set ;
let c2 be ManySortedSet of c1;
mode MSSubsetFamily is ManySortedSubset of bool a2;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster V5 ManySortedSubset of bool a2;
existence
ex b1 being MSSubsetFamily of c2 st b1 is non-empty
proof end;
end;

definition
let c1 be set ;
let c2 be ManySortedSet of c1;
redefine func bool as bool c2 -> MSSubsetFamily of a2;
coherence
bool c2 is MSSubsetFamily of c2
by PBOOLE:def 23;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster V6 locally-finite ManySortedSubset of bool a2;
existence
ex b1 being MSSubsetFamily of c2 st
( b1 is empty-yielding & b1 is locally-finite )
proof end;
end;

theorem Th31: :: MSSUBFAM:31
for b1 being set
for b2 being ManySortedSet of b1 holds
[0] b1 is V6 locally-finite MSSubsetFamily of b2
proof end;

registration
let c1 be set ;
let c2 be locally-finite ManySortedSet of c1;
cluster V5 locally-finite ManySortedSubset of bool a2;
existence
ex b1 being MSSubsetFamily of c2 st
( b1 is non-empty & b1 is locally-finite )
proof end;
end;

definition
let c1 be non empty set ;
let c2 be ManySortedSet of c1;
let c3 be MSSubsetFamily of c2;
let c4 be Element of c1;
redefine func . as c3 . c4 -> Subset-Family of (a2 . a4);
coherence
c3 . c4 is Subset-Family of (c2 . c4)
proof end;
end;

theorem Th32: :: MSSUBFAM:32
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4 being MSSubsetFamily of b3 holds
( b1 in b2 implies b4 . b1 is Subset-Family of (b3 . b1) )
proof end;

theorem Th33: :: MSSUBFAM:33
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being MSSubsetFamily of b3 holds
( b2 in b4 implies b2 is ManySortedSubset of b3 )
proof end;

theorem Th34: :: MSSUBFAM:34
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being MSSubsetFamily of b2 holds
b3 \/ b4 is MSSubsetFamily of b2
proof end;

theorem Th35: :: MSSUBFAM:35
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being MSSubsetFamily of b2 holds
b3 /\ b4 is MSSubsetFamily of b2
proof end;

theorem Th36: :: MSSUBFAM:36
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being MSSubsetFamily of b3 holds
b4 \ b2 is MSSubsetFamily of b3
proof end;

theorem Th37: :: MSSUBFAM:37
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being MSSubsetFamily of b2 holds
b3 \+\ b4 is MSSubsetFamily of b2
proof end;

theorem Th38: :: MSSUBFAM:38
for b1 being set
for b2, b3 being ManySortedSet of b1 holds
( b2 c= b3 implies {b2} is MSSubsetFamily of b3 )
proof end;

theorem Th39: :: MSSUBFAM:39
for b1 being set
for b2, b3, b4 being ManySortedSet of b1 holds
( b2 c= b3 & b4 c= b3 implies {b2,b4} is MSSubsetFamily of b3 )
proof end;

theorem Th40: :: MSSUBFAM:40
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds union b3 c= b2
proof end;

definition
let c1 be set ;
let c2 be ManySortedSet of c1;
let c3 be MSSubsetFamily of c2;
canceled;
func meet c3 -> ManySortedSet of a1 means :Def2: :: MSSUBFAM:def 2
for b1 being set holds
not ( b1 in a1 & ( for b2 being Subset-Family of (a2 . b1) holds
not ( b2 = a3 . b1 & a4 . b1 = Intersect b2 ) ) );
existence
ex b1 being ManySortedSet of c1 st
for b2 being set holds
not ( b2 in c1 & ( for b3 being Subset-Family of (c2 . b2) holds
not ( b3 = c3 . b2 & b1 . b2 = Intersect b3 ) ) )
proof end;
uniqueness
for b1, b2 being ManySortedSet of c1 holds
( ( for b3 being set holds
not ( b3 in c1 & ( for b4 being Subset-Family of (c2 . b3) holds
not ( b4 = c3 . b3 & b1 . b3 = Intersect b4 ) ) ) ) & ( for b3 being set holds
not ( b3 in c1 & ( for b4 being Subset-Family of (c2 . b3) holds
not ( b4 = c3 . b3 & b2 . b3 = Intersect b4 ) ) ) ) implies b1 = b2 )
proof end;
end;

:: deftheorem Def1 MSSUBFAM:def 1 :
canceled;

:: deftheorem Def2 defines meet MSSUBFAM:def 2 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2
for b4 being ManySortedSet of b1 holds
( b4 = meet b3 iff for b5 being set holds
not ( b5 in b1 & ( for b6 being Subset-Family of (b2 . b5) holds
not ( b6 = b3 . b5 & b4 . b5 = Intersect b6 ) ) ) );

definition
let c1 be set ;
let c2 be ManySortedSet of c1;
let c3 be MSSubsetFamily of c2;
redefine func meet as meet c3 -> ManySortedSubset of a2;
coherence
meet c3 is ManySortedSubset of c2
proof end;
end;

theorem Th41: :: MSSUBFAM:41
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 = [0] b1 implies meet b3 = b2 )
proof end;

theorem Th42: :: MSSUBFAM:42
for b1 being set
for b2 being ManySortedSet of b1
for b3 being V5 MSSubsetFamily of b2 holds meet b3 c= union b3
proof end;

theorem Th43: :: MSSUBFAM:43
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being MSSubsetFamily of b2 holds
( b3 in b4 implies meet b4 c= b3 )
proof end;

theorem Th44: :: MSSUBFAM:44
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( [0] b1 in b3 implies meet b3 = [0] b1 )
proof end;

theorem Th45: :: MSSUBFAM:45
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being V5 MSSubsetFamily of b3 holds
( ( for b5 being ManySortedSet of b1 holds
( b5 in b4 implies b2 c= b5 ) ) implies b2 c= meet b4 )
proof end;

theorem Th46: :: MSSUBFAM:46
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being MSSubsetFamily of b2 holds
( b3 c= b4 implies meet b4 c= meet b3 )
proof end;

theorem Th47: :: MSSUBFAM:47
for b1 being set
for b2, b3, b4 being ManySortedSet of b1
for b5 being MSSubsetFamily of b2 holds
( b3 in b5 & b3 c= b4 implies meet b5 c= b4 )
proof end;

theorem Th48: :: MSSUBFAM:48
for b1 being set
for b2, b3, b4 being ManySortedSet of b1
for b5 being MSSubsetFamily of b2 holds
( b3 in b5 & b3 /\ b4 = [0] b1 implies (meet b5) /\ b4 = [0] b1 )
proof end;

theorem Th49: :: MSSUBFAM:49
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4, b5 being MSSubsetFamily of b2 holds
( b3 = b4 \/ b5 implies meet b3 = (meet b4) /\ (meet b5) )
proof end;

theorem Th50: :: MSSUBFAM:50
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2
for b4 being ManySortedSubset of b2 holds
( b3 = {b4} implies meet b3 = b4 )
proof end;

theorem Th51: :: MSSUBFAM:51
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2
for b4, b5 being ManySortedSubset of b2 holds
( b3 = {b4,b5} implies meet b3 = b4 /\ b5 )
proof end;

theorem Th52: :: MSSUBFAM:52
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being MSSubsetFamily of b2 holds
( b3 in meet b4 implies for b5 being ManySortedSet of b1 holds
( b5 in b4 implies b3 in b5 ) )
proof end;

theorem Th53: :: MSSUBFAM:53
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being V5 MSSubsetFamily of b3 holds
( b2 in b3 & ( for b5 being ManySortedSet of b1 holds
( b5 in b4 implies b2 in b5 ) ) implies b2 in meet b4 )
proof end;

definition
let c1 be set ;
let c2 be ManySortedSet of c1;
let c3 be MSSubsetFamily of c2;
attr a3 is additive means :: MSSUBFAM:def 3
for b1, b2 being ManySortedSet of a1 holds
( b1 in a3 & b2 in a3 implies b1 \/ b2 in a3 );
attr a3 is absolutely-additive means :Def4: :: MSSUBFAM:def 4
for b1 being MSSubsetFamily of a2 holds
( b1 c= a3 implies union b1 in a3 );
attr a3 is multiplicative means :: MSSUBFAM:def 5
for b1, b2 being ManySortedSet of a1 holds
( b1 in a3 & b2 in a3 implies b1 /\ b2 in a3 );
attr a3 is absolutely-multiplicative means :Def6: :: MSSUBFAM:def 6
for b1 being MSSubsetFamily of a2 holds
( b1 c= a3 implies meet b1 in a3 );
attr a3 is properly-upper-bound means :Def7: :: MSSUBFAM:def 7
a2 in a3;
attr a3 is properly-lower-bound means :Def8: :: MSSUBFAM:def 8
[0] a1 in a3;
end;

:: deftheorem Def3 defines additive MSSUBFAM:def 3 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 is additive iff for b4, b5 being ManySortedSet of b1 holds
( b4 in b3 & b5 in b3 implies b4 \/ b5 in b3 ) );

:: deftheorem Def4 defines absolutely-additive MSSUBFAM:def 4 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 is absolutely-additive iff for b4 being MSSubsetFamily of b2 holds
( b4 c= b3 implies union b4 in b3 ) );

:: deftheorem Def5 defines multiplicative MSSUBFAM:def 5 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 is multiplicative iff for b4, b5 being ManySortedSet of b1 holds
( b4 in b3 & b5 in b3 implies b4 /\ b5 in b3 ) );

:: deftheorem Def6 defines absolutely-multiplicative MSSUBFAM:def 6 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 is absolutely-multiplicative iff for b4 being MSSubsetFamily of b2 holds
( b4 c= b3 implies meet b4 in b3 ) );

:: deftheorem Def7 defines properly-upper-bound MSSUBFAM:def 7 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 is properly-upper-bound iff b2 in b3 );

:: deftheorem Def8 defines properly-lower-bound MSSUBFAM:def 8 :
for b1 being set
for b2 being ManySortedSet of b1
for b3 being MSSubsetFamily of b2 holds
( b3 is properly-lower-bound iff [0] b1 in b3 );

Lemma19: for b1 being set
for b2 being ManySortedSet of b1 holds
( bool b2 is additive & bool b2 is absolutely-additive & bool b2 is multiplicative & bool b2 is absolutely-multiplicative & bool b2 is properly-upper-bound & bool b2 is properly-lower-bound )
proof end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster V5 additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound ManySortedSubset of bool a2;
existence
ex b1 being MSSubsetFamily of c2 st
( b1 is non-empty & b1 is additive & b1 is absolutely-additive & b1 is multiplicative & b1 is absolutely-multiplicative & b1 is properly-upper-bound & b1 is properly-lower-bound )
proof end;
end;

definition
let c1 be set ;
let c2 be ManySortedSet of c1;
redefine func bool as bool c2 -> additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound MSSubsetFamily of a2;
coherence
bool c2 is additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound MSSubsetFamily of c2
by Lemma19;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster absolutely-additive -> additive ManySortedSubset of bool a2;
coherence
for b1 being MSSubsetFamily of c2 holds
( b1 is absolutely-additive implies b1 is additive )
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster absolutely-multiplicative -> multiplicative ManySortedSubset of bool a2;
coherence
for b1 being MSSubsetFamily of c2 holds
( b1 is absolutely-multiplicative implies b1 is multiplicative )
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster absolutely-multiplicative -> properly-upper-bound ManySortedSubset of bool a2;
coherence
for b1 being MSSubsetFamily of c2 holds
( b1 is absolutely-multiplicative implies b1 is properly-upper-bound )
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster properly-upper-bound -> V5 ManySortedSubset of bool a2;
coherence
for b1 being MSSubsetFamily of c2 holds
( b1 is properly-upper-bound implies b1 is non-empty )
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster absolutely-additive -> properly-lower-bound ManySortedSubset of bool a2;
coherence
for b1 being MSSubsetFamily of c2 holds
( b1 is absolutely-additive implies b1 is properly-lower-bound )
proof end;
end;

registration
let c1 be set ;
let c2 be ManySortedSet of c1;
cluster properly-lower-bound -> V5 ManySortedSubset of bool a2;
coherence
for b1 being MSSubsetFamily of c2 holds
( b1 is properly-lower-bound implies b1 is non-empty )
proof end;
end;