Article COMPLEX1, MML version 4.99.1005

:: COMPLEX1:th 2
theorem
for b1, b2 being real set
      st b1 ^2 + (b2 ^2) = 0
   holds b1 = 0;

:: COMPLEX1:funcnot 1 => COMPLEX1:func 1
definition
  let a1 be complex set;
  func Re A1 -> set means
    it = a1
    if a1 in REAL
    otherwise ex b1 being Function-like quasi_total Relation of 2,REAL st
       a1 = b1 & it = b1 . 0;
end;

:: COMPLEX1:def 2
theorem
for b1 being complex set
for b2 being set holds
   (b1 in REAL implies    (b2 = Re b1
    iff
       b2 = b1)) &
    (b1 in REAL or    (b2 = Re b1
    iff
       ex b3 being Function-like quasi_total Relation of 2,REAL st
          b1 = b3 & b2 = b3 . 0));

:: COMPLEX1:funcnot 2 => COMPLEX1:func 2
definition
  let a1 be complex set;
  func Im A1 -> set means
    it = 0
    if a1 in REAL
    otherwise ex b1 being Function-like quasi_total Relation of 2,REAL st
       a1 = b1 & it = b1 . 1;
end;

:: COMPLEX1:def 3
theorem
for b1 being complex set
for b2 being set holds
   (b1 in REAL implies    (b2 = Im b1
    iff
       b2 = 0)) &
    (b1 in REAL or    (b2 = Im b1
    iff
       ex b3 being Function-like quasi_total Relation of 2,REAL st
          b1 = b3 & b2 = b3 . 1));

:: COMPLEX1:funcreg 1
registration
  let a1 be complex set;
  cluster Re a1 -> real;
end;

:: COMPLEX1:funcreg 2
registration
  let a1 be complex set;
  cluster Im a1 -> real;
end;

:: COMPLEX1:funcnot 3 => COMPLEX1:func 3
definition
  let a1 be complex set;
  redefine func Re a1 -> Element of REAL;
end;

:: COMPLEX1:funcnot 4 => COMPLEX1:func 4
definition
  let a1 be complex set;
  redefine func Im a1 -> Element of REAL;
end;

:: COMPLEX1:th 5
theorem
for b1 being Function-like quasi_total Relation of 2,REAL holds
   ex b2, b3 being Element of REAL st
      b1 = (0,1)-->(b2,b3);

:: COMPLEX1:th 9
theorem
for b1, b2 being complex set
      st Re b1 = Re b2 & Im b1 = Im b2
   holds b1 = b2;

:: COMPLEX1:prednot 1 => HIDDEN:pred 1
definition
  let a1, a2 be set;
  pred A1 = A2 means
    Re a1 = Re a2 & Im a1 = Im a2;
  symmetry;
::  for a1, a2 being set
::        st a1 = a2
::     holds a2 = a1;
  reflexivity;
::  for a1 being set holds
::     a1 = a1;
end;

:: COMPLEX1:dfs 3
definiens
  let a1, a2 be complex set;
To prove
     a1 = a2
it is sufficient to prove
  thus Re a1 = Re a2 & Im a1 = Im a2;

:: COMPLEX1:def 5
theorem
for b1, b2 being complex set holds
   b1 = b2
iff
   Re b1 = Re b2 & Im b1 = Im b2;

:: COMPLEX1:funcnot 5 => XBOOLE_0:func 1
notation
  synonym 0c for {};
end;

:: COMPLEX1:funcnot 6 => COMPLEX1:func 5
definition
  redefine func 0c -> Element of COMPLEX;
end;

:: COMPLEX1:funcnot 7 => COMPLEX1:func 6
definition
  func 1r -> Element of COMPLEX equals
    1;
end;

:: COMPLEX1:def 7
theorem
1r = 1;

:: COMPLEX1:funcnot 8 => COMPLEX1:func 7
definition
  redefine func <i> -> Element of COMPLEX equals
    [*0,1*];
end;

:: COMPLEX1:def 8
theorem
<i> = [*0,1*];

:: COMPLEX1:funcreg 3
registration
  cluster {} -> empty;
end;

:: COMPLEX1:th 12
theorem
Re 0 = 0 & Im 0 = 0;

:: COMPLEX1:th 13
theorem
for b1 being complex set holds
      b1 = 0
   iff
      (Re b1) ^2 + ((Im b1) ^2) = 0;

:: COMPLEX1:th 15
theorem
Re 1r = 1 & Im 1r = 0;

:: COMPLEX1:th 17
theorem
Re <i> = 0 & Im <i> = 1;

:: COMPLEX1:funcnot 9 => COMPLEX1:func 8
definition
  let a1, a2 be Element of COMPLEX;
  redefine func A1 + A2 -> Element of COMPLEX equals
    ((Re a1) + Re a2) + (((Im a1) + Im a2) * <i>);
  commutativity;
::  for a1, a2 being Element of COMPLEX holds
::  a1 + a2 = a2 + a1;
end;

:: COMPLEX1:def 9
theorem
for b1, b2 being Element of COMPLEX holds
b1 + b2 = ((Re b1) + Re b2) + (((Im b1) + Im b2) * <i>);

:: COMPLEX1:th 19
theorem
for b1, b2 being complex set holds
Re (b1 + b2) = (Re b1) + Re b2 &
 Im (b1 + b2) = (Im b1) + Im b2;

:: COMPLEX1:funcnot 10 => COMPLEX1:func 9
definition
  let a1, a2 be Element of COMPLEX;
  redefine func A1 * A2 -> Element of COMPLEX equals
    (((Re a1) * Re a2) - ((Im a1) * Im a2)) + ((((Re a1) * Im a2) + ((Re a2) * Im a1)) * <i>);
  commutativity;
::  for a1, a2 being Element of COMPLEX holds
::  a1 * a2 = a2 * a1;
end;

:: COMPLEX1:def 10
theorem
for b1, b2 being Element of COMPLEX holds
b1 * b2 = (((Re b1) * Re b2) - ((Im b1) * Im b2)) + ((((Re b1) * Im b2) + ((Re b2) * Im b1)) * <i>);

:: COMPLEX1:th 24
theorem
for b1, b2 being complex set holds
Re (b1 * b2) = ((Re b1) * Re b2) - ((Im b1) * Im b2) &
 Im (b1 * b2) = ((Re b1) * Im b2) + ((Re b2) * Im b1);

:: COMPLEX1:th 25
theorem
for b1 being Element of REAL holds
   Re (b1 * <i>) = 0;

:: COMPLEX1:th 26
theorem
for b1 being Element of REAL holds
   Im (b1 * <i>) = b1;

:: COMPLEX1:th 27
theorem
for b1, b2 being Element of REAL holds
[*b1,b2*] = b1 + (b2 * <i>);

:: COMPLEX1:th 28
theorem
for b1, b2 being Element of REAL holds
Re (b1 + (b2 * <i>)) = b1 & Im (b1 + (b2 * <i>)) = b2;

:: COMPLEX1:th 29
theorem
for b1 being complex set holds
   (Re b1) + ((Im b1) * <i>) = b1;

:: COMPLEX1:th 30
theorem
for b1, b2 being complex set
      st Im b1 = 0 & Im b2 = 0
   holds Re (b1 * b2) = (Re b1) * Re b2 &
    Im (b1 * b2) = 0;

:: COMPLEX1:th 31
theorem
for b1, b2 being complex set
      st Re b1 = 0 & Re b2 = 0
   holds Re (b1 * b2) = - ((Im b1) * Im b2) &
    Im (b1 * b2) = 0;

:: COMPLEX1:th 32
theorem
for b1 being Element of COMPLEX holds
   Re (b1 * b1) = (Re b1) ^2 - ((Im b1) ^2) &
    Im (b1 * b1) = 2 * ((Re b1) * Im b1);

:: COMPLEX1:funcnot 11 => COMPLEX1:func 10
definition
  let a1 be Element of COMPLEX;
  redefine func - A1 -> Element of COMPLEX equals
    (- Re a1) + ((- Im a1) * <i>);
  involutiveness;
::  for a1 being Element of COMPLEX holds
::     - - a1 = a1;
end;

:: COMPLEX1:def 11
theorem
for b1 being Element of COMPLEX holds
   - b1 = (- Re b1) + ((- Im b1) * <i>);

:: COMPLEX1:th 34
theorem
for b1 being complex set holds
   Re - b1 = - Re b1 & Im - b1 = - Im b1;

:: COMPLEX1:th 37
theorem
<i> * <i> = - 1r;

:: COMPLEX1:funcnot 12 => COMPLEX1:func 11
definition
  let a1, a2 be Element of COMPLEX;
  redefine func A1 - A2 -> Element of COMPLEX equals
    ((Re a1) - Re a2) + (((Im a1) - Im a2) * <i>);
end;

:: COMPLEX1:def 12
theorem
for b1, b2 being Element of COMPLEX holds
b1 - b2 = ((Re b1) - Re b2) + (((Im b1) - Im b2) * <i>);

:: COMPLEX1:th 48
theorem
for b1, b2 being Element of COMPLEX holds
Re (b1 - b2) = (Re b1) - Re b2 &
 Im (b1 - b2) = (Im b1) - Im b2;

:: COMPLEX1:funcnot 13 => COMPLEX1:func 12
definition
  let a1 be Element of COMPLEX;
  redefine func A1 " -> Element of COMPLEX equals
    ((Re a1) / ((Re a1) ^2 + ((Im a1) ^2))) + (((- Im a1) / ((Re a1) ^2 + ((Im a1) ^2))) * <i>);
  involutiveness;
::  for a1 being Element of COMPLEX holds
::     a1 " " = a1;
end;

:: COMPLEX1:def 13
theorem
for b1 being Element of COMPLEX holds
   b1 " = ((Re b1) / ((Re b1) ^2 + ((Im b1) ^2))) + (((- Im b1) / ((Re b1) ^2 + ((Im b1) ^2))) * <i>);

:: COMPLEX1:th 64
theorem
for b1 being complex set holds
   Re (b1 ") = (Re b1) / ((Re b1) ^2 + ((Im b1) ^2)) &
    Im (b1 ") = (- Im b1) / ((Re b1) ^2 + ((Im b1) ^2));

:: COMPLEX1:th 72
theorem
<i> " = - <i>;

:: COMPLEX1:th 79
theorem
for b1 being Element of COMPLEX
      st Re b1 <> 0 & Im b1 = 0
   holds Re (b1 ") = (Re b1) " & Im (b1 ") = 0;

:: COMPLEX1:th 80
theorem
for b1 being Element of COMPLEX
      st Re b1 = 0 & Im b1 <> 0
   holds Re (b1 ") = 0 & Im (b1 ") = - ((Im b1) ");

:: COMPLEX1:funcnot 14 => COMPLEX1:func 13
definition
  let a1, a2 be Element of COMPLEX;
  redefine func A1 / A2 -> Element of COMPLEX equals
    ((((Re a1) * Re a2) + ((Im a1) * Im a2)) / ((Re a2) ^2 + ((Im a2) ^2))) + (((((Re a2) * Im a1) - ((Re a1) * Im a2)) / ((Re a2) ^2 + ((Im a2) ^2))) * <i>);
end;

:: COMPLEX1:def 14
theorem
for b1, b2 being Element of COMPLEX holds
b1 / b2 = ((((Re b1) * Re b2) + ((Im b1) * Im b2)) / ((Re b2) ^2 + ((Im b2) ^2))) + (((((Re b2) * Im b1) - ((Re b1) * Im b2)) / ((Re b2) ^2 + ((Im b2) ^2))) * <i>);

:: COMPLEX1:th 82
theorem
for b1, b2 being Element of COMPLEX holds
Re (b1 / b2) = (((Re b1) * Re b2) + ((Im b1) * Im b2)) / ((Re b2) ^2 + ((Im b2) ^2)) &
 Im (b1 / b2) = (((Re b2) * Im b1) - ((Re b1) * Im b2)) / ((Re b2) ^2 + ((Im b2) ^2));

:: COMPLEX1:th 109
theorem
for b1, b2 being Element of COMPLEX
      st Im b1 = 0 & Im b2 = 0 & Re b2 <> 0
   holds Re (b1 / b2) = (Re b1) / Re b2 &
    Im (b1 / b2) = 0;

:: COMPLEX1:th 110
theorem
for b1, b2 being Element of COMPLEX
      st Re b1 = 0 & Re b2 = 0 & Im b2 <> 0
   holds Re (b1 / b2) = (Im b1) / Im b2 &
    Im (b1 / b2) = 0;

:: COMPLEX1:funcnot 15 => COMPLEX1:func 14
definition
  let a1 be complex set;
  func A1 *' -> complex set equals
    (Re a1) - ((Im a1) * <i>);
  involutiveness;
::  for a1 being complex set holds
::     a1 *' *' = a1;
end;

:: COMPLEX1:def 15
theorem
for b1 being complex set holds
   b1 *' = (Re b1) - ((Im b1) * <i>);

:: COMPLEX1:funcnot 16 => COMPLEX1:func 15
definition
  let a1 be complex set;
  redefine func a1 *' -> Element of COMPLEX;
  involutiveness;
::  for a1 being complex set holds
::     a1 *' *' = a1;
end;

:: COMPLEX1:th 112
theorem
for b1 being complex set holds
   Re (b1 *') = Re b1 & Im (b1 *') = - Im b1;

:: COMPLEX1:th 113
theorem
0 *' = 0;

:: COMPLEX1:th 114
theorem
for b1 being complex set
      st b1 *' = 0
   holds b1 = 0;

:: COMPLEX1:th 115
theorem
1r *' = 1r;

:: COMPLEX1:th 116
theorem
<i> *' = - <i>;

:: COMPLEX1:th 118
theorem
for b1, b2 being complex set holds
(b1 + b2) *' = b1 *' + (b2 *');

:: COMPLEX1:th 119
theorem
for b1 being Element of COMPLEX holds
   (- b1) *' = - (b1 *');

:: COMPLEX1:th 120
theorem
for b1, b2 being Element of COMPLEX holds
(b1 - b2) *' = b1 *' - (b2 *');

:: COMPLEX1:th 121
theorem
for b1, b2 being Element of COMPLEX holds
(b1 * b2) *' = b1 *' * (b2 *');

:: COMPLEX1:th 122
theorem
for b1 being Element of COMPLEX holds
   b1 " *' = b1 *' ";

:: COMPLEX1:th 123
theorem
for b1, b2 being Element of COMPLEX holds
(b1 / b2) *' = b1 *' / (b2 *');

:: COMPLEX1:th 124
theorem
for b1 being Element of COMPLEX
      st Im b1 = 0
   holds b1 *' = b1;

:: COMPLEX1:th 125
theorem
for b1 being Element of COMPLEX
      st Re b1 = 0
   holds b1 *' = - b1;

:: COMPLEX1:th 126
theorem
for b1 being Element of COMPLEX holds
   Re (b1 * (b1 *')) = (Re b1) ^2 + ((Im b1) ^2) &
    Im (b1 * (b1 *')) = 0;

:: COMPLEX1:th 127
theorem
for b1 being Element of COMPLEX holds
   Re (b1 + (b1 *')) = 2 * Re b1 &
    Im (b1 + (b1 *')) = 0;

:: COMPLEX1:th 128
theorem
for b1 being Element of COMPLEX holds
   Re (b1 - (b1 *')) = 0 &
    Im (b1 - (b1 *')) = 2 * Im b1;

:: COMPLEX1:funcnot 17 => COMPLEX1:func 16
definition
  let a1 be complex set;
  func |.A1.| -> complex set equals
    sqrt ((Re a1) ^2 + ((Im a1) ^2));
  projectivity;
::  for a1 being complex set holds
::     |.|.a1.|.| = |.a1.|;
end;

:: COMPLEX1:def 16
theorem
for b1 being complex set holds
   |.b1.| = sqrt ((Re b1) ^2 + ((Im b1) ^2));

:: COMPLEX1:funcreg 4
registration
  let a1 be complex set;
  cluster |.a1.| -> complex real;
end;

:: COMPLEX1:funcnot 18 => COMPLEX1:func 17
definition
  let a1 be complex set;
  redefine func |.a1.| -> Element of REAL;
  projectivity;
::  for a1 being complex set holds
::     |.|.a1.|.| = |.a1.|;
end;

:: COMPLEX1:th 129
theorem
for b1 being real set
      st 0 <= b1
   holds |.b1.| = b1;

:: COMPLEX1:th 130
theorem
|.0.| = 0;

:: COMPLEX1:th 131
theorem
for b1 being complex set
      st |.b1.| = 0
   holds b1 = 0;

:: COMPLEX1:th 132
theorem
for b1 being complex set holds
   0 <= |.b1.|;

:: COMPLEX1:th 133
theorem
for b1 being complex set holds
      b1 <> 0
   iff
      0 < |.b1.|;

:: COMPLEX1:th 134
theorem
|.1r.| = 1;

:: COMPLEX1:th 135
theorem
|.<i>.| = 1;

:: COMPLEX1:th 136
theorem
for b1 being complex set
      st Im b1 = 0
   holds |.b1.| = |.Re b1.|;

:: COMPLEX1:th 137
theorem
for b1 being complex set
      st Re b1 = 0
   holds |.b1.| = |.Im b1.|;

:: COMPLEX1:th 138
theorem
for b1 being complex set holds
   |.- b1.| = |.b1.|;

:: COMPLEX1:th 139
theorem
for b1 being complex set holds
   |.b1 *'.| = |.b1.|;

:: COMPLEX1:th 140
theorem
for b1 being complex set holds
   Re b1 <= |.b1.|;

:: COMPLEX1:th 141
theorem
for b1 being complex set holds
   Im b1 <= |.b1.|;

:: COMPLEX1:th 142
theorem
for b1, b2 being complex set holds
|.b1 + b2.| <= |.b1.| + |.b2.|;

:: COMPLEX1:th 143
theorem
for b1, b2 being complex set holds
|.b1 - b2.| <= |.b1.| + |.b2.|;

:: COMPLEX1:th 144
theorem
for b1, b2 being complex set holds
|.b1.| - |.b2.| <= |.b1 + b2.|;

:: COMPLEX1:th 145
theorem
for b1, b2 being complex set holds
|.b1.| - |.b2.| <= |.b1 - b2.|;

:: COMPLEX1:th 146
theorem
for b1, b2 being complex set holds
|.b1 - b2.| = |.b2 - b1.|;

:: COMPLEX1:th 147
theorem
for b1, b2 being complex set holds
   |.b1 - b2.| = 0
iff
   b1 = b2;

:: COMPLEX1:th 148
theorem
for b1, b2 being complex set holds
   b1 <> b2
iff
   0 < |.b1 - b2.|;

:: COMPLEX1:th 149
theorem
for b1, b2, b3 being complex set holds
|.b2 - b3.| <= |.b2 - b1.| + |.b1 - b3.|;

:: COMPLEX1:th 150
theorem
for b1, b2 being complex set holds
|.|.b1.| - |.b2.|.| <= |.b1 - b2.|;

:: COMPLEX1:th 151
theorem
for b1, b2 being complex set holds
|.b1 * b2.| = |.b1.| * |.b2.|;

:: COMPLEX1:th 152
theorem
for b1 being complex set holds
   |.b1 ".| = |.b1.| ";

:: COMPLEX1:th 153
theorem
for b1, b2 being complex set holds
|.b1.| / |.b2.| = |.b1 / b2.|;

:: COMPLEX1:th 154
theorem
for b1 being complex set holds
   |.b1 * b1.| = (Re b1) ^2 + ((Im b1) ^2);

:: COMPLEX1:th 155
theorem
for b1 being complex set holds
   |.b1 * b1.| = |.b1 * (b1 *').|;

:: COMPLEX1:th 156
theorem
for b1 being real set
      st b1 <= 0
   holds |.b1.| = - b1;

:: COMPLEX1:th 157
theorem
for b1 being real set
      st |.b1.| <> b1
   holds |.b1.| = - b1;

:: COMPLEX1:th 158
theorem
for b1 being real set holds
   sqrt (b1 ^2) = |.b1.|;

:: COMPLEX1:th 159
theorem
for b1, b2 being real set holds
min(b1,b2) = ((b1 + b2) - |.b1 - b2.|) / 2;

:: COMPLEX1:th 160
theorem
for b1, b2 being real set holds
max(b1,b2) = ((b1 + b2) + |.b1 - b2.|) / 2;

:: COMPLEX1:th 161
theorem
for b1 being real set holds
   |.b1.| ^2 = b1 ^2;

:: COMPLEX1:th 162
theorem
for b1 being real set holds
   - |.b1.| <= b1 & b1 <= |.b1.|;

:: COMPLEX1:funcnot 19 => COMPLEX1:func 16
notation
  let a1 be complex set;
  synonym abs a1 for |.a1.|;
end;

:: COMPLEX1:funcnot 20 => COMPLEX1:func 18
definition
  let a1 be complex set;
  redefine func abs a1 -> Element of REAL;
  projectivity;
::  for a1 being complex set holds
::     abs abs a1 = abs a1;
end;

:: COMPLEX1:th 163
theorem
for b1, b2, b3, b4 being real set
      st b1 + (b2 * <i>) = b3 + (b4 * <i>)
   holds b1 = b3 & b2 = b4;

:: COMPLEX1:th 164
theorem
for b1, b2 being real set holds
sqrt (b1 ^2 + (b2 ^2)) <= (abs b1) + abs b2;

:: COMPLEX1:th 165
theorem
for b1, b2 being real set holds
abs b1 <= sqrt (b1 ^2 + (b2 ^2));