Article SEQ_4, MML version 4.99.1005

:: SEQ_4:th 8
theorem
for b1, b2 being Element of bool REAL
      st for b3, b4 being real set
              st b3 in b1 & b4 in b2
           holds b3 < b4
   holds ex b3 being real set st
      for b4, b5 being real set
            st b4 in b1 & b5 in b2
         holds b4 <= b3 & b3 <= b5;

:: SEQ_4:th 9
theorem
for b1 being real set
for b2 being Element of bool REAL
   st 0 < b1 &
      (ex b3 being real set st
         b3 in b2) &
      (for b3 being real set
            st b3 in b2
         holds b3 + b1 in b2)
for b3 being real set holds
   ex b4 being real set st
      b4 in b2 & b3 < b4;

:: SEQ_4:th 10
theorem
for b1 being real set holds
   ex b2 being Element of NAT st
      b1 < b2;

:: SEQ_4:attrnot 1 => SEQ_4:attr 1
definition
  let a1 be real-membered set;
  attr a1 is bounded_above means
    ex b1 being real set st
       for b2 being real set
             st b2 in a1
          holds b2 <= b1;
end;

:: SEQ_4:dfs 1
definiens
  let a1 be real-membered set;
To prove
     a1 is bounded_above
it is sufficient to prove
  thus ex b1 being real set st
       for b2 being real set
             st b2 in a1
          holds b2 <= b1;

:: SEQ_4:def 1
theorem
for b1 being real-membered set holds
      b1 is bounded_above
   iff
      ex b2 being real set st
         for b3 being real set
               st b3 in b1
            holds b3 <= b2;

:: SEQ_4:attrnot 2 => SEQ_4:attr 2
definition
  let a1 be real-membered set;
  attr a1 is bounded_below means
    ex b1 being real set st
       for b2 being real set
             st b2 in a1
          holds b1 <= b2;
end;

:: SEQ_4:dfs 2
definiens
  let a1 be real-membered set;
To prove
     a1 is bounded_below
it is sufficient to prove
  thus ex b1 being real set st
       for b2 being real set
             st b2 in a1
          holds b1 <= b2;

:: SEQ_4:def 2
theorem
for b1 being real-membered set holds
      b1 is bounded_below
   iff
      ex b2 being real set st
         for b3 being real set
               st b3 in b1
            holds b2 <= b3;

:: SEQ_4:attrnot 3 => SEQ_4:attr 3
definition
  let a1 be Element of bool REAL;
  attr a1 is bounded means
    a1 is bounded_below & a1 is bounded_above;
end;

:: SEQ_4:dfs 3
definiens
  let a1 be Element of bool REAL;
To prove
     a1 is bounded
it is sufficient to prove
  thus a1 is bounded_below & a1 is bounded_above;

:: SEQ_4:def 3
theorem
for b1 being Element of bool REAL holds
      b1 is bounded
   iff
      b1 is bounded_below & b1 is bounded_above;

:: SEQ_4:th 14
theorem
for b1 being Element of bool REAL holds
      b1 is bounded
   iff
      ex b2 being real set st
         0 < b2 &
          (for b3 being real set
                st b3 in b1
             holds abs b3 < b2);

:: SEQ_4:funcnot 1 => SEQ_4:func 1
definition
  let a1 be real set;
  redefine func {a1} -> Element of bool REAL;
end;

:: SEQ_4:th 15
theorem
for b1 being real set holds
   {b1} is bounded;

:: SEQ_4:th 16
theorem
for b1 being real-membered set
      st b1 is not empty & b1 is bounded_above
   holds ex b2 being real set st
      (for b3 being real set
             st b3 in b1
          holds b3 <= b2) &
       (for b3 being real set
             st 0 < b3
          holds ex b4 being real set st
             b4 in b1 & b2 - b3 < b4);

:: SEQ_4:th 17
theorem
for b1, b2 being real set
for b3 being real-membered set
      st (for b4 being real set
               st b4 in b3
            holds b4 <= b1) &
         (for b4 being real set
               st 0 < b4
            holds ex b5 being real set st
               b5 in b3 & b1 - b4 < b5) &
         (for b4 being real set
               st b4 in b3
            holds b4 <= b2) &
         (for b4 being real set
               st 0 < b4
            holds ex b5 being real set st
               b5 in b3 & b2 - b4 < b5)
   holds b1 = b2;

:: SEQ_4:th 18
theorem
for b1 being real-membered set
      st b1 is not empty & b1 is bounded_below
   holds ex b2 being real set st
      (for b3 being real set
             st b3 in b1
          holds b2 <= b3) &
       (for b3 being real set
             st 0 < b3
          holds ex b4 being real set st
             b4 in b1 & b4 < b2 + b3);

:: SEQ_4:th 19
theorem
for b1, b2 being real set
for b3 being real-membered set
      st (for b4 being real set
               st b4 in b3
            holds b1 <= b4) &
         (for b4 being real set
               st 0 < b4
            holds ex b5 being real set st
               b5 in b3 & b5 < b1 + b4) &
         (for b4 being real set
               st b4 in b3
            holds b2 <= b4) &
         (for b4 being real set
               st 0 < b4
            holds ex b5 being real set st
               b5 in b3 & b5 < b2 + b4)
   holds b1 = b2;

:: SEQ_4:funcnot 2 => SEQ_4:func 2
definition
  let a1 be real-membered set;
  assume a1 is not empty & a1 is bounded_above;
  func upper_bound A1 -> real set means
    (for b1 being real set
           st b1 in a1
        holds b1 <= it) &
     (for b1 being real set
           st 0 < b1
        holds ex b2 being real set st
           b2 in a1 & it - b1 < b2);
end;

:: SEQ_4:def 4
theorem
for b1 being real-membered set
   st b1 is not empty & b1 is bounded_above
for b2 being real set holds
      b2 = upper_bound b1
   iff
      (for b3 being real set
             st b3 in b1
          holds b3 <= b2) &
       (for b3 being real set
             st 0 < b3
          holds ex b4 being real set st
             b4 in b1 & b2 - b3 < b4);

:: SEQ_4:funcnot 3 => SEQ_4:func 3
definition
  let a1 be real-membered set;
  assume a1 is not empty & a1 is bounded_below;
  func lower_bound A1 -> real set means
    (for b1 being real set
           st b1 in a1
        holds it <= b1) &
     (for b1 being real set
           st 0 < b1
        holds ex b2 being real set st
           b2 in a1 & b2 < it + b1);
end;

:: SEQ_4:def 5
theorem
for b1 being real-membered set
   st b1 is not empty & b1 is bounded_below
for b2 being real set holds
      b2 = lower_bound b1
   iff
      (for b3 being real set
             st b3 in b1
          holds b2 <= b3) &
       (for b3 being real set
             st 0 < b3
          holds ex b4 being real set st
             b4 in b1 & b4 < b2 + b3);

:: SEQ_4:funcnot 4 => SEQ_4:func 4
definition
  let a1 be Element of bool REAL;
  redefine func upper_bound a1 -> Element of REAL;
end;

:: SEQ_4:funcnot 5 => SEQ_4:func 5
definition
  let a1 be Element of bool REAL;
  redefine func lower_bound a1 -> Element of REAL;
end;

:: SEQ_4:th 22
theorem
for b1 being real set holds
   lower_bound {b1} = b1 & upper_bound {b1} = b1;

:: SEQ_4:th 23
theorem
for b1 being real set holds
   lower_bound {b1} = upper_bound {b1};

:: SEQ_4:th 24
theorem
for b1 being Element of bool REAL
      st b1 is bounded & b1 is not empty
   holds lower_bound b1 <= upper_bound b1;

:: SEQ_4:th 25
theorem
for b1 being Element of bool REAL
      st b1 is bounded & b1 is not empty
   holds    ex b2, b3 being real set st
         b2 in b1 & b3 in b1 & b3 <> b2
   iff
      lower_bound b1 < upper_bound b1;

:: SEQ_4:th 26
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent
   holds abs b1 is convergent;

:: SEQ_4:th 27
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent
   holds lim abs b1 = abs lim b1;

:: SEQ_4:th 28
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st abs b1 is convergent & lim abs b1 = 0
   holds b1 is convergent & lim b1 = 0;

:: SEQ_4:th 29
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is subsequence of b2 & b2 is convergent
   holds b1 is convergent;

:: SEQ_4:th 30
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is subsequence of b2 & b2 is convergent
   holds lim b1 = lim b2;

:: SEQ_4:th 31
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent &
         (ex b3 being Element of NAT st
            for b4 being Element of NAT
                  st b3 <= b4
               holds b2 . b4 = b1 . b4)
   holds b2 is convergent;

:: SEQ_4:th 32
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent &
         (ex b3 being Element of NAT st
            for b4 being Element of NAT
                  st b3 <= b4
               holds b2 . b4 = b1 . b4)
   holds lim b1 = lim b2;

:: SEQ_4:th 33
theorem
for b1 being Element of NAT
for b2 being Function-like quasi_total Relation of NAT,REAL
      st b2 is convergent
   holds b2 ^\ b1 is convergent & lim (b2 ^\ b1) = lim b2;

:: SEQ_4:th 35
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent &
         (ex b3 being Element of NAT st
            b1 = b2 ^\ b3)
   holds b2 is convergent;

:: SEQ_4:th 36
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent &
         (ex b3 being Element of NAT st
            b1 = b2 ^\ b3)
   holds lim b2 = lim b1;

:: SEQ_4:th 37
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent & lim b1 <> 0
   holds ex b2 being Element of NAT st
      b1 ^\ b2 is non-empty;

:: SEQ_4:th 38
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is convergent & lim b1 <> 0
   holds ex b2 being Function-like quasi_total Relation of NAT,REAL st
      b2 is subsequence of b1 & b2 is non-empty;

:: SEQ_4:th 39
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is constant
   holds b1 is convergent;

:: SEQ_4:condreg 1
registration
  cluster Function-like constant quasi_total -> convergent (Relation of NAT,REAL);
end;

:: SEQ_4:th 40
theorem
for b1 being real set
for b2 being Function-like quasi_total Relation of NAT,REAL
      st (b2 is constant & b1 in proj2 b2 or b2 is constant &
         (ex b3 being Element of NAT st
            b2 . b3 = b1))
   holds lim b2 = b1;

:: SEQ_4:th 41
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
   st b1 is constant
for b2 being Element of NAT holds
   lim b1 = b1 . b2;

:: SEQ_4:th 42
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
   st b1 is convergent & lim b1 <> 0
for b2 being Function-like quasi_total Relation of NAT,REAL
      st b2 is subsequence of b1 & b2 is non-empty
   holds lim (b2 ") = (lim b1) ";

:: SEQ_4:th 43
theorem
for b1 being real set
for b2 being Function-like quasi_total Relation of NAT,REAL
      st 0 <= b1 &
         (for b3 being Element of NAT holds
            b2 . b3 = 1 / (b3 + b1))
   holds b2 is convergent;

:: SEQ_4:th 44
theorem
for b1 being real set
for b2 being Function-like quasi_total Relation of NAT,REAL
      st 0 <= b1 &
         (for b3 being Element of NAT holds
            b2 . b3 = 1 / (b3 + b1))
   holds lim b2 = 0;

:: SEQ_4:th 45
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st for b2 being Element of NAT holds
           b1 . b2 = 1 / (b2 + 1)
   holds b1 is convergent & lim b1 = 0;

:: SEQ_4:th 46
theorem
for b1, b2 being real set
for b3 being Function-like quasi_total Relation of NAT,REAL
      st 0 <= b1 &
         (for b4 being Element of NAT holds
            b3 . b4 = b2 / (b4 + b1))
   holds b3 is convergent & lim b3 = 0;

:: SEQ_4:th 47
theorem
for b1 being real set
for b2 being Function-like quasi_total Relation of NAT,REAL
      st 0 <= b1 &
         (for b3 being Element of NAT holds
            b2 . b3 = 1 / ((b3 * b3) + b1))
   holds b2 is convergent;

:: SEQ_4:th 48
theorem
for b1 being real set
for b2 being Function-like quasi_total Relation of NAT,REAL
      st 0 <= b1 &
         (for b3 being Element of NAT holds
            b2 . b3 = 1 / ((b3 * b3) + b1))
   holds lim b2 = 0;

:: SEQ_4:th 49
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st for b2 being Element of NAT holds
           b1 . b2 = 1 / ((b2 * b2) + 1)
   holds b1 is convergent & lim b1 = 0;

:: SEQ_4:th 50
theorem
for b1, b2 being real set
for b3 being Function-like quasi_total Relation of NAT,REAL
      st 0 <= b1 &
         (for b4 being Element of NAT holds
            b3 . b4 = b2 / ((b4 * b4) + b1))
   holds b3 is convergent & lim b3 = 0;

:: SEQ_4:th 51
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is non-decreasing & b1 is bounded_above
   holds b1 is convergent;

:: SEQ_4:th 52
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is non-increasing & b1 is bounded_below
   holds b1 is convergent;

:: SEQ_4:th 53
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is monotone & b1 is bounded
   holds b1 is convergent;

:: SEQ_4:th 54
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
   st b1 is bounded_above & b1 is non-decreasing
for b2 being Element of NAT holds
   b1 . b2 <= lim b1;

:: SEQ_4:th 55
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
   st b1 is bounded_below & b1 is non-increasing
for b2 being Element of NAT holds
   lim b1 <= b1 . b2;

:: SEQ_4:th 56
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL holds
   ex b2 being Function-like quasi_total natural-valued increasing Relation of NAT,REAL st
      b1 * b2 is monotone;

:: SEQ_4:th 57
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL
      st b1 is bounded
   holds ex b2 being Function-like quasi_total Relation of NAT,REAL st
      b2 is subsequence of b1 & b2 is convergent;

:: SEQ_4:th 58
theorem
for b1 being Function-like quasi_total Relation of NAT,REAL holds
      b1 is convergent
   iff
      for b2 being real set
            st 0 < b2
         holds ex b3 being Element of NAT st
            for b4 being Element of NAT
                  st b3 <= b4
               holds abs ((b1 . b4) - (b1 . b3)) < b2;

:: SEQ_4:th 59
theorem
for b1, b2 being Function-like quasi_total Relation of NAT,REAL
      st b1 is constant & b2 is convergent
   holds lim (b1 + b2) = (b1 . 0) + lim b2 &
    lim (b1 - b2) = (b1 . 0) - lim b2 &
    lim (b2 - b1) = (lim b2) - (b1 . 0) &
    lim (b1 (#) b2) = (b1 . 0) * lim b2;

:: SEQ_4:th 60
theorem
for b1 being non empty real-membered set
for b2 being real set
      st for b3 being real set
              st b3 in b1
           holds b2 <= b3
   holds b2 <= lower_bound b1;

:: SEQ_4:th 61
theorem
for b1 being real set
for b2 being non empty real-membered set
      st (for b3 being real set
               st b3 in b2
            holds b1 <= b3) &
         (for b3 being real set
               st for b4 being real set
                       st b4 in b2
                    holds b3 <= b4
            holds b3 <= b1)
   holds b1 = lower_bound b2;

:: SEQ_4:th 62
theorem
for b1 being non empty real-membered set
for b2, b3 being real set
      st for b4 being real set
              st b4 in b1
           holds b4 <= b3
   holds upper_bound b1 <= b3;

:: SEQ_4:th 63
theorem
for b1 being non empty real-membered set
for b2 being real set
      st (for b3 being real set
               st b3 in b1
            holds b3 <= b2) &
         (for b3 being real set
               st for b4 being real set
                       st b4 in b1
                    holds b4 <= b3
            holds b2 <= b3)
   holds b2 = upper_bound b1;

:: SEQ_4:th 64
theorem
for b1 being non empty real-membered set
for b2 being real-membered set
      st b1 c= b2 & b2 is bounded_below
   holds lower_bound b2 <= lower_bound b1;

:: SEQ_4:th 65
theorem
for b1 being non empty real-membered set
for b2 being real-membered set
      st b1 c= b2 & b2 is bounded_above
   holds upper_bound b1 <= upper_bound b2;

:: SEQ_4:condreg 2
registration
  cluster natural-membered -> bounded_below (set);
end;

:: SEQ_4:funcnot 6 => SEQ_4:func 3
notation
  let a1 be non empty natural-membered set;
  synonym min a1 for lower_bound a1;
end;

:: SEQ_4:funcnot 7 => SEQ_4:func 6
definition
  let a1 be non empty natural-membered set;
  redefine func min A1 -> Element of NAT means
    it in a1 &
     (for b1 being natural set
           st b1 in a1
        holds it <= b1);
end;

:: SEQ_4:def 6
theorem
for b1 being non empty natural-membered set
for b2 being Element of NAT holds
      b2 = min b1
   iff
      b2 in b1 &
       (for b3 being natural set
             st b3 in b1
          holds b2 <= b3);

:: SEQ_4:sch 1
scheme SEQ_4:sch 1
{F1 -> Element of NAT}:
ex b1 being Element of NAT st
   P1[b1] &
    (for b2 being Element of NAT
          st P1[b2]
       holds b1 <= b2)
provided
   for b1 being Element of NAT
         st F1(b1) <= F1(b1 + 1)
      holds P1[b1];