Article COMPLSP1, MML version 4.99.1005

:: COMPLSP1:th 3
theorem
0c is_a_unity_wrt addcomplex;

:: COMPLSP1:th 6
theorem
compcomplex is_an_inverseOp_wrt addcomplex;

:: COMPLSP1:th 7
theorem
addcomplex is having_an_inverseOp(COMPLEX);

:: COMPLSP1:th 8
theorem
the_inverseOp_wrt addcomplex = compcomplex;

:: COMPLSP1:funcnot 1 => BINOP_2:func 28
definition
  func diffcomplex -> Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX equals
    addcomplex *(id COMPLEX,compcomplex);
end;

:: COMPLSP1:def 3
theorem
diffcomplex = addcomplex *(id COMPLEX,compcomplex);

:: COMPLSP1:th 12
theorem
1r is_a_unity_wrt multcomplex;

:: COMPLSP1:th 15
theorem
multcomplex is_distributive_wrt addcomplex;

:: COMPLSP1:funcnot 2 => COMPLSP1:func 1
definition
  let a1 be complex set;
  func A1 multcomplex -> Function-like quasi_total Relation of COMPLEX,COMPLEX equals
    multcomplex [;](a1,id COMPLEX);
end;

:: COMPLSP1:def 5
theorem
for b1 being complex set holds
   b1 multcomplex = multcomplex [;](b1,id COMPLEX);

:: COMPLSP1:th 16
theorem
for b1, b2 being Element of COMPLEX holds
b1 multcomplex . b2 = b1 * b2;

:: COMPLSP1:th 17
theorem
for b1 being Element of COMPLEX holds
   b1 multcomplex is_distributive_wrt addcomplex;

:: COMPLSP1:funcnot 3 => COMPLSP1:func 2
definition
  func abscomplex -> Function-like quasi_total Relation of COMPLEX,REAL means
    for b1 being Element of COMPLEX holds
       it . b1 = |.b1.|;
end;

:: COMPLSP1:def 6
theorem
for b1 being Function-like quasi_total Relation of COMPLEX,REAL holds
      b1 = abscomplex
   iff
      for b2 being Element of COMPLEX holds
         b1 . b2 = |.b2.|;

:: COMPLSP1:funcnot 4 => COMPLSP1:func 3
definition
  let a1, a2 be FinSequence of COMPLEX;
  redefine func A1 + A2 -> FinSequence of COMPLEX equals
    addcomplex .:(a1,a2);
  commutativity;
::  for a1, a2 being FinSequence of COMPLEX holds
::  a1 + a2 = a2 + a1;
end;

:: COMPLSP1:def 7
theorem
for b1, b2 being FinSequence of COMPLEX holds
b1 + b2 = addcomplex .:(b1,b2);

:: COMPLSP1:funcnot 5 => COMPLSP1:func 4
definition
  let a1, a2 be FinSequence of COMPLEX;
  redefine func A1 - A2 -> FinSequence of COMPLEX equals
    diffcomplex .:(a1,a2);
end;

:: COMPLSP1:def 8
theorem
for b1, b2 being FinSequence of COMPLEX holds
b1 - b2 = diffcomplex .:(b1,b2);

:: COMPLSP1:funcnot 6 => COMPLSP1:func 5
definition
  let a1 be FinSequence of COMPLEX;
  redefine func - A1 -> FinSequence of COMPLEX equals
    compcomplex * a1;
  involutiveness;
::  for a1 being FinSequence of COMPLEX holds
::     - - a1 = a1;
end;

:: COMPLSP1:def 9
theorem
for b1 being FinSequence of COMPLEX holds
   - b1 = compcomplex * b1;

:: COMPLSP1:funcnot 7 => VALUED_1:func 24
notation
  let a1 be FinSequence of COMPLEX;
  let a2 be complex set;
  synonym a2 * a1 for a2 (#) a1;
end;

:: COMPLSP1:funcnot 8 => COMPLSP1:func 6
definition
  let a1 be FinSequence of COMPLEX;
  let a2 be complex set;
  redefine func A2 * A1 -> FinSequence of COMPLEX equals
    a2 multcomplex * a1;
end;

:: COMPLSP1:def 10
theorem
for b1 being FinSequence of COMPLEX
for b2 being complex set holds
   b2 * b1 = b2 multcomplex * b1;

:: COMPLSP1:funcnot 9 => COMPLSP1:func 7
definition
  let a1 be FinSequence of COMPLEX;
  redefine func abs A1 -> FinSequence of REAL equals
    abscomplex * a1;
  projectivity;
::  for a1 being FinSequence of COMPLEX holds
::     abs abs a1 = abs a1;
end;

:: COMPLSP1:def 11
theorem
for b1 being FinSequence of COMPLEX holds
   abs b1 = abscomplex * b1;

:: COMPLSP1:funcnot 10 => COMPLSP1:func 8
definition
  let a1 be Element of NAT;
  func COMPLEX A1 -> non empty FinSequenceSet of COMPLEX equals
    a1 -tuples_on COMPLEX;
end;

:: COMPLSP1:def 12
theorem
for b1 being Element of NAT holds
   COMPLEX b1 = b1 -tuples_on COMPLEX;

:: COMPLSP1:funcreg 1
registration
  let a1 be Element of NAT;
  cluster COMPLEX a1 -> non empty;
end;

:: COMPLSP1:th 21
theorem
for b1, b2 being Element of NAT
for b3 being Element of COMPLEX b2
      st b1 in Seg b2
   holds b3 . b1 in COMPLEX;

:: COMPLSP1:funcnot 11 => COMPLSP1:func 9
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of COMPLEX a1;
  redefine func a2 + a3 -> Element of COMPLEX a1;
  commutativity;
::  for a1 being Element of NAT
::  for a2, a3 being Element of COMPLEX a1 holds
::  a2 + a3 = a3 + a2;
end;

:: COMPLSP1:th 24
theorem
for b1, b2 being Element of NAT
for b3, b4 being Element of COMPLEX
for b5, b6 being Element of COMPLEX b2
      st b1 in Seg b2 & b3 = b5 . b1 & b4 = b6 . b1
   holds (b5 + b6) . b1 = b3 + b4;

:: COMPLSP1:funcnot 12 => COMPLSP1:func 10
definition
  let a1 be Element of NAT;
  func 0c A1 -> FinSequence of COMPLEX equals
    a1 |-> 0c;
end;

:: COMPLSP1:def 13
theorem
for b1 being Element of NAT holds
   0c b1 = b1 |-> 0c;

:: COMPLSP1:funcnot 13 => COMPLSP1:func 11
definition
  let a1 be Element of NAT;
  redefine func 0c a1 -> Element of COMPLEX a1;
end;

:: COMPLSP1:th 28
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   b2 + 0c b1 = b2 & b2 = (0c b1) + b2;

:: COMPLSP1:funcnot 14 => COMPLSP1:func 12
definition
  let a1 be Element of NAT;
  let a2 be Element of COMPLEX a1;
  redefine func - a2 -> Element of COMPLEX a1;
  involutiveness;
::  for a1 being Element of NAT
::  for a2 being Element of COMPLEX a1 holds
::     - - a2 = a2;
end;

:: COMPLSP1:th 29
theorem
for b1, b2 being Element of NAT
for b3 being Element of COMPLEX
for b4 being Element of COMPLEX b2
      st b1 in Seg b2 & b3 = b4 . b1
   holds (- b4) . b1 = - b3;

:: COMPLSP1:th 30
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   b2 + - b2 = 0c b1 & (- b2) + b2 = 0c b1;

:: COMPLSP1:th 31
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1
      st b2 + b3 = 0c b1
   holds b2 = - b3 & b3 = - b2;

:: COMPLSP1:th 32
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   - - b2 = b2;

:: COMPLSP1:th 33
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1
      st - b2 = - b3
   holds b2 = b3;

:: COMPLSP1:th 34
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of COMPLEX b1
      st (b2 + b3 = b4 + b3 or b2 + b3 = b3 + b4)
   holds b2 = b4;

:: COMPLSP1:th 35
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
- (b2 + b3) = (- b2) + - b3;

:: COMPLSP1:funcnot 15 => COMPLSP1:func 13
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of COMPLEX a1;
  redefine func a2 - a3 -> Element of COMPLEX a1;
end;

:: COMPLSP1:th 36
theorem
for b1, b2 being Element of NAT
for b3, b4 being Element of COMPLEX
for b5, b6 being Element of COMPLEX b2
      st b1 in Seg b2 & b3 = b5 . b1 & b4 = b6 . b1
   holds (b5 - b6) . b1 = b3 - b4;

:: COMPLSP1:th 38
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   b2 - 0c b1 = b2;

:: COMPLSP1:th 39
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   (0c b1) - b2 = - b2;

:: COMPLSP1:th 40
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
b2 - - b3 = b2 + b3;

:: COMPLSP1:th 41
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
- (b2 - b3) = b3 - b2;

:: COMPLSP1:th 42
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
- (b2 - b3) = (- b2) + b3;

:: COMPLSP1:th 43
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   b2 - b2 = 0c b1;

:: COMPLSP1:th 44
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1
      st b2 - b3 = 0c b1
   holds b2 = b3;

:: COMPLSP1:th 45
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of COMPLEX b1 holds
(b2 - b3) - b4 = b2 - (b3 + b4);

:: COMPLSP1:th 46
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of COMPLEX b1 holds
b2 + (b3 - b4) = (b2 + b3) - b4;

:: COMPLSP1:th 47
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of COMPLEX b1 holds
b2 - (b3 - b4) = (b2 - b3) + b4;

:: COMPLSP1:th 48
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of COMPLEX b1 holds
(b2 - b3) + b4 = (b2 + b4) - b3;

:: COMPLSP1:th 49
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
b2 = (b2 + b3) - b3;

:: COMPLSP1:th 50
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
b2 + (b3 - b2) = b3;

:: COMPLSP1:th 51
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
b2 = (b2 - b3) + b3;

:: COMPLSP1:funcnot 16 => COMPLSP1:func 14
definition
  let a1 be Element of NAT;
  let a2 be Element of COMPLEX a1;
  let a3 be Element of COMPLEX;
  redefine func a3 * a2 -> Element of COMPLEX a1;
end;

:: COMPLSP1:th 52
theorem
for b1, b2 being Element of NAT
for b3, b4 being Element of COMPLEX
for b5 being Element of COMPLEX b2
      st b1 in Seg b2 & b3 = b5 . b1
   holds (b4 * b5) . b1 = b4 * b3;

:: COMPLSP1:th 53
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX
for b4 being Element of COMPLEX b1 holds
   b2 * (b3 * b4) = (b2 * b3) * b4;

:: COMPLSP1:th 54
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX
for b4 being Element of COMPLEX b1 holds
   (b2 + b3) * b4 = (b2 * b4) + (b3 * b4);

:: COMPLSP1:th 55
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX
for b3, b4 being Element of COMPLEX b1 holds
b2 * (b3 + b4) = (b2 * b3) + (b2 * b4);

:: COMPLSP1:th 56
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   1r * b2 = b2;

:: COMPLSP1:th 57
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   0c * b2 = 0c b1;

:: COMPLSP1:th 58
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   (- 1r) * b2 = - b2;

:: COMPLSP1:funcnot 17 => COMPLSP1:func 15
definition
  let a1 be Element of NAT;
  let a2 be Element of COMPLEX a1;
  redefine func abs a2 -> Element of a1 -tuples_on REAL;
  projectivity;
::  for a1 being Element of NAT
::  for a2 being Element of COMPLEX a1 holds
::     abs abs a2 = abs a2;
end;

:: COMPLSP1:th 59
theorem
for b1, b2 being Element of NAT
for b3 being Element of COMPLEX
for b4 being Element of COMPLEX b2
      st b1 in Seg b2 & b3 = b4 . b1
   holds (abs b4) . b1 = |.b3.|;

:: COMPLSP1:th 60
theorem
for b1 being Element of NAT holds
   abs 0c b1 = b1 |-> 0;

:: COMPLSP1:th 61
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   abs - b2 = abs b2;

:: COMPLSP1:th 62
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX
for b3 being Element of COMPLEX b1 holds
   abs (b2 * b3) = |.b2.| * abs b3;

:: COMPLSP1:funcnot 18 => COMPLSP1:func 16
definition
  let a1 be FinSequence of COMPLEX;
  func |.A1.| -> Element of REAL equals
    sqrt Sum sqr abs a1;
end;

:: COMPLSP1:def 14
theorem
for b1 being FinSequence of COMPLEX holds
   |.b1.| = sqrt Sum sqr abs b1;

:: COMPLSP1:th 63
theorem
for b1 being Element of NAT holds
   |.0c b1.| = 0;

:: COMPLSP1:th 64
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
      st |.b2.| = 0
   holds b2 = 0c b1;

:: COMPLSP1:th 65
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   0 <= |.b2.|;

:: COMPLSP1:th 66
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1 holds
   |.- b2.| = |.b2.|;

:: COMPLSP1:th 67
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX
for b3 being Element of COMPLEX b1 holds
   |.b2 * b3.| = |.b2.| * |.b3.|;

:: COMPLSP1:th 68
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
|.b2 + b3.| <= |.b2.| + |.b3.|;

:: COMPLSP1:th 69
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
|.b2 - b3.| <= |.b2.| + |.b3.|;

:: COMPLSP1:th 70
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
|.b2.| - |.b3.| <= |.b2 + b3.|;

:: COMPLSP1:th 71
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
|.b2.| - |.b3.| <= |.b2 - b3.|;

:: COMPLSP1:th 72
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
   |.b2 - b3.| = 0
iff
   b2 = b3;

:: COMPLSP1:th 73
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1
      st b2 <> b3
   holds 0 < |.b2 - b3.|;

:: COMPLSP1:th 74
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1 holds
|.b2 - b3.| = |.b3 - b2.|;

:: COMPLSP1:th 75
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of COMPLEX b1 holds
|.b2 - b3.| <= |.b2 - b4.| + |.b4 - b3.|;

:: COMPLSP1:attrnot 1 => COMPLSP1:attr 1
definition
  let a1 be Element of NAT;
  let a2 be Element of bool COMPLEX a1;
  attr a2 is open means
    for b1 being Element of COMPLEX a1
          st b1 in a2
       holds ex b2 being Element of REAL st
          0 < b2 &
           (for b3 being Element of COMPLEX a1
                 st |.b3.| < b2
              holds b1 + b3 in a2);
end;

:: COMPLSP1:dfs 12
definiens
  let a1 be Element of NAT;
  let a2 be Element of bool COMPLEX a1;
To prove
     a2 is open
it is sufficient to prove
  thus for b1 being Element of COMPLEX a1
          st b1 in a2
       holds ex b2 being Element of REAL st
          0 < b2 &
           (for b3 being Element of COMPLEX a1
                 st |.b3.| < b2
              holds b1 + b3 in a2);

:: COMPLSP1:def 15
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1 holds
      b2 is open(b1)
   iff
      for b3 being Element of COMPLEX b1
            st b3 in b2
         holds ex b4 being Element of REAL st
            0 < b4 &
             (for b5 being Element of COMPLEX b1
                   st |.b5.| < b4
                holds b3 + b5 in b2);

:: COMPLSP1:attrnot 2 => COMPLSP1:attr 2
definition
  let a1 be Element of NAT;
  let a2 be Element of bool COMPLEX a1;
  attr a2 is closed means
    for b1 being Element of COMPLEX a1
          st for b2 being Element of REAL
                  st 0 < b2
               holds ex b3 being Element of COMPLEX a1 st
                  |.b3.| < b2 & b1 + b3 in a2
       holds b1 in a2;
end;

:: COMPLSP1:dfs 13
definiens
  let a1 be Element of NAT;
  let a2 be Element of bool COMPLEX a1;
To prove
     a2 is closed
it is sufficient to prove
  thus for b1 being Element of COMPLEX a1
          st for b2 being Element of REAL
                  st 0 < b2
               holds ex b3 being Element of COMPLEX a1 st
                  |.b3.| < b2 & b1 + b3 in a2
       holds b1 in a2;

:: COMPLSP1:def 16
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1 holds
      b2 is closed(b1)
   iff
      for b3 being Element of COMPLEX b1
            st for b4 being Element of REAL
                    st 0 < b4
                 holds ex b5 being Element of COMPLEX b1 st
                    |.b5.| < b4 & b3 + b5 in b2
         holds b3 in b2;

:: COMPLSP1:th 76
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1
      st b2 = {}
   holds b2 is open(b1);

:: COMPLSP1:th 77
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1
      st b2 = COMPLEX b1
   holds b2 is open(b1);

:: COMPLSP1:th 78
theorem
for b1 being Element of NAT
for b2 being Element of bool bool COMPLEX b1
   st for b3 being Element of bool COMPLEX b1
           st b3 in b2
        holds b3 is open(b1)
for b3 being Element of bool COMPLEX b1
      st b3 = union b2
   holds b3 is open(b1);

:: COMPLSP1:th 79
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool COMPLEX b1
   st b2 is open(b1) & b3 is open(b1)
for b4 being Element of bool COMPLEX b1
      st b4 = b2 /\ b3
   holds b4 is open(b1);

:: COMPLSP1:funcnot 19 => COMPLSP1:func 17
definition
  let a1 be Element of NAT;
  let a2 be Element of COMPLEX a1;
  let a3 be Element of REAL;
  func Ball(A2,A3) -> Element of bool COMPLEX a1 equals
    {b1 where b1 is Element of COMPLEX a1: |.b1 - a2.| < a3};
end;

:: COMPLSP1:def 17
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
for b3 being Element of REAL holds
   Ball(b2,b3) = {b4 where b4 is Element of COMPLEX b1: |.b4 - b2.| < b3};

:: COMPLSP1:th 80
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3, b4 being Element of COMPLEX b1 holds
   b3 in Ball(b4,b2)
iff
   |.b4 - b3.| < b2;

:: COMPLSP1:th 81
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of COMPLEX b1
      st 0 < b2
   holds b3 in Ball(b3,b2);

:: COMPLSP1:th 82
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of COMPLEX b1 holds
   Ball(b3,b2) is open(b1);

:: COMPLSP1:sch 1
scheme COMPLSP1:sch 1
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> Element of F2()}:
{F3(b1) where b1 is Element of F1(): P1[b1]} is Element of bool F2()


:: COMPLSP1:sch 2
scheme COMPLSP1:sch 2
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> Element of F3()}:
{F4(b1, b2) where b1 is Element of F1(), b2 is Element of F2(): P1[b1, b2]} is Element of bool F3()


:: COMPLSP1:funcnot 20 => COMPLSP1:func 18
definition
  let a1 be Element of NAT;
  let a2 be Element of COMPLEX a1;
  let a3 be Element of bool COMPLEX a1;
  func dist(A2,A3) -> Element of REAL means
    for b1 being Element of bool REAL
          st b1 = {|.a2 - b2.| where b2 is Element of COMPLEX a1: b2 in a3}
       holds it = lower_bound b1;
end;

:: COMPLSP1:def 18
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
for b3 being Element of bool COMPLEX b1
for b4 being Element of REAL holds
      b4 = dist(b2,b3)
   iff
      for b5 being Element of bool REAL
            st b5 = {|.b2 - b6.| where b6 is Element of COMPLEX b1: b6 in b3}
         holds b4 = lower_bound b5;

:: COMPLSP1:funcnot 21 => COMPLSP1:func 19
definition
  let a1 be Element of NAT;
  let a2 be Element of bool COMPLEX a1;
  let a3 be Element of REAL;
  func Ball(A2,A3) -> Element of bool COMPLEX a1 equals
    {b1 where b1 is Element of COMPLEX a1: dist(b1,a2) < a3};
end;

:: COMPLSP1:def 19
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1
for b3 being Element of REAL holds
   Ball(b2,b3) = {b4 where b4 is Element of COMPLEX b1: dist(b4,b2) < b3};

:: COMPLSP1:th 84
theorem
for b1 being Element of bool REAL
for b2 being Element of REAL
      st b1 <> {} &
         (for b3 being Element of REAL
               st b3 in b1
            holds b2 <= b3)
   holds b2 <= lower_bound b1;

:: COMPLSP1:th 85
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
for b3 being Element of bool COMPLEX b1
      st b3 <> {}
   holds 0 <= dist(b2,b3);

:: COMPLSP1:th 86
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1
for b4 being Element of bool COMPLEX b1
      st b4 <> {}
   holds dist(b2 + b3,b4) <= (dist(b2,b4)) + |.b3.|;

:: COMPLSP1:th 87
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
for b3 being Element of bool COMPLEX b1
      st b2 in b3
   holds dist(b2,b3) = 0;

:: COMPLSP1:th 88
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
for b3 being Element of bool COMPLEX b1
      st not b2 in b3 & b3 <> {} & b3 is closed(b1)
   holds 0 < dist(b2,b3);

:: COMPLSP1:th 89
theorem
for b1 being Element of NAT
for b2, b3 being Element of COMPLEX b1
for b4 being Element of bool COMPLEX b1
      st b4 <> {}
   holds dist(b2,b4) <= |.b2 - b3.| + dist(b3,b4);

:: COMPLSP1:th 90
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of COMPLEX b1
for b4 being Element of bool COMPLEX b1 holds
      b3 in Ball(b4,b2)
   iff
      dist(b3,b4) < b2;

:: COMPLSP1:th 91
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of COMPLEX b1
for b4 being Element of bool COMPLEX b1
      st 0 < b2 & b3 in b4
   holds b3 in Ball(b4,b2);

:: COMPLSP1:th 92
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool COMPLEX b1
      st 0 < b2
   holds b3 c= Ball(b3,b2);

:: COMPLSP1:th 93
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool COMPLEX b1
      st b3 <> {}
   holds Ball(b3,b2) is open(b1);

:: COMPLSP1:funcnot 22 => COMPLSP1:func 20
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of bool COMPLEX a1;
  func dist(A2,A3) -> Element of REAL means
    for b1 being Element of bool REAL
          st b1 = {|.b2 - b3.| where b2 is Element of COMPLEX a1, b3 is Element of COMPLEX a1: b2 in a2 & b3 in a3}
       holds it = lower_bound b1;
end;

:: COMPLSP1:def 20
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool COMPLEX b1
for b4 being Element of REAL holds
      b4 = dist(b2,b3)
   iff
      for b5 being Element of bool REAL
            st b5 = {|.b6 - b7.| where b6 is Element of COMPLEX b1, b7 is Element of COMPLEX b1: b6 in b2 & b7 in b3}
         holds b4 = lower_bound b5;

:: COMPLSP1:funcnot 23 => COMPLSP1:func 21
definition
  let a1, a2 be Element of bool REAL;
  func A1 + A2 -> Element of bool REAL equals
    {b1 + b2 where b1 is Element of REAL, b2 is Element of REAL: b1 in a1 & b2 in a2};
end;

:: COMPLSP1:def 21
theorem
for b1, b2 being Element of bool REAL holds
b1 + b2 = {b3 + b4 where b3 is Element of REAL, b4 is Element of REAL: b3 in b1 & b4 in b2};

:: COMPLSP1:th 94
theorem
for b1, b2 being Element of bool REAL
      st b1 <> {} & b2 <> {}
   holds b1 + b2 <> {};

:: COMPLSP1:th 95
theorem
for b1, b2 being Element of bool REAL
      st b1 is bounded_below & b2 is bounded_below
   holds b1 + b2 is bounded_below;

:: COMPLSP1:th 96
theorem
for b1, b2 being Element of bool REAL
      st b1 <> {} & b1 is bounded_below & b2 <> {} & b2 is bounded_below
   holds lower_bound (b1 + b2) = (lower_bound b1) + lower_bound b2;

:: COMPLSP1:th 97
theorem
for b1, b2 being Element of bool REAL
      st b2 is bounded_below &
         b1 <> {} &
         (for b3 being Element of REAL
               st b3 in b1
            holds ex b4 being Element of REAL st
               b4 in b2 & b4 <= b3)
   holds lower_bound b2 <= lower_bound b1;

:: COMPLSP1:th 98
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool COMPLEX b1
      st b2 <> {} & b3 <> {}
   holds 0 <= dist(b2,b3);

:: COMPLSP1:th 99
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool COMPLEX b1 holds
dist(b2,b3) = dist(b3,b2);

:: COMPLSP1:th 100
theorem
for b1 being Element of NAT
for b2 being Element of COMPLEX b1
for b3, b4 being Element of bool COMPLEX b1
      st b3 <> {} & b4 <> {}
   holds dist(b3,b4) <= (dist(b2,b3)) + dist(b2,b4);

:: COMPLSP1:th 101
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool COMPLEX b1
      st b2 meets b3
   holds dist(b2,b3) = 0;

:: COMPLSP1:funcnot 24 => COMPLSP1:func 22
definition
  let a1 be Element of NAT;
  func ComplexOpenSets A1 -> Element of bool bool COMPLEX a1 equals
    {b1 where b1 is Element of bool COMPLEX a1: b1 is open(a1)};
end;

:: COMPLSP1:def 22
theorem
for b1 being Element of NAT holds
   ComplexOpenSets b1 = {b2 where b2 is Element of bool COMPLEX b1: b2 is open(b1)};

:: COMPLSP1:th 102
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1 holds
      b2 in ComplexOpenSets b1
   iff
      b2 is open(b1);

:: COMPLSP1:funcreg 2
registration
  let a1 be non empty set;
  let a2 be Element of bool bool a1;
  cluster TopStruct(#a1,a2#) -> non empty strict;
end;

:: COMPLSP1:funcnot 25 => COMPLSP1:func 23
definition
  let a1 be Element of NAT;
  func the_Complex_Space A1 -> strict TopSpace-like TopStruct equals
    TopStruct(#COMPLEX a1,ComplexOpenSets a1#);
end;

:: COMPLSP1:def 23
theorem
for b1 being Element of NAT holds
   the_Complex_Space b1 = TopStruct(#COMPLEX b1,ComplexOpenSets b1#);

:: COMPLSP1:funcreg 3
registration
  let a1 be Element of NAT;
  cluster the_Complex_Space a1 -> non empty strict TopSpace-like;
end;

:: COMPLSP1:th 103
theorem
for b1 being Element of NAT holds
   the topology of the_Complex_Space b1 = ComplexOpenSets b1;

:: COMPLSP1:th 104
theorem
for b1 being Element of NAT holds
   the carrier of the_Complex_Space b1 = COMPLEX b1;

:: COMPLSP1:th 105
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of the_Complex_Space b1 holds
   b2 is Element of COMPLEX b1;

:: COMPLSP1:th 108
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of the_Complex_Space b1
for b3 being Element of bool COMPLEX b1
      st b3 = b2
   holds    b3 is open(b1)
   iff
      b2 is open(the_Complex_Space b1);

:: COMPLSP1:th 109
theorem
for b1 being Element of NAT
for b2 being Element of bool COMPLEX b1 holds
      b2 is closed(b1)
   iff
      b2 ` is open(b1);

:: COMPLSP1:th 110
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of the_Complex_Space b1
for b3 being Element of bool COMPLEX b1
      st b3 = b2
   holds    b3 is closed(b1)
   iff
      b2 is closed(the_Complex_Space b1);

:: COMPLSP1:th 111
theorem
for b1 being Element of NAT holds
   the_Complex_Space b1 is being_T2;

:: COMPLSP1:th 112
theorem
for b1 being Element of NAT holds
   the_Complex_Space b1 is being_T3;