turing-py 0.1.0__tar.gz

turing_py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eric Santos
+
+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.

turing_py-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: turing-py
+Version: 0.1.0
+Summary: Education Turing Machine simulator in Python
+Author-email: Eric Santos <ericshantos13@gmail.com>
+Project-URL: Homepage, https://github.com/ericshantos/turing-py
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# py-turing
+
+A simple and extensible **Turing Machine simulator written in Python**, designed for learning, experimentation, and educational purposes.
+
+This project allows users to define **states, transitions, and tapes** to simulate the behavior of a **deterministic Turing Machine**, one of the fundamental models in the theory of computation.
+
+---
+
+## 📚 About
+
+A **Turing Machine** is an abstract computational model introduced by **Alan Turing** in 1936. It is widely used in computer science to study the limits of computation and algorithm design.
+
+**py-turing** provides a Python implementation that enables:
+
+* Simulation of Turing Machines
+* Creation of custom transition rules
+* Step-by-step computation
+* Experimentation with theoretical algorithms
+
+This project is intended for:
+
+* Computer Science students
+* Theory of Computation courses
+* Developers interested in computational models
+* Educational demonstrations
+
+---
+
+## ✨ Features
+
+* Deterministic Turing Machine simulation
+* Customizable tape input
+* Configurable states and transitions
+* Step-by-step execution
+* Simple and modular Python architecture
+* Easy to extend and modify
+* CLI-ready structure
+
+---
+
+## 📂 Project Structure
+
+```
+py-turing/
+│
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+│
+├── src/
+    └── pyturing/
+        ├── __init__.py
+        │
+        ├── machine/
+        │   ├── __init__.py
+        │   ├── turing_machine.py
+        │   ├── tape.py
+        │   └── states.py
+        │
+        ├── alphabet/
+        │   ├── __init__.py
+        │   ├── symbol.py
+        │   ├── alphabet.py
+        │   └── tape_alphabet.py
+        │
+        └─ transition/
+            ├── __init__.py
+            ├── transition.py
+            ├── transition_function.py
+            └── direction.py
+```
+
+---
+
+## 🧪 Example Turing Machines
+
+Examples you can implement using **py-turing**:
+
+* Binary increment machine
+* Palindrome checker
+* Unary addition
+* Even/Odd binary checker
+* String copying machine
+
+---
+
+## 🧩 How It Works
+
+A Turing Machine consists of:
+
+* **Tape** – infinite memory divided into cells
+* **Head** – reads and writes symbols on the tape
+* **States** – machine configuration states
+* **Transition Function** – rules that determine the next action
+
+Each step follows this rule:
+
+```
+(Current State, Read Symbol) → (Next State, Write Symbol, Move Direction)
+```
+
+Where direction can be:
+
+* `L` → Move left
+* `R` → Move right
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome!
+
+To contribute:
+
+1. Fork the repository
+2. Create a new branch
+
+```bash
+git checkout -b feature/my-feature
+```
+
+3. Make your changes
+4. Commit your work
+
+```bash
+git commit -m "Add new feature"
+```
+
+5. Push to your fork
+
+```bash
+git push origin feature/my-feature
+```
+
+6. Open a Pull Request
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License**.
+
+---
+
+## 👨‍💻 Author
+
+Developed by **Eric Santos**.
+
+---

turing_py-0.1.0/README.md

@@ -0,0 +1,150 @@
+# py-turing
+
+A simple and extensible **Turing Machine simulator written in Python**, designed for learning, experimentation, and educational purposes.
+
+This project allows users to define **states, transitions, and tapes** to simulate the behavior of a **deterministic Turing Machine**, one of the fundamental models in the theory of computation.
+
+---
+
+## 📚 About
+
+A **Turing Machine** is an abstract computational model introduced by **Alan Turing** in 1936. It is widely used in computer science to study the limits of computation and algorithm design.
+
+**py-turing** provides a Python implementation that enables:
+
+* Simulation of Turing Machines
+* Creation of custom transition rules
+* Step-by-step computation
+* Experimentation with theoretical algorithms
+
+This project is intended for:
+
+* Computer Science students
+* Theory of Computation courses
+* Developers interested in computational models
+* Educational demonstrations
+
+---
+
+## ✨ Features
+
+* Deterministic Turing Machine simulation
+* Customizable tape input
+* Configurable states and transitions
+* Step-by-step execution
+* Simple and modular Python architecture
+* Easy to extend and modify
+* CLI-ready structure
+
+---
+
+## 📂 Project Structure
+
+```
+py-turing/
+│
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+│
+├── src/
+    └── pyturing/
+        ├── __init__.py
+        │
+        ├── machine/
+        │   ├── __init__.py
+        │   ├── turing_machine.py
+        │   ├── tape.py
+        │   └── states.py
+        │
+        ├── alphabet/
+        │   ├── __init__.py
+        │   ├── symbol.py
+        │   ├── alphabet.py
+        │   └── tape_alphabet.py
+        │
+        └─ transition/
+            ├── __init__.py
+            ├── transition.py
+            ├── transition_function.py
+            └── direction.py
+```
+
+---
+
+## 🧪 Example Turing Machines
+
+Examples you can implement using **py-turing**:
+
+* Binary increment machine
+* Palindrome checker
+* Unary addition
+* Even/Odd binary checker
+* String copying machine
+
+---
+
+## 🧩 How It Works
+
+A Turing Machine consists of:
+
+* **Tape** – infinite memory divided into cells
+* **Head** – reads and writes symbols on the tape
+* **States** – machine configuration states
+* **Transition Function** – rules that determine the next action
+
+Each step follows this rule:
+
+```
+(Current State, Read Symbol) → (Next State, Write Symbol, Move Direction)
+```
+
+Where direction can be:
+
+* `L` → Move left
+* `R` → Move right
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome!
+
+To contribute:
+
+1. Fork the repository
+2. Create a new branch
+
+```bash
+git checkout -b feature/my-feature
+```
+
+3. Make your changes
+4. Commit your work
+
+```bash
+git commit -m "Add new feature"
+```
+
+5. Push to your fork
+
+```bash
+git push origin feature/my-feature
+```
+
+6. Open a Pull Request
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License**.
+
+---
+
+## 👨‍💻 Author
+
+Developed by **Eric Santos**.
+
+---

turing_py-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name="turing-py"
+version="0.1.0"
+description = "Education Turing Machine simulator in Python"
+readme = "README.md"
+requires-python = ">=3.10"
+
+authors = [
+  { name = "Eric Santos", email = "ericshantos13@gmail.com" }
+]
+
+dependencies = []
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project.urls]
+"Homepage" = "https://github.com/ericshantos/turing-py"

turing_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

turing_py-0.1.0/src/turing_py.egg-info/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: turing-py
+Version: 0.1.0
+Summary: Education Turing Machine simulator in Python
+Author-email: Eric Santos <ericshantos13@gmail.com>
+Project-URL: Homepage, https://github.com/ericshantos/turing-py
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# py-turing
+
+A simple and extensible **Turing Machine simulator written in Python**, designed for learning, experimentation, and educational purposes.
+
+This project allows users to define **states, transitions, and tapes** to simulate the behavior of a **deterministic Turing Machine**, one of the fundamental models in the theory of computation.
+
+---
+
+## 📚 About
+
+A **Turing Machine** is an abstract computational model introduced by **Alan Turing** in 1936. It is widely used in computer science to study the limits of computation and algorithm design.
+
+**py-turing** provides a Python implementation that enables:
+
+* Simulation of Turing Machines
+* Creation of custom transition rules
+* Step-by-step computation
+* Experimentation with theoretical algorithms
+
+This project is intended for:
+
+* Computer Science students
+* Theory of Computation courses
+* Developers interested in computational models
+* Educational demonstrations
+
+---
+
+## ✨ Features
+
+* Deterministic Turing Machine simulation
+* Customizable tape input
+* Configurable states and transitions
+* Step-by-step execution
+* Simple and modular Python architecture
+* Easy to extend and modify
+* CLI-ready structure
+
+---
+
+## 📂 Project Structure
+
+```
+py-turing/
+│
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+│
+├── src/
+    └── pyturing/
+        ├── __init__.py
+        │
+        ├── machine/
+        │   ├── __init__.py
+        │   ├── turing_machine.py
+        │   ├── tape.py
+        │   └── states.py
+        │
+        ├── alphabet/
+        │   ├── __init__.py
+        │   ├── symbol.py
+        │   ├── alphabet.py
+        │   └── tape_alphabet.py
+        │
+        └─ transition/
+            ├── __init__.py
+            ├── transition.py
+            ├── transition_function.py
+            └── direction.py
+```
+
+---
+
+## 🧪 Example Turing Machines
+
+Examples you can implement using **py-turing**:
+
+* Binary increment machine
+* Palindrome checker
+* Unary addition
+* Even/Odd binary checker
+* String copying machine
+
+---
+
+## 🧩 How It Works
+
+A Turing Machine consists of:
+
+* **Tape** – infinite memory divided into cells
+* **Head** – reads and writes symbols on the tape
+* **States** – machine configuration states
+* **Transition Function** – rules that determine the next action
+
+Each step follows this rule:
+
+```
+(Current State, Read Symbol) → (Next State, Write Symbol, Move Direction)
+```
+
+Where direction can be:
+
+* `L` → Move left
+* `R` → Move right
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome!
+
+To contribute:
+
+1. Fork the repository
+2. Create a new branch
+
+```bash
+git checkout -b feature/my-feature
+```
+
+3. Make your changes
+4. Commit your work
+
+```bash
+git commit -m "Add new feature"
+```
+
+5. Push to your fork
+
+```bash
+git push origin feature/my-feature
+```
+
+6. Open a Pull Request
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License**.
+
+---
+
+## 👨‍💻 Author
+
+Developed by **Eric Santos**.
+
+---

turing_py-0.1.0/src/turing_py.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/turing_py.egg-info/PKG-INFO
+src/turing_py.egg-info/SOURCES.txt
+src/turing_py.egg-info/dependency_links.txt
+src/turing_py.egg-info/top_level.txt
+src/turingpy/__init__.py
+src/turingpy/alphabet/__init__.py
+src/turingpy/alphabet/input_alphabet.py
+src/turingpy/alphabet/symbol.py
+src/turingpy/alphabet/tape_alphabet.py
+src/turingpy/machine/__init__.py
+src/turingpy/machine/machine.py
+src/turingpy/machine/states.py
+src/turingpy/machine/tape.py
+src/turingpy/transition/__init__.py
+src/turingpy/transition/direction.py
+src/turingpy/transition/transition.py
+src/turingpy/transition/transition_function.py

turing_py-0.1.0/src/turing_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

turing_py-0.1.0/src/turing_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+turingpy

turing_py-0.1.0/src/turingpy/__init__.py

@@ -0,0 +1,21 @@
+from .transition import TransitionFunction
+from .transition import Transition
+
+from .alphabet import Alphabet
+from .alphabet import TapeAlphabet
+from .alphabet import Symbol
+
+from .machine import TuringMachine
+from .machine import States
+from .machine import Tape
+
+__all__ = [
+    "TransitionFunction",
+    "Transition",
+    "Alphabet",
+    "TapeAlphabet",
+    "Symbol",
+    "TuringMachine",
+    "States",
+    "Tape",
+]

turing_py-0.1.0/src/turingpy/alphabet/__init__.py

@@ -0,0 +1,5 @@
+from .input_alphabet import Alphabet
+from .tape_alphabet import TapeAlphabet
+from .symbol import Symbol
+
+__all__ = ["Alphabet", "TapeAlphabet", "Symbol"]

turing_py-0.1.0/src/turingpy/alphabet/input_alphabet.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""
+Input alphabet implementation for the Turing machine.
+
+@author: Eric Santos <ericshantos13@gmail.com>
+"""
+
+
+from typing import Iterator
+from .symbol import Symbol
+
+
+class Alphabet:
+    caracter: str = "Σ"
+
+    def __init__(self, *symbols: Symbol) -> None:
+
+        if not symbols:
+            raise ValueError("Alphabet cannot be empty")
+
+        self._symbols: set[Symbol] = set(symbols)
+
+    def __contains__(self, symbol: Symbol) -> bool:
+        return symbol in self._symbols
+
+    def __iter__(self) -> Iterator[Symbol]:
+        return iter(self._symbols)
+
+    def __str__(self) -> str:
+        return f"{self.caracter} = {{ {', '.join(str(s) for s in self._symbols)} }}"
+
+    def __or__(self, other: "Alphabet") -> "Alphabet":
+      if not isinstance(other, Alphabet):
+        return NotImplemented
+      return Alphabet(*(self._symbols | other._symbols))

turing_py-0.1.0/src/turingpy/alphabet/symbol.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""
+Symbol implementation for the Turing machine.
+
+@author: Eric Santos <ericshantos13@gmail.com>
+"""
+
+
+class Symbol:
+
+    _instances: dict[str, "Symbol"] = {}
+
+    def __new__(cls, value: str):
+
+      if value not in cls._instances:
+
+        instance = super().__new__(cls)
+        instance.value = value
+
+        cls._instances[value] = instance
+
+      return cls._instances[value]
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"Symbol({self.value})"
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, Symbol) and self.value == other.value
+    

turing_py-0.1.0/src/turingpy/alphabet/tape_alphabet.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+"""
+Tape alphabet implementation for the Turing machine.
+
+@Author: Eric Santos <ericshantos13@gmail.com>
+"""
+
+
+from .input_alphabet import Alphabet
+from .symbol import Symbol
+
+
+class TapeAlphabet(Alphabet):
+  caracter: str = "Γ"
+
+  def __init__(self, blank: Symbol, *symbols: Symbol) -> None:
+
+    super().__init__(*symbols)
+
+    if blank not in self._symbols:
+      raise ValueError("Blank must belong to the alphabet")
+
+    self.blank = blank
+    

turing_py-0.1.0/src/turingpy/machine/__init__.py

@@ -0,0 +1,6 @@
+
+from .machine import TuringMachine
+from .states import States
+from .tape import Tape
+
+__all__ = ["TuringMachine", "States", "Tape"]

turing_py-0.1.0/src/turingpy/machine/machine.py

@@ -0,0 +1,96 @@
+"""
+@author: Eric Santos <ericshantos13@gmail.com>
+
+Turing Machine implementation.
+"""
+
+
+from ..alphabet import Alphabet, TapeAlphabet, Symbol
+from .tape import Tape
+from ..transition import TransitionFunction
+
+
+class TuringMachine:
+    def __init__(
+        self,
+        states: str,
+        alphabet: Alphabet,
+        tape_alphabet: TapeAlphabet,
+        delta: TransitionFunction,
+        blank: Symbol
+    ):
+        self.states = states
+        self.alphabet = alphabet
+        self.tape_alphabet = tape_alphabet
+        self.delta = delta
+        self.blank = blank
+
+        self.head: int = 0
+
+    def run(
+      self,
+      input: str,
+      debug: bool = False,
+      max_steps: int = 10000
+    ) -> None:
+
+        steps = 0
+
+        self.states.current_state = self.states.initial_state
+        self._load_tape(input)
+
+        while self.states.current_state not in self.states.final_states:
+
+          if steps > max_steps:
+            raise RuntimeError("Max steps exceeded")
+
+          steps += 1
+
+          if debug:
+            print(self)
+
+          if not self._step():
+            break
+
+        if debug:
+          print(self)
+
+    def _load_tape(self, input: str) -> None:
+        alphabet = self.alphabet | self.tape_alphabet
+        self.tape = Tape(input, alphabet, self.blank)
+        self.head = 0
+
+    def _step(self) -> bool:
+        symbol = self.tape[self.head]
+
+        t = self.delta(self.states.current_state, symbol)
+
+        if t is None:
+            return False
+
+        self.tape[self.head] = t.new_symbol
+        self.states.current_state = t.new_state
+
+        self.head = t.direction.move(self.head)
+
+        return True
+
+    def __str__(self) -> str:
+
+      tape_str = "".join(str(s) for s in self.tape)
+
+      head_indicator = " " * self.head + "^"
+
+      return f"""
+        State : {self.states.current_state}
+        Head  : {self.head}
+        Tape  : {tape_str}
+                {head_indicator}
+      """
+
+    @property
+    def result(self) -> str:
+
+        tape = "".join(str(s) for s in self.tape)
+
+        return tape.rstrip(str(self.blank))

turing_py-0.1.0/src/turingpy/machine/states.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+@Author: Eric Santos <ericshantos13@gmail.com>
+
+States implementation for the Turing machine.
+"""
+
+
+from typing import Iterator
+
+
+class States:
+    def __init__(self, *states: str, initial_state: str, final_states: set[str]):
+        self._states = set(states)
+
+        if initial_state not in self._states:
+            raise ValueError("Initial state must belong to the state set")
+
+        if not final_states.issubset(self._states):
+            raise ValueError("Final states must belong to the state set")
+
+        self.initial_state = initial_state
+        self.current_state = initial_state
+        self.final_states = final_states
+
+    def __contains__(self, state: str) -> bool:
+        return state in self._states
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._states)
+
+    def __len__(self)-> int:
+        return len(self._states)
+
+    def __str__(self) -> str:
+        return f"Q = {self._states}"

turing_py-0.1.0/src/turingpy/machine/tape.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+@Author: Eric Santos <ericshantos13@gmail.com>
+
+Tape implementation for the Turing machine.
+"""
+
+
+from typing import Iterator
+from ..alphabet.symbol import Symbol
+from ..alphabet.input_alphabet import Alphabet
+
+
+class Tape:
+
+    def __init__(self, input: str, alphabet: Alphabet, blank: Symbol) -> None:
+
+        self.blank = blank
+        self.alphabet = alphabet
+
+        self._tape: list[Symbol] = [Symbol(c) for c in input]
+
+    def __getitem__(self, idx: int) -> Symbol:
+
+        if idx < 0:
+            raise IndexError("Head moved left of tape start")
+
+        if idx >= len(self._tape):
+            self._tape.extend([self.blank] * (idx - len(self._tape) + 1))
+
+        return self._tape[idx]
+
+    def __setitem__(self, idx: int, value: str) -> None:
+
+        if value not in self.alphabet:
+            raise ValueError(f"Symbol {value} not in alphabet")
+
+        if idx >= len(self._tape):
+            self._tape.extend([self.blank] * (idx - len(self._tape) + 1))
+
+        self._tape[idx] = value
+
+    def __str__(self) -> str:
+        return "".join(str(s) for s in self._tape)
+
+    def __len__(self) -> int:
+        return len(self._tape)
+
+    def __iter__(self) -> Iterator[Symbol]:
+      yield from self._tape
+
+    def __repr__(self) -> str:
+      return f"Tape({self._tape})"
+    

turing_py-0.1.0/src/turingpy/transition/__init__.py

@@ -0,0 +1,4 @@
+from .transition_function import TransitionFunction
+from .transition import Transition
+
+__all__ = ["TransitionFunction", "Transition"]

turing_py-0.1.0/src/turingpy/transition/direction.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""
+@Author: Eric Santos <ericshantos13@gmail.com>
+
+Module for the direction of the transition.
+"""
+
+
+from enum import Enum
+from collections.abc import Iterable
+
+class Direction(Enum):
+    RIGHT: int = 1
+    LEFT: int = -1
+
+    def move(self, head: int) -> int:
+        return head + self.value
+
+    def __str__(self) -> str:
+        return self.name
+    

turing_py-0.1.0/src/turingpy/transition/transition.py

@@ -0,0 +1,22 @@
+"""
+@Author: Eric Santos <ericshantos13@gmail.com>
+
+Transition implementation for the Turing machine.
+"""
+
+
+from dataclasses import dataclass
+from ..alphabet.symbol import Symbol
+from .direction import Direction
+
+
+@dataclass(frozen=True)
+class Transition:
+    state: str
+    symbol: Symbol
+    new_state: str
+    new_symbol: Symbol
+    direction: Direction
+
+    def __str__(self) -> str:
+        return f"δ({self.state}, {self.symbol}) → ({self.new_state}, {self.new_symbol}, {self.direction})"

turing_py-0.1.0/src/turingpy/transition/transition_function.py

@@ -0,0 +1,37 @@
+"""
+@author: Eric Santos <ericshantos13@gmail.com>
+
+This module defines the TransitionFunction class, which represents the 
+transition function of a finite automaton. It allows adding transitions 
+and retrieving transitions based on the current state and input symbol.
+"""
+
+
+from collections.abc import Iterable
+from .transition import Transition
+from ..alphabet import Symbol
+
+
+class TransitionFunction:
+    def __init__(self) -> None:
+        self._transitions: dict[tuple[str, Symbol], Transition] = {}
+
+    def add(self, *transitions: Transition) -> None:
+
+        for t in transitions:
+
+            if isinstance(t, Iterable) and not isinstance(t, Transition):
+                for tr in t:
+                    self._transitions[(tr.state, tr.symbol)] = tr
+            else:
+                self._transitions[(t.state, t.symbol)] = t
+
+    def __call__(self, state: str, symbol: Symbol) -> Transition | None:
+        return self._transitions.get((state, symbol))
+
+    def __str__(self) -> str:
+        return "\n".join(str(t) for t in self._transitions.values())
+
+    @property
+    def conjugates(self) -> dict[tuple[str, str], Transition]:
+        return self._transitions