Article SCMFSA6B, MML version 4.99.1005

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

:: SCMFSA6B:th 5
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being Element of product the Object-Kind of SCM+FSA
      st b2 +* Start-At insloc b1 c= b3
   holds b2 c= b3;

:: SCMFSA6B:th 6
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   (b2 +* Start-At insloc b1) | NAT = b2;

:: SCMFSA6B:th 7
theorem
for b1 being Element of NAT
for b2 being set
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b2 in proj1 b3
   holds b3 . b2 = (b3 +* Start-At insloc b1) . b2;

:: SCMFSA6B:th 8
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 +* Start-At insloc 0 c= b2;

:: SCMFSA6B:th 9
theorem
for b1 being Int-Location
for b2 being Instruction-Location of SCM+FSA holds
   not b1 in proj1 Start-At b2;

:: SCMFSA6B:th 10
theorem
for b1 being FinSeq-Location
for b2 being Instruction-Location of SCM+FSA holds
   not b1 in proj1 Start-At b2;

:: SCMFSA6B:th 11
theorem
for b1, b2 being Instruction-Location of SCM+FSA holds
not b1 in proj1 Start-At b2;

:: SCMFSA6B:th 12
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Int-Location
for b3 being Instruction-Location of SCM+FSA holds
   not b2 in proj1 (b1 +* Start-At b3);

:: SCMFSA6B:th 13
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being FinSeq-Location
for b3 being Instruction-Location of SCM+FSA holds
   not b2 in proj1 (b1 +* Start-At b3);

:: SCMFSA6B:th 14
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
   (b2 +* b1) +* Start-At insloc 0 = (b2 +* Start-At insloc 0) +* b1;

:: SCMFSA6B:th 15
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
   st b4 = Following b4
for b5 being Element of NAT holds
   Computation(b4,b5) = b4;

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

:: SCMFSA6B:funcnot 2 => SCMFSA6B:func 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;
  func IExec(A1,A2) -> Element of product the Object-Kind of SCM+FSA equals
    (Result (a2 +* Initialized a1)) +* (a2 | NAT);
end;

:: SCMFSA6B:def 1
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) = (Result (b2 +* Initialized b1)) +* (b2 | NAT);

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

:: SCMFSA6B:dfs 2
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is paraclosed
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 a1 +* Start-At insloc 0 c= b1
       holds IC Computation(b1,b2) in proj1 a1;

:: SCMFSA6B:def 2
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is paraclosed
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA
      for b3 being Element of NAT
            st b1 +* Start-At insloc 0 c= b2
         holds IC Computation(b2,b3) in proj1 b1;

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

:: SCMFSA6B:dfs 3
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is parahalting
it is sufficient to prove
  thus a1 +* Start-At insloc 0 is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCMFSA6B:def 3
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is parahalting
   iff
      b1 +* Start-At insloc 0 is halting(NAT, {INT,INT *}, SCM+FSA);

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

:: SCMFSA6B:dfs 4
definiens
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is keeping_0
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of SCM+FSA
       st a1 +* Start-At insloc 0 c= b1
    for b2 being Element of NAT holds
       (Computation(b1,b2)) . intloc 0 = b1 . intloc 0;

:: SCMFSA6B:def 4
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is keeping_0
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA
         st b1 +* Start-At insloc 0 c= b2
      for b3 being Element of NAT holds
         (Computation(b2,b3)) . intloc 0 = b2 . intloc 0;

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

:: SCMFSA6B:th 18
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA
      st b2 +* Start-At insloc 0 c= b1
   holds b1 is halting(NAT, {INT,INT *}, SCM+FSA);

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

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

:: SCMFSA6B:th 20
theorem
for b1 being Element of product the Object-Kind of SCM+FSA holds
   b1 +*(IC b1,goto IC b1) is halting(not NAT, {INT,INT *}, SCM+FSA);

:: SCMFSA6B:th 21
theorem
for b1 being Element of NAT
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3, b4 being Element of product the Object-Kind of SCM+FSA
   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;

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

:: SCMFSA6B:condreg 2
registration
  cluster finite programmed initial keeping_0 -> paraclosed (Element of sproduct the Object-Kind of SCM+FSA);
end;

:: SCMFSA6B:th 22
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial parahalting 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;

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

:: SCMFSA6B:th 24
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
      st IC b2 = b1 & b2 . b1 = goto b1
   holds b2 is halting(not NAT, {INT,INT *}, SCM+FSA);

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

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

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

:: SCMFSA6B:th 27
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA
   st b3 +* Start-At insloc 0 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);

:: SCMFSA6B:th 28
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA
   st b3 +* Start-At insloc 0 c= b1 & b3 +* Start-At insloc 0 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);

:: SCMFSA6B:th 29
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA
      st b3 +* Start-At insloc 0 c= b1 & b3 +* Start-At insloc 0 c= b2 & b1,b2 equal_outside NAT
   holds LifeSpan b1 = LifeSpan b2 & Result b1,Result b2 equal_outside NAT;

:: SCMFSA6B:th 30
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA holds
   IC IExec(b2,b1) = IC Result (b1 +* Initialized b2);

:: SCMFSA6B:th 31
theorem
for b1 being non empty finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   insloc 0 in proj1 b1 &
    insloc 0 in proj1 Initialized b1 &
    insloc 0 in proj1 (b1 +* Start-At insloc 0);

:: SCMFSA6B:th 32
theorem
for b1 being set
for b2 being Element of the Instructions of SCM+FSA holds
      b1 in proj1 Macro b2
   iff
      (b1 = insloc 0 or b1 = insloc 1);

:: SCMFSA6B:th 33
theorem
for b1 being Element of the Instructions of SCM+FSA holds
   (Macro b1) . insloc 0 = b1 &
    (Macro b1) . insloc 1 = halt SCM+FSA &
    (Initialized Macro b1) . insloc 0 = b1 &
    (Initialized Macro b1) . insloc 1 = halt SCM+FSA &
    ((Macro b1) +* Start-At insloc 0) . insloc 0 = b1;

:: SCMFSA6B:th 34
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 IC b2 = insloc 0;

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

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

:: SCMFSA6B:th 36
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial paraclosed 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 b2 +* Start-At insloc 0 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;

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

:: SCMFSA6B:th 38
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial paraclosed Element of sproduct the Object-Kind of SCM+FSA
      st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA) &
         Directed b2 c= b1 &
         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);

:: SCMFSA6B:th 39
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial parahalting 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;

:: SCMFSA6B:th 40
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial paraclosed Element of sproduct the Object-Kind of SCM+FSA
   st b1 +* (b2 +* Start-At insloc 0) 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 +* (b2 +* Start-At insloc 0))
   holds Computation(b1 +* (b2 +* Start-At insloc 0),b4),Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),b4) equal_outside NAT;

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

:: SCMFSA6B:th 41
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial keeping_0 Element of sproduct the Object-Kind of SCM+FSA
   st b1 +* (b2 +* Start-At insloc 0) 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 +* (b2 +* Start-At insloc 0),b4),Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),b4) equal_outside NAT;

:: SCMFSA6B:th 42
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial keeping_0 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 paraclosed Element of sproduct the Object-Kind of SCM+FSA
   st (b2 ';' b3) +* Start-At insloc 0 c= b1
for b4 being Element of NAT holds
   (Computation((Result (b1 +* b2)) +* (b3 +* Start-At insloc 0),b4)) +* Start-At ((IC Computation((Result (b1 +* b2)) +* (b3 +* Start-At insloc 0),b4)) + card b2),Computation(b1 +* (b2 ';' b3),((LifeSpan (b1 +* b2)) + 1) + b4) equal_outside NAT;

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

:: SCMFSA6B:th 43
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial parahalting keeping_0 Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial parahalting 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);

:: SCMFSA6B:th 44
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial parahalting keeping_0 Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial parahalting 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);