Article MIDSP_3, MML version 4.99.1005

:: MIDSP_3:th 1
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being FinSequence of b3
      st len b4 = (b1 + 1) + b2
   holds ex b5, b6 being FinSequence of b3 st
      ex b7 being Element of b3 st
         len b5 = b1 & len b6 = b2 & b4 = (b5 ^ <*b7*>) ^ b6;

:: MIDSP_3:th 2
theorem
for b1, b2 being Element of NAT
      st b1 in Seg b2
   holds ex b3, b4 being Element of NAT st
      b2 = (b3 + 1) + b4 & b1 = b3 + 1;

:: MIDSP_3:th 3
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being Element of b2
for b4, b5, b6 being FinSequence of b2
      st b4 = (b5 ^ <*b3*>) ^ b6 & b1 = (len b5) + 1
   holds (for b7 being Element of NAT
          st 1 <= b7 & b7 <= len b5
       holds b4 . b7 = b5 . b7) &
    b4 . b1 = b3 &
    (for b7 being Element of NAT
          st b1 + 1 <= b7 & b7 <= len b4
       holds b4 . b7 = b6 . (b7 - b1));

:: MIDSP_3:th 4
theorem
for b1, b2 being Element of NAT
      st b2 < b1 & b1 <> b2 + 1
   holds b2 + 2 <= b1;

:: MIDSP_3:th 5
theorem
for b1, b2, b3, b4 being Element of NAT
      st b1 in (Seg b2) \ {b3} & b3 = b4 + 1 & (1 <= b1 implies b4 < b1)
   holds b3 + 1 <= b1 & b1 <= b2;

:: MIDSP_3:funcnot 1 => MIDSP_3:func 1
definition
  let a1 be non empty set;
  let a2 be Element of NAT;
  let a3 be Element of a2 -tuples_on a1;
  let a4 be Element of NAT;
  let a5 be Element of a1;
  redefine func a3 +*(a4,a5) -> Element of a2 -tuples_on a1;
end;

:: MIDSP_3:structnot 1 => MIDSP_3:struct 1
definition
  let a1 be Element of NAT;
  struct(MidStr) ReperAlgebraStr(#
    carrier -> set,
    MIDPOINT -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    reper -> Function-like quasi_total Relation of A1 -tuples_on the carrier of it,the carrier of it
  #);
end;

:: MIDSP_3:attrnot 1 => MIDSP_3:attr 1
definition
  let a1 be Element of NAT;
  let a2 be ReperAlgebraStr over a1;
  attr a2 is strict;
end;

:: MIDSP_3:exreg 1
registration
  let a1 be Element of NAT;
  cluster strict ReperAlgebraStr over a1;
end;

:: MIDSP_3:aggrnot 1 => MIDSP_3:aggr 1
definition
  let a1 be Element of NAT;
  let a2 be set;
  let a3 be Function-like quasi_total Relation of [:a2,a2:],a2;
  let a4 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  aggr ReperAlgebraStr(#a2,a3,a4#) -> strict ReperAlgebraStr over a1;
end;

:: MIDSP_3:selnot 1 => MIDSP_3:sel 1
definition
  let a1 be Element of NAT;
  let a2 be ReperAlgebraStr over a1;
  sel the reper of a2 -> Function-like quasi_total Relation of a1 -tuples_on the carrier of a2,the carrier of a2;
end;

:: MIDSP_3:funcreg 1
registration
  let a1 be Element of NAT;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:a2,a2:],a2;
  let a4 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  cluster ReperAlgebraStr(#a2,a3,a4#) -> non empty strict;
end;

:: MIDSP_3:exreg 2
registration
  let a1 be Element of NAT;
  cluster non empty ReperAlgebraStr over a1;
end;

:: MIDSP_3:exreg 3
registration
  let a1 be Element of NAT;
  cluster non empty MidSp-like ReperAlgebraStr over a1 + 2;
end;

:: MIDSP_3:modenot 1
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be Element of NAT;
  mode Tuple of a3,a2 is Element of a3 -tuples_on the carrier of a2;
end;

:: MIDSP_3:funcnot 2 => MIDSP_3:func 2
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be Element of the carrier of a2;
  redefine func <*a3*> -> Element of 1 -tuples_on the carrier of a2;
end;

:: MIDSP_3:funcnot 3 => MIDSP_3:func 3
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3, a4 be Element of NAT;
  let a5 be Element of a3 -tuples_on the carrier of a2;
  let a6 be Element of a4 -tuples_on the carrier of a2;
  redefine func a5 ^ a6 -> Element of (a3 + a4) -tuples_on the carrier of a2;
end;

:: MIDSP_3:funcnot 4 => MIDSP_3:func 4
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be Element of the carrier of a2;
  let a4 be Element of (a1 + 1) -tuples_on the carrier of a2;
  func *'(A3,A4) -> Element of the carrier of a2 equals
    (the reper of a2) . (<*a3*> ^ a4);
end;

:: MIDSP_3:def 2
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being Element of the carrier of b2
for b4 being Element of (b1 + 1) -tuples_on the carrier of b2 holds
   *'(b3,b4) = (the reper of b2) . (<*b3*> ^ b4);

:: MIDSP_3:th 7
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b2 + 2
for b4 being Element of the carrier of b3
for b5 being Element of (b2 + 1) -tuples_on the carrier of b3
      st b1 in Seg (b2 + 1)
   holds (b5 +*(b1,b4)) . b1 = b4 &
    (for b6 being Element of NAT
          st b6 in (dom b5) \ {b1}
       holds (b5 +*(b1,b4)) . b6 = b5 . b6);

:: MIDSP_3:modenot 2 => MIDSP_3:mode 1
definition
  let a1 be Element of NAT;
  mode Nat of A1 -> Element of NAT means
    1 <= it & it <= a1 + 1;
end;

:: MIDSP_3:dfs 2
definiens
  let a1, a2 be Element of NAT;
To prove
     a2 is Nat of a1
it is sufficient to prove
  thus 1 <= a2 & a2 <= a1 + 1;

:: MIDSP_3:def 4
theorem
for b1, b2 being Element of NAT holds
   b2 is Nat of b1
iff
   1 <= b2 & b2 <= b1 + 1;

:: MIDSP_3:th 8
theorem
for b1, b2 being Element of NAT holds
   b1 is Nat of b2
iff
   b1 in Seg (b2 + 1);

:: MIDSP_3:th 10
theorem
for b1, b2 being Element of NAT
      st b1 <= b2
   holds b1 + 1 is Nat of b2;

:: MIDSP_3:th 11
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3, b4 being Element of (b1 + 1) -tuples_on the carrier of b2
      st for b5 being Nat of b1 holds
           b3 . b5 = b4 . b5
   holds b3 = b4;

:: MIDSP_3:th 12
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b4 being Element of the carrier of b3
for b5 being Element of (b1 + 1) -tuples_on the carrier of b3
for b6 being Nat of b1
      st b6 = b2
   holds (b5 +*(b2,b4)) . b6 = b4;

:: MIDSP_3:funcnot 5 => MIDSP_3:func 5
definition
  let a1 be Element of NAT;
  let a2 be non empty set;
  let a3 be Element of (a1 + 1) -tuples_on a2;
  let a4 be Nat of a1;
  redefine func a3 . a4 -> Element of a2;
end;

:: MIDSP_3:attrnot 2 => MIDSP_3:attr 2
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  attr a2 is being_invariance means
    for b1, b2 being Element of the carrier of a2
    for b3, b4 being Element of (a1 + 1) -tuples_on the carrier of a2
          st for b5 being Nat of a1 holds
               b1 @ (b4 . b5) = b2 @ (b3 . b5)
       holds b1 @ *'(b2,b4) = b2 @ *'(b1,b3);
end;

:: MIDSP_3:dfs 3
definiens
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
To prove
     a2 is being_invariance
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a2
    for b3, b4 being Element of (a1 + 1) -tuples_on the carrier of a2
          st for b5 being Nat of a1 holds
               b1 @ (b4 . b5) = b2 @ (b3 . b5)
       holds b1 @ *'(b2,b4) = b2 @ *'(b1,b3);

:: MIDSP_3:def 5
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2 holds
      b2 is being_invariance(b1)
   iff
      for b3, b4 being Element of the carrier of b2
      for b5, b6 being Element of (b1 + 1) -tuples_on the carrier of b2
            st for b7 being Nat of b1 holds
                 b3 @ (b6 . b7) = b4 @ (b5 . b7)
         holds b3 @ *'(b4,b6) = b4 @ *'(b3,b5);

:: MIDSP_3:prednot 1 => MIDSP_3:attr 2
notation
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  synonym a2 is_invariance for being_invariance;
end;

:: MIDSP_3:prednot 2 => MIDSP_3:pred 1
definition
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  pred A3 has_property_of_zero_in A2 means
    for b1 being Element of the carrier of a3
    for b2 being Element of (a1 + 1) -tuples_on the carrier of a3 holds
       *'(b1,b2 +*(a2,b1)) = b1;
end;

:: MIDSP_3:dfs 4
definiens
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
To prove
     a3 has_property_of_zero_in a2
it is sufficient to prove
  thus for b1 being Element of the carrier of a3
    for b2 being Element of (a1 + 1) -tuples_on the carrier of a3 holds
       *'(b1,b2 +*(a2,b1)) = b1;

:: MIDSP_3:def 6
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b1 + 2 holds
      b3 has_property_of_zero_in b2
   iff
      for b4 being Element of the carrier of b3
      for b5 being Element of (b1 + 1) -tuples_on the carrier of b3 holds
         *'(b4,b5 +*(b2,b4)) = b4;

:: MIDSP_3:prednot 3 => MIDSP_3:pred 2
definition
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  pred A3 is_semi_additive_in A2 means
    for b1, b2 being Element of the carrier of a3
    for b3 being Element of (a1 + 1) -tuples_on the carrier of a3
          st b3 . a2 = b2
       holds *'(b1,b3 +*(a2,b1 @ b2)) = b1 @ *'(b1,b3);
end;

:: MIDSP_3:dfs 5
definiens
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
To prove
     a3 is_semi_additive_in a2
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a3
    for b3 being Element of (a1 + 1) -tuples_on the carrier of a3
          st b3 . a2 = b2
       holds *'(b1,b3 +*(a2,b1 @ b2)) = b1 @ *'(b1,b3);

:: MIDSP_3:def 7
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b1 + 2 holds
      b3 is_semi_additive_in b2
   iff
      for b4, b5 being Element of the carrier of b3
      for b6 being Element of (b1 + 1) -tuples_on the carrier of b3
            st b6 . b2 = b5
         holds *'(b4,b6 +*(b2,b4 @ b5)) = b4 @ *'(b4,b6);

:: MIDSP_3:th 13
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being Nat of b1
   st b2 is_semi_additive_in b3
for b4, b5 being Element of the carrier of b2
for b6, b7 being Element of (b1 + 1) -tuples_on the carrier of b2
      st b7 = b6 +*(b3,b5)
   holds *'(b4,b6 +*(b3,b4 @ b5)) = b4 @ *'(b4,b7);

:: MIDSP_3:prednot 4 => MIDSP_3:pred 3
definition
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  pred A3 is_additive_in A2 means
    for b1, b2, b3 being Element of the carrier of a3
    for b4 being Element of (a1 + 1) -tuples_on the carrier of a3
          st b4 . a2 = b2
       holds *'(b1,b4 +*(a2,b2 @ b3)) = (*'(b1,b4)) @ *'(b1,b4 +*(a2,b3));
end;

:: MIDSP_3:dfs 6
definiens
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
To prove
     a3 is_additive_in a2
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a3
    for b4 being Element of (a1 + 1) -tuples_on the carrier of a3
          st b4 . a2 = b2
       holds *'(b1,b4 +*(a2,b2 @ b3)) = (*'(b1,b4)) @ *'(b1,b4 +*(a2,b3));

:: MIDSP_3:def 8
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b1 + 2 holds
      b3 is_additive_in b2
   iff
      for b4, b5, b6 being Element of the carrier of b3
      for b7 being Element of (b1 + 1) -tuples_on the carrier of b3
            st b7 . b2 = b5
         holds *'(b4,b7 +*(b2,b5 @ b6)) = (*'(b4,b7)) @ *'(b4,b7 +*(b2,b6));

:: MIDSP_3:prednot 5 => MIDSP_3:pred 4
definition
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  pred A3 is_alternative_in A2 means
    for b1 being Element of the carrier of a3
    for b2 being Element of (a1 + 1) -tuples_on the carrier of a3
    for b3 being Element of the carrier of a3
          st b2 . a2 = b3
       holds *'(b1,b2 +*(a2 + 1,b3)) = b1;
end;

:: MIDSP_3:dfs 7
definiens
  let a1, a2 be Element of NAT;
  let a3 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
To prove
     a3 is_alternative_in a2
it is sufficient to prove
  thus for b1 being Element of the carrier of a3
    for b2 being Element of (a1 + 1) -tuples_on the carrier of a3
    for b3 being Element of the carrier of a3
          st b2 . a2 = b3
       holds *'(b1,b2 +*(a2 + 1,b3)) = b1;

:: MIDSP_3:def 9
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b1 + 2 holds
      b3 is_alternative_in b2
   iff
      for b4 being Element of the carrier of b3
      for b5 being Element of (b1 + 1) -tuples_on the carrier of b3
      for b6 being Element of the carrier of b3
            st b5 . b2 = b6
         holds *'(b4,b5 +*(b2 + 1,b6)) = b4;

:: MIDSP_3:modenot 3
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be ATLAS-like AtlasStr over a2;
  let a4 be Element of NAT;
  mode Tuple of a4,a3 is Element of a4 -tuples_on the carrier of the algebra of a3;
end;

:: MIDSP_3:th 14
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b2 + 2
for b4 being ATLAS-like AtlasStr over b3
for b5 being Element of the carrier of the algebra of b4
for b6 being Element of (b2 + 1) -tuples_on the carrier of the algebra of b4
      st b1 in Seg (b2 + 1)
   holds (b6 +*(b1,b5)) . b1 = b5 &
    (for b7 being Element of NAT
          st b7 in (dom b6) \ {b1}
       holds (b6 +*(b1,b5)) . b7 = b6 . b7);

:: MIDSP_3:th 15
theorem
for b1, b2 being Element of NAT
for b3 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b4 being ATLAS-like AtlasStr over b3
for b5 being Element of the carrier of the algebra of b4
for b6 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b4 holds
   (for b7 being Nat of b1
          st b7 = b2
       holds (b6 +*(b2,b5)) . b7 = b5) &
    (for b7, b8 being Nat of b1
          st b7 <> b8
       holds (b6 +*(b8,b5)) . b7 = b6 . b7);

:: MIDSP_3:th 16
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being ATLAS-like AtlasStr over b2
for b4, b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b3
      st for b6 being Nat of b1 holds
           b4 . b6 = b5 . b6
   holds b4 = b5;

:: MIDSP_3:sch 1
scheme MIDSP_3:sch 1
{F1 -> Element of NAT,
  F2 -> non empty set,
  F3 -> Element of F2()}:
ex b1 being FinSequence of F2() st
   len b1 = F1() + 1 &
    (for b2 being Nat of F1() holds
       b1 . b2 = F3(b2))


:: MIDSP_3:funcnot 6 => MIDSP_3:func 6
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be ATLAS-like AtlasStr over a2;
  let a4 be Element of the carrier of a2;
  let a5 be Element of (a1 + 1) -tuples_on the carrier of the algebra of a3;
  func (A4,A5). A3 -> Element of (a1 + 1) -tuples_on the carrier of a2 means
    for b1 being Nat of a1 holds
       it . b1 = (a4,a5 . b1). a3;
end;

:: MIDSP_3:def 11
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being ATLAS-like AtlasStr over b2
for b4 being Element of the carrier of b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b3
for b6 being Element of (b1 + 1) -tuples_on the carrier of b2 holds
      b6 = (b4,b5). b3
   iff
      for b7 being Nat of b1 holds
         b6 . b7 = (b4,b5 . b7). b3;

:: MIDSP_3:funcnot 7 => MIDSP_3:func 7
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be ATLAS-like AtlasStr over a2;
  let a4 be Element of the carrier of a2;
  let a5 be Element of (a1 + 1) -tuples_on the carrier of a2;
  func A3 .(A4,A5) -> Element of (a1 + 1) -tuples_on the carrier of the algebra of a3 means
    for b1 being Nat of a1 holds
       it . b1 = a3 .(a4,a5 . b1);
end;

:: MIDSP_3:def 12
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being ATLAS-like AtlasStr over b2
for b4 being Element of the carrier of b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of b2
for b6 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b3 holds
      b6 = b3 .(b4,b5)
   iff
      for b7 being Nat of b1 holds
         b6 . b7 = b3 .(b4,b5 . b7);

:: MIDSP_3:th 17
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being Element of the carrier of b2
for b4 being Element of (b1 + 1) -tuples_on the carrier of b2
for b5 being ATLAS-like AtlasStr over b2
for b6 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b5 holds
      b5 .(b3,b4) = b6
   iff
      (b3,b6). b5 = b4;

:: MIDSP_3:th 18
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being Element of the carrier of b2
for b4 being ATLAS-like AtlasStr over b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b4 holds
   b4 .(b3,(b3,b5). b4) = b5;

:: MIDSP_3:th 19
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being Element of the carrier of b2
for b4 being Element of (b1 + 1) -tuples_on the carrier of b2
for b5 being ATLAS-like AtlasStr over b2 holds
   (b3,b5 .(b3,b4)). b5 = b4;

:: MIDSP_3:funcnot 8 => MIDSP_3:func 8
definition
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
  let a3 be ATLAS-like AtlasStr over a2;
  let a4 be Element of the carrier of a2;
  let a5 be Element of (a1 + 1) -tuples_on the carrier of the algebra of a3;
  func Phi(A4,A5) -> Element of the carrier of the algebra of a3 equals
    a3 .(a4,*'(a4,(a4,a5). a3));
end;

:: MIDSP_3:def 13
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being ATLAS-like AtlasStr over b2
for b4 being Element of the carrier of b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b3 holds
   Phi(b4,b5) = b3 .(b4,*'(b4,(b4,b5). b3));

:: MIDSP_3:th 20
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3, b4 being Element of the carrier of b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of b2
for b6 being ATLAS-like AtlasStr over b2
for b7 being Element of the carrier of the algebra of b6
for b8 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b6
      st b6 .(b3,b5) = b8 & b6 .(b3,b4) = b7
   holds    *'(b3,b5) = b4
   iff
      Phi(b3,b8) = b7;

:: MIDSP_3:th 21
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2
for b3 being ATLAS-like AtlasStr over b2 holds
      b2 is being_invariance(b1)
   iff
      for b4, b5 being Element of the carrier of b2
      for b6 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b3 holds
         Phi(b4,b6) = Phi(b5,b6);

:: MIDSP_3:th 22
theorem
for b1 being Element of NAT holds
   1 in Seg (b1 + 1);

:: MIDSP_3:th 24
theorem
for b1 being Element of NAT holds
   1 is Nat of b1;

:: MIDSP_3:modenot 4 => MIDSP_3:mode 2
definition
  let a1 be Element of NAT;
  mode ReperAlgebra of A1 -> non empty MidSp-like ReperAlgebraStr over a1 + 2 means
    it is being_invariance(a1);
end;

:: MIDSP_3:dfs 11
definiens
  let a1 be Element of NAT;
  let a2 be non empty MidSp-like ReperAlgebraStr over a1 + 2;
To prove
     a2 is ReperAlgebra of a1
it is sufficient to prove
  thus a2 is being_invariance(a1);

:: MIDSP_3:def 14
theorem
for b1 being Element of NAT
for b2 being non empty MidSp-like ReperAlgebraStr over b1 + 2 holds
      b2 is ReperAlgebra of b1
   iff
      b2 is being_invariance(b1);

:: MIDSP_3:th 25
theorem
for b1 being Element of NAT
for b2 being ReperAlgebra of b1
for b3, b4 being Element of the carrier of b2
for b5 being ATLAS-like AtlasStr over b2
for b6 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b5 holds
   Phi(b3,b6) = Phi(b4,b6);

:: MIDSP_3:funcnot 9 => MIDSP_3:func 9
definition
  let a1 be Element of NAT;
  let a2 be ReperAlgebra of a1;
  let a3 be ATLAS-like AtlasStr over a2;
  let a4 be Element of (a1 + 1) -tuples_on the carrier of the algebra of a3;
  func Phi A4 -> Element of the carrier of the algebra of a3 means
    for b1 being Element of the carrier of a2 holds
       it = Phi(b1,a4);
end;

:: MIDSP_3:def 15
theorem
for b1 being Element of NAT
for b2 being ReperAlgebra of b1
for b3 being ATLAS-like AtlasStr over b2
for b4 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b3
for b5 being Element of the carrier of the algebra of b3 holds
      b5 = Phi b4
   iff
      for b6 being Element of the carrier of b2 holds
         b5 = Phi(b6,b4);

:: MIDSP_3:th 26
theorem
for b1 being Element of NAT
for b2 being ReperAlgebra of b1
for b3, b4 being Element of the carrier of b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of b2
for b6 being ATLAS-like AtlasStr over b2
for b7 being Element of the carrier of the algebra of b6
for b8 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b6
      st b6 .(b3,b5) = b8 & b6 .(b3,b4) = b7 & Phi b8 = b7
   holds *'(b3,b5) = b4;

:: MIDSP_3:th 27
theorem
for b1 being Element of NAT
for b2 being ReperAlgebra of b1
for b3, b4 being Element of the carrier of b2
for b5 being Element of (b1 + 1) -tuples_on the carrier of b2
for b6 being ATLAS-like AtlasStr over b2
for b7 being Element of the carrier of the algebra of b6
for b8 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b6
      st (b3,b8). b6 = b5 & (b3,b7). b6 = b4 & *'(b3,b5) = b4
   holds Phi b8 = b7;

:: MIDSP_3:th 28
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4, b5 being Element of the carrier of b3
for b6 being Element of (b1 + 1) -tuples_on the carrier of b3
for b7 being ATLAS-like AtlasStr over b3
for b8 being Element of the carrier of the algebra of b7
for b9 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b7
      st b7 .(b4,b6) = b9 & b7 .(b4,b5) = b8
   holds b7 .(b4,b6 +*(b2,b5)) = b9 +*(b2,b8);

:: MIDSP_3:th 29
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4, b5 being Element of the carrier of b3
for b6 being Element of (b1 + 1) -tuples_on the carrier of b3
for b7 being ATLAS-like AtlasStr over b3
for b8 being Element of the carrier of the algebra of b7
for b9 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b7
      st (b4,b9). b7 = b6 & (b4,b8). b7 = b5
   holds (b4,b9 +*(b2,b8)). b7 = b6 +*(b2,b5);

:: MIDSP_3:th 30
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4 being ATLAS-like AtlasStr over b3 holds
      b3 has_property_of_zero_in b2
   iff
      for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b4 holds
         Phi (b5 +*(b2,0. b4)) = 0. b4;

:: MIDSP_3:th 31
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4 being ATLAS-like AtlasStr over b3 holds
      b3 is_semi_additive_in b2
   iff
      for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b4 holds
         Phi (b5 +*(b2,Double (b5 . b2))) = Double Phi b5;

:: MIDSP_3:th 32
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
      st b3 has_property_of_zero_in b2 & b3 is_additive_in b2
   holds b3 is_semi_additive_in b2;

:: MIDSP_3:th 33
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4 being ATLAS-like AtlasStr over b3
      st b3 has_property_of_zero_in b2
   holds    b3 is_additive_in b2
   iff
      for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b4
      for b6 being Element of the carrier of the algebra of b4 holds
         Phi (b5 +*(b2,(b5 . b2) + b6)) = (Phi b5) + Phi (b5 +*(b2,b6));

:: MIDSP_3:th 34
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4 being Element of the carrier of b3
for b5 being Element of (b1 + 1) -tuples_on the carrier of b3
for b6 being ATLAS-like AtlasStr over b3
for b7 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b6
      st b6 .(b4,b5) = b7 & b2 <= b1
   holds b6 .(b4,b5 +*(b2 + 1,b5 . b2)) = b7 +*(b2 + 1,b7 . b2);

:: MIDSP_3:th 35
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4 being Element of the carrier of b3
for b5 being Element of (b1 + 1) -tuples_on the carrier of b3
for b6 being ATLAS-like AtlasStr over b3
for b7 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b6
      st (b4,b7). b6 = b5 & b2 <= b1
   holds (b4,b7 +*(b2 + 1,b7 . b2)). b6 = b5 +*(b2 + 1,b5 . b2);

:: MIDSP_3:th 36
theorem
for b1 being Element of NAT
for b2 being Nat of b1
for b3 being ReperAlgebra of b1
for b4 being ATLAS-like AtlasStr over b3
      st b2 <= b1
   holds    b3 is_alternative_in b2
   iff
      for b5 being Element of (b1 + 1) -tuples_on the carrier of the algebra of b4 holds
         Phi (b5 +*(b2 + 1,b5 . b2)) = 0. b4;