Article TURING_1, MML version 4.99.1005

:: TURING_1:funcnot 1 => TURING_1:func 1
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be Function-like Relation of a1,a2;
  redefine func a3 +* a4 -> Function-like quasi_total Relation of a1,a2;
  idempotence;
::  for a1, a2 being non empty set
::  for a3 being Function-like quasi_total Relation of a1,a2 holds
::     a3 +* a3 = a3;
end;

:: TURING_1:funcnot 2 => TURING_1:func 2
definition
  let a1, a2 be non empty set;
  let a3 be Element of a1;
  let a4 be Element of a2;
  redefine func a3 .--> a4 -> Function-like Relation of a1,a2;
end;

:: TURING_1:funcnot 3 => TURING_1:func 3
definition
  let a1 be natural set;
  func SegM A1 -> Element of bool NAT equals
    {b1 where b1 is Element of NAT: b1 <= a1};
end;

:: TURING_1:def 1
theorem
for b1 being natural set holds
   SegM b1 = {b2 where b2 is Element of NAT: b2 <= b1};

:: TURING_1:funcreg 1
registration
  let a1 be natural set;
  cluster SegM a1 -> non empty finite;
end;

:: TURING_1:th 1
theorem
for b1, b2 being Element of NAT holds
   b1 in SegM b2
iff
   b1 <= b2;

:: TURING_1:th 2
theorem
for b1 being Relation-like Function-like set
for b2, b3, b4, b5, b6 being set
      st b5 <> b2
   holds (b1 +* ([b2,b3] .--> b4)) . [b5,b6] = b1 . [b5,b6];

:: TURING_1:th 3
theorem
for b1 being Relation-like Function-like set
for b2, b3, b4, b5, b6 being set
      st b6 <> b3
   holds (b1 +* ([b2,b3] .--> b4)) . [b5,b6] = b1 . [b5,b6];

:: TURING_1:th 6
theorem
for b1, b2, b3, b4 being Element of INT holds
Sum <*b1,b2,b3,b4*> = ((b1 + b2) + b3) + b4;

:: TURING_1:funcnot 4 => TURING_1:func 4
definition
  let a1 be FinSequence of NAT;
  let a2 be Element of NAT;
  func Prefix(A1,A2) -> FinSequence of INT equals
    a1 | Seg a2;
end;

:: TURING_1:def 2
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT holds
   Prefix(b1,b2) = b1 | Seg b2;

:: TURING_1:th 7
theorem
for b1, b2 being Element of NAT holds
Sum Prefix(<*b1,b2*>,1) = b1 &
 Sum Prefix(<*b1,b2*>,2) = b1 + b2;

:: TURING_1:th 8
theorem
for b1, b2, b3 being Element of NAT holds
Sum Prefix(<*b1,b2,b3*>,1) = b1 &
 Sum Prefix(<*b1,b2,b3*>,2) = b1 + b2 &
 Sum Prefix(<*b1,b2,b3*>,3) = (b1 + b2) + b3;

:: TURING_1:structnot 1 => TURING_1:struct 1
definition
  struct() TuringStr(#
    Symbols -> non empty finite set,
    States -> non empty finite set,
    Tran -> Function-like quasi_total Relation of [:the States of it,the Symbols of it:],[:the States of it,the Symbols of it,{- 1,0,1}:],
    InitS -> Element of the States of it,
    AcceptS -> Element of the States of it
  #);
end;

:: TURING_1:attrnot 1 => TURING_1:attr 1
definition
  let a1 be TuringStr;
  attr a1 is strict;
end;

:: TURING_1:exreg 1
registration
  cluster strict TuringStr;
end;

:: TURING_1:aggrnot 1 => TURING_1:aggr 1
definition
  let a1, a2 be non empty finite set;
  let a3 be Function-like quasi_total Relation of [:a2,a1:],[:a2,a1,{- 1,0,1}:];
  let a4, a5 be Element of a2;
  aggr TuringStr(#a1,a2,a3,a4,a5#) -> strict TuringStr;
end;

:: TURING_1:selnot 1 => TURING_1:sel 1
definition
  let a1 be TuringStr;
  sel the Symbols of a1 -> non empty finite set;
end;

:: TURING_1:selnot 2 => TURING_1:sel 2
definition
  let a1 be TuringStr;
  sel the States of a1 -> non empty finite set;
end;

:: TURING_1:selnot 3 => TURING_1:sel 3
definition
  let a1 be TuringStr;
  sel the Tran of a1 -> Function-like quasi_total Relation of [:the States of a1,the Symbols of a1:],[:the States of a1,the Symbols of a1,{- 1,0,1}:];
end;

:: TURING_1:selnot 4 => TURING_1:sel 4
definition
  let a1 be TuringStr;
  sel the InitS of a1 -> Element of the States of a1;
end;

:: TURING_1:selnot 5 => TURING_1:sel 5
definition
  let a1 be TuringStr;
  sel the AcceptS of a1 -> Element of the States of a1;
end;

:: TURING_1:modenot 1
definition
  let a1 be TuringStr;
  mode State of a1 is Element of the States of a1;
end;

:: TURING_1:modenot 2
definition
  let a1 be TuringStr;
  mode Tape of a1 is Element of Funcs(INT,the Symbols of a1);
end;

:: TURING_1:modenot 3
definition
  let a1 be TuringStr;
  mode Symbol of a1 is Element of the Symbols of a1;
end;

:: TURING_1:funcnot 5 => TURING_1:func 5
definition
  let a1 be TuringStr;
  let a2 be Element of Funcs(INT,the Symbols of a1);
  let a3 be integer set;
  let a4 be Element of the Symbols of a1;
  func Tape-Chg(A2,A3,A4) -> Element of Funcs(INT,the Symbols of a1) equals
    a2 +* (a3 .--> a4);
end;

:: TURING_1:def 3
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3 being integer set
for b4 being Element of the Symbols of b1 holds
   Tape-Chg(b2,b3,b4) = b2 +* (b3 .--> b4);

:: TURING_1:modenot 4
definition
  let a1 be TuringStr;
  mode All-State of a1 is Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
end;

:: TURING_1:modenot 5
definition
  let a1 be TuringStr;
  mode Tran-Source of a1 is Element of [:the States of a1,the Symbols of a1:];
end;

:: TURING_1:modenot 6
definition
  let a1 be TuringStr;
  mode Tran-Goal of a1 is Element of [:the States of a1,the Symbols of a1,{- 1,0,1}:];
end;

:: TURING_1:funcnot 6 => TURING_1:func 6
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,the Symbols of a1,{- 1,0,1}:];
  func offset A2 -> integer set equals
    a2 `3;
end;

:: TURING_1:def 4
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,the Symbols of b1,{- 1,0,1}:] holds
   offset b2 = b2 `3;

:: TURING_1:funcnot 7 => TURING_1:func 7
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
  func Head A2 -> integer set equals
    a2 `2;
end;

:: TURING_1:def 5
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
   Head b2 = b2 `2;

:: TURING_1:funcnot 8 => TURING_1:func 8
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
  func TRAN A2 -> Element of [:the States of a1,the Symbols of a1,{- 1,0,1}:] equals
    (the Tran of a1) . [a2 `1,a2 `3 . Head a2];
end;

:: TURING_1:def 6
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
   TRAN b2 = (the Tran of b1) . [b2 `1,b2 `3 . Head b2];

:: TURING_1:funcnot 9 => TURING_1:func 9
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
  func Following A2 -> Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):] equals
    [(TRAN a2) `1,(Head a2) + offset TRAN a2,Tape-Chg(a2 `3,Head a2,(TRAN a2) `2)]
    if a2 `1 <> the AcceptS of a1
    otherwise a2;
end;

:: TURING_1:def 7
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
   (b2 `1 = the AcceptS of b1 or Following b2 = [(TRAN b2) `1,(Head b2) + offset TRAN b2,Tape-Chg(b2 `3,Head b2,(TRAN b2) `2)]) &
    (b2 `1 = the AcceptS of b1 implies Following b2 = b2);

:: TURING_1:funcnot 10 => TURING_1:func 10
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
  func Computation A2 -> Function-like quasi_total Relation of NAT,[:the States of a1,INT,Funcs(INT,the Symbols of a1):] means
    it . 0 = a2 &
     (for b1 being natural set holds
        it . (b1 + 1) = Following (it . b1));
end;

:: TURING_1:def 8
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
for b3 being Function-like quasi_total Relation of NAT,[:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
      b3 = Computation b2
   iff
      b3 . 0 = b2 &
       (for b4 being natural set holds
          b3 . (b4 + 1) = Following (b3 . b4));

:: TURING_1:th 9
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
      st b2 `1 = the AcceptS of b1
   holds b2 = Following b2;

:: TURING_1:th 10
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
   (Computation b2) . 0 = b2;

:: TURING_1:th 11
theorem
for b1 being Element of NAT
for b2 being TuringStr
for b3 being Element of [:the States of b2,INT,Funcs(INT,the Symbols of b2):] holds
   (Computation b3) . (b1 + 1) = Following ((Computation b3) . b1);

:: TURING_1:th 12
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
   (Computation b2) . 1 = Following b2;

:: TURING_1:th 13
theorem
for b1, b2 being Element of NAT
for b3 being TuringStr
for b4 being Element of [:the States of b3,INT,Funcs(INT,the Symbols of b3):] holds
   (Computation b4) . (b1 + b2) = (Computation ((Computation b4) . b1)) . b2;

:: TURING_1:th 14
theorem
for b1, b2 being Element of NAT
for b3 being TuringStr
for b4 being Element of [:the States of b3,INT,Funcs(INT,the Symbols of b3):]
      st b1 <= b2 &
         Following ((Computation b4) . b1) = (Computation b4) . b1
   holds (Computation b4) . b2 = (Computation b4) . b1;

:: TURING_1:th 15
theorem
for b1, b2 being Element of NAT
for b3 being TuringStr
for b4 being Element of [:the States of b3,INT,Funcs(INT,the Symbols of b3):]
      st b1 <= b2 & ((Computation b4) . b1) `1 = the AcceptS of b3
   holds (Computation b4) . b2 = (Computation b4) . b1;

:: TURING_1:attrnot 2 => TURING_1:attr 2
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
  attr a2 is Accept-Halt means
    ex b1 being Element of NAT st
       ((Computation a2) . b1) `1 = the AcceptS of a1;
end;

:: TURING_1:dfs 9
definiens
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
To prove
     a2 is Accept-Halt
it is sufficient to prove
  thus ex b1 being Element of NAT st
       ((Computation a2) . b1) `1 = the AcceptS of a1;

:: TURING_1:def 9
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
      b2 is Accept-Halt(b1)
   iff
      ex b3 being Element of NAT st
         ((Computation b2) . b3) `1 = the AcceptS of b1;

:: TURING_1:funcnot 11 => TURING_1:func 11
definition
  let a1 be TuringStr;
  let a2 be Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):];
  assume a2 is Accept-Halt(a1);
  func Result A2 -> Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):] means
    ex b1 being Element of NAT st
       it = (Computation a2) . b1 & ((Computation a2) . b1) `1 = the AcceptS of a1;
end;

:: TURING_1:def 10
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
   st b2 is Accept-Halt(b1)
for b3 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):] holds
      b3 = Result b2
   iff
      ex b4 being Element of NAT st
         b3 = (Computation b2) . b4 & ((Computation b2) . b4) `1 = the AcceptS of b1;

:: TURING_1:th 16
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
      st b2 is Accept-Halt(b1)
   holds ex b3 being Element of NAT st
      ((Computation b2) . b3) `1 = the AcceptS of b1 &
       Result b2 = (Computation b2) . b3 &
       (for b4 being Element of NAT
             st b4 < b3
          holds ((Computation b2) . b4) `1 <> the AcceptS of b1);

:: TURING_1:funcnot 12 => TURING_1:func 12
definition
  let a1, a2 be non empty set;
  let a3 be set;
  assume a3 in a2;
  func id(A1,A2,A3) -> Function-like quasi_total Relation of a1,[:a1,a2:] means
    for b1 being Element of a1 holds
       it . b1 = [b1,a3];
end;

:: TURING_1:def 11
theorem
for b1, b2 being non empty set
for b3 being set
   st b3 in b2
for b4 being Function-like quasi_total Relation of b1,[:b1,b2:] holds
      b4 = id(b1,b2,b3)
   iff
      for b5 being Element of b1 holds
         b4 . b5 = [b5,b3];

:: TURING_1:funcnot 13 => TURING_1:func 13
definition
  func Sum_Tran -> Function-like quasi_total Relation of [:SegM 5,{0,1}:],[:SegM 5,{0,1},{- 1,0,1}:] equals
    (((((((((id([:SegM 5,{0,1}:],{- 1,0,1},0)) +* ([0,0] .--> [0,0,1])) +* ([0,1] .--> [1,0,1])) +* ([1,1] .--> [1,1,1])) +* ([1,0] .--> [2,1,1])) +* ([2,1] .--> [2,1,1])) +* ([2,0] .--> [3,0,- 1])) +* ([3,1] .--> [4,0,- 1])) +* ([4,1] .--> [4,1,- 1])) +* ([4,0] .--> [5,0,0]);
end;

:: TURING_1:def 12
theorem
Sum_Tran = (((((((((id([:SegM 5,{0,1}:],{- 1,0,1},0)) +* ([0,0] .--> [0,0,1])) +* ([0,1] .--> [1,0,1])) +* ([1,1] .--> [1,1,1])) +* ([1,0] .--> [2,1,1])) +* ([2,1] .--> [2,1,1])) +* ([2,0] .--> [3,0,- 1])) +* ([3,1] .--> [4,0,- 1])) +* ([4,1] .--> [4,1,- 1])) +* ([4,0] .--> [5,0,0]);

:: TURING_1:th 17
theorem
Sum_Tran . [0,0] = [0,0,1] &
 Sum_Tran . [0,1] = [1,0,1] &
 Sum_Tran . [1,1] = [1,1,1] &
 Sum_Tran . [1,0] = [2,1,1] &
 Sum_Tran . [2,1] = [2,1,1] &
 Sum_Tran . [2,0] = [3,0,- 1] &
 Sum_Tran . [3,1] = [4,0,- 1] &
 Sum_Tran . [4,1] = [4,1,- 1] &
 Sum_Tran . [4,0] = [5,0,0];

:: TURING_1:prednot 1 => TURING_1:pred 1
definition
  let a1 be TuringStr;
  let a2 be Element of Funcs(INT,the Symbols of a1);
  let a3, a4 be integer set;
  pred A2 is_1_between A3,A4 means
    a2 . a3 = 0 &
     a2 . a4 = 0 &
     (for b1 being integer set
           st a3 < b1 & b1 < a4
        holds a2 . b1 = 1);
end;

:: TURING_1:dfs 13
definiens
  let a1 be TuringStr;
  let a2 be Element of Funcs(INT,the Symbols of a1);
  let a3, a4 be integer set;
To prove
     a2 is_1_between a3,a4
it is sufficient to prove
  thus a2 . a3 = 0 &
     a2 . a4 = 0 &
     (for b1 being integer set
           st a3 < b1 & b1 < a4
        holds a2 . b1 = 1);

:: TURING_1:def 13
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3, b4 being integer set holds
   b2 is_1_between b3,b4
iff
   b2 . b3 = 0 &
    b2 . b4 = 0 &
    (for b5 being integer set
          st b3 < b5 & b5 < b4
       holds b2 . b5 = 1);

:: TURING_1:prednot 2 => TURING_1:pred 2
definition
  let a1 be FinSequence of NAT;
  let a2 be TuringStr;
  let a3 be Element of Funcs(INT,the Symbols of a2);
  pred A3 storeData A1 means
    for b1 being Element of NAT
          st 1 <= b1 & b1 < len a1
       holds a3 is_1_between (Sum Prefix(a1,b1)) + (2 * (b1 - 1)),(Sum Prefix(a1,b1 + 1)) + (2 * b1);
end;

:: TURING_1:dfs 14
definiens
  let a1 be FinSequence of NAT;
  let a2 be TuringStr;
  let a3 be Element of Funcs(INT,the Symbols of a2);
To prove
     a3 storeData a1
it is sufficient to prove
  thus for b1 being Element of NAT
          st 1 <= b1 & b1 < len a1
       holds a3 is_1_between (Sum Prefix(a1,b1)) + (2 * (b1 - 1)),(Sum Prefix(a1,b1 + 1)) + (2 * b1);

:: TURING_1:def 14
theorem
for b1 being FinSequence of NAT
for b2 being TuringStr
for b3 being Element of Funcs(INT,the Symbols of b2) holds
      b3 storeData b1
   iff
      for b4 being Element of NAT
            st 1 <= b4 & b4 < len b1
         holds b3 is_1_between (Sum Prefix(b1,b4)) + (2 * (b4 - 1)),(Sum Prefix(b1,b4 + 1)) + (2 * b4);

:: TURING_1:th 18
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3, b4 being Element of NAT
      st b2 storeData <*b3,b4*>
   holds b2 is_1_between b3,(b3 + b4) + 2;

:: TURING_1:th 19
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3, b4 being Element of NAT
      st b2 is_1_between b3,(b3 + b4) + 2
   holds b2 storeData <*b3,b4*>;

:: TURING_1:th 20
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3, b4 being Element of NAT
      st b2 storeData <*b3,b4*>
   holds b2 . b3 = 0 &
    b2 . ((b3 + b4) + 2) = 0 &
    (for b5 being integer set
          st b3 < b5 & b5 < (b3 + b4) + 2
       holds b2 . b5 = 1);

:: TURING_1:th 21
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3, b4, b5 being Element of NAT
      st b2 storeData <*b3,b4,b5*>
   holds b2 is_1_between b3,(b3 + b4) + 2 &
    b2 is_1_between (b3 + b4) + 2,((b3 + b4) + b5) + 4;

:: TURING_1:th 22
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3, b4, b5 being Element of NAT
      st b2 storeData <*b3,b4,b5*>
   holds b2 . b3 = 0 &
    b2 . ((b3 + b4) + 2) = 0 &
    b2 . (((b3 + b4) + b5) + 4) = 0 &
    (for b6 being integer set
          st b3 < b6 & b6 < (b3 + b4) + 2
       holds b2 . b6 = 1) &
    (for b6 being integer set
          st (b3 + b4) + 2 < b6 & b6 < ((b3 + b4) + b5) + 4
       holds b2 . b6 = 1);

:: TURING_1:th 23
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
      st 1 <= len b1
   holds Sum Prefix(<*b2*> ^ b1,1) = b2 &
    Sum Prefix(<*b2*> ^ b1,2) = b2 + (b1 /. 1);

:: TURING_1:th 24
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
      st 3 <= len b1
   holds Sum Prefix(<*b2*> ^ b1,1) = b2 &
    Sum Prefix(<*b2*> ^ b1,2) = b2 + (b1 /. 1) &
    Sum Prefix(<*b2*> ^ b1,3) = (b2 + (b1 /. 1)) + (b1 /. 2) &
    Sum Prefix(<*b2*> ^ b1,4) = ((b2 + (b1 /. 1)) + (b1 /. 2)) + (b1 /. 3);

:: TURING_1:th 25
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3 being Element of NAT
for b4 being FinSequence of NAT
      st 1 <= len b4 & b2 storeData <*b3*> ^ b4
   holds b2 is_1_between b3,(b3 + (b4 /. 1)) + 2;

:: TURING_1:th 26
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3 being Element of NAT
for b4 being FinSequence of NAT
      st 3 <= len b4 & b2 storeData <*b3*> ^ b4
   holds b2 is_1_between b3,(b3 + (b4 /. 1)) + 2 &
    b2 is_1_between (b3 + (b4 /. 1)) + 2,((b3 + (b4 /. 1)) + (b4 /. 2)) + 4 &
    b2 is_1_between ((b3 + (b4 /. 1)) + (b4 /. 2)) + 4,(((b3 + (b4 /. 1)) + (b4 /. 2)) + (b4 /. 3)) + 6;

:: TURING_1:funcnot 14 => TURING_1:func 14
definition
  func SumTuring -> strict TuringStr means
    the Symbols of it = {0,1} & the States of it = SegM 5 & the Tran of it = Sum_Tran & the InitS of it = 0 & the AcceptS of it = 5;
end;

:: TURING_1:def 15
theorem
for b1 being strict TuringStr holds
      b1 = SumTuring
   iff
      the Symbols of b1 = {0,1} & the States of b1 = SegM 5 & the Tran of b1 = Sum_Tran & the InitS of b1 = 0 & the AcceptS of b1 = 5;

:: TURING_1:th 28
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3 being integer set
for b4 being Element of the Symbols of b1
      st b2 . b3 = b4
   holds Tape-Chg(b2,b3,b4) = b2;

:: TURING_1:th 29
theorem
for b1 being TuringStr
for b2 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
for b3, b4, b5 being set
      st b2 = [b3,b4,b5] & b3 <> the AcceptS of b1
   holds Following b2 = [(TRAN b2) `1,(Head b2) + offset TRAN b2,Tape-Chg(b2 `3,Head b2,(TRAN b2) `2)];

:: TURING_1:th 30
theorem
for b1 being TuringStr
for b2 being Element of Funcs(INT,the Symbols of b1)
for b3 being integer set
for b4 being Element of the Symbols of b1
for b5 being set holds
   (Tape-Chg(b2,b3,b4)) . b3 = b4 &
    (b5 = b3 or (Tape-Chg(b2,b3,b4)) . b5 = b2 . b5);

:: TURING_1:th 31
theorem
for b1 being Element of [:the States of SumTuring,INT,Funcs(INT,the Symbols of SumTuring):]
for b2 being Element of Funcs(INT,the Symbols of SumTuring)
for b3, b4, b5 being Element of NAT
      st b1 = [0,b3,b2] & b2 storeData <*b3,b4,b5*>
   holds b1 is Accept-Halt(SumTuring) &
    (Result b1) `2 = 1 + b3 &
    (Result b1) `3 storeData <*1 + b3,b4 + b5*>;

:: TURING_1:prednot 3 => TURING_1:pred 3
definition
  let a1 be TuringStr;
  let a2 be Relation-like Function-like set;
  pred A1 computes A2 means
    for b1 being Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):]
    for b2 being Element of Funcs(INT,the Symbols of a1)
    for b3 being Element of NAT
    for b4 being FinSequence of NAT
          st b4 in proj1 a2 & b1 = [the InitS of a1,b3,b2] & b2 storeData <*b3*> ^ b4
       holds b1 is Accept-Halt(a1) &
        (ex b5, b6 being Element of NAT st
           (Result b1) `2 = b5 &
            b6 = a2 . b4 &
            (Result b1) `3 storeData <*b5*> ^ <*b6*>);
end;

:: TURING_1:dfs 16
definiens
  let a1 be TuringStr;
  let a2 be Relation-like Function-like set;
To prove
     a1 computes a2
it is sufficient to prove
  thus for b1 being Element of [:the States of a1,INT,Funcs(INT,the Symbols of a1):]
    for b2 being Element of Funcs(INT,the Symbols of a1)
    for b3 being Element of NAT
    for b4 being FinSequence of NAT
          st b4 in proj1 a2 & b1 = [the InitS of a1,b3,b2] & b2 storeData <*b3*> ^ b4
       holds b1 is Accept-Halt(a1) &
        (ex b5, b6 being Element of NAT st
           (Result b1) `2 = b5 &
            b6 = a2 . b4 &
            (Result b1) `3 storeData <*b5*> ^ <*b6*>);

:: TURING_1:def 16
theorem
for b1 being TuringStr
for b2 being Relation-like Function-like set holds
      b1 computes b2
   iff
      for b3 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
      for b4 being Element of Funcs(INT,the Symbols of b1)
      for b5 being Element of NAT
      for b6 being FinSequence of NAT
            st b6 in proj1 b2 & b3 = [the InitS of b1,b5,b4] & b4 storeData <*b5*> ^ b6
         holds b3 is Accept-Halt(b1) &
          (ex b7, b8 being Element of NAT st
             (Result b3) `2 = b7 &
              b8 = b2 . b6 &
              (Result b3) `3 storeData <*b7*> ^ <*b8*>);

:: TURING_1:th 32
theorem
proj1 [+] c= 2 -tuples_on NAT;

:: TURING_1:th 33
theorem
SumTuring computes [+];

:: TURING_1:funcnot 15 => TURING_1:func 15
definition
  func Succ_Tran -> Function-like quasi_total Relation of [:SegM 4,{0,1}:],[:SegM 4,{0,1},{- 1,0,1}:] equals
    (((((((id([:SegM 4,{0,1}:],{- 1,0,1},0)) +* ([0,0] .--> [1,0,1])) +* ([1,1] .--> [1,1,1])) +* ([1,0] .--> [2,1,1])) +* ([2,0] .--> [3,0,- 1])) +* ([2,1] .--> [3,0,- 1])) +* ([3,1] .--> [3,1,- 1])) +* ([3,0] .--> [4,0,0]);
end;

:: TURING_1:def 17
theorem
Succ_Tran = (((((((id([:SegM 4,{0,1}:],{- 1,0,1},0)) +* ([0,0] .--> [1,0,1])) +* ([1,1] .--> [1,1,1])) +* ([1,0] .--> [2,1,1])) +* ([2,0] .--> [3,0,- 1])) +* ([2,1] .--> [3,0,- 1])) +* ([3,1] .--> [3,1,- 1])) +* ([3,0] .--> [4,0,0]);

:: TURING_1:th 34
theorem
Succ_Tran . [0,0] = [1,0,1] &
 Succ_Tran . [1,1] = [1,1,1] &
 Succ_Tran . [1,0] = [2,1,1] &
 Succ_Tran . [2,0] = [3,0,- 1] &
 Succ_Tran . [2,1] = [3,0,- 1] &
 Succ_Tran . [3,1] = [3,1,- 1] &
 Succ_Tran . [3,0] = [4,0,0];

:: TURING_1:funcnot 16 => TURING_1:func 16
definition
  func SuccTuring -> strict TuringStr means
    the Symbols of it = {0,1} & the States of it = SegM 4 & the Tran of it = Succ_Tran & the InitS of it = 0 & the AcceptS of it = 4;
end;

:: TURING_1:def 18
theorem
for b1 being strict TuringStr holds
      b1 = SuccTuring
   iff
      the Symbols of b1 = {0,1} & the States of b1 = SegM 4 & the Tran of b1 = Succ_Tran & the InitS of b1 = 0 & the AcceptS of b1 = 4;

:: TURING_1:th 36
theorem
for b1 being Element of [:the States of SuccTuring,INT,Funcs(INT,the Symbols of SuccTuring):]
for b2 being Element of Funcs(INT,the Symbols of SuccTuring)
for b3, b4 being Element of NAT
      st b1 = [0,b3,b2] & b2 storeData <*b3,b4*>
   holds b1 is Accept-Halt(SuccTuring) &
    (Result b1) `2 = b3 &
    (Result b1) `3 storeData <*b3,b4 + 1*>;

:: TURING_1:th 37
theorem
SuccTuring computes 1 succ 1;

:: TURING_1:funcnot 17 => TURING_1:func 17
definition
  func Zero_Tran -> Function-like quasi_total Relation of [:SegM 4,{0,1}:],[:SegM 4,{0,1},{- 1,0,1}:] equals
    (((((id([:SegM 4,{0,1}:],{- 1,0,1},1)) +* ([0,0] .--> [1,0,1])) +* ([1,1] .--> [2,1,1])) +* ([2,0] .--> [3,0,- 1])) +* ([2,1] .--> [3,0,- 1])) +* ([3,1] .--> [4,1,- 1]);
end;

:: TURING_1:def 19
theorem
Zero_Tran = (((((id([:SegM 4,{0,1}:],{- 1,0,1},1)) +* ([0,0] .--> [1,0,1])) +* ([1,1] .--> [2,1,1])) +* ([2,0] .--> [3,0,- 1])) +* ([2,1] .--> [3,0,- 1])) +* ([3,1] .--> [4,1,- 1]);

:: TURING_1:th 38
theorem
Zero_Tran . [0,0] = [1,0,1] &
 Zero_Tran . [1,1] = [2,1,1] &
 Zero_Tran . [2,0] = [3,0,- 1] &
 Zero_Tran . [2,1] = [3,0,- 1] &
 Zero_Tran . [3,1] = [4,1,- 1];

:: TURING_1:funcnot 18 => TURING_1:func 18
definition
  func ZeroTuring -> strict TuringStr means
    the Symbols of it = {0,1} & the States of it = SegM 4 & the Tran of it = Zero_Tran & the InitS of it = 0 & the AcceptS of it = 4;
end;

:: TURING_1:def 20
theorem
for b1 being strict TuringStr holds
      b1 = ZeroTuring
   iff
      the Symbols of b1 = {0,1} & the States of b1 = SegM 4 & the Tran of b1 = Zero_Tran & the InitS of b1 = 0 & the AcceptS of b1 = 4;

:: TURING_1:th 39
theorem
for b1 being Element of [:the States of ZeroTuring,INT,Funcs(INT,the Symbols of ZeroTuring):]
for b2 being Element of Funcs(INT,the Symbols of ZeroTuring)
for b3 being Element of NAT
for b4 being FinSequence of NAT
      st 1 <= len b4 & b1 = [0,b3,b2] & b2 storeData <*b3*> ^ b4
   holds b1 is Accept-Halt(ZeroTuring) &
    (Result b1) `2 = b3 &
    (Result b1) `3 storeData <*b3,0*>;

:: TURING_1:th 40
theorem
for b1 being Element of NAT
      st 1 <= b1
   holds ZeroTuring computes b1 const 0;

:: TURING_1:funcnot 19 => TURING_1:func 19
definition
  func U3(n)Tran -> Function-like quasi_total Relation of [:SegM 3,{0,1}:],[:SegM 3,{0,1},{- 1,0,1}:] equals
    (((((id([:SegM 3,{0,1}:],{- 1,0,1},0)) +* ([0,0] .--> [1,0,1])) +* ([1,1] .--> [1,0,1])) +* ([1,0] .--> [2,0,1])) +* ([2,1] .--> [2,0,1])) +* ([2,0] .--> [3,0,0]);
end;

:: TURING_1:def 21
theorem
U3(n)Tran = (((((id([:SegM 3,{0,1}:],{- 1,0,1},0)) +* ([0,0] .--> [1,0,1])) +* ([1,1] .--> [1,0,1])) +* ([1,0] .--> [2,0,1])) +* ([2,1] .--> [2,0,1])) +* ([2,0] .--> [3,0,0]);

:: TURING_1:th 41
theorem
U3(n)Tran . [0,0] = [1,0,1] &
 U3(n)Tran . [1,1] = [1,0,1] &
 U3(n)Tran . [1,0] = [2,0,1] &
 U3(n)Tran . [2,1] = [2,0,1] &
 U3(n)Tran . [2,0] = [3,0,0];

:: TURING_1:funcnot 20 => TURING_1:func 20
definition
  func U3(n)Turing -> strict TuringStr means
    the Symbols of it = {0,1} & the States of it = SegM 3 & the Tran of it = U3(n)Tran & the InitS of it = 0 & the AcceptS of it = 3;
end;

:: TURING_1:def 22
theorem
for b1 being strict TuringStr holds
      b1 = U3(n)Turing
   iff
      the Symbols of b1 = {0,1} & the States of b1 = SegM 3 & the Tran of b1 = U3(n)Tran & the InitS of b1 = 0 & the AcceptS of b1 = 3;

:: TURING_1:th 42
theorem
for b1 being Element of [:the States of U3(n)Turing,INT,Funcs(INT,the Symbols of U3(n)Turing):]
for b2 being Element of Funcs(INT,the Symbols of U3(n)Turing)
for b3 being Element of NAT
for b4 being FinSequence of NAT
      st 3 <= len b4 & b1 = [0,b3,b2] & b2 storeData <*b3*> ^ b4
   holds b1 is Accept-Halt(U3(n)Turing) &
    (Result b1) `2 = ((b3 + (b4 /. 1)) + (b4 /. 2)) + 4 &
    (Result b1) `3 storeData <*((b3 + (b4 /. 1)) + (b4 /. 2)) + 4,b4 /. 3*>;

:: TURING_1:th 43
theorem
for b1 being Element of NAT
      st 3 <= b1
   holds U3(n)Turing computes b1 proj 3;

:: TURING_1:funcnot 21 => TURING_1:func 21
definition
  let a1, a2 be TuringStr;
  func UnionSt(A1,A2) -> non empty finite set equals
    [:the States of a1,{the InitS of a2}:] \/ [:{the AcceptS of a1},the States of a2:];
end;

:: TURING_1:def 23
theorem
for b1, b2 being TuringStr holds
UnionSt(b1,b2) = [:the States of b1,{the InitS of b2}:] \/ [:{the AcceptS of b1},the States of b2:];

:: TURING_1:th 44
theorem
for b1, b2 being TuringStr holds
[the InitS of b1,the InitS of b2] in UnionSt(b1,b2) &
 [the AcceptS of b1,the AcceptS of b2] in UnionSt(b1,b2);

:: TURING_1:th 45
theorem
for b1, b2 being TuringStr
for b3 being Element of the States of b1 holds
   [b3,the InitS of b2] in UnionSt(b1,b2);

:: TURING_1:th 46
theorem
for b1, b2 being TuringStr
for b3 being Element of the States of b2 holds
   [the AcceptS of b1,b3] in UnionSt(b1,b2);

:: TURING_1:th 47
theorem
for b1, b2 being TuringStr
for b3 being Element of UnionSt(b1,b2) holds
   ex b4 being Element of the States of b1 st
      ex b5 being Element of the States of b2 st
         b3 = [b4,b5];

:: TURING_1:funcnot 22 => TURING_1:func 22
definition
  let a1, a2 be TuringStr;
  let a3 be Element of [:the States of a1,the Symbols of a1,{- 1,0,1}:];
  func FirstTuringTran(A1,A2,A3) -> Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2,{- 1,0,1}:] equals
    [[a3 `1,the InitS of a2],a3 `2,a3 `3];
end;

:: TURING_1:def 24
theorem
for b1, b2 being TuringStr
for b3 being Element of [:the States of b1,the Symbols of b1,{- 1,0,1}:] holds
   FirstTuringTran(b1,b2,b3) = [[b3 `1,the InitS of b2],b3 `2,b3 `3];

:: TURING_1:funcnot 23 => TURING_1:func 23
definition
  let a1, a2 be TuringStr;
  let a3 be Element of [:the States of a2,the Symbols of a2,{- 1,0,1}:];
  func SecondTuringTran(A1,A2,A3) -> Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2,{- 1,0,1}:] equals
    [[the AcceptS of a1,a3 `1],a3 `2,a3 `3];
end;

:: TURING_1:def 25
theorem
for b1, b2 being TuringStr
for b3 being Element of [:the States of b2,the Symbols of b2,{- 1,0,1}:] holds
   SecondTuringTran(b1,b2,b3) = [[the AcceptS of b1,b3 `1],b3 `2,b3 `3];

:: TURING_1:funcnot 24 => TURING_1:func 24
definition
  let a1, a2 be TuringStr;
  let a3 be Element of UnionSt(a1,a2);
  redefine func a3 `1 -> Element of the States of a1;
end;

:: TURING_1:funcnot 25 => TURING_1:func 25
definition
  let a1, a2 be TuringStr;
  let a3 be Element of UnionSt(a1,a2);
  redefine func a3 `2 -> Element of the States of a2;
end;

:: TURING_1:funcnot 26 => TURING_1:func 26
definition
  let a1, a2 be TuringStr;
  let a3 be Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2:];
  func FirstTuringState A3 -> Element of the States of a1 equals
    a3 `1 `1;
end;

:: TURING_1:def 26
theorem
for b1, b2 being TuringStr
for b3 being Element of [:UnionSt(b1,b2),(the Symbols of b1) \/ the Symbols of b2:] holds
   FirstTuringState b3 = b3 `1 `1;

:: TURING_1:funcnot 27 => TURING_1:func 27
definition
  let a1, a2 be TuringStr;
  let a3 be Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2:];
  func SecondTuringState A3 -> Element of the States of a2 equals
    a3 `1 `2;
end;

:: TURING_1:def 27
theorem
for b1, b2 being TuringStr
for b3 being Element of [:UnionSt(b1,b2),(the Symbols of b1) \/ the Symbols of b2:] holds
   SecondTuringState b3 = b3 `1 `2;

:: TURING_1:funcnot 28 => TURING_1:func 28
definition
  let a1, a2, a3 be non empty set;
  let a4 be Element of [:a1,a2 \/ a3:];
  assume ex b1 being set st
       ex b2 being Element of a2 st
          a4 = [b1,b2];
  func FirstTuringSymbol A4 -> Element of a2 equals
    a4 `2;
end;

:: TURING_1:def 28
theorem
for b1, b2, b3 being non empty set
for b4 being Element of [:b1,b2 \/ b3:]
      st ex b5 being set st
           ex b6 being Element of b2 st
              b4 = [b5,b6]
   holds FirstTuringSymbol b4 = b4 `2;

:: TURING_1:funcnot 29 => TURING_1:func 29
definition
  let a1, a2, a3 be non empty set;
  let a4 be Element of [:a1,a2 \/ a3:];
  assume ex b1 being set st
       ex b2 being Element of a3 st
          a4 = [b1,b2];
  func SecondTuringSymbol A4 -> Element of a3 equals
    a4 `2;
end;

:: TURING_1:def 29
theorem
for b1, b2, b3 being non empty set
for b4 being Element of [:b1,b2 \/ b3:]
      st ex b5 being set st
           ex b6 being Element of b3 st
              b4 = [b5,b6]
   holds SecondTuringSymbol b4 = b4 `2;

:: TURING_1:funcnot 30 => TURING_1:func 30
definition
  let a1, a2 be TuringStr;
  let a3 be Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2:];
  func Uniontran(A1,A2,A3) -> Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2,{- 1,0,1}:] equals
    FirstTuringTran(a1,a2,(the Tran of a1) . [FirstTuringState a3,FirstTuringSymbol a3])
    if ex b1 being Element of the States of a1 st
       ex b2 being Element of the Symbols of a1 st
          a3 = [[b1,the InitS of a2],b2] &
           b1 <> the AcceptS of a1,
SecondTuringTran(a1,a2,(the Tran of a2) . [SecondTuringState a3,SecondTuringSymbol a3])
    if ex b1 being Element of the States of a2 st
       ex b2 being Element of the Symbols of a2 st
          a3 = [[the AcceptS of a1,b1],b2]
    otherwise [a3 `1,a3 `2,- 1];
end;

:: TURING_1:def 30
theorem
for b1, b2 being TuringStr
for b3 being Element of [:UnionSt(b1,b2),(the Symbols of b1) \/ the Symbols of b2:] holds
   (for b4 being Element of the States of b1
    for b5 being Element of the Symbols of b1
          st b3 = [[b4,the InitS of b2],b5]
       holds b4 = the AcceptS of b1 or Uniontran(b1,b2,b3) = FirstTuringTran(b1,b2,(the Tran of b1) . [FirstTuringState b3,FirstTuringSymbol b3])) &
    (for b4 being Element of the States of b2
    for b5 being Element of the Symbols of b2 holds
       b3 <> [[the AcceptS of b1,b4],b5] or Uniontran(b1,b2,b3) = SecondTuringTran(b1,b2,(the Tran of b2) . [SecondTuringState b3,SecondTuringSymbol b3])) &
    ((for b4 being Element of the States of b1
     for b5 being Element of the Symbols of b1
           st b3 = [[b4,the InitS of b2],b5]
        holds b4 = the AcceptS of b1) &
     (for b4 being Element of the States of b2
     for b5 being Element of the Symbols of b2 holds
        b3 <> [[the AcceptS of b1,b4],b5]) implies Uniontran(b1,b2,b3) = [b3 `1,b3 `2,- 1]);

:: TURING_1:funcnot 31 => TURING_1:func 31
definition
  let a1, a2 be TuringStr;
  func UnionTran(A1,A2) -> Function-like quasi_total Relation of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2:],[:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2,{- 1,0,1}:] means
    for b1 being Element of [:UnionSt(a1,a2),(the Symbols of a1) \/ the Symbols of a2:] holds
       it . b1 = Uniontran(a1,a2,b1);
end;

:: TURING_1:def 31
theorem
for b1, b2 being TuringStr
for b3 being Function-like quasi_total Relation of [:UnionSt(b1,b2),(the Symbols of b1) \/ the Symbols of b2:],[:UnionSt(b1,b2),(the Symbols of b1) \/ the Symbols of b2,{- 1,0,1}:] holds
      b3 = UnionTran(b1,b2)
   iff
      for b4 being Element of [:UnionSt(b1,b2),(the Symbols of b1) \/ the Symbols of b2:] holds
         b3 . b4 = Uniontran(b1,b2,b4);

:: TURING_1:funcnot 32 => TURING_1:func 32
definition
  let a1, a2 be TuringStr;
  func A1 ';' A2 -> strict TuringStr means
    the Symbols of it = (the Symbols of a1) \/ the Symbols of a2 &
     the States of it = UnionSt(a1,a2) &
     the Tran of it = UnionTran(a1,a2) &
     the InitS of it = [the InitS of a1,the InitS of a2] &
     the AcceptS of it = [the AcceptS of a1,the AcceptS of a2];
end;

:: TURING_1:def 32
theorem
for b1, b2 being TuringStr
for b3 being strict TuringStr holds
      b3 = b1 ';' b2
   iff
      the Symbols of b3 = (the Symbols of b1) \/ the Symbols of b2 &
       the States of b3 = UnionSt(b1,b2) &
       the Tran of b3 = UnionTran(b1,b2) &
       the InitS of b3 = [the InitS of b1,the InitS of b2] &
       the AcceptS of b3 = [the AcceptS of b1,the AcceptS of b2];

:: TURING_1:th 48
theorem
for b1, b2 being TuringStr
for b3 being Element of [:the States of b1,the Symbols of b1,{- 1,0,1}:]
for b4 being Element of the States of b1
for b5 being Element of the Symbols of b1
      st b4 <> the AcceptS of b1 & b3 = (the Tran of b1) . [b4,b5]
   holds (the Tran of b1 ';' b2) . [[b4,the InitS of b2],b5] = [[b3 `1,the InitS of b2],b3 `2,b3 `3];

:: TURING_1:th 49
theorem
for b1, b2 being TuringStr
for b3 being Element of [:the States of b2,the Symbols of b2,{- 1,0,1}:]
for b4 being Element of the States of b2
for b5 being Element of the Symbols of b2
      st b3 = (the Tran of b2) . [b4,b5]
   holds (the Tran of b1 ';' b2) . [[the AcceptS of b1,b4],b5] = [[the AcceptS of b1,b3 `1],b3 `2,b3 `3];

:: TURING_1:th 50
theorem
for b1, b2 being TuringStr
for b3 being Element of [:the States of b1,INT,Funcs(INT,the Symbols of b1):]
for b4 being Element of NAT
for b5 being Element of Funcs(INT,the Symbols of b1)
for b6 being Element of [:the States of b2,INT,Funcs(INT,the Symbols of b2):]
for b7 being Element of [:the States of b1 ';' b2,INT,Funcs(INT,the Symbols of b1 ';' b2):]
      st b3 is Accept-Halt(b1) &
         b3 = [the InitS of b1,b4,b5] &
         b6 is Accept-Halt(b2) &
         b6 = [the InitS of b2,(Result b3) `2,(Result b3) `3] &
         b7 = [the InitS of b1 ';' b2,b4,b5]
   holds b7 is Accept-Halt(b1 ';' b2) & (Result b7) `2 = (Result b6) `2 & (Result b7) `3 = (Result b6) `3;

:: TURING_1:th 51
theorem
for b1, b2 being TuringStr
for b3 being Element of Funcs(INT,the Symbols of b1)
      st the Symbols of b1 = the Symbols of b2
   holds b3 is Element of Funcs(INT,the Symbols of b1 ';' b2);

:: TURING_1:th 52
theorem
for b1, b2 being TuringStr
for b3 being Element of Funcs(INT,the Symbols of b1 ';' b2)
      st the Symbols of b1 = the Symbols of b2
   holds b3 is Element of Funcs(INT,the Symbols of b1) & b3 is Element of Funcs(INT,the Symbols of b2);

:: TURING_1:th 53
theorem
for b1 being FinSequence of NAT
for b2, b3 being TuringStr
for b4 being Element of Funcs(INT,the Symbols of b2)
for b5 being Element of Funcs(INT,the Symbols of b3)
      st b4 = b5 & b4 storeData b1
   holds b5 storeData b1;

:: TURING_1:th 54
theorem
for b1 being Element of [:the States of ZeroTuring ';' SuccTuring,INT,Funcs(INT,the Symbols of ZeroTuring ';' SuccTuring):]
for b2 being Element of Funcs(INT,the Symbols of ZeroTuring)
for b3, b4 being Element of NAT
      st b1 = [[0,0],b3,b2] &
         b2 storeData <*b3,b4*>
   holds b1 is Accept-Halt(ZeroTuring ';' SuccTuring) &
    (Result b1) `2 = b3 &
    (Result b1) `3 storeData <*b3,1*>;