Article AMI_1, MML version 4.99.1005

:: AMI_1:structnot 1 => AMI_1:struct 1
definition
  let a1, a2 be set;
  struct(1-sorted) AMI-Struct(#
    carrier -> set,
    Instruction-Counter -> Element of the carrier of it,
    Instructions -> non empty set,
    Object-Kind -> Function-like quasi_total Relation of the carrier of it,A2 \/ {the Instructions of it,A1},
    Execution -> Function-like quasi_total Relation of the Instructions of it,Funcs(product the Object-Kind of it,product the Object-Kind of it)
  #);
end;

:: AMI_1:attrnot 1 => AMI_1:attr 1
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  attr a3 is strict;
end;

:: AMI_1:exreg 1
registration
  let a1, a2 be set;
  cluster strict AMI-Struct over a1,a2;
end;

:: AMI_1:aggrnot 1 => AMI_1:aggr 1
definition
  let a1, a2, a3 be set;
  let a4 be Element of a3;
  let a5 be non empty set;
  let a6 be Function-like quasi_total Relation of a3,a2 \/ {a5,a1};
  let a7 be Function-like quasi_total Relation of a5,Funcs(product a6,product a6);
  aggr AMI-Struct(#a3,a4,a5,a6,a7#) -> strict AMI-Struct over a1,a2;
end;

:: AMI_1:selnot 1 => AMI_1:sel 1
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  sel the Instruction-Counter of a3 -> Element of the carrier of a3;
end;

:: AMI_1:selnot 2 => AMI_1:sel 2
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  sel the Instructions of a3 -> non empty set;
end;

:: AMI_1:selnot 3 => AMI_1:sel 3
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  sel the Object-Kind of a3 -> Function-like quasi_total Relation of the carrier of a3,a2 \/ {the Instructions of a3,a1};
end;

:: AMI_1:selnot 4 => AMI_1:sel 4
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  sel the Execution of a3 -> Function-like quasi_total Relation of the Instructions of a3,Funcs(product the Object-Kind of a3,product the Object-Kind of a3);
end;

:: AMI_1:funcnot 1 => AMI_1:func 1
definition
  let a1, a2 be set;
  func Trivial-AMI(A1,A2) -> strict AMI-Struct over a1,a2 means
    the carrier of it = succ a1 &
     the Instruction-Counter of it = a1 &
     the Instructions of it = {[0,{}]} &
     the Object-Kind of it = (a1 --> {[0,{}]}) +* (a1 .--> a1) &
     the Execution of it = [0,{}] .--> id product ((a1 --> {[0,{}]}) +* (a1 .--> a1));
end;

:: AMI_1:def 2
theorem
for b1, b2 being set
for b3 being strict AMI-Struct over b1,b2 holds
      b3 = Trivial-AMI(b1,b2)
   iff
      the carrier of b3 = succ b1 &
       the Instruction-Counter of b3 = b1 &
       the Instructions of b3 = {[0,{}]} &
       the Object-Kind of b3 = (b1 --> {[0,{}]}) +* (b1 .--> b1) &
       the Execution of b3 = [0,{}] .--> id product ((b1 --> {[0,{}]}) +* (b1 .--> b1));

:: AMI_1:attrnot 2 => AMI_1:attr 2
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  attr a3 is stored-program means
    a1 c= the carrier of a3;
end;

:: AMI_1:dfs 2
definiens
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
To prove
     a3 is stored-program
it is sufficient to prove
  thus a1 c= the carrier of a3;

:: AMI_1:def 3
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2 holds
      b3 is stored-program(b1, b2)
   iff
      b1 c= the carrier of b3;

:: AMI_1:funcreg 1
registration
  let a1, a2 be set;
  cluster Trivial-AMI(a1,a2) -> non empty strict stored-program;
end;

:: AMI_1:exreg 2
registration
  let a1, a2 be set;
  cluster non empty stored-program AMI-Struct over a1,a2;
end;

:: AMI_1:modenot 1
definition
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  mode Object of a3 is Element of the carrier of a3;
end;

:: AMI_1:modenot 2 => AMI_1:mode 1
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be AMI-Struct over a1,a2;
  mode Instruction-Location of A3 means
    it in a1;
end;

:: AMI_1:dfs 3
definiens
  let a1 be non empty set;
  let a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be set;
To prove
     a4 is Instruction-Location of a3
it is sufficient to prove
  thus a4 in a1;

:: AMI_1:def 4
theorem
for b1 being non empty set
for b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being set holds
      b4 is Instruction-Location of b3
   iff
      b4 in b1;

:: AMI_1:modenot 3 => AMI_1:mode 2
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be AMI-Struct over a1,a2;
  redefine mode Instruction-Location of a3 -> Element of a1;
end;

:: AMI_1:modenot 4
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  mode Instruction of a3 is Element of the Instructions of a3;
end;

:: AMI_1:funcnot 2 => AMI_1:func 2
definition
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  func IC A3 -> Element of the carrier of a3 equals
    the Instruction-Counter of a3;
end;

:: AMI_1:def 5
theorem
for b1, b2 being set
for b3 being non empty AMI-Struct over b1,b2 holds
   IC b3 = the Instruction-Counter of b3;

:: AMI_1:funcnot 3 => AMI_1:func 3
definition
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be Element of the carrier of a3;
  func ObjectKind A4 -> Element of a2 \/ {the Instructions of a3,a1} equals
    (the Object-Kind of a3) . a4;
end;

:: AMI_1:def 6
theorem
for b1, b2 being set
for b3 being non empty AMI-Struct over b1,b2
for b4 being Element of the carrier of b3 holds
   ObjectKind b4 = (the Object-Kind of b3) . b4;

:: AMI_1:modenot 5
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  mode State of a3 is Element of product the Object-Kind of a3;
end;

:: AMI_1:funcnot 4 => AMI_1:func 4
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  let a5 be Element of product the Object-Kind of a3;
  func Exec(A4,A5) -> Element of product the Object-Kind of a3 equals
    ((the Execution of a3) . a4) . a5;
end;

:: AMI_1:def 7
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3
for b5 being Element of product the Object-Kind of b3 holds
   Exec(b4,b5) = ((the Execution of b3) . b4) . b5;

:: AMI_1:attrnot 3 => AMI_1:attr 3
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  attr a4 is halting means
    for b1 being Element of product the Object-Kind of a3 holds
       Exec(a4,b1) = b1;
end;

:: AMI_1:dfs 7
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
To prove
     a4 is halting
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of a3 holds
       Exec(a4,b1) = b1;

:: AMI_1:def 8
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
      b4 is halting(b1, b2, b3)
   iff
      for b5 being Element of product the Object-Kind of b3 holds
         Exec(b4,b5) = b5;

:: AMI_1:attrnot 4 => AMI_1:attr 4
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
  attr a3 is halting means
    ex b1 being Element of the Instructions of a3 st
       b1 is halting(a1, a2, a3);
end;

:: AMI_1:dfs 8
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
To prove
     a3 is halting
it is sufficient to prove
  thus ex b1 being Element of the Instructions of a3 st
       b1 is halting(a1, a2, a3);

:: AMI_1:def 9
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2 holds
      b3 is halting(b1, b2)
   iff
      ex b4 being Element of the Instructions of b3 st
         b4 is halting(b1, b2, b3);

:: AMI_1:th 6
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set holds
   Trivial-AMI(b1,b2) is halting(b1, b2);

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

:: AMI_1:exreg 3
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster halting AMI-Struct over a1,a2;
end;

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

:: AMI_1:funcnot 5 => AMI_1:func 5
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be halting AMI-Struct over a1,a2;
  func halt A3 -> Element of the Instructions of a3 equals
    choose {b1 where b1 is Element of the Instructions of a3: b1 is halting(a1, a2, a3)};
end;

:: AMI_1:def 10
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being halting AMI-Struct over b1,b2 holds
   halt b3 = choose {b4 where b4 is Element of the Instructions of b3: b4 is halting(b1, b2, b3)};

:: AMI_1:funcreg 3
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be halting AMI-Struct over a1,a2;
  cluster halt a3 -> halting;
end;

:: AMI_1:attrnot 5 => AMI_1:attr 5
definition
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  attr a3 is IC-Ins-separated means
    ObjectKind IC a3 = a1;
end;

:: AMI_1:dfs 10
definiens
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
To prove
     a3 is IC-Ins-separated
it is sufficient to prove
  thus ObjectKind IC a3 = a1;

:: AMI_1:def 11
theorem
for b1, b2 being set
for b3 being non empty AMI-Struct over b1,b2 holds
      b3 is IC-Ins-separated(b1, b2)
   iff
      ObjectKind IC b3 = b1;

:: AMI_1:attrnot 6 => AMI_1:attr 6
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty AMI-Struct over a1,a2;
  attr a3 is steady-programmed means
    for b1 being Element of product the Object-Kind of a3
    for b2 being Element of the Instructions of a3
    for b3 being Instruction-Location of a3 holds
       (Exec(b2,b1)) . b3 = b1 . b3;
end;

:: AMI_1:dfs 11
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty AMI-Struct over a1,a2;
To prove
     a3 is steady-programmed
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of a3
    for b2 being Element of the Instructions of a3
    for b3 being Instruction-Location of a3 holds
       (Exec(b2,b1)) . b3 = b1 . b3;

:: AMI_1:def 13
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty AMI-Struct over b1,b2 holds
      b3 is steady-programmed(b1, b2)
   iff
      for b4 being Element of product the Object-Kind of b3
      for b5 being Element of the Instructions of b3
      for b6 being Instruction-Location of b3 holds
         (Exec(b5,b4)) . b6 = b4 . b6;

:: AMI_1:modenot 6 => AMI_1:mode 3
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty stored-program AMI-Struct over a1,a2;
  redefine mode Instruction-Location of a3 -> Element of the carrier of a3;
end;

:: AMI_1:attrnot 7 => AMI_1:attr 7
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty stored-program AMI-Struct over a1,a2;
  attr a3 is definite means
    for b1 being Instruction-Location of a3 holds
       ObjectKind b1 = the Instructions of a3;
end;

:: AMI_1:dfs 12
definiens
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty stored-program AMI-Struct over a1,a2;
To prove
     a3 is definite
it is sufficient to prove
  thus for b1 being Instruction-Location of a3 holds
       ObjectKind b1 = the Instructions of a3;

:: AMI_1:def 14
theorem
for b1 being non empty set
for b2 being set
for b3 being non empty stored-program AMI-Struct over b1,b2 holds
      b3 is definite(b1, b2)
   iff
      for b4 being Instruction-Location of b3 holds
         ObjectKind b4 = the Instructions of b3;

:: AMI_1:th 7
theorem
for b1 being non empty set
for b2 being set holds
   Trivial-AMI(b1,b2) is IC-Ins-separated(b1, b2);

:: AMI_1:th 9
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being Element of product the Object-Kind of Trivial-AMI(b1,b2)
for b4 being Element of the Instructions of Trivial-AMI(b1,b2) holds
   Exec(b4,b3) = b3;

:: AMI_1:th 10
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set holds
   Trivial-AMI(b1,b2) is steady-programmed(b1, b2);

:: AMI_1:th 11
theorem
for b1 being non empty set
for b2 being set holds
   Trivial-AMI(b1,b2) is definite(b1, b2);

:: AMI_1:funcreg 4
registration
  let a1 be non empty set;
  let a2 be set;
  cluster Trivial-AMI(a1,a2) -> strict IC-Ins-separated definite;
end;

:: AMI_1:funcreg 5
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster Trivial-AMI(a1,a2) -> strict steady-programmed;
end;

:: AMI_1:exreg 5
registration
  let a1, a2 be set;
  cluster strict AMI-Struct over a1,a2;
end;

:: AMI_1:exreg 6
registration
  let a1 be non empty set;
  let a2 be set;
  cluster non empty strict stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
end;

:: AMI_1:exreg 7
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster non empty strict stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over a1,a2;
end;

:: AMI_1:funcnot 6 => AMI_1:func 6
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty IC-Ins-separated AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  func IC A4 -> Instruction-Location of a3 equals
    a4 . IC a3;
end;

:: AMI_1:def 15
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty IC-Ins-separated AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   IC b4 = b4 . IC b3;

:: AMI_1:th 12
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3, b4 being Element of product the Object-Kind of Trivial-AMI(b1,b2)
      st IC b3 = IC b4
   holds b3 = b4;

:: AMI_1:funcnot 7 => AMI_1:func 7
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 AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  redefine func IC a4 -> Instruction-Location of a3;
end;

:: AMI_1:funcnot 8 => AMI_1:func 8
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 be Element of product the Object-Kind of a3;
  func CurInstr A4 -> Element of the Instructions of a3 equals
    a4 . IC a4;
end;

:: AMI_1:def 17
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   CurInstr b4 = b4 . IC b4;

:: AMI_1:funcnot 9 => AMI_1:func 9
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 be Element of product the Object-Kind of a3;
  func Following A4 -> Element of product the Object-Kind of a3 equals
    Exec(CurInstr a4,a4);
end;

:: AMI_1:def 18
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   Following b4 = Exec(CurInstr b4,b4);

:: AMI_1:funcnot 10 => AMI_1:func 10
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 be Element of product the Object-Kind of a3;
  let a5 be natural set;
  func Computation(A4,A5) -> Element of product the Object-Kind of a3 means
    ex b1 being Function-like quasi_total Relation of NAT,product the Object-Kind of a3 st
       it = b1 . a5 &
        b1 . 0 = a4 &
        (for b2 being natural set holds
           b1 . (b2 + 1) = Following (b1 . b2));
end;

:: AMI_1:def 19
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being natural set
for b6 being Element of product the Object-Kind of b3 holds
      b6 = Computation(b4,b5)
   iff
      ex b7 being Function-like quasi_total Relation of NAT,product the Object-Kind of b3 st
         b6 = b7 . b5 &
          b7 . 0 = b4 &
          (for b8 being natural set holds
             b7 . (b8 + 1) = Following (b7 . b8));

:: AMI_1:funcnot 11 => AMI_1:func 11
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be Function-like quasi_total Relation of NAT,product the Object-Kind of a3;
  let a5 be Element of NAT;
  redefine func a4 . a5 -> Element of product the Object-Kind of a3;
end;

:: AMI_1:attrnot 8 => AMI_1:attr 8
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  attr a4 is halting means
    ex b1 being Element of NAT st
       CurInstr Computation(a4,b1) = halt a3;
end;

:: AMI_1:dfs 17
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
To prove
     a4 is halting
it is sufficient to prove
  thus ex b1 being Element of NAT st
       CurInstr Computation(a4,b1) = halt a3;

:: AMI_1:def 20
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
      b4 is halting(b1, b2, b3)
   iff
      ex b5 being Element of NAT st
         CurInstr Computation(b4,b5) = halt b3;

:: AMI_1:attrnot 9 => AMI_1:attr 9
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  attr a3 is realistic means
    not the Instruction-Counter of a3 in a1;
end;

:: AMI_1:dfs 18
definiens
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
To prove
     a3 is realistic
it is sufficient to prove
  thus not the Instruction-Counter of a3 in a1;

:: AMI_1:def 21
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2 holds
      b3 is realistic(b1, b2)
   iff
      not the Instruction-Counter of b3 in b1;

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

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

:: AMI_1:th 48
theorem
for b1 being non empty set
for b2 being set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
   st b3 is realistic(b1, b2)
for b4 being Instruction-Location of b3 holds
   IC b3 <> b4;

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

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

:: AMI_1:funcnot 12 => AMI_1:func 12
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  assume a4 is halting(a1, a2, a3);
  func Result A4 -> Element of product the Object-Kind of a3 means
    ex b1 being Element of NAT st
       it = Computation(a4,b1) & CurInstr it = halt a3;
end;

:: AMI_1:def 22
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
   st b4 is halting(b1, b2, b3)
for b5 being Element of product the Object-Kind of b3 holds
      b5 = Result b4
   iff
      ex b6 being Element of NAT st
         b5 = Computation(b4,b6) & CurInstr b5 = halt b3;

:: AMI_1:th 53
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 steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Instruction-Location of b3 holds
   b4 . b5 = (Following b4) . b5;

:: AMI_1:funcnot 13 => AMI_1:func 13
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program definite AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  let a5 be Instruction-Location of a3;
  redefine func a4 . a5 -> Element of the Instructions of a3;
end;

:: AMI_1:th 54
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 steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Instruction-Location of b3
for b6 being Element of NAT holds
   b4 . b5 = (Computation(b4,b6)) . b5;

:: AMI_1:th 55
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being Element of NAT
for b4 being non empty stored-program IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b5 being Element of product the Object-Kind of b4 holds
   Computation(b5,b3 + 1) = Exec(b5 . IC Computation(b5,b3),Computation(b5,b3));

:: AMI_1:th 56
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Element of NAT
      st b4 . IC Computation(b4,b5) = halt b3
   holds Result b4 = Computation(b4,b5);

:: AMI_1:th 57
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
   st ex b5 being Element of NAT st
        b4 . IC Computation(b4,b5) = halt b3
for b5 being Element of NAT holds
   Result b4 = Result Computation(b4,b5);

:: AMI_1:funcreg 6
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be Element of the carrier of a3;
  cluster ObjectKind a4 -> non empty;
end;

:: AMI_1:funcnot 14 => AMI_1:func 14
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  func FinPartSt A3 -> Element of bool sproduct the Object-Kind of a3 equals
    {b1 where b1 is Element of sproduct the Object-Kind of a3: b1 is finite};
end;

:: AMI_1:def 23
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2 holds
   FinPartSt b3 = {b4 where b4 is Element of sproduct the Object-Kind of b3: b4 is finite};

:: AMI_1:exreg 8
registration
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  cluster Relation-like Function-like finite Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:modenot 7
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  mode FinPartState of a3 is finite Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:attrnot 10 => AMI_1:attr 10
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 be finite Element of sproduct the Object-Kind of a3;
  attr a4 is autonomic means
    for b1, b2 being Element of product the Object-Kind of a3
       st a4 c= b1 & a4 c= b2
    for b3 being Element of NAT holds
       (Computation(b1,b3)) | proj1 a4 = (Computation(b2,b3)) | proj1 a4;
end;

:: AMI_1:dfs 21
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 AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
To prove
     a4 is autonomic
it is sufficient to prove
  thus for b1, b2 being Element of product the Object-Kind of a3
       st a4 c= b1 & a4 c= b2
    for b3 being Element of NAT holds
       (Computation(b1,b3)) | proj1 a4 = (Computation(b2,b3)) | proj1 a4;

:: AMI_1:def 25
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
      b4 is autonomic(b1, b2, b3)
   iff
      for b5, b6 being Element of product the Object-Kind of b3
         st b4 c= b5 & b4 c= b6
      for b7 being Element of NAT holds
         (Computation(b5,b7)) | proj1 b4 = (Computation(b6,b7)) | proj1 b4;

:: AMI_1:attrnot 11 => AMI_1:attr 11
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  attr a4 is halting means
    for b1 being Element of product the Object-Kind of a3
          st a4 c= b1
       holds b1 is halting(a1, a2, a3);
end;

:: AMI_1:dfs 22
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
To prove
     a4 is halting
it is sufficient to prove
  thus for b1 being Element of product the Object-Kind of a3
          st a4 c= b1
       holds b1 is halting(a1, a2, a3);

:: AMI_1:def 26
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
      b4 is halting(b1, b2, b3)
   iff
      for b5 being Element of product the Object-Kind of b3
            st b4 c= b5
         holds b5 is halting(b1, b2, b3);

:: AMI_1:attrnot 12 => AMI_1:attr 12
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;
  attr a3 is programmable means
    ex b1 being finite Element of sproduct the Object-Kind of a3 st
       b1 is not empty & b1 is autonomic(a1, a2, a3);
end;

:: AMI_1:dfs 23
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 AMI-Struct over a1,a2;
To prove
     a3 is programmable
it is sufficient to prove
  thus ex b1 being finite Element of sproduct the Object-Kind of a3 st
       b1 is not empty & b1 is autonomic(a1, a2, a3);

:: AMI_1:def 27
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2 holds
      b3 is programmable(b1, b2)
   iff
      ex b4 being finite Element of sproduct the Object-Kind of b3 st
         b4 is not empty & b4 is autonomic(b1, b2, b3);

:: AMI_1:th 58
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4, b5 being set
for b6, b7 being Element of the carrier of b3
   st ObjectKind b6 = b4 & ObjectKind b7 = b5
for b8 being Element of b4
for b9 being Element of b5 holds
   (b6,b7)-->(b8,b9) is finite Element of sproduct the Object-Kind of b3;

:: AMI_1:th 59
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being set
for b5 being Element of the carrier of b3
   st ObjectKind b5 = b4
for b6 being Element of b4 holds
   b5 .--> b6 is finite Element of sproduct the Object-Kind of b3;

:: AMI_1:funcnot 15 => AMI_1:func 15
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 be Element of the carrier of a3;
  let a5 be Element of ObjectKind a4;
  redefine func a4 .--> a5 -> finite Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:funcnot 16 => AMI_1:func 16
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 Element of the carrier of a3;
  let a6 be Element of ObjectKind a4;
  let a7 be Element of ObjectKind a5;
  redefine func (a4,a5)-->(a6,a7) -> finite Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:th 60
theorem
for b1 being non empty set
for b2 being set holds
   Trivial-AMI(b1,b2) is realistic(b1, b2);

:: AMI_1:th 61
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set holds
   Trivial-AMI(b1,b2) is programmable(b1, b2);

:: AMI_1:funcreg 7
registration
  let a1 be non empty set;
  let a2 be set;
  cluster Trivial-AMI(a1,a2) -> strict realistic;
end;

:: AMI_1:funcreg 8
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster Trivial-AMI(a1,a2) -> strict programmable;
end;

:: AMI_1:exreg 9
registration
  let a1 be non empty set;
  let a2 be set;
  cluster strict realistic AMI-Struct over a1,a2;
end;

:: AMI_1:exreg 10
registration
  let a1 be non empty set;
  let a2 be set;
  cluster non empty strict stored-program IC-Ins-separated definite realistic AMI-Struct over a1,a2;
end;

:: AMI_1:exreg 11
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster non empty strict stored-program halting IC-Ins-separated steady-programmed definite realistic programmable AMI-Struct over a1,a2;
end;

:: AMI_1:th 62
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being finite Element of sproduct the Object-Kind of b3 holds
   b4 | proj1 b5 is finite Element of sproduct the Object-Kind of b3;

:: AMI_1:th 63
theorem
for b1 being non empty set
for b2 being set
for b3 being AMI-Struct over b1,b2 holds
   {} is finite Element of sproduct the Object-Kind of b3;

:: AMI_1:exreg 12
registration
  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 programmable AMI-Struct over a1,a2;
  cluster non empty Relation-like Function-like finite autonomic Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:funcnot 17 => AMI_1:func 17
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4, a5 be finite Element of sproduct the Object-Kind of a3;
  redefine func a4 +* a5 -> finite Element of sproduct the Object-Kind of a3;
  idempotence;
::  for a1, a2 being set
::  for a3 being AMI-Struct over a1,a2
::  for a4 being finite Element of sproduct the Object-Kind of a3 holds
::     a4 +* a4 = a4;
end;

:: AMI_1:th 64
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Instruction-Location of b3
for b5 being Element of ObjectKind IC b3
   st b5 = b4
for b6 being Element of ObjectKind b4
   st b6 = halt b3
for b7 being Element of product the Object-Kind of b3
      st (IC b3,b4)-->(b5,b6) c= b7
   holds CurInstr b7 = halt b3;

:: AMI_1:th 65
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Instruction-Location of b3
for b5 being Element of ObjectKind IC b3
   st b5 = b4
for b6 being Element of ObjectKind b4
      st b6 = halt b3
   holds (IC b3,b4)-->(b5,b6) is halting(b1, b2, b3);

:: AMI_1:th 66
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Instruction-Location of b3
for b5 being Element of ObjectKind IC b3
   st b5 = b4
for b6 being Element of ObjectKind b4
   st b6 = halt b3
for b7 being Element of product the Object-Kind of b3
   st (IC b3,b4)-->(b5,b6) c= b7
for b8 being Element of NAT holds
   Computation(b7,b8) = b7;

:: AMI_1:th 67
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Instruction-Location of b3
for b5 being Element of ObjectKind IC b3
   st b5 = b4
for b6 being Element of ObjectKind b4
      st b6 = halt b3
   holds (IC b3,b4)-->(b5,b6) is autonomic(b1, b2, b3);

:: AMI_1:exreg 13
registration
  let a1 be non empty 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;
  cluster Relation-like Function-like finite autonomic halting Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:modenot 8
definition
  let a1 be non empty 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;
  mode pre-program of a3 is finite autonomic halting Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:funcnot 18 => AMI_1:func 18
definition
  let a1 be non empty 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 finite Element of sproduct the Object-Kind of a3;
  assume a4 is finite autonomic halting Element of sproduct the Object-Kind of a3;
  func Result A4 -> finite Element of sproduct the Object-Kind of a3 means
    for b1 being Element of product the Object-Kind of a3
          st a4 c= b1
       holds it = (Result b1) | proj1 a4;
end;

:: AMI_1:def 28
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
   st b4 is finite autonomic halting Element of sproduct the Object-Kind of b3
for b5 being finite Element of sproduct the Object-Kind of b3 holds
      b5 = Result b4
   iff
      for b6 being Element of product the Object-Kind of b3
            st b4 c= b6
         holds b5 = (Result b6) | proj1 b4;

:: AMI_1:prednot 1 => AMI_1:pred 1
definition
  let a1 be non empty 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 finite Element of sproduct the Object-Kind of a3;
  let a5 be Relation-like Function-like set;
  pred A4 computes A5 means
    for b1 being set
          st b1 in proj1 a5
       holds ex b2 being finite Element of sproduct the Object-Kind of a3 st
          b1 = b2 &
           a4 +* b2 is finite autonomic halting Element of sproduct the Object-Kind of a3 &
           a5 . b2 c= Result (a4 +* b2);
end;

:: AMI_1:dfs 25
definiens
  let a1 be non empty 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 finite Element of sproduct the Object-Kind of a3;
  let a5 be Relation-like Function-like set;
To prove
     a4 computes a5
it is sufficient to prove
  thus for b1 being set
          st b1 in proj1 a5
       holds ex b2 being finite Element of sproduct the Object-Kind of a3 st
          b1 = b2 &
           a4 +* b2 is finite autonomic halting Element of sproduct the Object-Kind of a3 &
           a5 . b2 c= Result (a4 +* b2);

:: AMI_1:def 29
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being Relation-like Function-like set holds
      b4 computes b5
   iff
      for b6 being set
            st b6 in proj1 b5
         holds ex b7 being finite Element of sproduct the Object-Kind of b3 st
            b6 = b7 &
             b4 +* b7 is finite autonomic halting Element of sproduct the Object-Kind of b3 &
             b5 . b7 c= Result (b4 +* b7);

:: AMI_1:prednot 2 => not AMI_1:pred 1
notation
  let a1 be non empty 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 finite Element of sproduct the Object-Kind of a3;
  let a5 be Relation-like Function-like set;
  antonym a4 does_not_compute a5 for a4 computes a5;
end;

:: AMI_1:th 68
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   b4 computes {};

:: AMI_1:th 69
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
      b4 is finite autonomic halting Element of sproduct the Object-Kind of b3
   iff
      b4 computes {} .--> Result b4;

:: AMI_1:th 70
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
      b4 is finite autonomic halting Element of sproduct the Object-Kind of b3
   iff
      b4 computes {} .--> {};

:: AMI_1:attrnot 13 => AMI_1:attr 13
definition
  let a1 be non empty 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 Function-like Relation of FinPartSt a3,FinPartSt a3;
  attr a4 is computable means
    ex b1 being finite Element of sproduct the Object-Kind of a3 st
       b1 computes a4;
end;

:: AMI_1:dfs 26
definiens
  let a1 be non empty 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 Function-like Relation of FinPartSt a3,FinPartSt a3;
To prove
     a4 is computable
it is sufficient to prove
  thus ex b1 being finite Element of sproduct the Object-Kind of a3 st
       b1 computes a4;

:: AMI_1:def 30
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3 holds
      b4 is computable(b1, b2, b3)
   iff
      ex b5 being finite Element of sproduct the Object-Kind of b3 st
         b5 computes b4;

:: AMI_1:th 71
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3
      st b4 = {}
   holds b4 is computable(b1, b2, b3);

:: AMI_1:th 72
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3
      st b4 = {} .--> {}
   holds b4 is computable(b1, b2, b3);

:: AMI_1:th 73
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite autonomic halting Element of sproduct the Object-Kind of b3
for b5 being Function-like Relation of FinPartSt b3,FinPartSt b3
      st b5 = {} .--> Result b4
   holds b5 is computable(b1, b2, b3);

:: AMI_1:modenot 9 => AMI_1:mode 4
definition
  let a1 be non empty 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 Function-like Relation of FinPartSt a3,FinPartSt a3;
  assume a4 is computable(a1, a2, a3);
  mode Program of A4 -> finite Element of sproduct the Object-Kind of a3 means
    it computes a4;
end;

:: AMI_1:dfs 27
definiens
  let a1 be non empty 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 Function-like Relation of FinPartSt a3,FinPartSt a3;
  let a5 be finite Element of sproduct the Object-Kind of a3;
To prove
     a5 is Program of a4
it is sufficient to prove
thus a4 is computable(a1, a2, a3);
  thus a5 computes a4;

:: AMI_1:def 31
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3
   st b4 is computable(b1, b2, b3)
for b5 being finite Element of sproduct the Object-Kind of b3 holds
      b5 is Program of b4
   iff
      b5 computes b4;

:: AMI_1:th 74
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3
   st b4 = {}
for b5 being finite Element of sproduct the Object-Kind of b3 holds
   b5 is Program of b4;

:: AMI_1:th 75
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3
   st b4 = {} .--> {}
for b5 being finite autonomic halting Element of sproduct the Object-Kind of b3 holds
   b5 is Program of b4;

:: AMI_1:th 76
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite realistic AMI-Struct over b1,b2
for b4 being finite autonomic halting Element of sproduct the Object-Kind of b3
for b5 being Function-like Relation of FinPartSt b3,FinPartSt b3
      st b5 = {} .--> Result b4
   holds b4 is Program of b5;

:: AMI_1:funcnot 19 => MCART_1:func 1
notation
  let a1 be set;
  synonym InsCode a1 for a1 `1;
end;

:: AMI_1:funcnot 20 => MCART_1:func 2
notation
  let a1 be set;
  synonym AddressPart a1 for a1 `2;
end;

:: AMI_1:attrnot 14 => AMI_1:attr 14
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  attr a3 is standard-ins means
    the Instructions of a3 c= [:NAT,((union a2) \/ the carrier of a3) *:];
end;

:: AMI_1:dfs 28
definiens
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
To prove
     a3 is standard-ins
it is sufficient to prove
  thus the Instructions of a3 c= [:NAT,((union a2) \/ the carrier of a3) *:];

:: AMI_1:def 32
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2 holds
      b3 is standard-ins(b1, b2)
   iff
      the Instructions of b3 c= [:NAT,((union b2) \/ the carrier of b3) *:];

:: AMI_1:funcreg 9
registration
  let a1, a2 be set;
  cluster Trivial-AMI(a1,a2) -> strict standard-ins;
end;

:: AMI_1:exreg 14
registration
  let a1, a2 be set;
  cluster non empty stored-program standard-ins AMI-Struct over a1,a2;
end;

:: AMI_1:exreg 15
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 AMI-Struct over a1,a2;
end;

:: AMI_1:funcreg 10
registration
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  cluster the Instructions of a3 -> non empty Relation-like;
end;

:: AMI_1:funcnot 21 => AMI_1:func 19
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  func InsCodes A3 -> set equals
    proj1 the Instructions of a3;
end;

:: AMI_1:def 33
theorem
for b1, b2 being set
for b3 being standard-ins AMI-Struct over b1,b2 holds
   InsCodes b3 = proj1 the Instructions of b3;

:: AMI_1:modenot 10
definition
  let a1, a2 be set;
  let a3 be standard-ins AMI-Struct over a1,a2;
  mode InsType of a3 is Element of InsCodes a3;
end;

:: AMI_1:funcnot 22 => AMI_1:func 20
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 InsCode a4 -> Element of InsCodes a3;
end;

:: AMI_1:th 77
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   b4 in FinPartSt b3;

:: AMI_1:modenot 11 => AMI_1:mode 5
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  mode IL-FinSequence of A3 -> FinSequence of a1 means
    TRUE;
end;

:: AMI_1:dfs 30
definiens
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be FinSequence of a1;
To prove
     a4 is IL-FinSequence of a3
it is sufficient to prove
  thus TRUE;

:: AMI_1:def 34
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being FinSequence of b1 holds
   (b4 is IL-FinSequence of b3 implies TRUE) & b4 is IL-FinSequence of b3;

:: AMI_1:funcnot 23 => AMI_1:func 21
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be IL-FinSequence of a3;
  let a5 be set;
  func A4 /. A5 -> Instruction-Location of a3 equals
    a4 /. a5;
end;

:: AMI_1:def 35
theorem
for b1 being non empty set
for b2 being set
for b3 being non empty AMI-Struct over b1,b2
for b4 being IL-FinSequence of b3
for b5 being set holds
   b4 /. b5 = b4 /. b5;

:: AMI_1:funcnot 24 => AMI_1:func 22
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be Instruction-Location of a3;
  redefine func <*a4*> -> IL-FinSequence of a3;
end;

:: AMI_1:funcnot 25 => AMI_1:func 23
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4, a5 be Instruction-Location of a3;
  redefine func <*a4, a5*> -> IL-FinSequence of a3;
end;

:: AMI_1:exreg 16
registration
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  cluster non empty Relation-like Function-like finite FinSequence-like IL-FinSequence of a3;
end;

:: AMI_1:funcnot 26 => AMI_1:func 24
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4, a5 be IL-FinSequence of a3;
  redefine func a4 ^' a5 -> IL-FinSequence of a3;
end;

:: AMI_1:modenot 12 => AMI_1:mode 6
definition
  let a1 be set;
  let a2 be non empty set;
  let a3 be set;
  let a4 be non empty AMI-Struct over a2,a3;
  mode IL-Function of A1,A4 -> Function-like quasi_total Relation of a1,a2 means
    TRUE;
end;

:: AMI_1:dfs 32
definiens
  let a1 be set;
  let a2 be non empty set;
  let a3 be set;
  let a4 be non empty AMI-Struct over a2,a3;
  let a5 be Function-like quasi_total Relation of a1,a2;
To prove
     a5 is IL-Function of a1,a4
it is sufficient to prove
  thus TRUE;

:: AMI_1:def 36
theorem
for b1 being set
for b2 being non empty set
for b3 being set
for b4 being non empty AMI-Struct over b2,b3
for b5 being Function-like quasi_total Relation of b1,b2 holds
   (b5 is IL-Function of b1,b4 implies TRUE) & b5 is IL-Function of b1,b4;

:: AMI_1:funcnot 27 => AMI_1:func 25
definition
  let a1, a2 be non empty set;
  let a3 be set;
  let a4 be non empty AMI-Struct over a2,a3;
  let a5 be IL-Function of a1,a4;
  let a6 be Element of a1;
  redefine func a5 . a6 -> Instruction-Location of a4;
end;

:: AMI_1:modenot 13 => AMI_1:mode 7
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  mode IL-DecoratedTree of A3 -> Function-like DecoratedTree-like ParametrizedSubset of a1 means
    TRUE;
end;

:: AMI_1:dfs 33
definiens
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be Function-like DecoratedTree-like ParametrizedSubset of a1;
To prove
     a4 is IL-DecoratedTree of a3
it is sufficient to prove
  thus TRUE;

:: AMI_1:def 37
theorem
for b1 being non empty set
for b2 being set
for b3 being non empty AMI-Struct over b1,b2
for b4 being Function-like DecoratedTree-like ParametrizedSubset of b1 holds
   (b4 is IL-DecoratedTree of b3 implies TRUE) & b4 is IL-DecoratedTree of b3;

:: AMI_1:funcnot 28 => AMI_1:func 26
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be IL-DecoratedTree of a3;
  let a5 be set;
  assume a5 in proj1 a4;
  func A4 . A5 -> Instruction-Location of a3 equals
    a4 . a5;
end;

:: AMI_1:def 38
theorem
for b1 being non empty set
for b2 being set
for b3 being non empty AMI-Struct over b1,b2
for b4 being IL-DecoratedTree of b3
for b5 being set
      st b5 in proj1 b4
   holds b4 . b5 = b4 . b5;

:: AMI_1:sch 1
scheme AMI_1:sch 1
{F1 -> non empty set,
  F2 -> set,
  F3 -> non empty stored-program AMI-Struct over F1(),F2(),
  F4 -> set,
  F5 -> set}:
{F5(b1) where b1 is Instruction-Location of F3(): b1 in F4()} is finite
provided
   F4() is finite;


:: AMI_1:sch 2
scheme AMI_1:sch 2
{F1 -> non empty set,
  F2 -> set,
  F3 -> set,
  F4 -> non empty stored-program AMI-Struct over F1(),F2(),
  F5 -> set,
  F6 -> Instruction-Location of F4()}:
{F5(b1) where b1 is Element of F3(): ex b2 being Instruction-Location of F4() st
   b2 = F6() & P1[b1, b2]} = {F5(b1) where b1 is Element of F3(): P1[b1, F6()]}


:: AMI_1:funcreg 11
registration
  let a1 be non empty set;
  let a2 be set;
  let a3 be AMI-Struct over a1,a2;
  cluster FinPartSt a3 -> non empty;
end;

:: AMI_1:funcnot 29 => AMI_1:func 27
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 be Instruction-Location of a3;
  func Start-At A4 -> finite Element of sproduct the Object-Kind of a3 equals
    (IC a3) .--> a4;
end;

:: AMI_1:def 39
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Instruction-Location of b3 holds
   Start-At b4 = (IC b3) .--> b4;

:: AMI_1:attrnot 15 => AMI_1:attr 15
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  attr a4 is programmed means
    proj1 a4 c= a1;
end;

:: AMI_1:dfs 36
definiens
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
To prove
     a4 is programmed
it is sufficient to prove
  thus proj1 a4 c= a1;

:: AMI_1:def 40
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
      b4 is programmed(b1, b2, b3)
   iff
      proj1 b4 c= b1;

:: AMI_1:exreg 17
registration
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  cluster Relation-like Function-like finite programmed Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:th 78
theorem
for b1 being non empty set
for b2 being set
for b3 being AMI-Struct over b1,b2
for b4, b5 being finite programmed Element of sproduct the Object-Kind of b3 holds
b4 +* b5 is programmed(b1, b2, b3);

:: AMI_1:th 79
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   proj1 b4 = the carrier of b3;

:: AMI_1:th 80
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   proj1 b4 c= the carrier of b3;

:: AMI_1:th 81
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 steady-programmed definite AMI-Struct over b1,b2
for b4 being finite programmed Element of sproduct the Object-Kind of b3
for b5 being Element of product the Object-Kind of b3
   st b4 c= b5
for b6 being Element of NAT holds
   b4 c= Computation(b5,b6);

:: AMI_1:prednot 3 => AMI_1:pred 2
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty IC-Ins-separated AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  let a5 be Element of a1;
  pred A4 starts_at A5 means
    IC a4 = a5;
end;

:: AMI_1:dfs 37
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty IC-Ins-separated AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  let a5 be Element of a1;
To prove
     a4 starts_at a5
it is sufficient to prove
  thus IC a4 = a5;

:: AMI_1:def 41
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty IC-Ins-separated AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Element of b1 holds
      b4 starts_at b5
   iff
      IC b4 = b5;

:: AMI_1:prednot 4 => AMI_1:pred 3
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty halting IC-Ins-separated AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  let a5 be set;
  pred A4 halts_at A5 means
    a4 . a5 = halt a3;
end;

:: AMI_1:dfs 38
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty halting IC-Ins-separated AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  let a5 be set;
To prove
     a4 halts_at a5
it is sufficient to prove
  thus a4 . a5 = halt a3;

:: AMI_1:def 42
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty halting IC-Ins-separated AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being set holds
      b4 halts_at b5
   iff
      b4 . b5 = halt b3;

:: AMI_1:th 82
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   ex b5 being Element of product the Object-Kind of b3 st
      b4 c= b5;

:: AMI_1:funcnot 30 => AMI_1:func 28
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 be finite Element of sproduct the Object-Kind of a3;
  assume IC a3 in proj1 a4;
  func IC A4 -> Instruction-Location of a3 equals
    a4 . IC a3;
end;

:: AMI_1:def 43
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
      st IC b3 in proj1 b4
   holds IC b4 = b4 . IC b3;

:: AMI_1:prednot 5 => AMI_1:pred 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 AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  let a5 be Element of a1;
  pred A4 starts_at A5 means
    IC a3 in proj1 a4 & IC a4 = a5;
end;

:: AMI_1:dfs 40
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 AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  let a5 be Element of a1;
To prove
     a4 starts_at a5
it is sufficient to prove
  thus IC a3 in proj1 a4 & IC a4 = a5;

:: AMI_1:def 44
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being Element of b1 holds
      b4 starts_at b5
   iff
      IC b3 in proj1 b4 & IC b4 = b5;

:: AMI_1:prednot 6 => AMI_1:pred 5
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  let a5 be set;
  pred A4 halts_at A5 means
    a5 in proj1 a4 & a4 . a5 = halt a3;
end;

:: AMI_1:dfs 41
definiens
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  let a5 be set;
To prove
     a4 halts_at a5
it is sufficient to prove
  thus a5 in proj1 a4 & a4 . a5 = halt a3;

:: AMI_1:def 45
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being set holds
      b4 halts_at b5
   iff
      b5 in proj1 b4 & b4 . b5 = halt b3;

:: AMI_1:th 83
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
      b4 is halting(b1, b2, b3)
   iff
      ex b5 being Element of NAT st
         b4 halts_at IC Computation(b4,b5);

:: AMI_1:th 84
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being finite Element of sproduct the Object-Kind of b3
for b6 being Instruction-Location of b3
      st b5 c= b4 & b5 halts_at b6
   holds b4 halts_at b6;

:: AMI_1:th 85
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Element of NAT
      st b4 is halting(b1, b2, b3)
   holds    Result b4 = Computation(b4,b5)
   iff
      b4 halts_at IC Computation(b4,b5);

:: AMI_1:th 86
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 steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being finite programmed Element of sproduct the Object-Kind of b3
for b6 being Element of NAT holds
      b5 c= b4
   iff
      b5 c= Computation(b4,b6);

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

:: AMI_1:th 88
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being with_non-empty_elements set
   st b1 <= b2
for b5 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b3,b4
for b6 being Element of product the Object-Kind of b5
      st b6 halts_at IC Computation(b6,b1)
   holds b6 halts_at IC Computation(b6,b2);

:: AMI_1:th 89
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being with_non-empty_elements set
   st b1 <= b2
for b5 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b3,b4
for b6 being Element of product the Object-Kind of b5
      st b6 halts_at IC Computation(b6,b1)
   holds Computation(b6,b2) = Computation(b6,b1);

:: AMI_1:th 90
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
   st ex b5 being Element of NAT st
        b4 halts_at IC Computation(b4,b5)
for b5 being Element of NAT holds
   Result b4 = Result Computation(b4,b5);

:: AMI_1:th 91
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Instruction-Location of b3
for b6 being Element of NAT holds
      b4 halts_at b5
   iff
      Computation(b4,b6) halts_at b5;

:: AMI_1:th 92
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being Element of b1
   st b4 starts_at b5
for b6 being Element of product the Object-Kind of b3
      st b4 c= b6
   holds b6 starts_at b5;

:: AMI_1:funcnot 31 => AMI_1:func 29
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 be Instruction-Location of a3;
  let a5 be Element of the Instructions of a3;
  redefine func a4 .--> a5 -> finite programmed Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:funcnot 32 => AMI_1:func 30
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program halting IC-Ins-separated definite AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  assume a4 is halting(a1, a2, a3);
  func LifeSpan A4 -> Element of NAT means
    CurInstr Computation(a4,it) = halt a3 &
     (for b1 being Element of NAT
           st CurInstr Computation(a4,b1) = halt a3
        holds it <= b1);
end;

:: AMI_1:def 46
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
   st b4 is halting(b1, b2, b3)
for b5 being Element of NAT holds
      b5 = LifeSpan b4
   iff
      CurInstr Computation(b4,b5) = halt b3 &
       (for b6 being Element of NAT
             st CurInstr Computation(b4,b6) = halt b3
          holds b5 <= b6);

:: AMI_1:th 93
theorem
for b1 being non empty set
for b2 being non empty with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Element of NAT holds
      b4 is halting(b1, b2, b3)
   iff
      Computation(b4,b5) is halting(b1, b2, b3);

:: AMI_1:th 94
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   IC b3 in proj1 b4;

:: AMI_1:th 95
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   Start-At IC b4 = b4 | {IC b3};

:: AMI_1:th 96
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Instruction-Location of b3 holds
   Start-At b4 = {[IC b3,b4]};

:: AMI_1:th 97
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being Element of product the Object-Kind of b3
      st IC b3 in proj1 b4 & b4 c= b5
   holds IC b4 = IC b5;

:: AMI_1:funcnot 33 => AMI_1:func 31
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 be finite programmed Element of sproduct the Object-Kind of a3;
  let a5 be set;
  assume a5 in proj1 a4;
  func pi(A4,A5) -> Element of the Instructions of a3 equals
    a4 . a5;
end;

:: AMI_1:def 47
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite programmed Element of sproduct the Object-Kind of b3
for b5 being set
      st b5 in proj1 b4
   holds pi(b4,b5) = b4 . b5;

:: AMI_1:th 98
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being set
for b5 being finite Element of sproduct the Object-Kind of b3
      st b4 c= b5
   holds b4 is finite Element of sproduct the Object-Kind of b3;

:: AMI_1:funcnot 34 => AMI_1:func 32
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  func ProgramPart A4 -> finite programmed Element of sproduct the Object-Kind of a3 equals
    a4 | a1;
end;

:: AMI_1:def 48
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   ProgramPart b4 = b4 | b1;

:: AMI_1:funcnot 35 => AMI_1:func 33
definition
  let a1, a2 be set;
  let a3 be non empty stored-program AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  func DataPart A4 -> finite Element of sproduct the Object-Kind of a3 equals
    a4 | ((the carrier of a3) \ ({IC a3} \/ a1));
end;

:: AMI_1:def 49
theorem
for b1, b2 being set
for b3 being non empty stored-program AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   DataPart b4 = b4 | ((the carrier of b3) \ ({IC b3} \/ b1));

:: AMI_1:attrnot 16 => AMI_1:attr 16
definition
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
  attr a4 is data-only means
    proj1 a4 misses {IC a3} \/ a1;
end;

:: AMI_1:dfs 46
definiens
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  let a4 be finite Element of sproduct the Object-Kind of a3;
To prove
     a4 is data-only
it is sufficient to prove
  thus proj1 a4 misses {IC a3} \/ a1;

:: AMI_1:def 50
theorem
for b1, b2 being set
for b3 being non empty AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
      b4 is data-only(b1, b2, b3)
   iff
      proj1 b4 misses {IC b3} \/ b1;

:: AMI_1:exreg 18
registration
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  cluster Relation-like Function-like finite data-only Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:th 99
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 steady-programmed definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being Element of product the Object-Kind of b3
   st b4 c= b5
for b6 being Element of NAT holds
   ProgramPart b4 c= Computation(b5,b6);

:: AMI_1:th 100
theorem
for b1, b2 being set
for b3 being non empty stored-program AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   not IC b3 in proj1 DataPart b4;

:: AMI_1:th 101
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 realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   not IC b3 in proj1 ProgramPart b4;

:: AMI_1:th 102
theorem
for b1, b2 being set
for b3 being non empty stored-program AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   {IC b3} misses proj1 DataPart b4;

:: AMI_1:th 103
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 realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
   {IC b3} misses proj1 ProgramPart b4;

:: AMI_1:th 104
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4, b5 being finite Element of sproduct the Object-Kind of b3 holds
proj1 DataPart b4 misses proj1 ProgramPart b5;

:: AMI_1:th 105
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite programmed Element of sproduct the Object-Kind of b3 holds
   ProgramPart b4 = b4;

:: AMI_1:th 106
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
for b5 being Instruction-Location of b3
      st b5 in proj1 b4
   holds b5 in proj1 ProgramPart b4;

:: AMI_1:th 107
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite data-only Element of sproduct the Object-Kind of b3
for b5 being finite Element of sproduct the Object-Kind of b3 holds
      b4 c= b5
   iff
      b4 c= DataPart b5;

:: AMI_1:th 108
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 realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
      st IC b3 in proj1 b4
   holds b4 = ((Start-At IC b4) +* ProgramPart b4) +* DataPart b4;

:: AMI_1:attrnot 17 => AMI_1:attr 17
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 be Function-like Relation of FinPartSt a3,FinPartSt a3;
  attr a4 is data-only means
    for b1 being finite Element of sproduct the Object-Kind of a3
          st b1 in proj1 a4
       holds b1 is data-only(a1, a2, a3) &
        (for b2 being finite Element of sproduct the Object-Kind of a3
              st b2 = a4 . b1
           holds b2 is data-only(a1, a2, a3));
end;

:: AMI_1:dfs 47
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 AMI-Struct over a1,a2;
  let a4 be Function-like Relation of FinPartSt a3,FinPartSt a3;
To prove
     a4 is data-only
it is sufficient to prove
  thus for b1 being finite Element of sproduct the Object-Kind of a3
          st b1 in proj1 a4
       holds b1 is data-only(a1, a2, a3) &
        (for b2 being finite Element of sproduct the Object-Kind of a3
              st b2 = a4 . b1
           holds b2 is data-only(a1, a2, a3));

:: AMI_1:def 51
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Function-like Relation of FinPartSt b3,FinPartSt b3 holds
      b4 is data-only(b1, b2, b3)
   iff
      for b5 being finite Element of sproduct the Object-Kind of b3
            st b5 in proj1 b4
         holds b5 is data-only(b1, b2, b3) &
          (for b6 being finite Element of sproduct the Object-Kind of b3
                st b6 = b4 . b5
             holds b6 is data-only(b1, b2, b3));

:: AMI_1:th 109
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 realistic AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
      st IC b3 in proj1 b4
   holds b4 is not programmed(b1, b2, b3);

:: AMI_1:funcnot 36 => AMI_1:func 34
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be AMI-Struct over a1,a2;
  let a4 be Element of product the Object-Kind of a3;
  let a5 be finite Element of sproduct the Object-Kind of a3;
  redefine func a4 +* a5 -> Element of product the Object-Kind of a3;
  idempotence;
::  for a1 being non empty set
::  for a2 being with_non-empty_elements set
::  for a3 being AMI-Struct over a1,a2
::  for a4 being Element of product the Object-Kind of a3 holds
::     a4 +* a4 = a4;
end;

:: AMI_1:th 110
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3
      st IC b3 in proj1 b4
   holds Start-At IC b4 c= b4;

:: AMI_1:th 111
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Instruction-Location of b3 holds
   IC (b4 +* Start-At b5) = b5;

:: AMI_1:th 112
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 realistic AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5, b6 being Instruction-Location of b3 holds
b4 . b6 = (b4 +* Start-At b5) . b6;

:: AMI_1:th 113
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4, b5 being Element of product the Object-Kind of b3
for b6 being set holds
   b4 +* (b5 | b6) is Element of product the Object-Kind of b3;

:: AMI_1:th 114
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 product the Object-Kind of b3 holds
   b1 c= proj1 b4;

:: AMI_1:th 115
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 AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3 holds
   IC b4 in proj1 b4;

:: AMI_1:th 116
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Instruction-Location of b3 holds
   b5 in proj1 b4;

:: AMI_1:th 117
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program steady-programmed AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3
for b5 being Element of product the Object-Kind of b3 holds
   (Exec(b4,b5)) | b1 = b5 | b1;

:: AMI_1:exreg 19
registration
  let a1 be non empty set;
  let a2 be set;
  let a3 be AMI-Struct over a1,a2;
  cluster Relation-like Function-like finite programmed Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:th 118
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program definite AMI-Struct over b1,b2
for b4 being finite programmed Element of sproduct the Object-Kind of b3 holds
   proj2 b4 c= the Instructions of b3;

:: AMI_1:funcnot 37 => AMI_1:func 35
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be AMI-Struct over a1,a2;
  let a4, a5 be finite programmed Element of sproduct the Object-Kind of a3;
  redefine func a4 +* a5 -> finite programmed Element of sproduct the Object-Kind of a3;
  idempotence;
::  for a1 being non empty set
::  for a2 being set
::  for a3 being AMI-Struct over a1,a2
::  for a4 being finite programmed Element of sproduct the Object-Kind of a3 holds
::     a4 +* a4 = a4;
end;

:: AMI_1:th 119
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program definite AMI-Struct over b1,b2
for b4 being Function-like quasi_total Relation of the Instructions of b3,the Instructions of b3
for b5 being finite programmed Element of sproduct the Object-Kind of b3 holds
   proj1 (b5 * b4) = proj1 b5;

:: AMI_1:funcnot 38 => AMI_1:func 36
definition
  let a1 be non empty set;
  let a2 be non empty with_non-empty_elements set;
  let a3 be non empty stored-program definite AMI-Struct over a1,a2;
  let a4 be finite programmed Element of sproduct the Object-Kind of a3;
  let a5 be Function-like quasi_total Relation of the Instructions of a3,the Instructions of a3;
  redefine func a5 * a4 -> finite programmed Element of sproduct the Object-Kind of a3;
end;

:: AMI_1:th 120
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being finite programmed Element of sproduct the Object-Kind of b3 holds
   b4,b4 +* b5 equal_outside b1;

:: AMI_1:th 121
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 realistic AMI-Struct over b1,b2
for b4, b5 being Element of product the Object-Kind of b3
      st b4,b5 equal_outside b1
   holds IC b4 = IC b5;

:: AMI_1:th 122
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program halting IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
      st b4 is halting(b1, b2, b3)
   holds Result b4 = Computation(b4,LifeSpan b4);

:: AMI_1:funcnot 39 => AMI_1:func 37
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 be Element of product the Object-Kind of a3;
  let a5 be Instruction-Location of a3;
  let a6 be Element of the Instructions of a3;
  redefine func a4 +*(a5,a6) -> Element of product the Object-Kind of a3;
end;

:: AMI_1:th 123
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 steady-programmed definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Element of NAT holds
   b4 | b1 = (Computation(b4,b5)) | b1;

:: AMI_1:th 124
theorem
for b1 being Element of NAT
for b2 being non empty set
for b3 being with_non-empty_elements set
for b4 being non empty stored-program IC-Ins-separated steady-programmed definite AMI-Struct over b2,b3
for b5 being finite programmed Element of sproduct the Object-Kind of b4
for b6, b7 being Element of product the Object-Kind of b4
      st b5 c= b6 & b5 c= b7
   holds (Computation(b6,b1)) | proj1 b5 = (Computation(b7,b1)) | proj1 b5;

:: AMI_1:th 125
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being AMI-Struct over b1,b2
for b4 being Element of FinPartSt b3 holds
   b4 is finite Element of sproduct the Object-Kind of b3;

:: AMI_1:th 126
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program definite AMI-Struct over b1,b2
for b4 being finite programmed Element of sproduct the Object-Kind of b3
for b5 being set
      st b5 in proj1 b4
   holds b4 . b5 is Element of the Instructions of b3;

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

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

:: AMI_1:th 129
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 realistic AMI-Struct over b1,b2
for b4, b5 being Element of product the Object-Kind of b3
for b6 being Instruction-Location of b3
for b7 being Element of ObjectKind IC b3
for b8 being Element of ObjectKind b6
      st b7 = b6 & b5 = b4 +* ((IC b3,b6)-->(b7,b8))
   holds b5 . b6 = b8 &
    IC b5 = b6 &
    IC Following b5 = (Exec(b5 . IC b5,b5)) . IC b3;

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

:: AMI_1:th 131
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Element of product the Object-Kind of b3
for b5 being Element of the Instructions of b3 holds
   (Exec(b4 . IC b4,b4)) . IC b3 = IC Following b4;