Article PCS_0, MML version 4.99.1005
:: PCS_0:funcnot 1 => PCS_0:func 1
definition
let a1, a2 be set;
let a3 be Relation of a1,a2;
redefine func field a3 -> Element of bool (a1 \/ a2);
end;
:: PCS_0:funcnot 2 => PCS_0:func 2
definition
let a1, a2, a3, a4 be set;
let a5 be Relation of a1,a2;
let a6 be Relation of a3,a4;
redefine func a5 \/ a6 -> Relation of a1 \/ a3,a2 \/ a4;
commutativity;
:: for a1, a2, a3, a4 being set
:: for a5 being Relation of a1,a2
:: for a6 being Relation of a3,a4 holds
:: a5 \/ a6 = a6 \/ a5;
idempotence;
:: for a1, a2, a3, a4 being set
:: for a5 being Relation of a1,a2 holds
:: a5 \/ a5 = a5;
end;
:: PCS_0:funcreg 1
registration
let a1, a2 be set;
let a3 be total Relation of a1,a1;
let a4 be total Relation of a2,a2;
cluster a3 \/ a4 -> total;
end;
:: PCS_0:funcreg 2
registration
let a1, a2 be set;
let a3 be reflexive Relation of a1,a1;
let a4 be reflexive Relation of a2,a2;
cluster a3 \/ a4 -> reflexive;
end;
:: PCS_0:funcreg 3
registration
let a1, a2 be set;
let a3 be symmetric Relation of a1,a1;
let a4 be symmetric Relation of a2,a2;
cluster a3 \/ a4 -> symmetric;
end;
:: PCS_0:th 1
theorem
for b1, b2 being set
for b3 being transitive Relation of b1,b1
for b4 being transitive Relation of b2,b2
st b1 misses b2
holds b3 \/ b4 is transitive;
:: PCS_0:funcreg 4
registration
let a1 be empty set;
let a2 be set;
cluster {}(a1,a2) -> total;
end;
:: PCS_0:funcnot 3 => PRALG_1:func 12
definition
let a1 be set;
let a2 be 1-sorted-yielding ManySortedSet of a1;
func Carrier A2 -> ManySortedSet of a1 means
for b1 being Element of a1 holds
it . b1 = the carrier of a2 . b1;
end;
:: PCS_0:def 1
theorem
for b1 being non empty set
for b2 being 1-sorted-yielding ManySortedSet of b1
for b3 being ManySortedSet of b1 holds
b3 = Carrier b2
iff
for b4 being Element of b1 holds
b3 . b4 = the carrier of b2 . b4;
:: PCS_0:funcnot 4 => PCS_0:func 3
definition
let a1, a2, a3, a4 be set;
let a5 be Relation of a1,a2;
let a6 be Relation of a3,a4;
func [^A5,A6^] -> Relation of [:a1,a3:],[:a2,a4:] means
for b1, b2 being set holds
[b1,b2] in it
iff
ex b3, b4, b5, b6 being set st
b1 = [b3,b4] &
b2 = [b5,b6] &
b3 in a1 &
b4 in a3 &
b5 in a2 &
b6 in a4 &
([b3,b5] in a5 or [b4,b6] in a6);
end;
:: PCS_0:def 2
theorem
for b1, b2, b3, b4 being set
for b5 being Relation of b1,b2
for b6 being Relation of b3,b4
for b7 being Relation of [:b1,b3:],[:b2,b4:] holds
b7 = [^b5,b6^]
iff
for b8, b9 being set holds
[b8,b9] in b7
iff
ex b10, b11, b12, b13 being set st
b8 = [b10,b11] &
b9 = [b12,b13] &
b10 in b1 &
b11 in b3 &
b12 in b2 &
b13 in b4 &
([b10,b12] in b5 or [b11,b13] in b6);
:: PCS_0:funcnot 5 => PCS_0:func 3
definition
let a1, a2, a3, a4 be set;
let a5 be Relation of a1,a2;
let a6 be Relation of a3,a4;
func [^A5,A6^] -> Relation of [:a1,a3:],[:a2,a4:] means
for b1 being Element of a1
for b2 being Element of a2
for b3 being Element of a3
for b4 being Element of a4 holds
[[b1,b3],[b2,b4]] in it
iff
([b1,b2] in a5 or [b3,b4] in a6);
end;
:: PCS_0:def 3
theorem
for b1, b2, b3, b4 being non empty set
for b5 being Relation of b1,b2
for b6 being Relation of b3,b4
for b7 being Relation of [:b1,b3:],[:b2,b4:] holds
b7 = [^b5,b6^]
iff
for b8 being Element of b1
for b9 being Element of b2
for b10 being Element of b3
for b11 being Element of b4 holds
[[b8,b10],[b9,b11]] in b7
iff
([b8,b9] in b5 or [b10,b11] in b6);
:: PCS_0:funcreg 5
registration
let a1, a2 be set;
let a3 be total Relation of a1,a1;
let a4 be total Relation of a2,a2;
cluster [^a3,a4^] -> total;
end;
:: PCS_0:funcreg 6
registration
let a1, a2 be set;
let a3 be reflexive Relation of a1,a1;
let a4 be reflexive Relation of a2,a2;
cluster [^a3,a4^] -> reflexive;
end;
:: PCS_0:funcreg 7
registration
let a1, a2 be set;
let a3 be Relation of a1,a1;
let a4 be total reflexive Relation of a2,a2;
cluster [^a3,a4^] -> reflexive;
end;
:: PCS_0:funcreg 8
registration
let a1, a2 be set;
let a3 be total reflexive Relation of a1,a1;
let a4 be Relation of a2,a2;
cluster [^a3,a4^] -> reflexive;
end;
:: PCS_0:funcreg 9
registration
let a1, a2 be set;
let a3 be symmetric Relation of a1,a1;
let a4 be symmetric Relation of a2,a2;
cluster [^a3,a4^] -> symmetric;
end;
:: PCS_0:condreg 1
registration
cluster empty -> total (RelStr);
end;
:: PCS_0:attrnot 1 => PCS_0:attr 1
definition
let a1 be Relation-like set;
attr a1 is transitive-yielding means
for b1 being RelStr
st b1 in proj2 a1
holds b1 is transitive;
end;
:: PCS_0:dfs 4
definiens
let a1 be Relation-like set;
To prove
a1 is transitive-yielding
it is sufficient to prove
thus for b1 being RelStr
st b1 in proj2 a1
holds b1 is transitive;
:: PCS_0:def 4
theorem
for b1 being Relation-like set holds
b1 is transitive-yielding
iff
for b2 being RelStr
st b2 in proj2 b1
holds b2 is transitive;
:: PCS_0:condreg 2
registration
cluster Relation-like Poset-yielding -> transitive-yielding (set);
end;
:: PCS_0:exreg 1
registration
cluster Relation-like Function-like Poset-yielding set;
end;
:: PCS_0:exreg 2
registration
let a1 be set;
cluster Relation-like Function-like Poset-yielding ManySortedSet of a1;
end;
:: PCS_0:funcnot 6 => PCS_0:func 4
definition
let a1 be set;
let a2 be RelStr-yielding ManySortedSet of a1;
func pcs-InternalRels A2 -> ManySortedSet of a1 means
for b1 being set
st b1 in a1
holds ex b2 being RelStr st
b2 = a2 . b1 & it . b1 = the InternalRel of b2;
end;
:: PCS_0:def 5
theorem
for b1 being set
for b2 being RelStr-yielding ManySortedSet of b1
for b3 being ManySortedSet of b1 holds
b3 = pcs-InternalRels b2
iff
for b4 being set
st b4 in b1
holds ex b5 being RelStr st
b5 = b2 . b4 & b3 . b4 = the InternalRel of b5;
:: PCS_0:funcnot 7 => PCS_0:func 4
definition
let a1 be set;
let a2 be RelStr-yielding ManySortedSet of a1;
func pcs-InternalRels A2 -> ManySortedSet of a1 means
for b1 being Element of a1 holds
it . b1 = the InternalRel of a2 . b1;
end;
:: PCS_0:def 6
theorem
for b1 being non empty set
for b2 being RelStr-yielding ManySortedSet of b1
for b3 being ManySortedSet of b1 holds
b3 = pcs-InternalRels b2
iff
for b4 being Element of b1 holds
b3 . b4 = the InternalRel of b2 . b4;
:: PCS_0:funcreg 10
registration
let a1 be set;
let a2 be RelStr-yielding ManySortedSet of a1;
cluster pcs-InternalRels a2 -> Relation-yielding;
end;
:: PCS_0:funcreg 11
registration
let a1 be non empty set;
let a2 be RelStr-yielding transitive-yielding ManySortedSet of a1;
let a3 be Element of a1;
cluster a2 . a3 -> transitive;
end;
:: PCS_0:structnot 1 => PCS_0:struct 1
definition
struct(1-sorted) TolStr(#
carrier -> set,
ToleranceRel -> Relation of the carrier of it,the carrier of it
#);
end;
:: PCS_0:attrnot 2 => PCS_0:attr 2
definition
let a1 be TolStr;
attr a1 is strict;
end;
:: PCS_0:exreg 3
registration
cluster strict TolStr;
end;
:: PCS_0:aggrnot 1 => PCS_0:aggr 1
definition
let a1 be set;
let a2 be Relation of a1,a1;
aggr TolStr(#a1,a2#) -> strict TolStr;
end;
:: PCS_0:selnot 1 => PCS_0:sel 1
definition
let a1 be TolStr;
sel the ToleranceRel of a1 -> Relation of the carrier of a1,the carrier of a1;
end;
:: PCS_0:prednot 1 => PCS_0:pred 1
definition
let a1 be TolStr;
let a2, a3 be Element of the carrier of a1;
pred A2 (--) A3 means
[a2,a3] in the ToleranceRel of a1;
end;
:: PCS_0:dfs 7
definiens
let a1 be TolStr;
let a2, a3 be Element of the carrier of a1;
To prove
a2 (--) a3
it is sufficient to prove
thus [a2,a3] in the ToleranceRel of a1;
:: PCS_0:def 7
theorem
for b1 being TolStr
for b2, b3 being Element of the carrier of b1 holds
b2 (--) b3
iff
[b2,b3] in the ToleranceRel of b1;
:: PCS_0:attrnot 3 => PCS_0:attr 3
definition
let a1 be TolStr;
attr a1 is pcs-tol-total means
the ToleranceRel of a1 is total(the carrier of a1, the carrier of a1);
end;
:: PCS_0:dfs 8
definiens
let a1 be TolStr;
To prove
a1 is pcs-tol-total
it is sufficient to prove
thus the ToleranceRel of a1 is total(the carrier of a1, the carrier of a1);
:: PCS_0:def 8
theorem
for b1 being TolStr holds
b1 is pcs-tol-total
iff
the ToleranceRel of b1 is total(the carrier of b1, the carrier of b1);
:: PCS_0:attrnot 4 => PCS_0:attr 4
definition
let a1 be TolStr;
attr a1 is pcs-tol-reflexive means
the ToleranceRel of a1 is_reflexive_in the carrier of a1;
end;
:: PCS_0:dfs 9
definiens
let a1 be TolStr;
To prove
a1 is pcs-tol-reflexive
it is sufficient to prove
thus the ToleranceRel of a1 is_reflexive_in the carrier of a1;
:: PCS_0:def 9
theorem
for b1 being TolStr holds
b1 is pcs-tol-reflexive
iff
the ToleranceRel of b1 is_reflexive_in the carrier of b1;
:: PCS_0:attrnot 5 => PCS_0:attr 5
definition
let a1 be TolStr;
attr a1 is pcs-tol-irreflexive means
the ToleranceRel of a1 is_irreflexive_in the carrier of a1;
end;
:: PCS_0:dfs 10
definiens
let a1 be TolStr;
To prove
a1 is pcs-tol-irreflexive
it is sufficient to prove
thus the ToleranceRel of a1 is_irreflexive_in the carrier of a1;
:: PCS_0:def 10
theorem
for b1 being TolStr holds
b1 is pcs-tol-irreflexive
iff
the ToleranceRel of b1 is_irreflexive_in the carrier of b1;
:: PCS_0:attrnot 6 => PCS_0:attr 6
definition
let a1 be TolStr;
attr a1 is pcs-tol-symmetric means
the ToleranceRel of a1 is_symmetric_in the carrier of a1;
end;
:: PCS_0:dfs 11
definiens
let a1 be TolStr;
To prove
a1 is pcs-tol-symmetric
it is sufficient to prove
thus the ToleranceRel of a1 is_symmetric_in the carrier of a1;
:: PCS_0:def 11
theorem
for b1 being TolStr holds
b1 is pcs-tol-symmetric
iff
the ToleranceRel of b1 is_symmetric_in the carrier of b1;
:: PCS_0:funcnot 8 => PCS_0:func 5
definition
func emptyTolStr -> TolStr equals
TolStr(#{},{}({},{})#);
end;
:: PCS_0:def 12
theorem
emptyTolStr = TolStr(#{},{}({},{})#);
:: PCS_0:funcreg 12
registration
cluster emptyTolStr -> empty strict;
end;
:: PCS_0:th 2
theorem
for b1 being TolStr
st b1 is empty
holds TolStr(#the carrier of b1,the ToleranceRel of b1#) = emptyTolStr;
:: PCS_0:condreg 3
registration
cluster pcs-tol-reflexive -> pcs-tol-total (TolStr);
end;
:: PCS_0:condreg 4
registration
cluster empty -> pcs-tol-reflexive pcs-tol-irreflexive pcs-tol-symmetric (TolStr);
end;
:: PCS_0:exreg 4
registration
cluster empty TolStr;
end;
:: PCS_0:funcreg 13
registration
let a1 be pcs-tol-total TolStr;
cluster the ToleranceRel of a1 -> total;
end;
:: PCS_0:funcreg 14
registration
let a1 be pcs-tol-reflexive TolStr;
cluster the ToleranceRel of a1 -> reflexive;
end;
:: PCS_0:funcreg 15
registration
let a1 be pcs-tol-irreflexive TolStr;
cluster the ToleranceRel of a1 -> irreflexive;
end;
:: PCS_0:funcreg 16
registration
let a1 be pcs-tol-symmetric TolStr;
cluster the ToleranceRel of a1 -> symmetric;
end;
:: PCS_0:funcreg 17
registration
let a1 be pcs-tol-total TolStr;
cluster TolStr(#the carrier of a1,the ToleranceRel of a1#) -> strict pcs-tol-total;
end;
:: PCS_0:prednot 2 => PCS_0:pred 2
definition
let a1 be pcs-tol-symmetric TolStr;
let a2, a3 be Element of the carrier of a1;
redefine pred a2 (--) a3;
symmetry;
:: for a1 being pcs-tol-symmetric TolStr
:: for a2, a3 being Element of the carrier of a1
:: st a2 (--) a3
:: holds a3 (--) a2;
end;
:: PCS_0:funcreg 18
registration
let a1 be set;
cluster TolStr(#a1,nabla a1#) -> strict pcs-tol-reflexive pcs-tol-symmetric;
end;
:: PCS_0:funcreg 19
registration
let a1 be set;
cluster TolStr(#a1,{}(a1,a1)#) -> strict pcs-tol-irreflexive pcs-tol-symmetric;
end;
:: PCS_0:exreg 5
registration
cluster non empty strict pcs-tol-reflexive pcs-tol-symmetric TolStr;
end;
:: PCS_0:exreg 6
registration
cluster non empty strict pcs-tol-irreflexive pcs-tol-symmetric TolStr;
end;
:: PCS_0:attrnot 7 => PCS_0:attr 7
definition
let a1 be Relation-like set;
attr a1 is TolStr-yielding means
for b1 being set
st b1 in proj2 a1
holds b1 is TolStr;
end;
:: PCS_0:dfs 13
definiens
let a1 be Relation-like set;
To prove
a1 is TolStr-yielding
it is sufficient to prove
thus for b1 being set
st b1 in proj2 a1
holds b1 is TolStr;
:: PCS_0:def 13
theorem
for b1 being Relation-like set holds
b1 is TolStr-yielding
iff
for b2 being set
st b2 in proj2 b1
holds b2 is TolStr;
:: PCS_0:attrnot 8 => PCS_0:attr 7
definition
let a1 be Relation-like set;
attr a1 is TolStr-yielding means
for b1 being set
st b1 in proj1 a1
holds a1 . b1 is TolStr;
end;
:: PCS_0:dfs 14
definiens
let a1 be Relation-like Function-like set;
To prove
a1 is TolStr-yielding
it is sufficient to prove
thus for b1 being set
st b1 in proj1 a1
holds a1 . b1 is TolStr;
:: PCS_0:def 14
theorem
for b1 being Relation-like Function-like set holds
b1 is TolStr-yielding
iff
for b2 being set
st b2 in proj1 b1
holds b1 . b2 is TolStr;
:: PCS_0:attrnot 9 => PCS_0:attr 8
definition
let a1 be set;
let a2 be ManySortedSet of a1;
redefine attr a2 is TolStr-yielding means
for b1 being set
st b1 in a1
holds a2 . b1 is TolStr;
end;
:: PCS_0:dfs 15
definiens
let a1 be set;
let a2 be ManySortedSet of a1;
To prove
a1 is TolStr-yielding
it is sufficient to prove
thus for b1 being set
st b1 in a1
holds a2 . b1 is TolStr;
:: PCS_0:def 15
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
b2 is TolStr-yielding
iff
for b3 being set
st b3 in b1
holds b2 . b3 is TolStr;
:: PCS_0:attrnot 10 => PCS_0:attr 9
definition
let a1 be Relation-like set;
attr a1 is pcs-tol-reflexive-yielding means
for b1 being TolStr
st b1 in proj2 a1
holds b1 is pcs-tol-reflexive;
end;
:: PCS_0:dfs 16
definiens
let a1 be Relation-like set;
To prove
a1 is pcs-tol-reflexive-yielding
it is sufficient to prove
thus for b1 being TolStr
st b1 in proj2 a1
holds b1 is pcs-tol-reflexive;
:: PCS_0:def 16
theorem
for b1 being Relation-like set holds
b1 is pcs-tol-reflexive-yielding
iff
for b2 being TolStr
st b2 in proj2 b1
holds b2 is pcs-tol-reflexive;
:: PCS_0:attrnot 11 => PCS_0:attr 10
definition
let a1 be Relation-like set;
attr a1 is pcs-tol-irreflexive-yielding means
for b1 being TolStr
st b1 in proj2 a1
holds b1 is pcs-tol-irreflexive;
end;
:: PCS_0:dfs 17
definiens
let a1 be Relation-like set;
To prove
a1 is pcs-tol-irreflexive-yielding
it is sufficient to prove
thus for b1 being TolStr
st b1 in proj2 a1
holds b1 is pcs-tol-irreflexive;
:: PCS_0:def 17
theorem
for b1 being Relation-like set holds
b1 is pcs-tol-irreflexive-yielding
iff
for b2 being TolStr
st b2 in proj2 b1
holds b2 is pcs-tol-irreflexive;
:: PCS_0:attrnot 12 => PCS_0:attr 11
definition
let a1 be Relation-like set;
attr a1 is pcs-tol-symmetric-yielding means
for b1 being TolStr
st b1 in proj2 a1
holds b1 is pcs-tol-symmetric;
end;
:: PCS_0:dfs 18
definiens
let a1 be Relation-like set;
To prove
a1 is pcs-tol-symmetric-yielding
it is sufficient to prove
thus for b1 being TolStr
st b1 in proj2 a1
holds b1 is pcs-tol-symmetric;
:: PCS_0:def 18
theorem
for b1 being Relation-like set holds
b1 is pcs-tol-symmetric-yielding
iff
for b2 being TolStr
st b2 in proj2 b1
holds b2 is pcs-tol-symmetric;
:: PCS_0:condreg 5
registration
cluster Relation-like empty -> pcs-tol-reflexive-yielding pcs-tol-irreflexive-yielding pcs-tol-symmetric-yielding (set);
end;
:: PCS_0:funcreg 20
registration
let a1 be set;
let a2 be TolStr;
cluster a1 --> a2 -> TolStr-yielding;
end;
:: PCS_0:funcreg 21
registration
let a1 be set;
let a2 be pcs-tol-reflexive TolStr;
cluster a1 --> a2 -> pcs-tol-reflexive-yielding;
end;
:: PCS_0:funcreg 22
registration
let a1 be set;
let a2 be pcs-tol-irreflexive TolStr;
cluster a1 --> a2 -> pcs-tol-irreflexive-yielding;
end;
:: PCS_0:funcreg 23
registration
let a1 be set;
let a2 be pcs-tol-symmetric TolStr;
cluster a1 --> a2 -> pcs-tol-symmetric-yielding;
end;
:: PCS_0:condreg 6
registration
cluster Relation-like Function-like TolStr-yielding -> 1-sorted-yielding (set);
end;
:: PCS_0:exreg 7
registration
let a1 be set;
cluster Relation-like Function-like TolStr-yielding pcs-tol-reflexive-yielding pcs-tol-symmetric-yielding ManySortedSet of a1;
end;
:: PCS_0:exreg 8
registration
let a1 be set;
cluster Relation-like Function-like TolStr-yielding pcs-tol-irreflexive-yielding pcs-tol-symmetric-yielding ManySortedSet of a1;
end;
:: PCS_0:exreg 9
registration
let a1 be set;
cluster Relation-like Function-like TolStr-yielding ManySortedSet of a1;
end;
:: PCS_0:funcnot 9 => PCS_0:func 6
definition
let a1 be non empty set;
let a2 be TolStr-yielding ManySortedSet of a1;
let a3 be Element of a1;
redefine func a2 . a3 -> TolStr;
end;
:: PCS_0:funcnot 10 => PCS_0:func 7
definition
let a1 be set;
let a2 be TolStr-yielding ManySortedSet of a1;
func pcs-ToleranceRels A2 -> ManySortedSet of a1 means
for b1 being set
st b1 in a1
holds ex b2 being TolStr st
b2 = a2 . b1 & it . b1 = the ToleranceRel of b2;
end;
:: PCS_0:def 19
theorem
for b1 being set
for b2 being TolStr-yielding ManySortedSet of b1
for b3 being ManySortedSet of b1 holds
b3 = pcs-ToleranceRels b2
iff
for b4 being set
st b4 in b1
holds ex b5 being TolStr st
b5 = b2 . b4 & b3 . b4 = the ToleranceRel of b5;
:: PCS_0:funcnot 11 => PCS_0:func 7
definition
let a1 be set;
let a2 be TolStr-yielding ManySortedSet of a1;
func pcs-ToleranceRels A2 -> ManySortedSet of a1 means
for b1 being Element of a1 holds
it . b1 = the ToleranceRel of a2 . b1;
end;
:: PCS_0:def 20
theorem
for b1 being non empty set
for b2 being TolStr-yielding ManySortedSet of b1
for b3 being ManySortedSet of b1 holds
b3 = pcs-ToleranceRels b2
iff
for b4 being Element of b1 holds
b3 . b4 = the ToleranceRel of b2 . b4;
:: PCS_0:funcreg 24
registration
let a1 be set;
let a2 be TolStr-yielding ManySortedSet of a1;
cluster pcs-ToleranceRels a2 -> Relation-yielding;
end;
:: PCS_0:funcreg 25
registration
let a1 be non empty set;
let a2 be TolStr-yielding pcs-tol-reflexive-yielding ManySortedSet of a1;
let a3 be Element of a1;
cluster a2 . a3 -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 26
registration
let a1 be non empty set;
let a2 be TolStr-yielding pcs-tol-irreflexive-yielding ManySortedSet of a1;
let a3 be Element of a1;
cluster a2 . a3 -> pcs-tol-irreflexive;
end;
:: PCS_0:funcreg 27
registration
let a1 be non empty set;
let a2 be TolStr-yielding pcs-tol-symmetric-yielding ManySortedSet of a1;
let a3 be Element of a1;
cluster a2 . a3 -> pcs-tol-symmetric;
end;
:: PCS_0:th 3
theorem
for b1, b2 being TolStr
st TolStr(#the carrier of b1,the ToleranceRel of b1#) = TolStr(#the carrier of b2,the ToleranceRel of b2#) &
b1 is pcs-tol-reflexive
holds b2 is pcs-tol-reflexive;
:: PCS_0:th 4
theorem
for b1, b2 being TolStr
st TolStr(#the carrier of b1,the ToleranceRel of b1#) = TolStr(#the carrier of b2,the ToleranceRel of b2#) &
b1 is pcs-tol-irreflexive
holds b2 is pcs-tol-irreflexive;
:: PCS_0:th 5
theorem
for b1, b2 being TolStr
st TolStr(#the carrier of b1,the ToleranceRel of b1#) = TolStr(#the carrier of b2,the ToleranceRel of b2#) &
b1 is pcs-tol-symmetric
holds b2 is pcs-tol-symmetric;
:: PCS_0:funcnot 12 => PCS_0:func 8
definition
let a1, a2 be TolStr;
func [^A1,A2^] -> TolStr equals
TolStr(#[:the carrier of a1,the carrier of a2:],[^the ToleranceRel of a1,the ToleranceRel of a2^]#);
end;
:: PCS_0:def 21
theorem
for b1, b2 being TolStr holds
[^b1,b2^] = TolStr(#[:the carrier of b1,the carrier of b2:],[^the ToleranceRel of b1,the ToleranceRel of b2^]#);
:: PCS_0:funcnot 13 => TARSKI:func 4
notation
let a1, a2 be TolStr;
let a3 be Element of the carrier of a1;
let a4 be Element of the carrier of a2;
synonym [^a3,a4^] for [a1,a2];
end;
:: PCS_0:funcnot 14 => PCS_0:func 9
definition
let a1, a2 be non empty TolStr;
let a3 be Element of the carrier of a1;
let a4 be Element of the carrier of a2;
redefine func [^a3, a4^] -> Element of the carrier of [^a1,a2^];
end;
:: PCS_0:funcnot 15 => MCART_1:func 1
notation
let a1, a2 be TolStr;
let a3 be Element of the carrier of [^a1,a2^];
synonym a3 ^`1 for a1 `1;
end;
:: PCS_0:funcnot 16 => MCART_1:func 2
notation
let a1, a2 be TolStr;
let a3 be Element of the carrier of [^a1,a2^];
synonym a3 ^`2 for a1 `2;
end;
:: PCS_0:funcnot 17 => PCS_0:func 10
definition
let a1, a2 be non empty TolStr;
let a3 be Element of the carrier of [^a1,a2^];
redefine func a3 ^`1 -> Element of the carrier of a1;
end;
:: PCS_0:funcnot 18 => PCS_0:func 11
definition
let a1, a2 be non empty TolStr;
let a3 be Element of the carrier of [^a1,a2^];
redefine func a3 ^`2 -> Element of the carrier of a2;
end;
:: PCS_0:th 6
theorem
for b1, b2 being non empty TolStr
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2 holds
[^b3,b5^] (--) [^b4,b6^]
iff
(b3 (--) b4 or b5 (--) b6);
:: PCS_0:th 7
theorem
for b1, b2 being non empty TolStr
for b3, b4 being Element of the carrier of [^b1,b2^] holds
b3 (--) b4
iff
(b3 ^`1 (--) b4 ^`1 or b3 ^`2 (--) b4 ^`2);
:: PCS_0:funcreg 28
registration
let a1 be TolStr;
let a2 be pcs-tol-reflexive TolStr;
cluster [^a1,a2^] -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 29
registration
let a1 be pcs-tol-reflexive TolStr;
let a2 be TolStr;
cluster [^a1,a2^] -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 30
registration
let a1, a2 be pcs-tol-symmetric TolStr;
cluster [^a1,a2^] -> pcs-tol-symmetric;
end;
:: PCS_0:structnot 2 => PCS_0:struct 2
definition
struct(RelStr, TolStr) pcs-Str(#
carrier -> set,
InternalRel -> Relation of the carrier of it,the carrier of it,
ToleranceRel -> Relation of the carrier of it,the carrier of it
#);
end;
:: PCS_0:attrnot 13 => PCS_0:attr 12
definition
let a1 be pcs-Str;
attr a1 is strict;
end;
:: PCS_0:exreg 10
registration
cluster strict pcs-Str;
end;
:: PCS_0:aggrnot 2 => PCS_0:aggr 2
definition
let a1 be set;
let a2, a3 be Relation of a1,a1;
aggr pcs-Str(#a1,a2,a3#) -> strict pcs-Str;
end;
:: PCS_0:attrnot 14 => PCS_0:attr 13
definition
let a1 be pcs-Str;
attr a1 is pcs-compatible means
for b1, b2, b3, b4 being Element of the carrier of a1
st b1 (--) b3 & b2 <= b1 & b4 <= b3
holds b2 (--) b4;
end;
:: PCS_0:dfs 22
definiens
let a1 be pcs-Str;
To prove
a1 is pcs-compatible
it is sufficient to prove
thus for b1, b2, b3, b4 being Element of the carrier of a1
st b1 (--) b3 & b2 <= b1 & b4 <= b3
holds b2 (--) b4;
:: PCS_0:def 22
theorem
for b1 being pcs-Str holds
b1 is pcs-compatible
iff
for b2, b3, b4, b5 being Element of the carrier of b1
st b2 (--) b4 & b3 <= b2 & b5 <= b4
holds b3 (--) b5;
:: PCS_0:attrnot 15 => PCS_0:attr 14
definition
let a1 be pcs-Str;
attr a1 is pcs-like means
a1 is reflexive & a1 is transitive & a1 is pcs-tol-reflexive & a1 is pcs-tol-symmetric & a1 is pcs-compatible;
end;
:: PCS_0:dfs 23
definiens
let a1 be pcs-Str;
To prove
a1 is pcs-like
it is sufficient to prove
thus a1 is reflexive & a1 is transitive & a1 is pcs-tol-reflexive & a1 is pcs-tol-symmetric & a1 is pcs-compatible;
:: PCS_0:def 23
theorem
for b1 being pcs-Str holds
b1 is pcs-like
iff
b1 is reflexive & b1 is transitive & b1 is pcs-tol-reflexive & b1 is pcs-tol-symmetric & b1 is pcs-compatible;
:: PCS_0:attrnot 16 => PCS_0:attr 15
definition
let a1 be pcs-Str;
attr a1 is anti-pcs-like means
a1 is reflexive & a1 is transitive & a1 is pcs-tol-irreflexive & a1 is pcs-tol-symmetric & a1 is pcs-compatible;
end;
:: PCS_0:dfs 24
definiens
let a1 be pcs-Str;
To prove
a1 is anti-pcs-like
it is sufficient to prove
thus a1 is reflexive & a1 is transitive & a1 is pcs-tol-irreflexive & a1 is pcs-tol-symmetric & a1 is pcs-compatible;
:: PCS_0:def 24
theorem
for b1 being pcs-Str holds
b1 is anti-pcs-like
iff
b1 is reflexive & b1 is transitive & b1 is pcs-tol-irreflexive & b1 is pcs-tol-symmetric & b1 is pcs-compatible;
:: PCS_0:condreg 7
registration
cluster pcs-like -> reflexive transitive pcs-tol-reflexive pcs-tol-symmetric pcs-compatible (pcs-Str);
end;
:: PCS_0:condreg 8
registration
cluster reflexive transitive pcs-tol-reflexive pcs-tol-symmetric pcs-compatible -> pcs-like (pcs-Str);
end;
:: PCS_0:condreg 9
registration
cluster anti-pcs-like -> reflexive transitive pcs-tol-irreflexive pcs-tol-symmetric pcs-compatible (pcs-Str);
end;
:: PCS_0:condreg 10
registration
cluster reflexive transitive pcs-tol-irreflexive pcs-tol-symmetric pcs-compatible -> anti-pcs-like (pcs-Str);
end;
:: PCS_0:funcnot 19 => PCS_0:func 12
definition
let a1 be set;
func pcs-total A1 -> pcs-Str equals
pcs-Str(#a1,nabla a1,nabla a1#);
end;
:: PCS_0:def 25
theorem
for b1 being set holds
pcs-total b1 = pcs-Str(#b1,nabla b1,nabla b1#);
:: PCS_0:funcreg 31
registration
let a1 be set;
cluster pcs-total a1 -> strict;
end;
:: PCS_0:funcreg 32
registration
let a1 be non empty set;
cluster pcs-total a1 -> non empty;
end;
:: PCS_0:funcreg 33
registration
let a1 be set;
cluster pcs-total a1 -> reflexive transitive pcs-tol-reflexive pcs-tol-symmetric;
end;
:: PCS_0:funcreg 34
registration
let a1 be set;
cluster pcs-total a1 -> pcs-like;
end;
:: PCS_0:funcreg 35
registration
let a1 be set;
cluster pcs-Str(#a1,nabla a1,{}(a1,a1)#) -> strict anti-pcs-like;
end;
:: PCS_0:exreg 11
registration
cluster non empty strict pcs-like pcs-Str;
end;
:: PCS_0:exreg 12
registration
cluster non empty strict anti-pcs-like pcs-Str;
end;
:: PCS_0:modenot 1
definition
mode pcs is pcs-like pcs-Str;
end;
:: PCS_0:modenot 2
definition
mode anti-pcs is anti-pcs-like pcs-Str;
end;
:: PCS_0:funcnot 20 => PCS_0:func 13
definition
func pcs-empty -> pcs-Str equals
pcs-total 0;
end;
:: PCS_0:def 26
theorem
pcs-empty = pcs-total 0;
:: PCS_0:funcreg 36
registration
cluster pcs-empty -> empty strict pcs-like;
end;
:: PCS_0:funcnot 21 => PCS_0:func 14
definition
let a1 be set;
func pcs-singleton A1 -> pcs-Str equals
pcs-total {a1};
end;
:: PCS_0:def 27
theorem
for b1 being set holds
pcs-singleton b1 = pcs-total {b1};
:: PCS_0:funcreg 37
registration
let a1 be set;
cluster pcs-singleton a1 -> non empty strict pcs-like;
end;
:: PCS_0:attrnot 17 => PCS_0:attr 16
definition
let a1 be Relation-like set;
attr a1 is pcs-Str-yielding means
for b1 being set
st b1 in proj2 a1
holds b1 is pcs-Str;
end;
:: PCS_0:dfs 28
definiens
let a1 be Relation-like set;
To prove
a1 is pcs-Str-yielding
it is sufficient to prove
thus for b1 being set
st b1 in proj2 a1
holds b1 is pcs-Str;
:: PCS_0:def 28
theorem
for b1 being Relation-like set holds
b1 is pcs-Str-yielding
iff
for b2 being set
st b2 in proj2 b1
holds b2 is pcs-Str;
:: PCS_0:attrnot 18 => PCS_0:attr 17
definition
let a1 be Relation-like set;
attr a1 is pcs-yielding means
for b1 being set
st b1 in proj2 a1
holds b1 is pcs-like pcs-Str;
end;
:: PCS_0:dfs 29
definiens
let a1 be Relation-like set;
To prove
a1 is pcs-yielding
it is sufficient to prove
thus for b1 being set
st b1 in proj2 a1
holds b1 is pcs-like pcs-Str;
:: PCS_0:def 29
theorem
for b1 being Relation-like set holds
b1 is pcs-yielding
iff
for b2 being set
st b2 in proj2 b1
holds b2 is pcs-like pcs-Str;
:: PCS_0:attrnot 19 => PCS_0:attr 16
definition
let a1 be Relation-like set;
attr a1 is pcs-Str-yielding means
for b1 being set
st b1 in proj1 a1
holds a1 . b1 is pcs-Str;
end;
:: PCS_0:dfs 30
definiens
let a1 be Relation-like Function-like set;
To prove
a1 is pcs-Str-yielding
it is sufficient to prove
thus for b1 being set
st b1 in proj1 a1
holds a1 . b1 is pcs-Str;
:: PCS_0:def 30
theorem
for b1 being Relation-like Function-like set holds
b1 is pcs-Str-yielding
iff
for b2 being set
st b2 in proj1 b1
holds b1 . b2 is pcs-Str;
:: PCS_0:attrnot 20 => PCS_0:attr 17
definition
let a1 be Relation-like set;
attr a1 is pcs-yielding means
for b1 being set
st b1 in proj1 a1
holds a1 . b1 is pcs-like pcs-Str;
end;
:: PCS_0:dfs 31
definiens
let a1 be Relation-like Function-like set;
To prove
a1 is pcs-yielding
it is sufficient to prove
thus for b1 being set
st b1 in proj1 a1
holds a1 . b1 is pcs-like pcs-Str;
:: PCS_0:def 31
theorem
for b1 being Relation-like Function-like set holds
b1 is pcs-yielding
iff
for b2 being set
st b2 in proj1 b1
holds b1 . b2 is pcs-like pcs-Str;
:: PCS_0:attrnot 21 => PCS_0:attr 18
definition
let a1 be set;
let a2 be ManySortedSet of a1;
redefine attr a2 is pcs-Str-yielding means
for b1 being set
st b1 in a1
holds a2 . b1 is pcs-Str;
end;
:: PCS_0:dfs 32
definiens
let a1 be set;
let a2 be ManySortedSet of a1;
To prove
a1 is pcs-Str-yielding
it is sufficient to prove
thus for b1 being set
st b1 in a1
holds a2 . b1 is pcs-Str;
:: PCS_0:def 32
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
b2 is pcs-Str-yielding
iff
for b3 being set
st b3 in b1
holds b2 . b3 is pcs-Str;
:: PCS_0:attrnot 22 => PCS_0:attr 19
definition
let a1 be set;
let a2 be ManySortedSet of a1;
redefine attr a2 is pcs-yielding means
for b1 being set
st b1 in a1
holds a2 . b1 is pcs-like pcs-Str;
end;
:: PCS_0:dfs 33
definiens
let a1 be set;
let a2 be ManySortedSet of a1;
To prove
a1 is pcs-yielding
it is sufficient to prove
thus for b1 being set
st b1 in a1
holds a2 . b1 is pcs-like pcs-Str;
:: PCS_0:def 33
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
b2 is pcs-yielding
iff
for b3 being set
st b3 in b1
holds b2 . b3 is pcs-like pcs-Str;
:: PCS_0:condreg 11
registration
cluster Relation-like pcs-Str-yielding -> RelStr-yielding TolStr-yielding (set);
end;
:: PCS_0:condreg 12
registration
cluster Relation-like pcs-yielding -> pcs-Str-yielding (set);
end;
:: PCS_0:condreg 13
registration
cluster Relation-like pcs-yielding -> reflexive-yielding transitive-yielding pcs-tol-reflexive-yielding pcs-tol-symmetric-yielding (set);
end;
:: PCS_0:funcreg 38
registration
let a1 be set;
let a2 be pcs-like pcs-Str;
cluster a1 --> a2 -> pcs-yielding;
end;
:: PCS_0:exreg 13
registration
let a1 be set;
cluster Relation-like Function-like pcs-yielding ManySortedSet of a1;
end;
:: PCS_0:funcnot 22 => PCS_0:func 15
definition
let a1 be non empty set;
let a2 be pcs-Str-yielding ManySortedSet of a1;
let a3 be Element of a1;
redefine func a2 . a3 -> pcs-Str;
end;
:: PCS_0:funcnot 23 => PCS_0:func 16
definition
let a1 be non empty set;
let a2 be pcs-yielding ManySortedSet of a1;
let a3 be Element of a1;
redefine func a2 . a3 -> pcs-like pcs-Str;
end;
:: PCS_0:prednot 3 => PCS_0:pred 3
definition
let a1, a2 be pcs-Str;
pred A1 c= A2 means
the carrier of a1 c= the carrier of a2 & the InternalRel of a1 c= the InternalRel of a2 & the ToleranceRel of a1 c= the ToleranceRel of a2;
reflexivity;
:: for a1 being pcs-Str holds
:: a1 c= a1;
end;
:: PCS_0:dfs 34
definiens
let a1, a2 be pcs-Str;
To prove
a1 c= a2
it is sufficient to prove
thus the carrier of a1 c= the carrier of a2 & the InternalRel of a1 c= the InternalRel of a2 & the ToleranceRel of a1 c= the ToleranceRel of a2;
:: PCS_0:def 34
theorem
for b1, b2 being pcs-Str holds
b1 c= b2
iff
the carrier of b1 c= the carrier of b2 & the InternalRel of b1 c= the InternalRel of b2 & the ToleranceRel of b1 c= the ToleranceRel of b2;
:: PCS_0:th 8
theorem
for b1, b2 being RelStr
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
st the InternalRel of b1 c= the InternalRel of b2 & b3 = b5 & b4 = b6 & b3 <= b4
holds b5 <= b6;
:: PCS_0:th 9
theorem
for b1, b2 being TolStr
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
st the ToleranceRel of b1 c= the ToleranceRel of b2 & b3 = b5 & b4 = b6 & b3 (--) b4
holds b5 (--) b6;
:: PCS_0:attrnot 23 => PCS_0:attr 20
definition
let a1 be Relation-like set;
attr a1 is pcs-chain-like means
for b1, b2 being pcs-Str
st b1 in proj2 a1 & b2 in proj2 a1 & not b1 c= b2
holds b2 c= b1;
end;
:: PCS_0:dfs 35
definiens
let a1 be Relation-like set;
To prove
a1 is pcs-chain-like
it is sufficient to prove
thus for b1, b2 being pcs-Str
st b1 in proj2 a1 & b2 in proj2 a1 & not b1 c= b2
holds b2 c= b1;
:: PCS_0:def 35
theorem
for b1 being Relation-like set holds
b1 is pcs-chain-like
iff
for b2, b3 being pcs-Str
st b2 in proj2 b1 & b3 in proj2 b1 & not b2 c= b3
holds b3 c= b2;
:: PCS_0:funcreg 39
registration
let a1 be set;
let a2 be pcs-Str;
cluster a1 --> a2 -> pcs-chain-like;
end;
:: PCS_0:exreg 14
registration
cluster Relation-like Function-like pcs-yielding pcs-chain-like set;
end;
:: PCS_0:exreg 15
registration
let a1 be set;
cluster Relation-like Function-like pcs-yielding pcs-chain-like ManySortedSet of a1;
end;
:: PCS_0:modenot 3
definition
let a1 be set;
mode pcs-Chain of a1 is pcs-yielding pcs-chain-like ManySortedSet of a1;
end;
:: PCS_0:funcnot 24 => PCS_0:func 17
definition
let a1 be set;
let a2 be pcs-Str-yielding ManySortedSet of a1;
func pcs-union A2 -> strict pcs-Str means
the carrier of it = Union Carrier a2 & the InternalRel of it = Union pcs-InternalRels a2 & the ToleranceRel of it = Union pcs-ToleranceRels a2;
end;
:: PCS_0:def 36
theorem
for b1 being set
for b2 being pcs-Str-yielding ManySortedSet of b1
for b3 being strict pcs-Str holds
b3 = pcs-union b2
iff
the carrier of b3 = Union Carrier b2 & the InternalRel of b3 = Union pcs-InternalRels b2 & the ToleranceRel of b3 = Union pcs-ToleranceRels b2;
:: PCS_0:th 10
theorem
for b1 being set
for b2 being pcs-Str-yielding ManySortedSet of b1
for b3, b4 being Element of the carrier of pcs-union b2 holds
b3 <= b4
iff
ex b5 being set st
ex b6 being pcs-Str st
ex b7, b8 being Element of the carrier of b6 st
b5 in b1 & b6 = b2 . b5 & b7 = b3 & b8 = b4 & b7 <= b8;
:: PCS_0:th 11
theorem
for b1 being non empty set
for b2 being pcs-Str-yielding ManySortedSet of b1
for b3, b4 being Element of the carrier of pcs-union b2 holds
b3 <= b4
iff
ex b5 being Element of b1 st
ex b6, b7 being Element of the carrier of b2 . b5 st
b6 = b3 & b7 = b4 & b6 <= b7;
:: PCS_0:th 12
theorem
for b1 being set
for b2 being pcs-Str-yielding ManySortedSet of b1
for b3, b4 being Element of the carrier of pcs-union b2 holds
b3 (--) b4
iff
ex b5 being set st
ex b6 being pcs-Str st
ex b7, b8 being Element of the carrier of b6 st
b5 in b1 & b6 = b2 . b5 & b7 = b3 & b8 = b4 & b7 (--) b8;
:: PCS_0:th 13
theorem
for b1 being non empty set
for b2 being pcs-Str-yielding ManySortedSet of b1
for b3, b4 being Element of the carrier of pcs-union b2 holds
b3 (--) b4
iff
ex b5 being Element of b1 st
ex b6, b7 being Element of the carrier of b2 . b5 st
b6 = b3 & b7 = b4 & b6 (--) b7;
:: PCS_0:funcreg 40
registration
let a1 be set;
let a2 be reflexive-yielding pcs-Str-yielding ManySortedSet of a1;
cluster pcs-union a2 -> reflexive strict;
end;
:: PCS_0:funcreg 41
registration
let a1 be set;
let a2 be pcs-tol-reflexive-yielding pcs-Str-yielding ManySortedSet of a1;
cluster pcs-union a2 -> pcs-tol-reflexive strict;
end;
:: PCS_0:funcreg 42
registration
let a1 be set;
let a2 be pcs-tol-symmetric-yielding pcs-Str-yielding ManySortedSet of a1;
cluster pcs-union a2 -> pcs-tol-symmetric strict;
end;
:: PCS_0:funcreg 43
registration
let a1 be set;
let a2 be pcs-yielding pcs-chain-like ManySortedSet of a1;
cluster pcs-union a2 -> transitive strict pcs-compatible;
end;
:: PCS_0:funcnot 25 => PCS_0:func 18
definition
let a1, a2 be set;
func MSSet(A1,A2) -> ManySortedSet of {0,1} equals
(0,1)-->(a1,a2);
end;
:: PCS_0:def 37
theorem
for b1, b2 being set holds
MSSet(b1,b2) = (0,1)-->(b1,b2);
:: PCS_0:funcreg 44
registration
let a1, a2 be 1-sorted;
cluster MSSet(a1,a2) -> 1-sorted-yielding;
end;
:: PCS_0:funcreg 45
registration
let a1, a2 be RelStr;
cluster MSSet(a1,a2) -> RelStr-yielding;
end;
:: PCS_0:funcreg 46
registration
let a1, a2 be TolStr;
cluster MSSet(a1,a2) -> TolStr-yielding;
end;
:: PCS_0:funcreg 47
registration
let a1, a2 be pcs-Str;
cluster MSSet(a1,a2) -> pcs-Str-yielding;
end;
:: PCS_0:funcreg 48
registration
let a1, a2 be reflexive pcs-Str;
cluster MSSet(a1,a2) -> reflexive-yielding;
end;
:: PCS_0:funcreg 49
registration
let a1, a2 be transitive pcs-Str;
cluster MSSet(a1,a2) -> transitive-yielding;
end;
:: PCS_0:funcreg 50
registration
let a1, a2 be pcs-tol-reflexive pcs-Str;
cluster MSSet(a1,a2) -> pcs-tol-reflexive-yielding;
end;
:: PCS_0:funcreg 51
registration
let a1, a2 be pcs-tol-symmetric pcs-Str;
cluster MSSet(a1,a2) -> pcs-tol-symmetric-yielding;
end;
:: PCS_0:funcreg 52
registration
let a1, a2 be pcs-like pcs-Str;
cluster MSSet(a1,a2) -> pcs-yielding;
end;
:: PCS_0:funcnot 26 => PCS_0:func 19
definition
let a1, a2 be pcs-Str;
func pcs-sum(A1,A2) -> pcs-Str equals
pcs-union MSSet(a1,a2);
end;
:: PCS_0:def 38
theorem
for b1, b2 being pcs-Str holds
pcs-sum(b1,b2) = pcs-union MSSet(b1,b2);
:: PCS_0:th 14
theorem
for b1, b2 being pcs-Str holds
the carrier of pcs-sum(b1,b2) = (the carrier of b1) \/ the carrier of b2 &
the InternalRel of pcs-sum(b1,b2) = (the InternalRel of b1) \/ the InternalRel of b2 &
the ToleranceRel of pcs-sum(b1,b2) = (the ToleranceRel of b1) \/ the ToleranceRel of b2;
:: PCS_0:th 15
theorem
for b1, b2 being pcs-Str holds
pcs-sum(b1,b2) = pcs-Str(#(the carrier of b1) \/ the carrier of b2,(the InternalRel of b1) \/ the InternalRel of b2,(the ToleranceRel of b1) \/ the ToleranceRel of b2#);
:: PCS_0:th 16
theorem
for b1, b2 being pcs-Str
for b3, b4 being Element of the carrier of pcs-sum(b1,b2) holds
b3 <= b4
iff
(for b5, b6 being Element of the carrier of b1
st b5 = b3 & b6 = b4
holds not b5 <= b6 implies ex b5, b6 being Element of the carrier of b2 st
b5 = b3 & b6 = b4 & b5 <= b6);
:: PCS_0:th 17
theorem
for b1, b2 being pcs-Str
for b3, b4 being Element of the carrier of pcs-sum(b1,b2) holds
b3 (--) b4
iff
(for b5, b6 being Element of the carrier of b1
st b5 = b3 & b6 = b4
holds not b5 (--) b6 implies ex b5, b6 being Element of the carrier of b2 st
b5 = b3 & b6 = b4 & b5 (--) b6);
:: PCS_0:funcreg 53
registration
let a1, a2 be reflexive pcs-Str;
cluster pcs-sum(a1,a2) -> reflexive;
end;
:: PCS_0:funcreg 54
registration
let a1, a2 be pcs-tol-reflexive pcs-Str;
cluster pcs-sum(a1,a2) -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 55
registration
let a1, a2 be pcs-tol-symmetric pcs-Str;
cluster pcs-sum(a1,a2) -> pcs-tol-symmetric;
end;
:: PCS_0:th 18
theorem
for b1, b2 being pcs-like pcs-Str
st b1 misses b2
holds the InternalRel of pcs-sum(b1,b2) is transitive;
:: PCS_0:th 19
theorem
for b1, b2 being pcs-like pcs-Str
st b1 misses b2
holds pcs-sum(b1,b2) is pcs-compatible;
:: PCS_0:th 20
theorem
for b1, b2 being pcs-like pcs-Str
st b1 misses b2
holds pcs-sum(b1,b2) is pcs-like pcs-Str;
:: PCS_0:funcnot 27 => PCS_0:func 20
definition
let a1 be pcs-Str;
let a2 be set;
func pcs-extension(A1,A2) -> strict pcs-Str means
the carrier of it = {a2} \/ the carrier of a1 &
the InternalRel of it = [:{a2},the carrier of it:] \/ the InternalRel of a1 &
the ToleranceRel of it = ([:{a2},the carrier of it:] \/ [:the carrier of it,{a2}:]) \/ the ToleranceRel of a1;
end;
:: PCS_0:def 39
theorem
for b1 being pcs-Str
for b2 being set
for b3 being strict pcs-Str holds
b3 = pcs-extension(b1,b2)
iff
the carrier of b3 = {b2} \/ the carrier of b1 &
the InternalRel of b3 = [:{b2},the carrier of b3:] \/ the InternalRel of b1 &
the ToleranceRel of b3 = ([:{b2},the carrier of b3:] \/ [:the carrier of b3,{b2}:]) \/ the ToleranceRel of b1;
:: PCS_0:funcreg 56
registration
let a1 be pcs-Str;
let a2 be set;
cluster pcs-extension(a1,a2) -> non empty strict;
end;
:: PCS_0:th 21
theorem
for b1 being pcs-Str
for b2 being set holds
the carrier of b1 c= the carrier of pcs-extension(b1,b2) & the InternalRel of b1 c= the InternalRel of pcs-extension(b1,b2) & the ToleranceRel of b1 c= the ToleranceRel of pcs-extension(b1,b2);
:: PCS_0:th 22
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b2
holds b3 <= b4;
:: PCS_0:th 23
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b5 & b4 = b6 & b3 <= b4
holds b5 <= b6;
:: PCS_0:th 24
theorem
for b1 being pcs-Str
for b2 being set
for b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b4 & b3 <> b2 & b4 <= b5 & not b2 in the carrier of b1
holds b5 in the carrier of b1 & b5 <> b2;
:: PCS_0:th 25
theorem
for b1 being pcs-Str
for b2 being set
for b3 being Element of the carrier of pcs-extension(b1,b2)
st b3 <> b2
holds b3 in the carrier of b1;
:: PCS_0:th 26
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b5 & b4 = b6 & b3 <> b2 & b5 <= b6
holds b3 <= b4;
:: PCS_0:th 27
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b2
holds b3 (--) b4 & b4 (--) b3;
:: PCS_0:th 28
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b5 & b4 = b6 & b3 (--) b4
holds b5 (--) b6;
:: PCS_0:th 29
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of pcs-extension(b1,b2)
st b3 = b5 & b4 = b6 & b3 <> b2 & b4 <> b2 & b5 (--) b6
holds b3 (--) b4;
:: PCS_0:funcreg 57
registration
let a1 be reflexive pcs-Str;
let a2 be set;
cluster pcs-extension(a1,a2) -> reflexive strict;
end;
:: PCS_0:th 30
theorem
for b1 being transitive pcs-Str
for b2 being set
st not b2 in the carrier of b1
holds pcs-extension(b1,b2) is transitive;
:: PCS_0:funcreg 58
registration
let a1 be pcs-tol-reflexive pcs-Str;
let a2 be set;
cluster pcs-extension(a1,a2) -> pcs-tol-reflexive strict;
end;
:: PCS_0:funcreg 59
registration
let a1 be pcs-tol-symmetric pcs-Str;
let a2 be set;
cluster pcs-extension(a1,a2) -> pcs-tol-symmetric strict;
end;
:: PCS_0:th 31
theorem
for b1 being pcs-compatible pcs-Str
for b2 being set
st not b2 in the carrier of b1
holds pcs-extension(b1,b2) is pcs-compatible;
:: PCS_0:th 32
theorem
for b1 being pcs-like pcs-Str
for b2 being set
st not b2 in the carrier of b1
holds pcs-extension(b1,b2) is pcs-like pcs-Str;
:: PCS_0:funcnot 28 => PCS_0:func 21
definition
let a1 be pcs-Str;
func pcs-reverse A1 -> strict pcs-Str means
the carrier of it = the carrier of a1 & the InternalRel of it = (the InternalRel of a1) ~ & the ToleranceRel of it = (the ToleranceRel of a1) `;
end;
:: PCS_0:def 40
theorem
for b1 being pcs-Str
for b2 being strict pcs-Str holds
b2 = pcs-reverse b1
iff
the carrier of b2 = the carrier of b1 & the InternalRel of b2 = (the InternalRel of b1) ~ & the ToleranceRel of b2 = (the ToleranceRel of b1) `;
:: PCS_0:funcreg 60
registration
let a1 be non empty pcs-Str;
cluster pcs-reverse a1 -> non empty strict;
end;
:: PCS_0:th 33
theorem
for b1 being pcs-Str
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of pcs-reverse b1
st b2 = b4 & b3 = b5
holds b2 <= b3
iff
b5 <= b4;
:: PCS_0:th 34
theorem
for b1 being pcs-Str
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of pcs-reverse b1
st b2 = b4 & b3 = b5 & b2 (--) b3
holds not b4 (--) b5;
:: PCS_0:th 35
theorem
for b1 being non empty pcs-Str
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of pcs-reverse b1
st b2 = b4 & b3 = b5 & not b4 (--) b5
holds b2 (--) b3;
:: PCS_0:funcreg 61
registration
let a1 be reflexive pcs-Str;
cluster pcs-reverse a1 -> reflexive strict;
end;
:: PCS_0:funcreg 62
registration
let a1 be transitive pcs-Str;
cluster pcs-reverse a1 -> transitive strict;
end;
:: PCS_0:funcreg 63
registration
let a1 be pcs-tol-reflexive pcs-Str;
cluster pcs-reverse a1 -> pcs-tol-irreflexive strict;
end;
:: PCS_0:funcreg 64
registration
let a1 be pcs-tol-irreflexive pcs-Str;
cluster pcs-reverse a1 -> pcs-tol-reflexive strict;
end;
:: PCS_0:funcreg 65
registration
let a1 be pcs-tol-symmetric pcs-Str;
cluster pcs-reverse a1 -> pcs-tol-symmetric strict;
end;
:: PCS_0:funcreg 66
registration
let a1 be pcs-compatible pcs-Str;
cluster pcs-reverse a1 -> strict pcs-compatible;
end;
:: PCS_0:funcnot 29 => PCS_0:func 22
definition
let a1, a2 be pcs-Str;
func A1 pcs-times A2 -> pcs-Str equals
pcs-Str(#[:the carrier of a1,the carrier of a2:],["the InternalRel of a1,the InternalRel of a2"],[^the ToleranceRel of a1,the ToleranceRel of a2^]#);
end;
:: PCS_0:def 41
theorem
for b1, b2 being pcs-Str holds
b1 pcs-times b2 = pcs-Str(#[:the carrier of b1,the carrier of b2:],["the InternalRel of b1,the InternalRel of b2"],[^the ToleranceRel of b1,the ToleranceRel of b2^]#);
:: PCS_0:funcreg 67
registration
let a1, a2 be pcs-Str;
cluster a1 pcs-times a2 -> strict;
end;
:: PCS_0:funcreg 68
registration
let a1, a2 be non empty pcs-Str;
cluster a1 pcs-times a2 -> non empty;
end;
:: PCS_0:th 36
theorem
for b1, b2 being pcs-Str
for b3, b4 being Element of the carrier of b1 pcs-times b2
for b5, b6 being Element of the carrier of b1
for b7, b8 being Element of the carrier of b2
st b3 = [b5,b7] & b4 = [b6,b8]
holds b3 <= b4
iff
b5 <= b6 & b7 <= b8;
:: PCS_0:th 37
theorem
for b1, b2 being pcs-Str
for b3, b4 being Element of the carrier of b1 pcs-times b2
for b5, b6 being Element of the carrier of b1
for b7, b8 being Element of the carrier of b2
st b3 = [b5,b7] & b4 = [b6,b8] & b3 (--) b4 & not b5 (--) b6
holds b7 (--) b8;
:: PCS_0:th 38
theorem
for b1, b2 being non empty pcs-Str
for b3, b4 being Element of the carrier of b1 pcs-times b2
for b5, b6 being Element of the carrier of b1
for b7, b8 being Element of the carrier of b2
st b3 = [b5,b7] & b4 = [b6,b8] & (b5 (--) b6 or b7 (--) b8)
holds b3 (--) b4;
:: PCS_0:funcreg 69
registration
let a1, a2 be reflexive pcs-Str;
cluster a1 pcs-times a2 -> reflexive;
end;
:: PCS_0:funcreg 70
registration
let a1, a2 be transitive pcs-Str;
cluster a1 pcs-times a2 -> transitive;
end;
:: PCS_0:funcreg 71
registration
let a1 be pcs-Str;
let a2 be pcs-tol-reflexive pcs-Str;
cluster a1 pcs-times a2 -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 72
registration
let a1 be pcs-tol-reflexive pcs-Str;
let a2 be pcs-Str;
cluster a1 pcs-times a2 -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 73
registration
let a1, a2 be pcs-tol-symmetric pcs-Str;
cluster a1 pcs-times a2 -> pcs-tol-symmetric;
end;
:: PCS_0:funcreg 74
registration
let a1, a2 be pcs-compatible pcs-Str;
cluster a1 pcs-times a2 -> pcs-compatible;
end;
:: PCS_0:funcnot 30 => PCS_0:func 23
definition
let a1, a2 be pcs-Str;
func A1 --> A2 -> pcs-Str equals
(pcs-reverse a1) pcs-times a2;
end;
:: PCS_0:def 42
theorem
for b1, b2 being pcs-Str holds
b1 --> b2 = (pcs-reverse b1) pcs-times b2;
:: PCS_0:funcreg 75
registration
let a1, a2 be pcs-Str;
cluster a1 --> a2 -> strict;
end;
:: PCS_0:funcreg 76
registration
let a1, a2 be non empty pcs-Str;
cluster a1 --> a2 -> non empty;
end;
:: PCS_0:th 39
theorem
for b1, b2 being pcs-Str
for b3, b4 being Element of the carrier of b1 --> b2
for b5, b6 being Element of the carrier of b1
for b7, b8 being Element of the carrier of b2
st b3 = [b5,b7] & b4 = [b6,b8]
holds b3 <= b4
iff
b6 <= b5 & b7 <= b8;
:: PCS_0:th 40
theorem
for b1, b2 being pcs-Str
for b3, b4 being Element of the carrier of b1 --> b2
for b5, b6 being Element of the carrier of b1
for b7, b8 being Element of the carrier of b2
st b3 = [b5,b7] & b4 = [b6,b8] & b3 (--) b4 & b5 (--) b6
holds b7 (--) b8;
:: PCS_0:th 41
theorem
for b1, b2 being non empty pcs-Str
for b3, b4 being Element of the carrier of b1 --> b2
for b5, b6 being Element of the carrier of b1
for b7, b8 being Element of the carrier of b2
st b3 = [b5,b7] & b4 = [b6,b8] & (b5 (--) b6 implies b7 (--) b8)
holds b3 (--) b4;
:: PCS_0:funcreg 77
registration
let a1, a2 be reflexive pcs-Str;
cluster a1 --> a2 -> reflexive;
end;
:: PCS_0:funcreg 78
registration
let a1, a2 be transitive pcs-Str;
cluster a1 --> a2 -> transitive;
end;
:: PCS_0:funcreg 79
registration
let a1 be pcs-Str;
let a2 be pcs-tol-reflexive pcs-Str;
cluster a1 --> a2 -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 80
registration
let a1 be pcs-tol-irreflexive pcs-Str;
let a2 be pcs-Str;
cluster a1 --> a2 -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 81
registration
let a1, a2 be pcs-tol-symmetric pcs-Str;
cluster a1 --> a2 -> pcs-tol-symmetric;
end;
:: PCS_0:funcreg 82
registration
let a1, a2 be pcs-compatible pcs-Str;
cluster a1 --> a2 -> pcs-compatible;
end;
:: PCS_0:funcreg 83
registration
let a1, a2 be pcs-like pcs-Str;
cluster a1 --> a2 -> pcs-like;
end;
:: PCS_0:attrnot 24 => PCS_0:attr 21
definition
let a1 be TolStr;
let a2 be Element of bool the carrier of a1;
attr a2 is pcs-self-coherent means
for b1, b2 being Element of the carrier of a1
st b1 in a2 & b2 in a2
holds b1 (--) b2;
end;
:: PCS_0:dfs 43
definiens
let a1 be TolStr;
let a2 be Element of bool the carrier of a1;
To prove
a2 is pcs-self-coherent
it is sufficient to prove
thus for b1, b2 being Element of the carrier of a1
st b1 in a2 & b2 in a2
holds b1 (--) b2;
:: PCS_0:def 43
theorem
for b1 being TolStr
for b2 being Element of bool the carrier of b1 holds
b2 is pcs-self-coherent(b1)
iff
for b3, b4 being Element of the carrier of b1
st b3 in b2 & b4 in b2
holds b3 (--) b4;
:: PCS_0:condreg 14
registration
let a1 be TolStr;
cluster empty -> pcs-self-coherent (Element of bool the carrier of a1);
end;
:: PCS_0:exreg 16
registration
let a1 be TolStr;
cluster empty Element of bool the carrier of a1;
end;
:: PCS_0:attrnot 25 => PCS_0:attr 22
definition
let a1 be TolStr;
let a2 be Element of bool bool the carrier of a1;
attr a2 is pcs-self-coherent-membered means
for b1 being Element of bool the carrier of a1
st b1 in a2
holds b1 is pcs-self-coherent(a1);
end;
:: PCS_0:dfs 44
definiens
let a1 be TolStr;
let a2 be Element of bool bool the carrier of a1;
To prove
a2 is pcs-self-coherent-membered
it is sufficient to prove
thus for b1 being Element of bool the carrier of a1
st b1 in a2
holds b1 is pcs-self-coherent(a1);
:: PCS_0:def 44
theorem
for b1 being TolStr
for b2 being Element of bool bool the carrier of b1 holds
b2 is pcs-self-coherent-membered(b1)
iff
for b3 being Element of bool the carrier of b1
st b3 in b2
holds b3 is pcs-self-coherent(b1);
:: PCS_0:exreg 17
registration
let a1 be TolStr;
cluster non empty pcs-self-coherent-membered Element of bool bool the carrier of a1;
end;
:: PCS_0:funcnot 31 => PCS_0:func 24
definition
let a1 be RelStr;
let a2 be set;
func pcs-general-power-IR(A1,A2) -> Relation of a2,a2 means
for b1, b2 being set holds
[b1,b2] in it
iff
b1 in a2 &
b2 in a2 &
(for b3 being set
st b3 in b1
holds ex b4 being set st
b4 in b2 & [b3,b4] in the InternalRel of a1);
end;
:: PCS_0:def 45
theorem
for b1 being RelStr
for b2 being set
for b3 being Relation of b2,b2 holds
b3 = pcs-general-power-IR(b1,b2)
iff
for b4, b5 being set holds
[b4,b5] in b3
iff
b4 in b2 &
b5 in b2 &
(for b6 being set
st b6 in b4
holds ex b7 being set st
b7 in b5 & [b6,b7] in the InternalRel of b1);
:: PCS_0:funcnot 32 => PCS_0:func 25
definition
let a1 be TolStr;
let a2 be set;
func pcs-general-power-TR(A1,A2) -> Relation of a2,a2 means
for b1, b2 being set holds
[b1,b2] in it
iff
b1 in a2 &
b2 in a2 &
(for b3, b4 being set
st b3 in b1 & b4 in b2
holds [b3,b4] in the ToleranceRel of a1);
end;
:: PCS_0:def 46
theorem
for b1 being TolStr
for b2 being set
for b3 being Relation of b2,b2 holds
b3 = pcs-general-power-TR(b1,b2)
iff
for b4, b5 being set holds
[b4,b5] in b3
iff
b4 in b2 &
b5 in b2 &
(for b6, b7 being set
st b6 in b4 & b7 in b5
holds [b6,b7] in the ToleranceRel of b1);
:: PCS_0:th 42
theorem
for b1 being RelStr
for b2 being Element of bool bool the carrier of b1
for b3, b4 being set holds
[b3,b4] in pcs-general-power-IR(b1,b2)
iff
b3 in b2 &
b4 in b2 &
(for b5 being Element of the carrier of b1
st b5 in b3
holds ex b6 being Element of the carrier of b1 st
b6 in b4 & b5 <= b6);
:: PCS_0:th 43
theorem
for b1 being TolStr
for b2 being Element of bool bool the carrier of b1
for b3, b4 being set holds
[b3,b4] in pcs-general-power-TR(b1,b2)
iff
b3 in b2 &
b4 in b2 &
(for b5, b6 being Element of the carrier of b1
st b5 in b3 & b6 in b4
holds b5 (--) b6);
:: PCS_0:funcnot 33 => PCS_0:func 26
definition
let a1 be pcs-Str;
let a2 be set;
func pcs-general-power(A1,A2) -> pcs-Str equals
pcs-Str(#a2,pcs-general-power-IR(a1,a2),pcs-general-power-TR(a1,a2)#);
end;
:: PCS_0:def 47
theorem
for b1 being pcs-Str
for b2 being set holds
pcs-general-power(b1,b2) = pcs-Str(#b2,pcs-general-power-IR(b1,b2),pcs-general-power-TR(b1,b2)#);
:: PCS_0:funcnot 34 => PCS_0:func 26
notation
let a1 be pcs-Str;
let a2 be Element of bool bool the carrier of a1;
synonym pcs-general-power a2 for pcs-general-power(a1,a2);
end;
:: PCS_0:funcreg 84
registration
let a1 be pcs-Str;
let a2 be non empty set;
cluster pcs-general-power(a1,a2) -> non empty;
end;
:: PCS_0:th 44
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of pcs-general-power(b1,b2)
st b3 <= b4
for b5 being Element of the carrier of b1
st b5 in b3
holds ex b6 being Element of the carrier of b1 st
b6 in b4 & b5 <= b6;
:: PCS_0:th 45
theorem
for b1 being pcs-Str
for b2 being non empty Element of bool bool the carrier of b1
for b3, b4 being Element of the carrier of pcs-general-power(b1,b2)
st for b5 being Element of the carrier of b1
st b5 in b3
holds ex b6 being Element of the carrier of b1 st
b6 in b4 & b5 <= b6
holds b3 <= b4;
:: PCS_0:th 46
theorem
for b1 being pcs-Str
for b2 being set
for b3, b4 being Element of the carrier of pcs-general-power(b1,b2)
st b3 (--) b4
for b5, b6 being Element of the carrier of b1
st b5 in b3 & b6 in b4
holds b5 (--) b6;
:: PCS_0:th 47
theorem
for b1 being pcs-Str
for b2 being non empty Element of bool bool the carrier of b1
for b3, b4 being Element of the carrier of pcs-general-power(b1,b2)
st for b5, b6 being Element of the carrier of b1
st b5 in b3 & b6 in b4
holds b5 (--) b6
holds b3 (--) b4;
:: PCS_0:funcreg 85
registration
let a1 be pcs-Str;
let a2 be set;
cluster pcs-general-power(a1,a2) -> strict;
end;
:: PCS_0:funcreg 86
registration
let a1 be reflexive pcs-Str;
let a2 be Element of bool bool the carrier of a1;
cluster pcs-general-power(a1,a2) -> reflexive;
end;
:: PCS_0:funcreg 87
registration
let a1 be transitive pcs-Str;
let a2 be set;
cluster pcs-general-power(a1,a2) -> transitive;
end;
:: PCS_0:funcreg 88
registration
let a1 be pcs-tol-reflexive pcs-Str;
let a2 be pcs-self-coherent-membered Element of bool bool the carrier of a1;
cluster pcs-general-power(a1,a2) -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 89
registration
let a1 be pcs-tol-symmetric pcs-Str;
let a2 be Element of bool bool the carrier of a1;
cluster pcs-general-power(a1,a2) -> pcs-tol-symmetric;
end;
:: PCS_0:funcreg 90
registration
let a1 be pcs-compatible pcs-Str;
let a2 be Element of bool bool the carrier of a1;
cluster pcs-general-power(a1,a2) -> pcs-compatible;
end;
:: PCS_0:funcnot 35 => PCS_0:func 27
definition
let a1 be pcs-Str;
func pcs-coherent-power A1 -> set equals
{b1 where b1 is Element of bool the carrier of a1: b1 is pcs-self-coherent(a1)};
end;
:: PCS_0:def 48
theorem
for b1 being pcs-Str holds
pcs-coherent-power b1 = {b2 where b2 is Element of bool the carrier of b1: b2 is pcs-self-coherent(b1)};
:: PCS_0:th 48
theorem
for b1 being pcs-Str
for b2 being set
st b2 in pcs-coherent-power b1
holds b2 is pcs-self-coherent Element of bool the carrier of b1;
:: PCS_0:funcreg 91
registration
let a1 be pcs-Str;
cluster pcs-coherent-power a1 -> non empty;
end;
:: PCS_0:funcnot 36 => PCS_0:func 28
definition
let a1 be pcs-Str;
redefine func pcs-coherent-power a1 -> Element of bool bool the carrier of a1;
end;
:: PCS_0:funcreg 92
registration
let a1 be pcs-Str;
cluster pcs-coherent-power a1 -> pcs-self-coherent-membered;
end;
:: PCS_0:funcnot 37 => PCS_0:func 29
definition
let a1 be pcs-Str;
func pcs-power A1 -> pcs-Str equals
pcs-general-power(a1,pcs-coherent-power a1);
end;
:: PCS_0:def 49
theorem
for b1 being pcs-Str holds
pcs-power b1 = pcs-general-power(b1,pcs-coherent-power b1);
:: PCS_0:funcreg 93
registration
let a1 be pcs-Str;
cluster pcs-power a1 -> strict;
end;
:: PCS_0:funcreg 94
registration
let a1 be pcs-Str;
cluster pcs-power a1 -> non empty;
end;
:: PCS_0:funcreg 95
registration
let a1 be reflexive pcs-Str;
cluster pcs-power a1 -> reflexive;
end;
:: PCS_0:funcreg 96
registration
let a1 be transitive pcs-Str;
cluster pcs-power a1 -> transitive;
end;
:: PCS_0:funcreg 97
registration
let a1 be pcs-tol-reflexive pcs-Str;
cluster pcs-power a1 -> pcs-tol-reflexive;
end;
:: PCS_0:funcreg 98
registration
let a1 be pcs-tol-symmetric pcs-Str;
cluster pcs-power a1 -> pcs-tol-symmetric;
end;
:: PCS_0:funcreg 99
registration
let a1 be pcs-compatible pcs-Str;
cluster pcs-power a1 -> pcs-compatible;
end;
:: PCS_0:funcreg 100
registration
let a1 be pcs-like pcs-Str;
cluster pcs-power a1 -> pcs-like;
end;