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(RelStrTolStr) 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;