Article SCMFSA8A, MML version 4.99.1005

:: SCMFSA8A:th 3
theorem
for b1 being Element of product the Object-Kind of SCM+FSA holds
   proj1 (b1 | NAT) = NAT;

:: SCMFSA8A:th 4
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
   st b1 is halting(NAT, {INT,INT *}, SCM+FSA)
for b2 being Element of NAT
      st LifeSpan b1 <= b2
   holds CurInstr Computation(b1,b2) = halt SCM+FSA;

:: SCMFSA8A:th 5
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
   st b1 is halting(NAT, {INT,INT *}, SCM+FSA)
for b2 being Element of NAT
      st LifeSpan b1 <= b2
   holds IC Computation(b1,b2) = IC Computation(b1,LifeSpan b1);

:: SCMFSA8A:th 6
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA holds
   b1,b2 equal_outside NAT
iff
   IC b1 = IC b2 &
    b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA8A:th 7
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
   IC IExec(b2,b1) = IC Result (b1 +* Initialized b2);

:: SCMFSA8A:th 8
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
   (Initialize b1) +* Initialized b2 = b1 +* Initialized b2;

:: SCMFSA8A:th 9
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   b1 c= b1 +* Start-At b2;

:: SCMFSA8A:th 10
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   b1 | (Int-Locations \/ FinSeq-Locations) = (b1 +* Start-At b2) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA8A:th 11
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 Instruction-Location of SCM+FSA holds
   b1 | (Int-Locations \/ FinSeq-Locations) = (b1 +* (b2 +* Start-At b3)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA8A:th 12
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   proj1 (b1 | NAT) misses proj1 Start-At b2;

:: SCMFSA8A:th 13
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
   b1 +* Initialized b2 = (Initialize b1) +* (b2 +* Start-At insloc 0);

:: SCMFSA8A:th 14
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 Instruction-Location of SCM+FSA holds
   b1 +* (b2 +* Start-At b4),b1 +* (b3 +* Start-At b4) equal_outside NAT;

:: SCMFSA8A:th 15
theorem
proj1 SCM+FSA-Stop = {insloc 0};

:: SCMFSA8A:th 16
theorem
insloc 0 in proj1 SCM+FSA-Stop &
 SCM+FSA-Stop . insloc 0 = halt SCM+FSA;

:: SCMFSA8A:th 17
theorem
card SCM+FSA-Stop = 1;

:: SCMFSA8A:funcnot 1 => SCMFSA8A:func 1
definition
  let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Instruction-Location of SCM+FSA;
  func Directed(A1,A2) -> finite programmed Element of sproduct the Object-Kind of SCM+FSA equals
    a1 * ((id the Instructions of SCM+FSA) +* ((halt SCM+FSA) .--> goto a2));
end;

:: SCMFSA8A:def 1
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   Directed(b1,b2) = b1 * ((id the Instructions of SCM+FSA) +* ((halt SCM+FSA) .--> goto b2));

:: SCMFSA8A:funcreg 1
registration
  let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Instruction-Location of SCM+FSA;
  cluster Directed(a1,a2) -> finite programmed halt-free;
end;

:: SCMFSA8A:funcreg 2
registration
  let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
  cluster Directed a1 -> finite programmed halt-free;
end;

:: SCMFSA8A:th 19
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   proj1 Directed(b1,b2) = proj1 b1;

:: SCMFSA8A:th 20
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   Directed(b1,b2) = b1 +* (b1 * ((halt SCM+FSA) .--> goto b2));

:: SCMFSA8A:th 21
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA
for b3 being set
      st b3 in proj1 b1
   holds (b1 . b3 = halt SCM+FSA implies (Directed(b1,b2)) . b3 = goto b2) &
    (b1 . b3 = halt SCM+FSA or (Directed(b1,b2)) . b3 = b1 . b3);

:: SCMFSA8A:th 22
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being Int-Location
for b3 being Element of NAT
      st b1 does_not_destroy b2
   holds IncAddr(b1,b3) does_not_destroy b2;

:: SCMFSA8A:th 23
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT
for b3 being Int-Location
      st b1 does_not_destroy b3
   holds ProgramPart Relocated(b1,b2) does_not_destroy b3;

:: SCMFSA8A:th 24
theorem
for b1 being finite programmed good Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
   ProgramPart Relocated(b1,b2) is good;

:: SCMFSA8A:th 25
theorem
for b1, b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
      st b1 does_not_destroy b3 & b2 does_not_destroy b3
   holds b1 +* b2 does_not_destroy b3;

:: SCMFSA8A:th 26
theorem
for b1, b2 being finite programmed good Element of sproduct the Object-Kind of SCM+FSA holds
b1 +* b2 is good;

:: SCMFSA8A:th 27
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA
for b3 being Int-Location
      st b1 does_not_destroy b3
   holds Directed(b1,b2) does_not_destroy b3;

:: SCMFSA8A:funcreg 3
registration
  let a1 be finite programmed good Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Instruction-Location of SCM+FSA;
  cluster Directed(a1,a2) -> finite programmed good;
end;

:: SCMFSA8A:funcreg 4
registration
  let a1 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
  cluster Directed a1 -> finite programmed good;
end;

:: SCMFSA8A:funcreg 5
registration
  let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  let a2 be Instruction-Location of SCM+FSA;
  cluster Directed(a1,a2) -> finite programmed initial;
end;

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

:: SCMFSA8A:funcnot 2 => SCMFSA8A:func 2
definition
  let a1 be Instruction-Location of SCM+FSA;
  func Goto A1 -> finite programmed initial good halt-free Element of sproduct the Object-Kind of SCM+FSA equals
    (insloc 0) .--> goto a1;
end;

:: SCMFSA8A:def 2
theorem
for b1 being Instruction-Location of SCM+FSA holds
   Goto b1 = (insloc 0) .--> goto b1;

:: SCMFSA8A:prednot 1 => SCMFSA8A:pred 1
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be finite initial Element of sproduct the Object-Kind of SCM+FSA;
  pred A2 is_pseudo-closed_on A1 means
    ex b1 being Element of NAT st
       IC Computation(a1 +* (a2 +* Start-At insloc 0),b1) = insloc card ProgramPart a2 &
        (for b2 being Element of NAT
              st b2 < b1
           holds IC Computation(a1 +* (a2 +* Start-At insloc 0),b2) in proj1 a2);
end;

:: SCMFSA8A:dfs 3
definiens
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be finite initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a2 is_pseudo-closed_on a1
it is sufficient to prove
  thus ex b1 being Element of NAT st
       IC Computation(a1 +* (a2 +* Start-At insloc 0),b1) = insloc card ProgramPart a2 &
        (for b2 being Element of NAT
              st b2 < b1
           holds IC Computation(a1 +* (a2 +* Start-At insloc 0),b2) in proj1 a2);

:: SCMFSA8A:def 3
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite initial Element of sproduct the Object-Kind of SCM+FSA holds
      b2 is_pseudo-closed_on b1
   iff
      ex b3 being Element of NAT st
         IC Computation(b1 +* (b2 +* Start-At insloc 0),b3) = insloc card ProgramPart b2 &
          (for b4 being Element of NAT
                st b4 < b3
             holds IC Computation(b1 +* (b2 +* Start-At insloc 0),b4) in proj1 b2);

:: SCMFSA8A:attrnot 1 => SCMFSA8A:attr 1
definition
  let a1 be finite initial Element of sproduct the Object-Kind of SCM+FSA;
  attr a1 is pseudo-paraclosed means
    for b1 being Element of product the Object-Kind of SCM+FSA holds
       a1 is_pseudo-closed_on b1;
end;

:: SCMFSA8A:dfs 4
definiens
  let a1 be finite initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     a1 is pseudo-paraclosed
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of SCM+FSA holds
       a1 is_pseudo-closed_on b1;

:: SCMFSA8A:def 4
theorem
for b1 being finite initial Element of sproduct the Object-Kind of SCM+FSA holds
      b1 is pseudo-paraclosed
   iff
      for b2 being Element of product the Object-Kind of SCM+FSA holds
         b1 is_pseudo-closed_on b2;

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

:: SCMFSA8A:funcnot 3 => SCMFSA8A:func 3
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be finite initial Element of sproduct the Object-Kind of SCM+FSA;
  assume a2 is_pseudo-closed_on a1;
  func pseudo-LifeSpan(A1,A2) -> Element of NAT means
    IC Computation(a1 +* (a2 +* Start-At insloc 0),it) = insloc card ProgramPart a2 &
     (for b1 being Element of NAT
           st not IC Computation(a1 +* (a2 +* Start-At insloc 0),b1) in proj1 a2
        holds it <= b1);
end;

:: SCMFSA8A:def 5
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite initial Element of sproduct the Object-Kind of SCM+FSA
   st b2 is_pseudo-closed_on b1
for b3 being Element of NAT holds
      b3 = pseudo-LifeSpan(b1,b2)
   iff
      IC Computation(b1 +* (b2 +* Start-At insloc 0),b3) = insloc card ProgramPart b2 &
       (for b4 being Element of NAT
             st not IC Computation(b1 +* (b2 +* Start-At insloc 0),b4) in proj1 b2
          holds b3 <= b4);

:: SCMFSA8A:th 28
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being set
      st b3 in proj1 b1
   holds (b1 ';' b2) . b3 = (Directed b1) . b3;

:: SCMFSA8A:th 29
theorem
for b1 being Instruction-Location of SCM+FSA holds
   card Goto b1 = 1;

:: SCMFSA8A:th 30
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being set
      st b2 in proj1 b1
   holds (b1 . b2 = halt SCM+FSA implies (Directed b1) . b2 = goto insloc card b1) &
    (b1 . b2 = halt SCM+FSA or (Directed b1) . b2 = b1 . b2);

:: SCMFSA8A:th 31
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite initial Element of sproduct the Object-Kind of SCM+FSA
   st b2 is_pseudo-closed_on b1
for b3 being Element of NAT
      st b3 < pseudo-LifeSpan(b1,b2)
   holds IC Computation(b1 +* (b2 +* Start-At insloc 0),b3) in proj1 b2 &
    CurInstr Computation(b1 +* (b2 +* Start-At insloc 0),b3) <> halt SCM+FSA;

:: SCMFSA8A:th 32
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
   st b2 is_pseudo-closed_on b1
for b4 being Element of NAT
      st b4 <= pseudo-LifeSpan(b1,b2)
   holds Computation(b1 +* (b2 +* Start-At insloc 0),b4),Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),b4) equal_outside NAT;

:: SCMFSA8A:th 33
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA holds
   card Directed(b1,b2) = card b1;

:: SCMFSA8A:th 34
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   card Directed b1 = card b1;

:: SCMFSA8A:th 35
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_on b1 & b2 is_halting_on b1
for b3 being Element of NAT
      st b3 <= LifeSpan (b1 +* (b2 +* Start-At insloc 0))
   holds Computation(b1 +* (b2 +* Start-At insloc 0),b3),Computation(b1 +* ((Directed b2) +* Start-At insloc 0),b3) equal_outside NAT &
    CurInstr Computation(b1 +* ((Directed b2) +* Start-At insloc 0),b3) <> halt SCM+FSA;

:: SCMFSA8A:th 36
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_on b1 & b2 is_halting_on b1
   holds IC Computation(b1 +* ((Directed b2) +* Start-At insloc 0),(LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1) = insloc card b2 &
    (Computation(b1 +* (b2 +* Start-At insloc 0),LifeSpan (b1 +* (b2 +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1 +* ((Directed b2) +* Start-At insloc 0),(LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA8A: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
      st b2 is_closed_on b1 & b2 is_halting_on b1
   holds Directed b2 is_pseudo-closed_on b1;

:: SCMFSA8A:th 38
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_on b1 & b2 is_halting_on b1
   holds pseudo-LifeSpan(b1,Directed b2) = (LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1;

:: SCMFSA8A:th 39
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Instruction-Location of SCM+FSA
      st b1 is halt-free(NAT, {INT,INT *}, SCM+FSA)
   holds Directed(b1,b2) = b1;

:: SCMFSA8A:th 40
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b1 is halt-free(NAT, {INT,INT *}, SCM+FSA)
   holds Directed b1 = b1;

:: SCMFSA8A:th 41
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
(Directed b1) ';' b2 = b1 ';' b2;

:: SCMFSA8A:th 42
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
      st b2 is_closed_on b1 & b2 is_halting_on b1
   holds (for b4 being Element of NAT
          st b4 <= LifeSpan (b1 +* (b2 +* Start-At insloc 0))
       holds IC Computation(b1 +* ((Directed b2) +* Start-At insloc 0),b4) = IC Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),b4) &
        CurInstr Computation(b1 +* ((Directed b2) +* Start-At insloc 0),b4) = CurInstr Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),b4)) &
    (Computation(b1 +* ((Directed b2) +* Start-At insloc 0),(LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1)) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),(LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1)) | (Int-Locations \/ FinSeq-Locations) &
    IC Computation(b1 +* ((Directed b2) +* Start-At insloc 0),(LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1) = IC Computation(b1 +* ((b2 ';' b3) +* Start-At insloc 0),(LifeSpan (b1 +* (b2 +* Start-At insloc 0))) + 1);

:: SCMFSA8A: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
      st b2 is_closed_on Initialize b1 & b2 is_halting_on Initialize b1
   holds (for b4 being Element of NAT
          st b4 <= LifeSpan (b1 +* Initialized b2)
       holds IC Computation(b1 +* Initialized Directed b2,b4) = IC Computation(b1 +* Initialized (b2 ';' b3),b4) &
        CurInstr Computation(b1 +* Initialized Directed b2,b4) = CurInstr Computation(b1 +* Initialized (b2 ';' b3),b4)) &
    (Computation(b1 +* Initialized Directed b2,(LifeSpan (b1 +* Initialized b2)) + 1)) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1 +* Initialized (b2 ';' b3),(LifeSpan (b1 +* Initialized b2)) + 1)) | (Int-Locations \/ FinSeq-Locations) &
    IC Computation(b1 +* Initialized Directed b2,(LifeSpan (b1 +* Initialized b2)) + 1) = IC Computation(b1 +* Initialized (b2 ';' b3),(LifeSpan (b1 +* Initialized b2)) + 1);

:: SCMFSA8A:th 44
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_on Initialize b1 & b2 is_halting_on Initialize b1
for b3 being Element of NAT
      st b3 <= LifeSpan (b1 +* Initialized b2)
   holds Computation(b1 +* Initialized b2,b3),Computation(b1 +* Initialized Directed b2,b3) equal_outside NAT &
    CurInstr Computation(b1 +* Initialized Directed b2,b3) <> halt SCM+FSA;

:: SCMFSA8A:th 45
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_on Initialize b1 & b2 is_halting_on Initialize b1
   holds IC Computation(b1 +* Initialized Directed b2,(LifeSpan (b1 +* Initialized b2)) + 1) = insloc card b2 &
    (Computation(b1 +* Initialized b2,LifeSpan (b1 +* Initialized b2))) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1 +* Initialized Directed b2,(LifeSpan (b1 +* Initialized b2)) + 1)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA8A:th 46
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 b1 is_closed_on b2 & b1 is_halting_on b2
   holds b1 ';' SCM+FSA-Stop is_closed_on b2 & b1 ';' SCM+FSA-Stop is_halting_on b2;

:: SCMFSA8A:th 47
theorem
for b1 being Instruction-Location of SCM+FSA holds
   insloc 0 in proj1 Goto b1 &
    (Goto b1) . insloc 0 = goto b1;

:: SCMFSA8A:th 49
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being set
for b3 being Element of NAT
      st b2 in proj1 ProgramPart Relocated(b1,b3)
   holds (ProgramPart Relocated(b1,b3)) . b2 = (Relocated(b1,b3)) . b2;

:: SCMFSA8A:th 50
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
   ProgramPart Relocated(Directed b1,b2) = Directed(ProgramPart Relocated(b1,b2),insloc ((card b1) + b2));

:: SCMFSA8A:th 51
theorem
for b1, b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b3 being Instruction-Location of SCM+FSA holds
   Directed(b1 +* b2,b3) = (Directed(b1,b3)) +* Directed(b2,b3);

:: SCMFSA8A:th 52
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
Directed (b1 ';' b2) = b1 ';' Directed b2;

:: SCMFSA8A:th 53
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 b1 is_closed_on Initialize b2 & b1 is_halting_on Initialize b2
   holds IC Computation(b2 +* Initialized (b1 ';' SCM+FSA-Stop),(LifeSpan (b2 +* Initialized b1)) + 1) = insloc card b1;

:: SCMFSA8A:th 54
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 b1 is_closed_on Initialize b2 & b1 is_halting_on Initialize b2
   holds (Computation(b2 +* Initialized b1,LifeSpan (b2 +* Initialized b1))) | (Int-Locations \/ FinSeq-Locations) = (Computation(b2 +* Initialized (b1 ';' SCM+FSA-Stop),(LifeSpan (b2 +* Initialized b1)) + 1)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA8A:th 55
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 b1 is_closed_on Initialize b2 & b1 is_halting_on Initialize b2
   holds b2 +* Initialized (b1 ';' SCM+FSA-Stop) is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCMFSA8A:th 56
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 b1 is_closed_on Initialize b2 & b1 is_halting_on Initialize b2
   holds LifeSpan (b2 +* Initialized (b1 ';' SCM+FSA-Stop)) = (LifeSpan (b2 +* Initialized b1)) + 1;

:: SCMFSA8A:th 57
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_on Initialize b1 & b2 is_halting_on Initialize b1
   holds IExec(b2 ';' SCM+FSA-Stop,b1) = (IExec(b2,b1)) +* Start-At insloc card b2;

:: SCMFSA8A:th 58
theorem
for b1, 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 b1 is_closed_on b3 & b1 is_halting_on b3
   holds ((b1 ';' Goto insloc ((card b2) + 1)) ';' b2) ';' SCM+FSA-Stop is_closed_on b3 &
    ((b1 ';' Goto insloc ((card b2) + 1)) ';' b2) ';' SCM+FSA-Stop is_halting_on b3;

:: SCMFSA8A:th 59
theorem
for b1, 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 b1 is_closed_on b3 & b1 is_halting_on b3
   holds b3 +* ((((b1 ';' Goto insloc ((card b2) + 1)) ';' b2) ';' SCM+FSA-Stop) +* Start-At insloc 0) is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCMFSA8A:th 60
theorem
for b1, 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 b1 is_closed_on Initialize b3 & b1 is_halting_on Initialize b3
   holds b3 +* Initialized (((b1 ';' Goto insloc ((card b2) + 1)) ';' b2) ';' SCM+FSA-Stop) is halting(NAT, {INT,INT *}, SCM+FSA);

:: SCMFSA8A:th 61
theorem
for b1, 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 b1 is_closed_on Initialize b3 & b1 is_halting_on Initialize b3
   holds IC IExec(((b1 ';' Goto insloc ((card b2) + 1)) ';' b2) ';' SCM+FSA-Stop,b3) = insloc (((card b1) + card b2) + 1);

:: SCMFSA8A:th 62
theorem
for b1, 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 b1 is_closed_on Initialize b3 & b1 is_halting_on Initialize b3
   holds IExec(((b1 ';' Goto insloc ((card b2) + 1)) ';' b2) ';' SCM+FSA-Stop,b3) = (IExec(b1,b3)) +* Start-At insloc (((card b1) + card b2) + 1);