The document outlines a programming assignment that involves creating context-free grammars and Turing machines. It specifies the required grammar formats for accepting specific string patterns over given alphabets, and describes how to set up and execute a Turing machine simulator. Additionally, the document details the structure of Turing machine files, including state transitions and input requirements.

1. write the code for
Part 1 Context-Free Grammars
Create context-free grammars for these languages. The grammar must be specified as a text
file in the format below.
1. (Filename: cfg1.txt) Create a context-free grammar for the language that accepts all odd
length strings over the alphabet T = {a, b} that begin with a and end with b.
2. (Filename: cfg2.txt) Create a context-free grammar for the alphabet T = {x, y, z} that is
equivalent to the regular expression: ^(xy?)*(zz|xyz)+$
Grammar File Format
The grammar file format must be specified using the notation in class. Some rules:
Nonterminals can either be a single capital letter or a longer string (with no spaces). If you
use longer strings, you must separate the elements on the right-hand side of the
production with spaces.
The terminal alphabet T is provided with each problem. Anything that is not a terminal is
assumed to be a nonterminal.
The assignment requires the grammar to be a context-free grammar. This means that the
left-hand side of each production only consists of a single nonterminal.
You may use the shorthand notation using |.
The start symbol must either be S or Start.
You should use E or Empty to represent the empty string.
Example using single letter nonterminals with T = {a, b}:
S -> aS
S -> X
X -> bX
X -> E
Example using longer string nonterminals and shorthand notation with T = { (, ), +, *, 0, 1}:
Start -> BoolExpr
BoolExpr -> BoolExpr BoolOp BoolExpr | ( BoolExpr ) | BoolVal
BoolOp -> + | *
BoolVal -> 0 | 1
Unfortunately, there is no Python simulator for testing your grammars like the DFAs in last
assignments and the Turing machines in Part 2. Your grammars will be graded manually.
using
# Turing machine simulator
# Original Author: Matt Chu (mwc2110@columbia.edu)
import sys
from optparse import OptionParser
COMMENT = "#"
BLANK = "B"
LEFT = "L"
RIGHT = "R"
# Parses command line

2. def parse_command_line():
parser = OptionParser()
parser.add_option("-d", "--display_mode", dest = "display_mode",
help = "Display mode")
parser.add_option("-t", "--tm_file", dest = "machine_file",
help = "Turing machine file (.tur)")
parser.add_option("-s", "--string", dest = "tape_string",
help = "Initial string")
options, args = parser.parse_args()
if options.machine_file == None:
options.machine_file = input("Enter the name of the machine file: ")
if options.tape_string == None:
options.tape_string = input("Enter the starting string: ")
if options.display_mode == None:
valid = False
while not valid:
print("Select display mode:")
print("1. Step through the program (stops after each step)")
print("2. Display each step (does not stop until the machine halts)")
print("3. Display the final state (does not stop until the machine halts)")
choice = int(input("Your choice: "))
if choice == 1:
options.display_mode = "step"
valid = True
elif choice == 2:
options.display_mode = "show"
valid = True
elif choice == 3:
options.display_mode = "final"
valid = True
else:
print("Invalid choice")
if not options.display_mode in ("step", "show", "final"):
print("Invalid display mode")
sys.exit(-1)
return options.machine_file, options.tape_string, options.display_mode
# Loads machine from file
def load_machine(machine_file):
machine = {}
# Traverse the file
file = open(machine_file, 'r')
lines = file.readlines()

3. instruction = lines[0].strip().replace(' ','').split(',')
start_state = instruction[0]
accept_state = instruction[1]
for line in lines[1:]:
# Ignore blank lines and comments
if line.strip() == "" or line.strip()[0] == COMMENT:
continue
# Split the line into its pieces
instruction = line.strip().replace(' ','').split(',')
current_state = instruction[0]
current_symbol = instruction[1]
next_state = instruction[2]
write_symbol = instruction[3]
direction = instruction[4].upper()
# Add the (key, value) to the dictionary
key = (current_state, current_symbol)
value = (write_symbol, next_state, direction)
if current_state == accept_state:
print("ERROR! Transitions are not allowed out of accept state")
sys.exit(-1)
if not key in machine:
machine[key] = value
else:
print("ERROR! Duplicate key detected:", key)
sys.exit(-1)
return machine, start_state, accept_state
# Converts the tape into a list
def load_tape(tape_string):
tape = []
for i in range(len(tape_string)):
tape.append(tape_string[i])
if (len(tape) == 0):
tape.append("B")
return tape
# Print the state of the machine
def print_state(tape, machine_position, machine_state, step):
line1 = "" # Stores the tape
line2 = "" # Stores the head pointer
line3 = "" # Stores the current state
for i in range(len(tape)):
line1 += tape[i]

4. if i == machine_position:
line2 += "^"
line3 += machine_state
else:
line2 += " "
line3 += " "
print(line1 + "n" + line2 + "n" + line3)
if step:
input("")
else:
print ("")
# Execute the machine
def execute(machine, start_state, tape, display_mode):
# Initialize the machine
current_state = start_state
current_position = 0
current_symbol = tape[current_position]
# Print state
if display_mode == "step":
print_state(tape, current_position, current_state, True)
elif display_mode == "show":
print_state(tape, current_position, current_state, False)
# Continue until machine halts (key does not exist)
while (current_state, current_symbol) in machine:
# Look up next move
write_symbol, next_state, direction = machine[(current_state, current_symbol)]
# Write new symbol
tape[current_position] = write_symbol
# Change state
current_state = next_state
# Move
if direction == LEFT:
current_position -= 1
elif direction == RIGHT:
current_position += 1
else:
print("ERROR! Invalid direction:", direction)
sys.exit(-1)
# Check to see if we are at the end of the tape
if current_position == -1:
tape.insert(0, BLANK)
current_position = 0

5. elif current_position == len(tape):
tape.append(BLANK)
# Update current symbol
current_symbol = tape[current_position]
# Print state
if display_mode == "step":
print_state(tape, current_position, current_state, True)
elif display_mode == "show":
print_state(tape, current_position, current_state, False)
return current_state, tape
# Converts the tape back to a string
def tape_to_string(tape):
# Convert to string
tape_str = ""
for c in tape:
tape_str += c
# Strip off leading and trailing blanks
tape_str = tape_str.lstrip(BLANK)
tape_str = tape_str.rstrip(BLANK)
# If string only contained blanks, return a single blank
if len(tape_str) == 0:
return BLANK
return tape_str
if __name__ == "__main__":
# Parse command line.
machine_file, tape_string, display_mode = parse_command_line()
# Load the program.
machine, start_state, accept_state = load_machine(machine_file)
# Load the initial tape.
tape = load_tape(tape_string)
# Execute the machine on the tape.
final_state, final_tape = execute(machine, start_state, tape, display_mode)
# Print the final tape.
if final_state == accept_state:
acceptStr = "(accepting)"
else:
acceptStr = "(rejecting)"
print("State:", final_state, acceptStr, "Tape:", tape_to_string(final_tape))
Part 2 Turing Machines
Create Turing machines based on the following specifications. The Turing machine must be
expressed as
files that can be used as inputs for the Turing machine simulator described below.

6. 1. (Filename: tm1.txt) Design a Turing machine on the input alphabet {a,b,c} that accepts strings in
the format: "^([ab]*)c$" and results in a final tape string "^c1$". In other words, the
characters before c in the original input string appear on the right side of c at the end of the
program.
You should move the group of characters, not the letter c, on the tape. It rejects strings that are
not in
the format specified above. You can assume that the input string has at most one c.
Ex. input = babc, resulting tape = cbab
input = aabbc, resulting tape = caabb
input = aab rejected
2. (Filename: tm2.txt) Design a Turing machine on the input alphabet {x, y, z} that accepts strings
where the number of xs is greater than the number of ys in the string. The input string will consist
of x
and y only (i.e., no zs).
For this machine, the final tape output does not matter. You will need to modify the tape in order to
complete this exercise.
Turing Machine Simulator
To run the simulator, the file tm.py needs to be in the current directory:
python3 tm.py
When running the simulator, you will be initially prompted three times:
The name of the Turing machine file (file format is described below).
The initial string.
A choice of three display modes: 1 (step, interactively), 2 (step, non-interactive), 3 (display
final state and output only).
In the Turing machine, states are represented by nonnegative integers. The tape alphabet
consists of any desired characters. The character 'B' represents a blank character.
In the file, the first line contains two integers separated by a comma:
initial state, accepting state
Each subsequent line of the file refers to a different transition represented by a comma-
separated list:
current state, current input, next state, new symbol, direction
For instance, the line 0,x,1,y,R means that if the Turing machine is currently in state 0 with
the head reading an x, it will transition to state 1, write a y into the current tape cell, and
then move the head right one cell.
Notes:
The five fields within a line are separated by commas. Spaces in the line are removed and
ignored.
The symbol B represents a blank character.
The direction can either be L for left and R for right.
Only one accepting state (noted on the first line) is permitted. As with Turing machines, you
cannot have transitions out of the accepting state.
The same input pair (current state, current input) cannot appear multiple times in a file.

7. The simulator halts when there is no transition for the current input pair. Just like real Turing
machines, it is possible for the simulator to go into an infinite loop.
After the required first line, lines that start with # are ignored and can be used for comments.
If you do something wrong (such as type in the filename incorrectly), you will likely get an
uncaught Python exception rather than a clear error message.
When running the simulator using interactive mode (choice 1), you will see the initial state of
the machine. It will look something like this:
xyyzzz
^
0
The first line is the tape. The initial blanks on both sides of the input are not displayed until
necessary. The subsequent lines show where the head is pointing to and the current state.
Press Enter to advance the Turing machine one step. Continue to press Enter until the
simulator halts. You can also press Ctrl-C to stop execution, necessary in infinite loops.
Command line parameters are also available to specify the Turing machine file (-t), display
mode (-d), and tape string (-s). For display mode, there are three options: step (option 1),
show (option 2), and final (option 3).