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;