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);