Article HAHNBAN1, MML version 4.99.1005

:: HAHNBAN1:th 1
theorem
for b1 being complex set holds
   abs |.b1.| = |.b1.|;

:: HAHNBAN1:th 2
theorem
for b1, b2, b3, b4 being real set holds
(b1 + (b2 * <i>)) * (b3 + (b4 * <i>)) = ((b1 * b3) - (b2 * b4)) + (((b1 * b4) + (b3 * b2)) * <i>);

:: HAHNBAN1:th 3
theorem
for b1 being Element of REAL holds
   [*b1,0*] * <i> = [*0,b1*];

:: HAHNBAN1:th 4
theorem
for b1 being Element of REAL holds
   |.[*b1,0*].| = abs b1;

:: HAHNBAN1:th 5
theorem
for b1 being Element of COMPLEX holds
   |.b1.| + (0 * <i>) = (b1 *' / (|.b1.| + (0 * <i>))) * b1;

:: HAHNBAN1:funcnot 1 => HAHNBAN1:func 1
definition
  let a1, a2 be real set;
  func [**A1,A2**] -> Element of the carrier of F_Complex equals
    a1 + (a2 * <i>);
end;

:: HAHNBAN1:def 1
theorem
for b1, b2 being real set holds
[**b1,b2**] = b1 + (b2 * <i>);

:: HAHNBAN1:funcnot 2 => HAHNBAN1:func 2
definition
  func i_FC -> Element of the carrier of F_Complex equals
    <i>;
end;

:: HAHNBAN1:def 2
theorem
i_FC = <i>;

:: HAHNBAN1:th 6
theorem
i_FC = [*0,1*] & i_FC = [**0,1**];

:: HAHNBAN1:th 8
theorem
i_FC * i_FC = - 1_ F_Complex;

:: HAHNBAN1:th 9
theorem
(- 1_ F_Complex) * - 1_ F_Complex = 1_ F_Complex;

:: HAHNBAN1:th 10
theorem
for b1, b2, b3, b4 being Element of REAL holds
[**b1,b2**] + [**b3,b4**] = [**b1 + b3,b2 + b4**];

:: HAHNBAN1:th 11
theorem
for b1, b2, b3, b4 being real set holds
[**b1,b2**] * [**b3,b4**] = [**(b1 * b3) - (b2 * b4),(b1 * b4) + (b3 * b2)**];

:: HAHNBAN1:th 12
theorem
for b1 being complex set holds
   abs |.b1.| = |.b1.|;

:: HAHNBAN1:th 13
theorem
for b1 being Element of REAL holds
   |.[**b1,0**].| = abs b1;

:: HAHNBAN1:th 16
theorem
for b1, b2 being Element of the carrier of F_Complex holds
Re (b1 + b2) = (Re b1) + Re b2 &
 Im (b1 + b2) = (Im b1) + Im b2;

:: HAHNBAN1:th 17
theorem
for b1, b2 being Element of the carrier of F_Complex holds
Re (b1 * b2) = ((Re b1) * Re b2) - ((Im b1) * Im b2) &
 Im (b1 * b2) = ((Re b1) * Im b2) + ((Re b2) * Im b1);

:: HAHNBAN1:modenot 1
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  mode Functional of a2 is Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
end;

:: HAHNBAN1:funcnot 3 => HAHNBAN1:func 3
definition
  let a1 be non empty addLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3, a4 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  func A3 + A4 -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1 means
    for b1 being Element of the carrier of a2 holds
       it . b1 = (a3 . b1) + (a4 . b1);
end;

:: HAHNBAN1:def 6
theorem
for b1 being non empty addLoopStr
for b2 being non empty VectSpStr over b1
for b3, b4, b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   b5 = b3 + b4
iff
   for b6 being Element of the carrier of b2 holds
      b5 . b6 = (b3 . b6) + (b4 . b6);

:: HAHNBAN1:funcnot 4 => HAHNBAN1:func 4
definition
  let a1 be non empty addLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  func - A3 -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1 means
    for b1 being Element of the carrier of a2 holds
       it . b1 = - (a3 . b1);
end;

:: HAHNBAN1:def 7
theorem
for b1 being non empty addLoopStr
for b2 being non empty VectSpStr over b1
for b3, b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   b4 = - b3
iff
   for b5 being Element of the carrier of b2 holds
      b4 . b5 = - (b3 . b5);

:: HAHNBAN1:funcnot 5 => HAHNBAN1:func 5
definition
  let a1 be non empty addLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3, a4 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  func A3 - A4 -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1 equals
    a3 + - a4;
end;

:: HAHNBAN1:def 8
theorem
for b1 being non empty addLoopStr
for b2 being non empty VectSpStr over b1
for b3, b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
b3 - b4 = b3 + - b4;

:: HAHNBAN1:funcnot 6 => HAHNBAN1:func 6
definition
  let a1 be non empty multMagma;
  let a2 be non empty VectSpStr over a1;
  let a3 be Element of the carrier of a1;
  let a4 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  func A3 * A4 -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1 means
    for b1 being Element of the carrier of a2 holds
       it . b1 = a3 * (a4 . b1);
end;

:: HAHNBAN1:def 9
theorem
for b1 being non empty multMagma
for b2 being non empty VectSpStr over b1
for b3 being Element of the carrier of b1
for b4, b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   b5 = b3 * b4
iff
   for b6 being Element of the carrier of b2 holds
      b5 . b6 = b3 * (b4 . b6);

:: HAHNBAN1:funcnot 7 => HAHNBAN1:func 7
definition
  let a1 be non empty ZeroStr;
  let a2 be VectSpStr over a1;
  func 0Functional A2 -> Function-like quasi_total Relation of the carrier of a2,the carrier of a1 equals
    ([#] a2) --> 0. a1;
end;

:: HAHNBAN1:def 10
theorem
for b1 being non empty ZeroStr
for b2 being VectSpStr over b1 holds
   0Functional b2 = ([#] b2) --> 0. b1;

:: HAHNBAN1:attrnot 1 => HAHNBAN1:attr 1
definition
  let a1 be non empty addLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  attr a3 is additive means
    for b1, b2 being Element of the carrier of a2 holds
    a3 . (b1 + b2) = (a3 . b1) + (a3 . b2);
end;

:: HAHNBAN1:dfs 8
definiens
  let a1 be non empty addLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
To prove
     a3 is additive
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a2 holds
    a3 . (b1 + b2) = (a3 . b1) + (a3 . b2);

:: HAHNBAN1:def 11
theorem
for b1 being non empty addLoopStr
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
      b3 is additive(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b2 holds
      b3 . (b4 + b5) = (b3 . b4) + (b3 . b5);

:: HAHNBAN1:attrnot 2 => HAHNBAN1:attr 2
definition
  let a1 be non empty multMagma;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  attr a3 is homogeneous means
    for b1 being Element of the carrier of a2
    for b2 being Element of the carrier of a1 holds
       a3 . (b2 * b1) = b2 * (a3 . b1);
end;

:: HAHNBAN1:dfs 9
definiens
  let a1 be non empty multMagma;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
To prove
     a3 is homogeneous
it is sufficient to prove
  thus for b1 being Element of the carrier of a2
    for b2 being Element of the carrier of a1 holds
       a3 . (b2 * b1) = b2 * (a3 . b1);

:: HAHNBAN1:def 12
theorem
for b1 being non empty multMagma
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
      b3 is homogeneous(b1, b2)
   iff
      for b4 being Element of the carrier of b2
      for b5 being Element of the carrier of b1 holds
         b3 . (b5 * b4) = b5 * (b3 . b4);

:: HAHNBAN1:attrnot 3 => HAHNBAN1:attr 3
definition
  let a1 be non empty ZeroStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
  attr a3 is 0-preserving means
    a3 . 0. a2 = 0. a1;
end;

:: HAHNBAN1:dfs 10
definiens
  let a1 be non empty ZeroStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,the carrier of a1;
To prove
     a3 is 0-preserving
it is sufficient to prove
  thus a3 . 0. a2 = 0. a1;

:: HAHNBAN1:def 13
theorem
for b1 being non empty ZeroStr
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
      b3 is 0-preserving(b1, b2)
   iff
      b3 . 0. b2 = 0. b1;

:: HAHNBAN1:condreg 1
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  let a2 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over a1;
  cluster Function-like quasi_total homogeneous -> 0-preserving (Relation of the carrier of a2,the carrier of a1);
end;

:: HAHNBAN1:funcreg 1
registration
  let a1 be non empty right_zeroed addLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster 0Functional a2 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 2
registration
  let a1 be non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster 0Functional a2 -> Function-like quasi_total homogeneous;
end;

:: HAHNBAN1:funcreg 3
registration
  let a1 be non empty ZeroStr;
  let a2 be non empty VectSpStr over a1;
  cluster 0Functional a2 -> Function-like quasi_total 0-preserving;
end;

:: HAHNBAN1:exreg 1
registration
  let a1 be non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster Relation-like Function-like quasi_total additive homogeneous 0-preserving Relation of the carrier of a2,the carrier of a1;
end;

:: HAHNBAN1:th 20
theorem
for b1 being non empty Abelian addLoopStr
for b2 being non empty VectSpStr over b1
for b3, b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
b3 + b4 = b4 + b3;

:: HAHNBAN1:th 21
theorem
for b1 being non empty add-associative addLoopStr
for b2 being non empty VectSpStr over b1
for b3, b4, b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
(b3 + b4) + b5 = b3 + (b4 + b5);

:: HAHNBAN1:th 22
theorem
for b1 being non empty ZeroStr
for b2 being non empty VectSpStr over b1
for b3 being Element of the carrier of b2 holds
   (0Functional b2) . b3 = 0. b1;

:: HAHNBAN1:th 23
theorem
for b1 being non empty right_zeroed addLoopStr
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   b3 + 0Functional b2 = b3;

:: HAHNBAN1:th 24
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   b3 - b3 = 0Functional b2;

:: HAHNBAN1:th 25
theorem
for b1 being non empty right-distributive doubleLoopStr
for b2 being non empty VectSpStr over b1
for b3 being Element of the carrier of b1
for b4, b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
b3 * (b4 + b5) = (b3 * b4) + (b3 * b5);

:: HAHNBAN1:th 26
theorem
for b1 being non empty left-distributive doubleLoopStr
for b2 being non empty VectSpStr over b1
for b3, b4 being Element of the carrier of b1
for b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   (b3 + b4) * b5 = (b3 * b5) + (b4 * b5);

:: HAHNBAN1:th 27
theorem
for b1 being non empty associative multMagma
for b2 being non empty VectSpStr over b1
for b3, b4 being Element of the carrier of b1
for b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   (b3 * b4) * b5 = b3 * (b4 * b5);

:: HAHNBAN1:th 28
theorem
for b1 being non empty left_unital doubleLoopStr
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,the carrier of b1 holds
   (1. b1) * b3 = b3;

:: HAHNBAN1:funcreg 4
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3, a4 be Function-like quasi_total additive Relation of the carrier of a2,the carrier of a1;
  cluster a3 + a4 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 5
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total additive Relation of the carrier of a2,the carrier of a1;
  cluster - a3 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 6
registration
  let a1 be non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Element of the carrier of a1;
  let a4 be Function-like quasi_total additive Relation of the carrier of a2,the carrier of a1;
  cluster a3 * a4 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 7
registration
  let a1 be non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3, a4 be Function-like quasi_total homogeneous Relation of the carrier of a2,the carrier of a1;
  cluster a3 + a4 -> Function-like quasi_total homogeneous;
end;

:: HAHNBAN1:funcreg 8
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total homogeneous Relation of the carrier of a2,the carrier of a1;
  cluster - a3 -> Function-like quasi_total homogeneous;
end;

:: HAHNBAN1:funcreg 9
registration
  let a1 be non empty right_complementable add-associative right_zeroed associative commutative right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  let a3 be Element of the carrier of a1;
  let a4 be Function-like quasi_total homogeneous Relation of the carrier of a2,the carrier of a1;
  cluster a3 * a4 -> Function-like quasi_total homogeneous;
end;

:: HAHNBAN1:modenot 2
definition
  let a1 be non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  mode linear-Functional of a2 is Function-like quasi_total additive homogeneous Relation of the carrier of a2,the carrier of a1;
end;

:: HAHNBAN1:funcnot 8 => HAHNBAN1:func 8
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative commutative right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  func A2 *' -> non empty strict VectSpStr over a1 means
    (for b1 being set holds
           b1 in the carrier of it
        iff
           b1 is Function-like quasi_total additive homogeneous Relation of the carrier of a2,the carrier of a1) &
     (for b1, b2 being Function-like quasi_total additive homogeneous Relation of the carrier of a2,the carrier of a1 holds
     (the addF of it) .(b1,b2) = b1 + b2) &
     0. it = 0Functional a2 &
     (for b1 being Function-like quasi_total additive homogeneous Relation of the carrier of a2,the carrier of a1
     for b2 being Element of the carrier of a1 holds
        (the lmult of it) .(b2,b1) = b2 * b1);
end;

:: HAHNBAN1:def 14
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative commutative right-distributive doubleLoopStr
for b2 being non empty VectSpStr over b1
for b3 being non empty strict VectSpStr over b1 holds
      b3 = b2 *'
   iff
      (for b4 being set holds
             b4 in the carrier of b3
          iff
             b4 is Function-like quasi_total additive homogeneous Relation of the carrier of b2,the carrier of b1) &
       (for b4, b5 being Function-like quasi_total additive homogeneous Relation of the carrier of b2,the carrier of b1 holds
       (the addF of b3) .(b4,b5) = b4 + b5) &
       0. b3 = 0Functional b2 &
       (for b4 being Function-like quasi_total additive homogeneous Relation of the carrier of b2,the carrier of b1
       for b5 being Element of the carrier of b1 holds
          (the lmult of b3) .(b5,b4) = b5 * b4);

:: HAHNBAN1:funcreg 10
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative commutative right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster a2 *' -> non empty Abelian strict;
end;

:: HAHNBAN1:funcreg 11
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative commutative right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster a2 *' -> non empty add-associative strict;
end;

:: HAHNBAN1:funcreg 12
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative commutative right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster a2 *' -> non empty right_zeroed strict;
end;

:: HAHNBAN1:funcreg 13
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative commutative right-distributive doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster a2 *' -> non empty right_complementable strict;
end;

:: HAHNBAN1:funcreg 14
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative commutative distributive left_unital doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  cluster a2 *' -> non empty strict VectSp-like;
end;

:: HAHNBAN1:modenot 3
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  mode RFunctional of a2 is Function-like quasi_total Relation of the carrier of a2,REAL;
end;

:: HAHNBAN1:attrnot 4 => HAHNBAN1:attr 4
definition
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,REAL;
  attr a3 is subadditive means
    for b1, b2 being Element of the carrier of a2 holds
    a3 . (b1 + b2) <= (a3 . b1) + (a3 . b2);
end;

:: HAHNBAN1:dfs 12
definiens
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,REAL;
To prove
     a3 is subadditive
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a2 holds
    a3 . (b1 + b2) <= (a3 . b1) + (a3 . b2);

:: HAHNBAN1:def 16
theorem
for b1 being 1-sorted
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,REAL holds
      b3 is subadditive(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b2 holds
      b3 . (b4 + b5) <= (b3 . b4) + (b3 . b5);

:: HAHNBAN1:attrnot 5 => HAHNBAN1:attr 5
definition
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,REAL;
  attr a3 is additive means
    for b1, b2 being Element of the carrier of a2 holds
    a3 . (b1 + b2) = (a3 . b1) + (a3 . b2);
end;

:: HAHNBAN1:dfs 13
definiens
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,REAL;
To prove
     a3 is additive
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a2 holds
    a3 . (b1 + b2) = (a3 . b1) + (a3 . b2);

:: HAHNBAN1:def 17
theorem
for b1 being 1-sorted
for b2 being non empty VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,REAL holds
      b3 is additive(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b2 holds
      b3 . (b4 + b5) = (b3 . b4) + (b3 . b5);

:: HAHNBAN1:attrnot 6 => HAHNBAN1:attr 6
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
  attr a2 is Real_homogeneous means
    for b1 being Element of the carrier of a1
    for b2 being Element of REAL holds
       a2 . ([**b2,0**] * b1) = b2 * (a2 . b1);
end;

:: HAHNBAN1:dfs 14
definiens
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
To prove
     a2 is Real_homogeneous
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Element of REAL holds
       a2 . ([**b2,0**] * b1) = b2 * (a2 . b1);

:: HAHNBAN1:def 18
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL holds
      b2 is Real_homogeneous(b1)
   iff
      for b3 being Element of the carrier of b1
      for b4 being Element of REAL holds
         b2 . ([**b4,0**] * b3) = b4 * (b2 . b3);

:: HAHNBAN1:th 29
theorem
for b1 being non empty VectSp-like VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL
   st b2 is Real_homogeneous(b1)
for b3 being Element of the carrier of b1
for b4 being Element of REAL holds
   b2 . ([**0,b4**] * b3) = b4 * (b2 . (i_FC * b3));

:: HAHNBAN1:attrnot 7 => HAHNBAN1:attr 7
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
  attr a2 is homogeneous means
    for b1 being Element of the carrier of a1
    for b2 being Element of the carrier of F_Complex holds
       a2 . (b2 * b1) = |.b2.| * (a2 . b1);
end;

:: HAHNBAN1:dfs 15
definiens
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
To prove
     a2 is homogeneous
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Element of the carrier of F_Complex holds
       a2 . (b2 * b1) = |.b2.| * (a2 . b1);

:: HAHNBAN1:def 19
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL holds
      b2 is homogeneous(b1)
   iff
      for b3 being Element of the carrier of b1
      for b4 being Element of the carrier of F_Complex holds
         b2 . (b4 * b3) = |.b4.| * (b2 . b3);

:: HAHNBAN1:attrnot 8 => HAHNBAN1:attr 8
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,REAL;
  attr a3 is 0-preserving means
    a3 . 0. a2 = 0;
end;

:: HAHNBAN1:dfs 16
definiens
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  let a3 be Function-like quasi_total Relation of the carrier of a2,REAL;
To prove
     a3 is 0-preserving
it is sufficient to prove
  thus a3 . 0. a2 = 0;

:: HAHNBAN1:def 20
theorem
for b1 being 1-sorted
for b2 being VectSpStr over b1
for b3 being Function-like quasi_total Relation of the carrier of b2,REAL holds
      b3 is 0-preserving(b1, b2)
   iff
      b3 . 0. b2 = 0;

:: HAHNBAN1:condreg 2
registration
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  cluster Function-like quasi_total additive -> subadditive (Relation of the carrier of a2,REAL);
end;

:: HAHNBAN1:condreg 3
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex;
  cluster Function-like quasi_total Real_homogeneous -> 0-preserving (Relation of the carrier of a1,REAL);
end;

:: HAHNBAN1:funcnot 9 => HAHNBAN1:func 9
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  func 0RFunctional A2 -> Function-like quasi_total Relation of the carrier of a2,REAL equals
    ([#] a2) --> 0;
end;

:: HAHNBAN1:def 21
theorem
for b1 being 1-sorted
for b2 being VectSpStr over b1 holds
   0RFunctional b2 = ([#] b2) --> 0;

:: HAHNBAN1:funcreg 15
registration
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  cluster 0RFunctional a2 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 16
registration
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  cluster 0RFunctional a2 -> Function-like quasi_total 0-preserving;
end;

:: HAHNBAN1:funcreg 17
registration
  let a1 be non empty VectSpStr over F_Complex;
  cluster 0RFunctional a1 -> Function-like quasi_total Real_homogeneous;
end;

:: HAHNBAN1:funcreg 18
registration
  let a1 be non empty VectSpStr over F_Complex;
  cluster 0RFunctional a1 -> Function-like quasi_total homogeneous;
end;

:: HAHNBAN1:exreg 2
registration
  let a1 be 1-sorted;
  let a2 be non empty VectSpStr over a1;
  cluster Relation-like Function-like quasi_total additive 0-preserving Relation of the carrier of a2,REAL;
end;

:: HAHNBAN1:exreg 3
registration
  let a1 be non empty VectSpStr over F_Complex;
  cluster Relation-like Function-like quasi_total additive Real_homogeneous homogeneous Relation of the carrier of a1,REAL;
end;

:: HAHNBAN1:modenot 4
definition
  let a1 be non empty VectSpStr over F_Complex;
  mode Semi-Norm of a1 is Function-like quasi_total subadditive homogeneous Relation of the carrier of a1,REAL;
end;

:: HAHNBAN1:funcnot 10 => HAHNBAN1:func 10
definition
  let a1 be non empty VectSpStr over F_Complex;
  func RealVS A1 -> strict RLSStruct means
    addLoopStr(#the carrier of it,the addF of it,the ZeroF of it#) = addLoopStr(#the carrier of a1,the addF of a1,the ZeroF of a1#) &
     (for b1 being Element of REAL
     for b2 being Element of the carrier of a1 holds
        (the Mult of it) .(b1,b2) = [**b1,0**] * b2);
end;

:: HAHNBAN1:def 22
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being strict RLSStruct holds
      b2 = RealVS b1
   iff
      addLoopStr(#the carrier of b2,the addF of b2,the ZeroF of b2#) = addLoopStr(#the carrier of b1,the addF of b1,the ZeroF of b1#) &
       (for b3 being Element of REAL
       for b4 being Element of the carrier of b1 holds
          (the Mult of b2) .(b3,b4) = [**b3,0**] * b4);

:: HAHNBAN1:funcreg 19
registration
  let a1 be non empty VectSpStr over F_Complex;
  cluster RealVS a1 -> non empty strict;
end;

:: HAHNBAN1:funcreg 20
registration
  let a1 be non empty Abelian VectSpStr over F_Complex;
  cluster RealVS a1 -> strict Abelian;
end;

:: HAHNBAN1:funcreg 21
registration
  let a1 be non empty add-associative VectSpStr over F_Complex;
  cluster RealVS a1 -> strict add-associative;
end;

:: HAHNBAN1:funcreg 22
registration
  let a1 be non empty right_zeroed VectSpStr over F_Complex;
  cluster RealVS a1 -> strict right_zeroed;
end;

:: HAHNBAN1:funcreg 23
registration
  let a1 be non empty right_complementable VectSpStr over F_Complex;
  cluster RealVS a1 -> right_complementable strict;
end;

:: HAHNBAN1:funcreg 24
registration
  let a1 be non empty VectSp-like VectSpStr over F_Complex;
  cluster RealVS a1 -> strict RealLinearSpace-like;
end;

:: HAHNBAN1:th 30
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex
for b2 being Subspace of b1 holds
   RealVS b2 is Subspace of RealVS b1;

:: HAHNBAN1:th 31
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   b2 is Function-like quasi_total Relation of the carrier of RealVS b1,REAL;

:: HAHNBAN1:th 32
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex
for b2 being Function-like quasi_total subadditive homogeneous Relation of the carrier of b1,REAL holds
   b2 is Function-like quasi_total subadditive positively_homogeneous Relation of the carrier of RealVS b1,REAL;

:: HAHNBAN1:funcnot 11 => HAHNBAN1:func 11
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of F_Complex;
  func projRe A2 -> Function-like quasi_total Relation of the carrier of RealVS a1,REAL means
    for b1 being Element of the carrier of a1 holds
       it . b1 = Re (a2 . b1);
end;

:: HAHNBAN1:def 23
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of F_Complex
for b3 being Function-like quasi_total Relation of the carrier of RealVS b1,REAL holds
      b3 = projRe b2
   iff
      for b4 being Element of the carrier of b1 holds
         b3 . b4 = Re (b2 . b4);

:: HAHNBAN1:funcnot 12 => HAHNBAN1:func 12
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of F_Complex;
  func projIm A2 -> Function-like quasi_total Relation of the carrier of RealVS a1,REAL means
    for b1 being Element of the carrier of a1 holds
       it . b1 = Im (a2 . b1);
end;

:: HAHNBAN1:def 24
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of F_Complex
for b3 being Function-like quasi_total Relation of the carrier of RealVS b1,REAL holds
      b3 = projIm b2
   iff
      for b4 being Element of the carrier of b1 holds
         b3 . b4 = Im (b2 . b4);

:: HAHNBAN1:funcnot 13 => HAHNBAN1:func 13
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of RealVS a1,REAL;
  func RtoC A2 -> Function-like quasi_total Relation of the carrier of a1,REAL equals
    a2;
end;

:: HAHNBAN1:def 25
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of RealVS b1,REAL holds
   RtoC b2 = b2;

:: HAHNBAN1:funcnot 14 => HAHNBAN1:func 14
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
  func CtoR A2 -> Function-like quasi_total Relation of the carrier of RealVS a1,REAL equals
    a2;
end;

:: HAHNBAN1:def 26
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   CtoR b2 = b2;

:: HAHNBAN1:funcreg 25
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex;
  let a2 be Function-like quasi_total additive Relation of the carrier of RealVS a1,REAL;
  cluster RtoC a2 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 26
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex;
  let a2 be Function-like quasi_total additive Relation of the carrier of a1,REAL;
  cluster CtoR a2 -> Function-like quasi_total additive;
end;

:: HAHNBAN1:funcreg 27
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex;
  let a2 be Function-like quasi_total homogeneous Relation of the carrier of RealVS a1,REAL;
  cluster RtoC a2 -> Function-like quasi_total Real_homogeneous;
end;

:: HAHNBAN1:funcreg 28
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Real_homogeneous Relation of the carrier of a1,REAL;
  cluster CtoR a2 -> Function-like quasi_total homogeneous;
end;

:: HAHNBAN1:funcnot 15 => HAHNBAN1:func 15
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
  func i-shift A2 -> Function-like quasi_total Relation of the carrier of a1,REAL means
    for b1 being Element of the carrier of a1 holds
       it . b1 = a2 . (i_FC * b1);
end;

:: HAHNBAN1:def 27
theorem
for b1 being non empty VectSpStr over F_Complex
for b2, b3 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   b3 = i-shift b2
iff
   for b4 being Element of the carrier of b1 holds
      b3 . b4 = b2 . (i_FC * b4);

:: HAHNBAN1:funcnot 16 => HAHNBAN1:func 16
definition
  let a1 be non empty VectSpStr over F_Complex;
  let a2 be Function-like quasi_total Relation of the carrier of RealVS a1,REAL;
  func prodReIm A2 -> Function-like quasi_total Relation of the carrier of a1,the carrier of F_Complex means
    for b1 being Element of the carrier of a1 holds
       it . b1 = [**(RtoC a2) . b1,- ((i-shift RtoC a2) . b1)**];
end;

:: HAHNBAN1:def 28
theorem
for b1 being non empty VectSpStr over F_Complex
for b2 being Function-like quasi_total Relation of the carrier of RealVS b1,REAL
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of F_Complex holds
      b3 = prodReIm b2
   iff
      for b4 being Element of the carrier of b1 holds
         b3 . b4 = [**(RtoC b2) . b4,- ((i-shift RtoC b2) . b4)**];

:: HAHNBAN1:th 33
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex
for b2 being Function-like quasi_total additive homogeneous Relation of the carrier of b1,the carrier of F_Complex holds
   projRe b2 is Function-like quasi_total additive homogeneous Relation of the carrier of RealVS b1,REAL;

:: HAHNBAN1:th 34
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex
for b2 being Function-like quasi_total additive homogeneous Relation of the carrier of b1,the carrier of F_Complex holds
   projIm b2 is Function-like quasi_total additive homogeneous Relation of the carrier of RealVS b1,REAL;

:: HAHNBAN1:th 35
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex
for b2 being Function-like quasi_total additive homogeneous Relation of the carrier of RealVS b1,REAL holds
   prodReIm b2 is Function-like quasi_total additive homogeneous Relation of the carrier of b1,the carrier of F_Complex;

:: HAHNBAN1:th 36
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over F_Complex
for b2 being Function-like quasi_total subadditive homogeneous Relation of the carrier of b1,REAL
for b3 being Subspace of b1
for b4 being Function-like quasi_total additive homogeneous Relation of the carrier of b3,the carrier of F_Complex
      st for b5 being Element of the carrier of b3
        for b6 being Element of the carrier of b1
              st b6 = b5
           holds |.b4 . b5.| <= b2 . b6
   holds ex b5 being Function-like quasi_total additive homogeneous Relation of the carrier of b1,the carrier of F_Complex st
      b5 | the carrier of b3 = b4 &
       (for b6 being Element of the carrier of b1 holds
          |.b5 . b6.| <= b2 . b6);

:: HAHNBAN1:th 37
theorem
for b1 being Element of REAL
   st 0 < b1
for b2 being Element of NAT holds
   (power F_Complex) .([**b1,0**],b2) = [**b1 to_power b2,0**];