Initial commit

Author: Simone Gasperini

.gitignore

@@ -0,0 +1,129 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

TMsim/__init__.py

@@ -0,0 +1,110 @@
+from TMsim.parsing import parse_text, get_delta_dict
+from TMsim.tape import Tape
+
+
+class TuringMachine:
+
+    init_state = 'Qinit'
+    halt_states = {'Qhalt', 'Qaccept', 'Qreject'}
+
+    def __init__(self, num_tapes, alphabet, states, transition_func):
+        self.num_tapes = num_tapes
+        self.alphabet = alphabet
+        self.states = states
+        self.transition_func = transition_func
+        self._initialize()
+
+    def __repr__(self):
+        class_name = self.__class__.__qualname__
+        params = list(self.__init__.__code__.co_varnames)
+        params.remove('self')
+        params.remove('transition_func')
+        args = '\n'.join([f'\t{key} = {getattr(self, key)}' for key in params])
+        return f'{class_name}(\n{args}\n)'
+
+    @classmethod
+    def from_txt(cls, filepath):
+        with open(filepath) as file:
+            lines = file.readlines()
+        num_tapes, alphabet, states, transitions = parse_text(lines)
+        transition_func = get_delta_dict(transitions, alphabet)
+        return cls(num_tapes=num_tapes, alphabet=alphabet, states=states,
+                   transition_func=transition_func)
+
+    def _initialize(self):
+        self._check_symbols()
+        self._check_init_state()
+        self.state = self.init_state
+        self.steps = 0
+        self.tapes = self._init_tapes()
+
+    def _check_symbols(self):
+        for symbol in {'>', '_'}:
+            if symbol not in self.alphabet:
+                raise ValueError(
+                    f'The required symbol "{symbol}" is not in the alphabet!')
+
+    def _check_init_state(self):
+        if self.init_state not in self.states:
+            raise ValueError(
+                f'The required state "{self.init_state}" is not in the set of states!')
+
+    def _init_tapes(self):
+        empty_tapes = [Tape() for i in range(self.num_tapes)]
+        return empty_tapes
+
+    def load_input(self, string):
+        for s in string:
+            self.tapes[0].move(key='R')
+            self.tapes[0].write(s)
+        self.tapes[0].head = self.tapes[0].min_head+1
+
+    def get_config(self):
+        config = (self.state,)
+        for tape in self.tapes:
+            config += (tape.read(),)
+        return config
+
+    def execute(self, instructions):
+        self.state = instructions[0]
+        k = 1+self.num_tapes
+        symbols = instructions[1:k]
+        moves = instructions[k:]
+        for i, s, m in zip(range(self.num_tapes), symbols, moves):
+            self.tapes[i].write(symbol=s)
+            self.tapes[i].move(key=m)
+
+    def make_step(self):
+        config = self.get_config()
+        instructions = self.transition_func[config]
+        self.execute(instructions)
+
+    def run(self):
+        while self.state not in self.halt_states:
+            self.make_step()
+            self.steps += 1
+
+    def show_state(self, prefix=''):
+        print(f'{prefix}state = {self.state}')
+
+    def show_input(self):
+        self.show_state(prefix='init_')
+        print(f'input = {self.tapes[0]}')
+
+    def show_output(self):
+        self.show_state(prefix='final_')
+        print(f'output = {self.tapes[-1]}')
+        print(f'num_steps = {self.steps}')
+
+
+if __name__ == '__main__':
+
+    filepath = './../codes/1tape_inverse.txt'
+    TM = TuringMachine.from_txt(filepath)
+
+    input_string = '00011101'
+    TM.load_input(input_string)
+
+    TM.show_input()
+    TM.run()
+    TM.show_output()

TMsim/machine.py

@@ -0,0 +1,28 @@
+def parse_string(s, par='{}', sep=',', ret=set):
+    s = s.strip(par[0]).strip(par[1])
+    return ret(s.split(sep))
+
+
+def parse_text(lines):
+    lines = [l.strip('\n').replace(' ', '') for l in lines if l != '\n']
+    for line in lines:
+        if line.startswith('NUM_TAPES='):
+            num_tapes = int(line.strip('NUM_TAPES='))
+        elif line.startswith('ALPHABET='):
+            alphabet = parse_string(line.strip('ALPHABET='))
+        elif line.startswith('STATES='):
+            states = parse_string(line.strip('STATES='))
+        elif line.startswith('TRANSITION_FUNC='):
+            transitions = lines[lines.index(line)+1:]
+            break
+    return num_tapes, alphabet, states, transitions
+
+
+def get_delta_dict(transitions, alphabet):
+    transitions_list = [t.replace('*', s) for s in alphabet
+                        for t in transitions if '*' in t]
+    transitions_list.extend([t for t in transitions if '*' not in t])
+    delta_dict = {parse_string(string.split('-->')[0], par='()', ret=tuple):
+                  parse_string(string.split('-->')[1], par='()', ret=tuple)
+                  for string in transitions_list}
+    return delta_dict

TMsim/parsing.py

@@ -0,0 +1,45 @@
+class Tape:
+
+    moves = {'S': lambda head: head,
+             'R': lambda head: head+1,
+             'L': lambda head: head-1}
+
+    def __init__(self):
+        self.head = 0
+        self.cells = {self.head-1: '_',
+                      self.head: '>',
+                      self.head+1: '_'}
+
+    def __repr__(self):
+        symbols = [self.cells[i] if i != self.head else '|' + self.cells[i]
+                   for i in range(self.min_head, self.max_head+1)]
+        return '..|' + '|'.join(symbols) + '|..'
+
+    @property
+    def min_head(self):
+        return min(list(self.cells.keys()))
+
+    @property
+    def max_head(self):
+        return max(list(self.cells.keys()))
+
+    def _blank_first_cell(self):
+        first = self.min_head
+        if self.cells[first] != '_':
+            self.cells[first-1] = '_'
+
+    def _blank_last_cell(self):
+        last = self.max_head
+        if self.cells[last] != '_':
+            self.cells[last+1] = '_'
+
+    def move(self, key):
+        self.head = self.moves[key](self.head)
+
+    def read(self):
+        return self.cells[self.head]
+
+    def write(self, symbol):
+        self.cells[self.head] = symbol
+        self._blank_first_cell()
+        self._blank_last_cell()

TMsim/tape.py

@@ -0,0 +1,16 @@
+NUM_TAPES = 1
+
+ALPHABET = {0, 1, >, _}
+
+STATES = {Qinit, Q1, Q2, Qhalt}
+
+TRANSITION_FUNC =
+(Qinit, >) --> (Q1, >, S)
+(Q1, >) --> (Q1, >, R)
+(Q1, 0) --> (Q1, 0, R)
+(Q1, 1) --> (Q1, 1, R)
+(Q1, _) --> (Q2, _, S)
+(Q2, _) --> (Q2, _, L)
+(Q2, 0) --> (Q2, 1, L)
+(Q2, 1) --> (Q2, 0, L)
+(Q2, >) --> (Qhalt, >, S)

codes/1tape_inverse.txt

@@ -0,0 +1,19 @@
+from setuptools import setup
+from setuptools import find_packages
+
+
+setup(
+
+    name='TMsimulator',
+    version='0.0.1',
+
+    author='SimoneGasperini',
+    author_email='simone.gasperini2@studio.unibo.it',
+
+    description='Turing Machine simulator written in Python',
+    url='https://github.com/SimoneGasperini/TMsimulator.git',
+
+    packages=find_packages(),
+    python_requires='>=3.8',
+
+)