Article SCMPDS_4, MML version 4.99.1005

:: SCMPDS_4:modenot 1
definition
  mode Program-block is finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
end;

:: SCMPDS_4:funcnot 1 => SCMPDS_4:func 1
definition
  let a1 be Element of the Instructions of SCMPDS;
  func Load A1 -> finite programmed initial Element of sproduct the Object-Kind of SCMPDS equals
    (inspos 0) .--> a1;
end;

:: SCMPDS_4:def 1
theorem
for b1 being Element of the Instructions of SCMPDS holds
   Load b1 = (inspos 0) .--> b1;

:: SCMPDS_4:funcreg 1
registration
  let a1 be Element of the Instructions of SCMPDS;
  cluster Load a1 -> non empty finite programmed initial;
end;

:: SCMPDS_4:th 1
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Element of NAT holds
      b2 < card b1
   iff
      b2 in proj1 b1;

:: SCMPDS_4:funcreg 2
registration
  let a1 be finite initial Element of sproduct the Object-Kind of SCMPDS;
  cluster ProgramPart a1 -> finite programmed initial;
end;

:: SCMPDS_4:th 2
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
proj1 b1 misses proj1 Shift(b2,card b1);

:: SCMPDS_4:th 3
theorem
for b1 being Element of NAT
for b2 being finite programmed Element of sproduct the Object-Kind of SCMPDS holds
   card Shift(b2,b1) = card b2;

:: SCMPDS_4:th 4
theorem
for b1, b2 being finite Element of sproduct the Object-Kind of SCMPDS holds
ProgramPart (b1 +* b2) = (ProgramPart b1) +* ProgramPart b2;

:: SCMPDS_4:th 5
theorem
for b1 being Element of NAT
for b2, b3 being finite Element of sproduct the Object-Kind of SCMPDS holds
Shift(ProgramPart (b2 +* b3),b1) = (Shift(ProgramPart b2,b1)) +* Shift(ProgramPart b3,b1);

:: SCMPDS_4:funcnot 2 => SCMPDS_4:func 2
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  func Initialized A1 -> finite Element of sproduct the Object-Kind of SCMPDS equals
    a1 +* Start-At inspos 0;
end;

:: SCMPDS_4:def 2
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   Initialized b1 = b1 +* Start-At inspos 0;

:: SCMPDS_4:th 6
theorem
for b1 being Element of the Instructions of SCMPDS
for b2 being Element of product the Object-Kind of SCMPDS
      st not InsCode b1 in {0,1,4,5,6}
   holds (Exec(b1,b2)) . IC SCMPDS = Next IC b2;

:: SCMPDS_4:th 7
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   IC SCMPDS in proj1 Initialized b1;

:: SCMPDS_4:th 8
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   IC Initialized b1 = inspos 0;

:: SCMPDS_4:th 9
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   b1 c= Initialized b1;

:: SCMPDS_4:th 11
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
      st IC b1 = IC b2 &
         (for b3 being Int_position holds
            b1 . b3 = b2 . b3)
   holds b1,b2 equal_outside NAT;

:: SCMPDS_4:th 13
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
   st b1,b2 equal_outside NAT
for b3 being Int_position holds
   b1 . b3 = b2 . b3;

:: SCMPDS_4:th 14
theorem
for b1 being Int_position
for b2, b3 being Element of product the Object-Kind of SCMPDS
for b4 being integer set
      st b2,b3 equal_outside NAT
   holds b2 . DataLoc(b2 . b1,b4) = b3 . DataLoc(b3 . b1,b4);

:: SCMPDS_4:th 15
theorem
for b1 being Element of the Instructions of SCMPDS
for b2, b3 being Element of product the Object-Kind of SCMPDS
      st b2,b3 equal_outside NAT
   holds Exec(b1,b2),Exec(b1,b3) equal_outside NAT;

:: SCMPDS_4:th 16
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   (Initialized b1) | NAT = b1;

:: SCMPDS_4:th 17
theorem
for b1, b2 being Element of NAT
      st b1 <> b2
   holds DataLoc(b1,0) <> DataLoc(b2,0);

:: SCMPDS_4:th 18
theorem
for b1 being Int_position holds
   ex b2 being Element of NAT st
      b1 = DataLoc(b2,0);

:: SCMPDS_4:sch 1
scheme SCMPDS_4:sch 1
{F1 -> Element of the Instructions of SCMPDS,
  F2 -> integer set,
  F3 -> Instruction-Location of SCMPDS}:
ex b1 being Element of product the Object-Kind of SCMPDS st
   IC b1 = F3() &
    (for b2 being Element of NAT holds
       b1 . inspos b2 = F1(b2) & b1 . DataLoc(b2,0) = F2(b2))


:: SCMPDS_4:th 19
theorem
for b1 being Element of product the Object-Kind of SCMPDS holds
   proj1 b1 = ({IC SCMPDS} \/ SCM-Data-Loc) \/ NAT;

:: SCMPDS_4:th 20
theorem
for b1 being Element of product the Object-Kind of SCMPDS
for b2 being set
      st b2 in proj1 b1 & b2 is not Int_position & b2 <> IC SCMPDS
   holds b2 is Instruction-Location of SCMPDS;

:: SCMPDS_4:th 21
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS holds
   for b3 being Instruction-Location of SCMPDS holds
      b1 . b3 = b2 . b3
iff
   b1 | NAT = b2 | NAT;

:: SCMPDS_4:th 22
theorem
for b1 being Instruction-Location of SCMPDS holds
   not b1 in SCM-Data-Loc;

:: SCMPDS_4:th 23
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS holds
   for b3 being Int_position holds
      b1 . b3 = b2 . b3
iff
   b1 | SCM-Data-Loc = b2 | SCM-Data-Loc;

:: SCMPDS_4:th 24
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
      st b1,b2 equal_outside NAT
   holds b1 | SCM-Data-Loc = b2 | SCM-Data-Loc;

:: SCMPDS_4:th 25
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
for b3 being set holds
   (b2 +* (b1 | b3)) | b3 = b1 | b3;

:: SCMPDS_4:th 26
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
b1,b2 equal_outside NAT;

:: SCMPDS_4:th 27
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   proj1 Initialized b1 = (proj1 b1) \/ {IC SCMPDS};

:: SCMPDS_4:th 28
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being set
      st b2 in proj1 Initialized b1 & not b2 in proj1 b1
   holds b2 = IC SCMPDS;

:: SCMPDS_4:th 29
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   (Initialized b1) . IC SCMPDS = inspos 0;

:: SCMPDS_4:th 30
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   not IC SCMPDS in proj1 b1;

:: SCMPDS_4:th 31
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Int_position holds
   not b2 in proj1 Initialized b1;

:: SCMPDS_4:th 32
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being set
      st b3 in proj1 b2
   holds b2 . b3 = (b2 +* Start-At inspos b1) . b3;

:: SCMPDS_4:th 33
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being set
      st b2 in proj1 b1
   holds b1 . b2 = (Initialized b1) . b2;

:: SCMPDS_4:th 34
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being Element of product the Object-Kind of SCMPDS
      st Initialized b2 c= b3
   holds b3 +* Initialized b1 = b3 +* b1;

:: SCMPDS_4:th 35
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being Element of product the Object-Kind of SCMPDS
      st Initialized b2 c= b3
   holds Initialized b1 c= b3 +* b1;

:: SCMPDS_4:th 36
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being Element of product the Object-Kind of SCMPDS holds
   b3 +* Initialized b1,b3 +* Initialized b2 equal_outside NAT;

:: SCMPDS_4:funcnot 3 => SCMPDS_4:func 3
definition
  let a1, a2 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  func A1 ';' A2 -> finite programmed initial Element of sproduct the Object-Kind of SCMPDS equals
    a1 +* Shift(a2,card a1);
end;

:: SCMPDS_4:def 3
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
b1 ';' b2 = b1 +* Shift(b2,card b1);

:: SCMPDS_4:th 37
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being Instruction-Location of SCMPDS
      st b3 in proj1 b1
   holds (b1 ';' b2) . b3 = b1 . b3;

:: SCMPDS_4:th 38
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being Instruction-Location of SCMPDS
      st b3 in proj1 b2
   holds (b1 ';' b2) . (b3 + card b1) = b2 . b3;

:: SCMPDS_4:th 39
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
proj1 b1 c= proj1 (b1 ';' b2);

:: SCMPDS_4:th 40
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
b1 c= b1 ';' b2;

:: SCMPDS_4:th 41
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
b1 +* (b1 ';' b2) = b1 ';' b2;

:: SCMPDS_4:th 42
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
(Initialized b1) +* (b1 ';' b2) = Initialized (b1 ';' b2);

:: SCMPDS_4:funcnot 4 => SCMPDS_4:func 4
definition
  let a1 be Element of the Instructions of SCMPDS;
  let a2 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  func A1 ';' A2 -> finite programmed initial Element of sproduct the Object-Kind of SCMPDS equals
    (Load a1) ';' a2;
end;

:: SCMPDS_4:def 4
theorem
for b1 being Element of the Instructions of SCMPDS
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   b1 ';' b2 = (Load b1) ';' b2;

:: SCMPDS_4:funcnot 5 => SCMPDS_4:func 5
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  let a2 be Element of the Instructions of SCMPDS;
  func A1 ';' A2 -> finite programmed initial Element of sproduct the Object-Kind of SCMPDS equals
    a1 ';' Load a2;
end;

:: SCMPDS_4:def 5
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Element of the Instructions of SCMPDS holds
   b1 ';' b2 = b1 ';' Load b2;

:: SCMPDS_4:funcnot 6 => SCMPDS_4:func 6
definition
  let a1, a2 be Element of the Instructions of SCMPDS;
  func A1 ';' A2 -> finite programmed initial Element of sproduct the Object-Kind of SCMPDS equals
    (Load a1) ';' Load a2;
end;

:: SCMPDS_4:def 6
theorem
for b1, b2 being Element of the Instructions of SCMPDS holds
b1 ';' b2 = (Load b1) ';' Load b2;

:: SCMPDS_4:th 43
theorem
for b1, b2 being Element of the Instructions of SCMPDS holds
b1 ';' b2 = (Load b1) ';' b2;

:: SCMPDS_4:th 44
theorem
for b1, b2 being Element of the Instructions of SCMPDS holds
b1 ';' b2 = b1 ';' Load b2;

:: SCMPDS_4:th 45
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
card (b1 ';' b2) = (card b1) + card b2;

:: SCMPDS_4:th 46
theorem
for b1, b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
(b1 ';' b2) ';' b3 = b1 ';' (b2 ';' b3);

:: SCMPDS_4:th 47
theorem
for b1 being Element of the Instructions of SCMPDS
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
(b2 ';' b3) ';' b1 = b2 ';' (b3 ';' b1);

:: SCMPDS_4:th 48
theorem
for b1 being Element of the Instructions of SCMPDS
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
(b2 ';' b1) ';' b3 = b2 ';' (b1 ';' b3);

:: SCMPDS_4:th 49
theorem
for b1, b2 being Element of the Instructions of SCMPDS
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   (b3 ';' b1) ';' b2 = b3 ';' (b1 ';' b2);

:: SCMPDS_4:th 50
theorem
for b1 being Element of the Instructions of SCMPDS
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
(b1 ';' b2) ';' b3 = b1 ';' (b2 ';' b3);

:: SCMPDS_4:th 51
theorem
for b1, b2 being Element of the Instructions of SCMPDS
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   (b1 ';' b3) ';' b2 = b1 ';' (b3 ';' b2);

:: SCMPDS_4:th 52
theorem
for b1, b2 being Element of the Instructions of SCMPDS
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   (b1 ';' b2) ';' b3 = b1 ';' (b2 ';' b3);

:: SCMPDS_4:th 53
theorem
for b1, b2, b3 being Element of the Instructions of SCMPDS holds
(b1 ';' b2) ';' b3 = b1 ';' (b2 ';' b3);

:: SCMPDS_4:th 54
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   proj1 b2 misses proj1 Start-At inspos b1;

:: SCMPDS_4:th 56
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3 being Element of product the Object-Kind of SCMPDS
      st b2 +* Start-At inspos b1 c= b3
   holds b2 c= b3;

:: SCMPDS_4:th 57
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Element of product the Object-Kind of SCMPDS
      st Initialized b1 c= b2
   holds b1 c= b2;

:: SCMPDS_4:th 58
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   (b2 +* Start-At inspos b1) | NAT = b2;

:: SCMPDS_4:th 59
theorem
for b1 being Int_position
for b2 being Instruction-Location of SCMPDS holds
   not b1 in proj1 Start-At b2;

:: SCMPDS_4:th 60
theorem
for b1, b2 being Instruction-Location of SCMPDS holds
not b1 in proj1 Start-At b2;

:: SCMPDS_4:th 61
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Int_position
for b3 being Instruction-Location of SCMPDS holds
   not b2 in proj1 (b1 +* Start-At b3);

:: SCMPDS_4:th 62
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Element of product the Object-Kind of SCMPDS holds
   (b2 +* b1) +* Start-At inspos 0 = (b2 +* Start-At inspos 0) +* b1;

:: SCMPDS_4:funcnot 7 => SCMPDS_4:func 7
definition
  let a1 be Element of product the Object-Kind of SCMPDS;
  let a2 be Int_position;
  let a3 be integer set;
  redefine func a1 +*(a2,a3) -> Element of product the Object-Kind of SCMPDS;
end;

:: SCMPDS_4:funcnot 8 => SCMPDS_4:func 8
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  func stop A1 -> finite programmed initial Element of sproduct the Object-Kind of SCMPDS equals
    a1 ';' SCMPDS-Stop;
end;

:: SCMPDS_4:def 7
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   stop b1 = b1 ';' SCMPDS-Stop;

:: SCMPDS_4:funcnot 9 => SCMPDS_4:func 9
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  let a2 be Element of product the Object-Kind of SCMPDS;
  func IExec(A1,A2) -> Element of product the Object-Kind of SCMPDS equals
    (Result (a2 +* Initialized stop a1)) +* (a2 | NAT);
end;

:: SCMPDS_4:def 8
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Element of product the Object-Kind of SCMPDS holds
   IExec(b1,b2) = (Result (b2 +* Initialized stop b1)) +* (b2 | NAT);

:: SCMPDS_4:attrnot 1 => SCMPDS_4:attr 1
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  attr a1 is paraclosed means
    for b1 being Element of product the Object-Kind of SCMPDS
    for b2 being Element of NAT
          st Initialized stop a1 c= b1
       holds IC Computation(b1,b2) in proj1 stop a1;
end;

:: SCMPDS_4:dfs 9
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
To prove
     a1 is paraclosed
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of SCMPDS
    for b2 being Element of NAT
          st Initialized stop a1 c= b1
       holds IC Computation(b1,b2) in proj1 stop a1;

:: SCMPDS_4:def 9
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
      b1 is paraclosed
   iff
      for b2 being Element of product the Object-Kind of SCMPDS
      for b3 being Element of NAT
            st Initialized stop b1 c= b2
         holds IC Computation(b2,b3) in proj1 stop b1;

:: SCMPDS_4:attrnot 2 => SCMPDS_4:attr 2
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
  attr a1 is parahalting means
    Initialized stop a1 is halting(NAT, {INT}, SCMPDS);
end;

:: SCMPDS_4:dfs 10
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCMPDS;
To prove
     a1 is parahalting
it is sufficient to prove
  thus Initialized stop a1 is halting(NAT, {INT}, SCMPDS);

:: SCMPDS_4:def 10
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
      b1 is parahalting
   iff
      Initialized stop b1 is halting(NAT, {INT}, SCMPDS);

:: SCMPDS_4:exreg 1
registration
  cluster Relation-like Function-like finite programmed initial parahalting Element of sproduct the Object-Kind of SCMPDS;
end;

:: SCMPDS_4:th 63
theorem
for b1 being Element of product the Object-Kind of SCMPDS
for b2 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCMPDS
      st Initialized stop b2 c= b1
   holds b1 is halting(NAT, {INT}, SCMPDS);

:: SCMPDS_4:funcreg 3
registration
  let a1 be finite programmed initial parahalting Element of sproduct the Object-Kind of SCMPDS;
  cluster Initialized stop a1 -> finite halting;
end;

:: SCMPDS_4:funcnot 10 => SCMPDS_4:func 10
definition
  let a1, a2 be Instruction-Location of SCMPDS;
  let a3, a4 be Element of the Instructions of SCMPDS;
  redefine func (a1,a2)-->(a3,a4) -> finite Element of sproduct the Object-Kind of SCMPDS;
end;

:: SCMPDS_4:th 65
theorem
for b1 being Element of product the Object-Kind of SCMPDS holds
   IC b1 <> Next IC b1;

:: SCMPDS_4:th 66
theorem
for b1 being Element of product the Object-Kind of SCMPDS holds
   b1 +* ((IC b1,Next IC b1)-->(goto 1,goto - 1)) is halting(not NAT, {INT}, SCMPDS);

:: SCMPDS_4:th 67
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b3, b4 being Element of product the Object-Kind of SCMPDS
   st b3,b4 equal_outside NAT &
      b2 c= b3 &
      b2 c= b4 &
      (for b5 being Element of NAT
            st b5 < b1
         holds IC Computation(b4,b5) in proj1 b2)
for b5 being Element of NAT
      st b5 <= b1
   holds Computation(b3,b5),Computation(b4,b5) equal_outside NAT;

:: SCMPDS_4:th 68
theorem
for b1 being Element of product the Object-Kind of SCMPDS
for b2 being Instruction-Location of SCMPDS holds
   b2 in proj1 b1;

:: SCMPDS_4:th 69
theorem
for b1 being Element of product the Object-Kind of SCMPDS
for b2, b3 being Instruction-Location of SCMPDS
for b4, b5 being Element of the Instructions of SCMPDS holds
b1 +* ((b2,b3)-->(b4,b5)) = (b1 +*(b2,b4)) +*(b3,b5);

:: SCMPDS_4:th 71
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS
for b2 being Element of product the Object-Kind of SCMPDS
      st not IC b2 in proj1 b1
   holds not Next IC b2 in proj1 b1;

:: SCMPDS_4:condreg 1
registration
  cluster finite programmed initial parahalting -> paraclosed (Element of sproduct the Object-Kind of SCMPDS);
end;

:: SCMPDS_4:th 73
theorem
inspos 0 in proj1 SCMPDS-Stop &
 SCMPDS-Stop . inspos 0 = halt SCMPDS;

:: SCMPDS_4:th 74
theorem
card SCMPDS-Stop = 1;

:: SCMPDS_4:th 75
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCMPDS holds
   inspos 0 in proj1 stop b1;

:: SCMPDS_4:th 76
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCMPDS
for b2, b3 being Element of NAT
      st b3 in proj1 b1
   holds b3 + b2 in proj1 Shift(b1,b2);

:: SCMPDS_4:prednot 1 => SCMPDS_4:pred 1
definition
  let a1 be Element of the Instructions of SCMPDS;
  let a2 be Element of NAT;
  pred A1 valid_at A2 means
    (InsCode a1 = 0 implies ex b1 being integer set st
        a1 = goto b1 & 0 <= a2 + b1) &
     (InsCode a1 = 4 implies ex b1 being Int_position st
        ex b2, b3 being integer set st
           a1 = (b1,b2)<>0_goto b3 & 0 <= a2 + b3) &
     (InsCode a1 = 5 implies ex b1 being Int_position st
        ex b2, b3 being integer set st
           a1 = (b1,b2)<=0_goto b3 & 0 <= a2 + b3) &
     (InsCode a1 = 6 implies ex b1 being Int_position st
        ex b2, b3 being integer set st
           a1 = (b1,b2)>=0_goto b3 & 0 <= a2 + b3);
end;

:: SCMPDS_4:dfs 11
definiens
  let a1 be Element of the Instructions of SCMPDS;
  let a2 be Element of NAT;
To prove
     a1 valid_at a2
it is sufficient to prove
  thus (InsCode a1 = 0 implies ex b1 being integer set st
        a1 = goto b1 & 0 <= a2 + b1) &
     (InsCode a1 = 4 implies ex b1 being Int_position st
        ex b2, b3 being integer set st
           a1 = (b1,b2)<>0_goto b3 & 0 <= a2 + b3) &
     (InsCode a1 = 5 implies ex b1 being Int_position st
        ex b2, b3 being integer set st
           a1 = (b1,b2)<=0_goto b3 & 0 <= a2 + b3) &
     (InsCode a1 = 6 implies ex b1 being Int_position st
        ex b2, b3 being integer set st
           a1 = (b1,b2)>=0_goto b3 & 0 <= a2 + b3);

:: SCMPDS_4:def 11
theorem
for b1 being Element of the Instructions of SCMPDS
for b2 being Element of NAT holds
      b1 valid_at b2
   iff
      (InsCode b1 = 0 implies ex b3 being integer set st
          b1 = goto b3 & 0 <= b2 + b3) &
       (InsCode b1 = 4 implies ex b3 being Int_position st
          ex b4, b5 being integer set st
             b1 = (b3,b4)<>0_goto b5 & 0 <= b2 + b5) &
       (InsCode b1 = 5 implies ex b3 being Int_position st
          ex b4, b5 being integer set st
             b1 = (b3,b4)<=0_goto b5 & 0 <= b2 + b5) &
       (InsCode b1 = 6 implies ex b3 being Int_position st
          ex b4, b5 being integer set st
             b1 = (b3,b4)>=0_goto b5 & 0 <= b2 + b5);

:: SCMPDS_4:th 77
theorem
for b1 being Element of the Instructions of SCMPDS
for b2, b3 being Element of NAT
      st b1 valid_at b2 & b2 <= b3
   holds b1 valid_at b3;

:: SCMPDS_4:attrnot 3 => SCMPDS_4:attr 3
definition
  let a1 be finite Element of sproduct the Object-Kind of SCMPDS;
  attr a1 is shiftable means
    for b1 being Element of NAT
    for b2 being Element of the Instructions of SCMPDS
          st inspos b1 in proj1 a1 & b2 = a1 . inspos b1
       holds InsCode b2 <> 1 & InsCode b2 <> 3 & b2 valid_at b1;
end;

:: SCMPDS_4:dfs 12
definiens
  let a1 be finite Element of sproduct the Object-Kind of SCMPDS;
To prove
     a1 is shiftable
it is sufficient to prove
  thus for b1 being Element of NAT
    for b2 being Element of the Instructions of SCMPDS
          st inspos b1 in proj1 a1 & b2 = a1 . inspos b1
       holds InsCode b2 <> 1 & InsCode b2 <> 3 & b2 valid_at b1;

:: SCMPDS_4:def 12
theorem
for b1 being finite Element of sproduct the Object-Kind of SCMPDS holds
      b1 is shiftable
   iff
      for b2 being Element of NAT
      for b3 being Element of the Instructions of SCMPDS
            st inspos b2 in proj1 b1 & b3 = b1 . inspos b2
         holds InsCode b3 <> 1 & InsCode b3 <> 3 & b3 valid_at b2;

:: SCMPDS_4:exreg 2
registration
  cluster Relation-like Function-like finite programmed initial parahalting shiftable Element of sproduct the Object-Kind of SCMPDS;
end;

:: SCMPDS_4:attrnot 4 => SCMPDS_4:attr 4
definition
  let a1 be Element of the Instructions of SCMPDS;
  attr a1 is shiftable means
    (InsCode a1 <> 2) implies 6 < InsCode a1;
end;

:: SCMPDS_4:dfs 13
definiens
  let a1 be Element of the Instructions of SCMPDS;
To prove
     a1 is shiftable
it is sufficient to prove
  thus (InsCode a1 <> 2) implies 6 < InsCode a1;

:: SCMPDS_4:def 13
theorem
for b1 being Element of the Instructions of SCMPDS holds
      b1 is shiftable
   iff
      (InsCode b1 <> 2 implies 6 < InsCode b1);

:: SCMPDS_4:exreg 3
registration
  cluster shiftable Element of the Instructions of SCMPDS;
end;

:: SCMPDS_4:funcreg 4
registration
  let a1 be Int_position;
  let a2 be integer set;
  cluster a1 := a2 -> shiftable;
end;

:: SCMPDS_4:funcreg 5
registration
  let a1 be Int_position;
  let a2, a3 be integer set;
  cluster (a1,a2):= a3 -> shiftable;
end;

:: SCMPDS_4:funcreg 6
registration
  let a1 be Int_position;
  let a2, a3 be integer set;
  cluster AddTo(a1,a2,a3) -> shiftable;
end;

:: SCMPDS_4:funcreg 7
registration
  let a1, a2 be Int_position;
  let a3, a4 be integer set;
  cluster AddTo(a1,a3,a2,a4) -> shiftable;
end;

:: SCMPDS_4:funcreg 8
registration
  let a1, a2 be Int_position;
  let a3, a4 be integer set;
  cluster SubFrom(a1,a3,a2,a4) -> shiftable;
end;

:: SCMPDS_4:funcreg 9
registration
  let a1, a2 be Int_position;
  let a3, a4 be integer set;
  cluster MultBy(a1,a3,a2,a4) -> shiftable;
end;

:: SCMPDS_4:funcreg 10
registration
  let a1, a2 be Int_position;
  let a3, a4 be integer set;
  cluster Divide(a1,a3,a2,a4) -> shiftable;
end;

:: SCMPDS_4:funcreg 11
registration
  let a1, a2 be Int_position;
  let a3, a4 be integer set;
  cluster (a1,a3):=(a2,a4) -> shiftable;
end;

:: SCMPDS_4:funcreg 12
registration
  let a1, a2 be finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS;
  cluster a1 ';' a2 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:funcreg 13
registration
  let a1 be shiftable Element of the Instructions of SCMPDS;
  cluster Load a1 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:funcreg 14
registration
  let a1 be shiftable Element of the Instructions of SCMPDS;
  let a2 be finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS;
  cluster a1 ';' a2 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:funcreg 15
registration
  let a1 be finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS;
  let a2 be shiftable Element of the Instructions of SCMPDS;
  cluster a1 ';' a2 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:funcreg 16
registration
  let a1, a2 be shiftable Element of the Instructions of SCMPDS;
  cluster a1 ';' a2 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:funcreg 17
registration
  cluster SCMPDS-Stop -> finite parahalting shiftable;
end;

:: SCMPDS_4:funcreg 18
registration
  let a1 be finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS;
  cluster stop a1 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:th 78
theorem
for b1 being finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS
for b2 being integer set
      st 0 <= (card b1) + b2
   holds b1 ';' goto b2 is shiftable;

:: SCMPDS_4:funcreg 19
registration
  let a1 be Element of NAT;
  cluster Load goto a1 -> finite programmed initial shiftable;
end;

:: SCMPDS_4:th 79
theorem
for b1 being finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS
for b2, b3 being integer set
for b4 being Int_position
      st 0 <= (card b1) + b3
   holds b1 ';' ((b4,b2)<>0_goto b3) is shiftable;

:: SCMPDS_4:funcreg 20
registration
  let a1 be integer set;
  let a2 be Int_position;
  let a3 be Element of NAT;
  cluster Load ((a2,a1)<>0_goto a3) -> finite programmed initial shiftable;
end;

:: SCMPDS_4:th 80
theorem
for b1 being finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS
for b2, b3 being integer set
for b4 being Int_position
      st 0 <= (card b1) + b3
   holds b1 ';' ((b4,b2)<=0_goto b3) is shiftable;

:: SCMPDS_4:funcreg 21
registration
  let a1 be integer set;
  let a2 be Int_position;
  let a3 be Element of NAT;
  cluster Load ((a2,a1)<=0_goto a3) -> finite programmed initial shiftable;
end;

:: SCMPDS_4:th 81
theorem
for b1 being finite programmed initial shiftable Element of sproduct the Object-Kind of SCMPDS
for b2, b3 being integer set
for b4 being Int_position
      st 0 <= (card b1) + b3
   holds b1 ';' ((b4,b2)>=0_goto b3) is shiftable;

:: SCMPDS_4:funcreg 22
registration
  let a1 be integer set;
  let a2 be Int_position;
  let a3 be Element of NAT;
  cluster Load ((a2,a1)>=0_goto a3) -> finite programmed initial shiftable;
end;

:: SCMPDS_4:th 82
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
for b3, b4 being Element of NAT
for b5 being integer set
      st IC b1 = inspos b4 & 0 <= b4 + b5 & (IC b1) + b3 = IC b2
   holds (ICplusConst(b1,b5)) + b3 = ICplusConst(b2,b5);

:: SCMPDS_4:th 83
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
for b3, b4 being Element of NAT
for b5 being Element of the Instructions of SCMPDS
      st IC b1 = inspos b4 & b5 valid_at b4 & InsCode b5 <> 1 & InsCode b5 <> 3 & (IC b1) + b3 = IC b2 & b1 | SCM-Data-Loc = b2 | SCM-Data-Loc
   holds (IC Exec(b5,b1)) + b3 = IC Exec(b5,b2) &
    (Exec(b5,b1)) | SCM-Data-Loc = (Exec(b5,b2)) | SCM-Data-Loc;

:: SCMPDS_4:th 84
theorem
for b1, b2 being Element of product the Object-Kind of SCMPDS
for b3 being finite programmed initial parahalting shiftable Element of sproduct the Object-Kind of SCMPDS
   st Initialized stop b3 c= b1
for b4 being Element of NAT
   st Shift(stop b3,b4) c= b2 & IC b2 = inspos b4 & b1 | SCM-Data-Loc = b2 | SCM-Data-Loc
for b5 being Element of NAT holds
   (IC Computation(b1,b5)) + b4 = IC Computation(b2,b5) &
    CurInstr Computation(b1,b5) = CurInstr Computation(b2,b5) &
    (Computation(b1,b5)) | SCM-Data-Loc = (Computation(b2,b5)) | SCM-Data-Loc;