Article ROUGHS_1, MML version 4.99.1005

:: ROUGHS_1:funcreg 1
registration
  let a1 be set;
  cluster RelStr(#a1,id a1#) -> strict discrete;
end;

:: ROUGHS_1:th 1
theorem
for b1 being set
      st nabla b1 c= id b1
   holds b1 is trivial;

:: ROUGHS_1:attrnot 1 => ROUGHS_1:attr 1
definition
  let a1 be RelStr;
  attr a1 is diagonal means
    the InternalRel of a1 c= id the carrier of a1;
end;

:: ROUGHS_1:dfs 1
definiens
  let a1 be RelStr;
To prove
     a1 is diagonal
it is sufficient to prove
  thus the InternalRel of a1 c= id the carrier of a1;

:: ROUGHS_1:def 1
theorem
for b1 being RelStr holds
      b1 is diagonal
   iff
      the InternalRel of b1 c= id the carrier of b1;

:: ROUGHS_1:funcreg 2
registration
  let a1 be non trivial set;
  cluster RelStr(#a1,nabla a1#) -> strict non diagonal;
end;

:: ROUGHS_1:th 2
theorem
for b1 being reflexive RelStr holds
   id the carrier of b1 c= the InternalRel of b1;

:: ROUGHS_1:condreg 1
registration
  cluster reflexive non discrete -> non trivial (RelStr);
end;

:: ROUGHS_1:condreg 2
registration
  cluster trivial reflexive -> discrete (RelStr);
end;

:: ROUGHS_1:th 3
theorem
for b1 being set
for b2 being reflexive total Relation of b1,b1 holds
   id b1 c= b2;

:: ROUGHS_1:condreg 3
registration
  cluster discrete -> diagonal (RelStr);
end;

:: ROUGHS_1:condreg 4
registration
  cluster non diagonal -> non discrete (RelStr);
end;

:: ROUGHS_1:exreg 1
registration
  cluster non empty non diagonal RelStr;
end;

:: ROUGHS_1:th 4
theorem
for b1 being non empty non diagonal RelStr holds
   ex b2, b3 being Element of the carrier of b1 st
      b2 <> b3 & [b2,b3] in the InternalRel of b1;

:: ROUGHS_1:th 5
theorem
for b1 being set
for b2, b3 being FinSequence of b1 holds
Union (b2 ^ b3) = (Union b2) \/ Union b3;

:: ROUGHS_1:th 6
theorem
for b1, b2 being Relation-like Function-like set
      st b2 is disjoint_valued & b1 c= b2
   holds b1 is disjoint_valued;

:: ROUGHS_1:condreg 5
registration
  cluster Relation-like Function-like empty -> disjoint_valued (set);
end;

:: ROUGHS_1:exreg 2
registration
  let a1 be set;
  cluster Relation-like Function-like finite disjoint_valued FinSequence-like FinSequence of a1;
end;

:: ROUGHS_1:exreg 3
registration
  let a1 be non empty set;
  cluster Relation-like Function-like non empty finite disjoint_valued FinSequence-like FinSequence of a1;
end;

:: ROUGHS_1:funcnot 1 => ROUGHS_1:func 1
definition
  let a1 be set;
  let a2 be FinSequence of bool a1;
  let a3 be natural set;
  redefine func a2 . a3 -> Element of bool a1;
end;

:: ROUGHS_1:funcnot 2 => ROUGHS_1:func 2
definition
  let a1 be set;
  let a2 be FinSequence of bool a1;
  redefine func Union a2 -> Element of bool a1;
end;

:: ROUGHS_1:funcreg 3
registration
  let a1 be finite set;
  let a2 be Relation of a1,a1;
  cluster RelStr(#a1,a2#) -> finite strict;
end;

:: ROUGHS_1:th 7
theorem
for b1, b2, b3 being set
for b4 being reflexive symmetric total Relation of b1,b1
      st b2 in Class(b4,b3)
   holds b3 in Class(b4,b2);

:: ROUGHS_1:attrnot 2 => ROUGHS_1:attr 2
definition
  let a1 be RelStr;
  attr a1 is with_equivalence means
    the InternalRel of a1 is symmetric transitive total Relation of the carrier of a1,the carrier of a1;
end;

:: ROUGHS_1:dfs 2
definiens
  let a1 be RelStr;
To prove
     a1 is with_equivalence
it is sufficient to prove
  thus the InternalRel of a1 is symmetric transitive total Relation of the carrier of a1,the carrier of a1;

:: ROUGHS_1:def 2
theorem
for b1 being RelStr holds
      b1 is with_equivalence
   iff
      the InternalRel of b1 is symmetric transitive total Relation of the carrier of b1,the carrier of b1;

:: ROUGHS_1:attrnot 3 => ROUGHS_1:attr 3
definition
  let a1 be RelStr;
  attr a1 is with_tolerance means
    the InternalRel of a1 is reflexive symmetric total Relation of the carrier of a1,the carrier of a1;
end;

:: ROUGHS_1:dfs 3
definiens
  let a1 be RelStr;
To prove
     a1 is with_tolerance
it is sufficient to prove
  thus the InternalRel of a1 is reflexive symmetric total Relation of the carrier of a1,the carrier of a1;

:: ROUGHS_1:def 3
theorem
for b1 being RelStr holds
      b1 is with_tolerance
   iff
      the InternalRel of b1 is reflexive symmetric total Relation of the carrier of b1,the carrier of b1;

:: ROUGHS_1:condreg 6
registration
  cluster with_equivalence -> with_tolerance (RelStr);
end;

:: ROUGHS_1:funcreg 4
registration
  let a1 be set;
  cluster RelStr(#a1,id a1#) -> strict with_equivalence;
end;

:: ROUGHS_1:exreg 4
registration
  cluster non empty finite discrete with_equivalence RelStr;
end;

:: ROUGHS_1:exreg 5
registration
  cluster non empty finite non diagonal with_equivalence RelStr;
end;

:: ROUGHS_1:modenot 1
definition
  mode Approximation_Space is non empty with_equivalence RelStr;
end;

:: ROUGHS_1:modenot 2
definition
  mode Tolerance_Space is non empty with_tolerance RelStr;
end;

:: ROUGHS_1:funcreg 5
registration
  let a1 be non empty with_tolerance RelStr;
  cluster the InternalRel of a1 -> reflexive symmetric total;
end;

:: ROUGHS_1:funcreg 6
registration
  let a1 be non empty with_equivalence RelStr;
  cluster the InternalRel of a1 -> transitive;
end;

:: ROUGHS_1:funcnot 3 => ROUGHS_1:func 3
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func LAp A2 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: Class(the InternalRel of a1,b1) c= a2};
end;

:: ROUGHS_1:def 4
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp b2 = {b3 where b3 is Element of the carrier of b1: Class(the InternalRel of b1,b3) c= b2};

:: ROUGHS_1:funcnot 4 => ROUGHS_1:func 4
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func UAp A2 -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: Class(the InternalRel of a1,b1) meets a2};
end;

:: ROUGHS_1:def 5
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   UAp b2 = {b3 where b3 is Element of the carrier of b1: Class(the InternalRel of b1,b3) meets b2};

:: ROUGHS_1:funcnot 5 => ROUGHS_1:func 5
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func BndAp A2 -> Element of bool the carrier of a1 equals
    (UAp a2) \ LAp a2;
end;

:: ROUGHS_1:def 6
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   BndAp b2 = (UAp b2) \ LAp b2;

:: ROUGHS_1:attrnot 4 => ROUGHS_1:attr 4
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is rough means
    BndAp a2 <> {};
end;

:: ROUGHS_1:dfs 7
definiens
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is rough
it is sufficient to prove
  thus BndAp a2 <> {};

:: ROUGHS_1:def 7
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is rough(b1)
   iff
      BndAp b2 <> {};

:: ROUGHS_1:attrnot 5 => ROUGHS_1:attr 4
notation
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  antonym exact for rough;
end;

:: ROUGHS_1:th 8
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being set
      st b3 in LAp b2
   holds Class(the InternalRel of b1,b3) c= b2;

:: ROUGHS_1:th 9
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st Class(the InternalRel of b1,b3) c= b2
   holds b3 in LAp b2;

:: ROUGHS_1:th 10
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being set
      st b3 in UAp b2
   holds Class(the InternalRel of b1,b3) meets b2;

:: ROUGHS_1:th 11
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1
      st Class(the InternalRel of b1,b3) meets b2
   holds b3 in UAp b2;

:: ROUGHS_1:th 12
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp b2 c= b2;

:: ROUGHS_1:th 13
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 c= UAp b2;

:: ROUGHS_1:th 14
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp b2 c= UAp b2;

:: ROUGHS_1:th 15
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is exact(b1)
   iff
      LAp b2 = b2;

:: ROUGHS_1:th 16
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is exact(b1)
   iff
      UAp b2 = b2;

:: ROUGHS_1:th 17
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 = LAp b2
   iff
      b2 = UAp b2;

:: ROUGHS_1:th 18
theorem
for b1 being non empty with_tolerance RelStr holds
   LAp {} b1 = {};

:: ROUGHS_1:th 19
theorem
for b1 being non empty with_tolerance RelStr holds
   UAp {} b1 = {};

:: ROUGHS_1:th 20
theorem
for b1 being non empty with_tolerance RelStr holds
   LAp [#] b1 = [#] b1;

:: ROUGHS_1:th 21
theorem
for b1 being non empty with_tolerance RelStr holds
   UAp [#] b1 = [#] b1;

:: ROUGHS_1:th 22
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
LAp (b2 /\ b3) = (LAp b2) /\ LAp b3;

:: ROUGHS_1:th 23
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
UAp (b2 \/ b3) = (UAp b2) \/ UAp b3;

:: ROUGHS_1:th 24
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds LAp b2 c= LAp b3;

:: ROUGHS_1:th 25
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds UAp b2 c= UAp b3;

:: ROUGHS_1:th 26
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
(LAp b2) \/ LAp b3 c= LAp (b2 \/ b3);

:: ROUGHS_1:th 27
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
UAp (b2 /\ b3) c= (UAp b2) /\ UAp b3;

:: ROUGHS_1:th 28
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp (b2 `) = (UAp b2) `;

:: ROUGHS_1:th 29
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   UAp (b2 `) = (LAp b2) `;

:: ROUGHS_1:th 30
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   UAp LAp UAp b2 = UAp b2;

:: ROUGHS_1:th 31
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp UAp LAp b2 = LAp b2;

:: ROUGHS_1:th 32
theorem
for b1 being non empty with_tolerance RelStr
for b2 being Element of bool the carrier of b1 holds
   BndAp b2 = BndAp (b2 `);

:: ROUGHS_1:th 33
theorem
for b1 being non empty with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp LAp b2 = LAp b2;

:: ROUGHS_1:th 34
theorem
for b1 being non empty with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp LAp b2 = UAp LAp b2;

:: ROUGHS_1:th 35
theorem
for b1 being non empty with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   UAp UAp b2 = UAp b2;

:: ROUGHS_1:th 36
theorem
for b1 being non empty with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   UAp UAp b2 = LAp UAp b2;

:: ROUGHS_1:exreg 6
registration
  let a1 be non empty with_tolerance RelStr;
  cluster exact Element of bool the carrier of a1;
end;

:: ROUGHS_1:funcreg 7
registration
  let a1 be non empty with_equivalence RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster LAp a2 -> exact;
end;

:: ROUGHS_1:funcreg 8
registration
  let a1 be non empty with_equivalence RelStr;
  let a2 be Element of bool the carrier of a1;
  cluster UAp a2 -> exact;
end;

:: ROUGHS_1:th 37
theorem
for b1 being non empty with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3, b4 being set
      st b3 in UAp b2 & [b3,b4] in the InternalRel of b1
   holds b4 in UAp b2;

:: ROUGHS_1:exreg 7
registration
  let a1 be non empty non diagonal with_equivalence RelStr;
  cluster rough Element of bool the carrier of a1;
end;

:: ROUGHS_1:modenot 3 => ROUGHS_1:mode 1
definition
  let a1 be non empty with_equivalence RelStr;
  let a2 be Element of bool the carrier of a1;
  mode RoughSet of A2 means
    it = [LAp a2,UAp a2];
end;

:: ROUGHS_1:dfs 8
definiens
  let a1 be non empty with_equivalence RelStr;
  let a2 be Element of bool the carrier of a1;
  let a3 be set;
To prove
     a3 is RoughSet of a2
it is sufficient to prove
  thus a3 = [LAp a2,UAp a2];

:: ROUGHS_1:def 8
theorem
for b1 being non empty with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3 being set holds
      b3 is RoughSet of b2
   iff
      b3 = [LAp b2,UAp b2];

:: ROUGHS_1:funcreg 9
registration
  let a1 be non empty finite with_tolerance RelStr;
  let a2 be Element of the carrier of a1;
  cluster Card Class(the InternalRel of a1,a2) -> non empty cardinal;
end;

:: ROUGHS_1:funcnot 6 => ROUGHS_1:func 6
definition
  let a1 be non empty finite with_tolerance RelStr;
  let a2 be Element of bool the carrier of a1;
  func MemberFunc(A2,A1) -> Function-like quasi_total Relation of the carrier of a1,REAL means
    for b1 being Element of the carrier of a1 holds
       it . b1 = (card (a2 /\ Class(the InternalRel of a1,b1))) / card Class(the InternalRel of a1,b1);
end;

:: ROUGHS_1:def 9
theorem
for b1 being non empty finite with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being Function-like quasi_total Relation of the carrier of b1,REAL holds
      b3 = MemberFunc(b2,b1)
   iff
      for b4 being Element of the carrier of b1 holds
         b3 . b4 = (card (b2 /\ Class(the InternalRel of b1,b4))) / card Class(the InternalRel of b1,b4);

:: ROUGHS_1:th 38
theorem
for b1 being non empty finite with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
   0 <= (MemberFunc(b2,b1)) . b3 & (MemberFunc(b2,b1)) . b3 <= 1;

:: ROUGHS_1:th 39
theorem
for b1 being non empty finite with_tolerance RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
   (MemberFunc(b2,b1)) . b3 in [.0,1.];

:: ROUGHS_1:th 40
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      (MemberFunc(b2,b1)) . b3 = 1
   iff
      b3 in LAp b2;

:: ROUGHS_1:th 41
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      (MemberFunc(b2,b1)) . b3 = 0
   iff
      b3 in (UAp b2) `;

:: ROUGHS_1:th 42
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
      0 < (MemberFunc(b2,b1)) . b3 & (MemberFunc(b2,b1)) . b3 < 1
   iff
      b3 in BndAp b2;

:: ROUGHS_1:th 43
theorem
for b1 being non empty discrete with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 is exact(b1);

:: ROUGHS_1:condreg 7
registration
  let a1 be non empty discrete with_equivalence RelStr;
  cluster -> exact (Element of bool the carrier of a1);
end;

:: ROUGHS_1:th 44
theorem
for b1 being non empty finite discrete with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   MemberFunc(b2,b1) = chi(b2,the carrier of b1);

:: ROUGHS_1:th 45
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3, b4 being set
      st [b3,b4] in the InternalRel of b1
   holds (MemberFunc(b2,b1)) . b3 = (MemberFunc(b2,b1)) . b4;

:: ROUGHS_1:th 46
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
   (MemberFunc(b2 `,b1)) . b3 = 1 - ((MemberFunc(b2,b1)) . b3);

:: ROUGHS_1:th 47
theorem
for b1 being non empty finite with_equivalence RelStr
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1
      st b2 c= b3
   holds (MemberFunc(b2,b1)) . b4 <= (MemberFunc(b3,b1)) . b4;

:: ROUGHS_1:th 48
theorem
for b1 being non empty finite with_equivalence RelStr
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1 holds
   (MemberFunc(b2,b1)) . b4 <= (MemberFunc(b2 \/ b3,b1)) . b4;

:: ROUGHS_1:th 49
theorem
for b1 being non empty finite with_equivalence RelStr
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1 holds
   (MemberFunc(b2 /\ b3,b1)) . b4 <= (MemberFunc(b2,b1)) . b4;

:: ROUGHS_1:th 50
theorem
for b1 being non empty finite with_equivalence RelStr
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1 holds
   max((MemberFunc(b2,b1)) . b4,(MemberFunc(b3,b1)) . b4) <= (MemberFunc(b2 \/ b3,b1)) . b4;

:: ROUGHS_1:th 51
theorem
for b1 being non empty finite with_equivalence RelStr
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1
      st b2 misses b3
   holds (MemberFunc(b2 \/ b3,b1)) . b4 = ((MemberFunc(b2,b1)) . b4) + ((MemberFunc(b3,b1)) . b4);

:: ROUGHS_1:th 52
theorem
for b1 being non empty finite with_equivalence RelStr
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of the carrier of b1 holds
   (MemberFunc(b2 /\ b3,b1)) . b4 <= min((MemberFunc(b2,b1)) . b4,(MemberFunc(b3,b1)) . b4);

:: ROUGHS_1:funcnot 7 => ROUGHS_1:func 7
definition
  let a1 be non empty finite with_tolerance RelStr;
  let a2 be FinSequence of bool the carrier of a1;
  let a3 be Element of the carrier of a1;
  func FinSeqM(A3,A2) -> FinSequence of REAL means
    dom it = dom a2 &
     (for b1 being natural set
           st b1 in dom a2
        holds it . b1 = (MemberFunc(a2 . b1,a1)) . a3);
end;

:: ROUGHS_1:def 10
theorem
for b1 being non empty finite with_tolerance RelStr
for b2 being FinSequence of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being FinSequence of REAL holds
      b4 = FinSeqM(b3,b2)
   iff
      dom b4 = dom b2 &
       (for b5 being natural set
             st b5 in dom b2
          holds b4 . b5 = (MemberFunc(b2 . b5,b1)) . b3);

:: ROUGHS_1:th 53
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being FinSequence of bool the carrier of b1
for b3 being Element of the carrier of b1
for b4 being Element of bool the carrier of b1 holds
   FinSeqM(b3,b2 ^ <*b4*>) = (FinSeqM(b3,b2)) ^ <*(MemberFunc(b4,b1)) . b3*>;

:: ROUGHS_1:th 54
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of the carrier of b1 holds
   (MemberFunc({} b1,b1)) . b2 = 0;

:: ROUGHS_1:th 55
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of the carrier of b1
for b3 being disjoint_valued FinSequence of bool the carrier of b1 holds
   (MemberFunc(Union b3,b1)) . b2 = Sum FinSeqM(b2,b3);

:: ROUGHS_1:th 56
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   LAp b2 = {b3 where b3 is Element of the carrier of b1: (MemberFunc(b2,b1)) . b3 = 1};

:: ROUGHS_1:th 57
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   UAp b2 = {b3 where b3 is Element of the carrier of b1: 0 < (MemberFunc(b2,b1)) . b3};

:: ROUGHS_1:th 58
theorem
for b1 being non empty finite with_equivalence RelStr
for b2 being Element of bool the carrier of b1 holds
   BndAp b2 = {b3 where b3 is Element of the carrier of b1: 0 < (MemberFunc(b2,b1)) . b3 & (MemberFunc(b2,b1)) . b3 < 1};

:: ROUGHS_1:prednot 1 => ROUGHS_1:pred 1
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 _c= A3 means
    LAp a2 c= LAp a3;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 _c= a2;
end;

:: ROUGHS_1:dfs 11
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 _c= a3
it is sufficient to prove
  thus LAp a2 c= LAp a3;

:: ROUGHS_1:def 11
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 _c= b3
iff
   LAp b2 c= LAp b3;

:: ROUGHS_1:prednot 2 => ROUGHS_1:pred 2
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 c=^ A3 means
    UAp a2 c= UAp a3;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 c=^ a2;
end;

:: ROUGHS_1:dfs 12
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 c=^ a3
it is sufficient to prove
  thus UAp a2 c= UAp a3;

:: ROUGHS_1:def 12
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 c=^ b3
iff
   UAp b2 c= UAp b3;

:: ROUGHS_1:prednot 3 => ROUGHS_1:pred 3
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 _c=^ A3 means
    a2 _c= a3 & a2 c=^ a3;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 _c=^ a2;
end;

:: ROUGHS_1:dfs 13
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 _c=^ a3
it is sufficient to prove
  thus a2 _c= a3 & a2 c=^ a3;

:: ROUGHS_1:def 13
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 _c=^ b3
iff
   b2 _c= b3 & b2 c=^ b3;

:: ROUGHS_1:th 59
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3, b4 being Element of bool the carrier of b1
      st b2 _c= b3 & b3 _c= b4
   holds b2 _c= b4;

:: ROUGHS_1:th 60
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3, b4 being Element of bool the carrier of b1
      st b2 c=^ b3 & b3 c=^ b4
   holds b2 c=^ b4;

:: ROUGHS_1:th 61
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3, b4 being Element of bool the carrier of b1
      st b2 _c=^ b3 & b3 _c=^ b4
   holds b2 _c=^ b4;

:: ROUGHS_1:prednot 4 => ROUGHS_1:pred 4
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 _= A3 means
    LAp a2 = LAp a3;
  symmetry;
::  for a1 being non empty with_tolerance RelStr
::  for a2, a3 being Element of bool the carrier of a1
::        st a2 _= a3
::     holds a3 _= a2;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 _= a2;
end;

:: ROUGHS_1:dfs 14
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 _= a3
it is sufficient to prove
  thus LAp a2 = LAp a3;

:: ROUGHS_1:def 14
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 _= b3
iff
   LAp b2 = LAp b3;

:: ROUGHS_1:prednot 5 => ROUGHS_1:pred 5
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 =^ A3 means
    UAp a2 = UAp a3;
  symmetry;
::  for a1 being non empty with_tolerance RelStr
::  for a2, a3 being Element of bool the carrier of a1
::        st a2 =^ a3
::     holds a3 =^ a2;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 =^ a2;
end;

:: ROUGHS_1:dfs 15
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 =^ a3
it is sufficient to prove
  thus UAp a2 = UAp a3;

:: ROUGHS_1:def 15
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 =^ b3
iff
   UAp b2 = UAp b3;

:: ROUGHS_1:prednot 6 => ROUGHS_1:pred 6
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 _=^ A3 means
    LAp a2 = LAp a3 & UAp a2 = UAp a3;
  symmetry;
::  for a1 being non empty with_tolerance RelStr
::  for a2, a3 being Element of bool the carrier of a1
::        st a2 _=^ a3
::     holds a3 _=^ a2;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 _=^ a2;
end;

:: ROUGHS_1:dfs 16
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 _=^ a3
it is sufficient to prove
  thus LAp a2 = LAp a3 & UAp a2 = UAp a3;

:: ROUGHS_1:def 16
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 _=^ b3
iff
   LAp b2 = LAp b3 & UAp b2 = UAp b3;

:: ROUGHS_1:prednot 7 => ROUGHS_1:pred 4
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 _= A3 means
    a2 _c= a3 & a3 _c= a2;
  symmetry;
::  for a1 being non empty with_tolerance RelStr
::  for a2, a3 being Element of bool the carrier of a1
::        st a2 _= a3
::     holds a3 _= a2;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 _= a2;
end;

:: ROUGHS_1:dfs 17
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 _= a3
it is sufficient to prove
  thus a2 _c= a3 & a3 _c= a2;

:: ROUGHS_1:def 17
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 _= b3
iff
   b2 _c= b3 & b3 _c= b2;

:: ROUGHS_1:prednot 8 => ROUGHS_1:pred 5
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 =^ A3 means
    a2 c=^ a3 & a3 c=^ a2;
  symmetry;
::  for a1 being non empty with_tolerance RelStr
::  for a2, a3 being Element of bool the carrier of a1
::        st a2 =^ a3
::     holds a3 =^ a2;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 =^ a2;
end;

:: ROUGHS_1:dfs 18
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 =^ a3
it is sufficient to prove
  thus a2 c=^ a3 & a3 c=^ a2;

:: ROUGHS_1:def 18
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 =^ b3
iff
   b2 c=^ b3 & b3 c=^ b2;

:: ROUGHS_1:prednot 9 => ROUGHS_1:pred 6
definition
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
  pred A2 _=^ A3 means
    a2 _= a3 & a2 =^ a3;
  symmetry;
::  for a1 being non empty with_tolerance RelStr
::  for a2, a3 being Element of bool the carrier of a1
::        st a2 _=^ a3
::     holds a3 _=^ a2;
  reflexivity;
::  for a1 being non empty with_tolerance RelStr
::  for a2 being Element of bool the carrier of a1 holds
::     a2 _=^ a2;
end;

:: ROUGHS_1:dfs 19
definiens
  let a1 be non empty with_tolerance RelStr;
  let a2, a3 be Element of bool the carrier of a1;
To prove
     a2 _=^ a3
it is sufficient to prove
  thus a2 _= a3 & a2 =^ a3;

:: ROUGHS_1:def 19
theorem
for b1 being non empty with_tolerance RelStr
for b2, b3 being Element of bool the carrier of b1 holds
   b2 _=^ b3
iff
   b2 _= b3 & b2 =^ b3;