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;