Article SCMFSA10, MML version 4.99.1005

:: SCMFSA10:funcnot 1 => SCMFSA10:func 1
definition
  let a1, a2 be Int-Location;
  let a3, a4 be integer set;
  redefine func (a1,a2)-->(a3,a4) -> finite Element of sproduct the Object-Kind of SCM+FSA;
end;

:: SCMFSA10:th 3
theorem
for b1 being Int-Location holds
   not b1 in NAT;

:: SCMFSA10:th 4
theorem
for b1 being FinSeq-Location holds
   not b1 in NAT;

:: SCMFSA10:th 5
theorem
SCM+FSA-Data-Loc <> NAT;

:: SCMFSA10:th 6
theorem
SCM+FSA-Data*-Loc <> NAT;

:: SCMFSA10:th 7
theorem
for b1 being Element of the carrier of SCM+FSA
      st b1 <> IC SCM+FSA & not b1 in NAT & b1 is not Int-Location
   holds b1 is FinSeq-Location;

:: SCMFSA10:condreg 1
registration
  cluster -> natural (Element of NAT);
end;

:: SCMFSA10:th 9
theorem
for b1, b2 being Int-Location holds
b1 := b2 = [1,<*b1,b2*>];

:: SCMFSA10:th 10
theorem
for b1, b2 being Int-Location holds
AddTo(b1,b2) = [2,<*b1,b2*>];

:: SCMFSA10:th 11
theorem
for b1, b2 being Int-Location holds
SubFrom(b1,b2) = [3,<*b1,b2*>];

:: SCMFSA10:th 12
theorem
for b1, b2 being Int-Location holds
MultBy(b1,b2) = [4,<*b1,b2*>];

:: SCMFSA10:th 13
theorem
for b1, b2 being Int-Location holds
Divide(b1,b2) = [5,<*b1,b2*>];

:: SCMFSA10:th 14
theorem
for b1 being Instruction-Location of SCM+FSA holds
   goto b1 = [6,<*b1*>];

:: SCMFSA10:th 15
theorem
for b1 being Int-Location
for b2 being Instruction-Location of SCM+FSA holds
   b1 =0_goto b2 = [7,<*b2,b1*>];

:: SCMFSA10:th 16
theorem
for b1 being Int-Location
for b2 being Instruction-Location of SCM+FSA holds
   b1 >0_goto b2 = [8,<*b2,b1*>];

:: SCMFSA10:th 17
theorem
AddressPart halt SCM+FSA = {};

:: SCMFSA10:th 18
theorem
for b1, b2 being Int-Location holds
AddressPart (b1 := b2) = <*b1,b2*>;

:: SCMFSA10:th 19
theorem
for b1, b2 being Int-Location holds
AddressPart AddTo(b1,b2) = <*b1,b2*>;

:: SCMFSA10:th 20
theorem
for b1, b2 being Int-Location holds
AddressPart SubFrom(b1,b2) = <*b1,b2*>;

:: SCMFSA10:th 21
theorem
for b1, b2 being Int-Location holds
AddressPart MultBy(b1,b2) = <*b1,b2*>;

:: SCMFSA10:th 22
theorem
for b1, b2 being Int-Location holds
AddressPart Divide(b1,b2) = <*b1,b2*>;

:: SCMFSA10:th 23
theorem
for b1 being Instruction-Location of SCM+FSA holds
   AddressPart goto b1 = <*b1*>;

:: SCMFSA10:th 24
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   AddressPart (b2 =0_goto b1) = <*b1,b2*>;

:: SCMFSA10:th 25
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   AddressPart (b2 >0_goto b1) = <*b1,b2*>;

:: SCMFSA10:th 26
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   AddressPart (b1 :=(b3,b2)) = <*b1,b3,b2*>;

:: SCMFSA10:th 27
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   AddressPart ((b3,b1):= b2) = <*b2,b3,b1*>;

:: SCMFSA10:th 28
theorem
for b1 being Int-Location
for b2 being FinSeq-Location holds
   AddressPart (b1 :=len b2) = <*b1,b2*>;

:: SCMFSA10:th 29
theorem
for b1 being Int-Location
for b2 being FinSeq-Location holds
   AddressPart (b2 :=<0,...,0> b1) = <*b1,b2*>;

:: SCMFSA10:th 30
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = {}
   holds AddressParts b1 = {{}};

:: SCMFSA10:funcreg 1
registration
  let a1 be Element of InsCodes SCM+FSA;
  cluster AddressParts a1 -> non empty;
end;

:: SCMFSA10:th 31
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 1
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 32
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 2
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 33
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 3
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 34
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 4
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 35
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 5
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 36
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 6
   holds proj1 product" AddressParts b1 = {1};

:: SCMFSA10:th 37
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 7
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 38
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 8
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 39
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 9
   holds proj1 product" AddressParts b1 = {1,2,3};

:: SCMFSA10:th 40
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 10
   holds proj1 product" AddressParts b1 = {1,2,3};

:: SCMFSA10:th 41
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 11
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 42
theorem
for b1 being Element of InsCodes SCM+FSA
      st b1 = 12
   holds proj1 product" AddressParts b1 = {1,2};

:: SCMFSA10:th 43
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode (b1 := b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 44
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode (b1 := b2)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 45
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode AddTo(b1,b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 46
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode AddTo(b1,b2)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 47
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode SubFrom(b1,b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 48
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode SubFrom(b1,b2)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 49
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode MultBy(b1,b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 50
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode MultBy(b1,b2)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 51
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode Divide(b1,b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 52
theorem
for b1, b2 being Int-Location holds
(product" AddressParts InsCode Divide(b1,b2)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 53
theorem
for b1 being Instruction-Location of SCM+FSA holds
   (product" AddressParts InsCode goto b1) . 1 = NAT;

:: SCMFSA10:th 54
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   (product" AddressParts InsCode (b2 =0_goto b1)) . 1 = NAT;

:: SCMFSA10:th 55
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   (product" AddressParts InsCode (b2 =0_goto b1)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 56
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   (product" AddressParts InsCode (b2 >0_goto b1)) . 1 = NAT;

:: SCMFSA10:th 57
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   (product" AddressParts InsCode (b2 >0_goto b1)) . 2 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 58
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   (product" AddressParts InsCode (b1 :=(b3,b2))) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 59
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   (product" AddressParts InsCode (b1 :=(b3,b2))) . 2 = SCM+FSA-Data*-Loc;

:: SCMFSA10:th 60
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   (product" AddressParts InsCode (b1 :=(b3,b2))) . 3 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 61
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   (product" AddressParts InsCode ((b3,b1):= b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 62
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   (product" AddressParts InsCode ((b3,b1):= b2)) . 2 = SCM+FSA-Data*-Loc;

:: SCMFSA10:th 63
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location holds
   (product" AddressParts InsCode ((b3,b1):= b2)) . 3 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 64
theorem
for b1 being Int-Location
for b2 being FinSeq-Location holds
   (product" AddressParts InsCode (b1 :=len b2)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 65
theorem
for b1 being Int-Location
for b2 being FinSeq-Location holds
   (product" AddressParts InsCode (b1 :=len b2)) . 2 = SCM+FSA-Data*-Loc;

:: SCMFSA10:th 66
theorem
for b1 being Int-Location
for b2 being FinSeq-Location holds
   (product" AddressParts InsCode (b2 :=<0,...,0> b1)) . 1 = SCM+FSA-Data-Loc;

:: SCMFSA10:th 67
theorem
for b1 being Int-Location
for b2 being FinSeq-Location holds
   (product" AddressParts InsCode (b2 :=<0,...,0> b1)) . 2 = SCM+FSA-Data*-Loc;

:: SCMFSA10:th 68
theorem
for b1 being Instruction-Location of SCM+FSA holds
   NIC(halt SCM+FSA,b1) = {b1};

:: SCMFSA10:funcreg 2
registration
  cluster JUMP halt SCM+FSA -> empty;
end;

:: SCMFSA10:th 69
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location holds
NIC(b2 := b3,b1) = {Next b1};

:: SCMFSA10:funcreg 3
registration
  let a1, a2 be Int-Location;
  cluster JUMP (a1 := a2) -> empty;
end;

:: SCMFSA10:th 70
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location holds
NIC(AddTo(b2,b3),b1) = {Next b1};

:: SCMFSA10:funcreg 4
registration
  let a1, a2 be Int-Location;
  cluster JUMP AddTo(a1,a2) -> empty;
end;

:: SCMFSA10:th 71
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location holds
NIC(SubFrom(b2,b3),b1) = {Next b1};

:: SCMFSA10:funcreg 5
registration
  let a1, a2 be Int-Location;
  cluster JUMP SubFrom(a1,a2) -> empty;
end;

:: SCMFSA10:th 72
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location holds
NIC(MultBy(b2,b3),b1) = {Next b1};

:: SCMFSA10:funcreg 6
registration
  let a1, a2 be Int-Location;
  cluster JUMP MultBy(a1,a2) -> empty;
end;

:: SCMFSA10:th 73
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location holds
NIC(Divide(b2,b3),b1) = {Next b1};

:: SCMFSA10:funcreg 7
registration
  let a1, a2 be Int-Location;
  cluster JUMP Divide(a1,a2) -> empty;
end;

:: SCMFSA10:th 74
theorem
for b1, b2 being Instruction-Location of SCM+FSA holds
NIC(goto b1,b2) = {b1};

:: SCMFSA10:th 75
theorem
for b1 being Instruction-Location of SCM+FSA holds
   JUMP goto b1 = {b1};

:: SCMFSA10:funcreg 8
registration
  let a1 be Instruction-Location of SCM+FSA;
  cluster JUMP goto a1 -> non empty trivial;
end;

:: SCMFSA10:th 76
theorem
for b1, b2 being Instruction-Location of SCM+FSA
for b3 being Int-Location holds
   NIC(b3 =0_goto b1,b2) = {b1,Next b2};

:: SCMFSA10:th 77
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   JUMP (b2 =0_goto b1) = {b1};

:: SCMFSA10:funcreg 9
registration
  let a1 be Int-Location;
  let a2 be Instruction-Location of SCM+FSA;
  cluster JUMP (a1 =0_goto a2) -> non empty trivial;
end;

:: SCMFSA10:th 78
theorem
for b1, b2 being Instruction-Location of SCM+FSA
for b3 being Int-Location holds
   NIC(b3 >0_goto b1,b2) = {b1,Next b2};

:: SCMFSA10:th 79
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location holds
   JUMP (b2 >0_goto b1) = {b1};

:: SCMFSA10:funcreg 10
registration
  let a1 be Int-Location;
  let a2 be Instruction-Location of SCM+FSA;
  cluster JUMP (a1 >0_goto a2) -> non empty trivial;
end;

:: SCMFSA10:th 80
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location
for b4 being FinSeq-Location holds
   NIC(b2 :=(b4,b3),b1) = {Next b1};

:: SCMFSA10:funcreg 11
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster JUMP (a1 :=(a3,a2)) -> empty;
end;

:: SCMFSA10:th 81
theorem
for b1 being Instruction-Location of SCM+FSA
for b2, b3 being Int-Location
for b4 being FinSeq-Location holds
   NIC((b4,b2):= b3,b1) = {Next b1};

:: SCMFSA10:funcreg 12
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster JUMP ((a3,a2):= a1) -> empty;
end;

:: SCMFSA10:th 82
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location
for b3 being FinSeq-Location holds
   NIC(b2 :=len b3,b1) = {Next b1};

:: SCMFSA10:funcreg 13
registration
  let a1 be Int-Location;
  let a2 be FinSeq-Location;
  cluster JUMP (a1 :=len a2) -> empty;
end;

:: SCMFSA10:th 83
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Int-Location
for b3 being FinSeq-Location holds
   NIC(b3 :=<0,...,0> b2,b1) = {Next b1};

:: SCMFSA10:funcreg 14
registration
  let a1 be Int-Location;
  let a2 be FinSeq-Location;
  cluster JUMP (a2 :=<0,...,0> a1) -> empty;
end;

:: SCMFSA10:th 84
theorem
for b1 being Instruction-Location of SCM+FSA holds
   SUCC b1 = {b1,Next b1};

:: SCMFSA10:th 85
theorem
for b1 being IL-Function of NAT,SCM+FSA
      st for b2 being Element of NAT holds
           b1 . b2 = insloc b2
   holds b1 is bijective(NAT, NAT) &
    (for b2 being Element of NAT holds
       b1 . (b2 + 1) in SUCC (b1 . b2) &
        (for b3 being Element of NAT
              st b1 . b3 in SUCC (b1 . b2)
           holds b2 <= b3));

:: SCMFSA10:funcreg 15
registration
  cluster SCM+FSA -> strict standard;
end;

:: SCMFSA10:th 86
theorem
for b1 being natural set holds
   il.(SCM+FSA,b1) = insloc b1;

:: SCMFSA10:th 87
theorem
for b1 being natural set holds
   Next il.(SCM+FSA,b1) = il.(SCM+FSA,b1 + 1);

:: SCMFSA10:th 88
theorem
for b1 being Instruction-Location of SCM+FSA holds
   Next b1 = NextLoc b1;

:: SCMFSA10:funcreg 16
registration
  cluster (halt SCM+FSA) `1 -> jump-only;
end;

:: SCMFSA10:funcreg 17
registration
  cluster halt SCM+FSA -> jump-only;
end;

:: SCMFSA10:funcreg 18
registration
  let a1 be Instruction-Location of SCM+FSA;
  cluster (goto a1) `1 -> jump-only;
end;

:: SCMFSA10:funcreg 19
registration
  let a1 be Instruction-Location of SCM+FSA;
  cluster goto a1 -> jump-only non sequential non ins-loc-free;
end;

:: SCMFSA10:funcreg 20
registration
  let a1 be Int-Location;
  let a2 be Instruction-Location of SCM+FSA;
  cluster (a1 =0_goto a2) `1 -> jump-only;
end;

:: SCMFSA10:funcreg 21
registration
  let a1 be Int-Location;
  let a2 be Instruction-Location of SCM+FSA;
  cluster (a1 >0_goto a2) `1 -> jump-only;
end;

:: SCMFSA10:funcreg 22
registration
  let a1 be Int-Location;
  let a2 be Instruction-Location of SCM+FSA;
  cluster a1 =0_goto a2 -> jump-only non sequential non ins-loc-free;
end;

:: SCMFSA10:funcreg 23
registration
  let a1 be Int-Location;
  let a2 be Instruction-Location of SCM+FSA;
  cluster a1 >0_goto a2 -> jump-only non sequential non ins-loc-free;
end;

:: SCMFSA10:funcreg 24
registration
  let a1, a2 be Int-Location;
  cluster (a1 := a2) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 25
registration
  let a1, a2 be Int-Location;
  cluster (AddTo(a1,a2)) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 26
registration
  let a1, a2 be Int-Location;
  cluster (SubFrom(a1,a2)) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 27
registration
  let a1, a2 be Int-Location;
  cluster (MultBy(a1,a2)) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 28
registration
  let a1, a2 be Int-Location;
  cluster (Divide(a1,a2)) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 29
registration
  let a1, a2 be Int-Location;
  cluster a1 := a2 -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 30
registration
  let a1, a2 be Int-Location;
  cluster AddTo(a1,a2) -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 31
registration
  let a1, a2 be Int-Location;
  cluster SubFrom(a1,a2) -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 32
registration
  let a1, a2 be Int-Location;
  cluster MultBy(a1,a2) -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 33
registration
  let a1, a2 be Int-Location;
  cluster Divide(a1,a2) -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 34
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster (a2 :=(a3,a1)) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 35
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster ((a3,a1):= a2) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 36
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster a2 :=(a3,a1) -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 37
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster (a3,a1):= a2 -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 38
registration
  let a1 be Int-Location;
  let a2 be FinSeq-Location;
  cluster (a1 :=len a2) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 39
registration
  let a1 be Int-Location;
  let a2 be FinSeq-Location;
  cluster (a2 :=<0,...,0> a1) `1 -> non jump-only;
end;

:: SCMFSA10:funcreg 40
registration
  let a1 be Int-Location;
  let a2 be FinSeq-Location;
  cluster a1 :=len a2 -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 41
registration
  let a1 be Int-Location;
  let a2 be FinSeq-Location;
  cluster a2 :=<0,...,0> a1 -> non jump-only sequential;
end;

:: SCMFSA10:funcreg 42
registration
  cluster SCM+FSA -> strict homogeneous with_explicit_jumps without_implicit_jumps;
end;

:: SCMFSA10:funcreg 43
registration
  cluster SCM+FSA -> strict regular;
end;

:: SCMFSA10:th 89
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being natural set holds
   IncAddr(goto b1,b2) = goto il.(SCM+FSA,(locnum b1) + b2);

:: SCMFSA10:th 90
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being natural set
for b3 being Int-Location holds
   IncAddr(b3 =0_goto b1,b2) = b3 =0_goto il.(SCM+FSA,(locnum b1) + b2);

:: SCMFSA10:th 91
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being natural set
for b3 being Int-Location holds
   IncAddr(b3 >0_goto b1,b2) = b3 >0_goto il.(SCM+FSA,(locnum b1) + b2);

:: SCMFSA10:funcreg 44
registration
  cluster SCM+FSA -> strict IC-good Exec-preserving;
end;