formal/mizar/amistd_1.miz

:: Standard Ordering of Instruction Locations
::  by Andrzej Trybulec , Piotr Rudnicki and Artur Korni{\l}owicz

environ

 vocabularies NUMBERS, XBOOLE_0, SUBSET_1, SETFAM_1, AMI_1, FSM_1, FUNCT_4,
      FUNCOP_1, RELAT_1, TARSKI, STRUCT_0, FUNCT_1, CARD_3, ZFMISC_1, CIRCUIT2,
      CAT_1, NAT_1, GLIB_000, XXREAL_0, PARTFUN1, FINSEQ_1, ARYTM_3, CARD_1,
      GOBOARD5, FUNCT_2, FINSEQ_4, ARYTM_1, FINSET_1, FRECHET, AMISTD_1,
      EXTPRO_1, COMPOS_1, AMISTD_2, SCMFSA6B, QUANTAL1, GOBRD13, MEMSTR_0,
      FUNCT_7;
 notations TARSKI, XBOOLE_0, ZFMISC_1, SUBSET_1, RELAT_1, SETFAM_1, ORDINAL1,
      CARD_1, XXREAL_0, NUMBERS, XCMPLX_0, NAT_1, MEMBERED, FUNCT_1, RELSET_1,
      PARTFUN1, XTUPLE_0, MCART_1, VALUED_1, DOMAIN_1, CARD_3, FINSEQ_1,
      FINSEQ_4, FUNCOP_1, FINSET_1, FUNCT_4, FUNCT_7, AFINSQ_1, PBOOLE,
      MEASURE6, STRUCT_0, GRAPH_2, NAT_D, XXREAL_2, MEMSTR_0, COMPOS_0,
      COMPOS_1, EXTPRO_1, FUNCT_2;
 constructors WELLORD2, REAL_1, FINSEQ_4, REALSET1, NAT_D, XXREAL_2, COMPOS_1,
      EXTPRO_1, RELSET_1, PRE_POLY, GRAPH_2, AFINSQ_1, MCART_1, FUNCT_7,
      PBOOLE, XXREAL_1, FUNCT_4, MEASURE6, MEMSTR_0, XTUPLE_0;
 registrations SETFAM_1, RELAT_1, FUNCT_1, FUNCT_2, FUNCOP_1, FINSET_1,
      XREAL_0, NAT_1, MEMBERED, FINSEQ_1, CARD_3, FUNCT_7, STRUCT_0, CARD_1,
      RELSET_1, FUNCT_4, AFINSQ_1, COMPOS_1, EXTPRO_1, PRE_POLY, MEMSTR_0,
      MEASURE6, COMPOS_0, XTUPLE_0, INT_1;
 requirements NUMERALS, BOOLE, REAL, SUBSET, ARITHM;
 definitions TARSKI, EXTPRO_1, XBOOLE_0, MEMSTR_0, FUNCT_1, COMPOS_0;
 equalities STRUCT_0, COMPOS_1, EXTPRO_1, XBOOLE_0, MEMSTR_0, FUNCOP_1,
      AFINSQ_1, COMPOS_0, ORDINAL1;
 expansions XBOOLE_0, MEMSTR_0;
 theorems TARSKI, FINSEQ_4, FINSEQ_1, NAT_1, FUNCT_4, FUNCT_1, FUNCT_2,
      ENUMSET1, ZFMISC_1, FUNCOP_1, CARD_3, ORDINAL1, FINSEQ_3, INT_1,
      SETFAM_1, REVROT_1, EXTPRO_1, RELSET_1, XBOOLE_0, XBOOLE_1, XREAL_1,
      XXREAL_0, COMPOS_1, FUNCT_7, PARTFUN1, XREAL_0, NAT_D, PBOOLE, MEMSTR_0,
      GRFUNC_1, PARTFUN2, MEASURE6, RELAT_1, FINSEQ_6;
 schemes NAT_1, FINSEQ_2, FUNCT_2;

begin :: AMI-Struct

reserve x for set,
  D for non empty set,
  k, n for Nat,
  z for Nat;

reserve
  N for with_zero set,
  S for IC-Ins-separated non empty
          with_non-empty_values AMI-Struct over N,
  i for Element of the InstructionsF of S,
  l, l1, l2, l3 for Nat,
  s for State of S;

registration
  let N be with_zero set, S be
   with_non-empty_values AMI-Struct over N,
      i be Element of the InstructionsF of S, s be State of S;
  cluster ((the Execution of S).i).s -> Function-like Relation-like;
  coherence
  proof
    reconsider A =(the Execution of S).i
     as Function of product the_Values_of S, product the_Values_of S
             by FUNCT_2:66;
  reconsider s as Element of product the_Values_of S
   by CARD_3:107;
    A.s in product the_Values_of S;
    hence thesis;
  end;
end;

registration let N;
 cluster non empty with_non-empty_values for AMI-Struct over N;
   existence
   proof
    take Trivial-AMI N;
    thus thesis;
   end;
end;

definition
  let N be with_zero set;
  let S be non empty with_non-empty_values AMI-Struct over N;
  let T be InsType of the InstructionsF of S;
  attr T is jump-only means
  for s being State of S, o being Object of S, I
  being Instruction of S st InsCode I = T &
   o in Data-Locations S
  holds Exec(I, s).o = s.o;
end;

definition
  let N be with_zero set;
  let S be non empty with_non-empty_values AMI-Struct over N;
  let I be Instruction of S;
  attr I is jump-only means
  InsCode I is jump-only;
end;

reserve ss for Element of product the_Values_of S;

definition
  let N,S; let l be Nat;
  let i be Element of the InstructionsF of S;
  func NIC(i,l) -> Subset of NAT equals
   { IC Exec(i,ss) : IC ss = l };
  coherence
  proof
    { IC Exec(i,ss) : IC ss = l } c= NAT
    proof
      let e be object;
      assume e in { IC Exec(i,ss) : IC ss = l };
      then ex ss st e = IC Exec(i,ss) & IC ss = l;
      hence thesis;
    end;
    hence thesis;
  end;
end;

Lm1:
 now
  let N;
  let S be IC-Ins-separated
  non empty with_non-empty_values AMI-Struct over N,
  i be Element of the InstructionsF of S, l be
  Nat, s be State of S,
  P be Instruction-Sequence of S;
  reconsider t = s+*(IC S,l) as Element of product the_Values_of S
   by CARD_3:107;
    l in NAT by ORDINAL1:def 12;
    then
A1: l in dom P by PARTFUN1:def 2;
    IC S in dom s by MEMSTR_0:2;
    then
A2: IC t = l by FUNCT_7:31;
   then CurInstr(P+*(l,i),t) = (P+*(l,i)).l by PBOOLE:143
       .= i by A1,FUNCT_7:31;
  hence IC Following(P+*(l,i),s+*(IC S,l)) in NIC(i,l) by A2;
end;

registration
  let N be with_zero set,
  S be IC-Ins-separated
   non empty with_non-empty_values AMI-Struct over N, i be Element of the
  InstructionsF of S, l be Nat;
  cluster NIC(i,l) -> non empty;
  coherence by Lm1;
end;

definition
  let N,S,i;
  func JUMP i -> Subset of NAT equals
  meet the set of all  NIC(i,l) ;
  coherence
  proof
    set X = the set of all  NIC(i,l) ;
    X c= bool NAT
    proof
      let x be object;
      assume x in X;
      then ex l st x = NIC(i,l);
      hence thesis;
    end;
    then reconsider X as Subset-Family of NAT;
    meet X c= NAT;
    hence thesis;
  end;
end;

definition
  let N,S; let l be Nat;
  func SUCC(l,S) -> Subset of NAT equals
  union the set of all  NIC(i,l) \ JUMP i ;
  coherence
  proof
    set X = the set of all  NIC(i,l) \ JUMP i ;
    X c= bool NAT
    proof
      let x be object;
      assume x in X;
      then ex i st x = NIC(i,l) \ JUMP i;
      hence thesis;
    end;
    then reconsider X as Subset-Family of NAT;
    union X c= NAT;
    hence thesis;
  end;
end;



theorem Th1:
  for i being Element of the InstructionsF of S
   st for l being Nat holds NIC(i,l)={l}
  holds JUMP i is empty
proof
  let i be Element of the InstructionsF of S;
  set p = 0, q = 1;
  set X = the set of all  NIC(i, l) where l is Nat;
  reconsider p,q as Nat;
  assume
A1: for l being Nat holds NIC(i,l)={l};
  assume not thesis;
  then consider x being object such that
A2: x in meet X;
  NIC(i,p) = {p} by A1;
  then {p} in X;
  then
A3: x in {p} by A2,SETFAM_1:def 1;
  NIC(i,q) = {q} by A1;
  then {q} in X;
  then x in {q} by A2,SETFAM_1:def 1;
  hence contradiction by A3,TARSKI:def 1;
end;

theorem Th2:
  for S being IC-Ins-separated non empty with_non-empty_values
         AMI-Struct over N,
      il being Nat, i being Instruction of S st i is halting
  holds NIC(i,il) = {il}
proof
  let S be IC-Ins-separated
   non empty with_non-empty_values AMI-Struct over N,
  il be Nat, i be Instruction of S
  such that
A1: for s being State of S holds Exec(i,s) = s;
  hereby
    let n be object;
    assume n in NIC(i,il);
    then ex s being Element of product the_Values_of S
    st n = IC Exec(i,s) & IC s = il;
    then n = il by A1;
    hence n in {il} by TARSKI:def 1;
  end;
    set s = the  State of S,
        P = the Instruction-Sequence of S;
  let n be object;
  assume
 n in {il};
  then
A2: n = il by TARSKI:def 1;
    il in NAT by ORDINAL1:def 12;
    then
A3: il in dom P by PARTFUN1:def 2;
A4: IC S in dom s by MEMSTR_0:2;
   then IC(s+*(IC S,il)) = il by FUNCT_7:31;
   then CurInstr(P+*(il,i),s+*(IC S,il))
         = (P+*(il,i)).il by PBOOLE:143
        .= i by A3,FUNCT_7:31;
   then IC Following(P+*(il,i),s+*(IC S,il))
      = IC(s+*(IC S,il)) by A1
     .= n by A2,A4,FUNCT_7:31;
  hence n in NIC(i,il) by Lm1;
end;

begin :: Ordering of Instruction Locations

definition

  let N, S;
  attr S is standard means

  for m, n being Nat holds m <= n iff
   ex f being non empty FinSequence of NAT st f/.1 = m & f/.len f = n &
    for n st 1 <= n & n < len f holds f/.(n+1) in SUCC(f/.n,S);
end;

Lm2:
  ex f being non empty FinSequence of NAT st f/.1
= k & f/.len f = k & for n st 1 <= n & n < len f
 holds f/.(n+1) in SUCC(f/.n,S)
  proof
     reconsider l=k as Element of NAT by ORDINAL1:def 12;
     reconsider f = <*l*> as non empty FinSequence of NAT;
    take f;
    thus f/.1 = k by FINSEQ_4:16;
    hence thesis by FINSEQ_1:39;
  end;



theorem Th3:
   S is standard iff
   for k being Nat holds k+1 in SUCC(k,S) &
    for j being Nat st j in SUCC(k,S) holds k <= j
proof
  hereby
    assume
A1:  S is standard;
    let k be Nat;
    k <= k+1 by NAT_1:11;
    then consider F being non empty FinSequence of NAT such that
A2: F/.1 = k and
A3: F/.len F = k+1 and
A4: for n st 1 <= n & n < len F holds F/.(n+1) in SUCC(F/.n,S) by A1;
    set F1 = F -| (k+1);
    set x = (k+1)..F;
A5: k+1 in rng F by A3,FINSEQ_6:168;
    then
A6: len F1 = x-1 by FINSEQ_4:34;
    then
A7: len F1+1 = x;
A8: x in dom F by A5,FINSEQ_4:20;
    then
A9: F/.(len F1+1) = F.x by A6,PARTFUN1:def 6
      .= k+1 by A5,FINSEQ_4:19;
    x <= len F by A8,FINSEQ_3:25;
    then
A10: len F1 < len F by A7,NAT_1:13;
    1 <= len F by NAT_1:14;
    then
A11: 1 in dom F by FINSEQ_3:25;
    then
A12: F/.1 = F.1 by PARTFUN1:def 6;
A13: F.x = k+1 by A5,FINSEQ_4:19;
A14: k <> k+1;
    then
A15:  len F1 <> 0 by A2,A13,A11,A6,PARTFUN1:def 6;
    1 <= x by A8,FINSEQ_3:25;
    then 1 < x by A2,A14,A13,A12,XXREAL_0:1;
    then
A16: 1 <= len F1 by A7,NAT_1:13;
    reconsider F1 as non empty FinSequence of NAT by A15,A5,FINSEQ_4:41;
    set m = F/.len F1;
    reconsider m as Nat;
A17: len F1 in dom F by A16,A10,FINSEQ_3:25;
A18: len F1 in dom F1 by A16,FINSEQ_3:25;
    then
A19: F1/.len F1 = F1.len F1 by PARTFUN1:def 6
      .= F.len F1 by A5,A18,FINSEQ_4:36
      .= F/.len F1 by A17,PARTFUN1:def 6;
A20: now
      (rng F1) misses {k+1} by A5,FINSEQ_4:38;
      then rng F1 /\ {k+1} = {};
      then
A21:  not k+1 in rng F1 or not k+1 in {k+1} by XBOOLE_0:def 4;
      assume
A22:  m = k+1;
A23:  len F1 in dom F1 by A16,FINSEQ_3:25;
      then F1/.len F1 = F1.len F1 by PARTFUN1:def 6;
      hence contradiction by A19,A22,A21,A23,FUNCT_1:def 3,TARSKI:def 1;
    end;
    reconsider F2 = <*F/.len F1, F/.x*> as non empty FinSequence of NAT;
A24: len F2 = 2 by FINSEQ_1:44;
    then
A25: 2 in dom F2 by FINSEQ_3:25;
    then
A26: F2/.len F2 = F2.2 by A24,PARTFUN1:def 6
      .= F/.x by FINSEQ_1:44
      .= k+1 by A13,A8,PARTFUN1:def 6;
A27: 1 in dom F2 by A24,FINSEQ_3:25;
A28: now
      let n;
      assume 1 <= n & n < len F2;
      then n <> 0 & n < 1+1 by FINSEQ_1:44;
      then n <> 0 & n <= 1 by NAT_1:13;
      then
A29:  n = 1 by NAT_1:25;
      then
A30:  F2/.n = F2.1 by A27,PARTFUN1:def 6
        .= F/.len F1 by FINSEQ_1:44;
      F2/.(n+1) = F2.2 by A25,A29,PARTFUN1:def 6
        .= F/.(len F1+1) by A6,FINSEQ_1:44;
      hence F2/.(n+1) in SUCC(F2/.n,S) by A4,A16,A10,A30;
    end;
A31: now
      let n;
      assume that
A32:  1 <= n and
A33:  n < len F1;
A34:  1 <= n+1 by A32,NAT_1:13;
A35:  n+1 <= len F1 by A33,NAT_1:13;
      then n+1 <= len F by A10,XXREAL_0:2;
      then
A36:  n+1 in dom F by A34,FINSEQ_3:25;
      n <= len F by A10,A33,XXREAL_0:2;
      then
A37:  n in dom F by A32,FINSEQ_3:25;
A38:  n in dom F1 by A32,A33,FINSEQ_3:25;
      then
A39:  F1/.n = F1.n by PARTFUN1:def 6
        .= F.n by A5,A38,FINSEQ_4:36
        .= F/.n by A37,PARTFUN1:def 6;
A40:  n < len F by A10,A33,XXREAL_0:2;
A41:  n+1 in dom F1 by A34,A35,FINSEQ_3:25;
      then F1/.(n+1) = F1.(n+1) by PARTFUN1:def 6
        .= F.(n+1) by A5,A41,FINSEQ_4:36
        .= F/.(n+1) by A36,PARTFUN1:def 6;
      hence F1/.(n+1) in SUCC(F1/.n,S) by A4,A32,A39,A40;
    end;
    F2/.1 = F2.1 by A27,PARTFUN1:def 6
      .= m by FINSEQ_1:44;
    then
A42: m <= k+1 by A1,A26,A28;
A43: 1 in dom F1 by A16,FINSEQ_3:25;
    then F1/.1 = F1.1 by PARTFUN1:def 6
      .= F.1 by A5,A43,FINSEQ_4:36
      .= k by A2,A11,PARTFUN1:def 6;
    then k <= m by A1,A19,A31;
    then m = k or m = k+1 by A42,NAT_1:9;
    hence k+1 in SUCC(k,S) by A4,A16,A10,A9,A20;
    let j be Nat;
    reconsider fk=k, fj=j as Element of NAT by ORDINAL1:def 12;
    reconsider F = <*fk, fj*> as non empty FinSequence of NAT;
A44: len F = 2 by FINSEQ_1:44;
    then
A45: 2 in dom F by FINSEQ_3:25;
A46: 1 in dom F by A44,FINSEQ_3:25;
    then
A47: F/.1 = F.1 by PARTFUN1:def 6
      .= k by FINSEQ_1:44;
    assume
A48: j in SUCC(k,S);
A49: now
      let n be Nat;
      assume 1 <= n & n < len F;
      then n <> 0 & n < 1+1 by FINSEQ_1:44;
      then n <> 0 & n <= 1 by NAT_1:13;
      then
A50:  n = 1 by NAT_1:25;
      then
A51:  F/.n = F.1 by A46,PARTFUN1:def 6
        .= k by FINSEQ_1:44;
      F/.(n+1) = F.2 by A45,A50,PARTFUN1:def 6
        .= j by FINSEQ_1:44;
      hence F/.(n+1) in SUCC(F/.n,S) by A48,A51;
    end;
    F/.len F = F.2 by A44,A45,PARTFUN1:def 6
      .= j by FINSEQ_1:44;
    hence k <= j by A1,A47,A49;
  end;
  assume
A52: for k being Nat holds k+1 in SUCC(k,S) & for j
  being Nat st j in SUCC(k,S) holds k <= j;
  thus S is standard
  proof
  let m, n be Nat;
  thus m <= n implies ex f being non empty FinSequence of NAT st f/.1
= m & f/.len f = n &
 for k st 1 <= k & k < len f holds f/.(k+1) in SUCC(f/.k,S)
  proof
    assume
A53: m <= n;
    per cases by A53,XXREAL_0:1;
    suppose
      m = n;
    hence ex f being non empty FinSequence of NAT st f/.1
= m & f/.len f = n & for n st 1 <= n & n < len f
 holds f/.(n+1) in SUCC(f/.n,S) by Lm2;
    end;
    suppose
A54:  m < n;
      thus ex f being non empty FinSequence of NAT st f/.1
= m & f/.len f = n & for n st 1 <= n & n < len f
 holds f/.(n+1) in SUCC(f/.n,S)
      proof
        set mn = n -' m;
        deffunc F(Nat) = m+$1-'1;
        consider F being FinSequence of NAT such that
A55:    len F = mn+1 and
A56:    for j being Nat st j in dom F holds F.j = F(j) from FINSEQ_2:
        sch 1;
        reconsider F as non empty FinSequence of NAT by A55;
        take F;
A57:    1 <= mn+1 by NAT_1:11;
        then
A58:    1 in dom F by A55,FINSEQ_3:25;
        hence F/.1 = F.1 by PARTFUN1:def 6
          .= m+1-'1 by A56,A58
          .= m by NAT_D:34;
        m+1 <= n by A54,INT_1:7;
        then 1 <= n-m by XREAL_1:19;
        then 0 <= n-m;
        then
A59:    mn = n - m by XREAL_0:def 2;
A60:    len F in dom F by A55,A57,FINSEQ_3:25;
        hence F/.len F = F.len F by PARTFUN1:def 6
          .= m+(mn+1)-'1 by A55,A56,A60
          .= m+mn+1-'1
          .= n by A59,NAT_D:34;
        let p be Nat;
        assume that
A61:    1 <= p and
A62:    p < len F;
A63:    p in dom F by A61,A62,FINSEQ_3:25;
        then
A64:    F/.p = F.p by PARTFUN1:def 6
          .= m+p-'1 by A56,A63;
A65:    p <= m+p by NAT_1:11;
        1 <= p+1 & p+1 <= len F by A61,A62,NAT_1:13;
        then
A66:    p+1 in dom F by FINSEQ_3:25;
        then F/.(p+1) = F.(p+1) by PARTFUN1:def 6
          .= m+(p+1)-'1 by A56,A66
          .= m+p+1-'1
          .= m+p-'1+1 by A61,A65,NAT_D:38,XXREAL_0:2;
        hence thesis by A52,A64;
      end;
    end;
  end;
  given F being non empty FinSequence of NAT such that
A67: F/.1 = m and
A68: F/.len F = n and
A69: for n being Nat st 1 <= n & n < len F holds F/.(n+1) in
  SUCC(F/.n,S);
  defpred P[Nat] means 1 <= $1 & $1 <= len F implies ex l being
  Nat st F/.$1 = l & m <= l;
A70: now
    let k be Nat such that
A71: P[k];
    now
      assume that
      1 <= k+1 and
A72:  k+1 <= len F;
      per cases;
      suppose
        k = 0;
        hence ex l being Nat st F/.(k+1) = l & m <= l by A67;
      end;
      suppose
A73:    k > 0;
        set l1 = F/.(k+1);
        consider l being Nat such that
A74:    F/.k = l and
A75:    m <= l by A71,A72,A73,NAT_1:13,14;
        reconsider l1 as Nat;
        k < len F by A72,NAT_1:13;
        then F/.(k+1) in SUCC(F/.k,S) by A69,A73,NAT_1:14;
        then l <= l1 by A52,A74;
        hence
        ex l being Nat st F/.(k+1) = l & m <= l by A75,XXREAL_0:2;
      end;
    end;
    hence P[k+1];
  end;
A76: 1 <= len F by NAT_1:14;
A77: P[0];
  for k being Nat holds P[k] from NAT_1:sch 2(A77, A70);
  then ex l being Nat st F/.len F = l & m <= l by A76;
  hence thesis by A68;
 end;
end;
set III = {[1,{},{}],[0,{},{}]};

begin :: Standard trivial computer

definition
  let N be with_zero set;
  func STC N -> strict AMI-Struct over N means
  :Def7:
  the carrier of it = {0} & IC it = 0 &
  the InstructionsF of it = {[0,0,0],[1,0,0]} &
  the Object-Kind of it = (0 .--> 0) &
  the ValuesF of it = N --> NAT &
  ex f being Function of product the_Values_of it,
                         product the_Values_of it st
  (for s being Element of product the_Values_of it
    holds f.s = s+*(0 .-->(In(s.0,NAT) + 1))) &
  the Execution of it = ([1,0,0] .--> f) +*
    ([0,0,0] .--> id product the_Values_of it);
  existence
  proof
    set O = {0};
    set V = N --> NAT;
    reconsider IC1 = 0 as Element of O by TARSKI:def 1;
    reconsider i = [0,0,0] as Element of III by TARSKI:def 2;
A1: 0 in N by MEASURE6:def 2;
    then
A2:  V*(0 .-->0) = 0 .--> NAT by FUNCOP_1:89;
    then
A3: dom(V*(0 .-->0)) = O;
A4: dom(0 .-->0) = O;
    rng(0 .-->0) = {0} by FUNCOP_1:88;
    then rng(0 .-->0) c= N by A1,ZFMISC_1:31;
    then reconsider Ok = 0 .-->0 as Function of O, N by A4,RELSET_1:4;
    deffunc F(Element of product(V*Ok)) = $1+*(0 .-->(In($1.0,NAT) + 1));
A5: now
      let s be Element of product(V*Ok);
     now
        thus dom (s+*(0 .-->(In(s.0,NAT)+1)))
           = dom s \/ dom (0 .-->(In(s.0,NAT)+1)) by FUNCT_4:def 1
          .= dom s \/ {0}
          .= {0} \/ {0} by PARTFUN1:def 2
          .= dom(V*Ok) by A3;
        let o be object;
A6:     dom (0 .-->(In(s.0,NAT)+1)) = {0};
        assume
A7:        o in dom(V*Ok);
A8:      (V*Ok).o = NAT by A7,A2,FUNCOP_1:7;
       (s+*(0 .-->(In(s.0,NAT)+1))).o
             = (0 .-->(In(s.0,NAT)+1)).o by A6,A7,FUNCT_4:13
            .= In(s.0,NAT)+1 by A7,FUNCOP_1:7;
       hence (s+*(0 .-->(In(s.0,NAT)+1))).o in (V*Ok).o by A8;
      end;
      hence F(s) in product(V*Ok) by CARD_3:9;
    end;
    consider f being Function of product(V*Ok), product(V*Ok) such that
A9: for s being Element of product(V*Ok) holds f.s= F(s) from FUNCT_2:
    sch 8 (A5);
    set E = ([1,0,0] .--> f) +* ([0,0,0] .--> id product(V*Ok));
A10: dom E = dom ([1,0,0] .--> f) \/ dom ([0,0,0] .--> id product(V*Ok)) by
FUNCT_4:def 1
      .= {[1,0,0]} \/ dom ([0,0,0] .--> id product(V*Ok))
      .= {[1,0,0]} \/ {[0,0,0]}
      .= III by ENUMSET1:1;
A11: rng ([1,0,0] .--> f) c= {f} & rng ([0,0,0] .--> id product(V*Ok)) c= {id
    product(V*Ok)} by FUNCOP_1:13;
A12: rng E c= rng ([1,0,0] .--> f) \/ rng ([0,0,0] .--> id product(V*Ok)) by
FUNCT_4:17;
    rng E c= Funcs(product(V*Ok), product(V*Ok))
    proof
      let e be object;
      assume e in rng E;
      then e in rng ([1,0,0] .--> f) or
      e in rng ([0,0,0] .--> id product(V*Ok)) by A12,XBOOLE_0:def 3;
      then e = f or e = id product(V*Ok) by A11,TARSKI:def 1;
      hence thesis by FUNCT_2:9;
    end;
    then reconsider E as Function of III, Funcs(product(V*Ok), product(V*Ok))
     by A10,FUNCT_2:def 1,RELSET_1:4;
    set V = N --> NAT;
    set M = AMI-Struct(# O, IC1, III, Ok, V, E#);
    take M qua strict AMI-Struct over N;
    thus the carrier of M = {0};
    thus IC M = 0;
    thus the InstructionsF of M = {[0,0,0],[1,0,0]};
    thus the Object-Kind of M = (0 .-->0);
    thus the ValuesF of M = N --> NAT;
    reconsider f as Function of product the_Values_of M,
    product the_Values_of M;
    take f;
    thus for s being Element of product the_Values_of M
     holds f.s = s+*(0 .-->(In(s.0,NAT) + 1)) by A9;
    thus thesis;
  end;
  uniqueness
  proof
    let it1, it2 be strict AMI-Struct over N such that
A13: the carrier of it1 = {0} & IC it1 = 0
    & the InstructionsF of it1 = {[0,0,0],[1,0,0]}
    and
A14: the Object-Kind of it1 = (0 .-->0) and
A15:    the ValuesF of it1 = N --> NAT;
    given f1 being Function of product the_Values_of it1,
     product the_Values_of it1 such that
A16: for s being Element of product the_Values_of it1 holds f1.s
    = s+* (0 .-->(In(s.0,NAT)+1)) and
A17: the Execution of it1 = ([1,0,0] .--> f1) +* ([0,0,0] .--> id product
    the_Values_of it1);
    assume that
A18: the carrier of it2 = {0} & IC it2 = 0
     & the InstructionsF of it2 = {[0,0,0],[1,0,0]} and
A19: the Object-Kind of it2 = (0 .-->0) and
A20:    the ValuesF of it2 = N --> NAT;
    given f2 being Function of product the_Values_of it2, product
    the_Values_of it2 such that
A21: for s being Element of product the_Values_of it2 holds f2.s
    = s+* (0 .-->(In(s.0,NAT)+1)) and
A22: the Execution of it2 = ([1,0,0] .--> f2) +* ([0,0,0] .--> id product
    the_Values_of it2);
A23:  the_Values_of it1 = the_Values_of it2 by A14,A15,A19,A20;
    now
      let c be Element of product the_Values_of it1;
      thus f1.c = c+*(0 .-->(In(c.0,NAT)+1)) by A16
        .= f2.c by A21,A23;
    end;
    hence thesis by A13,A14,A17,A18,A19,A22,A15,A20,FUNCT_2:63;
  end;
end;

registration
  let N be with_zero set;
  cluster STC N -> finite non empty;
  coherence by Def7;
end;

registration
  let N be with_zero set;
  cluster STC N -> with_non-empty_values;
  coherence
  proof
   let n be object;
    set S = STC N, F = the_Values_of S;
   assume
A1:   n in dom F;
    then
A2:  (the Object-Kind of S).n in dom the ValuesF of S by FUNCT_1:11;
A3:  the ValuesF of S = N --> NAT by Def7;
A4:  (the Object-Kind of S).n in N by A2;
    F.n =(the ValuesF of S).((the Object-Kind of S).n) by A1,FUNCT_1:12
       .= NAT by A4,A3,FUNCOP_1:7;
   hence F.n is non empty;
  end;
end;

registration
  let N be with_zero set;
  cluster STC N -> IC-Ins-separated;
  coherence
  proof
    set IT = STC N;
    set Ok = the_Values_of IT;
A1: 0 in {0} by TARSKI:def 1;
A2: the_Values_of IT = (the ValuesF of IT)*(the Object-Kind of IT)
       .= (the ValuesF of IT)*(0.-->0) by Def7
       .= (N-->NAT)*(0.-->0) by Def7;
    0 in N by MEASURE6:def 2;
    then Ok.0 = (0 .-->NAT).0 by A2,FUNCOP_1:89
      .= NAT by A1,FUNCOP_1:7;
    then Values IC IT = NAT by Def7;
    hence STC N is IC-Ins-separated;
  end;
end;

Lm3: for i being Instruction of STC N, s being State of STC N st InsCode i = 1
holds Exec(i,s).IC STC N = IC s + 1
proof
  let i be Instruction of STC N, s be State of STC N;
  set M = STC N;
  assume
A1: InsCode i = 1;
A2: now
    assume i in {[0,0,0]};
    then i = [0,0,0] by TARSKI:def 1;
    hence contradiction by A1;
  end;
  the InstructionsF of M = III by Def7;
  then i = [1,0,0] or i = [0,0,0] by TARSKI:def 2;
  then
A3: i in {[1,0,0]} by A1,TARSKI:def 1;
A4: 0 in {0} by TARSKI:def 1;
  then
A5: 0 in dom (0 .-->(In(s.0,NAT)+1));

  consider f be Function of product the_Values_of M, product
  the_Values_of M such that
A6: for s being Element of product the_Values_of M holds f.s = s+*(
  0 .-->(In(s.0,NAT)+1)) and

A7: the Execution of M = ([1,0,0] .--> f) +* ([0,0,0] .-->
    id product the_Values_of M) by Def7;
A8: for s being State of M holds f.s = s+*(0 .-->(In(s.0,NAT)+1))
 proof let s be State of M;
  reconsider s as Element of product the_Values_of M by CARD_3:107;
  f.s = s+*(0 .-->(In(s.0,NAT)+1)) by A6;
  hence thesis;
 end;
A9: IC M = 0 by Def7;
A10: s in product the_Values_of M by CARD_3:107;
   dom(the_Values_of M) = the carrier of M by PARTFUN1:def 2
     .= {0} by Def7;
    then
A11:  0 in dom(the_Values_of M) by TARSKI:def 1;
  Values IC M = NAT by MEMSTR_0:def 6;
  then reconsider k = s.0 as Element of NAT by A10,A11,CARD_3:9,A9;
  dom ([0,0,0] .--> id product the_Values_of M) = {[0,0,0]};
  then (the Execution of M).i = ([1,0,0] .--> f).i by A7,A2,FUNCT_4:11
    .= f by A3,FUNCOP_1:7;
  hence Exec(i,s).IC STC N = (s+*(0 .-->(In(s.0,NAT) + 1))).0 by A9,A8
    .= (0 .-->(In(s.0,NAT)+1)).0 by A5,FUNCT_4:13
    .= In(k,NAT)+1 by A4,FUNCOP_1:7
    .= IC s + 1 by A9;
end;

theorem Th4:
  for i being Instruction of STC N st InsCode i = 0 holds i is halting
proof
  let i be Instruction of STC N;
  set M = STC N;
  the InstructionsF of M = III by Def7;
  then
A1: i = [1,0,0] or i = [0,0,0] by TARSKI:def 2;
  assume InsCode i = 0;
  then
A2: i in {[0,0,0]} by A1,TARSKI:def 1;
  let s be State of M;
  reconsider s as Element of product the_Values_of M by CARD_3:107;
  (ex f be Function of product the_Values_of M, product
         the_Values_of M
 st ( for s being Element of product the_Values_of M holds
f.s = s+*(0 .-->(In(s.0,NAT)+1)))&
   the Execution of M = ([1,0,0] .--> f) +* ([0,0,0]
  .--> id product the_Values_of M) )& dom ([0,0,0] .--> id product
  the_Values_of M) = {[0,0,0]} by Def7;
  then
  (the Execution of M).i = ([0,0,0] .--> id product the_Values_of M).i
  by A2,FUNCT_4:13
    .= id product the_Values_of M by A2,FUNCOP_1:7;
   then (the Execution of M).i.s = s;
  hence thesis;
end;

theorem
  for i being Instruction of STC N st InsCode i = 1 holds i is non halting
proof
  let i be Instruction of STC N;
  set M = STC N;
  set s =the  State of M;
  assume InsCode i = 1;
  then
A1: Exec(i,s).IC M = IC s + 1 by Lm3;
  assume for s being State of M holds Exec(i,s) = s;
  then Exec(i,s).IC M = IC s;
  hence thesis by A1;
end;

theorem Th6:
  for i being Element of the InstructionsF of STC N
    holds InsCode i = 1 or InsCode i = 0
proof
  let i be Element of the InstructionsF of STC N;
  the InstructionsF of STC N = III by Def7;
  then i = [1,0,0] or i = [0,0,0] by TARSKI:def 2;
  hence thesis;
end;

theorem
  for i being Instruction of STC N holds i is jump-only
proof
  let i be Instruction of STC N;
  set M = STC N;
  let s be State of M, o be Object of M, I be Instruction of M such that
  InsCode I = InsCode i and
A1: o in Data-Locations M;
A2: IC M = 0 by Def7;
  Data-Locations M = ({0}) \ ({0}) by A2,Def7
       .= {} by XBOOLE_1:37;
   hence thesis by A1;
end;

registration let N;
 cluster -> ins-loc-free for Instruction of STC N;
 coherence
  proof let I be Instruction of STC N;
    I in the InstructionsF of STC N;
    then I in {[0,0,0],[1,0,0]} by Def7;
    then I = [0,0,0] or I = [1,0,0] by TARSKI:def 2;
   hence JumpPart I is empty;
  end;
end;

Lm4: for l being Nat, i being Element of the
InstructionsF of STC N st l = z & InsCode i = 1 holds NIC(i, l) = {z+1}
proof
  let l be Nat, i be Element of the InstructionsF of STC N;
  assume that
A1: l = z and
A2: InsCode i = 1;
  set M = STC N;
  set F = { IC Exec(i,ss)
   where ss is Element of product the_Values_of STC N: IC ss = l};
  now
    set f = NAT --> i;
    set w =the  State of M;
    reconsider ll=l as Element of NAT by ORDINAL1:def 12;
    reconsider l9 = ll as Element of Values IC M by MEMSTR_0:def 6;
    set u = (IC M).-->l9;
    let y be object;
    reconsider t = w+*u as Element of product the_Values_of STC N
     by CARD_3:107;
    hereby
      assume y in F;
      then ex s being Element of product the_Values_of STC N
      st y = IC Exec(i,s) & IC s = l;
      then y = z+1 by A1,A2,Lm3;
      hence y in {z+1} by TARSKI:def 1;
    end;
    assume y in {z+1};
    then
A5: y = z+1 by TARSKI:def 1;
    IC M in dom u by TARSKI:def 1;
    then
A6: IC t = u.IC M by FUNCT_4:13
      .= z by A1,FUNCOP_1:72;
    then IC Following(f,t) = z+1 by A2,Lm3;
    hence y in F by A1,A5,A6;
  end;
  hence thesis by TARSKI:2;
end;

Lm5: for i being Element of the InstructionsF of STC N holds JUMP i is empty
proof
  let i be Element of the InstructionsF of STC N;
  per cases by Th6;
  suppose
A1: InsCode i = 1;
    reconsider l1 = 0, l2 = 1 as Nat;

    set X = the set of all  NIC(i,l) where l is Nat ;

    assume not thesis;
    then consider x being object such that
A2: x in meet X;
    NIC(i, l1) in X;
    then {0+1} in X by A1,Lm4;
    then x in {1} by A2,SETFAM_1:def 1;
    then
A3: x = 1 by TARSKI:def 1;
    NIC(i, l2) in X;
    then {1+1} in X by A1,Lm4;
    then x in {2} by A2,SETFAM_1:def 1;
    hence contradiction by A3,TARSKI:def 1;
  end;
  suppose
A4: InsCode i = 0;
    reconsider i as Instruction of STC N;

    for l being Nat holds NIC(i,l)={l} by A4,Th2,Th4;

    hence thesis by Th1;
  end;
end;

theorem Th8:
  for l being Nat st l = z holds SUCC(l,STC N) = {z, z+1}
proof
  let l be Nat such that
A1: l = z;
  set M = STC N;
  set K = the set of all
 NIC(i,l) \ JUMP i where i is Element of the InstructionsF of STC N;
  now
    let y be object;
    hereby
      assume y in K;
      then consider ii being Element of the InstructionsF of STC N such that
A2:   y = NIC(ii,l) \ JUMP ii and
      not contradiction;
      reconsider ii as Instruction of STC N;
      now
        per cases by Th6;
        suppose
A3:       InsCode ii = 1;
          JUMP ii = {} by Lm5;
          then y = {z+1} by A1,A2,A3,Lm4;
          hence y in {{z},{z+1}} by TARSKI:def 2;
        end;
        suppose
A4:       InsCode ii = 0;
          JUMP ii = {} by Lm5;
          then y = {z} by A1,A2,A4,Th2,Th4;
          hence y in {{z},{z+1}} by TARSKI:def 2;
        end;
      end;
      hence y in {{z},{z+1}};
    end;
    assume
A5: y in {{z},{z+1}};
    per cases by A5,TARSKI:def 2;
    suppose
A6:   y = {z};
      halt M = [0,{},{}];
      then reconsider i = [0,0,0] as Instruction of M;
      JUMP i = {} & InsCode i = 0 by Lm5;
      then NIC(i,l) \ JUMP i = y by A1,A6,Th2,Th4;
      hence y in K;
    end;
    suppose
A7:   y = {z+1};
      set i = [1,0,0];
      i in III by TARSKI:def 2;
      then reconsider i as Instruction of M by Def7;
      JUMP i = {} & InsCode i = 1 by Lm5;
      then NIC(i,l) \ JUMP i = y by A1,A7,Lm4;
      hence y in K;
    end;
  end;
  then K = {{z},{z+1}} by TARSKI:2;
  hence thesis by ZFMISC_1:26;
end;

registration
  let N be with_zero set;
  cluster STC N -> standard;
  coherence
  proof
    set M = STC N;
    now
      let k be Nat;
A1:   SUCC(k,STC N) = {k,k+1} by Th8;
      thus k+1 in SUCC(k,STC N) by A1,TARSKI:def 2;
      let j be Nat;
      assume j in SUCC(k,STC N);
      then j = k or j = k+1 by A1,TARSKI:def 2;
      hence k <= j by NAT_1:11;
    end;
    hence thesis by Th3;
  end;
end;

registration
  let N be with_zero set;
  cluster STC N -> halting;
  coherence
  proof
    set I = halt STC N;
    InsCode I = 0;
    hence I is halting by Th4;
  end;
end;

registration
  let N be with_zero set;
  cluster standard halting for IC-Ins-separated
      non empty with_non-empty_values AMI-Struct over N;
  existence
  proof
    take STC N;
    thus thesis;
  end;
end;

reserve T for standard IC-Ins-separated non empty
     with_non-empty_values AMI-Struct over N;

theorem
  for i being Instruction of STC N, s being State of STC N st InsCode i = 1
   holds Exec(i,s).IC STC N = IC s + 1 by Lm3;

theorem
  for l being Nat, i being Element of the
  InstructionsF of STC N st InsCode i = 1 holds NIC(i, l) = {l+1} by Lm4;

theorem
  for l being Nat holds SUCC(l,STC N) = {l, l + 1} by Th8;

definition
  let N be with_zero set,
  S be IC-Ins-separated
   non empty with_non-empty_values AMI-Struct over N,
  i be Instruction of S;
  attr i is sequential means
  for s being State of S holds Exec(i, s).IC S = IC s + 1;
end;

theorem Th12:
  for S being IC-Ins-separated non empty with_non-empty_values
         AMI-Struct over N,
      il being Nat, i being Instruction of S st i is sequential
       holds NIC(i,il) = {il + 1}
proof
  let S be IC-Ins-separated
   non empty with_non-empty_values AMI-Struct over N,
     il be Nat, i be
  Instruction of S such that
A1: for s being State of S holds Exec(i, s).IC S = IC s + 1;
  now
    let x be object;
A2: now
     reconsider ll = il as Element of NAT by ORDINAL1:def 12;
      reconsider il1 = ll as Element of Values IC S by MEMSTR_0:def 6;
      set I = i;
      set t = the  State of S, P = the Instruction-Sequence of S;
      assume
A3:   x = il+1;
      reconsider u = t+*(IC S,il1) as
       Element of product the_Values_of S by CARD_3:107;
      ll in NAT;
      then
A4:     il in dom P by PARTFUN1:def 2;
A5:   (P+*(il,i))/.ll = (P+*(il,i)).ll by PBOOLE:143
         .= i by A4,FUNCT_7:31;
      IC S in dom t by MEMSTR_0:2;
      then
A6:   IC u = il by FUNCT_7:31;
      then IC Following(P+*(il,i),u) = il + 1 by A1,A5;
      hence x in {IC Exec(i,ss)
       where ss is Element of product the_Values_of S
        : IC ss = il} by A3,A6,A5;
    end;
    now
      assume x in {IC Exec(i,ss)
       where ss is Element of product the_Values_of S : IC ss = il};
      then ex s being Element of product the_Values_of S
       st x = IC Exec(i,s) & IC s = il;
      hence x = il + 1 by A1;
    end;
    hence
    x in {il+1} iff x in {IC Exec(i,ss)
       where ss is Element of product the_Values_of S
     : IC ss = il } by A2,TARSKI:def 1;
  end;
  hence thesis by TARSKI:2;
end;

registration
  let N;
  let S be IC-Ins-separated
   non empty with_non-empty_values AMI-Struct over N;
  cluster sequential -> non halting for Instruction of S;
  coherence
proof
  let i be Instruction of S such that
A1: i is sequential;
  set s =the  State of S;
A2: IC s + 1 <> IC s + 0;
  NIC(i,IC s) = {IC s + 1} by A1,Th12;
  then NIC(i,IC s) <> {IC s} by ZFMISC_1:3,A2;
  hence thesis by Th2;
end;
  cluster halting -> non sequential for Instruction of S;
  coherence;
end;

theorem
 for T being IC-Ins-separated non empty with_non-empty_values AMI-Struct over N
  for i being Instruction of T st JUMP i is non empty holds i is non
  sequential
proof
 let T be IC-Ins-separated non empty with_non-empty_values AMI-Struct over N;
  let i be Instruction of T;
  set X = the set of all NIC(i,l1) where l1 is Nat;
  assume JUMP i is non empty;
  then consider l being object such that
A1: l in JUMP i;
  reconsider l as Nat by A1;
  NIC(i,l) in X;
  then l in NIC(i,l) by A1,SETFAM_1:def 1;
  then consider s being Element of product the_Values_of T
  such that
A2: l = IC Exec(i,s) & IC s = l;
  take s;
  thus thesis by A2;
end;

begin :: Closedness of finite partial states

definition
  let N be with_zero set;
  let S be IC-Ins-separated non empty with_non-empty_values AMI-Struct over N;
  let F be finite preProgram of S;
  attr F is really-closed means
  for l being Nat st l in dom F holds NIC (F/.l, l) c= dom F;
end;

::$CD

definition
  let N be with_zero set;
  let S be halting IC-Ins-separated non empty with_non-empty_values
         AMI-Struct over N;
  let F be NAT-defined (the InstructionsF of S)-valued Function;
  attr F is parahalting means
  for s being 0-started State of S
  for P being Instruction-Sequence of S st F c= P
   holds P halts_on s;
end;

theorem Th14:
 for N being with_zero set
 for S being IC-Ins-separated non empty with_non-empty_values AMI-Struct over N
 for F being finite preProgram of S
  holds F is really-closed iff
  for s being State of S st IC s in dom F
   for k being Nat holds IC Comput(F,s,k) in dom F
 proof let N be with_zero set;
  let S be IC-Ins-separated non empty
  with_non-empty_values AMI-Struct over N;
  let F be finite preProgram of S;
  thus F is really-closed implies
   for s being State of S st IC s in dom F
    for k being Nat holds IC Comput(F,s,k) in dom F
   proof assume
A1: F is really-closed;
     let s be State of S such that
A2: IC s in dom F;
     defpred P[Nat] means IC Comput(F,s,$1) in dom F;
A3: now
       let k be Nat such that
A4: P[k];
       reconsider t = Comput(F,s,k)
        as Element of product the_Values_of S by CARD_3:107;
       set l = IC Comput(F,s,k);
A5: IC Following(F,t) in NIC(F/.l,l);
A6: Comput(F,s,k+1) = Following(F,t) by EXTPRO_1:3;
       NIC(F/.l, l) c= dom F by A1,A4;
       hence P[k+1] by A5,A6;
     end;
A7: P[0] by A2;
     thus for k being Nat holds P[k] from NAT_1:sch 2(A7,A3);
   end;
  assume
A8: for s being State of S st IC s in dom F
     for k being Nat holds IC Comput(F,s,k) in dom F;
  let l being Nat such that
A9: l in dom F;
  let x be object;
  assume x in NIC(F/.l, l);
   then consider ss being Element of product the_Values_of S
    such that
A10: x = IC Exec(F/.l,ss) and
A11: IC ss = l;
   reconsider ss as State of S;
   IC Comput(F,ss,0+1) = IC Following(F,Comput(F,ss,0)) by EXTPRO_1:3
      .= IC Following(F,ss)
      .= IC Exec(F/.IC ss,ss);
  hence x in dom F by A10,A11,A8,A9;
 end;

Lm6:
 for N being with_zero set
 for S being IC-Ins-separated non empty
 with_non-empty_values AMI-Struct over N
 for F being finite preProgram of S
  holds F is really-closed iff
  for s being State of S st IC s in dom F
  for P being Instruction-Sequence of S st F c= P
   for k being Nat holds IC Comput(P,s,k) in dom F
 proof let N be with_zero set;
  let S be IC-Ins-separated non empty with_non-empty_values AMI-Struct over N;
  let F be finite preProgram of S;
  thus F is really-closed implies
   for s being State of S st IC s in dom F
   for P being Instruction-Sequence of S st F c= P
    for k being Nat holds IC Comput(P,s,k) in dom F
   proof assume
A1: F is really-closed;
     let s be State of S such that
A2: IC s in dom F;
    let P be Instruction-Sequence of S such that
A3:  F c= P;
     defpred P[Nat] means IC Comput(P,s,$1) in dom F;
A4: now
       let k be Nat such that
A5: P[k];
       reconsider t = Comput(P,s,k)
        as Element of product the_Values_of S by CARD_3:107;
       set l = IC Comput(P,s,k);
A6: IC Following(P,t) in NIC(P/.l,l);
A7: Comput(P,s,k+1) = Following(P,t) by EXTPRO_1:3;
       P/.l = F/.l by A5,A3,PARTFUN2:61;
       then NIC(P/.l, l) c= dom F by A1,A5;
       hence P[k+1] by A6,A7;
     end;
A8: P[0] by A2;
     thus for k being Nat holds P[k] from NAT_1:sch 2(A8,A4);
   end;
  assume
A9: for s being State of S st IC s in dom F
    for P being Instruction-Sequence of S st F c= P
     for k being Nat holds IC Comput(P,s,k) in dom F;
   for s being State of S st IC s in dom F
    for k being Nat holds IC Comput(F,s,k) in dom F
   proof let s be State of S such that
A10:   IC s in dom F;
    consider P being Instruction-Sequence of S such that
A11:   F c= P by PBOOLE:145;
    let k be Nat;
A12:   IC Comput(P,s,k) in dom F by A9,A10,A11;
   defpred P[Nat] means Comput(P,s,$1) = Comput(F,s,$1);
A13:  P[0];
A14:  for k being Nat st P[k] holds P[k+1]
     proof let k be Nat;
      assume
A15:     P[k];
      reconsider kk = k as Nat;
A16:   IC Comput(P,s,kk) in dom F by A9,A10,A11;
       Comput(P,s,k+1) = Following(P,Comput(F,s,k)) by A15,EXTPRO_1:3
          .= Following(F,Comput(F,s,k)) by A16,A11,A15,PARTFUN2:61
          .= Comput(F,s,k+1) by EXTPRO_1:3;
      hence P[k+1];
     end;
    for k being Nat holds P[k] from NAT_1:sch 2(A13,A14);
    hence IC Comput(F,s,k) in dom F by A12;
   end;
   hence thesis by Th14;
 end;

registration let N;
  let S be halting IC-Ins-separated
    non empty with_non-empty_values AMI-Struct over N;
  cluster Stop S -> really-closed;
  coherence
proof set F = Stop S;
  let l be Nat;
  assume
A1: l in dom F;
A3: l = 0 by A1,TARSKI:def 1;
  F/.l = F.l by A1,PARTFUN1:def 6
    .= halt S by A3;
  hence thesis by A3,Th2;
end;
end;

::$CT 2

registration
  let N be with_zero set;
  let S be standard halting IC-Ins-separated non empty
  with_non-empty_values AMI-Struct over N;
  cluster really-closed trivial for MacroInstruction of S;
  existence
  proof
    take F = Stop S;
    thus thesis;
  end;
end;

theorem
  for i being Instruction of Trivial-AMI(N) holds i is halting
proof
  let i be Instruction of Trivial-AMI(N);
  set M = Trivial-AMI(N);
A1: the InstructionsF of M = {[0,{},{}]} by EXTPRO_1:def 1;
  let s be State of M;
  reconsider s as Element of product the_Values_of M by CARD_3:107;
A2:  the Object-Kind of M = 0 .--> 0 &
  the ValuesF of M = N --> NAT by EXTPRO_1:def 1;
  (the Execution of M).i = ([0,{},{}] .--> id product the_Values_of M).i
         by A2,EXTPRO_1:def 1
    .= id product the_Values_of M by A1;
  then (the Execution of M).i.s = s;
  hence thesis;
end;

theorem
  for i being Element of the InstructionsF of Trivial-AMI N holds InsCode i = 0
proof
  let i be Element of the InstructionsF of Trivial-AMI(N);
  the InstructionsF of Trivial-AMI(N) = {[0,{},{}]} by EXTPRO_1:def 1;
  then i = [0,{},{}] by TARSKI:def 1;
  hence thesis;
end;

begin :: Addenda

:: from SCMPDS_9, 2008.03.10, A.T.

theorem
  for N being with_zero set, S
being IC-Ins-separated non empty with_non-empty_values AMI-Struct over N,
 i being Instruction of S, l being Nat
 holds JUMP(i) c= NIC(i,l)
proof
  let N be with_zero set,
  S be IC-Ins-separated non
  empty with_non-empty_values AMI-Struct over N, i be Instruction of S, l be
  Nat;
  set X = the set of all  NIC(i,k) where k is Nat;
  let x be object;
A1: NIC(i,l) in X;
  assume x in JUMP(i);
  hence thesis by A1,SETFAM_1:def 1;
end;

theorem
 for i being Instruction of STC N, s being State of STC N st InsCode i = 1
  holds Exec(i,s) = IncIC(s,1)
proof
  let i be Instruction of STC N, s be State of STC N;
  set M = STC N;
  assume
A1: InsCode i = 1;
A2: now
    assume i in {[0,0,0]};
    then i = [0,0,0] by TARSKI:def 1;
    hence contradiction by A1;
  end;
  the InstructionsF of M = III by Def7;
  then i = [1,0,0] or i = [0,0,0] by TARSKI:def 2;
  then
A3: i in {[1,0,0]} by A1,TARSKI:def 1;
  consider f be Function of product the_Values_of M, product
  the_Values_of M such that
A4: for s being Element of product the_Values_of M
   holds f.s = s+*(0 .-->(In(s.0,NAT)+1)) and
A5: the Execution of M = ([1,0,0] .--> f) +* ([0,0,0] .--> id product
  the_Values_of M) by Def7;
A6: for s being State of M holds f.s = s+*(0 .-->(In(s.0,NAT)+1))
 proof let s be State of M;
  reconsider s as Element of product the_Values_of M by CARD_3:107;
  f.s = s+*(0 .-->(In(s.0,NAT)+1)) by A4;
  hence thesis;
 end;
A7: IC M = 0 by Def7;
A8: s in product the_Values_of M by CARD_3:107;
   dom(the_Values_of M) = the carrier of M by PARTFUN1:def 2
     .= {0} by Def7;
    then
A9:  0 in dom(the_Values_of M) by TARSKI:def 1;
  Values IC M = NAT by MEMSTR_0:def 6;
  then reconsider k = s.0 as Element of NAT by A8,A9,CARD_3:9,A7;
A10: Start-At(IC s+1,M) = 0 .-->(In(k,NAT)+1) by A7;
  dom ([0,0,0] .--> id product the_Values_of M) = {[0,0,0]};
  then (the Execution of M).i = ([1,0,0] .--> f).i by A5,A2,FUNCT_4:11
    .= f by A3,FUNCOP_1:7;
  hence Exec(i,s) = IncIC(s,1) by A10,A6;
end;

registration let N; let p be PartState of STC N;
 cluster DataPart p -> empty;
 coherence
  proof
   Data-Locations STC N
      = (the carrier of STC N) \ ({0}) by Def7
     .= ({0}) \ ({0}) by Def7
     .= {} by XBOOLE_1:37;
  hence thesis;
  end;
end;

theorem
 for N being with_zero set
 for S being IC-Ins-separated non empty with_non-empty_values AMI-Struct over N
 for F being finite preProgram of S
  holds F is really-closed iff
  for s being State of S st IC s in dom F
  for P being Instruction-Sequence of S st F c= P
   for k being Nat holds IC Comput(P,s,k) in dom F by Lm6;

registration
  let N be with_zero set;
  let S be halting IC-Ins-separated non empty with_non-empty_values
         AMI-Struct over N;
 cluster parahalting
    for finite non halt-free non empty
       NAT-defined (the InstructionsF of S)-valued Function;
 existence
  proof
   take Stop S;
   let s be 0-started State of S;
   let P be Instruction-Sequence of S such that
A1:  Stop S c= P;
  take 0;
A2: 0 in dom Stop S by COMPOS_1:3;
   dom Stop S c= dom P by A1,RELAT_1:11;
   then
A3: 0 in dom P by A2;
A4:  IC s = 0 by MEMSTR_0:def 11;
   hence IC Comput(P,s,0) in dom P by A3;
   thus CurInstr(P,Comput(P,s,0))
        = P/.0 by A4
       .= P.0 by A3,PARTFUN1:def 6
       .= (Stop S).0 by A1,A2,GRFUNC_1:2
       .= halt S;
  end;
end;