示例#1
0
def main():

    custom_TM = TuringMachine(
     {
         ('q0', '#'): ('End', '#', 'R'),
         ('End', ''): ('qa', '', 'R'),

         ('q0', '0'): ('q1', 'X', 'R'),
         ('q1', '#'): ('Check0', '#', 'R'),
         ('Check0', '0'): ('FindLeftmost', 'X', 'L'),

         ('q0', '1'): ('q2', 'X', 'R'),
         ('q2', '#'): ('Check1', '#', 'R'),
         ('Check1', '1'): ('FindLeftmost', 'X', 'L'),

         ('FindLeftmost', '0'): ('FindLeftmost', '0', 'L'),
         ('FindLeftmost', '1'): ('FindLeftmost', '1', 'L'),
         ('FindLeftmost', 'X'): ('FindLeftmost', 'X', 'L'),
         ('FindLeftmost', '#'): ('FindLeftmost', '#', 'L'),
         ('FindLeftmost', ''): ('FindNext', '', 'R'),

         ('FindNext', 'X'): ('FindNext', 'X', 'R'),
         ('FindNext', '0'): ('q1', 'X', 'R'),
         ('FindNext', '1'): ('q2', 'X', 'R'),
         ('FindNext', '#'): ('End', '#', 'R'),

         ('q1', '0'): ('q1', '0', 'R'),
         ('q1', '1'): ('q1', '1', 'R'),
         ('q2', '0'): ('q2', '0', 'R'),
         ('q2', '1'): ('q2', '1', 'R'),

         ('Check0', 'X'): ('Check0', 'X', 'R'),
         ('Check1', 'X'): ('Check1', 'X', 'R'),

        ('End', 'X'): ('End', 'X', 'R'),
     }
 )
    
    user_input = str(input("Enter a word : "))


    finish = False # use to check if the machine has reached a final state


    execution = custom_TM.run(user_input)

    while finish != True :
        context = next(execution)
        info =context[1]
        print("state : {0}".format(info["state"]))

        if(context[0] == "Reject" or context[0] == "Accept" ):
            finish = True

    print("\n***** Results *****")
    print("w = {0} ({1})".format(user_input,context[0] ))
    print("state : {0}".format(info["state"]))
    return 0
示例#2
0
def main():
    tm = TuringMachine(states={'i', 'a', 'b', 'c', 'd', 'e', 'H'},
                       symbols={'0', '1'},
                       blank_symbol='0',
                       input_symbols={'1'},
                       initial_state='i',
                       accepting_states={'H'},
                       transitions={
                           ('i', '0'): ('H', '0', 1),
                           ('i', '1'): ('a', '0', 1),
                           ('a', '1'): ('a', '1', 1),
                           ('a', '0'): ('b', '0', 1),
                           ('b', '1'): ('b', '1', 1),
                           ('b', '0'): ('c', '1', 1),
                           ('c', '0'): ('d', '1', -1),
                           ('c', '0'): ('d', '1', -1),
                           ('d', '1'): ('d', '1', -1),
                           ('d', '0'): ('e', '0', -1),
                           ('e', '1'): ('e', '1', -1),
                           ('e', '0'): ('i', '0', 1),
                       })
    tm.initialize({i: '1' for i in range(5)})
    # or a nicer way to input a string
    # tm.initialize(dict(enumerate("11111")))

    while not tm.halted:
        tm.print()
        tm.step()
        time.sleep(.3)

    print(tm.accepted_input())
示例#3
0
def main():
    states_count = int(input())
    states = [map(State, input().split())]
    state_initial, state_final = (map(State, input().split()))
    states_final = {state_final}
    steps_count = int(input())
    steps = dict()
    while steps_count > 0:
        line = input()
        if line == '':
            continue
        steps_count -= 1
        state, symbol, _, state_next, symbol_next, heading = line.split()
        state = State(state)
        state_next = State(state_next)
        heading = Heading(heading)
        steps[(state, symbol)] = (state_next, symbol_next, heading)
    tape = Tape(input())

    machine = TuringMachine(tape=tape,
                            alphabet=tape.get_alphabet(),
                            empty='_',
                            step_function=StepFunction(steps),
                            states=states,
                            state_initial=state_initial,
                            states_final=states_final)

    while True:
        is_running = machine.make_step()
        if machine.is_final():
            print(f'STOP after {machine.step_count} transitions')
            break
        if is_running:
            if machine.step_count >= 10**5:
                print(f'MADE 100000 transitions')
                break
        else:
            print(f'FAIL after {machine.step_count} transitions')
            break

    start = next((k for k, v in machine.tape.tape.items() if v != '_'), None)
    if start is not None:
        stop = next(
            (k for k, v in reversed(machine.tape.tape.items()) if v != '_'),
            None)
        tape = []
        for i in range(start, stop + 1):
            tape.append(machine.tape.tape[i])
        print(''.join(tape))
        print(machine.state, machine.position - start)
    else:
        print()
        print(machine.state, 0)
示例#4
0
class Maincontroller(object):
    """
    Maincontroller()

    This class parses the input file, then create an
    instance of a Turing machine.
    Also is responsible to access a validate method of
    Turing machine and initialize your computing
    """
    def __init__(self, file, tape_content):
        self._file_content = self._parse_file_(file)
        self._tape_content = tape_content
        self._turing_machine = TuringMachine(self._file_content, self._tape_content)

    def _parse_file_(self, file):
        file_content = []
        try:
            with open(file, 'r') as f:
                for line in f:
                    # Remove all leading and trailing characters (\n \r \t) of the line
                    # Transforms the line into a list, spliting in ' '
                    # Then append the list in "file_content"
                    file_content.append(line.strip().split(' '))
            return file_content
        except IOError:
            print('Error opening file for reading.')
            print('The file exists and you have read permissions?')
            exit(1)

    def validate(self):
        """
        validate()

        Input format validation.

        returns 0 if the input format is valid or one of the following for invalid:
            1 if has no one input alphabet detected
            2 if has no one tape alphabet detected
            3 if has no one blank symbol detected
            4 if has no one states detected
            5 if has no one init state detected
            6 if has no one final state detected
            7 if the quantity of tapes is different of 1
            8 if has no one transition detected
        """
        return self._turing_machine.validate_input()

    def init_turing(self):
        """
        Initialize the computing of Turing machine
        """
        self._turing_machine.initialize_computing()
示例#5
0
def main2():
    tape1 = Tape('101011', '01')
    tape2 = Tape('', '01')
    states = [
        State('qCopy', StateType.Start),
        State('qReturn', StateType.Empty),
        State('qTest', StateType.Empty),
        State('qa', StateType.Accept),
        State('qr', StateType.Reject)
    ]
    transitions = [
        TransitionTwoTape('qCopy', '$', '$', 'qCopy', '$', '$',
                          Direction.Right, Direction.Right),
        TransitionTwoTape('qCopy', '0', '#', 'qCopy', '0', '0',
                          Direction.Right, Direction.Right),
        TransitionTwoTape('qCopy', '1', '#', 'qCopy', '1', '1',
                          Direction.Right, Direction.Right),
        TransitionTwoTape('qCopy', '#', '#', 'qReturn', '#', '#',
                          Direction.Neutral, Direction.Left),
        TransitionTwoTape('qReturn', '#', '0', 'qReturn', '#', '0',
                          Direction.Neutral, Direction.Left),
        TransitionTwoTape('qReturn', '#', '1', 'qReturn', '#', '1',
                          Direction.Neutral, Direction.Left),
        TransitionTwoTape('qReturn', '#', '$', 'qTest', '#', '$',
                          Direction.Left, Direction.Right),
        TransitionTwoTape('qTest', '0', '0', 'qTest', '0', '0', Direction.Left,
                          Direction.Right),
        TransitionTwoTape('qTest', '1', '1', 'qTest', '1', '1', Direction.Left,
                          Direction.Right),
        TransitionTwoTape('qTest', '$', '#', 'qa', '$', '#', Direction.Neutral,
                          Direction.Neutral),
        TransitionTwoTape('qTest', '1', '0', 'qr', '1', '0', Direction.Neutral,
                          Direction.Neutral),
        TransitionTwoTape('qTest', '0', '1', 'qr', '0', '1', Direction.Neutral,
                          Direction.Neutral)
    ]
    tm = TuringMachine(states, transitions, tape1, tape2)
    print(
        "\nTwo-tape Turing machine recognizes whether a binary string is a palindrome."
    )
    tm.process2()
    print("\nInput string:")
    print(tm.get_tape1())
    if (tm.current_state.type == StateType.Accept):
        print('\nAccepting')
    if (tm.current_state.type == StateType.Reject):
        print('\nRejecting')
    pass
示例#6
0
def testPalindromeMachine(tape, initPos):
    # Machine quintuples
    q1 = Quintuple('s', 'a', BLANK, RIGHT,
                   '1')  # In state s, it scans the LHE, the left-hand-end.
    # If w starts with an 'a', does it end in an 'a'?

    q2 = Quintuple('1', 'a', 'a', RIGHT, '1')  # In state 1, it moves to RHE
    q3 = Quintuple('1', 'b', 'b', RIGHT, '1')
    q4 = Quintuple('1', BLANK, BLANK, LEFT, '2')  # and goes to state 2

    q5 = Quintuple('2', 'a', BLANK, LEFT,
                   '3')  # In state 2, it checks that RHE = 'a'
    q6 = Quintuple('2', 'b', 'b', RIGHT, 'no')
    q7 = Quintuple('2', BLANK, BLANK, LEFT,
                   'yes')  # was w = 'a'? [or was X = 'a'?]

    q8 = Quintuple('3', 'a', 'a', LEFT,
                   '3')  # In state 3, it moves back to LHE
    q9 = Quintuple('3', 'b', 'b', LEFT, '3')
    q10 = Quintuple('3', BLANK, BLANK, RIGHT, 's')  # and starts again

    q11 = Quintuple('s', 'b', BLANK, RIGHT,
                    '4')  # If w starts with a 'b', does it end in a 'b'?

    q12 = Quintuple('4', 'a', 'a', RIGHT, '4')  # In state 4, it moves to RHE
    q13 = Quintuple('4', 'b', 'b', RIGHT, '4')
    q14 = Quintuple('4', BLANK, BLANK, LEFT, '5')

    q15 = Quintuple('5', 'a', 'a', RIGHT,
                    'no')  # In state 5, it checks that RHE = 'b'
    q16 = Quintuple('5', 'b', BLANK, LEFT, '3')
    q17 = Quintuple('5', BLANK, BLANK, LEFT,
                    'yes')  # was w = 'b'? [or was X = 'b'?]

    q18 = Quintuple('s', BLANK, BLANK, RIGHT,
                    'yes')  # Is the word with no letters a palindrome?

    quintuples = [
        q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13, q14, q15, q16,
        q17, q18
    ]

    tapeCopy = tape.copy()
    machine = TuringMachine(quintuples, 's', ['yes', 'no'])
    machine.run(tape, initPos)
    print('Palindrome machine, input was: ', tapeCopy,
          ', if palyndrome then state = yes\n')
示例#7
0
def testDecimalSuccessorMachine(tape, initPos):
    # Machine quintuples
    q1 = Quintuple('s', 0, 0, RIGHT,
                   's')  # In state s, it moves to RHE, the right-hand-end
    q2 = Quintuple('s', 1, 1, RIGHT, 's')  # of the string of nonblank symbols
    q3 = Quintuple('s', 2, 2, RIGHT, 's')
    q4 = Quintuple('s', 3, 3, RIGHT, 's')
    q5 = Quintuple('s', 4, 4, RIGHT, 's')
    q6 = Quintuple('s', 5, 5, RIGHT, 's')
    q7 = Quintuple('s', 6, 6, RIGHT, 's')
    q8 = Quintuple('s', 7, 7, RIGHT, 's')
    q9 = Quintuple('s', 8, 8, RIGHT, 's')
    q10 = Quintuple('s', 9, 9, RIGHT, 's')
    q11 = Quintuple('s', BLANK, BLANK, LEFT,
                    't')  # When it goes past the RHE, it steps left
    # and goes to state t

    q12 = Quintuple('t', 0, 1, LEFT,
                    'h')  # In state t, it adds 1 to current digit and halts
    q13 = Quintuple('t', 1, 2, LEFT, 'h')
    q14 = Quintuple('t', 2, 3, LEFT, 'h')
    q15 = Quintuple('t', 3, 4, LEFT, 'h')
    q16 = Quintuple('t', 4, 5, LEFT, 'h')
    q17 = Quintuple('t', 5, 6, LEFT, 'h')
    q18 = Quintuple('t', 6, 7, LEFT, 'h')
    q19 = Quintuple('t', 7, 8, LEFT, 'h')
    q20 = Quintuple('t', 8, 9, LEFT, 'h')
    q21 = Quintuple('t', 9, 0, LEFT,
                    't')  # But if the current digit is 9, it "carries one"
    q22 = Quintuple('t', BLANK, 1, LEFT, 'h')  # for when the input is all 9's

    quintuples = [
        q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13, q14, q15, q16,
        q17, q18, q19, q20, q21, q22
    ]

    tapeCopy = tape.copy()
    machine = TuringMachine(quintuples, 's', ['h'])
    machine.run(tape, initPos)
    print('Decimal succesor machine, input was: ', tapeCopy, '\n')
示例#8
0
def increment(word, verbose=False):
    tape = Tape(word, '|')
    states = [
                State("s0", StateType.Start),
                State("s1", StateType.Empty),
                State("sf", StateType.Final)
             ]

    transitions = [
                     Transition("s0", "$", "s1", "$", Direction.Right),
                     Transition("s1", "|", "s1", "|", Direction.Right),
                     Transition("s1", "#", "sf", "|", Direction.Neutral)
                  ]

    return TuringMachine(states, transitions, tape, verbose)
示例#9
0
def run_turing(tf, init, final):
    initial_state = init,
    accepting_states = final,
    transition_function = tf
    final_states = {"final"}

    t = TuringMachine("010011 ",
                      initial_state=init,
                      final_states=final,
                      transition_function=tf)

    print("Input on Tape:\n" + t.get_tape())

    while not t.final():
        t.step()

    return t.get_tape()
示例#10
0
def subtract(word, verbose=False):
    tape = Tape(word, '|&')
    states = [
                State("s0", StateType.Start),
                State("s1", StateType.Empty),
                State("s2", StateType.Empty),
                State("s3", StateType.Empty),
                State("s4", StateType.Empty),
                State("s5", StateType.Empty),
                State("s6", StateType.Empty),
                State("s7", StateType.Empty),
                State("s8", StateType.Empty),
                State("sf", StateType.Final)
             ]

    transitions = [
                     Transition("s0", "$", "s0", "$", Direction.Right),
                     Transition("s0", "#", "sf", "#", Direction.Neutral),
                     Transition("s0", "|", "s1", "|", Direction.Right),
                     Transition("s1", "|", "s1", "|", Direction.Right),
                     Transition("s1", "#", "s2", "#", Direction.Right),
                     Transition("s2", "#", "s2", "#", Direction.Right),
                     Transition("s2", "|", "s3", "|", Direction.Right),
                     Transition("s3", "|", "s4", "|", Direction.Left),
                     Transition("s3", "#", "s6", "#", Direction.Left),
                     Transition("s4", "|", "s5", "#", Direction.Left),
                     Transition("s5", "#", "s5", "#", Direction.Left),
                     Transition("s5", "|", "s2", "#", Direction.Right),
                     Transition("s5", "$", "s2", "$", Direction.Right),
                     Transition("s6", "|", "s7", "#", Direction.Left),
                     Transition("s7", "#", "s7", "#", Direction.Left),
                     Transition("s7", "$", "sf", "$", Direction.Neutral),
                     Transition("s7", "|", "s8", "#", Direction.Left),
                     Transition("s8", "|", "s8", "|", Direction.Left),
                     Transition("s8", "$", "sf", "$", Direction.Neutral)
                  ]

    return TuringMachine(states, transitions, tape, verbose)
示例#11
0
tape = Tape(word, "10x")
states = [
    State("s0", StateType.Start),
    State("s1", StateType.Empty),
    State("s2", StateType.Empty),
    State("s3", StateType.Empty),
    State("s4", StateType.Empty),  #getting rid of x in tape
    State("sf", StateType.Final)
]

transitions = [
    Transition('s0', '$', 's0', '$', Direction.Right),
    Transition('s0', '1', 's1', 'x', Direction.Left),
    Transition('s1', '$', 's2', '1', Direction.Right),
    Transition('s2', '1', 's2', '1', Direction.Right),
    Transition('s2', '0', 's2', '0', Direction.Right),
    Transition('s2', 'x', 's3', 'x', Direction.Right),
    Transition('s3', 'x', 's3', 'x', Direction.Right),
    Transition('s3', '1', 's1', 'x', Direction.Left),
    Transition('s1', '1', 's1', '0', Direction.Left),
    Transition('s1', 'x', 's1', 'x', Direction.Left),
    Transition('s1', '0', 's2', '1', Direction.Right),
    Transition('s3', '#', 's4', '#', Direction.Left),  #clearing x
    Transition('s4', 'x', 's4', '#', Direction.Left),
    Transition('s4', '1', 'sf', '1', Direction.Neutral),
    Transition('s4', '0', 'sf', '0', Direction.Neutral),
]

tm = TuringMachine(states, transitions, tape)
tm.process(verbose=False)
print("FINAL TAPE: " + tm.get_tape())
示例#12
0
# This means that you could construct a Turing Machine lazily, repeatedly
# ask for output with next, _only when needed_, or collect all its outputs 
# if needed
# 
# EXAMPLE:
# >>> x = (i ** 2 for i in range(1, 10))
# >>> list(x)
# [1, 4, 9, 16, 25, 36, 49, 64, 81]

#create the Turing machine

bbeaver2 = TuringMachine( 
    { 
        ('a', '0'): ('b', '1', 'R'),
        ('a', '1'): ('b', '1', 'L'),
        ('b', '0'): ('a', '1', 'L'),
        ('b', '1'): ('h', '1', 'R'),
    },
    start_state='a', accept_state='h', reject_state='r', blank_symbol='0'
)

bbeaver3 = TuringMachine( 
    { 
        ('a', '0'): ('b', '1', 'R'),
        ('a', '1'): ('b', '1', 'L'),
        ('b', '0'): ('a', '1', 'L'),
        ('b', '1'): ('c', '1', 'R'),
        ('c', '0'): ('h', '1', 'R'),
        ('c', '1'): ('h', '1', 'R'),
    },
    start_state='a', accept_state='h', reject_state='r', blank_symbol='0'
示例#13
0
scheme = TuringMachine(
    {
        # setup string
        ('q0',''):('w0','#','R'),
        ('w0',''):('w1','1','R'),
        ('w1',''):('w+','1','R'),
        ('w+',''):('w2','+','R'),
        ('w2',''):('w3','1','R'),
        ('w3',''):('w4','1','R'),
        ('w4',''):('w5','1','R'),
        ('w5',''):('w=','1','R'),
        ('w=',''):('leftMost','=','L'),

        ('q1','1'):('rightMost','x','R'),
        ('q1','+'):('q1','x','R'),
        ('q1','='):('qa','=','R'),

        ('rightMost','1'):('rightMost','1','R'),
        ('rightMost','+'):('rightMost','+','R'),
        ('rightMost','='):('rightMost','=','R'),
        ('rightMost',''):('leftMost','1','L'),

        ('leftMost','1'):('leftMost','1','L'),
        ('leftMost','+'):('leftMost','+','L'),
        ('leftMost','='):('leftMost','=','L'),
        ('leftMost','x'):('q1','x','R'),
        ('leftMost','#'):('q1','#','R'),
    }
)
示例#14
0
from turing_machine import TuringMachine

initial_state = "init",
accepting_states = ["final"],
transition_function = {
    ("init", "0"): ("init", "1", "R"),
    ("init", "1"): ("init", "0", "R"),
    ("init", " "): ("final", " ", "N"),
}
final_states = {"final"}

t = TuringMachine("BB0100100110011000110001BB",
                  initial_state="init",
                  final_states=final_states,
                  transition_function=transition_function)

print("Input on Tape:\n" + t.get_tape())
while not t.final():
    t.step()

print("Result of the Turing machine calculation:")
print(t.get_tape())
示例#15
0
from turing_machine import TuringMachine
from state import State, StateType
from transition import Transition
from direction import Direction
from tape import Tape

tape = Tape('aaabbb', 'abxy')
states = [
    State("s0", StateType.Start),
    State("s1", StateType.Empty),
    State("s2", StateType.Empty),
    State("sf", StateType.Final)
]

transitions = [
    Transition("s0", "$", "s0", "$", Direction.Right),
    Transition("s0", "a", "s1", "x", Direction.Right),
    Transition("s1", "a", "s1", "a", Direction.Right),
    Transition("s1", "b", "s2", "y", Direction.Left),
    Transition("s2", "a", "s2", "a", Direction.Left),
    Transition("s2", "x", "s0", "x", Direction.Right),
    Transition("s1", "y", "s1", "y", Direction.Right),
    Transition("s2", "y", "s2", "y", Direction.Left),
    Transition("s0", "y", "sf", "y", Direction.Neutral)
]

tm = TuringMachine(states, transitions, tape)
tm.process(verbose=True)
print(tm.get_tape())
示例#16
0
accepting_states = ["final", "A", "B", "C", "D", "E", "F"],
transition_function = {
    ("A", "0"): ("B", "1", "R"),
    ("A", "1"): ("D", "0", "L"),
    ("B", "0"): ("C", "1", "R"),
    ("B", "1"): ("F", "0", "R"),
    ("C", "0"): ("C", "1", "L"),
    ("C", "1"): ("A", "1", "L"),
    ("D", "0"): ("E", "0", "L"),
    ("D", "1"): ("A", "1", "R"),
    ("E", "0"): ("A", "1", "L"),
    ("E", "1"): ("B", "0", "R"),
    ("F", "0"): ("C", "0", "R"),
    ("F", "1"): ("E", "0", "R"),
}
final_states = {"final"}

t = TuringMachine(
    "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    initial_state="A",
    final_states=final_states,
    transition_function=transition_function)

print("Input on Tape:\n" + t.get_tape())

for i in range(1230229):
    t.step()

print("Result of the Turing machine calculation:")
print(t.get_tape())
示例#17
0
def testBinaryAdderMachine(tape, initPos):
    # Machine quintuples
    q1 = Quintuple('s', 0, 0, RIGHT, 's')  # In state s, it moves to RHE
    q2 = Quintuple('s', 1, 1, RIGHT, 's')
    q3 = Quintuple('s', 'a', 'a', RIGHT,
                   's')  # Latter, there will be a's and b's in the summand
    q4 = Quintuple('s', 'b', 'b', RIGHT, 's')
    q5 = Quintuple('s', '+', '+', RIGHT, 's')
    q6 = Quintuple('s', BLANK, BLANK, LEFT, '1')

    q7 = Quintuple('1', 0, BLANK, LEFT, '2')  # In state 1, it finds x = 0
    # We'll do the other cases for x later

    q8 = Quintuple('2', 0, 0, LEFT,
                   '2')  # In state 2, it moves left across 0 and 1 to +
    q9 = Quintuple('2', 1, 1, LEFT, '2')
    q10 = Quintuple('2', '+', '+', LEFT, '3')

    q11 = Quintuple('3', 'a', 'a', LEFT,
                    '3')  # In state 3, it moves left across a and b to y
    q12 = Quintuple('3', 'b', 'b', LEFT, '3')
    q13 = Quintuple('3', 0, 'a', RIGHT,
                    's')  # y = 0, and x + y = 0, but this is recorded as a
    # Then, we move right to get the next x

    q14 = Quintuple('3', BLANK, 'a', RIGHT,
                    's')  # When there is no corresponding bit y because the
    # summand is shorter than the addend, we take 0 for
    # y and record an a and move right to get the next x

    q15 = Quintuple('3', 1, 'b', RIGHT,
                    's')  # y = 1 and x + y = 1, but this is recorded as b
    # Then, we move right to get the next x

    q16 = Quintuple('1', 1, BLANK, LEFT, '4')  # In state 1, it finds x = 1

    q17 = Quintuple('4', 0, 0, LEFT,
                    '4')  # In state 4, it move left across 0 and 1 to +
    q18 = Quintuple('4', 1, 1, LEFT, '4')
    q19 = Quintuple('4', '+', '+', LEFT, '5')

    q20 = Quintuple('5', 'a', 'a', LEFT,
                    '5')  # In state 5, it moves left across a and b to y
    q21 = Quintuple('5', 'b', 'b', LEFT, '5')
    q22 = Quintuple('5', '0', 'b', RIGHT,
                    's')  # y = 0 and x + y = 1, but this is recorded as b
    # Then, we move right to get the next x

    q23 = Quintuple('5', BLANK, 'b', RIGHT,
                    's')  # When there is no corresponding bit y, take 0 for y
    # and record a 'b' and move right to get the next x

    q24 = Quintuple('5', 1, 'a', LEFT,
                    '6')  # y = 1 and x + y = 10, but this is recorded as a
    # Then, we move to state 6 and carry the one

    q25 = Quintuple('6', 0, 1, RIGHT, 's')
    q26 = Quintuple('6', BLANK, 1, RIGHT, 's')
    q27 = Quintuple('6', 1, 0, LEFT, '6')

    q28 = Quintuple('1', '+', BLANK, LEFT, '7')  # In state 1, it finds no x

    q29 = Quintuple('7', 'a', 0, LEFT,
                    '7')  # In state 7, it replaces a's by 0s
    q30 = Quintuple('7', 'b', 1, LEFT, '7')  # and it replaces b's by 1s
    q31 = Quintuple('7', 0, 0, LEFT, '7')  # moves to the LHE
    q32 = Quintuple('7', 1, 1, LEFT, '7')
    q33 = Quintuple('7', BLANK, BLANK, RIGHT, 'h')  # and halts

    quintuples = [
        q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12, q13, q14, q15, q16,
        q17, q18, q19, q20, q21, q22, q23, q24, q25, q26, q27, q28, q29, q30,
        q31, q32, q33
    ]

    tapeCopy = tape.copy()
    machine = TuringMachine(quintuples, 's', ['h'])
    machine.run(tape, initPos)
    print('Binary adder machine, input was: ', tapeCopy, '\n')
# -*- coding: utf-8 -*-
"""
Test script for running a Turing machine unary adder

Created on Fri Mar 29 21:57:42 2019

@author: shakes
"""
from turing_machine import TuringMachine

#create the Turing machine
adder = TuringMachine({
    #Write your transition rules here as entries to a Python dictionary
    #For example, the key will be a pair (state, character)
    #The value will be the triple (next state, character to write, move head L or R)
    #such as ('q0', '1'): ('q1', '0', 'R'), which says if current state is q0 and 1 encountered
    #then transition to state q1, write a 0 and move head right.
    ('q0', '1'): ('q0', '1', 'R'),
    ('q0', '0'): ('q0', '', 'R'),
    ('q0', ''): ('qa', '', 'R')
})

print("Input:", '110111')
print("Accepted?", adder.accepts('110111'))
adder.debug('110111')

print("Input:", '11101111')
print("Accepted?", adder.accepts('11101111'))

adder.debug('11101111')
multiplier = TuringMachine({
    #'b' determines the tally we'll be applying it to those will get removed at the end but also
    #'a' the tallies on the right side we've already done and also the tallies we've manually placed
    #'X' the left end, treat it like another 1
    #'B' the left end, treat it like another b

    #0. Set left end to 'X' go to the right end
    #1. Turn first tally into 'a' then go to the left
    #2. Find first tally after 0
    #3. Set this tally to 'b' then go back right
    #4. Go all the way to the right and enter 'b' at the first empty space
    #5. Repeat 3 and 4 until the left side hits 'X'
    #5.5 Replace all 'b's on the left with 1s
    #6. Find the next tally and repeat from step 1
    #7. Stop once you can't find a tally (you hit the 0)
    #8. Clear left then clear right until you hit empty or 'b'
    ('q0', '1'): ('FindRightEnd', 'X', 'R'),
    ('q0', '0'): ('ClearRight', '', 'R'),
    ('FindRightEnd', '1'): ('FindRightEnd', '1', 'R'),
    ('FindRightEnd', '0'): ('FindRightEnd', '0', 'R'),
    ('FindRightEnd', ''): ('CheckLeftTally', '', 'L'),
    ('FindRightEnd', 'a'): ('CheckLeftTally', 'a', 'L'),
    ('CheckLeftTally', '0'): ('ClearFromLeft', '0', 'L'),
    ('CheckLeftTally', '1'): ('GetToZero', 'a', 'L'),
    ('GetToZero', '1'): ('GetToZero', '1', 'L'),
    ('GetToZero', 'a'): ('GetToZero', 'a', 'L'),
    ('GetToZero', 'b'): ('GetToZero', 'b', 'L'),
    ('GetToZero', '0'): ('FindLHSTally', '0', 'L'),
    ('FindLHSTally', '1'): ('AddTally', 'b', 'R'),
    ('FindLHSTally', 'b'): ('FindLHSTally', 'b', 'L'),
    ('FindLHSTally', 'X'): ('AddTally', 'B', 'R'),
    ('FindLHSTally', 'B'): ('BsToOnes', 'X', 'R'),
    ('AddTally', '1'): ('AddTally', '1', 'R'),
    ('AddTally', '0'): ('AddTally', '0', 'R'),
    ('AddTally', 'b'): ('AddTally', 'b', 'R'),
    ('AddTally', 'a'): ('AddTally', 'a', 'R'),
    ('AddTally', ''): ('GetToZero', 'b', 'L'),
    ('ClearFromLeft', '1'): ('ClearFromLeft', '1', 'L'),
    ('ClearFromLeft', 'X'): ('ClearRight', '', 'R'),
    ('ClearRight', 'a'): ('ClearRight', '', 'R'),
    ('ClearRight', '1'): ('ClearRight', '', 'R'),
    ('ClearRight', '0'): ('ClearRight', '', 'R'),
    ('ClearRight', 'b'): ('BsToOnes', '1', 'R'),
    ('ClearRight', ''): ('qa', '', 'R'),
    ('BsToOnes', 'b'): ('BsToOnes', '1', 'R'),
    ('BsToOnes', '0'): ('FindRightEnd', '0', 'R'),
    ('BsToOnes', ''): ('qa', '', 'R'),

    #Write your transition rules here as entries to a Python dictionary
    #For example, the key will be a pair (state, character)
    #The value will be the triple (next state, character to write, move head L or R)
    #such as ('q0', '1'): ('q1', '0', 'R'), which says if current state is q0 and 1 encountered
    #then transition to state q1, write a 0 and move head right.
})
示例#20
0
    ('FindLeftmost', 'X'): ('FindLeftmost', 'X', 'L'),
    ('FindLeftmost', '#'): ('FindLeftmost', '#', 'L'),
    ('FindLeftmost', ''): ('FindNext', '', 'R'),

    ('FindNext', 'X'): ('FindNext', 'X', 'R'),
    ('FindNext', '0'): ('FindDelimiter0', 'X', 'R'),
    ('FindNext', '1'): ('FindDelimiter1', 'X', 'R'),
    ('FindNext', '#'): ('End', '#', 'R'),

    ('End', 'X'): ('End', 'X', 'R')
}

if __name__ == "__main__":
    print_transitions(transitions)

    machine = TuringMachine(transitions)

    def run(input_):
        w = input_
        print("Input:",w)
        print("Accepted" if machine.accepts(w) else "Rejected")
        machine.debug(w)
        print()

    # ACCEPTS
    run("#")

    # REJECTS - the first character is a 0
    # and the character at the end of the 1s is a 1
    run("0000#XXXX1")
示例#21
0
from turing_machine import TuringMachine

machine = TuringMachine({
    ('q0', '#'): ('End', '#', 'R'),
    ('End', ''): ('qa', '', 'R'),
    ('q0', '0'): ('FindDelimiter0', 'X', 'R'),
    ('FindDelimiter0', '#'): ('Check0', '#', 'R'),
    ('Check0', '0'): ('FindLeftmost', 'X', 'L'),
    ('q0', '1'): ('FindDelimiter1', 'X', 'R'),
    ('FindDelimiter1', '#'): ('Check1', '#', 'R'),
    ('Check1', '1'): ('FindLeftmost', 'X', 'L'),
    ('FindLeftmost', '0'): ('FindLeftmost', '0', 'L'),
    ('FindLeftmost', '1'): ('FindLeftmost', '1', 'L'),
    ('FindLeftmost', 'X'): ('FindLeftmost', 'X', 'L'),
    ('FindLeftmost', '#'): ('FindLeftmost', '#', 'L'),
    ('FindLeftmost', ''): ('FindNext', '', 'R'),
    ('FindNext', 'X'): ('FindNext', 'X', 'R'),
    ('FindNext', '0'): ('FindDelimiter0', 'X', 'R'),
    ('FindNext', '1'): ('FindDelimiter1', 'X', 'R'),
    ('FindNext', '#'): ('End', '#', 'R'),
    ('FindDelimiter0', '0'): ('FindDelimiter0', '0', 'R'),
    ('FindDelimiter0', '1'): ('FindDelimiter0', '1', 'R'),
    ('FindDelimiter1', '0'): ('FindDelimiter1', '0', 'R'),
    ('FindDelimiter1', '1'): ('FindDelimiter1', '1', 'R'),
    ('Check0', 'X'): ('Check0', 'X', 'R'),
    ('Check1', 'X'): ('Check1', 'X', 'R'),
    ('End', 'X'): ('End', 'X', 'R')
})

w = "1#1#00#100#100"  #try some strings here to find out what the machine accepts and rejects
print("Input:", w)
示例#22
0
from turing_machine import TuringMachine

two = TuringMachine({
    ('q0', '0'): ('Expect0', 'd', 'R'),
    ('q0', '1'): ('Expect1', 'd', 'R'),
    ('Expect0', '0'): ('Expect0', '0', 'R'),
    ('Expect0', '1'): ('Expect0', '1', 'R'),
    ('Expect0', '#'): ('Need0', '#', 'R'),
    ('Expect1', '0'): ('Expect1', '0', 'R'),
    ('Expect1', '1'): ('Expect1', '1', 'R'),
    ('Expect0', '#'): ('Need0', '#', 'R'),
    ('Expect0', '#'): ('Need0', '#', 'R'),
})

multiplier.debug('111#111', step_limit=300)  # output 1111111111
from turing_machine import TuringMachine
from state import State, StateType
from transition import Transition
from direction import Direction
from tape import Tape

# Simple test to check whether the turing machine is working
tape = Tape('|||', '|')
states = [
    State("s0", StateType.Start),
    State("s1", StateType.Empty),
    State("sf", StateType.Final)
]

transitions = [
    Transition("s0", "$", "s1", "$", Direction.Right),
    Transition("s1", "|", "s1", "|", Direction.Right),
    Transition("s1", "#", "sf", "|", Direction.Neutral)
]

tm = TuringMachine(states, transitions, tape)
tm.process()
print(tm.get_tape())
示例#24
0
        (s1, _) = start
        (s2, _, _) = finish

        states.add(s1)
        states.add(s2)

    print("The Turing machine has", len(states), "states:")
    for i in states:
        print(i)
    print()


if __name__ == "__main__":
    print_states(transitions)

    machine = TuringMachine(transitions)

    def run(input_):
        w = input_
        print("Input:", w)
        print("Accepted" if machine.accepts(w) else "Rejected")
        machine.debug(w)
        print()

    # SHOULD ACCEPT
    run("##")

    # SHOULD REJECT
    run("101031##")

    # SHOULD REJECT
示例#25
0
multiplier = TuringMachine({
    #Write your transition rules here as entries to a Python dictionary
    #For example, the key will be a pair (state, character)
    #The value will be the triple (next state, character to write, move head L or R)
    #such as ('q0', '1'): ('q1', '0', 'R'), which says if current state is q0 and 1 encountered
    #then transition to state q1, write a 0 and move head right.
    ('q0', '1'): ('q2', '#', 'R'),
    ('q2', '1'): ('q2', '1', 'R'),
    ('q2', '0'): ('q3', '#', 'R'),
    ('q2', '#'): ('q3', '#', 'R'),
    ('q3', '1'): ('q4', '#', 'R'),
    ('q3', '0'): ('q15', '#', 'L'),
    ('q3', '#'): ('q4', '#', 'R'),
    ('q4', '1'): ('q4', '1', 'R'),
    ('q4', ''): ('q5', '#', 'R'),
    ('q4', '#'): ('q5', '#', 'R'),
    ('q5', '1'): ('q5', '1', 'R'),
    ('q5', ''): ('q6', '1', 'L'),
    ('q6', '#'): ('q7', '#', 'L'),
    ('q6', '1'): ('q6', '1', 'L'),
    ('q7', '#'): ('q9', '1', 'L'),
    ('q7', '1'): ('q8', '1', 'L'),
    ('q8', '#'): ('q3', '1', 'R'),
    ('q8', '1'): ('q8', '1', 'L'),
    ('q9', '#'): ('q10', '#', 'L'),
    ('q9', '1'): ('q9', '1', 'L'),
    ('q10', '#'): ('q12', '', 'R'),
    ('q10', '1'): ('q11', '1', 'L'),
    ('q11', '#'): ('q0', '', 'R'),
    ('q11', '1'): ('q11', '1', 'L'),
    ('q12', '#'): ('q12', '', 'R'),
    ('q12', '1'): ('q13', '#', 'R'),
    ('q13', '#'): ('q14', '', 'L'),
    ('q13', '1'): ('q13', '#', 'R'),
    ('q13', ''): ('qa', '', 'L'),
    ('q14', '#'): ('q14', '', 'L'),
    ('q14', '1'): ('q14', '#', 'R'),
    ('q14', ''): ('qa', '', 'L'),
    ##        ('q14', '0'): ('q14','#','R'),
    ('q15', '#'): ('q16', '', 'L'),
    ('q15', '1'): ('q15', '#', 'L'),
    ('q15', ''): ('qa', '', 'L'),
    ##        ('q15', '0'): ('q15','#','L'),
    ('q16', '#'): ('qa', '', 'L'),
    ('q16', ''): ('qa', '', 'L'),
    ('q16', '1'): ('q16', '#', 'L'),
    ##        ('q16', '0'): ('q16','#','L'),
})
示例#26
0
from turing_machine import TuringMachine

transition_function = {("init","0"):("init", "1", "R"),
                       ("init","1"):("init", "0", "R"),
                       ("init"," "):("final"," ", "N"),
                       }

t = TuringMachine("010011 ", final_states=["final"],
                  transition_function=transition_function)

print("Input on Tape:")
print(t.get_tape_str())

while not t.final():
    t.step()

print("Result of the Turing machine calculation:")    
print(t.get_tape_str())
from turing_machine import TuringMachine

machine = TuringMachine({
    ('q0', '#'): ('saw_#', '#', 'R'),
    ('saw_#', '#'): ('saw_##', '#', 'R'),
    ('saw_##', ''): ('qa', '', 'R'),
})

w = "##"  #try some strings here to find out what the machine accepts and rejects
print("Input:", w)
print("Accepted?", machine.accepts(w))
machine.debug(w)
示例#28
0
    ("0.011.100.01000", True),
    ("1.010.11.001000", True),
    ("0000.10.0100.10000", True),
    ("10.011.1100", True),
    ("1.000.10", False),
    ("110.111.11", False),
    ("0.000", False),
    ("000.01", False),
    ("100.110.000", False),
]

if __name__ == "__main__":
    folder = 'input_machines'
    timeout = 8
    for filename in listdir(folder):
        filepath = f"{folder}/{filename}"
        username = filename.upper().split(".TXT")[0]
        tm = TuringMachine.from_file(filepath)

        print(username, end="\t")
        for word, expected in TESTS:
            result = tm.run(word, timeout=timeout)
            value = "1" if result is expected else "0"
            print(value, end="\t")

        for word, expected in BONUS_TESTS:
            result = tm.run(word, timeout=timeout)
            value = "1" if result is expected else "0"
            print(value, end="\t")
        print()
示例#29
0
# -*- coding: utf-8 -*-
"""
Busy beaver Turing machine with 2 states.

Created on Sat Mar 30 13:55:25 2019

@author: shakes
"""
from turing_machine import TuringMachine


#create the Turing machine
bbeaver = TuringMachine( 
    { 
        #Write your transition rules here as entries to a Python dictionary
        #For example, the key will be a pair (state, character)
        #The value will be the triple (next state, character to write, move head L or R)
        #such as ('q0', '1'): ('q1', '0', 'R'), which says if current state is q0 and 1 encountered
        #then transition to state q1, write a 0 and move head right.
        ('a', '0'):('b','1','R'),
        ('a', '1'):('b','1','L'),

        ('b', '0'):('a','1','L'),
        ('b', '1'):('h','1','R'),
    },
    start_state='a', accept_state='h', reject_state='r', blank_symbol='0'
)

bbeaver.debug('00000000000000', step_limit=1000)
Created on Fri Mar 29 21:57:42 2019

@author: shakes
"""
from turing_machine import TuringMachine

#create the Turing machine
adder = TuringMachine( 
    { 
        #('q0', '0'): ('qa', ' ', 'R'),
        #('q0', '1'): ('q0', '1', 'R'),
        #('q0', ''): ('qr', '', 'R'),

        ('q0', '0'): ('CheckRight', '0', 'R'),
        ('CheckRight', ''): ('Delete0', '', 'L'),
        ('Delete0', '0'): ('qa', '', 'R'),
        ('CheckRight', '1'): ('Swap0', '0', 'L'),
        ('Swap0', '0'): ('q0', '1', 'R'),

        ('q0', '1'): ('q0', '1', 'R')
        #Write your transition rules here as entries to a Python dictionary
        #For example, the key will be a pair (state, character)
        #The value will be the triple (next state, character to write, move head L or R)
        #such as ('q0', '1'): ('q1', '0', 'R'), which says if current state is q0 and 1 encountered
        #then transition to state q1, write a 0 and move head right.
        
    }
)

adder.debug('111011111')
示例#31
0
from turing_machine import TuringMachine

transition_function = {
    ("init", "0"): ("init", "1", "R"),
    ("init", "1"): ("init", "0", "R"),
    ("init", " "): ("final", " ", "N"),
}

t = TuringMachine("010011 ",
                  final_states=["final"],
                  transition_function=transition_function)

print("Input on Tape:")
print(t.get_tape_str())

while not t.final():
    t.step()

print("Result of the Turing machine calculation:")
print(t.get_tape_str())
示例#32
0
from turing_machine import TuringMachine

tm = TuringMachine.from_file("oddbinarymachine.txt")

result = tm.run("11010")
print('result = tm.run("11010") # result =', result)

state = tm.current_state
print('state = tm.current_state # state =', state)

tape_content = tm.tapes.words[0]
print('tape_content = tm.tapes.words[0] # tape_content =', tape_content)

tm.print_current_configuration()
示例#33
0
文件: turing.py 项目: kressi/turing
args = parser.parse_args()
step = args.step
verbose = args.verbose

with open(args.config + ".conf", 'r') as config_f:
    config = ast.literal_eval(config_f.read())

if args.tapes:
    config['tapesInput'] = args.tapes.split(',')
else:
    config['tapesInput'] = str(raw_input("content of tapes? ")).split(" ")


# ********************************
# run turing machine
# ********************************
t = TuringMachine(**config)
print t

while t.step():
    # next step with enter
    if step:
        raw_input()
    if verbose:
        print t

char = '0'
print "{0} occurs {1} times".format(char, t.getCount(char))
print "Steps: {0}".format(t.getStepCount())

示例#34
0
w_hash_w = TuringMachine(
    {
        ('q0', '#'): ('End', '#', 'R'),
        ('End', ''): ('qa', '', 'R'),

        ('q0', '0'): ('FindDelimiter0', 'X', 'R'),
        ('FindDelimiter0', '#'): ('Check0', '#', 'R'),
        ('Check0', '0'): ('FindLeftmost', 'X', 'L'),

        ('q0', '1'): ('FindDelimiter1', 'X', 'R'),
        ('FindDelimiter1', '#'): ('Check1', '#', 'R'),
        ('Check1', '1'): ('FindLeftmost', 'X', 'L'),

        ('FindLeftmost', '0'): ('FindLeftmost', '0', 'L'),
        ('FindLeftmost', '1'): ('FindLeftmost', '1', 'L'),
        ('FindLeftmost', 'X'): ('FindLeftmost', 'X', 'L'),
        ('FindLeftmost', '#'): ('FindLeftmost', '#', 'L'),
        ('FindLeftmost', ''): ('FindNext', '', 'R'),

        ('FindNext', 'X'): ('FindNext', 'X', 'R'),
        ('FindNext', '0'): ('FindDelimiter0', 'X', 'R'),
        ('FindNext', '1'): ('FindDelimiter1', 'X', 'R'),
        ('FindNext', '#'): ('End', '#', 'R'),

        ('FindDelimiter0', '0'): ('FindDelimiter0', '0', 'R'),
        ('FindDelimiter0', '1'): ('FindDelimiter0', '1', 'R'),
        ('FindDelimiter1', '0'): ('FindDelimiter1', '0', 'R'),
        ('FindDelimiter1', '1'): ('FindDelimiter1', '1', 'R'),

        ('Check0', 'X'): ('Check0', 'X', 'R'),
        ('Check1', 'X'): ('Check1', 'X', 'R'),

        ('End', 'X'): ('End', 'X', 'R')
    }
)