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;