[syllabus] | [lecture notes] | [HW1-6,Q1] | [HW7-10,Q2,F] | [project]

[simulators/parsers] | [language definitions] | [automata definitions] | [computable definitions]

Contents

  • Turing Machine, TM simulator
  • Nondeterministic Turing Machine, NTM simulator
  • Deterministic Finite Automata, DFA simulator
  • Nondeterministic Finite Automata, NFA simulator
  • Myhill-Nerode minimization of a DFA
  • Quine McClusky minimization of sums of products
  • CYK parser for CFG's doing H&U simplification
  • Other Links
  • The files referenced on this page are all available on UMBC9 (gl)
    for copying to your directory using a command such as:
      cp  /afs/umbc.edu/users/s/q/squire/pub/download/tm.cpp  .
    

    Turing Machine, TM simulator

     
      The C++ source code is tm.cpp
      Sample input is add.tm
      Sample output is add.chk
    
      command line:   tm < add.tm > add.chk
    
      This simulator works as a language recognizer and accepts or
      rejects the contents of the input tape. (final mode)
    
      This simulator also works as a function computer using the
      initial contents of the tape as the input and the final
      contents of the tape as the output. (halt mode)
    
    
     A Turing machine M = (Q, Sigma, Gamma, delta, q0, B, F)
       where Q is finite set of states including q0
             Sigma is a finite set of input symbols not including B
             Gamma is a finite set of tape symbols including Sigma and B
             delta is a transitions mapping Q X Gamma to Q X Gamma X {L,R,N}
             q0 is the initial state
             B is blank tape symbol
             F is a finite set of final states
               
     Input Conventions:
    
     The file name extension is typically  .tm
     free form plain text input file
     typical execution is  tm < your_input.tm > your_output.out
    
     A comment line has "// " as the first three characters
     A line may end with a comment using whitespace "//"
     Anything after whitespace after last expected input is a comment
    
     There are only a few keywords:
                     start, final, halt, trace, limit, enddef and tape
     any line not starting with these keywords is a transition
     'enddef' is only needed when more than one 'tape' is to be read
     only 'tape' lines may follow an 'enddef' line
    
     there is no such thing as a continuation line.
    
     A transition is a five tuple:
     from-state  input-symbol  to-state  symbol-to-write  move
    
     at least one transition is required
     a typical dummy transition is  phi #b phi ## N
    
     special input-symbol #b for the blank character,
                          #[ for beginning of tape
                          #] for end of tape
                          #e for epsilon transition
    
     special symbol-to-write #b for blank character
                             ## for no character to write
    
     move is L or l for left one space on the tape
             R or r for right one space on the tape
             N or n for do not move the tape head
             anything else becomes "R"
    
     Anything after the required field(s) is a comment
    
     if symbol-to-write is "// "  then the rest of the line
     is a comment and symbol-to-write becomes ##
     and move becomes R, as in a DFA subset of a TM.
    
     if move is  "// "  then move becomes "N" and
     and the rest of the line is treated as a comment
    
     The input and output tape may contain only printable characters
     Use  #b  to input a blank (space) character on the input tape
     If you want a blank on each end of your tape, use #byour-stuff#b
     The initial position will point to your first tape character
     #] will be appended as a right_end character
     #[ will be appended as a left_end character
    
     Final states are entered as:  final state-name
    
     The default mode is language (string) recognition.
     Computation mode is specified using:  halt   or   halt state-name
    
     A full trace can be obtained using:  trace all
     or a partial trace can be obtained by one or more trace lines
     with the name of a state to be traced:  trace state-name
    
     The staring state is specified using:  start state-name
    
     Examples: There are a number of examples in the download directory with file extension .tm
    
     In particular, a very simple unary adder add.tm
     and associated output add.chk
    
     A simple unary proper subtraction sub.tm
     and associated output sub.chk
    
     A language recognizer for L = { a^n b^n c^n | n>0 } labc.tm
     and associated full trace output labc.chk
    
     A more complex binary number addition program b_add.tm
     and associated output b_add.chk
    
    

    Nondeterministic Turing Machine, NTM simulator

     
    
      The C++ source code is ntm.cpp
      Sample input is exntm.ntm
      Sample output is exntm.chk
    
      command line:   ntm < exntm.ntm > exntm.chk
    
      See TM above for input preparation.
    
      The only additional feature of NTM is that nondeterministic
      transitions are allowed.  For example the delta transition
      table below has nondeterministic transitions from state q0.
    
      delta                0                   1
    
         q0      {(q0,1,R), (q3,0,L)}  {q0,0,L), (q1,0,R)}
    
         q1      phi                   {q2,0,R}
    
      is coded as input:
    
      q0  0  q0  1  R
      q0  0  q3  0  L
      q0  1  q0  0  L
      q0  1  q1  0  R
      q1  1  q2  0  R
    
    
      The classic SAT recognizer using a NTM is sat.ntm
      and associated output sat.chk
    

    Deterministic Finite Automata, DFA simulator

     
      The C++ source code is dfa.cpp
      Sample input is ab_b_all.dfa
      Sample output is ab_b_all.chk
    
      command line:   dfa < ab_b_all.dfa > ab_b_all.chk
    
     Machine definition of a DFA  M = (Q, Sigma, alpha, q0, F)
        where Q is set of states
              Sigma is input tape alphabet
              alpha is transition table
              q0 is the starting state
              F is the set of final states
    
     Input Conventions:
    
     The file name extension is typically  .dfa
     free form plain text input file
     typical execution is   dfa < your_input.dfa > your_output.out
    
     A comment line has "// " as the first three characters
     A line may end with a comment using whitespace "//"
     Anything after whitespace after last expected input is a comment
    
     There are only a few keywords:
                     start, final, halt, trace, limit, enddef and tape
     any line not starting with these keywords is a transition
     'enddef' is only needed when more than one 'tape' is to be read
     only 'tape' lines may follow an 'enddef' line
    
     there is no such thing as a continuation line
    
     A transition is a three tuple:
     from-state  input-symbol  to-state
     
     special input-symbol #b for the blank character,
                          #e for epsilon transition
    
     at least one transition is required,
     the typical dummy transition is  phi #b phi
    
     Anything after the required field(s) is a comment
    
     Use  #b  to input a blank (space) character on the input tape
     If you want a blank on the end of your tape, use  your-stuff#b
     The initial position will point to your first tape character
     #] will be appended as a right_end character
     #[ will be appended as a left_end character
    
     Final states are entered as:  final state-name
    
     The default mode is language (string) recognition
     when in a final state and the tape head is over the right_end
     termination symbol.
    
     Halt mode stops the simulation as soon as the DFA enters a state
     designated as a halt state, specified using:  halt   or   halt state-name
    
     A full trace can be obtained using:  trace all
     or a partial trace can be obtained by one or more trace lines
     with the name of a state to be traced:  trace state-name
    
     The staring state is specified using:  start state-name
    
     Other input data and output examples: 
     reg.dfa reg.out
     
    

    Nondeterministic Finite Automata, NFA simulator

     
      The C++ source code is nfa.cpp
      Sample input is fig2_7.nfa
      Sample output is fig2_7.chk
    
      command line:   nfa < fig2_7.nfa > fig2_7.chk
    
      See DFA above for input preparation.
    
      The only additional feature of NFA is that nondeterministic
      transitions are allowed.  For example the delta transition
      table below has nondeterministic transitions from state q0.
    
      delta          0         1
    
         q0      {q0, q3}  {q0, q1}
    
         q1      phi       {q2}
    
      is coded as input:
    
      q0  0  q0
      q0  0  q3
      q0  1  q0
      q0  1  q1
      q1  1  q2
    
    
      Another example for recognizing 0*1*2* is fig2_9.nfa
      and associated output fig2_9.chk
    
    

    Myhill-Nerode minimization of a DFA

      The C++ source code is myhill.cpp
      The input data format is given above in  DFA.
    
      This program takes a DFA as input and uses the Myhill-Nerode Theorem
      to minimize the number of states. The output file is the minimized DFA.
    
      Execute the program using the command line:
      myhill initial_out.dfa < initial.dfa > initial.out
    
      A sample input file is initial.dfa
      The information output file is initial.out
      The minimized DFA is initial_out.dfa
    
      DO NOT use the same name for the input and output file!
    
      A simulation of the minimized DFA is initial_out_sim.out
    
    

    Quine McClusky minimization of sum or products

     
    Similar to the minimization of the number of states in a DFA using
    Myhill Nerode, combinational logic can be minimized to a sum of products.
    Sum of products represents two levels of digital logic, "and" gates
    followed by one "or" gate. The Quine McClusky algorithm requires NP time.
    For every number of digital inputs there is at least one function that
    requires a number of "and" "or" "not" gates that is exponential in the
    number of inputs when represented as a sum of products. The same
    exponential size is true for a product of sums representation,
    e.g. SAT.
    
    The source code for Quine McClusky is quine_mcclusky.c
    Also required, is calc_eqn.tab.c which can be
    built from calc_eqn.y using bison.
    All related files are in qm.tgz including
    Makefile_qm and examples
    qm -n 4 -t -i tt4.dat -o tt4.out
    tt4.dat  tt4.out
    
    qm -n 4 -e -i eqn4.dat -o eqn4.out
    eqn4.dat  eqn4.out
    
    qm -n 4 -m -i minterm4.dat -o minterm4.out
    minterm4.dat  minterm4.out
    
    The input data may be any of:
      A truth table. (see tt4.dat above)
      A set of minterms. (see minterm4.dat above)
      A VHDL equation. (see eqn4.dat above)
      A Verilog equartion. (see eqn4.dat and eqn4.out above)
    
    The output is the set of prime implicants and the VHDL equation and
    the Verilog equation. For example, the output  tt4.out is:
    
    Quine McClusky digital circuit minimization V1.0
    initial minterms 
    gr a b c d  cv 
    0  0 0 0 0  0 
    0  0 0 1 0  0 
    0  0 1 0 1  0 
    0  0 1 1 1  0 
    0  1 0 1 0  0 
    0  1 1 0 1  0 
    0  1 1 1 0  0 
    0  1 1 1 1  0 
    
    final prime implicants 
    gr a b c d  cv 
    0  - 0 1 0  0 
    0  1 - 1 0  0 
    0  1 1 1 -  0 
    0  - 1 - 1  0 
    0  0 0 - 0  0 
    
    out <= 
      (          not b and     c and not d ) or
      (    a           and     c and not d ) or
      (    a and     b and     c           ) or
      (              b           and     d ) or
      (not a and not b           and not d );
    
    out = 
      (     ~b &  c & ~d ) |
      ( a      &  c & ~d ) |
      ( a &  b &  c      ) |
      (      b      &  d ) |
      (~a & ~b      & ~d );
    
    The executable program is called  "qm" and the examples are run:
    
    qm -n 4 -t -i tt4.dat > tt4.out
    qm -n 4 -e -i eqn4.dat -o eqn4.out
    qm -n 4 -m -i minterm4.dat -o minterm4.out
    
    The standard format man page is 
    qm.1
    
    

    CYK parser for CFG's doing H&U simplification

     
      The C++ source code is cykp.cpp
      and other files including the Makefile_cykp
      cykp.h   cyk_eliminate.cpp   cyk_chomsky.cpp
      cyk_greibach.cpp   cyk_parse.cpp
      Sample input is g_220v.g
      Sample output is g_220v.out
    
      command line:   cykp < g_220v.g > g_220v.out
    
      The purpose of this program is not specifically to parse grammars,
      but rather to be able to output the "simplification" steps in
      Hopcroft and Ullman book. It does implement the CYK algorithm.
      There is also an output of Chomsky Normal Form and
      Greibach Normal Form.
    
      The Context Free Grammar  G = ( V, T, P, S ) is input:
      variable A xyz any-name ; // end with  space semicolon
      terminal 0 1 ;            // single characters
      A -> 0 A 1 xyz ; // or  A := 0 A 1 xyz // comment in place of ";"
      B := C D | B A ;          // variables automatically found
      start A                   // required starting symbol
      enddef                    // end of grammar, start of strings
      00110101  // input to parse
      1100110   // more input to parse
    
    
      Minimum printout is obtained by not having a "verbose" in the input.
      verbose 3  // generates maximal useful output
      verbose 6  // generates debug printout (full trace)
    
      Enter epsilon as the two characters    #e
      Enter the blank or space character as  #b
    
      Other input data and output: 
      g_140v.g g_140v.out
      g_97v.g g_97v.out
      g_90v.g g_90v.out
      g_paren.g g_paren.out
      g_reg.g g_reg.out  A regular, right linear grammar, from a DFA.
      g_grei.g g_grei.out greibach.pda Greibach test
    
    
    
      Report bugs or requests for additional features to  squire@umbc.edu
    
      Last updated 1/25/2021