Article SCMFSA9A, MML version 4.99.1005

:: SCMFSA9A:th 7
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Element of the Instructions of SCM+FSA holds
   UsedIntLoc (b1 .--> b2) = UsedIntLoc b2;

:: SCMFSA9A:th 8
theorem
for b1 being Instruction-Location of SCM+FSA
for b2 being Element of the Instructions of SCM+FSA holds
   UsedInt*Loc (b1 .--> b2) = UsedInt*Loc b2;

:: SCMFSA9A:th 9
theorem
UsedIntLoc SCM+FSA-Stop = {};

:: SCMFSA9A:th 10
theorem
UsedInt*Loc SCM+FSA-Stop = {};

:: SCMFSA9A:th 11
theorem
for b1 being Instruction-Location of SCM+FSA holds
   UsedIntLoc Goto b1 = {};

:: SCMFSA9A:th 12
theorem
for b1 being Instruction-Location of SCM+FSA holds
   UsedInt*Loc Goto b1 = {};

:: SCMFSA9A:th 13
theorem
for b1 being Int-Location
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc if=0(b1,b2,b3) = ({b1} \/ UsedIntLoc b2) \/ UsedIntLoc b3;

:: SCMFSA9A:th 14
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location holds
   UsedInt*Loc if=0(b3,b1,b2) = (UsedInt*Loc b1) \/ UsedInt*Loc b2;

:: SCMFSA9A:th 15
theorem
for b1 being Int-Location
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc if>0(b1,b2,b3) = ({b1} \/ UsedIntLoc b2) \/ UsedIntLoc b3;

:: SCMFSA9A:th 16
theorem
for b1 being Int-Location
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedInt*Loc if>0(b1,b2,b3) = (UsedInt*Loc b2) \/ UsedInt*Loc b3;

:: SCMFSA9A:th 17
theorem
for b1 being Int-Location
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   UsedIntLoc while=0(b1,b2) = {b1} \/ UsedIntLoc b2;

:: SCMFSA9A:th 18
theorem
for b1 being Int-Location
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   UsedInt*Loc while=0(b1,b2) = UsedInt*Loc b2;

:: SCMFSA9A:prednot 1 => SCMFSA9A:pred 1
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  pred ProperBodyWhile=0 A2,A3,A1 means
    for b1 being Element of NAT
          st ((StepWhile=0(a2,a3,a1)) . b1) . a2 = 0
       holds a3 is_closed_on (StepWhile=0(a2,a3,a1)) . b1 & a3 is_halting_on (StepWhile=0(a2,a3,a1)) . b1;
end;

:: SCMFSA9A:dfs 1
definiens
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     ProperBodyWhile=0 a2,a3,a1
it is sufficient to prove
  thus for b1 being Element of NAT
          st ((StepWhile=0(a2,a3,a1)) . b1) . a2 = 0
       holds a3 is_closed_on (StepWhile=0(a2,a3,a1)) . b1 & a3 is_halting_on (StepWhile=0(a2,a3,a1)) . b1;

:: SCMFSA9A:def 1
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      ProperBodyWhile=0 b2,b3,b1
   iff
      for b4 being Element of NAT
            st ((StepWhile=0(b2,b3,b1)) . b4) . b2 = 0
         holds b3 is_closed_on (StepWhile=0(b2,b3,b1)) . b4 & b3 is_halting_on (StepWhile=0(b2,b3,b1)) . b4;

:: SCMFSA9A:prednot 2 => SCMFSA9A:pred 2
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  pred WithVariantWhile=0 A2,A3,A1 means
    ex b1 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
       for b2 being Element of NAT
             st b1 . ((StepWhile=0(a2,a3,a1)) . b2) <= b1 . ((StepWhile=0(a2,a3,a1)) . (b2 + 1))
          holds ((StepWhile=0(a2,a3,a1)) . b2) . a2 <> 0;
end;

:: SCMFSA9A:dfs 2
definiens
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     WithVariantWhile=0 a2,a3,a1
it is sufficient to prove
  thus ex b1 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
       for b2 being Element of NAT
             st b1 . ((StepWhile=0(a2,a3,a1)) . b2) <= b1 . ((StepWhile=0(a2,a3,a1)) . (b2 + 1))
          holds ((StepWhile=0(a2,a3,a1)) . b2) . a2 <> 0;

:: SCMFSA9A:def 2
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      WithVariantWhile=0 b2,b3,b1
   iff
      ex b4 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
         for b5 being Element of NAT
               st b4 . ((StepWhile=0(b2,b3,b1)) . b5) <= b4 . ((StepWhile=0(b2,b3,b1)) . (b5 + 1))
            holds ((StepWhile=0(b2,b3,b1)) . b5) . b2 <> 0;

:: SCMFSA9A:th 19
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA holds
   ProperBodyWhile=0 b2,b3,b1;

:: SCMFSA9A:th 20
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st ProperBodyWhile=0 b2,b3,b1 & WithVariantWhile=0 b2,b3,b1
   holds while=0(b2,b3) is_halting_on b1 & while=0(b2,b3) is_closed_on b1;

:: SCMFSA9A:th 21
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA
      st WithVariantWhile=0 b2,b3,b1
   holds while=0(b2,b3) is_halting_on b1 & while=0(b2,b3) is_closed_on b1;

:: SCMFSA9A:th 22
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st (while=0(b2,b3)) +* Start-At insloc 0 c= b1 &
         b1 . b2 <> 0
   holds LifeSpan b1 = 4 &
    (for b4 being Element of NAT holds
       (Computation(b1,b4)) | (Int-Locations \/ FinSeq-Locations) = b1 | (Int-Locations \/ FinSeq-Locations));

:: SCMFSA9A:th 23
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b3 is_closed_on b1 & b3 is_halting_on b1 & b1 . b2 = 0
   holds (Computation(b1 +* ((while=0(b2,b3)) +* Start-At insloc 0),(LifeSpan (b1 +* (b3 +* Start-At insloc 0))) + 3)) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1 +* (b3 +* Start-At insloc 0),LifeSpan (b1 +* (b3 +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 24
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
      st ((StepWhile=0(b2,b3,b1)) . b4) . b2 <> 0
   holds ((StepWhile=0(b2,b3,b1)) . (b4 + 1)) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile=0(b2,b3,b1)) . b4) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 25
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
      st (b3 is_halting_on Initialize ((StepWhile=0(b2,b3,b1)) . b4) & b3 is_closed_on Initialize ((StepWhile=0(b2,b3,b1)) . b4) or b3 is parahalting) &
         ((StepWhile=0(b2,b3,b1)) . b4) . b2 = 0 &
         ((StepWhile=0(b2,b3,b1)) . b4) . intloc 0 = 1
   holds ((StepWhile=0(b2,b3,b1)) . (b4 + 1)) | (Int-Locations \/ FinSeq-Locations) = (IExec(b3,(StepWhile=0(b2,b3,b1)) . b4)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 26
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA
   st (ProperBodyWhile=0 b2,b3,b1 or b3 is parahalting) & b1 . intloc 0 = 1
for b4 being Element of NAT holds
   ((StepWhile=0(b2,b3,b1)) . b4) . intloc 0 = 1;

:: SCMFSA9A:th 27
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st ProperBodyWhile=0 b3,b4,b1 &
      b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations)
for b5 being Element of NAT holds
   ((StepWhile=0(b3,b4,b1)) . b5) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile=0(b3,b4,b2)) . b5) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:funcnot 1 => SCMFSA9A:func 1
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  assume (ProperBodyWhile=0 a2,a3,a1 or a3 is parahalting) & WithVariantWhile=0 a2,a3,a1;
  func ExitsAtWhile=0(A2,A3,A1) -> Element of NAT means
    ex b1 being Element of NAT st
       it = b1 &
        ((StepWhile=0(a2,a3,a1)) . b1) . a2 <> 0 &
        (for b2 being Element of NAT
              st ((StepWhile=0(a2,a3,a1)) . b2) . a2 <> 0
           holds b1 <= b2) &
        (Computation(a1 +* ((while=0(a2,a3)) +* Start-At insloc 0),LifeSpan (a1 +* ((while=0(a2,a3)) +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile=0(a2,a3,a1)) . b1) | (Int-Locations \/ FinSeq-Locations);
end;

:: SCMFSA9A:def 3
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st (ProperBodyWhile=0 b2,b3,b1 or b3 is parahalting) & WithVariantWhile=0 b2,b3,b1
for b4 being Element of NAT holds
      b4 = ExitsAtWhile=0(b2,b3,b1)
   iff
      ex b5 being Element of NAT st
         b4 = b5 &
          ((StepWhile=0(b2,b3,b1)) . b5) . b2 <> 0 &
          (for b6 being Element of NAT
                st ((StepWhile=0(b2,b3,b1)) . b6) . b2 <> 0
             holds b5 <= b6) &
          (Computation(b1 +* ((while=0(b2,b3)) +* Start-At insloc 0),LifeSpan (b1 +* ((while=0(b2,b3)) +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile=0(b2,b3,b1)) . b5) | (Int-Locations \/ FinSeq-Locations);

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

:: SCMFSA9A:th 29
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st (ProperBodyWhile=0 b2,b3,Initialize b1 or b3 is parahalting) & WithVariantWhile=0 b2,b3,Initialize b1
   holds (IExec(while=0(b2,b3),b1)) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile=0(b2,b3,Initialize b1)) . ExitsAtWhile=0(b2,b3,Initialize b1)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 30
theorem
for b1 being Int-Location
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   UsedIntLoc while>0(b1,b2) = {b1} \/ UsedIntLoc b2;

:: SCMFSA9A:th 31
theorem
for b1 being Int-Location
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
   UsedInt*Loc while>0(b1,b2) = UsedInt*Loc b2;

:: SCMFSA9A:prednot 3 => SCMFSA9A:pred 3
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  pred ProperBodyWhile>0 A2,A3,A1 means
    for b1 being Element of NAT
          st 0 < ((StepWhile>0(a2,a3,a1)) . b1) . a2
       holds a3 is_closed_on (StepWhile>0(a2,a3,a1)) . b1 & a3 is_halting_on (StepWhile>0(a2,a3,a1)) . b1;
end;

:: SCMFSA9A:dfs 4
definiens
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     ProperBodyWhile>0 a2,a3,a1
it is sufficient to prove
  thus for b1 being Element of NAT
          st 0 < ((StepWhile>0(a2,a3,a1)) . b1) . a2
       holds a3 is_closed_on (StepWhile>0(a2,a3,a1)) . b1 & a3 is_halting_on (StepWhile>0(a2,a3,a1)) . b1;

:: SCMFSA9A:def 4
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      ProperBodyWhile>0 b2,b3,b1
   iff
      for b4 being Element of NAT
            st 0 < ((StepWhile>0(b2,b3,b1)) . b4) . b2
         holds b3 is_closed_on (StepWhile>0(b2,b3,b1)) . b4 & b3 is_halting_on (StepWhile>0(b2,b3,b1)) . b4;

:: SCMFSA9A:prednot 4 => SCMFSA9A:pred 4
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  pred WithVariantWhile>0 A2,A3,A1 means
    ex b1 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
       for b2 being Element of NAT
             st b1 . ((StepWhile>0(a2,a3,a1)) . b2) <= b1 . ((StepWhile>0(a2,a3,a1)) . (b2 + 1))
          holds ((StepWhile>0(a2,a3,a1)) . b2) . a2 <= 0;
end;

:: SCMFSA9A:dfs 5
definiens
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
     WithVariantWhile>0 a2,a3,a1
it is sufficient to prove
  thus ex b1 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
       for b2 being Element of NAT
             st b1 . ((StepWhile>0(a2,a3,a1)) . b2) <= b1 . ((StepWhile>0(a2,a3,a1)) . (b2 + 1))
          holds ((StepWhile>0(a2,a3,a1)) . b2) . a2 <= 0;

:: SCMFSA9A:def 5
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
      WithVariantWhile>0 b2,b3,b1
   iff
      ex b4 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
         for b5 being Element of NAT
               st b4 . ((StepWhile>0(b2,b3,b1)) . b5) <= b4 . ((StepWhile>0(b2,b3,b1)) . (b5 + 1))
            holds ((StepWhile>0(b2,b3,b1)) . b5) . b2 <= 0;

:: SCMFSA9A:th 32
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA holds
   ProperBodyWhile>0 b2,b3,b1;

:: SCMFSA9A:th 33
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st ProperBodyWhile>0 b2,b3,b1 & WithVariantWhile>0 b2,b3,b1
   holds while>0(b2,b3) is_halting_on b1 & while>0(b2,b3) is_closed_on b1;

:: SCMFSA9A:th 34
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA
      st WithVariantWhile>0 b2,b3,b1
   holds while>0(b2,b3) is_halting_on b1 & while>0(b2,b3) is_closed_on b1;

:: SCMFSA9A:th 35
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st (while>0(b2,b3)) +* Start-At insloc 0 c= b1 &
         b1 . b2 <= 0
   holds LifeSpan b1 = 4 &
    (for b4 being Element of NAT holds
       (Computation(b1,b4)) | (Int-Locations \/ FinSeq-Locations) = b1 | (Int-Locations \/ FinSeq-Locations));

:: SCMFSA9A:th 36
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b3 is_closed_on b1 & b3 is_halting_on b1 & 0 < b1 . b2
   holds (Computation(b1 +* ((while>0(b2,b3)) +* Start-At insloc 0),(LifeSpan (b1 +* (b3 +* Start-At insloc 0))) + 3)) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1 +* (b3 +* Start-At insloc 0),LifeSpan (b1 +* (b3 +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 37
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
      st ((StepWhile>0(b2,b3,b1)) . b4) . b2 <= 0
   holds ((StepWhile>0(b2,b3,b1)) . (b4 + 1)) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile>0(b2,b3,b1)) . b4) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 38
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
      st (b3 is_halting_on Initialize ((StepWhile>0(b2,b3,b1)) . b4) & b3 is_closed_on Initialize ((StepWhile>0(b2,b3,b1)) . b4) or b3 is parahalting) &
         0 < ((StepWhile>0(b2,b3,b1)) . b4) . b2 &
         ((StepWhile>0(b2,b3,b1)) . b4) . intloc 0 = 1
   holds ((StepWhile>0(b2,b3,b1)) . (b4 + 1)) | (Int-Locations \/ FinSeq-Locations) = (IExec(b3,(StepWhile>0(b2,b3,b1)) . b4)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 39
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA
   st (ProperBodyWhile>0 b2,b3,b1 or b3 is parahalting) & b1 . intloc 0 = 1
for b4 being Element of NAT holds
   ((StepWhile>0(b2,b3,b1)) . b4) . intloc 0 = 1;

:: SCMFSA9A:th 40
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st ProperBodyWhile>0 b3,b4,b1 &
      b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations)
for b5 being Element of NAT holds
   ((StepWhile>0(b3,b4,b1)) . b5) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile>0(b3,b4,b2)) . b5) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:funcnot 2 => SCMFSA9A:func 2
definition
  let a1 be Element of product the Object-Kind of SCM+FSA;
  let a2 be read-write Int-Location;
  let a3 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
  assume (ProperBodyWhile>0 a2,a3,a1 or a3 is parahalting) & WithVariantWhile>0 a2,a3,a1;
  func ExitsAtWhile>0(A2,A3,A1) -> Element of NAT means
    ex b1 being Element of NAT st
       it = b1 &
        ((StepWhile>0(a2,a3,a1)) . b1) . a2 <= 0 &
        (for b2 being Element of NAT
              st ((StepWhile>0(a2,a3,a1)) . b2) . a2 <= 0
           holds b1 <= b2) &
        (Computation(a1 +* ((while>0(a2,a3)) +* Start-At insloc 0),LifeSpan (a1 +* ((while>0(a2,a3)) +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile>0(a2,a3,a1)) . b1) | (Int-Locations \/ FinSeq-Locations);
end;

:: SCMFSA9A:def 6
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
   st (ProperBodyWhile>0 b2,b3,b1 or b3 is parahalting) & WithVariantWhile>0 b2,b3,b1
for b4 being Element of NAT holds
      b4 = ExitsAtWhile>0(b2,b3,b1)
   iff
      ex b5 being Element of NAT st
         b4 = b5 &
          ((StepWhile>0(b2,b3,b1)) . b5) . b2 <= 0 &
          (for b6 being Element of NAT
                st ((StepWhile>0(b2,b3,b1)) . b6) . b2 <= 0
             holds b5 <= b6) &
          (Computation(b1 +* ((while>0(b2,b3)) +* Start-At insloc 0),LifeSpan (b1 +* ((while>0(b2,b3)) +* Start-At insloc 0)))) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile>0(b2,b3,b1)) . b5) | (Int-Locations \/ FinSeq-Locations);

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

:: SCMFSA9A:th 42
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st (ProperBodyWhile>0 b2,b3,Initialize b1 or b3 is parahalting) & WithVariantWhile>0 b2,b3,Initialize b1
   holds (IExec(while>0(b2,b3),b1)) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile>0(b2,b3,Initialize b1)) . ExitsAtWhile>0(b2,b3,Initialize b1)) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 43
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
   st ((StepWhile>0(b2,b3,b1)) . b4) . b2 <= 0
for b5 being Element of NAT
      st b4 <= b5
   holds ((StepWhile>0(b2,b3,b1)) . b5) | (Int-Locations \/ FinSeq-Locations) = ((StepWhile>0(b2,b3,b1)) . b4) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:th 44
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
      st b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations) &
         ProperBodyWhile>0 b3,b4,b1
   holds ProperBodyWhile>0 b3,b4,b2;

:: SCMFSA9A:th 45
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA
   st b1 . intloc 0 = 1 & ProperBodyWhile>0 b2,b3,b1 & WithVariantWhile>0 b2,b3,b1
for b4, b5 being Element of NAT
      st b4 <> b5 & b4 <= ExitsAtWhile>0(b2,b3,b1) & b5 <= ExitsAtWhile>0(b2,b3,b1)
   holds (StepWhile>0(b2,b3,b1)) . b4 <> (StepWhile>0(b2,b3,b1)) . b5 &
    ((StepWhile>0(b2,b3,b1)) . b4) | (Int-Locations \/ FinSeq-Locations) <> ((StepWhile>0(b2,b3,b1)) . b5) | (Int-Locations \/ FinSeq-Locations);

:: SCMFSA9A:attrnot 1 => SCMFSA9A:attr 1
definition
  let a1 be Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT;
  attr a1 is on_data_only means
    for b1, b2 being Element of product the Object-Kind of SCM+FSA
          st b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations)
       holds a1 . b1 = a1 . b2;
end;

:: SCMFSA9A:dfs 7
definiens
  let a1 be Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT;
To prove
     a1 is on_data_only
it is sufficient to prove
  thus for b1, b2 being Element of product the Object-Kind of SCM+FSA
          st b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations)
       holds a1 . b1 = a1 . b2;

:: SCMFSA9A:def 7
theorem
for b1 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT holds
      b1 is on_data_only
   iff
      for b2, b3 being Element of product the Object-Kind of SCM+FSA
            st b2 | (Int-Locations \/ FinSeq-Locations) = b3 | (Int-Locations \/ FinSeq-Locations)
         holds b1 . b2 = b1 . b3;

:: SCMFSA9A:th 46
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
for b3 being finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA
      st b1 . intloc 0 = 1 & ProperBodyWhile>0 b2,b3,b1 & WithVariantWhile>0 b2,b3,b1
   holds ex b4 being Function-like quasi_total Relation of product the Object-Kind of SCM+FSA,NAT st
      b4 is on_data_only &
       (for b5 being Element of NAT
             st b4 . ((StepWhile>0(b2,b3,b1)) . b5) <= b4 . ((StepWhile>0(b2,b3,b1)) . (b5 + 1))
          holds ((StepWhile>0(b2,b3,b1)) . b5) . b2 <= 0);

:: SCMFSA9A:th 47
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA
      st b1 . intloc 0 = 1 &
         b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations) &
         ProperBodyWhile>0 b3,b4,b1 &
         WithVariantWhile>0 b3,b4,b1
   holds WithVariantWhile>0 b3,b4,b2;

:: SCMFSA9A:funcnot 3 => SCMFSA9A:func 3
definition
  let a1, a2 be Int-Location;
  func Fusc_macro(A1,A2) -> finite programmed initial Element of sproduct the Object-Kind of SCM+FSA equals
    (((SubFrom(a2,a2)) ';' ((1 -thRWNotIn {a1,a2}) := intloc 0)) ';' ((2 -thRWNotIn {a1,a2}) := a1)) ';' while>0(2 -thRWNotIn {a1,a2},(((3 -thRWNotIn {a1,a2}) := 2) ';' Divide(2 -thRWNotIn {a1,a2},3 -thRWNotIn {a1,a2})) ';' if=0(3 -thRWNotIn {a1,a2},Macro AddTo(1 -thRWNotIn {a1,a2},a2),Macro AddTo(a2,1 -thRWNotIn {a1,a2})));
end;

:: SCMFSA9A:def 8
theorem
for b1, b2 being Int-Location holds
Fusc_macro(b1,b2) = (((SubFrom(b2,b2)) ';' ((1 -thRWNotIn {b1,b2}) := intloc 0)) ';' ((2 -thRWNotIn {b1,b2}) := b1)) ';' while>0(2 -thRWNotIn {b1,b2},(((3 -thRWNotIn {b1,b2}) := 2) ';' Divide(2 -thRWNotIn {b1,b2},3 -thRWNotIn {b1,b2})) ';' if=0(3 -thRWNotIn {b1,b2},Macro AddTo(1 -thRWNotIn {b1,b2},b2),Macro AddTo(b2,1 -thRWNotIn {b1,b2})));

:: SCMFSA9A:th 48
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being read-write Int-Location
   st b2 <> b3
for b4 being Element of NAT
      st b4 = b1 . b2
   holds (IExec(Fusc_macro(b2,b3),b1)) . b3 = Fusc b4 &
    (IExec(Fusc_macro(b2,b3),b1)) . b2 = b4;