Article SCMFSA_1, MML version 4.99.1005

:: SCMFSA_1:funcnot 1 => AMI_2:func 2
notation
  synonym SCM+FSA-Data-Loc for SCM-Data-Loc;
end;

:: SCMFSA_1:funcnot 2 => SCMFSA_1:func 1
definition
  func SCM+FSA-Data*-Loc -> set equals
    INT \ NAT;
end;

:: SCMFSA_1:def 1
theorem
SCM+FSA-Data*-Loc = INT \ NAT;

:: SCMFSA_1:funcnot 3 => SCMFSA_1:func 2
definition
  func SCM+FSA-Memory -> set equals
    SCM-Memory \/ SCM+FSA-Data*-Loc;
end;

:: SCMFSA_1:def 2
theorem
SCM+FSA-Memory = SCM-Memory \/ SCM+FSA-Data*-Loc;

:: SCMFSA_1:funcreg 1
registration
  cluster SCM+FSA-Memory -> non empty;
end;

:: SCMFSA_1:th 1
theorem
SCM-Memory c= SCM+FSA-Memory;

:: SCMFSA_1:funcnot 4 => SCMFSA_1:func 3
definition
  redefine func SCM+FSA-Data-Loc -> Element of bool SCM+FSA-Memory;
end;

:: SCMFSA_1:funcnot 5 => SCMFSA_1:func 4
definition
  redefine func SCM+FSA-Data*-Loc -> Element of bool SCM+FSA-Memory;
end;

:: SCMFSA_1:funcnot 6 => SCMFSA_1:func 5
definition
  redefine func NAT -> Element of bool SCM+FSA-Memory;
end;

:: SCMFSA_1:funcreg 2
registration
  cluster SCM+FSA-Data*-Loc -> non empty;
end;

:: SCMFSA_1:funcnot 7 => SCMFSA_1:func 6
definition
  func SCM+FSA-Instr -> Element of bool [:NAT,((union {INT,INT *}) \/ SCM+FSA-Memory) *:] equals
    (SCM-Instr \/ {[b1,<*b2,b4,b3*>] where b1 is Element of Segm 13, b2 is Element of SCM+FSA-Data-Loc, b3 is Element of SCM+FSA-Data-Loc, b4 is Element of SCM+FSA-Data*-Loc: b1 in {9,10}}) \/ {[b1,<*b2,b3*>] where b1 is Element of Segm 13, b2 is Element of SCM+FSA-Data-Loc, b3 is Element of SCM+FSA-Data*-Loc: b1 in {11,12}};
end;

:: SCMFSA_1:def 4
theorem
SCM+FSA-Instr = (SCM-Instr \/ {[b1,<*b2,b4,b3*>] where b1 is Element of Segm 13, b2 is Element of SCM+FSA-Data-Loc, b3 is Element of SCM+FSA-Data-Loc, b4 is Element of SCM+FSA-Data*-Loc: b1 in {9,10}}) \/ {[b1,<*b2,b3*>] where b1 is Element of Segm 13, b2 is Element of SCM+FSA-Data-Loc, b3 is Element of SCM+FSA-Data*-Loc: b1 in {11,12}};

:: SCMFSA_1:th 2
theorem
SCM-Instr c= SCM+FSA-Instr;

:: SCMFSA_1:funcreg 3
registration
  cluster SCM+FSA-Instr -> non empty;
end;

:: SCMFSA_1:funcreg 4
registration
  let a1 be Element of SCM+FSA-Instr;
  cluster a1 `1 -> natural;
end;

:: SCMFSA_1:th 3
theorem
for b1 being Element of SCM+FSA-Instr
      st b1 `1 <= 8
   holds b1 in SCM-Instr;

:: SCMFSA_1:th 4
theorem
[0,{}] in SCM+FSA-Instr;

:: SCMFSA_1:funcnot 8 => SCMFSA_1:func 7
definition
  func SCM+FSA-OK -> Function-like quasi_total Relation of SCM+FSA-Memory,{INT,INT *} \/ {SCM+FSA-Instr,NAT} equals
    ((SCM+FSA-Memory --> (INT *)) +* SCM-OK) +* ((SCM-OK | NAT) * (SCM-Instr .--> SCM+FSA-Instr));
end;

:: SCMFSA_1:def 6
theorem
SCM+FSA-OK = ((SCM+FSA-Memory --> (INT *)) +* SCM-OK) +* ((SCM-OK | NAT) * (SCM-Instr .--> SCM+FSA-Instr));

:: SCMFSA_1:th 5
theorem
NAT in SCM+FSA-Memory;

:: SCMFSA_1:th 6
theorem
for b1 being set
for b2, b3 being Element of SCM+FSA-Data-Loc
for b4 being Element of SCM+FSA-Data*-Loc
      st b1 in {9,10}
   holds [b1,<*b2,b4,b3*>] in SCM+FSA-Instr;

:: SCMFSA_1:th 7
theorem
for b1 being set
for b2 being Element of SCM+FSA-Data-Loc
for b3 being Element of SCM+FSA-Data*-Loc
      st b1 in {11,12}
   holds [b1,<*b2,b3*>] in SCM+FSA-Instr;

:: SCMFSA_1:th 8
theorem
SCM+FSA-Memory = (({NAT} \/ SCM+FSA-Data-Loc) \/ SCM+FSA-Data*-Loc) \/ NAT;

:: SCMFSA_1:th 9
theorem
SCM+FSA-OK . NAT = NAT;

:: SCMFSA_1:th 10
theorem
for b1 being Element of SCM+FSA-Data-Loc holds
   SCM+FSA-OK . b1 = INT;

:: SCMFSA_1:th 11
theorem
for b1 being Element of NAT holds
   SCM+FSA-OK . b1 = SCM+FSA-Instr;

:: SCMFSA_1:th 12
theorem
for b1 being Element of SCM+FSA-Data*-Loc holds
   SCM+FSA-OK . b1 = INT *;

:: SCMFSA_1:th 13
theorem
NAT <> INT & SCM+FSA-Instr <> INT & NAT <> SCM+FSA-Instr & NAT <> INT * & SCM+FSA-Instr <> INT *;

:: SCMFSA_1:th 14
theorem
for b1 being Element of SCM+FSA-Memory
      st SCM+FSA-OK . b1 = NAT
   holds b1 = NAT;

:: SCMFSA_1:th 15
theorem
for b1 being Element of SCM+FSA-Memory
      st SCM+FSA-OK . b1 = INT
   holds b1 in SCM+FSA-Data-Loc;

:: SCMFSA_1:th 16
theorem
for b1 being Element of SCM+FSA-Memory
      st SCM+FSA-OK . b1 = SCM+FSA-Instr
   holds b1 in NAT;

:: SCMFSA_1:th 17
theorem
for b1 being Element of SCM+FSA-Memory
      st SCM+FSA-OK . b1 = INT *
   holds b1 in SCM+FSA-Data*-Loc;

:: SCMFSA_1:modenot 1
definition
  mode SCM+FSA-State is Element of product SCM+FSA-OK;
end;

:: SCMFSA_1:th 18
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM-Instr holds
   (b1 | SCM-Memory) +* (NAT --> b2) is Element of product SCM-OK;

:: SCMFSA_1:th 19
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of product SCM-OK holds
   (b1 +* b2) +* (b1 | NAT) is Element of product SCM+FSA-OK;

:: SCMFSA_1:funcnot 9 => SCMFSA_1:func 8
definition
  let a1 be Element of product SCM+FSA-OK;
  let a2 be natural set;
  func SCM+FSA-Chg(A1,A2) -> Element of product SCM+FSA-OK equals
    a1 +* (NAT .--> a2);
end;

:: SCMFSA_1:def 7
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being natural set holds
   SCM+FSA-Chg(b1,b2) = b1 +* (NAT .--> b2);

:: SCMFSA_1:funcnot 10 => SCMFSA_1:func 9
definition
  let a1 be Element of product SCM+FSA-OK;
  let a2 be Element of SCM+FSA-Data-Loc;
  let a3 be integer set;
  func SCM+FSA-Chg(A1,A2,A3) -> Element of product SCM+FSA-OK equals
    a1 +* (a2 .--> a3);
end;

:: SCMFSA_1:def 8
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data-Loc
for b3 being integer set holds
   SCM+FSA-Chg(b1,b2,b3) = b1 +* (b2 .--> b3);

:: SCMFSA_1:funcnot 11 => SCMFSA_1:func 10
definition
  let a1 be Element of product SCM+FSA-OK;
  let a2 be Element of SCM+FSA-Data*-Loc;
  let a3 be FinSequence of INT;
  func SCM+FSA-Chg(A1,A2,A3) -> Element of product SCM+FSA-OK equals
    a1 +* (a2 .--> a3);
end;

:: SCMFSA_1:def 9
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data*-Loc
for b3 being FinSequence of INT holds
   SCM+FSA-Chg(b1,b2,b3) = b1 +* (b2 .--> b3);

:: SCMFSA_1:funcnot 12 => SCMFSA_1:func 11
definition
  let a1 be Element of product SCM+FSA-OK;
  let a2 be Element of SCM+FSA-Data-Loc;
  redefine func a1 . a2 -> integer set;
end;

:: SCMFSA_1:funcnot 13 => SCMFSA_1:func 12
definition
  let a1 be Element of product SCM+FSA-OK;
  let a2 be Element of SCM+FSA-Data*-Loc;
  redefine func a1 . a2 -> FinSequence of INT;
end;

:: SCMFSA_1:funcnot 14 => SCMFSA_1:func 13
definition
  let a1 be Element of SCM+FSA-Instr;
  assume ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of SCM+FSA-Data-Loc st
             ex b4 being Element of Segm 13 st
                a1 = [b4,<*b1,b2,b3*>];
  func A1 int_addr1 -> Element of SCM+FSA-Data-Loc means
    ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of SCM+FSA-Data-Loc st
             <*b1,b2,b3*> = a1 `2 & it = b1;
end;

:: SCMFSA_1:def 10
theorem
for b1 being Element of SCM+FSA-Instr
   st ex b2 being Element of SCM+FSA-Data-Loc st
        ex b3 being Element of SCM+FSA-Data*-Loc st
           ex b4 being Element of SCM+FSA-Data-Loc st
              ex b5 being Element of Segm 13 st
                 b1 = [b5,<*b2,b3,b4*>]
for b2 being Element of SCM+FSA-Data-Loc holds
      b2 = b1 int_addr1
   iff
      ex b3 being Element of SCM+FSA-Data-Loc st
         ex b4 being Element of SCM+FSA-Data*-Loc st
            ex b5 being Element of SCM+FSA-Data-Loc st
               <*b3,b4,b5*> = b1 `2 & b2 = b3;

:: SCMFSA_1:funcnot 15 => SCMFSA_1:func 14
definition
  let a1 be Element of SCM+FSA-Instr;
  assume ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of SCM+FSA-Data-Loc st
             ex b4 being Element of Segm 13 st
                a1 = [b4,<*b1,b2,b3*>];
  func A1 int_addr2 -> Element of SCM+FSA-Data-Loc means
    ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of SCM+FSA-Data-Loc st
             <*b1,b2,b3*> = a1 `2 & it = b3;
end;

:: SCMFSA_1:def 11
theorem
for b1 being Element of SCM+FSA-Instr
   st ex b2 being Element of SCM+FSA-Data-Loc st
        ex b3 being Element of SCM+FSA-Data*-Loc st
           ex b4 being Element of SCM+FSA-Data-Loc st
              ex b5 being Element of Segm 13 st
                 b1 = [b5,<*b2,b3,b4*>]
for b2 being Element of SCM+FSA-Data-Loc holds
      b2 = b1 int_addr2
   iff
      ex b3 being Element of SCM+FSA-Data-Loc st
         ex b4 being Element of SCM+FSA-Data*-Loc st
            ex b5 being Element of SCM+FSA-Data-Loc st
               <*b3,b4,b5*> = b1 `2 & b2 = b5;

:: SCMFSA_1:funcnot 16 => SCMFSA_1:func 15
definition
  let a1 be Element of SCM+FSA-Instr;
  assume ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of SCM+FSA-Data-Loc st
             ex b4 being Element of Segm 13 st
                a1 = [b4,<*b1,b2,b3*>];
  func A1 coll_addr1 -> Element of SCM+FSA-Data*-Loc means
    ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of SCM+FSA-Data-Loc st
             <*b1,b2,b3*> = a1 `2 & it = b2;
end;

:: SCMFSA_1:def 12
theorem
for b1 being Element of SCM+FSA-Instr
   st ex b2 being Element of SCM+FSA-Data-Loc st
        ex b3 being Element of SCM+FSA-Data*-Loc st
           ex b4 being Element of SCM+FSA-Data-Loc st
              ex b5 being Element of Segm 13 st
                 b1 = [b5,<*b2,b3,b4*>]
for b2 being Element of SCM+FSA-Data*-Loc holds
      b2 = b1 coll_addr1
   iff
      ex b3 being Element of SCM+FSA-Data-Loc st
         ex b4 being Element of SCM+FSA-Data*-Loc st
            ex b5 being Element of SCM+FSA-Data-Loc st
               <*b3,b4,b5*> = b1 `2 & b2 = b4;

:: SCMFSA_1:funcnot 17 => SCMFSA_1:func 16
definition
  let a1 be Element of SCM+FSA-Instr;
  assume ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of Segm 13 st
             a1 = [b3,<*b1,b2*>];
  func A1 int_addr3 -> Element of SCM+FSA-Data-Loc means
    ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          <*b1,b2*> = a1 `2 & it = b1;
end;

:: SCMFSA_1:def 13
theorem
for b1 being Element of SCM+FSA-Instr
   st ex b2 being Element of SCM+FSA-Data-Loc st
        ex b3 being Element of SCM+FSA-Data*-Loc st
           ex b4 being Element of Segm 13 st
              b1 = [b4,<*b2,b3*>]
for b2 being Element of SCM+FSA-Data-Loc holds
      b2 = b1 int_addr3
   iff
      ex b3 being Element of SCM+FSA-Data-Loc st
         ex b4 being Element of SCM+FSA-Data*-Loc st
            <*b3,b4*> = b1 `2 & b2 = b3;

:: SCMFSA_1:funcnot 18 => SCMFSA_1:func 17
definition
  let a1 be Element of SCM+FSA-Instr;
  assume ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          ex b3 being Element of Segm 13 st
             a1 = [b3,<*b1,b2*>];
  func A1 coll_addr2 -> Element of SCM+FSA-Data*-Loc means
    ex b1 being Element of SCM+FSA-Data-Loc st
       ex b2 being Element of SCM+FSA-Data*-Loc st
          <*b1,b2*> = a1 `2 & it = b2;
end;

:: SCMFSA_1:def 14
theorem
for b1 being Element of SCM+FSA-Instr
   st ex b2 being Element of SCM+FSA-Data-Loc st
        ex b3 being Element of SCM+FSA-Data*-Loc st
           ex b4 being Element of Segm 13 st
              b1 = [b4,<*b2,b3*>]
for b2 being Element of SCM+FSA-Data*-Loc holds
      b2 = b1 coll_addr2
   iff
      ex b3 being Element of SCM+FSA-Data-Loc st
         ex b4 being Element of SCM+FSA-Data*-Loc st
            <*b3,b4*> = b1 `2 & b2 = b4;

:: SCMFSA_1:funcnot 19 => SCMFSA_1:func 18
definition
  let a1 be Element of product SCM+FSA-OK;
  func IC A1 -> Element of NAT equals
    a1 . NAT;
end;

:: SCMFSA_1:def 16
theorem
for b1 being Element of product SCM+FSA-OK holds
   IC b1 = b1 . NAT;

:: SCMFSA_1:funcnot 20 => SCMFSA_1:func 19
definition
  let a1 be Element of SCM+FSA-Instr;
  let a2 be Element of product SCM+FSA-OK;
  func SCM+FSA-Exec-Res(A1,A2) -> Element of product SCM+FSA-OK means
    ex b1 being Element of SCM-Instr st
       ex b2 being Element of product SCM-OK st
          a1 = b1 &
           b2 = (a2 | SCM-Memory) +* (NAT --> b1) &
           it = (a2 +* SCM-Exec-Res(b1,b2)) +* (a2 | NAT)
    if a1 `1 <= 8,
ex b1 being integer set st
       ex b2 being Element of NAT st
          b2 = abs (a2 . (a1 int_addr2)) &
           b1 = (a2 . (a1 coll_addr1)) /. b2 &
           it = SCM+FSA-Chg(SCM+FSA-Chg(a2,a1 int_addr1,b1),succ IC a2)
    if a1 `1 = 9,
ex b1 being FinSequence of INT st
       ex b2 being Element of NAT st
          b2 = abs (a2 . (a1 int_addr2)) &
           b1 = (a2 . (a1 coll_addr1)) +*(b2,a2 . (a1 int_addr1)) &
           it = SCM+FSA-Chg(SCM+FSA-Chg(a2,a1 coll_addr1,b1),succ IC a2)
    if a1 `1 = 10,
it = SCM+FSA-Chg(SCM+FSA-Chg(a2,a1 int_addr3,len (a2 . (a1 coll_addr2))),succ IC a2)
    if a1 `1 = 11,
ex b1 being FinSequence of INT st
       ex b2 being Element of NAT st
          b2 = abs (a2 . (a1 int_addr3)) &
           b1 = b2 |-> 0 &
           it = SCM+FSA-Chg(SCM+FSA-Chg(a2,a1 coll_addr2,b1),succ IC a2)
    if a1 `1 = 12
    otherwise it = a2;
end;

:: SCMFSA_1:def 17
theorem
for b1 being Element of SCM+FSA-Instr
for b2, b3 being Element of product SCM+FSA-OK holds
(b1 `1 <= 8 implies    (b3 = SCM+FSA-Exec-Res(b1,b2)
 iff
    ex b4 being Element of SCM-Instr st
       ex b5 being Element of product SCM-OK st
          b1 = b4 &
           b5 = (b2 | SCM-Memory) +* (NAT --> b4) &
           b3 = (b2 +* SCM-Exec-Res(b4,b5)) +* (b2 | NAT))) &
 (b1 `1 = 9 implies    (b3 = SCM+FSA-Exec-Res(b1,b2)
 iff
    ex b4 being integer set st
       ex b5 being Element of NAT st
          b5 = abs (b2 . (b1 int_addr2)) &
           b4 = (b2 . (b1 coll_addr1)) /. b5 &
           b3 = SCM+FSA-Chg(SCM+FSA-Chg(b2,b1 int_addr1,b4),succ IC b2))) &
 (b1 `1 = 10 implies    (b3 = SCM+FSA-Exec-Res(b1,b2)
 iff
    ex b4 being FinSequence of INT st
       ex b5 being Element of NAT st
          b5 = abs (b2 . (b1 int_addr2)) &
           b4 = (b2 . (b1 coll_addr1)) +*(b5,b2 . (b1 int_addr1)) &
           b3 = SCM+FSA-Chg(SCM+FSA-Chg(b2,b1 coll_addr1,b4),succ IC b2))) &
 (b1 `1 = 11 implies    (b3 = SCM+FSA-Exec-Res(b1,b2)
 iff
    b3 = SCM+FSA-Chg(SCM+FSA-Chg(b2,b1 int_addr3,len (b2 . (b1 coll_addr2))),succ IC b2))) &
 (b1 `1 = 12 implies    (b3 = SCM+FSA-Exec-Res(b1,b2)
 iff
    ex b4 being FinSequence of INT st
       ex b5 being Element of NAT st
          b5 = abs (b2 . (b1 int_addr3)) &
           b4 = b5 |-> 0 &
           b3 = SCM+FSA-Chg(SCM+FSA-Chg(b2,b1 coll_addr2,b4),succ IC b2))) &
 (8 < b1 `1 & b1 `1 <> 9 & b1 `1 <> 10 & b1 `1 <> 11 & b1 `1 <> 12 implies    (b3 = SCM+FSA-Exec-Res(b1,b2)
 iff
    b3 = b2));

:: SCMFSA_1:funcnot 21 => SCMFSA_1:func 20
definition
  func SCM+FSA-Exec -> Function-like quasi_total Relation of SCM+FSA-Instr,Funcs(product SCM+FSA-OK,product SCM+FSA-OK) means
    for b1 being Element of SCM+FSA-Instr
    for b2 being Element of product SCM+FSA-OK holds
       (it . b1) . b2 = SCM+FSA-Exec-Res(b1,b2);
end;

:: SCMFSA_1:def 18
theorem
for b1 being Function-like quasi_total Relation of SCM+FSA-Instr,Funcs(product SCM+FSA-OK,product SCM+FSA-OK) holds
      b1 = SCM+FSA-Exec
   iff
      for b2 being Element of SCM+FSA-Instr
      for b3 being Element of product SCM+FSA-OK holds
         (b1 . b2) . b3 = SCM+FSA-Exec-Res(b2,b3);

:: SCMFSA_1:th 20
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of NAT holds
   (SCM+FSA-Chg(b1,b2)) . NAT = b2;

:: SCMFSA_1:th 21
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of NAT
for b3 being Element of SCM+FSA-Data-Loc holds
   (SCM+FSA-Chg(b1,b2)) . b3 = b1 . b3;

:: SCMFSA_1:th 22
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of NAT
for b3 being Element of SCM+FSA-Data*-Loc holds
   (SCM+FSA-Chg(b1,b2)) . b3 = b1 . b3;

:: SCMFSA_1:th 23
theorem
for b1 being Element of product SCM+FSA-OK
for b2, b3 being Element of NAT holds
(SCM+FSA-Chg(b1,b2)) . b3 = b1 . b3;

:: SCMFSA_1:th 24
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data-Loc
for b3 being integer set holds
   (SCM+FSA-Chg(b1,b2,b3)) . NAT = b1 . NAT;

:: SCMFSA_1:th 25
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data-Loc
for b3 being integer set holds
   (SCM+FSA-Chg(b1,b2,b3)) . b2 = b3;

:: SCMFSA_1:th 26
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data-Loc
for b3 being integer set
for b4 being Element of SCM+FSA-Data-Loc
      st b4 <> b2
   holds (SCM+FSA-Chg(b1,b2,b3)) . b4 = b1 . b4;

:: SCMFSA_1:th 27
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data-Loc
for b3 being integer set
for b4 being Element of SCM+FSA-Data*-Loc holds
   (SCM+FSA-Chg(b1,b2,b3)) . b4 = b1 . b4;

:: SCMFSA_1:th 28
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data-Loc
for b3 being integer set
for b4 being Element of NAT holds
   (SCM+FSA-Chg(b1,b2,b3)) . b4 = b1 . b4;

:: SCMFSA_1:th 29
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data*-Loc
for b3 being FinSequence of INT holds
   (SCM+FSA-Chg(b1,b2,b3)) . b2 = b3;

:: SCMFSA_1:th 30
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data*-Loc
for b3 being FinSequence of INT
for b4 being Element of SCM+FSA-Data*-Loc
      st b4 <> b2
   holds (SCM+FSA-Chg(b1,b2,b3)) . b4 = b1 . b4;

:: SCMFSA_1:th 31
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data*-Loc
for b3 being FinSequence of INT
for b4 being Element of SCM+FSA-Data-Loc holds
   (SCM+FSA-Chg(b1,b2,b3)) . b4 = b1 . b4;

:: SCMFSA_1:th 32
theorem
for b1 being Element of product SCM+FSA-OK
for b2 being Element of SCM+FSA-Data*-Loc
for b3 being FinSequence of INT
for b4 being Element of NAT holds
   (SCM+FSA-Chg(b1,b2,b3)) . b4 = b1 . b4;

:: SCMFSA_1:th 33
theorem
SCM+FSA-Data*-Loc misses SCM-Memory;