Article AMISTD_1, MML version 4.99.1005
:: AMISTD_1:th 11
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being non empty stored-program definite AMI-Struct over b2,b1
for b4 being Element of the Instructions of b3
for b5 being Element of product the Object-Kind of b3 holds
b5 +* (b2 --> b4) is Element of product the Object-Kind of b3;
:: AMISTD_1:condreg 1
registration
let a1, a2 be set;
let a3 be AMI-Struct over a1,a2;
cluster empty finite -> programmed (Element of sproduct the Object-Kind of a3);
end;
:: AMISTD_1:exreg 1
registration
let a1, a2 be set;
let a3 be AMI-Struct over a1,a2;
cluster Relation-like Function-like empty finite Element of sproduct the Object-Kind of a3;
end;
:: AMISTD_1:exreg 2
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 AMI-Struct over a1,a2;
cluster Relation-like Function-like non empty finite trivial programmed Element of sproduct the Object-Kind of a3;
end;
:: AMISTD_1:funcreg 1
registration
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be stored-program AMI-Struct over a1,a2;
let a4 be Element of the Instructions of a3;
let a5 be Element of product the Object-Kind of a3;
cluster ((the Execution of a3) . a4) . a5 -> Relation-like Function-like;
end;
:: AMISTD_1:exreg 3
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 steady-programmed definite AMI-Struct over a1,a2;
cluster Relation-like Function-like non empty finite trivial autonomic programmed Element of sproduct the Object-Kind of a3;
end;
:: AMISTD_1:th 12
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 Instruction-Location of b3
for b5 being Element of the Instructions of b3 holds
b4 .--> b5 is autonomic(b2, b1, b3);
:: AMISTD_1:th 13
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 holds
b3 is programmable(b2, b1);
:: AMISTD_1:condreg 2
registration
let a1 be non empty set;
let a2 be with_non-empty_elements set;
cluster non empty stored-program IC-Ins-separated steady-programmed definite -> programmable (AMI-Struct over a1,a2);
end;
:: AMISTD_1:modenot 1 => AMISTD_1:mode 1
definition
let a1, a2 be set;
let a3 be AMI-Struct over a1,a2;
mode IL-Subset of A3 -> Element of bool a1 means
TRUE;
end;
:: AMISTD_1:dfs 1
definiens
let a1, a2 be set;
let a3 be AMI-Struct over a1,a2;
let a4 be Element of bool a1;
To prove
a4 is IL-Subset of a3
it is sufficient to prove
thus TRUE;
:: AMISTD_1:def 1
theorem
for b1, b2 being set
for b3 being AMI-Struct over b1,b2
for b4 being Element of bool b1 holds
(b4 is IL-Subset of b3 implies TRUE) & b4 is IL-Subset of b3;
:: AMISTD_1:exreg 4
registration
let a1, a2 be set;
let a3 be AMI-Struct over a1,a2;
cluster empty IL-Subset of a3;
end;
:: AMISTD_1:exreg 5
registration
let a1 be non empty set;
let a2 be set;
let a3 be non empty AMI-Struct over a1,a2;
cluster non empty IL-Subset of a3;
end;
:: AMISTD_1:attrnot 1 => AMISTD_1:attr 1
definition
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program standard-ins AMI-Struct over a1,a2;
let a4 be Element of InsCodes a3;
attr a4 is jump-only means
for b1 being Element of product the Object-Kind of a3
for b2 being Element of the carrier of a3
for b3 being Element of the Instructions of a3
st InsCode b3 = a4 & b2 <> IC a3
holds (Exec(b3,b1)) . b2 = b1 . b2;
end;
:: AMISTD_1:dfs 2
definiens
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program standard-ins AMI-Struct over a1,a2;
let a4 be Element of InsCodes a3;
To prove
a4 is jump-only
it is sufficient to prove
thus for b1 being Element of product the Object-Kind of a3
for b2 being Element of the carrier of a3
for b3 being Element of the Instructions of a3
st InsCode b3 = a4 & b2 <> IC a3
holds (Exec(b3,b1)) . b2 = b1 . b2;
:: AMISTD_1:def 3
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program standard-ins AMI-Struct over b1,b2
for b4 being Element of InsCodes b3 holds
b4 is jump-only(b1, b2, b3)
iff
for b5 being Element of product the Object-Kind of b3
for b6 being Element of the carrier of b3
for b7 being Element of the Instructions of b3
st InsCode b7 = b4 & b6 <> IC b3
holds (Exec(b7,b5)) . b6 = b5 . b6;
:: AMISTD_1:attrnot 2 => AMISTD_1:attr 2
definition
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program standard-ins AMI-Struct over a1,a2;
let a4 be Element of the Instructions of a3;
attr a4 is jump-only means
InsCode a4 is jump-only(a1, a2, a3);
end;
:: AMISTD_1:dfs 3
definiens
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program standard-ins AMI-Struct over a1,a2;
let a4 be Element of the Instructions of a3;
To prove
a4 is jump-only
it is sufficient to prove
thus InsCode a4 is jump-only(a1, a2, a3);
:: AMISTD_1:def 4
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program standard-ins AMI-Struct over b1,b2
for b4 being Element of the Instructions of b3 holds
b4 is jump-only(b1, b2, b3)
iff
InsCode b4 is jump-only(b1, b2, b3);
:: AMISTD_1:funcnot 1 => AMISTD_1: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 Instruction-Location of a3;
let a5 be Element of the Instructions of a3;
func NIC(A5,A4) -> IL-Subset of a3 equals
{IC Following b1 where b1 is Element of product the Object-Kind of a3: IC b1 = a4 & b1 . a4 = a5};
end;
:: AMISTD_1: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 Instruction-Location of b3
for b5 being Element of the Instructions of b3 holds
NIC(b5,b4) = {IC Following b6 where b6 is Element of product the Object-Kind of b3: IC b6 = b4 & b6 . b4 = b5};
:: AMISTD_1:funcreg 2
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 realistic AMI-Struct over a1,a2;
let a4 be Element of the Instructions of a3;
let a5 be Instruction-Location of a3;
cluster NIC(a4,a5) -> non empty;
end;
:: AMISTD_1:funcnot 2 => AMISTD_1:func 2
definition
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
let a4 be Element of the Instructions of a3;
func JUMP A4 -> Element of bool a1 equals
meet {NIC(a4,b1) where b1 is Instruction-Location of a3: TRUE};
end;
:: AMISTD_1: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
JUMP b4 = meet {NIC(b4,b5) where b5 is Instruction-Location of b3: TRUE};
:: AMISTD_1:funcnot 3 => AMISTD_1: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 Instruction-Location of a3;
func SUCC A4 -> Element of bool a1 equals
union {(NIC(b1,a4)) \ JUMP b1 where b1 is Element of the Instructions of a3: TRUE};
end;
:: AMISTD_1:def 7
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being Instruction-Location of b3 holds
SUCC b4 = union {(NIC(b5,b4)) \ JUMP b5 where b5 is Element of the Instructions of b3: TRUE};
:: AMISTD_1:th 14
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 b2 is not trivial &
(for b5 being Instruction-Location of b3 holds
NIC(b4,b5) = {b5})
holds JUMP b4 is empty;
:: AMISTD_1: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 realistic AMI-Struct over b2,b1
for b4 being Instruction-Location of b3
for b5 being Element of the Instructions of b3
st b5 is halting(b2, b1, b3)
holds NIC(b5,b4) = {b4};
:: AMISTD_1:prednot 1 => AMISTD_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 IC-Ins-separated definite AMI-Struct over a1,a2;
let a4, a5 be Instruction-Location of a3;
pred A4 <= A5 means
ex b1 being non empty IL-FinSequence of a3 st
b1 /. 1 = a4 &
b1 /. len b1 = a5 &
(for b2 being Element of NAT
st 1 <= b2 & b2 < len b1
holds b1 /. (b2 + 1) in SUCC (b1 /. b2));
reflexivity;
:: for a1 being non empty set
:: for a2 being with_non-empty_elements set
:: for a3 being non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2
:: for a4 being Instruction-Location of a3 holds
:: a4 <= a4;
end;
:: AMISTD_1:dfs 7
definiens
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
let a4, a5 be Instruction-Location of a3;
To prove
a4 <= a5
it is sufficient to prove
thus ex b1 being non empty IL-FinSequence of a3 st
b1 /. 1 = a4 &
b1 /. len b1 = a5 &
(for b2 being Element of NAT
st 1 <= b2 & b2 < len b1
holds b1 /. (b2 + 1) in SUCC (b1 /. b2));
:: AMISTD_1:def 8
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2
for b4, b5 being Instruction-Location of b3 holds
b4 <= b5
iff
ex b6 being non empty IL-FinSequence of b3 st
b6 /. 1 = b4 &
b6 /. len b6 = b5 &
(for b7 being Element of NAT
st 1 <= b7 & b7 < len b6
holds b6 /. (b7 + 1) in SUCC (b6 /. b7));
:: AMISTD_1: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, b5, b6 being Instruction-Location of b3
st b4 <= b5 & b5 <= b6
holds b4 <= b6;
:: AMISTD_1:attrnot 3 => AMISTD_1:attr 3
definition
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
attr a3 is InsLoc-antisymmetric means
for b1, b2 being Instruction-Location of a3
st b1 <= b2 & b2 <= b1
holds b1 = b2;
end;
:: AMISTD_1:dfs 8
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 InsLoc-antisymmetric
it is sufficient to prove
thus for b1, b2 being Instruction-Location of a3
st b1 <= b2 & b2 <= b1
holds b1 = b2;
:: AMISTD_1:def 9
theorem
for b1 being non empty set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite AMI-Struct over b1,b2 holds
b3 is InsLoc-antisymmetric(b1, b2)
iff
for b4, b5 being Instruction-Location of b3
st b4 <= b5 & b5 <= b4
holds b4 = b5;
:: AMISTD_1:attrnot 4 => AMISTD_1:attr 4
definition
let a1 be non empty set;
let a2 be with_non-empty_elements set;
let a3 be non empty stored-program IC-Ins-separated definite AMI-Struct over a1,a2;
attr a3 is standard means
ex b1 being IL-Function of NAT,a3 st
b1 is bijective(NAT, a1) &
(for b2, b3 being Element of NAT holds
b2 <= b3
iff
b1 . b2 <= b1 . b3);
end;
:: AMISTD_1:dfs 9
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 standard
it is sufficient to prove
thus ex b1 being IL-Function of NAT,a3 st
b1 is bijective(NAT, a1) &
(for b2, b3 being Element of NAT holds
b2 <= b3
iff
b1 . b2 <= b1 . b3);
:: AMISTD_1:def 10
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 standard(b1, b2)
iff
ex b4 being IL-Function of NAT,b3 st
b4 is bijective(NAT, b1) &
(for b5, b6 being Element of NAT holds
b5 <= b6
iff
b4 . b5 <= b4 . b6);
:: AMISTD_1: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, b5 being IL-Function of NAT,b3
st b4 is bijective(NAT, b2) &
(for b6, b7 being Element of NAT holds
b6 <= b7
iff
b4 . b6 <= b4 . b7) &
b5 is bijective(NAT, b2) &
(for b6, b7 being Element of NAT holds
b6 <= b7
iff
b5 . b6 <= b5 . b7)
holds b4 = b5;
:: AMISTD_1: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 IL-Function of NAT,b3
st b4 is bijective(NAT, b2)
holds for b5, b6 being Element of NAT holds
b5 <= b6
iff
b4 . b5 <= b4 . b6
iff
for b5 being Element of NAT holds
b4 . (b5 + 1) in SUCC (b4 . b5) &
(for b6 being Element of NAT
st b4 . b6 in SUCC (b4 . b5)
holds b5 <= b6);
:: AMISTD_1:th 19
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 holds
b3 is standard(b2, b1)
iff
ex b4 being IL-Function of NAT,b3 st
b4 is bijective(NAT, b2) &
(for b5 being Element of NAT holds
b4 . (b5 + 1) in SUCC (b4 . b5) &
(for b6 being Element of NAT
st b4 . b6 in SUCC (b4 . b5)
holds b5 <= b6));
:: AMISTD_1:funcnot 4 => AMISTD_1:func 4
definition
let a1 be with_non-empty_elements set;
func STC A1 -> strict AMI-Struct over NAT,a1 means
the carrier of it = NAT \/ {NAT} &
the Instruction-Counter of it = NAT &
the Instructions of it = {[0,0],[1,0]} &
the Object-Kind of it = (NAT --> {[1,0],[0,0]}) +* (NAT .--> NAT) &
(ex b1 being Function-like quasi_total Relation of product the Object-Kind of it,product the Object-Kind of it st
(for b2 being Element of product the Object-Kind of it holds
b1 . b2 = b2 +* (NAT .--> succ (b2 . NAT))) &
the Execution of it = ([1,0] .--> b1) +* ([0,0] .--> id product the Object-Kind of it));
end;
:: AMISTD_1:def 11
theorem
for b1 being with_non-empty_elements set
for b2 being strict AMI-Struct over NAT,b1 holds
b2 = STC b1
iff
the carrier of b2 = NAT \/ {NAT} &
the Instruction-Counter of b2 = NAT &
the Instructions of b2 = {[0,0],[1,0]} &
the Object-Kind of b2 = (NAT --> {[1,0],[0,0]}) +* (NAT .--> NAT) &
(ex b3 being Function-like quasi_total Relation of product the Object-Kind of b2,product the Object-Kind of b2 st
(for b4 being Element of product the Object-Kind of b2 holds
b3 . b4 = b4 +* (NAT .--> succ (b4 . NAT))) &
the Execution of b2 = ([1,0] .--> b3) +* ([0,0] .--> id product the Object-Kind of b2));
:: AMISTD_1:funcreg 3
registration
let a1 be with_non-empty_elements set;
cluster STC a1 -> infinite strict;
end;
:: AMISTD_1:funcreg 4
registration
let a1 be with_non-empty_elements set;
cluster STC a1 -> non empty strict stored-program standard-ins;
end;
:: AMISTD_1:funcreg 5
registration
let a1 be with_non-empty_elements set;
cluster STC a1 -> strict IC-Ins-separated steady-programmed definite realistic;
end;
:: AMISTD_1:th 20
theorem
for b1 being with_non-empty_elements set
for b2 being Element of the Instructions of STC b1
st InsCode b2 = 0
holds b2 is halting(NAT, b1, STC b1);
:: AMISTD_1:th 21
theorem
for b1 being with_non-empty_elements set
for b2 being Element of the Instructions of STC b1
st InsCode b2 = 1
holds b2 is halting(not NAT, b1, STC b1);
:: AMISTD_1:th 22
theorem
for b1 being with_non-empty_elements set
for b2 being Element of the Instructions of STC b1
st InsCode b2 <> 1
holds InsCode b2 = 0;
:: AMISTD_1:th 23
theorem
for b1 being with_non-empty_elements set
for b2 being Element of the Instructions of STC b1 holds
b2 is jump-only(NAT, b1, STC b1);
:: AMISTD_1:th 24
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being Instruction-Location of STC b2
st b3 = b1
holds SUCC b3 = {b1,b1 + 1};
:: AMISTD_1:funcreg 6
registration
let a1 be with_non-empty_elements set;
cluster STC a1 -> strict standard;
end;
:: AMISTD_1:funcreg 7
registration
let a1 be with_non-empty_elements set;
cluster STC a1 -> strict halting;
end;
:: AMISTD_1:exreg 6
registration
let a1 be with_non-empty_elements set;
cluster non empty stored-program halting IC-Ins-separated steady-programmed definite realistic programmable standard-ins standard AMI-Struct over NAT,a1;
end;
:: AMISTD_1:funcnot 5 => AMISTD_1:func 5
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be natural set;
func il.(A2,A3) -> Instruction-Location of a2 means
ex b1 being IL-Function of NAT,a2 st
b1 is bijective(NAT, NAT) &
(for b2, b3 being Element of NAT holds
b2 <= b3
iff
b1 . b2 <= b1 . b3) &
it = b1 . a3;
end;
:: AMISTD_1:def 12
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 natural set
for b4 being Instruction-Location of b2 holds
b4 = il.(b2,b3)
iff
ex b5 being IL-Function of NAT,b2 st
b5 is bijective(NAT, NAT) &
(for b6, b7 being Element of NAT holds
b6 <= b7
iff
b5 . b6 <= b5 . b7) &
b4 = b5 . b3;
:: AMISTD_1: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, b4 being natural set
st il.(b2,b3) = il.(b2,b4)
holds b3 = b4;
:: AMISTD_1:th 26
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 Instruction-Location of b2 holds
ex b4 being natural set st
b3 = il.(b2,b4);
:: AMISTD_1:funcnot 6 => AMISTD_1:func 6
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be Instruction-Location of a2;
func locnum A3 -> natural set means
il.(a2,it) = a3;
end;
:: AMISTD_1:def 13
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2
for b4 being natural set holds
b4 = locnum b3
iff
il.(b2,b4) = b3;
:: AMISTD_1:funcnot 7 => AMISTD_1:func 7
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be Instruction-Location of a2;
redefine func locnum a3 -> Element of NAT;
end;
:: AMISTD_1: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, b4 being Instruction-Location of b2
st locnum b3 = locnum b4
holds b3 = b4;
:: AMISTD_1:th 28
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, b4 being natural set holds
il.(b2,b3) <= il.(b2,b4)
iff
b3 <= b4;
:: AMISTD_1:th 29
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, b4 being Instruction-Location of b2 holds
locnum b3 <= locnum b4
iff
b3 <= b4;
:: AMISTD_1:th 30
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 holds
b2 is InsLoc-antisymmetric(NAT, b1);
:: AMISTD_1:condreg 3
registration
let a1 be with_non-empty_elements set;
cluster non empty stored-program IC-Ins-separated definite standard -> InsLoc-antisymmetric (AMI-Struct over NAT,a1);
end;
:: AMISTD_1:funcnot 8 => AMISTD_1:func 8
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be Instruction-Location of a2;
let a4 be natural set;
func A3 + A4 -> Instruction-Location of a2 equals
il.(a2,(locnum a3) + a4);
end;
:: AMISTD_1:def 14
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2
for b4 being natural set holds
b3 + b4 = il.(b2,(locnum b3) + b4);
:: AMISTD_1:th 31
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 Instruction-Location of b2 holds
b3 + 0 = b3;
:: AMISTD_1:th 32
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b2
for b4, b5 being Instruction-Location of b3
st b4 + b1 = b5 + b1
holds b4 = b5;
:: AMISTD_1:th 33
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b2
for b4 being Instruction-Location of b3 holds
(locnum b4) + b1 = locnum (b4 + b1);
:: AMISTD_1:funcnot 9 => AMISTD_1:func 9
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be Instruction-Location of a2;
func NextLoc A3 -> Instruction-Location of a2 equals
a3 + 1;
end;
:: AMISTD_1:def 15
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2 holds
NextLoc b3 = b3 + 1;
:: AMISTD_1:th 34
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 Instruction-Location of b2 holds
NextLoc b3 = il.(b2,(locnum b3) + 1);
:: AMISTD_1:th 35
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 Instruction-Location of b2 holds
b3 <> NextLoc b3;
:: AMISTD_1:th 36
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, b4 being Instruction-Location of b2
st NextLoc b3 = NextLoc b4
holds b3 = b4;
:: AMISTD_1:th 37
theorem
for b1 being natural set
for b2 being with_non-empty_elements set holds
il.(STC b2,b1) = b1;
:: AMISTD_1:th 38
theorem
for b1 being with_non-empty_elements set
for b2 being Element of the Instructions of STC b1
for b3 being Element of product the Object-Kind of STC b1
st InsCode b2 = 1
holds (Exec(b2,b3)) . IC STC b1 = NextLoc IC b3;
:: AMISTD_1:th 39
theorem
for b1 being with_non-empty_elements set
for b2 being Instruction-Location of STC b1
for b3 being Element of the Instructions of STC b1
st InsCode b3 = 1
holds NIC(b3,b2) = {NextLoc b2};
:: AMISTD_1:th 40
theorem
for b1 being with_non-empty_elements set
for b2 being Instruction-Location of STC b1 holds
SUCC b2 = {b2,NextLoc b2};
:: AMISTD_1:attrnot 5 => AMISTD_1:attr 5
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be Element of the Instructions of a2;
attr a3 is sequential means
for b1 being Element of product the Object-Kind of a2 holds
(Exec(a3,b1)) . IC a2 = NextLoc IC b1;
end;
:: AMISTD_1:dfs 15
definiens
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be Element of the Instructions of a2;
To prove
a3 is sequential
it is sufficient to prove
thus for b1 being Element of product the Object-Kind of a2 holds
(Exec(a3,b1)) . IC a2 = NextLoc IC b1;
:: AMISTD_1:def 16
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
b3 is sequential(b1, b2)
iff
for b4 being Element of product the Object-Kind of b2 holds
(Exec(b3,b4)) . IC b2 = NextLoc IC b4;
:: AMISTD_1:th 41
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite realistic standard AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2
for b4 being Element of the Instructions of b2
st b4 is sequential(b1, b2)
holds NIC(b4,b3) = {NextLoc b3};
:: AMISTD_1:th 42
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite realistic standard AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2
st b3 is sequential(b1, b2)
holds b3 is halting(not NAT, b1, b2);
:: AMISTD_1:condreg 4
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite realistic standard AMI-Struct over NAT,a1;
cluster sequential -> non halting (Element of the Instructions of a2);
end;
:: AMISTD_1:condreg 5
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite realistic standard AMI-Struct over NAT,a1;
cluster halting -> non sequential (Element of the Instructions of a2);
end;
:: AMISTD_1:th 43
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 JUMP b3 is not empty
holds b3 is not sequential(b1, b2);
:: AMISTD_1:attrnot 6 => AMISTD_1:attr 6
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;
attr a4 is closed means
for b1 being Instruction-Location of a3
st b1 in proj1 a4
holds NIC(pi(a4,b1),b1) c= proj1 a4;
end;
:: AMISTD_1:dfs 16
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 programmed Element of sproduct the Object-Kind of a3;
To prove
a4 is closed
it is sufficient to prove
thus for b1 being Instruction-Location of a3
st b1 in proj1 a4
holds NIC(pi(a4,b1),b1) c= proj1 a4;
:: AMISTD_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 finite programmed Element of sproduct the Object-Kind of b3 holds
b4 is closed(b1, b2, b3)
iff
for b5 being Instruction-Location of b3
st b5 in proj1 b4
holds NIC(pi(b4,b5),b5) c= proj1 b4;
:: AMISTD_1:attrnot 7 => AMISTD_1:attr 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 definite AMI-Struct over a1,a2;
let a4 be finite programmed Element of sproduct the Object-Kind of a3;
attr a4 is really-closed means
for b1 being Element of product the Object-Kind of a3
st a4 c= b1 & IC b1 in proj1 a4
for b2 being Element of NAT holds
IC Computation(b1,b2) in proj1 a4;
end;
:: AMISTD_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 IC-Ins-separated definite AMI-Struct over a1,a2;
let a4 be finite programmed Element of sproduct the Object-Kind of a3;
To prove
a4 is really-closed
it is sufficient to prove
thus for b1 being Element of product the Object-Kind of a3
st a4 c= b1 & IC b1 in proj1 a4
for b2 being Element of NAT holds
IC Computation(b1,b2) in proj1 a4;
:: AMISTD_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 finite programmed Element of sproduct the Object-Kind of b3 holds
b4 is really-closed(b1, b2, b3)
iff
for b5 being Element of product the Object-Kind of b3
st b4 c= b5 & IC b5 in proj1 b4
for b6 being Element of NAT holds
IC Computation(b5,b6) in proj1 b4;
:: AMISTD_1:attrnot 8 => AMISTD_1:attr 8
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be finite Element of sproduct the Object-Kind of a2;
attr a3 is para-closed means
for b1 being Element of product the Object-Kind of a2
st a3 c= b1 & IC b1 = il.(a2,0)
for b2 being Element of NAT holds
IC Computation(b1,b2) in proj1 a3;
end;
:: AMISTD_1:dfs 18
definiens
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be finite Element of sproduct the Object-Kind of a2;
To prove
a3 is para-closed
it is sufficient to prove
thus for b1 being Element of product the Object-Kind of a2
st a3 c= b1 & IC b1 = il.(a2,0)
for b2 being Element of NAT holds
IC Computation(b1,b2) in proj1 a3;
:: AMISTD_1:def 19
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being finite Element of sproduct the Object-Kind of b2 holds
b3 is para-closed(b1, b2)
iff
for b4 being Element of product the Object-Kind of b2
st b3 c= b4 & IC b4 = il.(b2,0)
for b5 being Element of NAT holds
IC Computation(b4,b5) in proj1 b3;
:: AMISTD_1:th 44
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 finite programmed Element of sproduct the Object-Kind of b2
st b3 is really-closed(NAT, b1, b2) & il.(b2,0) in proj1 b3
holds b3 is para-closed(b1, b2);
:: AMISTD_1:th 45
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 finite programmed Element of sproduct the Object-Kind of b3
st b4 is closed(b2, b1, b3)
holds b4 is really-closed(b2, b1, b3);
:: AMISTD_1:condreg 6
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 steady-programmed definite AMI-Struct over a1,a2;
cluster finite programmed closed -> really-closed (Element of sproduct the Object-Kind of a3);
end;
:: AMISTD_1:th 46
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite realistic standard AMI-Struct over NAT,b1 holds
(il.(b2,0)) .--> halt b2 is closed(NAT, b1, b2);
:: AMISTD_1:attrnot 9 => AMISTD_1:attr 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 finite Element of sproduct the Object-Kind of a3;
attr a4 is lower means
for b1 being Instruction-Location of a3
st b1 in proj1 a4
for b2 being Instruction-Location of a3
st b2 <= b1
holds b2 in proj1 a4;
end;
:: AMISTD_1:dfs 19
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 lower
it is sufficient to prove
thus for b1 being Instruction-Location of a3
st b1 in proj1 a4
for b2 being Instruction-Location of a3
st b2 <= b1
holds b2 in proj1 a4;
:: AMISTD_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 IC-Ins-separated definite AMI-Struct over b1,b2
for b4 being finite Element of sproduct the Object-Kind of b3 holds
b4 is lower(b1, b2, b3)
iff
for b5 being Instruction-Location of b3
st b5 in proj1 b4
for b6 being Instruction-Location of b3
st b6 <= b5
holds b6 in proj1 b4;
:: AMISTD_1:th 47
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 empty finite Element of sproduct the Object-Kind of b3 holds
b4 is lower(b2, b1, b3);
:: AMISTD_1:condreg 7
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 AMI-Struct over a1,a2;
cluster empty finite -> lower (Element of sproduct the Object-Kind of a3);
end;
:: AMISTD_1:th 48
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Element of the Instructions of b2 holds
(il.(b2,0)) .--> b3 is lower(NAT, b1, b2);
:: AMISTD_1:exreg 7
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
cluster Relation-like Function-like non empty finite trivial programmed lower Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:th 49
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower Element of sproduct the Object-Kind of b2 holds
il.(b2,0) in proj1 b3;
:: AMISTD_1:th 50
theorem
for b1 being natural set
for b2 being with_non-empty_elements set
for b3 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b2
for b4 being finite programmed lower Element of sproduct the Object-Kind of b3 holds
b1 < card b4
iff
il.(b3,b1) in proj1 b4;
:: AMISTD_1:funcnot 10 => AMISTD_1:func 10
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
func LastLoc A3 -> Instruction-Location of a2 means
ex b1 being non empty finite natural-membered set st
b1 = {locnum b2 where b2 is Instruction-Location of a2: b2 in proj1 a3} &
it = il.(a2,max b1);
end;
:: AMISTD_1:def 21
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2
for b4 being Instruction-Location of b2 holds
b4 = LastLoc b3
iff
ex b5 being non empty finite natural-membered set st
b5 = {locnum b6 where b6 is Instruction-Location of b2: b6 in proj1 b3} &
b4 = il.(b2,max b5);
:: AMISTD_1:th 51
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
LastLoc b3 in proj1 b3;
:: AMISTD_1:th 52
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, b4 being non empty finite programmed Element of sproduct the Object-Kind of b2
st b3 c= b4
holds LastLoc b3 <= LastLoc b4;
:: AMISTD_1:th 53
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2
for b4 being Instruction-Location of b2
st b4 in proj1 b3
holds b4 <= LastLoc b3;
:: AMISTD_1:th 54
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower Element of sproduct the Object-Kind of b2
for b4 being non empty finite programmed Element of sproduct the Object-Kind of b2
st b3 c= b4 & LastLoc b3 = LastLoc b4
holds b3 = b4;
:: AMISTD_1:th 55
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed lower Element of sproduct the Object-Kind of b2 holds
LastLoc b3 = il.(b2,(card b3) -' 1);
:: AMISTD_1:condreg 8
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program IC-Ins-separated steady-programmed definite standard AMI-Struct over NAT,a1;
cluster non empty finite programmed really-closed lower -> para-closed (Element of sproduct the Object-Kind of a2);
end;
:: AMISTD_1:attrnot 10 => AMISTD_1:attr 10
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
attr a3 is halt-ending means
a3 . LastLoc a3 = halt a2;
end;
:: AMISTD_1:dfs 21
definiens
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
To prove
a3 is halt-ending
it is sufficient to prove
thus a3 . LastLoc a3 = halt a2;
:: AMISTD_1:def 22
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
b3 is halt-ending(b1, b2)
iff
b3 . LastLoc b3 = halt b2;
:: AMISTD_1:attrnot 11 => AMISTD_1:attr 11
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
attr a3 is unique-halt means
for b1 being Instruction-Location of a2
st a3 . b1 = halt a2 & b1 in proj1 a3
holds b1 = LastLoc a3;
end;
:: AMISTD_1:dfs 22
definiens
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
let a3 be non empty finite programmed Element of sproduct the Object-Kind of a2;
To prove
a3 is unique-halt
it is sufficient to prove
thus for b1 being Instruction-Location of a2
st a3 . b1 = halt a2 & b1 in proj1 a3
holds b1 = LastLoc a3;
:: AMISTD_1:def 23
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being non empty finite programmed Element of sproduct the Object-Kind of b2 holds
b3 is unique-halt(b1, b2)
iff
for b4 being Instruction-Location of b2
st b3 . b4 = halt b2 & b4 in proj1 b3
holds b4 = LastLoc b3;
:: AMISTD_1:exreg 8
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
cluster Relation-like Function-like non empty finite trivial programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:exreg 9
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite realistic standard AMI-Struct over NAT,a1;
cluster Relation-like Function-like non empty finite trivial programmed closed lower Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:exreg 10
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite realistic standard AMI-Struct over NAT,a1;
cluster Relation-like Function-like non empty finite trivial programmed closed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:exreg 11
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated steady-programmed definite realistic standard AMI-Struct over NAT,a1;
cluster Relation-like Function-like non empty finite trivial autonomic programmed closed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:modenot 2
definition
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite standard AMI-Struct over NAT,a1;
mode pre-Macro of a2 is non empty finite programmed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:exreg 12
registration
let a1 be with_non-empty_elements set;
let a2 be non empty stored-program halting IC-Ins-separated definite realistic standard AMI-Struct over NAT,a1;
cluster Relation-like Function-like non empty finite programmed closed lower halt-ending unique-halt Element of sproduct the Object-Kind of a2;
end;
:: AMISTD_1:th 56
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being Element of the Instructions of Trivial-AMI(b2,b1) holds
b3 is halting(b2, b1, Trivial-AMI(b2,b1));
:: AMISTD_1:th 57
theorem
for b1 being with_non-empty_elements set
for b2 being non empty set
for b3 being Element of the Instructions of Trivial-AMI(b2,b1) holds
InsCode b3 = 0;