Article AMISTD_3, MML version 4.99.1005
:: AMISTD_3:funcreg 1
registration
let a1 be Relation-like empty set;
let a2 be set;
cluster a1 | a2 -> Relation-like empty;
end;
:: AMISTD_3:th 1
theorem
for b1, b2 being set
for b3 being Relation-like set
st proj1 b3 = {b1} & proj2 b3 = {b2}
holds b3 = b1 .--> b2;
:: AMISTD_3:th 2
theorem
for b1 being set holds
field {[b1,b1]} = {b1};
:: AMISTD_3:funcreg 2
registration
let a1 be infinite set;
let a2 be set;
cluster a1 --> a2 -> infinite;
end;
:: AMISTD_3:exreg 1
registration
cluster Relation-like Function-like infinite set;
end;
:: AMISTD_3:funcreg 3
registration
let a1 be Relation-like finite set;
cluster field a1 -> finite;
end;
:: AMISTD_3:funcreg 4
registration
let a1 be Relation-like infinite set;
cluster field a1 -> infinite;
end;
:: AMISTD_3:funcreg 5
registration
cluster RelIncl {} -> Relation-like empty;
end;
:: AMISTD_3:funcreg 6
registration
let a1 be non empty set;
cluster RelIncl a1 -> Relation-like non empty;
end;
:: AMISTD_3:th 5
theorem
for b1 being set holds
RelIncl {b1} = {[b1,b1]};
:: AMISTD_3:th 6
theorem
for b1 being set holds
RelIncl b1 c= [:b1,b1:];
:: AMISTD_3:funcreg 7
registration
let a1 be finite set;
cluster RelIncl a1 -> Relation-like finite;
end;
:: AMISTD_3:th 7
theorem
for b1 being set
st RelIncl b1 is finite
holds b1 is finite;
:: AMISTD_3:funcreg 8
registration
let a1 be infinite set;
cluster RelIncl a1 -> Relation-like infinite;
end;
:: AMISTD_3:th 8
theorem
for b1, b2 being Relation-like set
st b1,b2 are_isomorphic & b1 is well-ordering
holds b2 is well-ordering;
:: AMISTD_3:th 9
theorem
for b1, b2 being Relation-like set
st b1,b2 are_isomorphic & b1 is finite
holds b2 is finite;
:: AMISTD_3:th 10
theorem
for b1, b2 being set holds
b1 .--> b2 is_isomorphism_of {[b1,b1]},{[b2,b2]};
:: AMISTD_3:th 11
theorem
for b1, b2 being set holds
{[b1,b1]},{[b2,b2]} are_isomorphic;
:: AMISTD_3:funcreg 9
registration
cluster order_type_of {} -> empty ordinal;
end;
:: AMISTD_3:th 12
theorem
for b1 being ordinal set holds
order_type_of RelIncl b1 = b1;
:: AMISTD_3:th 13
theorem
for b1 being ordinal set
for b2 being finite set
st b2 c= b1
holds order_type_of RelIncl b2 = card b2;
:: AMISTD_3:th 14
theorem
for b1 being set
for b2 being ordinal set
st {b1} c= b2
holds order_type_of RelIncl {b1} = 1;
:: AMISTD_3:th 15
theorem
for b1 being set
for b2 being ordinal set
st {b1} c= b2
holds canonical_isomorphism_of(RelIncl order_type_of RelIncl {b1},RelIncl {b1}) = 0 .--> b1;
:: AMISTD_3:funcreg 10
registration
let a1 be ordinal set;
let a2 be Element of bool a1;
let a3 be set;
cluster (canonical_isomorphism_of(RelIncl order_type_of RelIncl a2,RelIncl a2)) . a3 -> ordinal;
end;
:: AMISTD_3:funcreg 11
registration
let a1 be natural-membered set;
let a2 be set;
cluster (canonical_isomorphism_of(RelIncl order_type_of RelIncl a1,RelIncl a1)) . a2 -> natural;
end;
:: AMISTD_3:th 16
theorem
for b1 being set
for b2, b3 being natural set
st b2 |-> b1 = b3 |-> b1
holds b2 = b3;
:: AMISTD_3:th 17
theorem
for b1 being natural set
for b2 being non empty Tree-like set
for b3 being Element of b2 holds
b3 | Seg b1 in b2;
:: AMISTD_3:th 18
theorem
for b1, b2 being non empty Tree-like set
st for b3 being Element of NAT holds
b1 -level b3 = b2 -level b3
holds b1 = b2;
:: AMISTD_3:funcnot 1 => AMISTD_3:func 1
definition
func TrivialInfiniteTree -> set equals
{b1 |-> 0 where b1 is Element of NAT: TRUE};
end;
:: AMISTD_3:def 1
theorem
TrivialInfiniteTree = {b1 |-> 0 where b1 is Element of NAT: TRUE};
:: AMISTD_3:funcreg 12
registration
cluster TrivialInfiniteTree -> non empty Tree-like;
end;
:: AMISTD_3:th 19
theorem
NAT,TrivialInfiniteTree are_equipotent;
:: AMISTD_3:funcreg 13
registration
cluster TrivialInfiniteTree -> infinite;
end;
:: AMISTD_3:th 20
theorem
for b1 being Element of NAT holds
TrivialInfiniteTree -level b1 = {b1 |-> 0};
:: AMISTD_3:funcnot 2 => AMISTD_3:func 2
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;
assume a3 is not empty & a3 is programmed(NAT, a1, a2);
func FirstLoc A3 -> Instruction-Location of a2 means
ex b1 being non empty Element of bool NAT st
b1 = {locnum b2 where b2 is Instruction-Location of a2: b2 in proj1 a3} &
it = il.(a2,min b1);
end;
:: AMISTD_3:def 2
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
st b3 is not empty & b3 is programmed(NAT, b1, b2)
for b4 being Instruction-Location of b2 holds
b4 = FirstLoc b3
iff
ex b5 being non empty Element of bool NAT st
b5 = {locnum b6 where b6 is Instruction-Location of b2: b6 in proj1 b3} &
b4 = il.(b2,min b5);
:: AMISTD_3:th 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 holds
FirstLoc b3 in proj1 b3;
:: AMISTD_3:th 22
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 FirstLoc b4 <= FirstLoc b3;
:: AMISTD_3:th 23
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2
for b4 being non empty finite programmed Element of sproduct the Object-Kind of b2
st b3 in proj1 b4
holds FirstLoc b4 <= b3;
:: AMISTD_3:th 24
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
FirstLoc b3 = il.(b2,0);
:: AMISTD_3:funcnot 3 => AMISTD_3:func 3
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 IL-Subset of a2;
func LocNums A3 -> Element of bool NAT equals
{locnum b1 where b1 is Instruction-Location of a2: b1 in a3};
end;
:: AMISTD_3:def 3
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 IL-Subset of b2 holds
LocNums b3 = {locnum b4 where b4 is Instruction-Location of b2: b4 in b3};
:: AMISTD_3:th 25
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being Instruction-Location of b2
for b4 being IL-Subset of b2 holds
locnum b3 in LocNums b4
iff
b3 in b4;
:: AMISTD_3:funcreg 14
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;
let a3 be empty IL-Subset of a2;
cluster LocNums a3 -> empty;
end;
:: AMISTD_3:funcreg 15
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;
let a3 be non empty IL-Subset of a2;
cluster LocNums a3 -> non empty;
end;
:: AMISTD_3:th 26
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 IL-Subset of b3
st b4 = {il.(b3,b1)}
holds LocNums b4 = {b1};
:: AMISTD_3:th 27
theorem
for b1 being with_non-empty_elements set
for b2 being non empty stored-program IC-Ins-separated definite standard AMI-Struct over NAT,b1
for b3 being IL-Subset of b2 holds
b3,LocNums b3 are_equipotent;
:: AMISTD_3: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 being IL-Subset of b2 holds
Card b3 c= order_type_of RelIncl LocNums b3;
:: AMISTD_3: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 being Instruction-Location of b2
for b4 being Element of the Instructions of b2
st b2 is realistic(NAT, b1) & b4 is halting(NAT, b1, b2)
holds LocNums NIC(b4,b3) = {locnum b3};
:: AMISTD_3: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
for b3 being Instruction-Location of b2
for b4 being Element of the Instructions of b2
st b2 is realistic(NAT, b1) & b4 is sequential(b1, b2)
holds LocNums NIC(b4,b3) = {locnum NextLoc b3};
:: AMISTD_3:funcnot 4 => AMISTD_3:func 4
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 IL-Subset of a2;
func LocSeq A3 -> T-Sequence of NAT means
proj1 it = Card a3 &
(for b1 being set
st b1 in Card a3
holds it . b1 = il.(a2,(canonical_isomorphism_of(RelIncl order_type_of RelIncl LocNums a3,RelIncl LocNums a3)) . b1));
end;
:: AMISTD_3:def 4
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 IL-Subset of b2
for b4 being T-Sequence of NAT holds
b4 = LocSeq b3
iff
proj1 b4 = Card b3 &
(for b5 being set
st b5 in Card b3
holds b4 . b5 = il.(b2,(canonical_isomorphism_of(RelIncl order_type_of RelIncl LocNums b3,RelIncl LocNums b3)) . b5));
:: AMISTD_3:th 31
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 IL-Subset of b3
st b4 = {il.(b3,b1)}
holds LocSeq b4 = 0 .--> il.(b3,b1);
:: AMISTD_3:funcreg 16
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;
let a3 be IL-Subset of a2;
cluster LocSeq a3 -> one-to-one;
end;
:: AMISTD_3:funcnot 5 => AMISTD_3: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 finite programmed Element of sproduct the Object-Kind of a2;
func ExecTree A3 -> IL-DecoratedTree of a2 means
it . {} = FirstLoc a3 &
(for b1 being Element of proj1 it holds
succ b1 = {b1 ^ <*b2*> where b2 is Element of NAT: b2 in Card NIC(pi(a3,it . b1),it . b1)} &
(for b2 being Element of NAT
st b2 in Card NIC(pi(a3,it . b1),it . b1)
holds it . (b1 ^ <*b2*>) = (LocSeq NIC(pi(a3,it . b1),it . b1)) . b2));
end;
:: AMISTD_3:def 5
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 programmed Element of sproduct the Object-Kind of b2
for b4 being IL-DecoratedTree of b2 holds
b4 = ExecTree b3
iff
b4 . {} = FirstLoc b3 &
(for b5 being Element of proj1 b4 holds
succ b5 = {b5 ^ <*b6*> where b6 is Element of NAT: b6 in Card NIC(pi(b3,b4 . b5),b4 . b5)} &
(for b6 being Element of NAT
st b6 in Card NIC(pi(b3,b4 . b5),b4 . b5)
holds b4 . (b5 ^ <*b6*>) = (LocSeq NIC(pi(b3,b4 . b5),b4 . b5)) . b6));
:: AMISTD_3:th 32
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
ExecTree Stop b2 = TrivialInfiniteTree --> il.(b2,0);