automaton-simulate 0.1.0__py3-none-any.whl

automaton_simulate/__init__.py

@@ -0,0 +1,13 @@
+from turing_machine_main import TuringMachine
+from turing_machine_multitape import MultiTapeTuringMachine
+from turing_machine_nondeterministic import NondeterministicTuringMachine
+from turing_machine_formal_language import Enumerator, recognizer
+
+from automaton_main import FiniteAutomaton, PushdownAutomaton, LinearBoundedAutomaton
+
+from random_machine import random_machine, two_symbols_machine
+
+__version__ = "0.1.2"
+__all__ = ["TuringMachine", "MultiTapeTuringMachine", "NondeterministicTuringMachine", "Enumerator", "recognizer", 
+           "FiniteAutomaton", "PushdownAutomaton", "LinearBoundedAutomaton", 
+           "random_machine", "two_symbols_machine"]

automaton_simulate/automaton_main.py

@@ -0,0 +1,271 @@
+class FiniteAutomaton:
+    def __init__(self, states, alphabet, transition, initial_state, accept_state, initial_word):
+
+        self.states = states
+        self.alphabet = alphabet
+        self.transition = transition
+        self.initial_state = initial_state
+        self.accept_state = accept_state
+        self.current_state = initial_state
+        self.word = initial_word
+
+    def run(self):
+        for i in range(len(self.word)):
+            symbol = self.word[i]
+            if symbol not in self.alphabet:
+                raise ValueError(f"Write symbol '{symbol}' is not in alphabet")
+            
+            key = (self.current_state, symbol)
+
+            if key not in self.transition:
+                raise RuntimeError(f"transition function undefined: '{key}'")
+            self.current_state = self.transition[key]
+
+        return self.current_state == self.accept_state
+
+    def __repr__(self):
+        return(
+                f"FiniteAutomaton(states={self.states}, alphabet={self.alphabet}, "
+                f"initial_state={self.initial_state!r}, accept_state={self.accept_state!r}, "
+                f"current_state={self.current_state!r}, initial_word={self.word!r}, "
+                f"transition={self.transition})"
+            )
+
+
+
+class PushdownAutomaton:
+
+    "transition[(state, symbol, stack_top)] = (next_state, push_string)"
+
+    def __init__(self, states, alphabet, stack_alphabet, transition,
+                 initial_state, accept_state, initial_word, initial_stack_symbol):
+
+        self.states = states
+        self.alphabet = alphabet
+        self.stack_alphabet = stack_alphabet
+        self.transition = transition
+        self.initial_state = initial_state
+        self.accept_state = accept_state
+        self.current_state = initial_state
+        self.word = initial_word
+        self.initial_stack_symbol = initial_stack_symbol
+        self.stack = [] if initial_stack_symbol is None else [initial_stack_symbol]
+
+    def _apply(self, key):
+        next_state, push_string = self.transition[key]
+        for ch in push_string:
+            if ch not in self.stack_alphabet:
+                raise ValueError(
+                    f"stack symbol '{ch}' in push string '{push_string}' "
+                    f"is not in stack alphabet")
+        self.current_state = next_state
+        if self.stack:
+            self.stack.pop()
+        self.stack.extend(reversed(push_string)) 
+
+    def run(self):
+
+        self.current_state = self.initial_state
+        self.stack = [] if self.initial_stack_symbol is None else [self.initial_stack_symbol]
+
+        i = 0
+        while True:
+            top = self.stack[-1] if self.stack else None
+
+            key = (self.current_state, None, top)
+            if key in self.transition:
+                self._apply(key)
+                continue
+
+            if i == len(self.word):
+                break
+
+            symbol = self.word[i]
+            i += 1
+            if symbol not in self.alphabet:
+                raise ValueError(f"Input symbol '{symbol}' is not in alphabet")
+
+            key = (self.current_state, symbol, top)
+            if key not in self.transition:
+                raise RuntimeError(f"transition function undefined: '{key}'")
+            self._apply(key)
+
+        return self.current_state == self.accept_state
+
+    def __repr__(self):
+        return (
+            f"PushdownAutomaton(states={self.states}, alphabet={self.alphabet}, "
+            f"stack_alphabet={self.stack_alphabet}, "
+            f"initial_state={self.initial_state!r}, accept_state={self.accept_state!r}, "
+            f"current_state={self.current_state!r}, initial_word={self.word!r}, "
+            f"initial_stack_symbol={self.initial_stack_symbol!r}, "
+            f"stack={self.stack!r}, transition={self.transition})"
+        )
+
+    
+class LinearBoundedAutomaton:
+    #默认方法：属性及初始化
+    def __init__(self, states, alphabet, transition, initial_state, accept_state, reject_state, tape_length = 100, blank_symbol = " ", tape_alphabet = None, initial_tape = ""):
+
+        #七元组属性
+        self.states = states                #有限状态集合
+        self.alphabet = alphabet            #输入字母表
+        if tape_alphabet is None:           #纸带字母表，包含输入字母表和空白符
+            self.tape_alphabet = list(alphabet) + [blank_symbol]
+        else:
+            self.tape_alphabet = tape_alphabet
+        self.transition = transition        #转移函数
+        self.initial_state = initial_state  #初始状态
+        self.accept_state = accept_state    #接受状态
+        self.reject_state = reject_state    #拒绝状态
+
+        #合法性检测
+        if tape_length <= 0:
+            raise ValueError("tape_length must be greater than 0")
+
+        #初始化纸带
+        self.tape_length = tape_length              #纸带长度
+        self.blank_symbol = blank_symbol            #空白符号
+        self.tape = [blank_symbol] * tape_length    #写入初始空白符号
+        self.head = 0                               #初始读写头位置
+        self.current_state = initial_state          #当前状态为初始状态
+        self.steps = 0                              #初始步数
+
+        #输入原始字符串
+        for i, char in enumerate(initial_tape):
+            if i < self.tape_length:
+                if char in self.tape_alphabet:
+                    self.tape[i] = char
+                else:
+                    raise ValueError(f"Initial_tape character '{char}'  is not in tape_alphabet")
+        
+        self.reset_data = (states, alphabet, transition, initial_state, accept_state, reject_state, tape_length, blank_symbol, tape_alphabet)
+
+    #读取方法
+    def read(self):
+        return self.tape[self.head]
+    
+    #写入方法
+    def write(self, symbol):
+        if symbol in self.tape_alphabet:
+            self.tape[self.head] = symbol
+        else:
+            raise ValueError(f"Write symbol '{symbol}' is not in tape_alphabet")            #写入符号不在纸带字母表内
+
+    #移动方法
+    def move(self, direction):
+        #读写头右移
+        if direction == "Right":
+            if self.head < self.tape_length - 1:
+                self.head += 1
+            else:
+                raise RuntimeError("Head moved out of bounds: reached right end of tape")   #右方越界
+        #读写头左移
+        elif direction == "Left":
+            if self.head > 0:
+                self.head -= 1
+            else:
+                raise RuntimeError("Head moved out of bounds: reached left end of tape")    #左方越界
+        #读写头不动
+        elif direction == "Stay":
+            pass
+        #方向未定义
+        else:
+            raise ValueError(f"Invalid move direction: '{direction}'")                      #无效的方向
+
+    #单步运行方法
+    def step(self):
+        if self.current_state == self.accept_state or self.current_state == self.reject_state:
+            return False
+
+        symbol = self.read()
+        key = (self.current_state, symbol)
+
+        if key not in self.transition:
+            raise RuntimeError(f"transition function undefined: '{key}'")
+        new_state, write_symbol, direction = self.transition[key]
+
+        self.write(write_symbol)
+        self.move(direction)
+        self.current_state = new_state
+        self.steps += 1
+        return True
+
+    #运行方法
+    def run(self,max_steps=10000):
+        self.steps = 0
+        while self.steps < max_steps and self.step():
+            pass
+        return self.tape_content()
+
+    #结果输出方法
+    def tape_content(self):
+        return "".join(self.tape)
+
+    #调试方法
+    def __repr__(self):
+        return(
+            f"LinearBoundedAutomaton(states={self.states}, alphabet={self.alphabet}, tape_alphabet={self.tape_alphabet}, "
+            f"initial_state={self.initial_state!r}, accept_state={self.accept_state!r}, reject_state={self.reject_state!r}, blank_symbol={self.blank_symbol!r}, "
+            f"tape_length={self.tape_length}, current_state={self.current_state!r}, initial_tape={self.tape!r}, "
+            f"head={self.head}, steps={self.steps}, "
+            f"transition={self.transition})"
+        )
+
+if __name__ == "__main__":
+    LBA = LinearBoundedAutomaton(
+        states = {"q0","q_accept"},
+        alphabet = {"0","1"},
+        tape_alphabet = {"0","1"},
+        transition = {
+        ("q0", "0"): ("q1", "1", "Right"),
+        ("q0", "1"): ("q_accept", "1", "Stay"),
+        ("q1", "0"): ("q1", "1", "Left"),
+        ("q1", "1"): ("q_accept", "1", "Stay")
+        },
+        blank_symbol = "0",
+        initial_state = "q0",
+        accept_state = "q_accept",
+        reject_state = "q3",
+        initial_tape="00010"
+    )
+
+    print(LBA)
+    print(LBA.run())
+
+    FA = FiniteAutomaton(
+        states = {"q0", "q1", "q_accept"},
+        alphabet = {"a", "b"},
+        transition = {
+            ("q0", "a"): ("q1"), ("q0", "b"): ("q0"),
+            ("q1", "a"): ("q1"), ("q1", "b"): ("q_accept"),
+            ("q_accept", "a"): ("q1"), ("q_accept", "b"): ("q0")
+        },
+        initial_state = "q0",
+        accept_state = "q_accept",
+        initial_word = "abbab"
+    )
+    print(FA, FA.run())
+    pda = PushdownAutomaton(
+    states={'q0', 'q1', 'q2'},
+    alphabet={'a', 'b'},
+    stack_alphabet={'A', 'Z'},              # Z 是栈底标记
+    transition={
+        ('q0', 'a', 'Z'):  ('q0', 'AZ'),    # 读 a：压入 A
+        ('q0', 'a', 'A'):  ('q0', 'AA'),
+        ('q0', 'b', 'A'):  ('q1', ''),      # 读 b：弹出 A
+        ('q1', 'b', 'A'):  ('q1', ''),
+        ('q1', None, 'Z'): ('q2', 'Z'),     # ε：a、b 数量一致 → 接受态
+    },
+    initial_state='q0',
+    accept_state='q2',
+    initial_word='aaabbb',
+    initial_stack_symbol='Z',
+    )
+
+    for w in ['ab', 'aabb', 'aaabbb', 'aaabb', 'aab', 'aabbb']:
+        pda.word = w
+        try:
+            print(w, '->', pda.run())
+        except RuntimeError as e:
+            print(w, '-> False (拒绝：无可用转移，', e.args[0], ')')

automaton_simulate/function_affiliate.py

@@ -0,0 +1,7 @@
+def busy_beaver_shift(states_number):
+    busy_beaver_S_l = [1, 6, 21, 107, 47176870]
+    return int(busy_beaver_S_l[states_number])
+
+def busy_beaver_sigma(states_number):
+    busy_beaver_sigma_l = [1, 4, 6, 13, 4098]
+    return int(busy_beaver_sigma_l[states_number])

automaton_simulate/random_machine.py

@@ -0,0 +1,49 @@
+import random
+import string
+from turing_machine_main import TuringMachine
+
+
+def random_machine(states_number, symbol_number):
+
+    states = tuple(f"q{i}" for i in range(states_number)) + ("q_accept", "q_reject")
+    alphabet = random.sample(string.ascii_lowercase, symbol_number)   
+    blank = random.choice(alphabet)                                    
+
+    transitions = {
+        (f"q{i}", alphabet[j]): (
+            random.choice(states),
+            random.choice(alphabet),
+            random.choice(["Left", "Right", "Stay"]),
+        )
+        for i in range(states_number)
+        for j in range(symbol_number)
+    }
+
+    return (states, alphabet, transitions, "q0", "q_accept", "q_reject",
+            blank, list(alphabet))
+
+
+def two_symbols_machine(states_number):
+    states = tuple(f"q{i}" for i in range(states_number)) + ("q_accept", "q_reject")
+    alphabet = ["0", "1"]
+    blank = random.choice(alphabet)
+    transitions = {
+        (f"q{i}", alphabet[j]): (
+            random.choice(states),
+            random.choice(alphabet),
+            random.choice(["Left", "Right", "Stay"]),
+        )
+        for i in range(states_number)
+        for j in range(2)
+    }
+    return (states, alphabet, transitions, "q0", "q_accept", "q_reject",
+            blank, list(alphabet))
+
+
+if __name__ == "__main__":
+    for i in range(100):
+        try:
+            tm = TuringMachine(*random_machine(3, 2))   # ① 必须传两个参数
+            print(f"#{i}: {tm.run()}")
+        except:
+            print(1)

automaton_simulate/turing_machine_formal_language.py

@@ -0,0 +1,104 @@
+import itertools
+import copy
+from turing_machine_main import TuringMachine
+
+class Enumerator:
+    def __init__(self, machines, alphabet):
+        self.machines = list(machines)
+        self.alphabet = sorted(alphabet) if alphabet else ["0", "1"]
+
+    @staticmethod
+    def nth_string(alphabet, k):
+        m = k - 1
+        if m == 0:
+            return ""
+        base = len(alphabet)
+        m -= 1                              # 跳过空串
+        length = 1
+        while m >= base ** length:
+            m -= base ** length
+            length += 1
+        chars = []
+        for _ in range(length):
+            m, r = divmod(m, base)
+            chars.append(alphabet[r])
+        return "".join(reversed(chars))
+
+    @staticmethod
+    def enumerate_string(alphabet):
+        yield ""
+        for length in itertools.count(1):
+            for chars in itertools.product(alphabet, repeat=length):
+                yield "".join(chars)
+
+    # 对所有 (j, k, i)（均 >=1）按 j+k+i 递增的顺序
+    @staticmethod
+    def enumerate_task():
+        for s in itertools.count(3):
+            for j in range(1, s - 1):
+                for k in range(1, s - j):
+                    yield (j, k, s - j - k)
+
+    def run(self, max_outputs=None):
+        yielded = set()
+        outputs = 0
+        for j, k, i in self.enumerate_task():
+            if j > len(self.machines):
+                continue
+
+            machine = copy.deepcopy(self.machines[j - 1])
+            input_string = self.nth_string(self.alphabet, k)
+
+            machine.reset()
+            machine.set_input(input_string)
+
+            steps = 0
+            try:
+                while steps < i and not machine.is_halted:
+                    machine.step()
+                    steps += 1
+            except RuntimeError:
+                pass
+
+            if machine.is_accept and input_string not in yielded:
+                yielded.add(input_string)
+                yield input_string
+                outputs += 1
+                if max_outputs is not None and outputs >= max_outputs:
+                    return
+
+
+def recognizer(machine, input, max_steps):
+    sim = copy.deepcopy(machine)
+    sim.set_input(input)
+    while sim.steps <= max_steps:
+        if not sim.step():
+            return True
+    return False
+    
+
+
+if __name__ == "__main__":
+    a = TuringMachine(
+        states = {"q0","q1", "q_accept","q_reject"},
+        alphabet = {"0","1"},
+        tape_alphabet = {"0","1"},
+        transition = {
+        ("q0", "0"): ("q1", "1", "Right"),
+        ("q0", "1"): ("q_accept", "1", "Stay"),
+        ("q1", "0"): ("q1", "1", "Left"),
+        ("q1", "1"): ("q_accept", "1", "Stay")
+        },
+        blank_symbol = "0",
+        initial_state = "q0",
+        accept_state = "q_accept",
+        reject_state = "q_reject",
+        initial_tape="00010"
+    )
+
+
+    enum = Enumerator([a], ["0", "1"])
+    for output in enum.run(max_outputs=10):
+        print(output)
+
+    print(recognizer(a,"101",10), recognizer(a, "000", 1))

automaton_simulate/turing_machine_main.py

@@ -0,0 +1,169 @@
+class TuringMachine:
+    """七元组图灵机 M = (Q, Σ, Γ, δ, q0, q_accept, q_reject)"""
+    def __init__(self, states, alphabet, transition, initial_state, accept_state,
+                 reject_state, blank_symbol=" ", tape_alphabet=None, initial_tape=""):
+
+        self.states = set(states)
+        self.alphabet = set(alphabet)      
+
+        if tape_alphabet is None:
+            self.tape_alphabet = self.alphabet | {blank_symbol}
+        else:
+            self.tape_alphabet = set(tape_alphabet) | {blank_symbol}
+
+        self.transition = transition
+        self.initial_state = initial_state
+        self.accept_state = accept_state
+        self.reject_state = reject_state
+        self.blank_symbol = blank_symbol
+
+        for s in (initial_state, accept_state):
+            if s not in self.states:
+                raise ValueError(f"State '{s}' is not in states")
+        for (q, sym), (q2, ws, d) in transition.items():
+            if q not in self.states or q2 not in self.states:
+                raise ValueError(f"Transition {((q, sym), (q2, ws, d))} uses undefined states")
+            if ws not in self.tape_alphabet:
+                raise ValueError(f"Transition write symbol '{ws}' is not in tape_alphabet")
+
+        for char in initial_tape:
+            if char not in self.tape_alphabet:
+                raise ValueError(f"Initial_tape character '{char}' is not in tape_alphabet")
+
+        # ---- 初始化纸带：输入从下标 0 开始，读写头指向第一个字符 ----
+        self.tape = list(initial_tape)
+        self.head = 0
+        self.current_state = initial_state
+        self.steps = 0
+
+        self._initial_tape = list(self.tape)
+
+    def _ensure_cell(self):
+        while self.head < 0:
+            self.tape.insert(0, self.blank_symbol)
+            self.head += 1
+        while self.head >= len(self.tape):
+            self.tape.append(self.blank_symbol)
+
+    def read(self):
+        self._ensure_cell()
+        return self.tape[self.head]
+
+    def write(self, symbol):
+        if symbol not in self.tape_alphabet:
+            raise ValueError(f"Write symbol '{symbol}' is not in tape_alphabet")
+        self._ensure_cell()
+        self.tape[self.head] = symbol
+
+    def move(self, direction):
+        if direction == "Right":
+            self.head += 1
+        elif direction == "Left":
+            self.head -= 1
+        elif direction == "Stay":
+            pass
+        else:
+            raise ValueError(f"Unknown direction: '{direction}'")
+        self._ensure_cell()
+
+    def step(self):
+        if self.current_state in (self.accept_state, self.reject_state):
+            return False
+        key = (self.current_state, self.read())
+        if key not in self.transition:
+            raise RuntimeError(f"transition function undefined: '{key}'")
+        new_state, write_symbol, direction = self.transition[key]
+        self.write(write_symbol)
+        self.move(direction)
+        self.current_state = new_state
+        self.steps += 1
+        return True
+
+    def run(self, max_steps=10000):
+        self.reset()
+        while self.steps < max_steps and self.step():
+            pass
+        return self.tape_content()
+
+    def reset(self):
+        self.tape = list(self._initial_tape)
+        self.head = 0
+        self.current_state = self.initial_state
+        self.steps = 0
+
+    def set_input(self, initial_tape):
+        for i, char in enumerate(initial_tape):
+            if char not in self.tape_alphabet:
+                raise ValueError(f"Initial_tape character '{char}' is not in tape_alphabet")
+
+        tape_length = getattr(self, "tape_length", None)
+
+        if tape_length is not None and len(initial_tape) > tape_length:
+            raise ValueError(
+                f"initial_tape length {len(initial_tape)} exceeds tape_length {tape_length}"
+            )
+        if tape_length is not None:
+            self.tape = [self.blank_symbol] * tape_length
+            for i, char in enumerate(initial_tape):
+                self.tape[i] = char
+        else:
+            self.tape = list(initial_tape) or [self.blank_symbol]
+
+
+        self.head = 0
+        self.current_state = self.initial_state
+        self.steps = 0
+
+
+        self._initial_tape = list(self.tape)
+
+        return self.tape
+
+    @property
+    def is_halted(self):
+        return self.current_state in (self.accept_state, self.reject_state)
+
+    @property
+    def is_accept(self):
+        return self.current_state == self.accept_state
+
+    def tape_content(self):
+        return "".join(self.tape)
+
+    def __repr__(self):
+        return (
+            f"TuringMachine(states={self.states}, alphabet={self.alphabet}, "
+            f"tape_alphabet={self.tape_alphabet}, initial_state={self.initial_state!r}, "
+            f"accept_state={self.accept_state!r}, reject_state={self.reject_state!r}, "
+            f"blank_symbol={self.blank_symbol!r}, current_state={self.current_state!r}, "
+            f"tape={''.join(self.tape)!r}, head={self.head}, steps={self.steps})"
+        )
+
+
+if __name__ == "__main__":
+    # 一台"纸带上含有 1 就接受"的图灵机，顺便演示读写头越界处理
+    def make_tm(input_tape):
+        return TuringMachine(
+            states={"q0", "q_accept", "q_reject"},
+            alphabet={"0", "1"},
+            tape_alphabet={"0", "1", "_"},
+            transition={
+                ("q0", "0"): ("q0", "0", "Right"),       
+                ("q0", "1"): ("q_accept", "1", "Stay"),  
+                ("q0", "_"): ("q_reject", "_", "Stay"), 
+            },
+            blank_symbol="_",
+            initial_state="q0",
+            accept_state="q_accept",
+            reject_state="q_reject",
+            initial_tape=input_tape,
+        )
+
+    tm = make_tm("00010")
+    print(tm)
+    print("tape:", tm.run())
+    print("state:", tm.current_state, "| steps:", tm.steps)   
+
+    tm2 = make_tm("00000")
+    print("tape:", tm2.run())                                  
+    print("state:", tm2.current_state, "| steps:", tm2.steps)  

automaton_simulate/turing_machine_multitape.py

@@ -0,0 +1,134 @@
+class MultiTapeTuringMachine:
+    #默认方法：属性及初始化
+    def __init__(self, tapes_number, states, alphabet, transition, initial_state, accept_state, reject_state, tape_length = 100, blank_symbol = " ", tape_alphabet = None, initial_tape = ""):
+
+        self.tapes_number = tapes_number    #纸带数量
+
+        #七元组属性
+        self.states = states                #有限状态集合
+        self.alphabet = alphabet            #输入字母表
+        if tape_alphabet is None:           #纸带字母表，包含输入字母表和空白符
+            self.tape_alphabet = alphabet + [blank_symbol]
+        else:
+            self.tape_alphabet = tape_alphabet
+        self.transition = transition        #转移函数
+        self.initial_state = initial_state  #初始状态
+        self.accept_state = accept_state    #接受状态
+        self.reject_state = reject_state    #拒绝状态
+
+        #合法性检测
+        if tape_length <= 0:
+            raise ValueError("tape_length must be greater than 0")
+
+        #初始化纸带（动态扩展列表：只存放已触及的格子，读写头越界时自动补空白符）
+        self.tape_length = tape_length                      #保留原属性仅供兼容/参考，不再限制纸带长度
+        self.blank_symbol = blank_symbol                    #空白符号
+        self.tapes = [[self.blank_symbol] for _ in range(self.tapes_number)]  #每条纸带初始一格空白
+        self.heads = [0] * self.tapes_number                #初始化多个读写头位置
+        self.current_state = initial_state                  #当前状态为初始状态
+        self.steps = 0                                      #初始步数
+
+        #输入原始字符串（写入第 0 条纸带，按需扩展）
+        for i, char in enumerate(initial_tape):
+            if char in self.tape_alphabet:
+                if i == 0:
+                    self.tapes[0][i] = char
+                else:
+                    self.tapes[0].append(char)
+            else:
+                raise ValueError(f"Initial_tape character '{char}'  is not in tape_alphabet")
+
+    #读取方法
+    def read(self):
+        return [self.tapes[i][self.heads[i]] for i in range(self.tapes_number)]
+
+    #写入方法
+    def write(self, symbols):
+        for i in range(self.tapes_number):
+            if symbols[i] in self.tape_alphabet:
+                self.tapes[i][self.heads[i]] = symbols[i]
+            else:
+                raise ValueError(f"Write symbol '{symbols[i]}' is not in tape_alphabet")                #写入符号不在纸带字母表内
+
+    #移动方法
+    def move(self, directions):
+        for i in range(self.tapes_number):
+            #读写头右移（越界时在纸带末端动态补充空白符）
+            if directions[i] == "Right":
+                if self.heads[i] < len(self.tapes[i]) - 1:
+                    self.heads[i] += 1
+                else:
+                    self.tapes[i].append(self.blank_symbol)
+                    self.heads[i] += 1
+            #读写头左移（越界时在纸带左端动态补充空白符，读写头停留原位指向新补的空白格）
+            elif directions[i] == "Left":
+                if self.heads[i] > 0:
+                    self.heads[i] -= 1
+                else:
+                    self.tapes[i].insert(0, self.blank_symbol)
+            #读写头不动
+            elif directions[i] == "Stay":
+                pass
+            #方向未定义
+            else:
+                raise ValueError(f"Invalid move direction '{directions[i]}' for head {i}")              #无效的方向
+
+    #单步运行方法
+    def step(self):
+        if self.current_state == self.accept_state or self.current_state == self.reject_state:
+            return False
+        
+        symbol = self.read()
+        key = (self.current_state, tuple(symbol))
+
+        if key not in self.transition:
+            raise RuntimeError(f"transition function undefined: '{key}'")
+        new_state, write_symbols, directions = self.transition[key]
+
+        self.write(write_symbols)
+        self.move(directions)
+        self.current_state = new_state
+        self.steps += 1
+        return True
+
+    #运行方法
+    def run(self, max_steps=10000):
+        self.steps = 0
+        while self.steps < max_steps and self.step():
+            pass
+        return self.tape_content()
+
+    #结果输出方法
+    def tape_content(self):
+        return ["".join(self.tapes[i]) for i in range(self.tapes_number)]
+
+    #调试方法
+    def __repr__(self):
+        return(
+                    f"MultiTapeTuringMachine(states={self.states}, alphabet={self.alphabet}, tape_alphabet={self.tape_alphabet}, "
+                    f"initial_state={self.initial_state!r}, accept_state={self.accept_state!r}, reject_state={self.reject_state!r}, blank_symbol={self.blank_symbol!r}, "
+                    f"tape_length={self.tape_length}, current_state={self.current_state!r}, initial_tape={self.tapes[0]!r}, tapes_number={self.tapes_number}, "
+                    f"heads={self.heads}, steps={self.steps}, "
+                    f"transition={self.transition})"
+                )
+
+if __name__ == "__main__":
+    MTM = MultiTapeTuringMachine(
+        states = {"q0","q_accept"},
+        alphabet = {"0","1"},
+        tape_alphabet = {"0","1"},
+        transition = {
+            ("q0", ("0", "0")): ("q1", ("1", "0"), ("Right", "Stay")),
+        ("q1", ("0", "0")): ("q1", ("1", "0"), ("Left", "Stay")),
+        ("q1", ("1", "0")): ("q_accept", ("1", "0"), ("Stay", "Stay"))
+    },
+    blank_symbol = "0",
+    initial_state = "q0",
+    accept_state = "q_accept",
+    reject_state = "q3",
+    initial_tape="00010",
+    tapes_number=2 
+    )
+
+    print(MTM.run())
+    print(MTM)

automaton_simulate/turing_machine_nondeterministic.py

@@ -0,0 +1,151 @@
+from collections import deque
+from turing_machine_main import TuringMachine
+
+
+class NondeterministicTuringMachine(TuringMachine):
+
+    def __init__(self, states, alphabet, transition, initial_state, accept_state,
+                 reject_state, blank_symbol=" ", tape_alphabet=None, initial_tape=""):
+
+        if not isinstance(transition, dict):
+            raise TypeError("transition must be a dict")
+        for key, rules in transition.items():
+            if not isinstance(rules, list):
+                raise TypeError(
+                    f"transition[{key!r}] must be a list of "
+                    f"(new_state, write_symbol, direction)"
+                )
+            for rule in rules:
+                if not (isinstance(rule, tuple) and len(rule) == 3):
+                    raise TypeError(
+                        f"each rule in transition[{key!r}] must be a 3-tuple "
+                        f"(new_state, write_symbol, direction), got {rule!r}"
+                    )
+
+        super().__init__(states, alphabet, {}, initial_state, accept_state,
+                         reject_state, blank_symbol, tape_alphabet, initial_tape)
+        self.transition = transition
+        self._initial_tape = list(self.tape) or [self.blank_symbol]   # 供 run() 每次从头开始
+
+        # ---------- 语义校验 ----------
+        for (state, symbol), rules in transition.items():
+            if state not in self.states:
+                raise ValueError(f"transition state '{state}' is not in states")
+            for new_state, write_symbol, direction in rules:
+                if new_state not in self.states:
+                    raise ValueError(f"new state '{new_state}' is not in states")
+                if write_symbol not in self.tape_alphabet:
+                    raise ValueError(f"write symbol '{write_symbol}' is not in tape_alphabet")
+                if direction not in ("Right", "Left", "Stay"):
+                    raise ValueError(f"invalid move direction: '{direction}'")
+
+    # ---------- 纸带动态扩展 ----------
+    @staticmethod
+    def _move_head(tape, head, direction, blank_symbol):
+        if direction == "Right":
+            if head == len(tape) - 1:
+                tape.append(blank_symbol)        # 右端动态补一格空白
+            return head + 1
+        if direction == "Left":
+            if head == 0:
+                tape.insert(0, blank_symbol)     # 左端动态补一格空白
+                return 0
+            return head - 1
+        return head                              # Stay
+
+    def _canonical_key(self, state, tape, head):
+        start = 0
+        end = len(tape)
+        while start < head and tape[start] == self.blank_symbol:
+            start += 1
+        while end > head + 1 and tape[end - 1] == self.blank_symbol:
+            end -= 1
+        return (state, tuple(tape[start:end]), head - start)
+
+    def _next_configurations(self, state, tape, head, steps):
+        rules = self.transition.get((state, tape[head]))
+        if not rules:
+            return []                            # 无转移定义：死分支
+
+        successors = []
+        for new_state, write_symbol, direction in rules:
+            new_tape = list(tape)
+            new_tape[head] = write_symbol
+            new_head = self._move_head(new_tape, head, direction, self.blank_symbol)
+            successors.append((new_state, new_tape, new_head, steps + 1))
+        return successors
+
+    def run(self, max_steps=10000):
+        # 每次 run 都从初始配置重新开始（纸带、读写头、状态全部复位）
+        self.tape = list(self._initial_tape)
+        self.head = 0
+        self.current_state = self.initial_state
+        self.steps = 0
+
+        # 广度优先搜索遍历所有非确定性分支
+        start = (self.initial_state, list(self.tape), 0, 0)
+        queue = deque([start])
+        visited = {self._canonical_key(*start[:3])}   # 规范化去重，防纸带无限扩展
+
+        while queue:
+            state, tape, head, steps = queue.popleft()
+
+            if state == self.accept_state:
+                self.current_state = state
+                self.tape = tape
+                self.head = head
+                self.steps = steps
+                return self.tape_content()
+
+            if state == self.reject_state or steps >= max_steps:
+                continue
+
+            for nxt in self._next_configurations(state, tape, head, steps):
+                nstate, ntape, nhead, nsteps = nxt
+                key = self._canonical_key(nstate, ntape, nhead)
+                if key in visited:
+                    continue
+                visited.add(key)
+                queue.append(nxt)
+
+        return None          # 所有分支均未接受
+
+    def step(self):
+        raise NotImplementedError(
+            "NondeterministicTuringMachine not supported step(), please use run()"
+        )
+
+    def __repr__(self):
+        return (
+            f"NondeterministicTuringMachine(states={self.states}, alphabet={self.alphabet}, "
+            f"tape_alphabet={self.tape_alphabet}, initial_state={self.initial_state!r}, "
+            f"accept_state={self.accept_state!r}, reject_state={self.reject_state!r}, "
+            f"blank_symbol={self.blank_symbol!r}, current_state={self.current_state!r}, "
+            f"tape={''.join(self.tape)!r}, head={self.head}, steps={self.steps})"
+        )
+
+
+if __name__ == "__main__":
+    # 非确定性地判定"纸带上含有 11 子串"
+    def make_ntm(input_tape):
+        return NondeterministicTuringMachine(
+            states={"q0", "q1", "q_accept", "q_reject"},
+            alphabet={"0", "1"},
+            tape_alphabet={"0", "1", "_"},
+            transition={
+                ("q0", "0"): [("q0", "0", "Right")],
+                ("q0", "1"): [("q0", "1", "Right"), ("q1", "1", "Right")], 
+                ("q0", "_"): [("q_reject", "_", "Stay")],
+                ("q1", "1"): [("q_accept", "1", "Stay")],
+            },
+            blank_symbol="_",
+            initial_state="q0",
+            accept_state="q_accept",
+            reject_state="q_reject",
+            initial_tape=input_tape,
+        )
+
+    ntm = make_ntm("01011")                 
+    print(ntm.run())                        
+    print(ntm.current_state, ntm.steps)     
+    print(ntm)            

automaton_simulate-0.1.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: automaton-simulate
+Version: 0.1.0
+Summary: A library for simulating automatons
+Author-email: Dayu811 <13691283074@163.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# py-automaton
+
+A lightweight Python library for simulating automata and turing machine.
+
+## Install
+
+```bash
+pip install automaton-simulate

automaton_simulate-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+automaton_simulate/__init__.py,sha256=zkMW-VfdkxrKw6qZyH6vjCv_YKxL5h1RiuZTxG1FTkY,677
+automaton_simulate/automaton_main.py,sha256=BMs4-quNp4OC_BbR6I7WkkD_z2ZEe35xEqajM7V_Ipc,10363
+automaton_simulate/function_affiliate.py,sha256=JjweIMJJZ4hD8B6cKpjCja5qAlXiV6wNM0BEKpzR_RA,274
+automaton_simulate/random_machine.py,sha256=1UnX4QhI5Zoat4KipVtwci1T2SAyKrvu5jlZHgQJqQg,1568
+automaton_simulate/turing_machine_formal_language.py,sha256=-Oiz-GQt0tRq5TLsXTfuzbqs56Q-HoAzoUyQOevQeeQ,3110
+automaton_simulate/turing_machine_main.py,sha256=MF1agGWx7cQxz-WdMa1TNKo-lk7EFiTTOeQY_QURn-g,6175
+automaton_simulate/turing_machine_multitape.py,sha256=AlBwpwACdJXALNfoWx4xcpq-SL9lP7k9K7JjoxfITBU,5920
+automaton_simulate/turing_machine_nondeterministic.py,sha256=PY5XHPkcbObGDqUdSBE4sIiGxHLIxc-UMHVo7vL7z2w,6451
+automaton_simulate-0.1.0.dist-info/licenses/LICENSE,sha256=fU8tESbRE5wlGMODUQWtDc3LTO1z20PpiFiW51zeseI,1083
+automaton_simulate-0.1.0.dist-info/METADATA,sha256=gwugmX2Dmn9X2qJ5RYjfMM7ChFQA1rUhvFBsyF0mRm4,581
+automaton_simulate-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+automaton_simulate-0.1.0.dist-info/top_level.txt,sha256=vMJHsquhR1P1VST0e7nHSJDYuoQ5mH5ywd1KY88khco,19
+automaton_simulate-0.1.0.dist-info/RECORD,,

automaton_simulate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

automaton_simulate-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dayu811
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

automaton_simulate-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+automaton_simulate