Article AMI_7, MML version 4.99.1005

:: AMI_7:th 2
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program AMI-Struct over b2,b1
for b4 being Element of product the Object-Kind of b3
for b5 being Element of the carrier of b3 holds
   b4 . b5 in ObjectKind b5;

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

:: AMI_7:funcnot 1 => AMI_7: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 be Element of product the Object-Kind of a3;
  let a5 be Element of the carrier of a3;
  let a6 be Element of ObjectKind a5;
  redefine func a4 +*(a5,a6) -> Element of product the Object-Kind of a3;
end;

:: AMI_7:th 4
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated steady-programmed definite AMI-Struct over b2,b1
for b4 being Element of product the Object-Kind of b3
for b5 being Element of the carrier of b3
for b6 being Instruction-Location of b3
for b7 being Element of the Instructions of b3
for b8 being Element of ObjectKind b5
      st b6 <> b5
   holds (Exec(b7,b4)) . b6 = (Exec(b7,b4 +*(b5,b8))) . b6;

:: AMI_7:th 6
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
for b4 being Element of product the Object-Kind of b2
for b5 being Element of the carrier of b2
for b6 being Element of ObjectKind b5
      st b3 is sequential(b1, b2) & b5 <> IC b2
   holds IC Exec(b3,b4) = IC Exec(b3,b4 +*(b5,b6));

:: AMI_7:th 7
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
for b4 being Element of product the Object-Kind of b2
for b5 being Element of the carrier of b2
for b6 being Element of ObjectKind b5
      st b3 is sequential(b1, b2) & b5 <> IC b2
   holds IC Exec(b3,b4 +*(b5,b6)) = IC ((Exec(b3,b4)) +*(b5,b6));

:: AMI_7:th 8
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated steady-programmed definite standard AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
for b4 being Element of product the Object-Kind of b2
for b5 being Element of the carrier of b2
for b6 being Element of ObjectKind b5
for b7 being Instruction-Location of b2 holds
   (Exec(b3,b4 +*(b5,b6))) . b7 = ((Exec(b3,b4)) +*(b5,b6)) . b7;

:: AMI_7:attrnot 1 => AMI_7:attr 1
definition
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
  attr a3 is with_non_trivial_Instructions means
    the Instructions of a3 is not trivial;
end;

:: AMI_7:dfs 1
definiens
  let a1, a2 be set;
  let a3 be AMI-Struct over a1,a2;
To prove
     a3 is with_non_trivial_Instructions
it is sufficient to prove
  thus the Instructions of a3 is not trivial;

:: AMI_7:def 1
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2 holds
      b3 is with_non_trivial_Instructions(b1, b2)
   iff
      the Instructions of b3 is not trivial;

:: AMI_7:attrnot 2 => AMI_7:attr 2
definition
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
  attr a3 is with_non_trivial_ObjectKinds means
    for b1 being Element of the carrier of a3 holds
       ObjectKind b1 is not trivial;
end;

:: AMI_7:dfs 2
definiens
  let a1, a2 be set;
  let a3 be non empty AMI-Struct over a1,a2;
To prove
     a3 is with_non_trivial_ObjectKinds
it is sufficient to prove
  thus for b1 being Element of the carrier of a3 holds
       ObjectKind b1 is not trivial;

:: AMI_7:def 2
theorem
for b1, b2 being set
for b3 being non empty AMI-Struct over b1,b2 holds
      b3 is with_non_trivial_ObjectKinds(b1, b2)
   iff
      for b4 being Element of the carrier of b3 holds
         ObjectKind b4 is not trivial;

:: AMI_7:funcreg 1
registration
  let a1 be with_non-empty_elements set;
  cluster STC a1 -> strict with_non_trivial_ObjectKinds;
end;

:: AMI_7:exreg 1
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 with_non_trivial_Instructions with_non_trivial_ObjectKinds AMI-Struct over NAT,a1;
end;

:: AMI_7:condreg 1
registration
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  cluster non empty stored-program definite with_non_trivial_ObjectKinds -> with_non_trivial_Instructions (AMI-Struct over a1,a2);
end;

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

:: AMI_7:funcreg 2
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty with_non_trivial_ObjectKinds AMI-Struct over NAT,a1;
  let a3 be Element of the carrier of a2;
  cluster ObjectKind a3 -> non trivial;
end;

:: AMI_7:funcreg 3
registration
  let a1 be with_non-empty_elements set;
  let a2 be with_non_trivial_Instructions AMI-Struct over NAT,a1;
  cluster the Instructions of a2 -> non empty non trivial;
end;

:: AMI_7:funcreg 4
registration
  let a1 be non trivial set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty IC-Ins-separated AMI-Struct over a1,a2;
  cluster ObjectKind IC a3 -> non trivial;
end;

:: AMI_7:funcnot 2 => AMI_7:func 2
definition
  let a1 be non empty set;
  let a2 be with_non-empty_elements set;
  let a3 be non empty stored-program AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  func Output A4 -> Element of bool the carrier of a3 means
    for b1 being Element of the carrier of a3 holds
          b1 in it
       iff
          ex b2 being Element of product the Object-Kind of a3 st
             b2 . b1 <> (Exec(a4,b2)) . b1;
end;

:: AMI_7:def 3
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 the Instructions of b3
for b5 being Element of bool the carrier of b3 holds
      b5 = Output b4
   iff
      for b6 being Element of the carrier of b3 holds
            b6 in b5
         iff
            ex b7 being Element of product the Object-Kind of b3 st
               b7 . b6 <> (Exec(b4,b7)) . b6;

:: AMI_7:funcnot 3 => AMI_7:func 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 AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  func Out_\_Inp A4 -> Element of bool the carrier of a3 means
    for b1 being Element of the carrier of a3 holds
          b1 in it
       iff
          for b2 being Element of product the Object-Kind of a3
          for b3 being Element of ObjectKind b1 holds
             Exec(a4,b2) = Exec(a4,b2 +*(b1,b3));
end;

:: AMI_7:def 4
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 the Instructions of b3
for b5 being Element of bool the carrier of b3 holds
      b5 = Out_\_Inp b4
   iff
      for b6 being Element of the carrier of b3 holds
            b6 in b5
         iff
            for b7 being Element of product the Object-Kind of b3
            for b8 being Element of ObjectKind b6 holds
               Exec(b4,b7) = Exec(b4,b7 +*(b6,b8));

:: AMI_7:funcnot 4 => AMI_7:func 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 Element of the Instructions of a3;
  func Out_U_Inp A4 -> Element of bool the carrier of a3 means
    for b1 being Element of the carrier of a3 holds
          b1 in it
       iff
          ex b2 being Element of product the Object-Kind of a3 st
             ex b3 being Element of ObjectKind b1 st
                Exec(a4,b2 +*(b1,b3)) <> (Exec(a4,b2)) +*(b1,b3);
end;

:: AMI_7:def 5
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 the Instructions of b3
for b5 being Element of bool the carrier of b3 holds
      b5 = Out_U_Inp b4
   iff
      for b6 being Element of the carrier of b3 holds
            b6 in b5
         iff
            ex b7 being Element of product the Object-Kind of b3 st
               ex b8 being Element of ObjectKind b6 st
                  Exec(b4,b7 +*(b6,b8)) <> (Exec(b4,b7)) +*(b6,b8);

:: AMI_7:funcnot 5 => AMI_7:func 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 AMI-Struct over a1,a2;
  let a4 be Element of the Instructions of a3;
  func Input A4 -> Element of bool the carrier of a3 equals
    (Out_U_Inp a4) \ Out_\_Inp a4;
end;

:: AMI_7: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 AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
   Input b4 = (Out_U_Inp b4) \ Out_\_Inp b4;

:: AMI_7:th 10
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite with_non_trivial_ObjectKinds AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
   Out_\_Inp b3 c= Output b3;

:: AMI_7:th 11
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3 holds
   Output b4 c= Out_U_Inp b4;

:: AMI_7:th 13
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite with_non_trivial_ObjectKinds AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
   Out_\_Inp b3 = (Output b3) \ Input b3;

:: AMI_7:th 14
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite with_non_trivial_ObjectKinds AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
   Out_U_Inp b3 = (Output b3) \/ Input b3;

:: AMI_7:th 15
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being Element of the carrier of b3
      st ObjectKind b5 is trivial
   holds not b5 in Out_U_Inp b4;

:: AMI_7:th 16
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being Element of the carrier of b3
      st ObjectKind b5 is trivial
   holds not b5 in Input b4;

:: AMI_7:th 17
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being Element of the carrier of b3
      st ObjectKind b5 is trivial
   holds not b5 in Output b4;

:: AMI_7:th 18
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3 holds
      b4 is halting(b2, b1, b3)
   iff
      Output b4 is empty;

:: AMI_7:th 19
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite with_non_trivial_ObjectKinds AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
      st b3 is halting(NAT, b1, b2)
   holds Out_\_Inp b3 is empty;

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

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

:: AMI_7:funcreg 5
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 AMI-Struct over a1,a2;
  let a4 be halting Element of the Instructions of a3;
  cluster Input a4 -> empty;
end;

:: AMI_7:funcreg 6
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 AMI-Struct over a1,a2;
  let a4 be halting Element of the Instructions of a3;
  cluster Output a4 -> empty;
end;

:: AMI_7:funcreg 7
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 AMI-Struct over a1,a2;
  let a4 be halting Element of the Instructions of a3;
  cluster Out_U_Inp a4 -> empty;
end;

:: AMI_7:exreg 3
registration
  let a1 be with_non-empty_elements set;
  cluster non empty stored-program halting IC-Ins-separated definite with_non_trivial_ObjectKinds AMI-Struct over NAT,a1;
end;

:: AMI_7:funcreg 8
registration
  let a1 be with_non-empty_elements set;
  let a2 be non empty stored-program halting IC-Ins-separated definite with_non_trivial_ObjectKinds AMI-Struct over NAT,a1;
  let a3 be halting Element of the Instructions of a2;
  cluster Out_\_Inp a3 -> empty;
end;

:: AMI_7:exreg 4
registration
  let a1 be with_non-empty_elements set;
  cluster non empty stored-program IC-Ins-separated steady-programmed definite with_non_trivial_Instructions AMI-Struct over NAT,a1;
end;

:: AMI_7:th 22
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated steady-programmed definite with_non_trivial_Instructions AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2
for b4 being Element of the Instructions of b2 holds
   not b3 in Out_\_Inp b4;

:: AMI_7:th 23
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 b3 is sequential(b1, b2)
   holds not IC b2 in Out_\_Inp b3;

:: AMI_7:th 24
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
      st ex b5 being Element of product the Object-Kind of b3 st
           (Exec(b4,b5)) . IC b3 <> IC b5
   holds IC b3 in Output b4;

:: AMI_7:exreg 5
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;

:: AMI_7:th 25
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 b3 is sequential(b1, b2)
   holds IC b2 in Output b3;

:: AMI_7:th 26
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
      st ex b5 being Element of product the Object-Kind of b3 st
           (Exec(b4,b5)) . IC b3 <> IC b5
   holds IC b3 in Out_U_Inp b4;

:: AMI_7:th 27
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 b3 is sequential(b1, b2)
   holds IC b2 in Out_U_Inp b3;

:: AMI_7:th 28
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b2,b1
for b4 being Instruction-Location of b3
for b5 being Element of the Instructions of b3
      st for b6 being Element of product the Object-Kind of b3
        for b7 being finite programmed Element of sproduct the Object-Kind of b3 holds
           Exec(b5,b6 +* b7) = (Exec(b5,b6)) +* b7
   holds not b4 in Out_U_Inp b5;

:: AMI_7:th 29
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program IC-Ins-separated definite standard-ins AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being Element of the carrier of b3
      st b4 is jump-only(b2, b1, b3) & b5 in Output b4
   holds b5 = IC b3;