Article AMISTD_2, MML version 4.99.1005

:: AMISTD_2:condreg 1
registration
  let a1 be set;
  cluster -> functional (FinSequenceSet of a1);
end;

:: AMISTD_2:funcreg 1
registration
  let a1 be Element of NAT;
  let a2 be set;
  cluster a1 -tuples_on a2 -> with_common_domain;
end;

:: AMISTD_2:funcreg 2
registration
  let a1 be Element of NAT;
  let a2 be set;
  cluster a1 -tuples_on a2 -> product-like;
end;

:: AMISTD_2:th 11
theorem
for b1, b2, b3 being set
for b4 being AMI-Struct over b2,b3
for b5 being finite Element of sproduct the Object-Kind of b4 holds
   b5 \ b1 is finite Element of sproduct the Object-Kind of b4;

:: AMISTD_2:th 12
theorem
for b1 being set
for b2 being with_non-empty_elements set
for b3 being non empty set
for b4 being non empty stored-program IC-Ins-separated definite AMI-Struct over b3,b2
for b5 being finite programmed Element of sproduct the Object-Kind of b4 holds
   b5 \ b1 is finite programmed Element of sproduct the Object-Kind of b4;

:: AMISTD_2:funcnot 1 => AMISTD_2:func 1
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4, a5 be Instruction-Location of a3;
  let a6, a7 be Element of the Instructions of a3;
  redefine func (a4,a5)-->(a6,a7) -> finite Element of sproduct the Object-Kind of a3;
end;

:: AMISTD_2:exreg 1
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program halting AMI-Struct over a1,a2;
  cluster halting Element of the Instructions of a3;
end;

:: AMISTD_2:th 13
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite programmed lower Element of sproduct the Object-Kind of b2
for b4 being finite programmed Element of sproduct the Object-Kind of b2
      st proj1 b3 = proj1 b4
   holds b4 is lower(NAT, b1, b2);

:: AMISTD_2:th 14
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite programmed lower Element of sproduct the Object-Kind of b2
for b4 being Instruction-Location of b2
      st b4 in proj1 b3
   holds locnum b4 < card b3;

:: AMISTD_2:th 15
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite programmed lower Element of sproduct the Object-Kind of b2 holds
   proj1 b3 = {il.(b2,b4) where b4 is Element of NAT: b4 < card b3};

:: AMISTD_2:funcnot 2 => AMISTD_2:func 2
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  func AddressPart A4 -> set equals
    a4 `2;
end;

:: AMISTD_2:def 3
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
   AddressPart b4 = b4 `2;

:: AMISTD_2:funcnot 3 => AMISTD_2:func 3
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  redefine func AddressPart a4 -> FinSequence of (union a2) \/ the carrier of a3;
end;

:: AMISTD_2:th 16
theorem
for b1 being non empty set
for b2 being set
for b3 being standard-ins AMI-Struct over b1,b2
for b4, b5 being Element of the Instructions of b3
      st InsCode b4 = InsCode b5 & AddressPart b4 = AddressPart b5
   holds b4 = b5;

:: AMISTD_2:attrnot 1 => AMISTD_2:attr 1
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  attr a3 is homogeneous means
    for b1, b2 being Element of the Instructions of a3
          st InsCode b1 = InsCode b2
       holds dom AddressPart b1 = dom AddressPart b2;
end;

:: AMISTD_2:dfs 2
definiens
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
To prove
     a3 is homogeneous
it is sufficient to prove
  thus for b1, b2 being Element of the Instructions of a3
          st InsCode b1 = InsCode b2
       holds dom AddressPart b1 = dom AddressPart b2;

:: AMISTD_2:def 4
theorem
for b1, b2 being set
for b3 being standard-ins AMI-Struct over b1,b2 holds
      b3 is homogeneous(b1, b2)
   iff
      for b4, b5 being Element of the Instructions of b3
            st InsCode b4 = InsCode b5
         holds dom AddressPart b4 = dom AddressPart b5;

:: AMISTD_2:th 17
theorem
for b1 being with_non-empty_elements set
for b2 being Element of the Instructions of STC b1 holds
   AddressPart b2 = 0;

:: AMISTD_2:funcnot 4 => AMISTD_2:func 4
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  let a4 be Element of InsCodes a3;
  func AddressParts A4 -> set equals
    {AddressPart b1 where b1 is Element of the Instructions of a3: InsCode b1 = a4};
end;

:: AMISTD_2:def 5
theorem
for b1, b2 being set
for b3 being standard-ins AMI-Struct over b1,b2
for b4 being Element of InsCodes b3 holds
   AddressParts b4 = {AddressPart b5 where b5 is Element of the Instructions of b3: InsCode b5 = b4};

:: AMISTD_2:funcreg 3
registration
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  let a4 be Element of InsCodes a3;
  cluster AddressParts a4 -> functional;
end;

:: AMISTD_2:attrnot 2 => AMISTD_2:attr 2
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  attr a4 is with_explicit_jumps means
    for b1 being set
          st b1 in JUMP a4
       holds ex b2 being set st
          b2 in dom AddressPart a4 & b1 = (AddressPart a4) . b2 & (product" AddressParts InsCode a4) . b2 = a1;
end;

:: AMISTD_2:dfs 4
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
To prove
     a4 is with_explicit_jumps
it is sufficient to prove
  thus for b1 being set
          st b1 in JUMP a4
       holds ex b2 being set st
          b2 in dom AddressPart a4 & b1 = (AddressPart a4) . b2 & (product" AddressParts InsCode a4) . b2 = a1;

:: AMISTD_2:def 6
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 standard-ins AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
      b4 is with_explicit_jumps(b1, b2, b3)
   iff
      for b5 being set
            st b5 in JUMP b4
         holds ex b6 being set st
            b6 in dom AddressPart b4 & b5 = (AddressPart b4) . b6 & (product" AddressParts InsCode b4) . b6 = b1;

:: AMISTD_2:attrnot 3 => AMISTD_2:attr 3
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  attr a4 is without_implicit_jumps means
    for b1 being set
          st ex b2 being set st
               b2 in dom AddressPart a4 & b1 = (AddressPart a4) . b2 & (product" AddressParts InsCode a4) . b2 = a1
       holds b1 in JUMP a4;
end;

:: AMISTD_2:dfs 5
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
To prove
     a4 is without_implicit_jumps
it is sufficient to prove
  thus for b1 being set
          st ex b2 being set st
               b2 in dom AddressPart a4 & b1 = (AddressPart a4) . b2 & (product" AddressParts InsCode a4) . b2 = a1
       holds b1 in JUMP a4;

:: AMISTD_2:def 7
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 standard-ins AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
      b4 is without_implicit_jumps(b1, b2, b3)
   iff
      for b5 being set
            st ex b6 being set st
                 b6 in dom AddressPart b4 & b5 = (AddressPart b4) . b6 & (product" AddressParts InsCode b4) . b6 = b1
         holds b5 in JUMP b4;

:: AMISTD_2:attrnot 4 => AMISTD_2:attr 4
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
  attr a3 is with_explicit_jumps means
    for b1 being Element of the Instructions of a3 holds
       b1 is with_explicit_jumps(a1, a2, a3);
end;

:: AMISTD_2:dfs 6
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
To prove
     a3 is with_explicit_jumps
it is sufficient to prove
  thus for b1 being Element of the Instructions of a3 holds
       b1 is with_explicit_jumps(a1, a2, a3);

:: AMISTD_2:def 8
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 standard-ins AMI-Struct over b1,b2 holds
      b3 is with_explicit_jumps(b1, b2)
   iff
      for b4 being Element of the Instructions of b3 holds
         b4 is with_explicit_jumps(b1, b2, b3);

:: AMISTD_2:attrnot 5 => AMISTD_2:attr 5
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
  attr a3 is without_implicit_jumps means
    for b1 being Element of the Instructions of a3 holds
       b1 is without_implicit_jumps(a1, a2, a3);
end;

:: AMISTD_2:dfs 7
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over a1,a2;
To prove
     a3 is without_implicit_jumps
it is sufficient to prove
  thus for b1 being Element of the Instructions of a3 holds
       b1 is without_implicit_jumps(a1, a2, a3);

:: AMISTD_2:def 9
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 standard-ins AMI-Struct over b1,b2 holds
      b3 is without_implicit_jumps(b1, b2)
   iff
      for b4 being Element of the Instructions of b3 holds
         b4 is without_implicit_jumps(b1, b2, b3);

:: AMISTD_2:condreg 2
registration
  let a1 be with_non-empty_elements set;
  cluster non empty stored-program IC-Ins-separated definite standard -> (AMI-Struct over NAT,a1);
end;

:: AMISTD_2:exreg 2
registration
  let a1 be with_non-empty_elements set;
  cluster non empty stored-program IC-Ins-separated definite standard-ins standard AMI-Struct over NAT,a1;
end;

:: AMISTD_2:th 18
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
      st for b4 being Instruction-Location of b2 holds
           NIC(b3,b4) = {NextLoc b4}
   holds JUMP b3 is empty;

:: AMISTD_2:funcreg 4
registration
  let a1 be with_non-empty_elements set;
  let a2 be Element of the Instructions of STC a1;
  cluster JUMP a2 -> empty;
end;

:: AMISTD_2:attrnot 6 => AMISTD_2:attr 6
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  attr a3 is regular means
    for b1 being Element of InsCodes a3 holds
       AddressParts b1 is product-like;
end;

:: AMISTD_2:dfs 8
definiens
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
To prove
     a3 is regular
it is sufficient to prove
  thus for b1 being Element of InsCodes a3 holds
       AddressParts b1 is product-like;

:: AMISTD_2:def 11
theorem
for b1, b2 being set
for b3 being standard-ins AMI-Struct over b1,b2 holds
      b3 is regular(b1, b2)
   iff
      for b4 being Element of InsCodes b3 holds
         AddressParts b4 is product-like;

:: AMISTD_2:condreg 3
registration
  let a1, a2 be set;
  cluster standard-ins regular -> homogeneous (AMI-Struct over a1,a2);
end;

:: AMISTD_2:th 19
theorem
for b1 being with_non-empty_elements set
for b2 being Element of InsCodes STC b1 holds
   AddressParts b2 = {0};

:: AMISTD_2:funcreg 5
registration
  let a1 be with_non-empty_elements set;
  cluster STC a1 -> strict with_explicit_jumps without_implicit_jumps regular;
end;

:: AMISTD_2:exreg 3
registration
  let a1 be with_non-empty_elements set;
  cluster non empty stored-program halting IC-Ins-separated steady-programmed definite realistic programmable standard-ins standard with_explicit_jumps without_implicit_jumps regular AMI-Struct over NAT,a1;
end;

:: AMISTD_2:funcreg 6
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster Trivial-AMI(a1,a2) -> strict regular;
end;

:: AMISTD_2:exreg 4
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster standard-ins regular AMI-Struct over a1,a2;
end;

:: AMISTD_2:funcreg 7
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be standard-ins regular AMI-Struct over a1,a2;
  let a4 be Element of InsCodes a3;
  cluster AddressParts a4 -> product-like;
end;

:: AMISTD_2:funcreg 8
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be standard-ins homogeneous AMI-Struct over a1,a2;
  let a4 be Element of InsCodes a3;
  cluster AddressParts a4 -> with_common_domain;
end;

:: AMISTD_2:funcreg 9
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be Element of the Instructions of Trivial-AMI(a1,a2);
  cluster JUMP a3 -> empty;
end;

:: AMISTD_2:funcreg 10
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  cluster Trivial-AMI(a1,a2) -> strict with_explicit_jumps without_implicit_jumps regular;
end;

:: AMISTD_2:exreg 5
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  cluster non empty stored-program standard-ins regular AMI-Struct over a1,a2;
end;

:: AMISTD_2:th 20
theorem
for b1 being with_non-empty_elements set
for b2 being non trivial set
for b3 being non empty stored-program standard-ins homogeneous AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being set
      st b5 in dom AddressPart b4 & (product" AddressParts InsCode b4) . b5 = b2
   holds (AddressPart b4) . b5 is Instruction-Location of b3;

:: AMISTD_2:funcreg 11
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster Trivial-AMI(a1,a2) -> strict halting;
end;

:: AMISTD_2:exreg 6
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  cluster non empty stored-program halting IC-Ins-separated definite realistic standard-ins with_explicit_jumps without_implicit_jumps AMI-Struct over a1,a2;
end;

:: AMISTD_2:condreg 4
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins with_explicit_jumps AMI-Struct over a1,a2;
  cluster -> with_explicit_jumps (Element of the Instructions of a3);
end;

:: AMISTD_2:condreg 5
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite standard-ins without_implicit_jumps AMI-Struct over a1,a2;
  cluster -> without_implicit_jumps (Element of the Instructions of a3);
end;

:: AMISTD_2:th 21
theorem
for b1 being with_non-empty_elements set
for b2 being non trivial set
for b3 being non empty stored-program IC-Ins-separated definite realistic AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
      st b4 is halting(b2, b1, b3)
   holds JUMP b4 is empty;

:: AMISTD_2:funcreg 12
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over a1,a2;
  let a4 be halting Element of the Instructions of a3;
  cluster JUMP a4 -> empty;
end;

:: AMISTD_2:exreg 7
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
  cluster Relation-like Function-like non trivial finite programmed Element of sproduct the Object-Kind of a3;
end;

:: AMISTD_2:condreg 6
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  cluster non empty trivial finite programmed -> unique-halt (Element of sproduct the Object-Kind of a2);
end;

:: AMISTD_2:attrnot 7 => AMISTD_2:attr 7
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  attr a4 is ins-loc-free means
    for b1 being set
          st b1 in dom AddressPart a4
       holds (product" AddressParts InsCode a4) . b1 <> a1;
end;

:: AMISTD_2:dfs 9
definiens
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
To prove
     a4 is ins-loc-free
it is sufficient to prove
  thus for b1 being set
          st b1 in dom AddressPart a4
       holds (product" AddressParts InsCode a4) . b1 <> a1;

:: AMISTD_2:def 12
theorem
for b1, b2 being set
for b3 being standard-ins AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
      b4 is ins-loc-free(b1, b2, b3)
   iff
      for b5 being set
            st b5 in dom AddressPart b4
         holds (product" AddressParts InsCode b4) . b5 <> b1;

:: AMISTD_2:th 22
theorem
for b1 being with_non-empty_elements set
for b2 being non trivial set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic standard-ins with_explicit_jumps AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
      st b4 is ins-loc-free(b2, b1, b3)
   holds JUMP b4 is empty;

:: AMISTD_2:th 23
theorem
for b1 being with_non-empty_elements set
for b2 being non trivial set
for b3 being non empty stored-program IC-Ins-separated definite realistic standard-ins without_implicit_jumps AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
      st b4 is halting(b2, b1, b3)
   holds b4 is ins-loc-free(b2, b1, b3);

:: AMISTD_2:condreg 7
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program IC-Ins-separated definite realistic standard-ins without_implicit_jumps AMI-Struct over a1,a2;
  cluster halting -> ins-loc-free (Element of the Instructions of a3);
end;

:: AMISTD_2:th 24
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard without_implicit_jumps AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
      st b3 is sequential(b1, b2)
   holds b3 is ins-loc-free(NAT, b1, b2);

:: AMISTD_2:condreg 8
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard without_implicit_jumps AMI-Struct over NAT,a1;
  cluster sequential -> ins-loc-free (Element of the Instructions of a2);
end;

:: AMISTD_2:funcnot 5 => AMISTD_2:func 5
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  func Stop A2 -> finite Element of sproduct the Object-Kind of a2 equals
    (il.(a2,0)) .--> halt a2;
end;

:: AMISTD_2:def 13
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1 holds
   Stop b2 = (il.(b2,0)) .--> halt b2;

:: AMISTD_2:funcreg 13
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  cluster Stop a2 -> non empty trivial finite programmed lower;
end;

:: AMISTD_2:funcreg 14
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite realistic standard AMI-Struct over NAT,a1;
  cluster Stop a2 -> finite closed;
end;

:: AMISTD_2:funcreg 15
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated steady-programmed definite standard AMI-Struct over NAT,a1;
  cluster Stop a2 -> finite autonomic;
end;

:: AMISTD_2:th 25
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1 holds
   card Stop b2 = 1;

:: AMISTD_2:th 26
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of b2
      st card b3 = 1
   holds b3 = Stop b2;

:: AMISTD_2:th 27
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1 holds
   LastLoc Stop b2 = il.(b2,0);

:: AMISTD_2:funcreg 16
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  cluster Stop a2 -> finite halt-ending unique-halt;
end;

:: AMISTD_2:funcnot 6 => AMISTD_2:func 6
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  redefine func Stop a2 -> non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;

:: AMISTD_2:funcnot 7 => AMISTD_2:func 7
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be Element of the Instructions of a2;
  let a4 be natural set;
  func IncAddr(A3,A4) -> Element of the Instructions of a2 means
    InsCode it = InsCode a3 &
     dom AddressPart it = dom AddressPart a3 &
     (for b1 being set
           st b1 in dom AddressPart a3
        holds ((product" AddressParts InsCode a3) . b1 = NAT implies ex b2 being Instruction-Location of a2 st
            b2 = (AddressPart a3) . b1 &
             (AddressPart it) . b1 = il.(a2,a4 + locnum b2)) &
         ((product" AddressParts InsCode a3) . b1 = NAT or (AddressPart it) . b1 = (AddressPart a3) . b1));
end;

:: AMISTD_2:def 14
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
for b4 being natural set
for b5 being Element of the Instructions of b2 holds
      b5 = IncAddr(b3,b4)
   iff
      InsCode b5 = InsCode b3 &
       dom AddressPart b5 = dom AddressPart b3 &
       (for b6 being set
             st b6 in dom AddressPart b3
          holds ((product" AddressParts InsCode b3) . b6 = NAT implies ex b7 being Instruction-Location of b2 st
              b7 = (AddressPart b3) . b6 &
               (AddressPart b5) . b6 = il.(b2,b4 + locnum b7)) &
           ((product" AddressParts InsCode b3) . b6 = NAT or (AddressPart b5) . b6 = (AddressPart b3) . b6));

:: AMISTD_2:th 28
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
   IncAddr(b3,0) = b3;

:: AMISTD_2:th 29
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b2
for b4 being Element of the Instructions of b3
      st b4 is ins-loc-free(NAT, b2, b3)
   holds IncAddr(b4,b1) = b4;

:: AMISTD_2:th 30
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b2 holds
   IncAddr(halt b3,b1) = halt b3;

:: AMISTD_2:funcreg 17
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,a1;
  let a3 be halting Element of the Instructions of a2;
  let a4 be natural set;
  cluster IncAddr(a3,a4) -> halting;
end;

:: AMISTD_2:th 31
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b2
for b4 being Element of the Instructions of b3 holds
   AddressParts InsCode b4 = AddressParts InsCode IncAddr(b4,b1);

:: AMISTD_2:th 32
theorem
for b1 being set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b2
for b4, b5 being Element of the Instructions of b3
      st (ex b6 being natural set st
            IncAddr(b4,b6) = IncAddr(b5,b6)) &
         (product" AddressParts InsCode b4) . b1 = NAT
   holds (product" AddressParts InsCode b5) . b1 = NAT;

:: AMISTD_2:th 33
theorem
for b1 being set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b2
for b4, b5 being Element of the Instructions of b3
      st (ex b6 being natural set st
            IncAddr(b4,b6) = IncAddr(b5,b6)) &
         (product" AddressParts InsCode b4) . b1 <> NAT
   holds (product" AddressParts InsCode b5) . b1 <> NAT;

:: AMISTD_2:th 34
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3, b4 being Element of the Instructions of b2
      st ex b5 being natural set st
           IncAddr(b3,b5) = IncAddr(b4,b5)
   holds b3 = b4;

:: AMISTD_2:th 35
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b2
for b4 being Element of the Instructions of b3
      st IncAddr(b4,b1) = halt b3
   holds b4 = halt b3;

:: AMISTD_2:th 36
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b2
for b4 being Element of the Instructions of b3
      st b4 is sequential(b2, b3)
   holds IncAddr(b4,b1) is sequential(b2, b3);

:: AMISTD_2:th 37
theorem
for b1, b2 being natural set
for b3 being with_non-empty_elements set
for b4 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b3
for b5 being Element of the Instructions of b4 holds
   IncAddr(IncAddr(b5,b1),b2) = IncAddr(b5,b1 + b2);

:: AMISTD_2:funcnot 8 => AMISTD_2:func 8
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be finite programmed Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  func IncAddr(A3,A4) -> finite Element of sproduct the Object-Kind of a2 means
    proj1 it = proj1 a3 &
     (for b1 being natural set
           st il.(a2,b1) in proj1 a3
        holds it . il.(a2,b1) = IncAddr(pi(a3,il.(a2,b1)),a4));
end;

:: AMISTD_2:def 15
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being finite programmed Element of sproduct the Object-Kind of b2
for b4 being natural set
for b5 being finite Element of sproduct the Object-Kind of b2 holds
      b5 = IncAddr(b3,b4)
   iff
      proj1 b5 = proj1 b3 &
       (for b6 being natural set
             st il.(b2,b6) in proj1 b3
          holds b5 . il.(b2,b6) = IncAddr(pi(b3,il.(b2,b6)),b4));

:: AMISTD_2:funcreg 18
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be finite programmed Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster IncAddr(a3,a4) -> finite programmed;
end;

:: AMISTD_2:funcreg 19
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be empty finite programmed Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster IncAddr(a3,a4) -> empty finite;
end;

:: AMISTD_2:funcreg 20
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster IncAddr(a3,a4) -> non empty finite;
end;

:: AMISTD_2:funcreg 21
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be finite programmed lower Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster IncAddr(a3,a4) -> finite lower;
end;

:: AMISTD_2:th 38
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being finite programmed Element of sproduct the Object-Kind of b2 holds
   IncAddr(b3,0) = b3;

:: AMISTD_2:th 39
theorem
for b1, b2 being natural set
for b3 being with_non-empty_elements set
for b4 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b3
for b5 being finite programmed lower Element of sproduct the Object-Kind of b4 holds
   IncAddr(IncAddr(b5,b1),b2) = IncAddr(b5,b1 + b2);

:: AMISTD_2:funcnot 9 => AMISTD_2:func 9
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be finite Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  func Shift(A3,A4) -> finite Element of sproduct the Object-Kind of a2 means
    proj1 it = {il.(a2,b1 + a4) where b1 is Element of NAT: il.(a2,b1) in proj1 a3} &
     (for b1 being Element of NAT
           st il.(a2,b1) in proj1 a3
        holds it . il.(a2,b1 + a4) = a3 . il.(a2,b1));
end;

:: AMISTD_2:def 16
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite Element of sproduct the Object-Kind of b2
for b4 being natural set
for b5 being finite Element of sproduct the Object-Kind of b2 holds
      b5 = Shift(b3,b4)
   iff
      proj1 b5 = {il.(b2,b6 + b4) where b6 is Element of NAT: il.(b2,b6) in proj1 b3} &
       (for b6 being Element of NAT
             st il.(b2,b6) in proj1 b3
          holds b5 . il.(b2,b6 + b4) = b3 . il.(b2,b6));

:: AMISTD_2:funcreg 22
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be finite Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster Shift(a3,a4) -> finite programmed;
end;

:: AMISTD_2:funcreg 23
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be empty finite Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster Shift(a3,a4) -> empty finite;
end;

:: AMISTD_2:funcreg 24
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
  let a4 be natural set;
  cluster Shift(a3,a4) -> non empty finite;
end;

:: AMISTD_2:th 40
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite programmed Element of sproduct the Object-Kind of b2 holds
   Shift(b3,0) = b3;

:: AMISTD_2:th 41
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite Element of sproduct the Object-Kind of b2
for b4 being natural set
      st 0 < b4
   holds not il.(b2,0) in proj1 Shift(b3,b4);

:: AMISTD_2:th 42
theorem
for b1, b2 being natural set
for b3 being with_non-empty_elements set
for b4 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b3
for b5 being finite Element of sproduct the Object-Kind of b4 holds
   Shift(Shift(b5,b1),b2) = Shift(b5,b1 + b2);

:: AMISTD_2:th 43
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b2
for b4 being finite programmed Element of sproduct the Object-Kind of b3 holds
   proj1 b4,proj1 Shift(b4,b1) are_equipotent;

:: AMISTD_2:attrnot 8 => AMISTD_2:attr 8
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be Element of the Instructions of a2;
  attr a3 is IC-good means
    for b1 being natural set
    for b2, b3 being Element of product the Object-Kind of a2
          st b3 = b2 +* ((IC a2) .--> ((IC b2) + b1))
       holds (IC Exec(a3,b2)) + b1 = IC Exec(IncAddr(a3,b1),b3);
end;

:: AMISTD_2:dfs 14
definiens
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3 be Element of the Instructions of a2;
To prove
     a3 is IC-good
it is sufficient to prove
  thus for b1 being natural set
    for b2, b3 being Element of product the Object-Kind of a2
          st b3 = b2 +* ((IC a2) .--> ((IC b2) + b1))
       holds (IC Exec(a3,b2)) + b1 = IC Exec(IncAddr(a3,b1),b3);

:: AMISTD_2:def 17
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
      b3 is IC-good(b1, b2)
   iff
      for b4 being natural set
      for b5, b6 being Element of product the Object-Kind of b2
            st b6 = b5 +* ((IC b2) .--> ((IC b5) + b4))
         holds (IC Exec(b3,b5)) + b4 = IC Exec(IncAddr(b3,b4),b6);

:: AMISTD_2:attrnot 9 => AMISTD_2:attr 9
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  attr a2 is IC-good means
    for b1 being Element of the Instructions of a2 holds
       b1 is IC-good(a1, a2);
end;

:: AMISTD_2:dfs 15
definiens
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
To prove
     a2 is IC-good
it is sufficient to prove
  thus for b1 being Element of the Instructions of a2 holds
       b1 is IC-good(a1, a2);

:: AMISTD_2:def 18
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1 holds
      b2 is IC-good(b1)
   iff
      for b3 being Element of the Instructions of b2 holds
         b3 is IC-good(b1, b2);

:: AMISTD_2:attrnot 10 => AMISTD_2:attr 10
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  attr a4 is Exec-preserving means
    for b1, b2 being Element of product the Object-Kind of a3
          st b1,b2 equal_outside a1
       holds Exec(a4,b1),Exec(a4,b2) equal_outside a1;
end;

:: AMISTD_2:dfs 16
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
To prove
     a4 is Exec-preserving
it is sufficient to prove
  thus for b1, b2 being Element of product the Object-Kind of a3
          st b1,b2 equal_outside a1
       holds Exec(a4,b1),Exec(a4,b2) equal_outside a1;

:: AMISTD_2:def 19
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being stored-program AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
      b4 is Exec-preserving(b1, b2, b3)
   iff
      for b5, b6 being Element of product the Object-Kind of b3
            st b5,b6 equal_outside b1
         holds Exec(b4,b5),Exec(b4,b6) equal_outside b1;

:: AMISTD_2:attrnot 11 => AMISTD_2:attr 11
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program AMI-Struct over a1,a2;
  attr a3 is Exec-preserving means
    for b1 being Element of the Instructions of a3 holds
       b1 is Exec-preserving(a1, a2, a3);
end;

:: AMISTD_2:dfs 17
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program AMI-Struct over a1,a2;
To prove
     a3 is Exec-preserving
it is sufficient to prove
  thus for b1 being Element of the Instructions of a3 holds
       b1 is Exec-preserving(a1, a2, a3);

:: AMISTD_2:def 20
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being stored-program AMI-Struct over b1,b2 holds
      b3 is Exec-preserving(b1, b2)
   iff
      for b4 being Element of the Instructions of b3 holds
         b4 is Exec-preserving(b1, b2, b3);

:: AMISTD_2:th 44
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
      st b3 is sequential(b1, b2)
   holds b3 is IC-good(b1, b2);

:: AMISTD_2:condreg 9
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,a1;
  cluster sequential -> IC-good (Element of the Instructions of a2);
end;

:: AMISTD_2:th 45
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
      st b3 is halting(NAT, b1, b2)
   holds b3 is IC-good(b1, b2);

:: AMISTD_2:condreg 10
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,a1;
  cluster halting -> IC-good (Element of the Instructions of a2);
end;

:: AMISTD_2:th 46
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being stored-program AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
      st b4 is halting(b2, b1, b3)
   holds b4 is Exec-preserving(b2, b1, b3);

:: AMISTD_2:condreg 11
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program AMI-Struct over a1,a2;
  cluster halting -> Exec-preserving (Element of the Instructions of a3);
end;

:: AMISTD_2:funcreg 25
registration
  let a1 be with_non-empty_elements set;
  cluster STC a1 -> strict IC-good Exec-preserving;
end;

:: AMISTD_2:exreg 8
registration
  let a1 be with_non-empty_elements set;
  cluster non empty stored-program halting IC-Ins-separated steady-programmed definite realistic programmable standard-ins InsLoc-antisymmetric standard homogeneous with_explicit_jumps without_implicit_jumps regular IC-good Exec-preserving AMI-Struct over NAT,a1;
end;

:: AMISTD_2:exreg 9
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster non empty stored-program IC-Ins-separated definite standard-ins regular AMI-Struct over a1,a2;
end;

:: AMISTD_2:funcreg 26
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster Trivial-AMI(a1,a2) -> strict Exec-preserving;
end;

:: AMISTD_2:exreg 10
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  cluster non empty stored-program halting IC-Ins-separated steady-programmed definite realistic programmable standard-ins homogeneous with_explicit_jumps without_implicit_jumps regular Exec-preserving AMI-Struct over a1,a2;
end;

:: AMISTD_2:condreg 12
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular IC-good AMI-Struct over NAT,a1;
  cluster -> IC-good (Element of the Instructions of a2);
end;

:: AMISTD_2:condreg 13
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be stored-program Exec-preserving AMI-Struct over a1,a2;
  cluster -> Exec-preserving (Element of the Instructions of a3);
end;

:: AMISTD_2:funcnot 10 => AMISTD_2:func 10
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
  func CutLastLoc A3 -> finite Element of sproduct the Object-Kind of a2 equals
    a3 \ ((LastLoc a3) .--> (a3 . LastLoc a3));
end;

:: AMISTD_2:def 21
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
   CutLastLoc b3 = b3 \ ((LastLoc b3) .--> (b3 . LastLoc b3));

:: AMISTD_2:th 47
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
   proj1 CutLastLoc b3 = (proj1 b3) \ {LastLoc b3};

:: AMISTD_2:th 48
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
   proj1 b3 = (proj1 CutLastLoc b3) \/ {LastLoc b3};

:: AMISTD_2:funcreg 27
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be non empty trivial finite programmed Element of sproduct the Object-Kind of a2;
  cluster CutLastLoc a3 -> empty finite;
end;

:: AMISTD_2:funcreg 28
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
  cluster CutLastLoc a3 -> finite programmed;
end;

:: AMISTD_2:funcreg 29
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
  let a3 be non empty finite programmed lower Element of sproduct the Object-Kind of a2;
  cluster CutLastLoc a3 -> finite lower;
end;

:: AMISTD_2:th 49
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
   card CutLastLoc b3 = (card b3) - 1;

:: AMISTD_2:th 50
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower Element of sproduct the Object-Kind of b2
for b4 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
   proj1 CutLastLoc b3 misses proj1 Shift(IncAddr(b4,(card b3) -' 1),(card b3) -' 1);

:: AMISTD_2:th 51
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower unique-halt Element of sproduct the Object-Kind of b2
for b4 being Instruction-Location of b2
      st b4 in proj1 CutLastLoc b3
   holds (CutLastLoc b3) . b4 <> halt b2;

:: AMISTD_2:funcnot 11 => AMISTD_2:func 11
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3, a4 be non empty finite programmed Element of sproduct the Object-Kind of a2;
  func A3 ';' A4 -> finite Element of sproduct the Object-Kind of a2 equals
    (CutLastLoc a3) +* Shift(IncAddr(a4,(card a3) -' 1),(card a3) -' 1);
end;

:: AMISTD_2:def 22
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3, b4 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
b3 ';' b4 = (CutLastLoc b3) +* Shift(IncAddr(b4,(card b3) -' 1),(card b3) -' 1);

:: AMISTD_2:funcreg 30
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3, a4 be non empty finite programmed Element of sproduct the Object-Kind of a2;
  cluster a3 ';' a4 -> non empty finite programmed;
end;

:: AMISTD_2:th 52
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower Element of sproduct the Object-Kind of b2
for b4 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
   card (b3 ';' b4) = ((card b3) + card b4) - 1 &
    card (b3 ';' b4) = ((card b3) + card b4) -' 1;

:: AMISTD_2:funcreg 31
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,a1;
  let a3, a4 be non empty finite programmed lower Element of sproduct the Object-Kind of a2;
  cluster a3 ';' a4 -> finite lower;
end;

:: AMISTD_2:th 53
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3, b4 being non empty finite programmed lower Element of sproduct the Object-Kind of b2 holds
proj1 b3 c= proj1 (b3 ';' b4);

:: AMISTD_2:th 54
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3, b4 being non empty finite programmed lower Element of sproduct the Object-Kind of b2 holds
CutLastLoc b3 c= CutLastLoc (b3 ';' b4);

:: AMISTD_2:th 55
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3, b4 being non empty finite programmed lower Element of sproduct the Object-Kind of b2 holds
(b3 ';' b4) . LastLoc b3 = (IncAddr(b4,(card b3) -' 1)) . il.(b2,0);

:: AMISTD_2:th 56
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3, b4 being non empty finite programmed lower Element of sproduct the Object-Kind of b2
for b5 being Instruction-Location of b2
      st locnum b5 < (card b3) - 1
   holds (IncAddr(b3,(card b3) -' 1)) . b5 = (IncAddr(b3 ';' b4,(card b3) -' 1)) . b5;

:: AMISTD_2:funcreg 32
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated steady-programmed definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,a1;
  let a3 be non empty finite programmed lower Element of sproduct the Object-Kind of a2;
  let a4 be non empty finite programmed lower halt-ending Element of sproduct the Object-Kind of a2;
  cluster a3 ';' a4 -> finite halt-ending;
end;

:: AMISTD_2:funcreg 33
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated steady-programmed definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,a1;
  let a3, a4 be non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
  cluster a3 ';' a4 -> finite unique-halt;
end;

:: AMISTD_2:funcnot 12 => AMISTD_2:func 12
definition
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated steady-programmed definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,a1;
  let a3, a4 be non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
  redefine func a3 ';' a4 -> non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;

:: AMISTD_2:funcreg 34
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated steady-programmed definite realistic standard-ins standard regular IC-good Exec-preserving AMI-Struct over NAT,a1;
  let a3, a4 be non empty finite programmed closed lower Element of sproduct the Object-Kind of a2;
  cluster a3 ';' a4 -> finite closed;
end;

:: AMISTD_2:th 57
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b2 holds
   IncAddr(Stop b3,b1) = Stop b3;

:: AMISTD_2:th 58
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b2 holds
   Shift(Stop b3,b1) = (il.(b3,b1)) .--> halt b3;

:: AMISTD_2:th 59
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of b2 holds
   b3 ';' Stop b2 = b3;

:: AMISTD_2:th 60
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard-ins standard regular AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of b2 holds
   (Stop b2) ';' b3 = b3;

:: AMISTD_2:th 61
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated steady-programmed definite realistic standard-ins standard without_implicit_jumps regular AMI-Struct over NAT,b1
for b3, b4, b5 being non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of b2 holds
(b3 ';' b4) ';' b5 = b3 ';' (b4 ';' b5);

:: AMISTD_2:th 62
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program standard-ins regular AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being set
      st b5 in dom AddressPart b4
   holds (AddressPart b4) . b5 in (product" AddressParts InsCode b4) . b5;

:: AMISTD_2:th 63
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being Element of the Instructions of Trivial-AMI(b2,b1) holds
   AddressPart b3 = 0;

:: AMISTD_2:th 64
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being Element of InsCodes Trivial-AMI(b2,b1) holds
   AddressParts b3 = {0};