Article SCM_HALT, MML version 4.99.1005

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

:: SCM_HALT:dfs 1
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is InitClosed
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of SCM+FSA
    for b2 being Element of NAT
          st Initialized a1 c= b1
       holds IC Computation(b1,b2) in proj1 a1;

:: SCM_HALT:def 1
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is InitClosed
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA
      for b3 being Element of NAT
            st Initialized b1 c= b2
         holds IC Computation(b2,b3) in proj1 b1;

:: SCM_HALT:attrnot 2 => SCM_HALT:attr 2
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  attr a1 is InitHalting means
    Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);
end;

:: SCM_HALT:dfs 2
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is InitHalting
it is sufficient to prove
  thus Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCM_HALT:def 2
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is InitHalting
   iff
      Initialized b1 is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCM_HALT:attrnot 3 => SCM_HALT:attr 3
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  attr a1 is keepInt0_1 means
    for b1 being Element of product the Object-Kind of SCM+FSA
       st Initialized a1 c= b1
    for b2 being Element of NAT holds
       (Computation(b1,b2)) . intloc 0 = 1;
end;

:: SCM_HALT:dfs 3
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is keepInt0_1
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of SCM+FSA
       st Initialized a1 c= b1
    for b2 being Element of NAT holds
       (Computation(b1,b2)) . intloc 0 = 1;

:: SCM_HALT:def 3
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is keepInt0_1
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA
         st Initialized b1 c= b2
      for b3 being Element of NAT holds
         (Computation(b2,b3)) . intloc 0 = 1;

:: SCM_HALT:th 1
theorem
for b1 being set
for b2, b3, b4 being Element of NAT
      st b1 in proj1 (((intloc b2) .--> b3) +* Start-At insloc b4) &
         b1 <> intloc b2
   holds b1 = IC SCM+FSA;

:: SCM_HALT:th 2
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2, b3, b4 being Element of NAT holds
proj1 b1 misses proj1 (((intloc b2) .--> b3) +* Start-At insloc b4);

:: SCM_HALT:th 3
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   Initialized b1 = b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0);

:: SCM_HALT:th 4
theorem
Macro halt SCM+FSA is InitHalting;

:: SCM_HALT:exreg 1
registration
  cluster Relation-like Function-like finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
end;

:: SCM_HALT:th 5
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
      st Initialized b2 c= b1
   holds b1 is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCM_HALT:th 6
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   b1 +* Start-At insloc 0 c= Initialized b1;

:: SCM_HALT:th 7
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
      st Initialized b1 c= b2
   holds b2 . intloc 0 = 1;

:: SCM_HALT:condreg 1
registration
  cluster finite programmed initial paraclosed -> InitClosed (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:condreg 2
registration
  cluster finite programmed initial parahalting -> InitHalting (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:condreg 3
registration
  cluster finite programmed initial InitHalting -> InitClosed (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:condreg 4
registration
  cluster finite programmed initial keepInt0_1 -> InitClosed (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:condreg 5
registration
  cluster finite programmed initial keeping_0 -> keepInt0_1 (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:th 8
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st not b3 in UsedIntLoc b2
   holds (IExec(b2,b1)) . b3 = b1 . b3;

:: SCM_HALT:th 9
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being FinSeq-Location
      st not b3 in UsedInt*Loc b2
   holds (IExec(b2,b1)) . b3 = b1 . b3;

:: SCM_HALT:funcreg 1
registration
  let a1 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
  cluster Initialized a1 -> finite halting;
end;

:: SCM_HALT:condreg 6
registration
  cluster finite programmed initial InitHalting -> non empty (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:th 10
theorem
for b1 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
   proj1 b1 <> {};

:: SCM_HALT:th 11
theorem
for b1 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
   insloc 0 in proj1 b1;

:: SCM_HALT:th 12
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
   st Initialized b3 c= b1
for b4 being Element of NAT
   st ProgramPart Relocated(b3,b4) c= b2 &
      IC b2 = insloc b4 &
      b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations)
for b5 being Element of NAT holds
   (IC Computation(b1,b5)) + b4 = IC Computation(b2,b5) &
    IncAddr(CurInstr Computation(b1,b5),b4) = CurInstr Computation(b2,b5) &
    (Computation(b1,b5)) | (Int-Locations \/ FinSeq-Locations) = (Computation(b2,b5)) | (Int-Locations \/ FinSeq-Locations);

:: SCM_HALT:th 13
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
      st Initialized b1 c= b2
   holds b1 c= b2;

:: SCM_HALT:th 14
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
   st Initialized b3 c= b1 & Initialized b3 c= b2 & b1,b2 equal_outside NAT
for b4 being Element of NAT holds
   Computation(b1,b4),Computation(b2,b4) equal_outside NAT & CurInstr Computation(b1,b4) = CurInstr Computation(b2,b4);

:: SCM_HALT:th 15
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
      st Initialized b3 c= b1 & Initialized b3 c= b2 & b1,b2 equal_outside NAT
   holds LifeSpan b1 = LifeSpan b2 & Result b1,Result b2 equal_outside NAT;

:: SCM_HALT:exreg 2
registration
  cluster Relation-like Function-like finite programmed initial keeping_0 InitHalting Element of sproduct the Object-Kind of SCM+FSA;
end;

:: SCM_HALT:exreg 3
registration
  cluster Relation-like Function-like finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
end;

:: SCM_HALT:th 17
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA holds
   (IExec(b2,b1)) . intloc 0 = 1;

:: SCM_HALT:th 18
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st Initialized b2 c= b1 &
      b1 is halting(NAT, {INT,INT *}, SCM+FSA)
for b4 being Element of NAT
      st b4 <= LifeSpan b1
   holds Computation(b1,b4),Computation(b1 +* (b2 ';' b3),b4) equal_outside NAT;

:: SCM_HALT:th 19
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
for b3, b4, b5 being Element of NAT holds
(b2 +* b1) +* (((intloc b3) .--> b4) +* Start-At insloc b5) = (b2 +* (((intloc b3) .--> b4) +* Start-At insloc b5)) +* b1;

:: SCM_HALT:th 20
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
      st ((intloc 0) .--> 1) +* Start-At insloc 0 c= b2
   holds Initialized b1 c= b2 +* (b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0)) &
    b2 +* (b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0)) = b2 +* b1 &
    (b2 +* (b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0))) +* Directed b1 = b2 +* Directed b1;

:: SCM_HALT:th 21
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
      st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA) &
         Directed b2 c= b1 &
         ((intloc 0) .--> 1) +* Start-At insloc 0 c= b1
   holds IC Computation(b1,(LifeSpan (b1 +* b2)) + 1) = insloc card b2;

:: SCM_HALT:th 22
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
      st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA) &
         Directed b2 c= b1 &
         ((intloc 0) .--> 1) +* Start-At insloc 0 c= b1
   holds (Computation(b1,LifeSpan (b1 +* b2))) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1,(LifeSpan (b1 +* b2)) + 1)) | (Int-Locations \/ FinSeq-Locations);

:: SCM_HALT:th 23
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
   st Initialized b2 c= b1
for b3 being Element of NAT
      st b3 <= LifeSpan b1
   holds CurInstr Computation(b1 +* Directed b2,b3) <> halt SCM+FSA;

:: SCM_HALT:th 24
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
   st b1 +* Initialized b2 is halting(NAT, {INT,INT *}, SCM+FSA)
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
      st b4 <= LifeSpan (b1 +* Initialized b2)
   holds Computation(b1 +* Initialized b2,b4),Computation(b1 +* Initialized (b2 ';' b3),b4) equal_outside NAT;

:: SCM_HALT:th 25
theorem
for b1 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Element of product the Object-Kind of SCM+FSA
      st Initialized (b1 ';' b2) c= b3
   holds IC Computation(b3,(LifeSpan (b3 +* b1)) + 1) = insloc card b1 &
    (Computation(b3,(LifeSpan (b3 +* b1)) + 1)) | (Int-Locations \/ FinSeq-Locations) = ((Computation(b3 +* b1,LifeSpan (b3 +* b1))) +* Initialized b2) | (Int-Locations \/ FinSeq-Locations) &
    ProgramPart Relocated(b2,card b1) c= Computation(b3,(LifeSpan (b3 +* b1)) + 1) &
    (Computation(b3,(LifeSpan (b3 +* b1)) + 1)) . intloc 0 = 1 &
    b3 is halting(NAT, {INT,INT *}, SCM+FSA) &
    LifeSpan b3 = ((LifeSpan (b3 +* b1)) + 1) + LifeSpan ((Result (b3 +* b1)) +* Initialized b2) &
    (b2 is keeping_0 implies (Result b3) . intloc 0 = 1);

:: SCM_HALT:funcreg 2
registration
  let a1 be finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;

:: SCM_HALT:th 26
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
   st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA)
for b3 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
   st Initialized (b2 ';' b3) c= b1
for b4 being Element of NAT holds
   (Computation((Result (b1 +* b2)) +* Initialized b3,b4)) +* Start-At ((IC Computation((Result (b1 +* b2)) +* Initialized b3,b4)) + card b2),Computation(b1 +* (b2 ';' b3),((LifeSpan (b1 +* b2)) + 1) + b4) equal_outside NAT;

:: SCM_HALT:th 27
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
   st b1 +* Initialized b2 is halting(not NAT, {INT,INT *}, SCM+FSA)
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT holds
   Computation(b1 +* Initialized b2,b4),Computation(b1 +* Initialized (b2 ';' b3),b4) equal_outside NAT;

:: SCM_HALT:th 28
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
   LifeSpan (b1 +* Initialized (b2 ';' b3)) = ((LifeSpan (b1 +* Initialized b2)) + 1) + LifeSpan ((Result (b1 +* Initialized b2)) +* Initialized b3);

:: SCM_HALT:th 29
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
   IExec(b2 ';' b3,b1) = (IExec(b3,IExec(b2,b1))) +* Start-At ((IC IExec(b3,IExec(b2,b1))) + card b2);

:: SCM_HALT:funcreg 3
registration
  let a1 be parahalting Element of the Instructions of SCM+FSA;
  cluster Macro a1 -> finite programmed initial InitHalting;
end;

:: SCM_HALT:funcreg 4
registration
  let a1 be parahalting Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;

:: SCM_HALT:funcreg 5
registration
  let a1 be parahalting keeping_0 Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;

:: SCM_HALT:funcreg 6
registration
  let a1, a2 be finite programmed initial keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial keepInt0_1;
end;

:: SCM_HALT:funcreg 7
registration
  let a1 be parahalting keeping_0 Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
  cluster a2 ';' a1 -> finite programmed initial InitHalting keepInt0_1;
end;

:: SCM_HALT:funcreg 8
registration
  let a1 be parahalting keeping_0 Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial InitHalting keepInt0_1;
end;

:: SCM_HALT:funcreg 9
registration
  let a1 be parahalting Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA;
  cluster a2 ';' a1 -> finite programmed initial InitHalting;
end;

:: SCM_HALT:funcreg 10
registration
  let a1, a2 be parahalting Element of the Instructions of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;

:: SCM_HALT:th 30
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Int-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
   (IExec(b3 ';' b4,b1)) . b2 = (IExec(b4,IExec(b3,b1))) . b2;

:: SCM_HALT:th 31
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being FinSeq-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
   (IExec(b3 ';' b4,b1)) . b2 = (IExec(b4,IExec(b3,b1))) . b2;

:: SCM_HALT:th 32
theorem
for b1 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
   (Initialize IExec(b1,b2)) | (Int-Locations \/ FinSeq-Locations) = (IExec(b1,b2)) | (Int-Locations \/ FinSeq-Locations);

:: SCM_HALT:th 33
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Int-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being parahalting Element of the Instructions of SCM+FSA holds
   (IExec(b3 ';' b4,b1)) . b2 = (Exec(b4,IExec(b3,b1))) . b2;

:: SCM_HALT:th 34
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being FinSeq-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being parahalting Element of the Instructions of SCM+FSA holds
   (IExec(b3 ';' b4,b1)) . b2 = (Exec(b4,IExec(b3,b1))) . b2;

:: SCM_HALT:prednot 1 => SCM_HALT:pred 1
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Element of product the Object-Kind of SCM+FSA;
  pred A1 is_closed_onInit A2 means
    for b1 being Element of NAT holds
       IC Computation(a2 +* Initialized a1,b1) in proj1 a1;
end;

:: SCM_HALT:dfs 4
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Element of product the Object-Kind of SCM+FSA;
To prove
     a1 is_closed_onInit a2
it is sufficient to prove
  thus for b1 being Element of NAT holds
       IC Computation(a2 +* Initialized a1,b1) in proj1 a1;

:: SCM_HALT:def 4
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
      b1 is_closed_onInit b2
   iff
      for b3 being Element of NAT holds
         IC Computation(b2 +* Initialized b1,b3) in proj1 b1;

:: SCM_HALT:prednot 2 => SCM_HALT:pred 2
definition
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Element of product the Object-Kind of SCM+FSA;
  pred A1 is_halting_onInit A2 means
    a2 +* Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);
end;

:: SCM_HALT:dfs 5
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Element of product the Object-Kind of SCM+FSA;
To prove
     a1 is_halting_onInit a2
it is sufficient to prove
  thus a2 +* Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCM_HALT:def 5
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
      b1 is_halting_onInit b2
   iff
      b2 +* Initialized b1 is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCM_HALT:th 35
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is InitClosed
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA holds
         b1 is_closed_onInit b2;

:: SCM_HALT:th 36
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is InitHalting
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA holds
         b1 is_halting_onInit b2;

:: SCM_HALT:th 37
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
   st b2 does_not_destroy b3 & b2 is_closed_onInit b1 & Initialized b2 c= b1
for b4 being Element of NAT holds
   (Computation(b1,b4)) . b3 = b1 . b3;

:: SCM_HALT:exreg 4
registration
  cluster Relation-like Function-like finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA;
end;

:: SCM_HALT:condreg 7
registration
  cluster finite programmed initial good InitClosed -> keepInt0_1 (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCM_HALT:funcreg 11
registration
  cluster SCM+FSA-Stop -> finite good InitHalting;
end;

:: SCM_HALT:th 38
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being parahalting keeping_0 Element of the Instructions of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being Int-Location holds
   (IExec(b2 ';' b3,b1)) . b4 = (IExec(b3,Exec(b2,Initialize b1))) . b4;

:: SCM_HALT:th 39
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being parahalting keeping_0 Element of the Instructions of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being FinSeq-Location holds
   (IExec(b2 ';' b3,b1)) . b4 = (IExec(b3,Exec(b2,Initialize b1))) . b4;

:: SCM_HALT:th 40
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b2 is_closed_onInit b1
   iff
      b2 is_closed_on Initialize b1;

:: SCM_HALT:th 41
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b2 is_halting_onInit b1
   iff
      b2 is_halting_on Initialize b1;

:: SCM_HALT:th 42
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
   IExec(b1,b2) = IExec(b1,Initialize b2);

:: SCM_HALT:th 43
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st b1 . b4 = 0 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds if=0(b4,b2,b3) is_closed_onInit b1 & if=0(b4,b2,b3) is_halting_onInit b1;

:: SCM_HALT:th 44
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st b1 . b4 = 0 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds IExec(if=0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3);

:: SCM_HALT:th 45
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st b1 . b4 <> 0 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
   holds if=0(b4,b2,b3) is_closed_onInit b1 & if=0(b4,b2,b3) is_halting_onInit b1;

:: SCM_HALT:th 46
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being Element of product the Object-Kind of SCM+FSA
      st b4 . b3 <> 0 & b2 is_closed_onInit b4 & b2 is_halting_onInit b4
   holds IExec(if=0(b3,b1,b2),b4) = (IExec(b2,b4)) +* Start-At insloc (((card b1) + card b2) + 3);

:: SCM_HALT:th 47
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
   if=0(b4,b2,b3) is InitHalting &
    (b1 . b4 = 0 implies IExec(if=0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3)) &
    (b1 . b4 = 0 or IExec(if=0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc (((card b2) + card b3) + 3));

:: SCM_HALT:th 48
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
   IC IExec(if=0(b4,b2,b3),b1) = insloc (((card b2) + card b3) + 3) &
    (b1 . b4 = 0 implies (for b5 being Int-Location holds
        (IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5) &
     (for b5 being FinSeq-Location holds
        (IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5)) &
    (b1 . b4 = 0 or (for b5 being Int-Location holds
        (IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5) &
     (for b5 being FinSeq-Location holds
        (IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5));

:: SCM_HALT:th 49
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st 0 < b1 . b4 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds if>0(b4,b2,b3) is_closed_onInit b1 & if>0(b4,b2,b3) is_halting_onInit b1;

:: SCM_HALT:th 50
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st 0 < b1 . b4 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds IExec(if>0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3);

:: SCM_HALT:th 51
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st b1 . b4 <= 0 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
   holds if>0(b4,b2,b3) is_closed_onInit b1 & if>0(b4,b2,b3) is_halting_onInit b1;

:: SCM_HALT:th 52
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being Element of product the Object-Kind of SCM+FSA
      st b4 . b3 <= 0 & b2 is_closed_onInit b4 & b2 is_halting_onInit b4
   holds IExec(if>0(b3,b1,b2),b4) = (IExec(b2,b4)) +* Start-At insloc (((card b1) + card b2) + 3);

:: SCM_HALT:th 53
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
   if>0(b4,b2,b3) is InitHalting &
    (b1 . b4 <= 0 or IExec(if>0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3)) &
    (b1 . b4 <= 0 implies IExec(if>0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc (((card b2) + card b3) + 3));

:: SCM_HALT:th 54
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
   IC IExec(if>0(b4,b2,b3),b1) = insloc (((card b2) + card b3) + 3) &
    (b1 . b4 <= 0 or (for b5 being Int-Location holds
        (IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5) &
     (for b5 being FinSeq-Location holds
        (IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5)) &
    (b1 . b4 <= 0 implies (for b5 being Int-Location holds
        (IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5) &
     (for b5 being FinSeq-Location holds
        (IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5));

:: SCM_HALT:th 55
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st b1 . b4 < 0 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds IExec(if<0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7);

:: SCM_HALT:th 56
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st b1 . b4 = 0 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
   holds IExec(if<0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7);

:: SCM_HALT:th 57
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
      st 0 < b1 . b4 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
   holds IExec(if<0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7);

:: SCM_HALT:th 58
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
   if<0(b4,b2,b3) is InitHalting &
    (0 <= b1 . b4 or IExec(if<0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7)) &
    (0 <= b1 . b4 implies IExec(if<0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7));

:: SCM_HALT:funcreg 12
registration
  let a1, a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
  let a3 be read-write Int-Location;
  cluster if=0(a3,a1,a2) -> finite programmed initial InitHalting;
end;

:: SCM_HALT:funcreg 13
registration
  let a1, a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
  let a3 be read-write Int-Location;
  cluster if>0(a3,a1,a2) -> finite programmed initial InitHalting;
end;

:: SCM_HALT:funcreg 14
registration
  let a1, a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
  let a3 be read-write Int-Location;
  cluster if<0(a3,a1,a2) -> finite programmed initial InitHalting;
end;

:: SCM_HALT:th 59
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is InitHalting
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA holds
         b1 is_halting_on Initialize b2;

:: SCM_HALT:th 60
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is InitClosed
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA holds
         b1 is_closed_on Initialize b2;

:: SCM_HALT:th 61
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location holds
   (IExec(b2,b1)) . b3 = (Computation((Initialize b1) +* (b2 +* Start-At insloc 0),LifeSpan ((Initialize b1) +* (b2 +* Start-At insloc 0)))) . b3;

:: SCM_HALT:th 62
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
for b4 being Element of NAT
      st b2 does_not_destroy b3
   holds (IExec(b2,b1)) . b3 = (Computation((Initialize b1) +* (b2 +* Start-At insloc 0),b4)) . b3;

:: SCM_HALT:th 63
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
      st b2 does_not_destroy b3
   holds (IExec(b2,b1)) . b3 = (Initialize b1) . b3;

:: SCM_HALT:th 64
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b2 does_not_destroy b3
   holds (Computation((Initialize b1) +* ((b2 ';' SubFrom(b3,intloc 0)) +* Start-At insloc 0),LifeSpan ((Initialize b1) +* ((b2 ';' SubFrom(b3,intloc 0)) +* Start-At insloc 0)))) . b3 = (b1 . b3) - 1;

:: SCM_HALT:th 65
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
   st Initialized b2 c= b1 &
      b1 is halting(NAT, {INT,INT *}, SCM+FSA)
for b3 being Element of NAT
      st b3 <= LifeSpan b1
   holds Computation(b1,b3),Computation(b1 +* loop b2,b3) equal_outside NAT;

:: SCM_HALT:th 66
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
   st Initialized b2 c= b1
for b3 being Element of NAT
      st b3 <= LifeSpan b1
   holds CurInstr Computation(b1 +* loop b2,b3) <> halt SCM+FSA;

:: SCM_HALT:th 67
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
   b1 c= b2 +* Initialized b1;

:: SCM_HALT:th 68
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
for b3 being Element of NAT
      st b3 <= LifeSpan (b1 +* Initialized b2)
   holds Computation(b1 +* Initialized b2,b3),Computation(b1 +* Initialized loop b2,b3) equal_outside NAT;

:: SCM_HALT:th 69
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
for b3 being Element of NAT
      st b3 < LifeSpan (b1 +* Initialized b2)
   holds CurInstr Computation(b1 +* Initialized b2,b3) = CurInstr Computation(b1 +* Initialized loop b2,b3);

:: SCM_HALT:th 70
theorem
for b1 being Instruction-Location of SCM+FSA holds
   not b1 in proj1 (((intloc 0) .--> 1) +* Start-At insloc 0);

:: SCM_HALT:th 71
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds CurInstr Computation(b1 +* Initialized loop b2,LifeSpan (b1 +* Initialized b2)) = goto insloc 0 &
    (for b3 being Element of NAT
          st b3 <= LifeSpan (b1 +* Initialized b2)
       holds CurInstr Computation(b1 +* Initialized loop b2,b3) <> halt SCM+FSA);

:: SCM_HALT:th 72
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
   holds CurInstr Computation(b1 +* Initialized loop b2,LifeSpan (b1 +* Initialized b2)) = goto insloc 0;

:: SCM_HALT:th 73
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b2 does_not_destroy b3 & b1 . intloc 0 = 1 & 0 < b1 . b3
   holds loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)) is_pseudo-closed_on b1;

:: SCM_HALT:th 74
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b2 does_not_destroy b3 & 0 < b1 . b3
   holds Initialized loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)) is_pseudo-closed_on b1;

:: SCM_HALT:th 75
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b2 does_not_destroy b3 & b1 . intloc 0 = 1
   holds Times(b3,b2) is_closed_on b1 & Times(b3,b2) is_halting_on b1;

:: SCM_HALT:th 76
theorem
for b1 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
      st b1 does_not_destroy b2
   holds Initialized Times(b2,b1) is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCM_HALT:funcreg 15
registration
  let a1 be read-write Int-Location;
  let a2 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
  cluster Times(a1,a2) -> finite programmed initial good;
end;

:: SCM_HALT:th 77
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b2 does_not_destroy b3 & 0 < b1 . b3
   holds ex b4 being Element of product the Object-Kind of SCM+FSA st
      ex b5 being Element of NAT st
         b4 = b1 +* Initialized loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)) &
          b5 = (LifeSpan (b1 +* Initialized if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)))) + 1 &
          (Computation(b4,b5)) . b3 = (b1 . b3) - 1 &
          (Computation(b4,b5)) . intloc 0 = 1 &
          (for b6 being read-write Int-Location
                st b6 <> b3
             holds (Computation(b4,b5)) . b6 = (IExec(b2,b1)) . b6) &
          (for b6 being FinSeq-Location holds
             (Computation(b4,b5)) . b6 = (IExec(b2,b1)) . b6) &
          IC Computation(b4,b5) = insloc 0 &
          (for b6 being Element of NAT
                st b6 <= b5
             holds IC Computation(b4,b6) in proj1 loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)));

:: SCM_HALT:th 78
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b1 . intloc 0 = 1 & b1 . b3 <= 0
   holds (IExec(Times(b3,b2),b1)) | (Int-Locations \/ FinSeq-Locations) = b1 | (Int-Locations \/ FinSeq-Locations);

:: SCM_HALT:th 79
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
      st b2 does_not_destroy b3 & 0 < b1 . b3
   holds (IExec(b2 ';' SubFrom(b3,intloc 0),b1)) . b3 = (b1 . b3) - 1 &
    (IExec(Times(b3,b2),b1)) | (Int-Locations \/ FinSeq-Locations) = (IExec(Times(b3,b2),IExec(b2 ';' SubFrom(b3,intloc 0),b1))) | (Int-Locations \/ FinSeq-Locations);

:: SCM_HALT:th 80
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being FinSeq-Location
for b4 being read-write Int-Location
      st b1 . b4 <= 0
   holds (IExec(Times(b4,b2),b1)) . b3 = b1 . b3;

:: SCM_HALT:th 81
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
for b4 being read-write Int-Location
      st b1 . b4 <= 0
   holds (IExec(Times(b4,b2),b1)) . b3 = (Initialize b1) . b3;

:: SCM_HALT:th 82
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being FinSeq-Location
for b4 being read-write Int-Location
      st b2 does_not_destroy b4 & 0 < b1 . b4
   holds (IExec(Times(b4,b2),b1)) . b3 = (IExec(Times(b4,b2),IExec(b2 ';' SubFrom(b4,intloc 0),b1))) . b3;

:: SCM_HALT:th 83
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
for b4 being read-write Int-Location
      st b2 does_not_destroy b4 & 0 < b1 . b4
   holds (IExec(Times(b4,b2),b1)) . b3 = (IExec(Times(b4,b2),IExec(b2 ';' SubFrom(b4,intloc 0),b1))) . b3;

:: SCM_HALT:attrnot 4 => SCM_HALT:attr 4
definition
  let a1 be Element of the Instructions of SCM+FSA;
  attr a1 is good means
    a1 does_not_destroy intloc 0;
end;

:: SCM_HALT:dfs 6
definiens
  let a1 be Element of the Instructions of SCM+FSA;
To prove
     a1 is good
it is sufficient to prove
  thus a1 does_not_destroy intloc 0;

:: SCM_HALT:def 6
theorem
for b1 being Element of the Instructions of SCM+FSA holds
      b1 is good
   iff
      b1 does_not_destroy intloc 0;

:: SCM_HALT:exreg 5
registration
  cluster parahalting good Element of the Instructions of SCM+FSA;
end;

:: SCM_HALT:funcreg 16
registration
  let a1 be good Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial good;
end;

:: SCM_HALT:funcreg 17
registration
  let a1 be good Element of the Instructions of SCM+FSA;
  let a2 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
  cluster a2 ';' a1 -> finite programmed initial good;
end;

:: SCM_HALT:funcreg 18
registration
  let a1, a2 be good Element of the Instructions of SCM+FSA;
  cluster a1 ';' a2 -> finite programmed initial good;
end;

:: SCM_HALT:funcreg 19
registration
  let a1 be read-write Int-Location;
  let a2 be Int-Location;
  cluster a1 := a2 -> good;
end;

:: SCM_HALT:funcreg 20
registration
  let a1 be read-write Int-Location;
  let a2 be Int-Location;
  cluster SubFrom(a1,a2) -> good;
end;

:: SCM_HALT:funcreg 21
registration
  let a1 be read-write Int-Location;
  let a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster a1 :=(a3,a2) -> good;
end;

:: SCM_HALT:funcreg 22
registration
  let a1, a2 be Int-Location;
  let a3 be FinSeq-Location;
  cluster (a3,a1):= a2 -> good;
end;

:: SCM_HALT:funcreg 23
registration
  let a1 be read-write Int-Location;
  let a2 be FinSeq-Location;
  cluster a1 :=len a2 -> good;
end;

:: SCM_HALT:funcreg 24
registration
  let a1 be Element of NAT;
  cluster intloc (a1 + 1) -> read-write;
end;