Article MIDSP_1, MML version 4.99.1005

:: MIDSP_1:structnot 1 => MIDSP_1:struct 1
definition
  struct(1-sorted) MidStr(#
    carrier -> set,
    MIDPOINT -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: MIDSP_1:attrnot 1 => MIDSP_1:attr 1
definition
  let a1 be MidStr;
  attr a1 is strict;
end;

:: MIDSP_1:exreg 1
registration
  cluster strict MidStr;
end;

:: MIDSP_1:aggrnot 1 => MIDSP_1:aggr 1
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr MidStr(#a1,a2#) -> strict MidStr;
end;

:: MIDSP_1:selnot 1 => MIDSP_1:sel 1
definition
  let a1 be MidStr;
  sel the MIDPOINT of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: MIDSP_1:exreg 2
registration
  cluster non empty MidStr;
end;

:: MIDSP_1:funcnot 1 => MIDSP_1:func 1
definition
  let a1 be non empty MidStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 @ A3 -> Element of the carrier of a1 equals
    (the MIDPOINT of a1) .(a2,a3);
end;

:: MIDSP_1:def 1
theorem
for b1 being non empty MidStr
for b2, b3 being Element of the carrier of b1 holds
b2 @ b3 = (the MIDPOINT of b1) .(b2,b3);

:: MIDSP_1:funcnot 2 => MIDSP_1:func 2
definition
  func Example -> MidStr equals
    MidStr(#1,op2#);
end;

:: MIDSP_1:def 3
theorem
Example = MidStr(#1,op2#);

:: MIDSP_1:funcreg 1
registration
  cluster Example -> non empty strict;
end;

:: MIDSP_1:th 5
theorem
the carrier of Example = 1;

:: MIDSP_1:th 6
theorem
the MIDPOINT of Example = op2;

:: MIDSP_1:th 8
theorem
for b1, b2 being Element of the carrier of Example holds
b1 @ b2 = op2 .(b1,b2);

:: MIDSP_1:th 10
theorem
for b1, b2, b3, b4 being Element of the carrier of Example holds
b1 @ b1 = b1 &
 b1 @ b2 = b2 @ b1 &
 (b1 @ b2) @ (b3 @ b4) = (b1 @ b3) @ (b2 @ b4) &
 (ex b5 being Element of the carrier of Example st
    b5 @ b1 = b2);

:: MIDSP_1:attrnot 2 => MIDSP_1:attr 2
definition
  let a1 be non empty MidStr;
  attr a1 is MidSp-like means
    for b1, b2, b3, b4 being Element of the carrier of a1 holds
    b1 @ b1 = b1 &
     b1 @ b2 = b2 @ b1 &
     (b1 @ b2) @ (b3 @ b4) = (b1 @ b3) @ (b2 @ b4) &
     (ex b5 being Element of the carrier of a1 st
        b5 @ b1 = b2);
end;

:: MIDSP_1:dfs 3
definiens
  let a1 be non empty MidStr;
To prove
     a1 is MidSp-like
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of the carrier of a1 holds
    b1 @ b1 = b1 &
     b1 @ b2 = b2 @ b1 &
     (b1 @ b2) @ (b3 @ b4) = (b1 @ b3) @ (b2 @ b4) &
     (ex b5 being Element of the carrier of a1 st
        b5 @ b1 = b2);

:: MIDSP_1:def 4
theorem
for b1 being non empty MidStr holds
      b1 is MidSp-like
   iff
      for b2, b3, b4, b5 being Element of the carrier of b1 holds
      b2 @ b2 = b2 &
       b2 @ b3 = b3 @ b2 &
       (b2 @ b3) @ (b4 @ b5) = (b2 @ b4) @ (b3 @ b5) &
       (ex b6 being Element of the carrier of b1 st
          b6 @ b2 = b3);

:: MIDSP_1:exreg 3
registration
  cluster non empty strict MidSp-like MidStr;
end;

:: MIDSP_1:modenot 1
definition
  mode MidSp is non empty MidSp-like MidStr;
end;

:: MIDSP_1:funcnot 3 => MIDSP_1:func 3
definition
  let a1 be non empty MidSp-like MidStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func a2 @ a3 -> Element of the carrier of a1;
  commutativity;
::  for a1 being non empty MidSp-like MidStr
::  for a2, a3 being Element of the carrier of a1 holds
::  a2 @ a3 = a3 @ a2;
end;

:: MIDSP_1:th 15
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 @ b3) @ b4 = (b2 @ b4) @ (b3 @ b4);

:: MIDSP_1:th 16
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 @ (b3 @ b4) = (b2 @ b3) @ (b2 @ b4);

:: MIDSP_1:th 17
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of the carrier of b1
      st b2 @ b3 = b2
   holds b2 = b3;

:: MIDSP_1:th 18
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 @ b3 = b4 @ b3
   holds b2 = b4;

:: MIDSP_1:th 19
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 @ b3 = b2 @ b4
   holds b3 = b4;

:: MIDSP_1:prednot 1 => MIDSP_1:pred 1
definition
  let a1 be non empty MidSp-like MidStr;
  let a2, a3, a4, a5 be Element of the carrier of a1;
  pred A2,A3 @@ A4,A5 means
    a2 @ a5 = a3 @ a4;
end;

:: MIDSP_1:dfs 4
definiens
  let a1 be non empty MidSp-like MidStr;
  let a2, a3, a4, a5 be Element of the carrier of a1;
To prove
     a2,a3 @@ a4,a5
it is sufficient to prove
  thus a2 @ a5 = a3 @ a4;

:: MIDSP_1:def 5
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1 holds
   b2,b3 @@ b4,b5
iff
   b2 @ b5 = b3 @ b4;

:: MIDSP_1:th 21
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of the carrier of b1 holds
b2,b2 @@ b3,b3;

:: MIDSP_1:th 22
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2,b3 @@ b4,b5
   holds b4,b5 @@ b2,b3;

:: MIDSP_1:th 23
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1
      st b2,b2 @@ b3,b4
   holds b3 = b4;

:: MIDSP_1:th 24
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1
      st b2,b3 @@ b4,b4
   holds b2 = b3;

:: MIDSP_1:th 25
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of the carrier of b1 holds
b2,b3 @@ b2,b3;

:: MIDSP_1:th 26
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1 holds
ex b5 being Element of the carrier of b1 st
   b2,b3 @@ b4,b5;

:: MIDSP_1:th 27
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5, b6 being Element of the carrier of b1
      st b2,b3 @@ b4,b5 & b2,b3 @@ b4,b6
   holds b5 = b6;

:: MIDSP_1:th 28
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5, b6, b7 being Element of the carrier of b1
      st b2,b3 @@ b4,b5 & b2,b3 @@ b6,b7
   holds b4,b5 @@ b6,b7;

:: MIDSP_1:th 29
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5, b6, b7 being Element of the carrier of b1
      st b2,b3 @@ b4,b5 & b3,b6 @@ b5,b7
   holds b2,b6 @@ b4,b7;

:: MIDSP_1:funcnot 4 => MIDSP_1:func 4
definition
  let a1 be non empty MidSp-like MidStr;
  let a2 be Element of [:the carrier of a1,the carrier of a1:];
  redefine func a2 `1 -> Element of the carrier of a1;
end;

:: MIDSP_1:funcnot 5 => MIDSP_1:func 5
definition
  let a1 be non empty MidSp-like MidStr;
  let a2 be Element of [:the carrier of a1,the carrier of a1:];
  redefine func a2 `2 -> Element of the carrier of a1;
end;

:: MIDSP_1:prednot 2 => MIDSP_1:pred 2
definition
  let a1 be non empty MidSp-like MidStr;
  let a2, a3 be Element of [:the carrier of a1,the carrier of a1:];
  pred A2 ## A3 means
    a2 `1,a2 `2 @@ a3 `1,a3 `2;
  symmetry;
::  for a1 being non empty MidSp-like MidStr
::  for a2, a3 being Element of [:the carrier of a1,the carrier of a1:]
::        st a2 ## a3
::     holds a3 ## a2;
  reflexivity;
::  for a1 being non empty MidSp-like MidStr
::  for a2 being Element of [:the carrier of a1,the carrier of a1:] holds
::     a2 ## a2;
end;

:: MIDSP_1:dfs 5
definiens
  let a1 be non empty MidSp-like MidStr;
  let a2, a3 be Element of [:the carrier of a1,the carrier of a1:];
To prove
     a2 ## a3
it is sufficient to prove
  thus a2 `1,a2 `2 @@ a3 `1,a3 `2;

:: MIDSP_1:def 6
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of [:the carrier of b1,the carrier of b1:] holds
   b2 ## b3
iff
   b2 `1,b2 `2 @@ b3 `1,b3 `2;

:: MIDSP_1:th 31
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2,b3 @@ b4,b5
   holds [b2,b3] ## [b4,b5];

:: MIDSP_1:th 32
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st [b2,b3] ## [b4,b5]
   holds b2,b3 @@ b4,b5;

:: MIDSP_1:th 35
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of [:the carrier of b1,the carrier of b1:]
      st b2 ## b3 & b2 ## b4
   holds b3 ## b4;

:: MIDSP_1:th 36
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of [:the carrier of b1,the carrier of b1:]
      st b2 ## b3 & b4 ## b3
   holds b2 ## b4;

:: MIDSP_1:th 37
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of [:the carrier of b1,the carrier of b1:]
      st b2 ## b3 & b3 ## b4
   holds b2 ## b4;

:: MIDSP_1:th 38
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of [:the carrier of b1,the carrier of b1:]
      st b2 ## b3
   holds    b4 ## b2
   iff
      b4 ## b3;

:: MIDSP_1:th 39
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of [:the carrier of b1,the carrier of b1:] holds
   {b3 where b3 is Element of [:the carrier of b1,the carrier of b1:]: b3 ## b2} is non empty Element of bool [:the carrier of b1,the carrier of b1:];

:: MIDSP_1:funcnot 6 => MIDSP_1:func 6
definition
  let a1 be non empty MidSp-like MidStr;
  let a2 be Element of [:the carrier of a1,the carrier of a1:];
  func A2 ~ -> Element of bool [:the carrier of a1,the carrier of a1:] equals
    {b1 where b1 is Element of [:the carrier of a1,the carrier of a1:]: b1 ## a2};
end;

:: MIDSP_1:def 7
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of [:the carrier of b1,the carrier of b1:] holds
   b2 ~ = {b3 where b3 is Element of [:the carrier of b1,the carrier of b1:]: b3 ## b2};

:: MIDSP_1:funcreg 2
registration
  let a1 be non empty MidSp-like MidStr;
  let a2 be Element of [:the carrier of a1,the carrier of a1:];
  cluster a2 ~ -> non empty;
end;

:: MIDSP_1:th 41
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of [:the carrier of b1,the carrier of b1:] holds
   b2 in b3 ~
iff
   b2 ## b3;

:: MIDSP_1:th 42
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of [:the carrier of b1,the carrier of b1:]
      st b2 ## b3
   holds b2 ~ = b3 ~;

:: MIDSP_1:th 43
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of [:the carrier of b1,the carrier of b1:]
      st b2 ~ = b3 ~
   holds b2 ## b3;

:: MIDSP_1:th 44
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st [b2,b3] ~ = [b4,b5] ~
   holds b2 @ b5 = b3 @ b4;

:: MIDSP_1:th 45
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of [:the carrier of b1,the carrier of b1:] holds
   b2 in b2 ~;

:: MIDSP_1:modenot 2 => MIDSP_1:mode 1
definition
  let a1 be non empty MidSp-like MidStr;
  mode Vector of A1 -> non empty Element of bool [:the carrier of a1,the carrier of a1:] means
    ex b1 being Element of [:the carrier of a1,the carrier of a1:] st
       it = b1 ~;
end;

:: MIDSP_1:dfs 7
definiens
  let a1 be non empty MidSp-like MidStr;
  let a2 be non empty Element of bool [:the carrier of a1,the carrier of a1:];
To prove
     a2 is Vector of a1
it is sufficient to prove
  thus ex b1 being Element of [:the carrier of a1,the carrier of a1:] st
       a2 = b1 ~;

:: MIDSP_1:def 8
theorem
for b1 being non empty MidSp-like MidStr
for b2 being non empty Element of bool [:the carrier of b1,the carrier of b1:] holds
      b2 is Vector of b1
   iff
      ex b3 being Element of [:the carrier of b1,the carrier of b1:] st
         b2 = b3 ~;

:: MIDSP_1:funcnot 7 => MIDSP_1:func 7
definition
  let a1 be non empty MidSp-like MidStr;
  let a2 be Element of [:the carrier of a1,the carrier of a1:];
  redefine func a2 ~ -> Vector of a1;
end;

:: MIDSP_1:th 48
theorem
for b1 being non empty MidSp-like MidStr holds
   ex b2 being Vector of b1 st
      for b3 being Element of [:the carrier of b1,the carrier of b1:] holds
            b3 in b2
         iff
            b3 `1 = b3 `2;

:: MIDSP_1:funcnot 8 => MIDSP_1:func 8
definition
  let a1 be non empty MidSp-like MidStr;
  func ID A1 -> Vector of a1 equals
    {b1 where b1 is Element of [:the carrier of a1,the carrier of a1:]: b1 `1 = b1 `2};
end;

:: MIDSP_1:def 9
theorem
for b1 being non empty MidSp-like MidStr holds
   ID b1 = {b2 where b2 is Element of [:the carrier of b1,the carrier of b1:]: b2 `1 = b2 `2};

:: MIDSP_1:th 50
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of the carrier of b1 holds
   ID b1 = [b2,b2] ~;

:: MIDSP_1:th 51
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Vector of b1 holds
ex b4 being Vector of b1 st
   ex b5, b6 being Element of [:the carrier of b1,the carrier of b1:] st
      b2 = b5 ~ &
       b3 = b6 ~ &
       b5 `2 = b6 `1 &
       b4 = [b5 `1,b6 `2] ~;

:: MIDSP_1:th 52
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Vector of b1
      st (ex b6, b7 being Element of [:the carrier of b1,the carrier of b1:] st
            b2 = b6 ~ &
             b3 = b7 ~ &
             b6 `2 = b7 `1 &
             b4 = [b6 `1,b7 `2] ~) &
         (ex b6, b7 being Element of [:the carrier of b1,the carrier of b1:] st
            b2 = b6 ~ &
             b3 = b7 ~ &
             b6 `2 = b7 `1 &
             b5 = [b6 `1,b7 `2] ~)
   holds b4 = b5;

:: MIDSP_1:funcnot 9 => MIDSP_1:func 9
definition
  let a1 be non empty MidSp-like MidStr;
  let a2, a3 be Vector of a1;
  func A2 + A3 -> Vector of a1 means
    ex b1, b2 being Element of [:the carrier of a1,the carrier of a1:] st
       a2 = b1 ~ &
        a3 = b2 ~ &
        b1 `2 = b2 `1 &
        it = [b1 `1,b2 `2] ~;
end;

:: MIDSP_1:def 10
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Vector of b1 holds
   b4 = b2 + b3
iff
   ex b5, b6 being Element of [:the carrier of b1,the carrier of b1:] st
      b2 = b5 ~ &
       b3 = b6 ~ &
       b5 `2 = b6 `1 &
       b4 = [b5 `1,b6 `2] ~;

:: MIDSP_1:th 53
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of the carrier of b1
for b3 being Vector of b1 holds
   ex b4 being Element of the carrier of b1 st
      b3 = [b2,b4] ~;

:: MIDSP_1:funcnot 10 => MIDSP_1:func 10
definition
  let a1 be non empty MidSp-like MidStr;
  let a2, a3 be Element of the carrier of a1;
  func vect(A2,A3) -> Vector of a1 equals
    [a2,a3] ~;
end;

:: MIDSP_1:def 11
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of the carrier of b1 holds
vect(b2,b3) = [b2,b3] ~;

:: MIDSP_1:th 55
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of the carrier of b1
for b3 being Vector of b1 holds
   ex b4 being Element of the carrier of b1 st
      b3 = vect(b2,b4);

:: MIDSP_1:th 56
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st [b2,b3] ## [b4,b5]
   holds vect(b2,b3) = vect(b4,b5);

:: MIDSP_1:th 57
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st vect(b2,b3) = vect(b4,b5)
   holds b2 @ b5 = b3 @ b4;

:: MIDSP_1:th 58
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of the carrier of b1 holds
   ID b1 = vect(b2,b2);

:: MIDSP_1:th 59
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1
      st vect(b2,b3) = vect(b2,b4)
   holds b3 = b4;

:: MIDSP_1:th 60
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of the carrier of b1 holds
(vect(b2,b3)) + vect(b3,b4) = vect(b2,b4);

:: MIDSP_1:th 61
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of the carrier of b1 holds
[b2,b2 @ b3] ## [b2 @ b3,b3];

:: MIDSP_1:th 62
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of the carrier of b1 holds
(vect(b2,b2 @ b3)) + vect(b2,b2 @ b3) = vect(b2,b3);

:: MIDSP_1:th 63
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Vector of b1 holds
(b2 + b3) + b4 = b2 + (b3 + b4);

:: MIDSP_1:th 64
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Vector of b1 holds
   b2 + ID b1 = b2;

:: MIDSP_1:th 65
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Vector of b1 holds
   ex b3 being Vector of b1 st
      b2 + b3 = ID b1;

:: MIDSP_1:th 66
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Vector of b1 holds
b2 + b3 = b3 + b2;

:: MIDSP_1:th 67
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Vector of b1
      st b2 + b3 = b2 + b4
   holds b3 = b4;

:: MIDSP_1:funcnot 11 => MIDSP_1:func 11
definition
  let a1 be non empty MidSp-like MidStr;
  let a2 be Vector of a1;
  func - A2 -> Vector of a1 means
    a2 + it = ID a1;
end;

:: MIDSP_1:def 12
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Vector of b1 holds
   b3 = - b2
iff
   b2 + b3 = ID b1;

:: MIDSP_1:funcnot 12 => MIDSP_1:func 12
definition
  let a1 be non empty MidSp-like MidStr;
  func setvect A1 -> set equals
    {b1 where b1 is Element of bool [:the carrier of a1,the carrier of a1:]: b1 is Vector of a1};
end;

:: MIDSP_1:def 13
theorem
for b1 being non empty MidSp-like MidStr holds
   setvect b1 = {b2 where b2 is Element of bool [:the carrier of b1,the carrier of b1:]: b2 is Vector of b1};

:: MIDSP_1:th 71
theorem
for b1 being non empty MidSp-like MidStr
for b2 being set holds
      b2 is Vector of b1
   iff
      b2 in setvect b1;

:: MIDSP_1:funcreg 3
registration
  let a1 be non empty MidSp-like MidStr;
  cluster setvect a1 -> non empty;
end;

:: MIDSP_1:funcnot 13 => MIDSP_1:func 13
definition
  let a1 be non empty MidSp-like MidStr;
  let a2, a3 be Element of setvect a1;
  func A2 + A3 -> Element of setvect a1 means
    for b1, b2 being Vector of a1
          st a2 = b1 & a3 = b2
       holds it = b1 + b2;
end;

:: MIDSP_1:def 14
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of setvect b1 holds
   b4 = b2 + b3
iff
   for b5, b6 being Vector of b1
         st b2 = b5 & b3 = b6
      holds b4 = b5 + b6;

:: MIDSP_1:th 74
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3 being Element of setvect b1 holds
b2 + b3 = b3 + b2;

:: MIDSP_1:th 75
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of setvect b1 holds
(b2 + b3) + b4 = b2 + (b3 + b4);

:: MIDSP_1:funcnot 14 => MIDSP_1:func 14
definition
  let a1 be non empty MidSp-like MidStr;
  func addvect A1 -> Function-like quasi_total Relation of [:setvect a1,setvect a1:],setvect a1 means
    for b1, b2 being Element of setvect a1 holds
    it .(b1,b2) = b1 + b2;
end;

:: MIDSP_1:def 15
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Function-like quasi_total Relation of [:setvect b1,setvect b1:],setvect b1 holds
      b2 = addvect b1
   iff
      for b3, b4 being Element of setvect b1 holds
      b2 .(b3,b4) = b3 + b4;

:: MIDSP_1:th 77
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Element of setvect b1 holds
   ex b3 being Element of setvect b1 st
      b2 + b3 = ID b1;

:: MIDSP_1:th 78
theorem
for b1 being non empty MidSp-like MidStr
for b2, b3, b4 being Element of setvect b1
      st b2 + b3 = ID b1 & b2 + b4 = ID b1
   holds b3 = b4;

:: MIDSP_1:funcnot 15 => MIDSP_1:func 15
definition
  let a1 be non empty MidSp-like MidStr;
  func complvect A1 -> Function-like quasi_total Relation of setvect a1,setvect a1 means
    for b1 being Element of setvect a1 holds
       b1 + (it . b1) = ID a1;
end;

:: MIDSP_1:def 16
theorem
for b1 being non empty MidSp-like MidStr
for b2 being Function-like quasi_total Relation of setvect b1,setvect b1 holds
      b2 = complvect b1
   iff
      for b3 being Element of setvect b1 holds
         b3 + (b2 . b3) = ID b1;

:: MIDSP_1:funcnot 16 => MIDSP_1:func 16
definition
  let a1 be non empty MidSp-like MidStr;
  func zerovect A1 -> Element of setvect a1 equals
    ID a1;
end;

:: MIDSP_1:def 17
theorem
for b1 being non empty MidSp-like MidStr holds
   zerovect b1 = ID b1;

:: MIDSP_1:funcnot 17 => MIDSP_1:func 17
definition
  let a1 be non empty MidSp-like MidStr;
  func vectgroup A1 -> addLoopStr equals
    addLoopStr(#setvect a1,addvect a1,zerovect a1#);
end;

:: MIDSP_1:def 18
theorem
for b1 being non empty MidSp-like MidStr holds
   vectgroup b1 = addLoopStr(#setvect b1,addvect b1,zerovect b1#);

:: MIDSP_1:funcreg 4
registration
  let a1 be non empty MidSp-like MidStr;
  cluster vectgroup a1 -> non empty strict;
end;

:: MIDSP_1:th 82
theorem
for b1 being non empty MidSp-like MidStr holds
   the carrier of vectgroup b1 = setvect b1;

:: MIDSP_1:th 83
theorem
for b1 being non empty MidSp-like MidStr holds
   the addF of vectgroup b1 = addvect b1;

:: MIDSP_1:th 85
theorem
for b1 being non empty MidSp-like MidStr holds
   0. vectgroup b1 = zerovect b1;

:: MIDSP_1:th 86
theorem
for b1 being non empty MidSp-like MidStr holds
   vectgroup b1 is add-associative & vectgroup b1 is right_zeroed & vectgroup b1 is right_complementable & vectgroup b1 is Abelian;