Article SCMRING1, MML version 4.99.1005

:: SCMRING1:condreg 1
registration
  cluster non empty trivial -> right_complementable Abelian add-associative right_zeroed (addLoopStr);
end;

:: SCMRING1:condreg 2
registration
  cluster non empty trivial -> right-distributive well-unital (doubleLoopStr);
end;

:: SCMRING1:funcreg 1
registration
  cluster SCM-Instr -> non trivial;
end;

:: SCMRING1:funcreg 2
registration
  cluster omega -> infinite;
end;

:: SCMRING1:funcnot 1 => SCMRING1:func 1
definition
  let a1 be non empty 1-sorted;
  func SCM-Instr A1 -> Element of bool [:NAT,((union {the carrier of a1}) \/ SCM-Memory) *:] equals
    ((({[{},{}]} \/ {[b1,<*b2,b3*>] where b1 is Element of Segm 8, b2 is Element of SCM-Data-Loc, b3 is Element of SCM-Data-Loc: b1 in {1,2,3,4}}) \/ {[6,<*b1*>] where b1 is Element of NAT: TRUE}) \/ {[7,<*b1,b2*>] where b1 is Element of NAT, b2 is Element of SCM-Data-Loc: TRUE}) \/ {[5,<*b1,b2*>] where b1 is Element of SCM-Data-Loc, b2 is Element of the carrier of a1: TRUE};
end;

:: SCMRING1:def 1
theorem
for b1 being non empty 1-sorted holds
   SCM-Instr b1 = ((({[{},{}]} \/ {[b2,<*b3,b4*>] where b2 is Element of Segm 8, b3 is Element of SCM-Data-Loc, b4 is Element of SCM-Data-Loc: b2 in {1,2,3,4}}) \/ {[6,<*b2*>] where b2 is Element of NAT: TRUE}) \/ {[7,<*b2,b3*>] where b2 is Element of NAT, b3 is Element of SCM-Data-Loc: TRUE}) \/ {[5,<*b2,b3*>] where b2 is Element of SCM-Data-Loc, b3 is Element of the carrier of b1: TRUE};

:: SCMRING1:funcreg 3
registration
  let a1 be non empty 1-sorted;
  cluster SCM-Instr a1 -> non trivial;
end;

:: SCMRING1:attrnot 1 => SCMRING1:attr 1
definition
  let a1 be non empty 1-sorted;
  attr a1 is good means
    the carrier of a1 <> NAT & the carrier of a1 <> SCM-Instr a1;
end;

:: SCMRING1:dfs 2
definiens
  let a1 be non empty 1-sorted;
To prove
     a1 is good
it is sufficient to prove
  thus the carrier of a1 <> NAT & the carrier of a1 <> SCM-Instr a1;

:: SCMRING1:def 2
theorem
for b1 being non empty 1-sorted holds
      b1 is good
   iff
      the carrier of b1 <> NAT & the carrier of b1 <> SCM-Instr b1;

:: SCMRING1:condreg 3
registration
  cluster non empty trivial -> good (1-sorted);
end;

:: SCMRING1:exreg 1
registration
  cluster non empty trivial 1-sorted;
end;

:: SCMRING1:exreg 2
registration
  cluster non empty trivial strict doubleLoopStr;
end;

:: SCMRING1:exreg 3
registration
  cluster non empty trivial right_complementable strict Abelian add-associative right_zeroed unital associative right-distributive left-distributive right_unital well-unital distributive left_unital doubleLoopStr;
end;

:: SCMRING1:funcnot 2 => SCMRING1:func 2
definition
  let a1 be non empty 1-sorted;
  func SCM-OK A1 -> Function-like quasi_total Relation of SCM-Memory,{the carrier of a1} \/ {SCM-Instr a1,NAT} means
    for b1 being Element of SCM-Memory holds
       (b1 = NAT implies it . b1 = NAT) &
        (b1 in SCM-Data-Loc implies it . b1 = the carrier of a1) &
        (b1 in NAT implies it . b1 = SCM-Instr a1);
end;

:: SCMRING1:def 3
theorem
for b1 being non empty 1-sorted
for b2 being Function-like quasi_total Relation of SCM-Memory,{the carrier of b1} \/ {SCM-Instr b1,NAT} holds
      b2 = SCM-OK b1
   iff
      for b3 being Element of SCM-Memory holds
         (b3 = NAT implies b2 . b3 = NAT) &
          (b3 in SCM-Data-Loc implies b2 . b3 = the carrier of b1) &
          (b3 in NAT implies b2 . b3 = SCM-Instr b1);

:: SCMRING1:modenot 1
definition
  let a1 be non empty 1-sorted;
  mode SCM-State of a1 is Element of product SCM-OK a1;
end;

:: SCMRING1:th 1
theorem
for b1 being non empty 1-sorted holds
   NAT <> SCM-Instr b1;

:: SCMRING1:th 2
theorem
for b1 being non empty good 1-sorted
for b2 being Element of SCM-Memory holds
      (SCM-OK b1) . b2 = NAT
   iff
      b2 = NAT;

:: SCMRING1:th 3
theorem
for b1 being non empty good 1-sorted
for b2 being Element of SCM-Memory holds
      (SCM-OK b1) . b2 = the carrier of b1
   iff
      b2 in SCM-Data-Loc;

:: SCMRING1:th 4
theorem
for b1 being non empty good 1-sorted
for b2 being Element of SCM-Memory holds
      (SCM-OK b1) . b2 = SCM-Instr b1
   iff
      b2 in NAT;

:: SCMRING1:th 5
theorem
for b1 being Element of SCM-Data-Loc
for b2 being non empty good 1-sorted holds
   (SCM-OK b2) . b1 = the carrier of b2;

:: SCMRING1:th 6
theorem
for b1 being Element of NAT
for b2 being non empty good 1-sorted holds
   (SCM-OK b2) . b1 = SCM-Instr b2;

:: SCMRING1:th 7
theorem
for b1 being non empty 1-sorted holds
   pi(product SCM-OK b1,NAT) = NAT;

:: SCMRING1:th 8
theorem
for b1 being Element of SCM-Data-Loc
for b2 being non empty good 1-sorted holds
   pi(product SCM-OK b2,b1) = the carrier of b2;

:: SCMRING1:th 9
theorem
for b1 being Element of NAT
for b2 being non empty good 1-sorted holds
   pi(product SCM-OK b2,b1) = SCM-Instr b2;

:: SCMRING1:funcnot 3 => SCMRING1:func 3
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of product SCM-OK a1;
  func IC A2 -> Element of NAT equals
    a2 . NAT;
end;

:: SCMRING1:def 4
theorem
for b1 being non empty 1-sorted
for b2 being Element of product SCM-OK b1 holds
   IC b2 = b2 . NAT;

:: SCMRING1:funcnot 4 => SCMRING1:func 4
definition
  let a1 be non empty good 1-sorted;
  let a2 be Element of product SCM-OK a1;
  let a3 be natural set;
  func SCM-Chg(A2,A3) -> Element of product SCM-OK a1 equals
    a2 +* (NAT .--> a3);
end;

:: SCMRING1:def 5
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being natural set holds
   SCM-Chg(b2,b3) = b2 +* (NAT .--> b3);

:: SCMRING1:th 10
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being natural set holds
   (SCM-Chg(b2,b3)) . NAT = b3;

:: SCMRING1:th 11
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being natural set
for b4 being Element of SCM-Data-Loc holds
   (SCM-Chg(b2,b3)) . b4 = b2 . b4;

:: SCMRING1:th 12
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3, b4 being natural set holds
(SCM-Chg(b2,b3)) . b4 = b2 . b4;

:: SCMRING1:funcnot 5 => SCMRING1:func 5
definition
  let a1 be non empty good 1-sorted;
  let a2 be Element of product SCM-OK a1;
  let a3 be Element of SCM-Data-Loc;
  let a4 be Element of the carrier of a1;
  func SCM-Chg(A2,A3,A4) -> Element of product SCM-OK a1 equals
    a2 +* (a3 .--> a4);
end;

:: SCMRING1:def 6
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being Element of SCM-Data-Loc
for b4 being Element of the carrier of b1 holds
   SCM-Chg(b2,b3,b4) = b2 +* (b3 .--> b4);

:: SCMRING1:th 13
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being Element of SCM-Data-Loc
for b4 being Element of the carrier of b1 holds
   (SCM-Chg(b2,b3,b4)) . NAT = b2 . NAT;

:: SCMRING1:th 14
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being Element of SCM-Data-Loc
for b4 being Element of the carrier of b1 holds
   (SCM-Chg(b2,b3,b4)) . b3 = b4;

:: SCMRING1:th 15
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being Element of SCM-Data-Loc
for b4 being Element of the carrier of b1
for b5 being Element of SCM-Data-Loc
      st b5 <> b3
   holds (SCM-Chg(b2,b3,b4)) . b5 = b2 . b5;

:: SCMRING1:th 16
theorem
for b1 being non empty good 1-sorted
for b2 being Element of product SCM-OK b1
for b3 being Element of SCM-Data-Loc
for b4 being Element of the carrier of b1
for b5 being Element of NAT holds
   (SCM-Chg(b2,b3,b4)) . b5 = b2 . b5;

:: SCMRING1:funcnot 6 => SCMRING1:func 6
definition
  let a1 be non empty good 1-sorted;
  let a2 be Element of product SCM-OK a1;
  let a3 be Element of SCM-Data-Loc;
  redefine func a2 . a3 -> Element of the carrier of a1;
end;

:: SCMRING1:funcnot 7 => SCMRING1:func 7
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1, b2 being Element of SCM-Data-Loc st
       ex b3 being Element of Segm 8 st
          a2 = [b3,<*b1,b2*>];
  func A2 address_1 -> Element of SCM-Data-Loc means
    ex b1 being FinSequence of SCM-Data-Loc st
       b1 = a2 `2 & it = b1 /. 1;
end;

:: SCMRING1:def 7
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3, b4 being Element of SCM-Data-Loc st
        ex b5 being Element of Segm 8 st
           b2 = [b5,<*b3,b4*>]
for b3 being Element of SCM-Data-Loc holds
      b3 = b2 address_1
   iff
      ex b4 being FinSequence of SCM-Data-Loc st
         b4 = b2 `2 & b3 = b4 /. 1;

:: SCMRING1:funcnot 8 => SCMRING1:func 8
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1, b2 being Element of SCM-Data-Loc st
       ex b3 being Element of Segm 8 st
          a2 = [b3,<*b1,b2*>];
  func A2 address_2 -> Element of SCM-Data-Loc means
    ex b1 being FinSequence of SCM-Data-Loc st
       b1 = a2 `2 & it = b1 /. 2;
end;

:: SCMRING1:def 8
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3, b4 being Element of SCM-Data-Loc st
        ex b5 being Element of Segm 8 st
           b2 = [b5,<*b3,b4*>]
for b3 being Element of SCM-Data-Loc holds
      b3 = b2 address_2
   iff
      ex b4 being FinSequence of SCM-Data-Loc st
         b4 = b2 `2 & b3 = b4 /. 2;

:: SCMRING1:th 17
theorem
for b1 being Element of Segm 8
for b2 being non empty 1-sorted
for b3 being Element of SCM-Instr b2
for b4, b5 being Element of SCM-Data-Loc
      st b3 = [b1,<*b4,b5*>]
   holds b3 address_1 = b4 & b3 address_2 = b5;

:: SCMRING1:funcnot 9 => SCMRING1:func 9
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1 being Element of NAT st
       ex b2 being Element of Segm 8 st
          a2 = [b2,<*b1*>];
  func A2 jump_address -> Element of NAT means
    ex b1 being FinSequence of NAT st
       b1 = a2 `2 & it = b1 /. 1;
end;

:: SCMRING1:def 9
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3 being Element of NAT st
        ex b4 being Element of Segm 8 st
           b2 = [b4,<*b3*>]
for b3 being Element of NAT holds
      b3 = b2 jump_address
   iff
      ex b4 being FinSequence of NAT st
         b4 = b2 `2 & b3 = b4 /. 1;

:: SCMRING1:th 18
theorem
for b1 being Element of Segm 8
for b2 being non empty 1-sorted
for b3 being Element of SCM-Instr b2
for b4 being Element of NAT
      st b3 = [b1,<*b4*>]
   holds b3 jump_address = b4;

:: SCMRING1:funcnot 10 => SCMRING1:func 10
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1 being Element of NAT st
       ex b2 being Element of SCM-Data-Loc st
          ex b3 being Element of Segm 8 st
             a2 = [b3,<*b1,b2*>];
  func A2 cjump_address -> Element of NAT means
    ex b1 being Element of NAT st
       ex b2 being Element of SCM-Data-Loc st
          <*b1,b2*> = a2 `2 & it = <*b1,b2*> /. 1;
end;

:: SCMRING1:def 10
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3 being Element of NAT st
        ex b4 being Element of SCM-Data-Loc st
           ex b5 being Element of Segm 8 st
              b2 = [b5,<*b3,b4*>]
for b3 being Element of NAT holds
      b3 = b2 cjump_address
   iff
      ex b4 being Element of NAT st
         ex b5 being Element of SCM-Data-Loc st
            <*b4,b5*> = b2 `2 & b3 = <*b4,b5*> /. 1;

:: SCMRING1:funcnot 11 => SCMRING1:func 11
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1 being Element of NAT st
       ex b2 being Element of SCM-Data-Loc st
          ex b3 being Element of Segm 8 st
             a2 = [b3,<*b1,b2*>];
  func A2 cond_address -> Element of SCM-Data-Loc means
    ex b1 being Element of NAT st
       ex b2 being Element of SCM-Data-Loc st
          <*b1,b2*> = a2 `2 & it = <*b1,b2*> /. 2;
end;

:: SCMRING1:def 11
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3 being Element of NAT st
        ex b4 being Element of SCM-Data-Loc st
           ex b5 being Element of Segm 8 st
              b2 = [b5,<*b3,b4*>]
for b3 being Element of SCM-Data-Loc holds
      b3 = b2 cond_address
   iff
      ex b4 being Element of NAT st
         ex b5 being Element of SCM-Data-Loc st
            <*b4,b5*> = b2 `2 & b3 = <*b4,b5*> /. 2;

:: SCMRING1:th 19
theorem
for b1 being Element of Segm 8
for b2 being non empty 1-sorted
for b3 being Element of SCM-Instr b2
for b4 being Element of NAT
for b5 being Element of SCM-Data-Loc
      st b3 = [b1,<*b4,b5*>]
   holds b3 cjump_address = b4 & b3 cond_address = b5;

:: SCMRING1:funcnot 12 => SCMRING1:func 12
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Data-Loc;
  let a3 be Element of the carrier of a1;
  redefine func <*a2, a3*> -> FinSequence of SCM-Data-Loc \/ the carrier of a1;
end;

:: SCMRING1:funcnot 13 => SCMRING1:func 13
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1 being Element of SCM-Data-Loc st
       ex b2 being Element of the carrier of a1 st
          ex b3 being Element of Segm 8 st
             a2 = [b3,<*b1,b2*>];
  func A2 const_address -> Element of SCM-Data-Loc means
    ex b1 being FinSequence of SCM-Data-Loc \/ the carrier of a1 st
       b1 = a2 `2 & it = b1 /. 1;
end;

:: SCMRING1:def 12
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3 being Element of SCM-Data-Loc st
        ex b4 being Element of the carrier of b1 st
           ex b5 being Element of Segm 8 st
              b2 = [b5,<*b3,b4*>]
for b3 being Element of SCM-Data-Loc holds
      b3 = b2 const_address
   iff
      ex b4 being FinSequence of SCM-Data-Loc \/ the carrier of b1 st
         b4 = b2 `2 & b3 = b4 /. 1;

:: SCMRING1:funcnot 14 => SCMRING1:func 14
definition
  let a1 be non empty 1-sorted;
  let a2 be Element of SCM-Instr a1;
  assume ex b1 being Element of SCM-Data-Loc st
       ex b2 being Element of the carrier of a1 st
          ex b3 being Element of Segm 8 st
             a2 = [b3,<*b1,b2*>];
  func A2 const_value -> Element of the carrier of a1 means
    ex b1 being FinSequence of SCM-Data-Loc \/ the carrier of a1 st
       b1 = a2 `2 & it = b1 /. 2;
end;

:: SCMRING1:def 13
theorem
for b1 being non empty 1-sorted
for b2 being Element of SCM-Instr b1
   st ex b3 being Element of SCM-Data-Loc st
        ex b4 being Element of the carrier of b1 st
           ex b5 being Element of Segm 8 st
              b2 = [b5,<*b3,b4*>]
for b3 being Element of the carrier of b1 holds
      b3 = b2 const_value
   iff
      ex b4 being FinSequence of SCM-Data-Loc \/ the carrier of b1 st
         b4 = b2 `2 & b3 = b4 /. 2;

:: SCMRING1:th 20
theorem
for b1 being Element of Segm 8
for b2 being non empty 1-sorted
for b3 being Element of SCM-Instr b2
for b4 being Element of SCM-Data-Loc
for b5 being Element of the carrier of b2
      st b3 = [b1,<*b4,b5*>]
   holds b3 const_address = b4 & b3 const_value = b5;

:: SCMRING1:funcnot 15 => SCMRING1:func 15
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive good doubleLoopStr;
  let a2 be Element of SCM-Instr a1;
  let a3 be Element of product SCM-OK a1;
  func SCM-Exec-Res(A2,A3) -> Element of product SCM-OK a1 equals
    SCM-Chg(SCM-Chg(a3,a2 address_1,a3 . (a2 address_2)),succ IC a3)
    if ex b1, b2 being Element of SCM-Data-Loc st
       a2 = [1,<*b1,b2*>],
SCM-Chg(SCM-Chg(a3,a2 address_1,(a3 . (a2 address_1)) + (a3 . (a2 address_2))),succ IC a3)
    if ex b1, b2 being Element of SCM-Data-Loc st
       a2 = [2,<*b1,b2*>],
SCM-Chg(SCM-Chg(a3,a2 address_1,(a3 . (a2 address_1)) - (a3 . (a2 address_2))),succ IC a3)
    if ex b1, b2 being Element of SCM-Data-Loc st
       a2 = [3,<*b1,b2*>],
SCM-Chg(SCM-Chg(a3,a2 address_1,(a3 . (a2 address_1)) * (a3 . (a2 address_2))),succ IC a3)
    if ex b1, b2 being Element of SCM-Data-Loc st
       a2 = [4,<*b1,b2*>],
SCM-Chg(a3,a2 jump_address)
    if ex b1 being Element of NAT st
       a2 = [6,<*b1*>],
SCM-Chg(a3,IFEQ(a3 . (a2 cond_address),0. a1,a2 cjump_address,succ IC a3))
    if ex b1 being Element of NAT st
       ex b2 being Element of SCM-Data-Loc st
          a2 = [7,<*b1,b2*>],
SCM-Chg(SCM-Chg(a3,a2 const_address,a2 const_value),succ IC a3)
    if ex b1 being Element of SCM-Data-Loc st
       ex b2 being Element of the carrier of a1 st
          a2 = [5,<*b1,b2*>]
    otherwise a3;
end;

:: SCMRING1:def 14
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive good doubleLoopStr
for b2 being Element of SCM-Instr b1
for b3 being Element of product SCM-OK b1 holds
   (for b4, b5 being Element of SCM-Data-Loc holds
    b2 <> [1,<*b4,b5*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(SCM-Chg(b3,b2 address_1,b3 . (b2 address_2)),succ IC b3)) &
    (for b4, b5 being Element of SCM-Data-Loc holds
    b2 <> [2,<*b4,b5*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(SCM-Chg(b3,b2 address_1,(b3 . (b2 address_1)) + (b3 . (b2 address_2))),succ IC b3)) &
    (for b4, b5 being Element of SCM-Data-Loc holds
    b2 <> [3,<*b4,b5*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(SCM-Chg(b3,b2 address_1,(b3 . (b2 address_1)) - (b3 . (b2 address_2))),succ IC b3)) &
    (for b4, b5 being Element of SCM-Data-Loc holds
    b2 <> [4,<*b4,b5*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(SCM-Chg(b3,b2 address_1,(b3 . (b2 address_1)) * (b3 . (b2 address_2))),succ IC b3)) &
    (for b4 being Element of NAT holds
       b2 <> [6,<*b4*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(b3,b2 jump_address)) &
    (for b4 being Element of NAT
    for b5 being Element of SCM-Data-Loc holds
       b2 <> [7,<*b4,b5*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(b3,IFEQ(b3 . (b2 cond_address),0. b1,b2 cjump_address,succ IC b3))) &
    (for b4 being Element of SCM-Data-Loc
    for b5 being Element of the carrier of b1 holds
       b2 <> [5,<*b4,b5*>] or SCM-Exec-Res(b2,b3) = SCM-Chg(SCM-Chg(b3,b2 const_address,b2 const_value),succ IC b3)) &
    ((for b4, b5 being Element of SCM-Data-Loc holds
     b2 <> [1,<*b4,b5*>]) &
     (for b4, b5 being Element of SCM-Data-Loc holds
     b2 <> [2,<*b4,b5*>]) &
     (for b4, b5 being Element of SCM-Data-Loc holds
     b2 <> [3,<*b4,b5*>]) &
     (for b4, b5 being Element of SCM-Data-Loc holds
     b2 <> [4,<*b4,b5*>]) &
     (for b4 being Element of NAT holds
        b2 <> [6,<*b4*>]) &
     (for b4 being Element of NAT
     for b5 being Element of SCM-Data-Loc holds
        b2 <> [7,<*b4,b5*>]) &
     (for b4 being Element of SCM-Data-Loc
     for b5 being Element of the carrier of b1 holds
        b2 <> [5,<*b4,b5*>]) implies SCM-Exec-Res(b2,b3) = b3);

:: SCMRING1:funcreg 4
registration
  let a1 be non empty 1-sorted;
  let a2 be Function-like quasi_total Relation of SCM-Instr a1,Funcs(product SCM-OK a1,product SCM-OK a1);
  let a3 be Element of SCM-Instr a1;
  cluster a2 . a3 -> Relation-like Function-like;
end;

:: SCMRING1:funcnot 16 => SCMRING1:func 16
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive good doubleLoopStr;
  func SCM-Exec A1 -> Function-like quasi_total Relation of SCM-Instr a1,Funcs(product SCM-OK a1,product SCM-OK a1) means
    for b1 being Element of SCM-Instr a1
    for b2 being Element of product SCM-OK a1 holds
       (it . b1) . b2 = SCM-Exec-Res(b1,b2);
end;

:: SCMRING1:def 15
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive good doubleLoopStr
for b2 being Function-like quasi_total Relation of SCM-Instr b1,Funcs(product SCM-OK b1,product SCM-OK b1) holds
      b2 = SCM-Exec b1
   iff
      for b3 being Element of SCM-Instr b1
      for b4 being Element of product SCM-OK b1 holds
         (b2 . b3) . b4 = SCM-Exec-Res(b3,b4);