Article RCOMP_3, MML version 4.99.1005

:: RCOMP_3:funcreg 1
registration
  let a1 be non empty set;
  cluster [#] a1 -> non empty;
end;

:: RCOMP_3:condreg 1
registration
  cluster -> real-membered (SubSpace of RealSpace);
end;

:: RCOMP_3:exreg 1
registration
  cluster non empty finite complex-membered ext-real-membered real-membered bounded_above bounded_below set;
end;

:: RCOMP_3:th 1
theorem
for b1 being non empty real-membered bounded_below set
for b2 being closed Element of bool REAL
      st b1 c= b2
   holds lower_bound b1 in b2;

:: RCOMP_3:th 2
theorem
for b1 being non empty real-membered bounded_above set
for b2 being closed Element of bool REAL
      st b1 c= b2
   holds upper_bound b1 in b2;

:: RCOMP_3:th 3
theorem
for b1, b2 being Element of bool REAL holds
Cl (b1 \/ b2) = (Cl b1) \/ Cl b2;

:: RCOMP_3:funcreg 2
registration
  let a1, a2 be real set;
  cluster [.a1,a2.[ -> bounded;
end;

:: RCOMP_3:funcreg 3
registration
  let a1, a2 be real set;
  cluster ].a1,a2.] -> bounded;
end;

:: RCOMP_3:funcreg 4
registration
  let a1, a2 be real set;
  cluster ].a1,a2.[ -> bounded;
end;

:: RCOMP_3:funcreg 5
registration
  let a1, a2 be real set;
  cluster [.a1,a2.] -> connected;
end;

:: RCOMP_3:funcreg 6
registration
  let a1, a2 be real set;
  cluster [.a1,a2.[ -> connected;
end;

:: RCOMP_3:funcreg 7
registration
  let a1, a2 be real set;
  cluster ].a1,a2.] -> connected;
end;

:: RCOMP_3:funcreg 8
registration
  let a1, a2 be real set;
  cluster ].a1,a2.[ -> connected;
end;

:: RCOMP_3:exreg 2
registration
  cluster non empty complex-membered ext-real-membered real-membered bounded connected open Element of bool REAL;
end;

:: RCOMP_3:th 4
theorem
for b1, b2 being real set
      st b1 < b2
   holds inf [.b1,b2.[ = b1;

:: RCOMP_3:th 5
theorem
for b1, b2 being real set
      st b1 < b2
   holds sup [.b1,b2.[ = b2;

:: RCOMP_3:th 6
theorem
for b1, b2 being real set
      st b1 < b2
   holds inf ].b1,b2.] = b1;

:: RCOMP_3:th 7
theorem
for b1, b2 being real set
      st b1 < b2
   holds sup ].b1,b2.] = b2;

:: RCOMP_3:th 8
theorem
for b1, b2, b3, b4 being real set
      st b1 <= b2 & [.b1,b2.] = [.b3,b4.]
   holds b1 = b3 & b2 = b4;

:: RCOMP_3:th 9
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & ].b1,b2.[ = ].b3,b4.[
   holds b1 = b3 & b2 = b4;

:: RCOMP_3:th 10
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & ].b1,b2.] = ].b3,b4.]
   holds b1 = b3 & b2 = b4;

:: RCOMP_3:th 11
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & [.b1,b2.[ = [.b3,b4.[
   holds b1 = b3 & b2 = b4;

:: RCOMP_3:th 12
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & [.b1,b2.[ c= [.b3,b4.]
   holds b3 <= b1 & b2 <= b4;

:: RCOMP_3:th 13
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & [.b1,b2.[ c= [.b3,b4.[
   holds b3 <= b1 & b2 <= b4;

:: RCOMP_3:th 14
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & ].b1,b2.] c= [.b3,b4.]
   holds b3 <= b1 & b2 <= b4;

:: RCOMP_3:th 15
theorem
for b1, b2, b3, b4 being real set
      st b1 < b2 & ].b1,b2.] c= ].b3,b4.]
   holds b3 <= b1 & b2 <= b4;

:: RCOMP_3:th 16
theorem
for b1, b2 being real set holds
[.b1,b2.] ` = (halfline b1) \/ right_open_halfline b2;

:: RCOMP_3:th 17
theorem
for b1, b2 being real set holds
].b1,b2.[ ` = (left_closed_halfline b1) \/ right_closed_halfline b2;

:: RCOMP_3:th 18
theorem
for b1, b2 being real set holds
[.b1,b2.[ ` = (halfline b1) \/ right_closed_halfline b2;

:: RCOMP_3:th 19
theorem
for b1, b2 being real set holds
].b1,b2.] ` = (left_closed_halfline b1) \/ right_open_halfline b2;

:: RCOMP_3:th 20
theorem
for b1, b2 being real set
      st b1 <= b2
   holds [.b1,b2.] /\ ((left_closed_halfline b1) \/ right_closed_halfline b2) = {b1,b2};

:: RCOMP_3:funcreg 9
registration
  let a1 be real set;
  cluster left_closed_halfline a1 -> bounded_above non bounded_below connected;
end;

:: RCOMP_3:funcreg 10
registration
  let a1 be real set;
  cluster halfline a1 -> bounded_above non bounded_below connected;
end;

:: RCOMP_3:funcreg 11
registration
  let a1 be real set;
  cluster right_closed_halfline a1 -> non bounded_above bounded_below connected;
end;

:: RCOMP_3:funcreg 12
registration
  let a1 be real set;
  cluster right_open_halfline a1 -> non bounded_above bounded_below connected;
end;

:: RCOMP_3:th 21
theorem
for b1 being real set holds
   sup left_closed_halfline b1 = b1;

:: RCOMP_3:th 22
theorem
for b1 being real set holds
   sup halfline b1 = b1;

:: RCOMP_3:th 23
theorem
for b1 being real set holds
   inf right_closed_halfline b1 = b1;

:: RCOMP_3:th 24
theorem
for b1 being real set holds
   inf right_open_halfline b1 = b1;

:: RCOMP_3:funcreg 13
registration
  cluster [#] REAL -> non bounded_above non bounded_below connected;
end;

:: RCOMP_3:th 25
theorem
for b1 being bounded connected Element of bool REAL
      st inf b1 in b1 & sup b1 in b1
   holds b1 = [.inf b1,sup b1.];

:: RCOMP_3:th 26
theorem
for b1 being bounded Element of bool REAL
      st not inf b1 in b1
   holds b1 c= ].inf b1,sup b1.];

:: RCOMP_3:th 27
theorem
for b1 being bounded connected Element of bool REAL
      st not inf b1 in b1 & sup b1 in b1
   holds b1 = ].inf b1,sup b1.];

:: RCOMP_3:th 28
theorem
for b1 being bounded Element of bool REAL
      st not sup b1 in b1
   holds b1 c= [.inf b1,sup b1.[;

:: RCOMP_3:th 29
theorem
for b1 being bounded connected Element of bool REAL
      st inf b1 in b1 & not sup b1 in b1
   holds b1 = [.inf b1,sup b1.[;

:: RCOMP_3:th 30
theorem
for b1 being bounded Element of bool REAL
      st not inf b1 in b1 & not sup b1 in b1
   holds b1 c= ].inf b1,sup b1.[;

:: RCOMP_3:th 31
theorem
for b1 being non empty bounded connected Element of bool REAL
      st not inf b1 in b1 & not sup b1 in b1
   holds b1 = ].inf b1,sup b1.[;

:: RCOMP_3:th 32
theorem
for b1 being Element of bool REAL
      st b1 is bounded_above
   holds b1 c= left_closed_halfline sup b1;

:: RCOMP_3:th 33
theorem
for b1 being connected Element of bool REAL
      st b1 is not bounded_below & b1 is bounded_above & sup b1 in b1
   holds b1 = left_closed_halfline sup b1;

:: RCOMP_3:th 34
theorem
for b1 being Element of bool REAL
      st b1 is bounded_above & not sup b1 in b1
   holds b1 c= halfline sup b1;

:: RCOMP_3:th 35
theorem
for b1 being non empty connected Element of bool REAL
      st b1 is not bounded_below & b1 is bounded_above & not sup b1 in b1
   holds b1 = halfline sup b1;

:: RCOMP_3:th 36
theorem
for b1 being Element of bool REAL
      st b1 is bounded_below
   holds b1 c= right_closed_halfline inf b1;

:: RCOMP_3:th 37
theorem
for b1 being connected Element of bool REAL
      st b1 is bounded_below & b1 is not bounded_above & inf b1 in b1
   holds b1 = right_closed_halfline inf b1;

:: RCOMP_3:th 38
theorem
for b1 being Element of bool REAL
      st b1 is bounded_below & not inf b1 in b1
   holds b1 c= right_open_halfline inf b1;

:: RCOMP_3:th 39
theorem
for b1 being non empty connected Element of bool REAL
      st b1 is bounded_below & b1 is not bounded_above & not inf b1 in b1
   holds b1 = right_open_halfline inf b1;

:: RCOMP_3:th 40
theorem
for b1 being connected Element of bool REAL
      st b1 is not bounded_above & b1 is not bounded_below
   holds b1 = REAL;

:: RCOMP_3:th 41
theorem
for b1 being connected Element of bool REAL
      st b1 is not empty &
         b1 <> REAL &
         (for b2 being real set holds
            b1 <> left_closed_halfline b2) &
         (for b2 being real set holds
            b1 <> halfline b2) &
         (for b2 being real set holds
            b1 <> right_closed_halfline b2) &
         (for b2 being real set holds
            b1 <> right_open_halfline b2) &
         (for b2, b3 being real set
               st b2 <= b3
            holds b1 <> [.b2,b3.]) &
         (for b2, b3 being real set
               st b2 < b3
            holds b1 <> [.b2,b3.[) &
         (for b2, b3 being real set
               st b2 < b3
            holds b1 <> ].b2,b3.])
   holds ex b2, b3 being real set st
      b2 < b3 & b1 = ].b2,b3.[;

:: RCOMP_3:th 42
theorem
for b1 being real set
for b2 being non empty connected Element of bool REAL
      st not b1 in b2 & inf b2 < b1
   holds sup b2 <= b1;

:: RCOMP_3:th 43
theorem
for b1, b2 being non empty bounded connected Element of bool REAL
      st inf b1 <= inf b2 &
         sup b2 <= sup b1 &
         (inf b1 = inf b2 & inf b2 in b2 implies inf b1 in b1) &
         (sup b1 = sup b2 & sup b2 in b2 implies sup b1 in b1)
   holds b2 c= b1;

:: RCOMP_3:exreg 3
registration
  cluster non empty complex-membered ext-real-membered real-membered non bounded connected closed open Element of bool REAL;
end;

:: RCOMP_3:th 44
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b1 <= b2 & b3 = [.b1,b2.]
   holds Fr b3 = {b1,b2};

:: RCOMP_3:th 45
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b1 < b2 & b3 = ].b1,b2.[
   holds Fr b3 = {b1,b2};

:: RCOMP_3:th 46
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b1 < b2 & b3 = [.b1,b2.[
   holds Fr b3 = {b1,b2};

:: RCOMP_3:th 47
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b1 < b2 & b3 = ].b1,b2.]
   holds Fr b3 = {b1,b2};

:: RCOMP_3:th 48
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b3 = [.b1,b2.]
   holds Int b3 = ].b1,b2.[;

:: RCOMP_3:th 49
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b3 = ].b1,b2.[
   holds Int b3 = ].b1,b2.[;

:: RCOMP_3:th 50
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b3 = [.b1,b2.[
   holds Int b3 = ].b1,b2.[;

:: RCOMP_3:th 51
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of R^1
      st b3 = ].b1,b2.]
   holds Int b3 = ].b1,b2.[;

:: RCOMP_3:funcreg 14
registration
  let a1 be convex Element of bool the carrier of R^1;
  cluster R^1 | a1 -> strict convex;
end;

:: RCOMP_3:funcreg 15
registration
  let a1 be connected Element of bool REAL;
  cluster R^1 a1 -> convex;
end;

:: RCOMP_3:th 52
theorem
for b1 being Element of bool the carrier of R^1
for b2 being Element of bool REAL
      st b1 = b2
   holds    b1 is connected(R^1)
   iff
      b2 is connected;

:: RCOMP_3:funcreg 16
registration
  let a1 be real set;
  cluster Closed-Interval-TSpace(a1,a1) -> non empty trivial strict;
end;

:: RCOMP_3:th 53
theorem
for b1, b2 being real set
   st b1 <= b2
for b3 being Element of bool the carrier of Closed-Interval-TSpace(b1,b2) holds
   b3 is bounded Element of bool REAL;

:: RCOMP_3:th 54
theorem
for b1, b2, b3, b4 being real set
   st b1 <= b2
for b5 being Element of bool the carrier of Closed-Interval-TSpace(b1,b2)
      st b5 = [.b3,b4.[ & b1 < b3 & b4 <= b2
   holds Int b5 = ].b3,b4.[;

:: RCOMP_3:th 55
theorem
for b1, b2, b3, b4 being real set
   st b1 <= b2
for b5 being Element of bool the carrier of Closed-Interval-TSpace(b1,b2)
      st b5 = ].b3,b4.] & b1 <= b3 & b4 < b2
   holds Int b5 = ].b3,b4.[;

:: RCOMP_3:th 56
theorem
for b1, b2 being real set
for b3 being Element of bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being Element of bool REAL
      st b3 = b4
   holds    b3 is connected(Closed-Interval-TSpace(b1,b2))
   iff
      b4 is connected;

:: RCOMP_3:exreg 4
registration
  let a1 be TopSpace-like TopStruct;
  cluster open closed connected Element of bool the carrier of a1;
end;

:: RCOMP_3:exreg 5
registration
  let a1 be non empty TopSpace-like connected TopStruct;
  cluster non empty open closed connected Element of bool the carrier of a1;
end;

:: RCOMP_3:th 57
theorem
for b1, b2 being real set
   st b1 <= b2
for b3 being open connected Element of bool the carrier of Closed-Interval-TSpace(b1,b2)
      st b3 is not empty &
         b3 <> [.b1,b2.] &
         (for b4 being real set
               st b1 < b4 & b4 <= b2
            holds b3 <> [.b1,b4.[) &
         (for b4 being real set
               st b1 <= b4 & b4 < b2
            holds b3 <> ].b4,b2.])
   holds ex b4, b5 being real set st
      b1 <= b4 & b4 < b5 & b5 <= b2 & b3 = ].b4,b5.[;

:: RCOMP_3:th 58
theorem
for b1 being 1-sorted
for b2 being Element of bool bool the carrier of b1 holds
      b2 is_a_cover_of b1
   iff
      b2 is_a_cover_of [#] b1;

:: RCOMP_3:th 59
theorem
for b1 being 1-sorted
for b2 being finite Element of bool bool the carrier of b1
for b3 being Element of bool bool the carrier of b1
      st b2 is_a_cover_of b1 &
         b3 = b2 \ {b4 where b4 is Element of bool the carrier of b1: b4 in b2 &
          (ex b5 being Element of bool the carrier of b1 st
             b5 in b2 & b4 c< b5)}
   holds b3 is_a_cover_of b1;

:: RCOMP_3:th 60
theorem
for b1 being non empty trivial 1-sorted
for b2 being Element of the carrier of b1
for b3 being Element of bool bool the carrier of b1
      st b3 is_a_cover_of b1
   holds {b2} in b3;

:: RCOMP_3:attrnot 1 => RCOMP_3:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
  attr a2 is connected means
    for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds b1 is connected(a1);
end;

:: RCOMP_3:dfs 1
definiens
  let a1 be TopStruct;
  let a2 be Element of bool bool the carrier of a1;
To prove
     a2 is connected
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1
          st b1 in a2
       holds b1 is connected(a1);

:: RCOMP_3:def 1
theorem
for b1 being TopStruct
for b2 being Element of bool bool the carrier of b1 holds
      b2 is connected(b1)
   iff
      for b3 being Element of bool the carrier of b1
            st b3 in b2
         holds b3 is connected(b1);

:: RCOMP_3:exreg 6
registration
  let a1 be TopSpace-like TopStruct;
  cluster non empty open closed connected Element of bool bool the carrier of a1;
end;

:: RCOMP_3:th 61
theorem
for b1 being TopSpace-like TopStruct
for b2, b3 being Element of bool bool the carrier of b1
   st b2 is_a_cover_of b1 & b2 is finite
for b4 being set
      st b3 = b2 \ {b5 where b5 is Element of bool the carrier of b1: b5 in b2 &
          (ex b6 being Element of bool the carrier of b1 st
             b6 in b2 & b5 c< b6)} &
         b4 = {b5 where b5 is Element of bool bool the carrier of b1: b5 is_a_cover_of b1 & b5 c= b3}
   holds b4 has_lower_Zorn_property_wrt RelIncl b4;

:: RCOMP_3:th 62
theorem
for b1 being TopSpace-like TopStruct
for b2, b3 being set
   st b3 = {b4 where b4 is Element of bool bool the carrier of b1: b4 is_a_cover_of b1 & b4 c= b2}
for b4 being set
   st b4 is_minimal_in RelIncl b3 & b4 in field RelIncl b3
for b5 being Element of bool the carrier of b1
   st b5 in b4
for b6, b7 being Element of bool the carrier of b1
      st b6 in b4 & b7 in b4 & b5 c= b6 \/ b7 & b5 <> b6
   holds b5 = b7;

:: RCOMP_3:modenot 1 => RCOMP_3:mode 1
definition
  let a1, a2 be real set;
  let a3 be Element of bool bool the carrier of Closed-Interval-TSpace(a1,a2);
  assume a3 is_a_cover_of Closed-Interval-TSpace(a1,a2) & a3 is open(Closed-Interval-TSpace(a1,a2)) & a3 is connected(Closed-Interval-TSpace(a1,a2)) & a1 <= a2;
  mode IntervalCover of A3 -> FinSequence of bool REAL means
    rng it c= a3 &
     union rng it = [.a1,a2.] &
     (for b1 being natural set
           st 1 <= b1
        holds (b1 <= len it implies it /. b1 is not empty) &
         (b1 + 1 <= len it implies inf (it /. b1) <= inf (it /. (b1 + 1)) &
          sup (it /. b1) <= sup (it /. (b1 + 1)) &
          inf (it /. (b1 + 1)) < sup (it /. b1)) &
         (b1 + 2 <= len it implies sup (it /. b1) <= inf (it /. (b1 + 2)))) &
     ([.a1,a2.] in a3 implies it = <*[.a1,a2.]*>) &
     ([.a1,a2.] in a3 or (ex b1 being real set st
         a1 < b1 & b1 <= a2 & it . 1 = [.a1,b1.[) &
      (ex b1 being real set st
         a1 <= b1 & b1 < a2 & it . len it = ].b1,a2.]) &
      (for b1 being natural set
            st 1 < b1 & b1 < len it
         holds ex b2, b3 being real set st
            a1 <= b2 & b2 < b3 & b3 <= a2 & it . b1 = ].b2,b3.[));
end;

:: RCOMP_3:dfs 2
definiens
  let a1, a2 be real set;
  let a3 be Element of bool bool the carrier of Closed-Interval-TSpace(a1,a2);
  let a4 be FinSequence of bool REAL;
To prove
     a4 is IntervalCover of a3
it is sufficient to prove
thus a3 is_a_cover_of Closed-Interval-TSpace(a1,a2) & a3 is open(Closed-Interval-TSpace(a1,a2)) & a3 is connected(Closed-Interval-TSpace(a1,a2)) & a1 <= a2;
  thus rng a4 c= a3 &
     union rng a4 = [.a1,a2.] &
     (for b1 being natural set
           st 1 <= b1
        holds (b1 <= len a4 implies a4 /. b1 is not empty) &
         (b1 + 1 <= len a4 implies inf (a4 /. b1) <= inf (a4 /. (b1 + 1)) &
          sup (a4 /. b1) <= sup (a4 /. (b1 + 1)) &
          inf (a4 /. (b1 + 1)) < sup (a4 /. b1)) &
         (b1 + 2 <= len a4 implies sup (a4 /. b1) <= inf (a4 /. (b1 + 2)))) &
     ([.a1,a2.] in a3 implies a4 = <*[.a1,a2.]*>) &
     ([.a1,a2.] in a3 or (ex b1 being real set st
         a1 < b1 & b1 <= a2 & a4 . 1 = [.a1,b1.[) &
      (ex b1 being real set st
         a1 <= b1 & b1 < a2 & a4 . len a4 = ].b1,a2.]) &
      (for b1 being natural set
            st 1 < b1 & b1 < len a4
         holds ex b2, b3 being real set st
            a1 <= b2 & b2 < b3 & b3 <= a2 & a4 . b1 = ].b2,b3.[));

:: RCOMP_3:def 2
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
   st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
for b4 being FinSequence of bool REAL holds
      b4 is IntervalCover of b3
   iff
      rng b4 c= b3 &
       union rng b4 = [.b1,b2.] &
       (for b5 being natural set
             st 1 <= b5
          holds (b5 <= len b4 implies b4 /. b5 is not empty) &
           (b5 + 1 <= len b4 implies inf (b4 /. b5) <= inf (b4 /. (b5 + 1)) &
            sup (b4 /. b5) <= sup (b4 /. (b5 + 1)) &
            inf (b4 /. (b5 + 1)) < sup (b4 /. b5)) &
           (b5 + 2 <= len b4 implies sup (b4 /. b5) <= inf (b4 /. (b5 + 2)))) &
       ([.b1,b2.] in b3 implies b4 = <*[.b1,b2.]*>) &
       ([.b1,b2.] in b3 or (ex b5 being real set st
           b1 < b5 & b5 <= b2 & b4 . 1 = [.b1,b5.[) &
        (ex b5 being real set st
           b1 <= b5 & b5 < b2 & b4 . len b4 = ].b5,b2.]) &
        (for b5 being natural set
              st 1 < b5 & b5 < len b4
           holds ex b6, b7 being real set st
              b1 <= b6 & b6 < b7 & b7 <= b2 & b4 . b5 = ].b6,b7.[));

:: RCOMP_3:th 63
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & [.b1,b2.] in b3
   holds <*[.b1,b2.]*> is IntervalCover of b3;

:: RCOMP_3:th 64
theorem
for b1 being real set
for b2 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b1)
for b3 being IntervalCover of b2
      st b2 is_a_cover_of Closed-Interval-TSpace(b1,b1) & b2 is open(Closed-Interval-TSpace(b1,b1)) & b2 is connected(Closed-Interval-TSpace(b1,b1))
   holds b3 = <*[.b1,b1.]*>;

:: RCOMP_3:th 65
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
   holds 1 <= len b4;

:: RCOMP_3:th 66
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & len b4 = 1
   holds b4 = <*[.b1,b2.]*>;

:: RCOMP_3:th 67
theorem
for b1, b2 being real set
for b3, b4 being natural set
for b5 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b6 being IntervalCover of b5
      st b5 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b5 is open(Closed-Interval-TSpace(b1,b2)) & b5 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & b3 in dom b6 & b4 in dom b6 & b3 < b4
   holds inf (b6 /. b3) <= inf (b6 /. b4);

:: RCOMP_3:th 68
theorem
for b1, b2 being real set
for b3, b4 being natural set
for b5 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b6 being IntervalCover of b5
      st b5 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b5 is open(Closed-Interval-TSpace(b1,b2)) & b5 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & b3 in dom b6 & b4 in dom b6 & b3 < b4
   holds sup (b6 /. b3) <= sup (b6 /. b4);

:: RCOMP_3:th 69
theorem
for b1, b2 being real set
for b3 being natural set
for b4 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b5 being IntervalCover of b4
      st b4 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b4 is open(Closed-Interval-TSpace(b1,b2)) & b4 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & 1 <= b3 & b3 + 1 <= len b5
   holds ].inf (b5 /. (b3 + 1)),sup (b5 /. b3).[ is not empty;

:: RCOMP_3:th 70
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
   holds inf (b4 /. 1) = b1;

:: RCOMP_3:th 71
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
   holds b1 in b4 /. 1;

:: RCOMP_3:th 72
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
   holds sup (b4 /. len b4) = b2;

:: RCOMP_3:th 73
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
   holds b2 in b4 /. len b4;

:: RCOMP_3:modenot 2 => RCOMP_3:mode 2
definition
  let a1, a2 be real set;
  let a3 be Element of bool bool the carrier of Closed-Interval-TSpace(a1,a2);
  let a4 be IntervalCover of a3;
  assume a3 is_a_cover_of Closed-Interval-TSpace(a1,a2) & a3 is open(Closed-Interval-TSpace(a1,a2)) & a3 is connected(Closed-Interval-TSpace(a1,a2)) & a1 <= a2;
  mode IntervalCoverPts of A4 -> FinSequence of REAL means
    len it = (len a4) + 1 &
     it . 1 = a1 &
     it . len it = a2 &
     (for b1 being natural set
           st 1 <= b1 & b1 + 1 < len it
        holds it . (b1 + 1) in ].inf (a4 /. (b1 + 1)),sup (a4 /. b1).[);
end;

:: RCOMP_3:dfs 3
definiens
  let a1, a2 be real set;
  let a3 be Element of bool bool the carrier of Closed-Interval-TSpace(a1,a2);
  let a4 be IntervalCover of a3;
  let a5 be FinSequence of REAL;
To prove
     a5 is IntervalCoverPts of a4
it is sufficient to prove
thus a3 is_a_cover_of Closed-Interval-TSpace(a1,a2) & a3 is open(Closed-Interval-TSpace(a1,a2)) & a3 is connected(Closed-Interval-TSpace(a1,a2)) & a1 <= a2;
  thus len a5 = (len a4) + 1 &
     a5 . 1 = a1 &
     a5 . len a5 = a2 &
     (for b1 being natural set
           st 1 <= b1 & b1 + 1 < len a5
        holds a5 . (b1 + 1) in ].inf (a4 /. (b1 + 1)),sup (a4 /. b1).[);

:: RCOMP_3:def 3
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
   st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
for b5 being FinSequence of REAL holds
      b5 is IntervalCoverPts of b4
   iff
      len b5 = (len b4) + 1 &
       b5 . 1 = b1 &
       b5 . len b5 = b2 &
       (for b6 being natural set
             st 1 <= b6 & b6 + 1 < len b5
          holds b5 . (b6 + 1) in ].inf (b4 /. (b6 + 1)),sup (b4 /. b6).[);

:: RCOMP_3:th 74
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
for b5 being IntervalCoverPts of b4
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2
   holds 2 <= len b5;

:: RCOMP_3:th 75
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
for b5 being IntervalCoverPts of b4
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & len b4 = 1
   holds b5 = <*b1,b2*>;

:: RCOMP_3:th 76
theorem
for b1, b2 being real set
for b3 being natural set
for b4 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b5 being IntervalCover of b4
for b6 being IntervalCoverPts of b5
      st b4 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b4 is open(Closed-Interval-TSpace(b1,b2)) & b4 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & 1 <= b3 & b3 + 1 < len b6
   holds b6 . (b3 + 1) < sup (b5 /. b3);

:: RCOMP_3:th 77
theorem
for b1, b2 being real set
for b3 being natural set
for b4 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b5 being IntervalCover of b4
for b6 being IntervalCoverPts of b5
      st b4 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b4 is open(Closed-Interval-TSpace(b1,b2)) & b4 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & 1 < b3 & b3 <= len b5
   holds inf (b5 /. b3) < b6 . b3;

:: RCOMP_3:th 78
theorem
for b1, b2 being real set
for b3 being natural set
for b4 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b5 being IntervalCover of b4
for b6 being IntervalCoverPts of b5
      st b4 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b4 is open(Closed-Interval-TSpace(b1,b2)) & b4 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & 1 <= b3 & b3 < len b5
   holds b6 . b3 <= inf (b5 /. (b3 + 1));

:: RCOMP_3:th 79
theorem
for b1, b2 being real set
for b3 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b4 being IntervalCover of b3
for b5 being IntervalCoverPts of b4
      st b3 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b3 is open(Closed-Interval-TSpace(b1,b2)) & b3 is connected(Closed-Interval-TSpace(b1,b2)) & b1 < b2
   holds b5 is increasing;

:: RCOMP_3:th 80
theorem
for b1, b2 being real set
for b3 being natural set
for b4 being Element of bool bool the carrier of Closed-Interval-TSpace(b1,b2)
for b5 being IntervalCover of b4
for b6 being IntervalCoverPts of b5
      st b4 is_a_cover_of Closed-Interval-TSpace(b1,b2) & b4 is open(Closed-Interval-TSpace(b1,b2)) & b4 is connected(Closed-Interval-TSpace(b1,b2)) & b1 <= b2 & 1 <= b3 & b3 < len b6
   holds [.b6 . b3,b6 . (b3 + 1).] c= b5 . b3;