Article RLVECT_2, MML version 4.99.1005

:: RLVECT_2:funcnot 1 => RLVECT_2:func 1
definition
  let a1 be 1-sorted;
  let a2 be set;
  assume a2 in a1;
  func vector(A1,A2) -> Element of the carrier of a1 equals
    a2;
end;

:: RLVECT_2:def 1
theorem
for b1 being 1-sorted
for b2 being set
      st b2 in b1
   holds vector(b1,b2) = b2;

:: RLVECT_2:th 3
theorem
for b1 being non empty 1-sorted
for b2 being Element of the carrier of b1 holds
   vector(b1,b2) = b2;

:: RLVECT_2:th 4
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3, b4 being FinSequence of the carrier of b1
      st len b2 = len b3 &
         len b2 = len b4 &
         (for b5 being Element of NAT
               st b5 in dom b2
            holds b4 . b5 = (b2 /. b5) + (b3 /. b5))
   holds Sum b4 = (Sum b2) + Sum b3;

:: RLVECT_2:th 5
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of REAL
for b3, b4 being FinSequence of the carrier of b1
      st len b3 = len b4 &
         (for b5 being Element of NAT
               st b5 in dom b3
            holds b4 . b5 = b2 * (b3 /. b5))
   holds Sum b4 = b2 * Sum b3;

:: RLVECT_2:th 6
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being FinSequence of the carrier of b1
      st len b2 = len b3 &
         (for b4 being Element of NAT
               st b4 in dom b2
            holds b3 . b4 = - (b2 /. b4))
   holds Sum b3 = - Sum b2;

:: RLVECT_2:th 7
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3, b4 being FinSequence of the carrier of b1
      st len b2 = len b3 &
         len b2 = len b4 &
         (for b5 being Element of NAT
               st b5 in dom b2
            holds b4 . b5 = (b2 /. b5) - (b3 /. b5))
   holds Sum b4 = (Sum b2) - Sum b3;

:: RLVECT_2:th 8
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being FinSequence of the carrier of b1
for b4 being Function-like quasi_total bijective Relation of dom b2,dom b2
      st len b2 = len b3 &
         (for b5 being Element of NAT
               st b5 in dom b3
            holds b3 . b5 = b2 . (b4 . b5))
   holds Sum b2 = Sum b3;

:: RLVECT_2:th 9
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being FinSequence of the carrier of b1
for b4 being Function-like quasi_total bijective Relation of dom b2,dom b2
      st b3 = b2 * b4
   holds Sum b2 = Sum b3;

:: RLVECT_2:exreg 1
registration
  let a1 be 1-sorted;
  cluster empty finite Element of bool the carrier of a1;
end;

:: RLVECT_2:funcnot 2 => RLVECT_2:func 2
definition
  let a1 be non empty addLoopStr;
  let a2 be finite Element of bool the carrier of a1;
  assume a1 is Abelian & a1 is add-associative & a1 is right_zeroed;
  func Sum A2 -> Element of the carrier of a1 means
    ex b1 being FinSequence of the carrier of a1 st
       rng b1 = a2 & b1 is one-to-one & it = Sum b1;
end;

:: RLVECT_2:def 4
theorem
for b1 being non empty addLoopStr
for b2 being finite Element of bool the carrier of b1
   st b1 is Abelian & b1 is add-associative & b1 is right_zeroed
for b3 being Element of the carrier of b1 holds
      b3 = Sum b2
   iff
      ex b4 being FinSequence of the carrier of b1 st
         rng b4 = b2 & b4 is one-to-one & b3 = Sum b4;

:: RLVECT_2:exreg 2
registration
  let a1 be non empty 1-sorted;
  cluster non empty finite Element of bool the carrier of a1;
end;

:: RLVECT_2:th 14
theorem
for b1 being non empty Abelian add-associative right_zeroed addLoopStr holds
   Sum {} b1 = 0. b1;

:: RLVECT_2:th 15
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2 being Element of the carrier of b1 holds
   Sum {b2} = b2;

:: RLVECT_2:th 16
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 <> b3
   holds Sum {b2,b3} = b2 + b3;

:: RLVECT_2:th 17
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 <> b3 & b3 <> b4 & b2 <> b4
   holds Sum {b2,b3,b4} = (b2 + b3) + b4;

:: RLVECT_2:th 18
theorem
for b1 being non empty Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1
      st b3 misses b2
   holds Sum (b3 \/ b2) = (Sum b3) + Sum b2;

:: RLVECT_2:th 19
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1 holds
Sum (b3 \/ b2) = ((Sum b3) + Sum b2) - Sum (b3 /\ b2);

:: RLVECT_2:th 20
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1 holds
Sum (b3 /\ b2) = ((Sum b3) + Sum b2) - Sum (b3 \/ b2);

:: RLVECT_2:th 21
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1 holds
Sum (b3 \ b2) = (Sum (b3 \/ b2)) - Sum b2;

:: RLVECT_2:th 22
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1 holds
Sum (b3 \ b2) = (Sum b3) - Sum (b3 /\ b2);

:: RLVECT_2:th 23
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1 holds
Sum (b3 \+\ b2) = (Sum (b3 \/ b2)) - Sum (b3 /\ b2);

:: RLVECT_2:th 24
theorem
for b1 being non empty Abelian add-associative right_zeroed addLoopStr
for b2, b3 being finite Element of bool the carrier of b1 holds
Sum (b3 \+\ b2) = (Sum (b3 \ b2)) + Sum (b2 \ b3);

:: RLVECT_2:modenot 1 => RLVECT_2:mode 1
definition
  let a1 be non empty ZeroStr;
  mode Linear_Combination of A1 -> Element of Funcs(the carrier of a1,REAL) means
    ex b1 being finite Element of bool the carrier of a1 st
       for b2 being Element of the carrier of a1
             st not b2 in b1
          holds it . b2 = 0;
end;

:: RLVECT_2:dfs 3
definiens
  let a1 be non empty ZeroStr;
  let a2 be Element of Funcs(the carrier of a1,REAL);
To prove
     a2 is Linear_Combination of a1
it is sufficient to prove
  thus ex b1 being finite Element of bool the carrier of a1 st
       for b2 being Element of the carrier of a1
             st not b2 in b1
          holds a2 . b2 = 0;

:: RLVECT_2:def 5
theorem
for b1 being non empty ZeroStr
for b2 being Element of Funcs(the carrier of b1,REAL) holds
      b2 is Linear_Combination of b1
   iff
      ex b3 being finite Element of bool the carrier of b1 st
         for b4 being Element of the carrier of b1
               st not b4 in b3
            holds b2 . b4 = 0;

:: RLVECT_2:funcnot 3 => RLVECT_2:func 3
definition
  let a1 be non empty addLoopStr;
  let a2 be Linear_Combination of a1;
  func Carrier A2 -> finite Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: a2 . b1 <> 0};
end;

:: RLVECT_2:def 6
theorem
for b1 being non empty addLoopStr
for b2 being Linear_Combination of b1 holds
   Carrier b2 = {b3 where b3 is Element of the carrier of b1: b2 . b3 <> 0};

:: RLVECT_2:th 28
theorem
for b1 being non empty addLoopStr
for b2 being Linear_Combination of b1
for b3 being Element of the carrier of b1 holds
      b2 . b3 = 0
   iff
      not b3 in Carrier b2;

:: RLVECT_2:funcnot 4 => RLVECT_2:func 4
definition
  let a1 be non empty addLoopStr;
  func ZeroLC A1 -> Linear_Combination of a1 means
    Carrier it = {};
end;

:: RLVECT_2:def 7
theorem
for b1 being non empty addLoopStr
for b2 being Linear_Combination of b1 holds
      b2 = ZeroLC b1
   iff
      Carrier b2 = {};

:: RLVECT_2:th 30
theorem
for b1 being non empty addLoopStr
for b2 being Element of the carrier of b1 holds
   (ZeroLC b1) . b2 = 0;

:: RLVECT_2:modenot 2 => RLVECT_2:mode 2
definition
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
  mode Linear_Combination of A2 -> Linear_Combination of a1 means
    Carrier it c= a2;
end;

:: RLVECT_2:dfs 6
definiens
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
  let a3 be Linear_Combination of a1;
To prove
     a3 is Linear_Combination of a2
it is sufficient to prove
  thus Carrier a3 c= a2;

:: RLVECT_2:def 8
theorem
for b1 being non empty addLoopStr
for b2 being Element of bool the carrier of b1
for b3 being Linear_Combination of b1 holds
      b3 is Linear_Combination of b2
   iff
      Carrier b3 c= b2;

:: RLVECT_2:th 33
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Element of bool the carrier of b1
for b4 being Linear_Combination of b2
      st b2 c= b3
   holds b4 is Linear_Combination of b3;

:: RLVECT_2:th 34
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of bool the carrier of b1 holds
   ZeroLC b1 is Linear_Combination of b2;

:: RLVECT_2:th 35
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of {} the carrier of b1 holds
   b2 = ZeroLC b1;

:: RLVECT_2:funcnot 5 => RLVECT_2:func 5
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be FinSequence of the carrier of a1;
  let a3 be Function-like quasi_total Relation of the carrier of a1,REAL;
  func A3 (#) A2 -> FinSequence of the carrier of a1 means
    len it = len a2 &
     (for b1 being Element of NAT
           st b1 in dom it
        holds it . b1 = (a3 . (a2 /. b1)) * (a2 /. b1));
end;

:: RLVECT_2:def 9
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being FinSequence of the carrier of b1
for b3 being Function-like quasi_total Relation of the carrier of b1,REAL
for b4 being FinSequence of the carrier of b1 holds
      b4 = b3 (#) b2
   iff
      len b4 = len b2 &
       (for b5 being Element of NAT
             st b5 in dom b4
          holds b4 . b5 = (b3 . (b2 /. b5)) * (b2 /. b5));

:: RLVECT_2:th 40
theorem
for b1 being Element of NAT
for b2 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b3 being Element of the carrier of b2
for b4 being FinSequence of the carrier of b2
for b5 being Function-like quasi_total Relation of the carrier of b2,REAL
      st b1 in dom b4 & b3 = b4 . b1
   holds (b5 (#) b4) . b1 = (b5 . b3) * b3;

:: RLVECT_2:th 41
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   b2 (#) <*> the carrier of b1 = <*> the carrier of b1;

:: RLVECT_2:th 42
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of the carrier of b1
for b3 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   b3 (#) <*b2*> = <*(b3 . b2) * b2*>;

:: RLVECT_2:th 43
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Element of the carrier of b1
for b4 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   b4 (#) <*b2,b3*> = <*(b4 . b2) * b2,(b4 . b3) * b3*>;

:: RLVECT_2:th 44
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3, b4 being Element of the carrier of b1
for b5 being Function-like quasi_total Relation of the carrier of b1,REAL holds
   b5 (#) <*b2,b3,b4*> = <*(b5 . b2) * b2,(b5 . b3) * b3,(b5 . b4) * b4*>;

:: RLVECT_2:funcnot 6 => RLVECT_2:func 6
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be Linear_Combination of a1;
  func Sum A2 -> Element of the carrier of a1 means
    ex b1 being FinSequence of the carrier of a1 st
       b1 is one-to-one & rng b1 = Carrier a2 & it = Sum (a2 (#) b1);
end;

:: RLVECT_2:def 10
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1
for b3 being Element of the carrier of b1 holds
      b3 = Sum b2
   iff
      ex b4 being FinSequence of the carrier of b1 st
         b4 is one-to-one & rng b4 = Carrier b2 & b3 = Sum (b2 (#) b4);

:: RLVECT_2:th 47
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of bool the carrier of b1 holds
      b2 <> {} & b2 is linearly-closed(b1)
   iff
      for b3 being Linear_Combination of b2 holds
         Sum b3 in b2;

:: RLVECT_2:th 48
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct holds
   Sum ZeroLC b1 = 0. b1;

:: RLVECT_2:th 49
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of {} the carrier of b1 holds
   Sum b2 = 0. b1;

:: RLVECT_2:th 50
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of the carrier of b1
for b3 being Linear_Combination of {b2} holds
   Sum b3 = (b3 . b2) * b2;

:: RLVECT_2:th 51
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Element of the carrier of b1
   st b2 <> b3
for b4 being Linear_Combination of {b2,b3} holds
   Sum b4 = ((b4 . b2) * b2) + ((b4 . b3) * b3);

:: RLVECT_2:th 52
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1
      st Carrier b2 = {}
   holds Sum b2 = 0. b1;

:: RLVECT_2:th 53
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of the carrier of b1
for b3 being Linear_Combination of b1
      st Carrier b3 = {b2}
   holds Sum b3 = (b3 . b2) * b2;

:: RLVECT_2:th 54
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Element of the carrier of b1
for b4 being Linear_Combination of b1
      st Carrier b4 = {b2,b3} & b2 <> b3
   holds Sum b4 = ((b4 . b2) * b2) + ((b4 . b3) * b3);

:: RLVECT_2:prednot 1 => RLVECT_2:pred 1
definition
  let a1 be non empty addLoopStr;
  let a2, a3 be Linear_Combination of a1;
  redefine pred A2 = A3 means
    for b1 being Element of the carrier of a1 holds
       a2 . b1 = a3 . b1;
  symmetry;
::  for a1 being non empty addLoopStr
::  for a2, a3 being Linear_Combination of a1
::        st a2 = a3
::     holds a3 = a2;
  reflexivity;
::  for a1 being non empty addLoopStr
::  for a2 being Linear_Combination of a1 holds
::     a2 = a2;
end;

:: RLVECT_2:dfs 9
definiens
  let a1 be non empty addLoopStr;
  let a2, a3 be Linear_Combination of a1;
To prove
     a2 = a3
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       a2 . b1 = a3 . b1;

:: RLVECT_2:def 11
theorem
for b1 being non empty addLoopStr
for b2, b3 being Linear_Combination of b1 holds
   b2 = b3
iff
   for b4 being Element of the carrier of b1 holds
      b2 . b4 = b3 . b4;

:: RLVECT_2:funcnot 7 => RLVECT_2:func 7
definition
  let a1 be non empty addLoopStr;
  let a2, a3 be Linear_Combination of a1;
  redefine func A2 + A3 -> Linear_Combination of a1 means
    for b1 being Element of the carrier of a1 holds
       it . b1 = (a2 . b1) + (a3 . b1);
  commutativity;
::  for a1 being non empty addLoopStr
::  for a2, a3 being Linear_Combination of a1 holds
::  a2 + a3 = a3 + a2;
end;

:: RLVECT_2:def 12
theorem
for b1 being non empty addLoopStr
for b2, b3, b4 being Linear_Combination of b1 holds
   b4 = b2 + b3
iff
   for b5 being Element of the carrier of b1 holds
      b4 . b5 = (b2 . b5) + (b3 . b5);

:: RLVECT_2:th 58
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Linear_Combination of b1 holds
Carrier (b2 + b3) c= (Carrier b2) \/ Carrier b3;

:: RLVECT_2:th 59
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of bool the carrier of b1
for b3, b4 being Linear_Combination of b1
      st b3 is Linear_Combination of b2 & b4 is Linear_Combination of b2
   holds b3 + b4 is Linear_Combination of b2;

:: RLVECT_2:th 60
theorem
for b1 being non empty addLoopStr
for b2, b3 being Linear_Combination of b1 holds
b2 + b3 = b3 + b2;

:: RLVECT_2:th 61
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3, b4 being Linear_Combination of b1 holds
b2 + (b3 + b4) = (b2 + b3) + b4;

:: RLVECT_2:th 62
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   b2 + ZeroLC b1 = b2 & (ZeroLC b1) + b2 = b2;

:: RLVECT_2:funcnot 8 => RLVECT_2:func 8
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be Element of REAL;
  let a3 be Linear_Combination of a1;
  func A2 * A3 -> Linear_Combination of a1 means
    for b1 being Element of the carrier of a1 holds
       it . b1 = a2 * (a3 . b1);
end;

:: RLVECT_2:def 13
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of REAL
for b3, b4 being Linear_Combination of b1 holds
   b4 = b2 * b3
iff
   for b5 being Element of the carrier of b1 holds
      b4 . b5 = b2 * (b3 . b5);

:: RLVECT_2:th 65
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of REAL
for b3 being Linear_Combination of b1
      st b2 <> 0
   holds Carrier (b2 * b3) = Carrier b3;

:: RLVECT_2:th 66
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   0 * b2 = ZeroLC b1;

:: RLVECT_2:th 67
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of REAL
for b3 being Element of bool the carrier of b1
for b4 being Linear_Combination of b1
      st b4 is Linear_Combination of b3
   holds b2 * b4 is Linear_Combination of b3;

:: RLVECT_2:th 68
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Element of REAL
for b4 being Linear_Combination of b1 holds
   (b2 + b3) * b4 = (b2 * b4) + (b3 * b4);

:: RLVECT_2:th 69
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of REAL
for b3, b4 being Linear_Combination of b1 holds
b2 * (b3 + b4) = (b2 * b3) + (b2 * b4);

:: RLVECT_2:th 70
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Element of REAL
for b4 being Linear_Combination of b1 holds
   b2 * (b3 * b4) = (b2 * b3) * b4;

:: RLVECT_2:th 71
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   1 * b2 = b2;

:: RLVECT_2:funcnot 9 => RLVECT_2:func 9
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be Linear_Combination of a1;
  func - A2 -> Linear_Combination of a1 equals
    (- 1) * a2;
end;

:: RLVECT_2:def 14
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   - b2 = (- 1) * b2;

:: RLVECT_2:th 73
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of the carrier of b1
for b3 being Linear_Combination of b1 holds
   (- b3) . b2 = - (b3 . b2);

:: RLVECT_2:th 74
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Linear_Combination of b1
      st b2 + b3 = ZeroLC b1
   holds b3 = - b2;

:: RLVECT_2:th 75
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   Carrier - b2 = Carrier b2;

:: RLVECT_2:th 76
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of bool the carrier of b1
for b3 being Linear_Combination of b1
      st b3 is Linear_Combination of b2
   holds - b3 is Linear_Combination of b2;

:: RLVECT_2:th 77
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   - - b2 = b2;

:: RLVECT_2:funcnot 10 => RLVECT_2:func 10
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2, a3 be Linear_Combination of a1;
  func A2 - A3 -> Linear_Combination of a1 equals
    a2 + - a3;
end;

:: RLVECT_2:def 15
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Linear_Combination of b1 holds
b2 - b3 = b2 + - b3;

:: RLVECT_2:th 79
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of the carrier of b1
for b3, b4 being Linear_Combination of b1 holds
(b3 - b4) . b2 = (b3 . b2) - (b4 . b2);

:: RLVECT_2:th 80
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Linear_Combination of b1 holds
Carrier (b2 - b3) c= (Carrier b2) \/ Carrier b3;

:: RLVECT_2:th 81
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of bool the carrier of b1
for b3, b4 being Linear_Combination of b1
      st b3 is Linear_Combination of b2 & b4 is Linear_Combination of b2
   holds b3 - b4 is Linear_Combination of b2;

:: RLVECT_2:th 82
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   b2 - b2 = ZeroLC b1;

:: RLVECT_2:funcnot 11 => RLVECT_2:func 11
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  func LinComb A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is Linear_Combination of a1;
end;

:: RLVECT_2:def 16
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being set holds
      b2 = LinComb b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            b3 is Linear_Combination of b1;

:: RLVECT_2:funcreg 1
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  cluster LinComb a1 -> non empty;
end;

:: RLVECT_2:funcnot 12 => RLVECT_2:func 12
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be Element of LinComb a1;
  func @ A2 -> Linear_Combination of a1 equals
    a2;
end;

:: RLVECT_2:def 17
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of LinComb b1 holds
   @ b2 = b2;

:: RLVECT_2:funcnot 13 => RLVECT_2:func 13
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be Linear_Combination of a1;
  func @ A2 -> Element of LinComb a1 equals
    a2;
end;

:: RLVECT_2:def 18
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   @ b2 = b2;

:: RLVECT_2:funcnot 14 => RLVECT_2:func 14
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  func LCAdd A1 -> Function-like quasi_total Relation of [:LinComb a1,LinComb a1:],LinComb a1 means
    for b1, b2 being Element of LinComb a1 holds
    it .(b1,b2) = (@ b1) + @ b2;
end;

:: RLVECT_2:def 19
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Function-like quasi_total Relation of [:LinComb b1,LinComb b1:],LinComb b1 holds
      b2 = LCAdd b1
   iff
      for b3, b4 being Element of LinComb b1 holds
      b2 .(b3,b4) = (@ b3) + @ b4;

:: RLVECT_2:funcnot 15 => RLVECT_2:func 15
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  func LCMult A1 -> Function-like quasi_total Relation of [:REAL,LinComb a1:],LinComb a1 means
    for b1 being Element of REAL
    for b2 being Element of LinComb a1 holds
       it . [b1,b2] = b1 * @ b2;
end;

:: RLVECT_2:def 20
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Function-like quasi_total Relation of [:REAL,LinComb b1:],LinComb b1 holds
      b2 = LCMult b1
   iff
      for b3 being Element of REAL
      for b4 being Element of LinComb b1 holds
         b2 . [b3,b4] = b3 * @ b4;

:: RLVECT_2:funcnot 16 => RLVECT_2:func 16
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  func LC_RLSpace A1 -> RLSStruct equals
    RLSStruct(#LinComb a1,@ ZeroLC a1,LCAdd a1,LCMult a1#);
end;

:: RLVECT_2:def 21
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct holds
   LC_RLSpace b1 = RLSStruct(#LinComb b1,@ ZeroLC b1,LCAdd b1,LCMult b1#);

:: RLVECT_2:funcreg 2
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  cluster LC_RLSpace a1 -> non empty strict;
end;

:: RLVECT_2:funcreg 3
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  cluster LC_RLSpace a1 -> right_complementable Abelian add-associative right_zeroed RealLinearSpace-like;
end;

:: RLVECT_2:th 92
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct holds
   the carrier of LC_RLSpace b1 = LinComb b1;

:: RLVECT_2:th 93
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct holds
   0. LC_RLSpace b1 = ZeroLC b1;

:: RLVECT_2:th 94
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct holds
   the addF of LC_RLSpace b1 = LCAdd b1;

:: RLVECT_2:th 95
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct holds
   the Mult of LC_RLSpace b1 = LCMult b1;

:: RLVECT_2:th 96
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Linear_Combination of b1 holds
(vector(LC_RLSpace b1,b2)) + vector(LC_RLSpace b1,b3) = b2 + b3;

:: RLVECT_2:th 97
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of REAL
for b3 being Linear_Combination of b1 holds
   b2 * vector(LC_RLSpace b1,b3) = b2 * b3;

:: RLVECT_2:th 98
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Linear_Combination of b1 holds
   - vector(LC_RLSpace b1,b2) = - b2;

:: RLVECT_2:th 99
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2, b3 being Linear_Combination of b1 holds
(vector(LC_RLSpace b1,b2)) - vector(LC_RLSpace b1,b3) = b2 - b3;

:: RLVECT_2:funcnot 17 => RLVECT_2:func 17
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;
  let a2 be Element of bool the carrier of a1;
  func LC_RLSpace A2 -> strict Subspace of LC_RLSpace a1 means
    the carrier of it = {b1 where b1 is Linear_Combination of a2: TRUE};
end;

:: RLVECT_2:def 22
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct
for b2 being Element of bool the carrier of b1
for b3 being strict Subspace of LC_RLSpace b1 holds
      b3 = LC_RLSpace b2
   iff
      the carrier of b3 = {b4 where b4 is Linear_Combination of b2: TRUE};