Repository: hashberg-io/pauliopt (language: python)

Issue:
Pauli gadget support
Currently the library only supports ZX phase gadgets and CNOT layers. It would be great to support arbitrary Pauli gadgets and Clifford layers.

<img width="383" alt="image" src="https://user-images.githubusercontent.com/13847804/235445152-c3a71f32-7665-4ece-ad1b-a6d3431cbcc6.png">

- [ ] Pauli gadgets class
- [ ] Clifford layer class
- [ ] Drawing interface
- [ ] Pauli gadget extraction
- [ ] ZX representation?


Reference on Pauli gadgets: https://arxiv.org/pdf/1906.01734.pdf
Steiner tree improvement
At the moment the Steiner tree function create cycles:

Currently in the implementation, the Steiner tree contains nodes that need eliminating and the intermediate nodes are stored as edges, the added edges (`mst_branches`) are not necessarily disjoint.

https://github.com/sg495/pauliopt/blob/06c0178c93223733daea80f4829833a1f7a2bbe0/pauliopt/phase/phase_circuits.py#L79

Lets make the trees cycle free 😄 


Pauli gadget support
Currently the library only supports ZX phase gadgets and CNOT layers. It would be great to support arbitrary Pauli gadgets and Clifford layers.

<img width="383" alt="image" src="https://user-images.githubusercontent.com/13847804/235445152-c3a71f32-7665-4ece-ad1b-a6d3431cbcc6.png">

- [ ] Pauli gadgets class
- [ ] Clifford layer class
- [ ] Drawing interface
- [ ] Pauli gadget extraction
- [ ] ZX representation?


Reference on Pauli gadgets: https://arxiv.org/pdf/1906.01734.pdf


Discussion / hints:

Fix patch:
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 175de582..bb9fbaeb 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -1,3 +1,5 @@
 # Migrate code style to Black
 5ceb8eddf759df91f32faabde3fb3e895633f0ea
+# Apply black to merged results
+1232377d0c7e51258bd060b5b4f78ad79f1a6b45
 
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
new file mode 100644
index 00000000..88181e68
--- /dev/null
+++ b/.github/workflows/CI.yml
@@ -0,0 +1,113 @@
+name: CI
+
+on:
+  pull_request:
+    types:
+      - closed
+    branches:
+      - 'releases/**'
+
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [ x86_64, x86, aarch64, armv7, s390x, ppc64le ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+          manylinux: auto
+      - name: Upload wheels
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [ x64, x86 ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+          architecture: ${{ matrix.target }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: [ x86_64, aarch64 ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - name: Upload sdist
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    if: "startsWith(github.ref, 'refs/tags/')"
+    needs: [ linux, windows, macos, sdist ]
+    steps:
+      - uses: actions/download-artifact@v3
+        with:
+          name: wheels
+      - name: Publish to PyPI
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        with:
+          command: upload
+          args: --non-interactive --skip-existing *
diff --git a/Dockerfile b/Dockerfile
deleted file mode 100644
index 8c513231..00000000
--- a/Dockerfile
+++ /dev/null
@@ -1,20 +0,0 @@
-# Use the official Python 3.9 image as the base image
-FROM python:3.9
-
-# Set the working directory in the container
-WORKDIR /app
-
-# Copy the requirements to the container
-COPY ./requirements.txt .
-
-# Install the Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy the source code to the container
-COPY . .
-
-# Install pauliopt
-RUN python setup.py install
-
-# Execute all the unit tests in the ./tests folder
-CMD ["python", "-m", "unittest", "discover", "-s", "./tests/", "-p", "test_*.py"]
\ No newline at end of file
diff --git a/README.md b/README.md
index 76c30cb8..6067ffeb 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,28 @@
 # PauliOpt: A Python library to simplify quantum circuits.
+
 [![Generic badge](https://img.shields.io/badge/python-3.8+-green.svg)](https://docs.python.org/3.8/)
 [![Checked with Mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](https://github.com/python/mypy)
 [![PyPI version shields.io](https://img.shields.io/pypi/v/pauliopt.svg)](https://pypi.python.org/pypi/pauliopt/)
 [![PyPI status](https://img.shields.io/pypi/status/pauliopt.svg)](https://pypi.python.org/pypi/pauliopt/)
 [![Generic badge](https://img.shields.io/badge/supported%20by-Hashberg%20Quantum-blue)](https://hashberg.io/)
 
-PauliOpt is a Python library to simplify quantum circuits composed of phase and Pauli gadgets.
+PauliOpt is a Python library to simplify quantum circuits composed of phase and Pauli
+gadgets. We currently collect architecture-aware synthesis algorithms for circuits of
+phase gadgets, and we plan to add more algorithms in the future.
+
+## Currently, supported/implemented algorithms:
 
-<img src="phase_gadget_snippet.png" width="430" title="Snippet of a phase gadget.">
+We view this library as a collection of algorithms for the simplification of quantum
+circuits. We currently support the following algorithms:
 
-The [documentation](https://sg495.github.io/pauliopt/pauliopt/index.html) for this library was generated with [pdoc](https://pdoc3.github.io/pdoc/).
-Jupyter notebooks exemplifying various aspects of the library are available in the [notebooks](./notebooks) folder.
+- "Annealing Optimisation of Mixed ZX Phase Circuits" (arXiv:2206.11839)
+- "Architecture-Aware Synthesis of Stabilizer Circuits from Clifford Tableaus" (arXiv:
+  2309.08972)
 
-**Please Note:** This software library is in a pre-alpha development stage. It is not currently suitable for use by the public.
+**Please Note:** This software library is in a pre-alpha development stage. It is not
+currently suitable for use by the public.
+
+## Installation
 
 You can install the library with `pip`:
 
@@ -20,35 +30,98 @@ You can install the library with `pip`:
 pip install pauliopt
 ```
 
-If you already have the library installed and would like the latest version, you can also upgrade with `pip`:
+If you already have the library installed and would like the latest version, you can also
+upgrade with `pip`:
 
 ```
 pip install --upgrade pauliopt
 ```
 
-## Optimization of Circuits of Mixed ZX Phase Gadgets
+## Documentation
 
-**Step 1.** Create a circuit of Z and X phase gadgets.
+The [documentation](https://sg495.github.io/pauliopt/pauliopt/index.html) for this library
+was generated with [pdoc](https://pdoc3.github.io/pdoc/). Jupyter notebooks exemplifying
+various aspects of the library are available in the [notebooks](./notebooks) folder.
 
-<img src="readme-example-1.png" width="800" title="Creation of a circuit of phase gadgets.">
+## Usage
 
-**Step 2.** Select the desired qubit topology.
+The goal of this libary is to provide a simple interface and a collection of algorithms
+relevant for the synthesis of quantum circuits.
 
-<img src="readme-example-2.png" width="800" title="Selection of a topology.">
+### Example 1: Simplifying a circuit of phase gadgets
 
-**Step 3.** Instantiate an optimizer for the desired circuit and topology.
+As a first step we can create a ``PhaseCircuit`` object, which represents a trotterized
+circuit of phase gadegets.
 
-<img src="readme-example-3.png" width="800" title="Instantiation of an optimizer.">
+```python
+from pauliopt.phase import PhaseCircuit, Z, X, pi
 
-**Step 4.** Run a few iterations of simulated annealing and look at the simplified circuit.
+circ = PhaseCircuit(4)
+circ >>= Z(pi / 2) @ {0, 1}
+circ >>= X(pi) @ {0, 2}
+circ >>= X(-pi / 4) @ {1, 2, 3}
+circ >>= Z(pi / 4) @ {0, 3}
+circ >>= X(pi / 2) @ {0, 1, 3}
+```
 
-<img src="readme-example-4.png" width="800" title="Annealing.">
+We can then define the tolopogy of the device we want to map the circuit to. For example,
+we can define a circle topology with 4 qubits:
 
-## Unit tests
+```python
+from pauliopt.topologies import Topology
+
+topology = Topology.cycle(4)
+```
 
+Finally we can run a simulated annealing algorithm to find a nice optimized circuit:
 
-To run the unit tests, install the additional requirements using our `requirements.txt` (recommended python: 3.9), then to launch then, run:
+```python
+from pauliopt.phase import OptimizedPhaseCircuit
+
+num_cx_layers = 3
+opt_circ = OptimizedPhaseCircuit(circ, topology, num_cx_layers, rng_seed=0)
+```
+
+### Example 2: Synthesis of Clifford tableau's
+
+You can create a clifford tableau and append/prepend operations (H, S, CX), with the
+following code fragment:
+
+```python
+from pauliopt.clifford.tableau import CliffordTableau
+
+ct = CliffordTableau(3)
+
+ct.append_h(0)
+ct.append_cnot(0, 2)
+ct.append_s(1)
+```
+
+You can visualize the tableau with the following code fragment:
+
+```python
+print(ct)
+```
+
+To synthesize the circuit, you can use the following code fragment (note we have used to
+topology from above):
+
+```python
+from pauliopt.clifford.tableau_synthesis import synthesize_tableau
+
+qc, perm = synthesize_tableau(ct, topo, include_swaps=False)
+qc = qc.to_qiskit()
+print(qc)
+```
+
+## Unit tests
+
+To run the unit tests, install the additional requirements using
+our `requirements-dev.txt` (
+recommended python: 3.9), then to launch then, run:
 
 ```bash
-python -m unittest discover -s ./tests/ -p "test_*.py"
-```
\ No newline at end of file
+python -m unittest discover -s ./tests/ -p "test_*.py" -v 
+```
+
+(You must run this command from the root directory of the repository.)
\ No newline at end of file
diff --git a/notebooks/6. Pauli Polynomials.ipynb b/notebooks/6. Pauli Polynomials.ipynb
new file mode 100644
index 00000000..e5edd004
--- /dev/null
+++ b/notebooks/6. Pauli Polynomials.ipynb
@@ -0,0 +1,505 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4abbaa6c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pauliopt.pauli.pauli_polynomial import PauliPolynomial\n",
+    "from pauliopt.pauli.pauli_gadget import PPhase\n",
+    "from pauliopt.pauli.utils import I, Z, X, Y\n",
+    "from pauliopt.utils import Angle, pi\n",
+    "from pauliopt.topologies import Topology"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "173ba092",
+   "metadata": {},
+   "source": [
+    "# Pauli Polynomials\n",
+    "\n",
+    "## Pauli Gadgets\n",
+    "\n",
+    "Pauli Gadgets are mathematical expressions defined as:\n",
+    "\n",
+    "$$\n",
+    "P = \\exp(-i \\frac{\\alpha}{2} \\bigotimes_i P_i)\n",
+    "$$\n",
+    "\n",
+    "Here, \\(P_i\\) represents one of the Pauli matrices:\n",
+    "\n",
+    "- Pauli-X:\n",
+    "$$\n",
+    "X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\n",
+    "$$\n",
+    "- Pauli-Y:\n",
+    "$$\n",
+    "Y = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}\n",
+    "$$\n",
+    "- Pauli-Z:\n",
+    "$$\n",
+    "Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}\n",
+    "$$\n",
+    "- Identity:\n",
+    "$$\n",
+    "I = \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}\n",
+    "$$\n",
+    "\n",
+    "A formal definition and further information on Pauli gadgets can be found [here](https://arxiv.org/abs/1906.01734).\n",
+    "\n",
+    "Within `pauliopt`, Pauli gadgets are constructed in a similar way to Phase gadgets, following these steps:\n",
+    "- An angle is required, which can be an instance of `pauliopt.utils.Angle` or any object that satisfies the `pauliopt.utils.AngleProtocol` protocol.\n",
+    "- A list of legs is defined, where each leg corresponds to one of the Pauli matrices (X, Y, Z, I).\n",
+    "- The qubits spanned by the Pauli gadget are determined by the length of the list. If there are no qubits to be acted on, the Identity matrix is used.\n",
+    "\n",
+    "Example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a22d780c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.5) @ { I, Z, X, Y }"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pauli_gadget = PPhase(0.5) @ [I, Z, X, Y] # TODO Angle(pi)\n",
+    "pauli_gadget"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "641c0890",
+   "metadata": {},
+   "source": [
+    "We can define a Pauli gadget on a quantum circuit by following these steps:\n",
+    "\n",
+    "1. *Apply a set of Clifford gates:*\n",
+    "   - If the Pauli gadget is X, place the H-Gate on the corresponding qubit.\n",
+    "   - If the Pauli gadget is Y, apply the $\\sqrt{X}$ or V-Gate on the corresponding qubit.\n",
+    "   - If the Pauli gadget is Z or the Identity, no additional gate is applied.\n",
+    "2. *Create a CNOT-Ladder:*\n",
+    "   - Implement a sequence of CNOT gates between the target qubit and the control qubits.\n",
+    "3. *Perform an Rz(alpha) rotation:*\n",
+    "   - Apply the Rz(alpha) gate on the target qubit.\n",
+    "4. *Undo the process:*\n",
+    "   - Reverse the CNOT-Ladder by applying the CNOT gates in the opposite order.\n",
+    "   - Reapply the Clifford gates in the reverse order to undo their effects.\n",
+    "\n",
+    "Here's an example of a circuit showcasing these steps:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "71d6fc47",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                           \n",
+      "q_0: ──────────────────────────────────────────────────────\n",
+      "                     ┌───┐┌─────────┐┌───┐                 \n",
+      "q_1: ────────────────┤ X ├┤ Rz(0.5) ├┤ X ├─────────────────\n",
+      "        ┌───┐   ┌───┐└─┬─┘└─────────┘└─┬─┘┌───┐   ┌───┐    \n",
+      "q_2: ───┤ H ├───┤ X ├──■───────────────■──┤ X ├───┤ H ├────\n",
+      "     ┌──┴───┴──┐└─┬─┘                     └─┬─┘┌──┴───┴───┐\n",
+      "q_3: ┤ Rx(π/2) ├──■─────────────────────────■──┤ Rx(-π/2) ├\n",
+      "     └─────────┘                               └──────────┘\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(pauli_gadget.to_qiskit(Topology.line(4)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49fe3a52",
+   "metadata": {},
+   "source": [
+    "## Pauli Polynomial\n",
+    "\n",
+    "To construct a Pauli polynomial, we can chain together multiple Pauli gadgets. Each Pauli gadget acts on a specific set of qubits and contributes to the overall transformation of the system (you can view this as n-dimensional rotations acting sequentially). \n",
+    "\n",
+    "Here's an example illustrating the construction of a Pauli polynomial:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1c72d4e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(π) @ { I, I, X, Z, Y }\n",
+      "(π/2) @ { X, X, I, I, Y }\n",
+      "(π/256) @ { X, I, I, Z, Y }\n",
+      "(π/8) @ { X, X, X, Z, Y }\n",
+      "(π/4) @ { X, Z, I, I, Y }\n",
+      "(π/2) @ { X, I, I, Y, Y }\n"
+     ]
+    }
+   ],
+   "source": [
+    "pp = PauliPolynomial(5)\n",
+    "\n",
+    "pp >>= PPhase(Angle(pi)) @ [I, I, X, Z, Y]\n",
+    "pp >>= PPhase(Angle(pi/2)) @ [X, X, I, I, Y]\n",
+    "pp >>= PPhase(Angle(pi/256)) @ [X, I, I, Z, Y]\n",
+    "pp >>= PPhase(Angle(pi/8)) @ [X, X, X, Z, Y]\n",
+    "pp >>= PPhase(Angle(pi/4)) @ [X, Z, I, I, Y]\n",
+    "pp >>= PPhase(Angle(pi/2)) @ [X, I, I, Y, Y]\n",
+    "\n",
+    "# Representation in CLI applications\n",
+    "print(pp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f2007e30",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"610\" height=\"200\"><linearGradient id=\"ycolor\" x1=\"0%\" x2=\"100%\" y1=\"100%\" y2=\"0%\"><stop offset=\"0%\"  stop-color=\"#CCFFCC\"/><stop offset=\"50%\"  stop-color=\"#CCFFCC\"/><stop offset=\"50%\"  stop-color=\"#FF8888\"/><stop offset=\"100%\"  stop-color=\"#FF8888\"/></linearGradient>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 0, 130 L 10, 130\"/>\n",
+       "<path d=\"M 60 30 Q 63 81 30 120\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"10\" y=\"120\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 0, 160 L 10, 160\"/>\n",
+       "<path d=\"M 60 30 Q 74 97 30 150\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#FF8888\" stroke=\"black\" x=\"10\" y=\"150\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 0, 190 L 10, 190\"/>\n",
+       "<path d=\"M 60 30 Q 84 112 30 180\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"10\" y=\"180\" width=\"20\" height=\"20\"/>\n",
+       "<svg x=\"60\" y=\"10\" height=\"20\" width=\"50\"><rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"black\" fill=\"white\" stroke-width=\"5 %\"/><text x=\"50%\" y=\"50%\" width=\"100%\" height=\"100%\" font-size=\"100%\" dominant-baseline=\"middle\" text-anchor=\"middle\" >π</text></svg>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 0, 70 L 110, 70\"/>\n",
+       "<path d=\"M 160 30 Q 145 45 130 60\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"110\" y=\"60\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 0, 100 L 110, 100\"/>\n",
+       "<path d=\"M 160 30 Q 153 64 130 90\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"110\" y=\"90\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 30, 190 L 110, 190\"/>\n",
+       "<path d=\"M 160 30 Q 184 112 130 180\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"110\" y=\"180\" width=\"20\" height=\"20\"/>\n",
+       "<svg x=\"160\" y=\"10\" height=\"20\" width=\"50\"><rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"black\" fill=\"white\" stroke-width=\"5 %\"/><text x=\"50%\" y=\"50%\" width=\"100%\" height=\"100%\" font-size=\"100%\" dominant-baseline=\"middle\" text-anchor=\"middle\" >π/2</text></svg>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 130, 70 L 210, 70\"/>\n",
+       "<path d=\"M 260 30 Q 245 45 230 60\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"210\" y=\"60\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 30, 160 L 210, 160\"/>\n",
+       "<path d=\"M 260 30 Q 274 97 230 150\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#FF8888\" stroke=\"black\" x=\"210\" y=\"150\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 130, 190 L 210, 190\"/>\n",
+       "<path d=\"M 260 30 Q 284 112 230 180\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"210\" y=\"180\" width=\"20\" height=\"20\"/>\n",
+       "<svg x=\"260\" y=\"10\" height=\"20\" width=\"50\"><rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"black\" fill=\"white\" stroke-width=\"5 %\"/><text x=\"50%\" y=\"50%\" width=\"100%\" height=\"100%\" font-size=\"100%\" dominant-baseline=\"middle\" text-anchor=\"middle\" >π/256</text></svg>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 230, 70 L 310, 70\"/>\n",
+       "<path d=\"M 360 30 Q 345 45 330 60\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"310\" y=\"60\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 130, 100 L 310, 100\"/>\n",
+       "<path d=\"M 360 30 Q 353 64 330 90\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"310\" y=\"90\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 30, 130 L 310, 130\"/>\n",
+       "<path d=\"M 360 30 Q 363 81 330 120\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"310\" y=\"120\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 230, 160 L 310, 160\"/>\n",
+       "<path d=\"M 360 30 Q 374 97 330 150\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#FF8888\" stroke=\"black\" x=\"310\" y=\"150\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 230, 190 L 310, 190\"/>\n",
+       "<path d=\"M 360 30 Q 384 112 330 180\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"310\" y=\"180\" width=\"20\" height=\"20\"/>\n",
+       "<svg x=\"360\" y=\"10\" height=\"20\" width=\"50\"><rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"black\" fill=\"white\" stroke-width=\"5 %\"/><text x=\"50%\" y=\"50%\" width=\"100%\" height=\"100%\" font-size=\"100%\" dominant-baseline=\"middle\" text-anchor=\"middle\" >π/8</text></svg>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 330, 70 L 410, 70\"/>\n",
+       "<path d=\"M 460 30 Q 445 45 430 60\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"410\" y=\"60\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 330, 100 L 410, 100\"/>\n",
+       "<path d=\"M 460 30 Q 453 64 430 90\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#FF8888\" stroke=\"black\" x=\"410\" y=\"90\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 330, 190 L 410, 190\"/>\n",
+       "<path d=\"M 460 30 Q 484 112 430 180\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"410\" y=\"180\" width=\"20\" height=\"20\"/>\n",
+       "<svg x=\"460\" y=\"10\" height=\"20\" width=\"50\"><rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"black\" fill=\"white\" stroke-width=\"5 %\"/><text x=\"50%\" y=\"50%\" width=\"100%\" height=\"100%\" font-size=\"100%\" dominant-baseline=\"middle\" text-anchor=\"middle\" >π/4</text></svg>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 430, 70 L 510, 70\"/>\n",
+       "<path d=\"M 560 30 Q 545 45 530 60\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"#CCFFCC\" stroke=\"black\" x=\"510\" y=\"60\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 330, 160 L 510, 160\"/>\n",
+       "<path d=\"M 560 30 Q 574 97 530 150\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"510\" y=\"150\" width=\"20\" height=\"20\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 430, 190 L 510, 190\"/>\n",
+       "<path d=\"M 560 30 Q 584 112 530 180\" fill=\"none\" stroke=\"black\"/>\n",
+       "<rect fill=\"url(#ycolor)\" stroke=\"black\" x=\"510\" y=\"180\" width=\"20\" height=\"20\"/>\n",
+       "<svg x=\"560\" y=\"10\" height=\"20\" width=\"50\"><rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"black\" fill=\"white\" stroke-width=\"5 %\"/><text x=\"50%\" y=\"50%\" width=\"100%\" height=\"100%\" font-size=\"100%\" dominant-baseline=\"middle\" text-anchor=\"middle\" >π/2</text></svg>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 530, 70 L 610, 70\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 430, 100 L 610, 100\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 330, 130 L 610, 130\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 530, 160 L 610, 160\"/>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M 530, 190 L 610, 190\"/>\n",
+       "</svg>"
+      ],
+      "text/plain": [
+       "(π) @ { I, I, X, Z, Y }\n",
+       "(π/2) @ { X, X, I, I, Y }\n",
+       "(π/256) @ { X, I, I, Z, Y }\n",
+       "(π/8) @ { X, X, X, Z, Y }\n",
+       "(π/4) @ { X, Z, I, I, Y }\n",
+       "(π/2) @ { X, I, I, Y, Y }"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# SVG representation in e.g. Jupyter notebooks\n",
+    "pp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b74b67a2",
+   "metadata": {},
+   "source": [
+    "An example circuit of the Pauli Polynomial above, can be generated as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "08d1f442",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "        ┌───┐                                                       ┌───┐┌───┐»\n",
+      "q_0: ───┤ H ├───────────────────────────────────────────────────────┤ X ├┤ X ├»\n",
+      "        ├───┤                                                       └─┬─┘└─┬─┘»\n",
+      "q_1: ───┤ H ├─────────────────────────────────────────────────────────┼────■──»\n",
+      "        ├───┤   ┌───┐┌───┐┌───────┐┌───┐┌───┐   ┌───┐       ┌───┐     │       »\n",
+      "q_2: ───┤ H ├───┤ X ├┤ X ├┤ Rz(π) ├┤ X ├┤ X ├───┤ H ├───────┤ H ├─────┼───────»\n",
+      "        └───┘   └─┬─┘└─┬─┘└───────┘└─┬─┘└─┬─┘   └───┘       └───┘     │       »\n",
+      "q_3: ─────────────┼────■─────────────■────┼───────────────────────────┼───────»\n",
+      "     ┌─────────┐  │                       │  ┌──────────┐┌─────────┐  │       »\n",
+      "q_4: ┤ Rx(π/2) ├──■───────────────────────■──┤ Rx(-π/2) ├┤ Rx(π/2) ├──■───────»\n",
+      "     └─────────┘                             └──────────┘└─────────┘          »\n",
+      "«     ┌─────────┐┌───┐┌───┐   ┌───┐       ┌───┐   ┌───┐┌───┐┌───────────┐┌───┐»\n",
+      "«q_0: ┤ Rz(π/2) ├┤ X ├┤ X ├───┤ H ├───────┤ H ├───┤ X ├┤ X ├┤ Rz(π/256) ├┤ X ├»\n",
+      "«     └─────────┘└─┬─┘└─┬─┘   ├───┤       ├───┤   └─┬─┘└─┬─┘└───────────┘└─┬─┘»\n",
+      "«q_1: ─────────────■────┼─────┤ H ├───────┤ H ├─────┼────┼─────────────────┼──»\n",
+      "«                       │     └───┘       └───┘     │    │                 │  »\n",
+      "«q_2: ──────────────────┼───────────────────────────┼────┼─────────────────┼──»\n",
+      "«                       │                           │    │                 │  »\n",
+      "«q_3: ──────────────────┼───────────────────────────┼────■─────────────────■──»\n",
+      "«                       │  ┌──────────┐┌─────────┐  │                         »\n",
+      "«q_4: ──────────────────■──┤ Rx(-π/2) ├┤ Rx(π/2) ├──■─────────────────────────»\n",
+      "«                          └──────────┘└─────────┘                            »\n",
+      "«     ┌───┐   ┌───┐       ┌───┐   ┌───┐┌───┐┌───┐┌───┐┌─────────┐┌───┐┌───┐»\n",
+      "«q_0: ┤ X ├───┤ H ├───────┤ H ├───┤ X ├┤ X ├┤ X ├┤ X ├┤ Rz(π/8) ├┤ X ├┤ X ├»\n",
+      "«     └─┬─┘   └───┘       └───┘   └─┬─┘└─┬─┘└─┬─┘└─┬─┘└─────────┘└─┬─┘└─┬─┘»\n",
+      "«q_1: ──┼───────────────────────────┼────┼────┼────■───────────────■────┼──»\n",
+      "«       │                           │    │    │                         │  »\n",
+      "«q_2: ──┼───────────────────────────┼────┼────■─────────────────────────■──»\n",
+      "«       │                           │    │                                 »\n",
+      "«q_3: ──┼───────────────────────────┼────■─────────────────────────────────»\n",
+      "«       │  ┌──────────┐┌─────────┐  │                                      »\n",
+      "«q_4: ──■──┤ Rx(-π/2) ├┤ Rx(π/2) ├──■──────────────────────────────────────»\n",
+      "«          └──────────┘└─────────┘                                         »\n",
+      "«          ┌───┐┌───┐   ┌───┐       ┌───┐   ┌───┐┌───┐┌─────────┐┌───┐┌───┐»\n",
+      "«q_0: ─────┤ X ├┤ X ├───┤ H ├───────┤ H ├───┤ X ├┤ X ├┤ Rz(π/4) ├┤ X ├┤ X ├»\n",
+      "«     ┌───┐└─┬─┘└─┬─┘   └───┘       └───┘   └─┬─┘└─┬─┘└─────────┘└─┬─┘└─┬─┘»\n",
+      "«q_1: ┤ H ├──┼────┼───────────────────────────┼────■───────────────■────┼──»\n",
+      "«     ├───┤  │    │                           │                         │  »\n",
+      "«q_2: ┤ H ├──┼────┼───────────────────────────┼─────────────────────────┼──»\n",
+      "«     └───┘  │    │  ┌─────────┐              │                         │  »\n",
+      "«q_3: ───────■────┼──┤ Rx(π/2) ├──────────────┼─────────────────────────┼──»\n",
+      "«                 │  ├─────────┴┐┌─────────┐  │                         │  »\n",
+      "«q_4: ────────────■──┤ Rx(-π/2) ├┤ Rx(π/2) ├──■─────────────────────────■──»\n",
+      "«                    └──────────┘└─────────┘                               »\n",
+      "«        ┌───┐       ┌───┐   ┌───┐┌───┐┌─────────┐┌───┐┌───┐   ┌───┐    \n",
+      "«q_0: ───┤ H ├───────┤ H ├───┤ X ├┤ X ├┤ Rz(π/2) ├┤ X ├┤ X ├───┤ H ├────\n",
+      "«        └───┘       └───┘   └─┬─┘└─┬─┘└─────────┘└─┬─┘└─┬─┘   └───┘    \n",
+      "«q_1: ─────────────────────────┼────┼───────────────┼────┼──────────────\n",
+      "«                              │    │               │    │              \n",
+      "«q_2: ─────────────────────────┼────┼───────────────┼────┼──────────────\n",
+      "«                              │    │               │    │  ┌──────────┐\n",
+      "«q_3: ─────────────────────────┼────■───────────────■────┼──┤ Rx(-π/2) ├\n",
+      "«     ┌──────────┐┌─────────┐  │                         │  ├──────────┤\n",
+      "«q_4: ┤ Rx(-π/2) ├┤ Rx(π/2) ├──■─────────────────────────■──┤ Rx(-π/2) ├\n",
+      "«     └──────────┘└─────────┘                               └──────────┘\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(pp.to_qiskit())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc2407ad",
+   "metadata": {},
+   "source": [
+    "It is also possible to route such a polynomial on a certain type of architecture"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "774fb7c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "        ┌───┐                                                                 »\n",
+      "q_0: ───┤ H ├─────────────────────────────────────────────────────────────────»\n",
+      "        ├───┤                                                                 »\n",
+      "q_1: ───┤ H ├─────────────────────────────────────────────────────────────────»\n",
+      "        ├───┤        ┌───┐┌───────┐┌───┐┌───┐                                 »\n",
+      "q_2: ───┤ H ├────────┤ X ├┤ Rz(π) ├┤ X ├┤ H ├─────────────────────────────────»\n",
+      "        └───┘   ┌───┐└─┬─┘└───────┘└─┬─┘├───┤                            ┌───┐»\n",
+      "q_3: ───────────┤ X ├──■─────────────■──┤ X ├─────────────────────────■──┤ X ├»\n",
+      "     ┌─────────┐└─┬─┘                   └─┬─┘┌──────────┐┌─────────┐┌─┴─┐└─┬─┘»\n",
+      "q_4: ┤ Rx(π/2) ├──■───────────────────────■──┤ Rx(-π/2) ├┤ Rx(π/2) ├┤ X ├──■──»\n",
+      "     └─────────┘                             └──────────┘└─────────┘└───┘     »\n",
+      "«                    ┌───┐┌─────────┐┌───┐┌───┐┌───┐                           »\n",
+      "«q_0: ───────────────┤ X ├┤ Rz(π/2) ├┤ X ├┤ H ├┤ H ├───────────────────────────»\n",
+      "«               ┌───┐└─┬─┘└─────────┘└─┬─┘├───┤├───┤                           »\n",
+      "«q_1: ──────────┤ X ├──■───────────────■──┤ X ├┤ H ├───────────────────────────»\n",
+      "«          ┌───┐└─┬─┘                     └─┬─┘├───┤                           »\n",
+      "«q_2: ──■──┤ X ├──■─────────────────────────■──┤ X ├──■────────────────────────»\n",
+      "«     ┌─┴─┐└─┬─┘                               └─┬─┘┌─┴─┐┌───┐                 »\n",
+      "«q_3: ┤ X ├──■───────────────────────────────────■──┤ X ├┤ X ├──■──────────────»\n",
+      "«     └───┘                                         └───┘└─┬─┘┌─┴─┐┌──────────┐»\n",
+      "«q_4: ─────────────────────────────────────────────────────■──┤ X ├┤ Rx(-π/2) ├»\n",
+      "«                                                             └───┘└──────────┘»\n",
+      "«                                         ┌───┐┌───────────┐┌───┐┌───┐┌───┐»\n",
+      "«q_0: ────────────────────────────────────┤ X ├┤ Rz(π/256) ├┤ X ├┤ H ├┤ H ├»\n",
+      "«                                    ┌───┐└─┬─┘└───────────┘└─┬─┘├───┤└───┘»\n",
+      "«q_1: ────────────────────────────■──┤ X ├──■─────────────────■──┤ X ├──■──»\n",
+      "«                          ┌───┐┌─┴─┐└─┬─┘                       └─┬─┘┌─┴─┐»\n",
+      "«q_2: ──────────────────■──┤ X ├┤ X ├──■───────────────────────────■──┤ X ├»\n",
+      "«                ┌───┐┌─┴─┐└─┬─┘└───┘                                 └───┘»\n",
+      "«q_3: ───────────┤ X ├┤ X ├──■─────────────────────────────────────────────»\n",
+      "«     ┌─────────┐└─┬─┘└───┘                                                »\n",
+      "«q_4: ┤ Rx(π/2) ├──■───────────────────────────────────────────────────────»\n",
+      "«     └─────────┘                                                          »\n",
+      "«                                                          ┌───┐┌─────────┐»\n",
+      "«q_0: ─────────────────────────────────────────────────────┤ X ├┤ Rz(π/8) ├»\n",
+      "«     ┌───┐                                           ┌───┐└─┬─┘└─────────┘»\n",
+      "«q_1: ┤ H ├───────────────────────────────────────────┤ X ├──■─────────────»\n",
+      "«     ├───┤     ┌───┐                            ┌───┐└─┬─┘                »\n",
+      "«q_2: ┤ X ├──■──┤ H ├────────────────────────────┤ X ├──■──────────────────»\n",
+      "«     └─┬─┘┌─┴─┐├───┤                       ┌───┐└─┬─┘                     »\n",
+      "«q_3: ──■──┤ X ├┤ X ├───────────────────────┤ X ├──■───────────────────────»\n",
+      "«          └───┘└─┬─┘┌──────────┐┌─────────┐└─┬─┘                          »\n",
+      "«q_4: ────────────■──┤ Rx(-π/2) ├┤ Rx(π/2) ├──■────────────────────────────»\n",
+      "«                    └──────────┘└─────────┘                               »\n",
+      "«     ┌───┐┌───┐┌───┐                                                     ┌───┐»\n",
+      "«q_0: ┤ X ├┤ H ├┤ H ├─────────────────────────────────────────────────────┤ X ├»\n",
+      "«     └─┬─┘├───┤├───┤                                                ┌───┐└─┬─┘»\n",
+      "«q_1: ──■──┤ X ├┤ H ├────────────────────────────────────────────────┤ X ├──■──»\n",
+      "«          └─┬─┘├───┤┌───┐                                      ┌───┐└─┬─┘     »\n",
+      "«q_2: ───────■──┤ X ├┤ H ├───────────────────────────────────■──┤ X ├──■───────»\n",
+      "«               └─┬─┘├───┤                            ┌───┐┌─┴─┐└─┬─┘          »\n",
+      "«q_3: ────────────■──┤ X ├─────────────────────────■──┤ X ├┤ X ├──■────────────»\n",
+      "«                    └─┬─┘┌──────────┐┌─────────┐┌─┴─┐└─┬─┘└───┘               »\n",
+      "«q_4: ─────────────────■──┤ Rx(-π/2) ├┤ Rx(π/2) ├┤ X ├──■──────────────────────»\n",
+      "«                         └──────────┘└─────────┘└───┘                         »\n",
+      "«     ┌─────────┐┌───┐┌───┐┌───┐                                           »\n",
+      "«q_0: ┤ Rz(π/4) ├┤ X ├┤ H ├┤ H ├───────────────────────────────────────────»\n",
+      "«     └─────────┘└─┬─┘├───┤└───┘                                           »\n",
+      "«q_1: ─────────────■──┤ X ├────────────────────────────────────────────────»\n",
+      "«                     └─┬─┘┌───┐                                           »\n",
+      "«q_2: ──────────────────■──┤ X ├──■────────────────────────────────────────»\n",
+      "«                          └─┬─┘┌─┴─┐┌───┐     ┌─────────┐            ┌───┐»\n",
+      "«q_3: ───────────────────────■──┤ X ├┤ X ├──■──┤ Rx(π/2) ├────────────┤ X ├»\n",
+      "«                               └───┘└─┬─┘┌─┴─┐├─────────┴┐┌─────────┐└─┬─┘»\n",
+      "«q_4: ─────────────────────────────────■──┤ X ├┤ Rx(-π/2) ├┤ Rx(π/2) ├──■──»\n",
+      "«                                         └───┘└──────────┘└─────────┘     »\n",
+      "«                         ┌───┐┌─────────┐┌───┐┌───┐                    »\n",
+      "«q_0: ────────────────────┤ X ├┤ Rz(π/2) ├┤ X ├┤ H ├────────────────────»\n",
+      "«                    ┌───┐└─┬─┘└─────────┘└─┬─┘├───┤                    »\n",
+      "«q_1: ────────────■──┤ X ├──■───────────────■──┤ X ├──■─────────────────»\n",
+      "«          ┌───┐┌─┴─┐└─┬─┘                     └─┬─┘┌─┴─┐┌───┐          »\n",
+      "«q_2: ──■──┤ X ├┤ X ├──■─────────────────────────■──┤ X ├┤ X ├──■───────»\n",
+      "«     ┌─┴─┐└─┬─┘└───┘                               └───┘└─┬─┘┌─┴─┐┌───┐»\n",
+      "«q_3: ┤ X ├──■─────────────────────────────────────────────■──┤ X ├┤ X ├»\n",
+      "«     └───┘                                                   └───┘└─┬─┘»\n",
+      "«q_4: ───────────────────────────────────────────────────────────────■──»\n",
+      "«                                                                       »\n",
+      "«                 \n",
+      "«q_0: ────────────\n",
+      "«                 \n",
+      "«q_1: ────────────\n",
+      "«                 \n",
+      "«q_2: ────────────\n",
+      "«     ┌──────────┐\n",
+      "«q_3: ┤ Rx(-π/2) ├\n",
+      "«     ├──────────┤\n",
+      "«q_4: ┤ Rx(-π/2) ├\n",
+      "«     └──────────┘\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(pp.to_qiskit(Topology.line(pp.num_qubits)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a674d6c8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/6. Synthesis.ipynb b/notebooks/6. Synthesis.ipynb
index fb86ed3c..e228f6bc 100644
--- a/notebooks/6. Synthesis.ipynb
+++ b/notebooks/6. Synthesis.ipynb
@@ -848,9 +848,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/notebooks/7. Tableaus.ipynb b/notebooks/7. Tableaus.ipynb
new file mode 100644
index 00000000..f714a147
--- /dev/null
+++ b/notebooks/7. Tableaus.ipynb
@@ -0,0 +1,817 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5897e427-ba10-44b9-a36b-b0f6eab99539",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pauliopt.clifford.tableau import CliffordTableau\n",
+    "import qiskit\n",
+    "from qiskit import QuantumCircuit, transpile\n",
+    "from qiskit.quantum_info import Operator\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74a06002-d8ac-482f-92af-6d2c3363cc62",
+   "metadata": {},
+   "source": [
+    "# Clifford Tableau Synthesis\n",
+    "This is an outline of our work: *Architecture-Aware Synthesis of Stabilizer Circuits from Clifford Tableaus* (arxiv: 2309.08972). \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b718741a-904c-4dbd-b547-b1acd1059f99",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "## Clifford Tableaus\n",
+    "\n",
+    "Clifford tableaus are a compact way to represent quantum states and operations in the stabilizer formalism, which is a subset of all quantum operations that can be efficiently simulated classically. These tableaus are particularly useful in the study and simulation of quantum error-correcting codes and certain quantum algorithms.\n",
+    "\n",
+    "In the stabilizer formalism, the state of a quantum system is described by a set of stabilizer generators, which are Pauli operators (combinations of I, X, Y, and Z) that leave the state invariant. Similarly, destabilizer states are those not stabilized by the set of generators, offering a complete description of the system.\n",
+    "\n",
+    "A Clifford tableau is a binary matrix representation of these stabilizer and destabilizer states. Each row represents a stabilizer or destabilizer generator, and the columns correspond to the qubits and the Pauli operators acting on them. The tableau allows for efficient computation of the evolution of stabilizer states under Clifford operations (like CNOT-, H-, and S-gates) which are central to quantum error correction and fault-tolerant quantum computing.\n",
+    "\n",
+    "In Pauliopt a Clifford Tableau can be constructed as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2c5d9a64-89ee-4a41-9d6a-a7d0427d4408",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X/Z I/I I/I I/I I/I | + \n",
+      "I/I X/Z I/I I/I I/I | + \n",
+      "I/I I/I X/Z I/I I/I | + \n",
+      "I/I I/I I/I X/Z I/I | + \n",
+      "I/I I/I I/I I/I X/Z | + \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "ct = CliffordTableau(5)\n",
+    "\n",
+    "print(ct)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8ae30085-830e-49ce-b8a9-0e803abedfde",
+   "metadata": {},
+   "source": [
+    "You can append/prepend H, S and CNOT operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "22484d08-76cb-495a-9166-3f0d7f196ca0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Z/X I/I I/I I/I I/I | + \n",
+      "I/I X/Z I/I I/I I/I | + \n",
+      "I/I I/I X/Z I/I I/I | + \n",
+      "I/I I/I I/I X/Z I/I | + \n",
+      "I/I I/I I/I I/I X/Z | + \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "ct.append_h(0)\n",
+    "\n",
+    "print(ct)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c8ce6f29-14aa-4ea8-9e2e-2ea1bcd1bf5c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Z/X X/I I/I I/I I/I | + \n",
+      "I/X X/Z I/I I/I I/I | + \n",
+      "I/I I/I X/Z I/I I/I | + \n",
+      "I/I I/I I/I X/Z I/I | + \n",
+      "I/I I/I I/I I/I X/Z | + \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "ct.prepend_cnot(0, 1)\n",
+    "\n",
+    "print(ct)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "44106b1d-fff9-49a1-9edf-d6c2b790565b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Y/X X/I I/I I/I I/I | - \n",
+      "I/X X/Z I/I I/I I/I | + \n",
+      "I/I I/I X/Z I/I I/I | + \n",
+      "I/I I/I I/I X/Z I/I | + \n",
+      "I/I I/I I/I I/I X/Z | + \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "ct.prepend_s(0)\n",
+    "\n",
+    "print(ct)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c691f181-fc0c-4f30-8639-e9d8c8071922",
+   "metadata": {},
+   "source": [
+    "Internally the tableau is stored in a $2n \\times 2n$ binary matrix, which records the appending/prepending operations according to [1]."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "fdeb3e45-e4bf-409e-bcd8-b41ed8455d57",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 1, 0, 0, 0, 1, 0, 0, 0, 0],\n",
+       "       [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+       "       [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],\n",
+       "       [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],\n",
+       "       [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],\n",
+       "       [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+       "       [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],\n",
+       "       [0, 0, 0, 0, 0, 0, 0, 1, 0, 0],\n",
+       "       [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],\n",
+       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]], dtype=uint8)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ct.tableau"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "4174ecb7-a4d4-4a9a-9707-46f885d1014d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=uint8)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ct.signs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f90d7b2-b545-422e-a628-9552257918a8",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "## Clifford Tableau Synthesis\n",
+    "\n",
+    "Given now such a random clifford tableau (we will create it from a random clifford circuit) and a device connectivity (let's take a line graph for instance). You can synthesize the tableau to a circuit following the device constrains.\n",
+    "\n",
+    "Let's generate a random clifford circuit using qiskit:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ea27fe40-fe38-43bf-a029-b0edb984ae53",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tableau_from_circuit(tableau, circ):\n",
+    "    qreg = circ.qregs[0]\n",
+    "    circ = transpile(circ, basis_gates=[\"h\", \"s\", \"cx\"])\n",
+    "    for op in circ:\n",
+    "        if op.operation.name == \"h\":\n",
+    "            tableau.append_h(qreg.index(op.qubits[0]))\n",
+    "        elif op.operation.name == \"s\":\n",
+    "            tableau.append_s(qreg.index(op.qubits[0]))\n",
+    "        elif op.operation.name == \"cx\":\n",
+    "            tableau.append_cnot(qreg.index(op.qubits[0]), qreg.index(op.qubits[1]))\n",
+    "        else:\n",
+    "            raise TypeError(\n",
+    "                f\"Unrecongnized Gate type: {op.operation.name} for Clifford Tableaus\")\n",
+    "    return tableau\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2153ff91-82c9-41ed-b82e-dc19c23da2c9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Z/I X/X I/Z Z/X X/I | + \n",
+      "X/X X/Z Y/Z Y/Z I/I | - \n",
+      "I/I Y/X X/X I/Z Y/I | - \n",
+      "Z/Z Y/Z Z/I Z/Y Z/X | + \n",
+      "Y/X Y/I X/I X/I Y/Y | + \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "n_qubits = 5\n",
+    "\n",
+    "tableau = qiskit.quantum_info.random_clifford(n_qubits, seed=42)\n",
+    "\n",
+    "ct = CliffordTableau(n_qubits)\n",
+    "ct = tableau_from_circuit(ct, tableau.to_circuit())\n",
+    "print(ct)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5105b84a-9d78-406e-a485-e300b68b8cc3",
+   "metadata": {},
+   "source": [
+    "Now let's assume that there exists a quantum device with a line connectivity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "382518df-ddd8-405f-90f1-cfef98f3b1a8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Topology(5, [{3, 4}, {0, 1}, {2, 3}, {1, 2}])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pauliopt.topologies import Topology\n",
+    "\n",
+    "topo = Topology.line(n_qubits)\n",
+    "\n",
+    "topo"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47cbcc00-70c2-44ed-824f-a9a6fe63c29a",
+   "metadata": {},
+   "source": [
+    "The standard (highly simplified process !!) in a compilation framework is now to first optimize the clifford tableau and then route it to the specific qubit device.\n",
+    "\n",
+    "Let's do that using qiskit:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "2b251361-989b-42fd-942b-bd057ea1f1e3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[3, 4], [0, 1], [2, 3], [1, 2]]\n",
+      "         ┌───┐┌───┐     ┌───┐     ┌───┐     ┌───┐     ┌───┐                    »\n",
+      "q_0 -> 0 ┤ H ├┤ H ├──■──┤ H ├──■──┤ H ├──■──┤ H ├──■──┤ H ├────────────────────»\n",
+      "         ├───┤├───┤┌─┴─┐├───┤┌─┴─┐├───┤┌─┴─┐├───┤┌─┴─┐├───┤                    »\n",
+      "q_1 -> 1 ┤ S ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├────────────────────»\n",
+      "         ├───┤└───┘└───┘└───┘├───┤├───┤├───┤├───┤└───┘├───┤     ┌───┐     ┌───┐»\n",
+      "q_2 -> 2 ┤ H ├────────────■──┤ H ├┤ S ├┤ H ├┤ S ├──■──┤ H ├──■──┤ H ├──■──┤ H ├»\n",
+      "         ├───┤┌───┐┌───┐┌─┴─┐├───┤├───┤└───┘├───┤┌─┴─┐├───┤┌─┴─┐├───┤┌─┴─┐└───┘»\n",
+      "q_3 -> 3 ┤ H ├┤ S ├┤ H ├┤ X ├┤ H ├┤ H ├──■──┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├──■──»\n",
+      "         ├───┤└───┘└───┘└───┘└───┘└───┘┌─┴─┐├───┤├───┤└───┘└───┘└───┘└───┘┌─┴─┐»\n",
+      "q_4 -> 4 ┤ H ├─────────────────────────┤ X ├┤ H ├┤ H ├────────────────────┤ X ├»\n",
+      "         └───┘                         └───┘└───┘└───┘                    └───┘»\n",
+      "«                                  ┌───┐┌───┐     ┌───┐     ┌───┐          »\n",
+      "«q_0 -> 0 ──────────────────────■──┤ H ├┤ S ├──■──┤ H ├──■──┤ H ├──■───────»\n",
+      "«              ┌───┐     ┌───┐┌─┴─┐├───┤└───┘┌─┴─┐├───┤┌─┴─┐├───┤┌─┴─┐     »\n",
+      "«q_1 -> 1 ──■──┤ H ├──■──┤ H ├┤ X ├┤ H ├─────┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├──■──»\n",
+      "«         ┌─┴─┐├───┤┌─┴─┐└───┘└───┘└───┘     └───┘└───┘└───┘└───┘└───┘┌─┴─┐»\n",
+      "«q_2 -> 2 ┤ X ├┤ H ├┤ X ├─────────────────────────────────────────────┤ X ├»\n",
+      "«         ├───┤└───┘└───┘                                             └───┘»\n",
+      "«q_3 -> 3 ┤ H ├────────────────────────────────────────────────────────────»\n",
+      "«         ├───┤┌───┐┌───┐                                                  »\n",
+      "«q_4 -> 4 ┤ S ├┤ H ├┤ H ├──────────────────────────────────────────────────»\n",
+      "«         └───┘└───┘└───┘                                                  »\n",
+      "«                                                                          »\n",
+      "«q_0 -> 0 ─────────────────────────────────────────────────────────────────»\n",
+      "«         ┌───┐                         ┌───┐┌───┐┌───┐               ┌───┐»\n",
+      "«q_1 -> 1 ┤ H ├──────────────────────■──┤ H ├┤ S ├┤ H ├────────────■──┤ H ├»\n",
+      "«         ├───┤     ┌───┐     ┌───┐┌─┴─┐├───┤├───┤├───┤┌───┐┌───┐┌─┴─┐├───┤»\n",
+      "«q_2 -> 2 ┤ H ├──■──┤ H ├──■──┤ H ├┤ X ├┤ H ├┤ H ├┤ S ├┤ S ├┤ H ├┤ X ├┤ H ├»\n",
+      "«         └───┘┌─┴─┐├───┤┌─┴─┐└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘»\n",
+      "«q_3 -> 3 ─────┤ X ├┤ H ├┤ X ├─────────────────────────────────────────────»\n",
+      "«              └───┘└───┘└───┘                                             »\n",
+      "«q_4 -> 4 ─────────────────────────────────────────────────────────────────»\n",
+      "«                                                                          »\n",
+      "«                                                      \n",
+      "«q_0 -> 0 ─────────────────────────────────────────────\n",
+      "«              ┌───┐                                   \n",
+      "«q_1 -> 1 ──■──┤ H ├──■────────────────────────────────\n",
+      "«         ┌─┴─┐├───┤┌─┴─┐     ┌───┐┌───┐┌───┐┌───┐┌───┐\n",
+      "«q_2 -> 2 ┤ X ├┤ H ├┤ X ├──■──┤ H ├┤ H ├┤ S ├┤ S ├┤ H ├\n",
+      "«         └───┘└───┘└───┘┌─┴─┐├───┤└───┘├───┤└───┘└───┘\n",
+      "«q_3 -> 3 ───────────────┤ X ├┤ H ├──■──┤ H ├──────────\n",
+      "«                        └───┘└───┘┌─┴─┐├───┤┌───┐     \n",
+      "«q_4 -> 4 ─────────────────────────┤ X ├┤ H ├┤ H ├─────\n",
+      "«                                  └───┘└───┘└───┘     \n",
+      "Operations:  OrderedDict([('h', 60), ('cx', 25), ('s', 11)])\n",
+      "Depth:  49\n"
+     ]
+    }
+   ],
+   "source": [
+    "couplings = [[i, j] for i, j in topo.couplings]\n",
+    "print(couplings)\n",
+    "\n",
+    "inital_circuit = tableau.to_circuit()\n",
+    "qc = transpile(inital_circuit, \n",
+    "               basis_gates=[\"h\", \"s\", \"cx\"],                                       \n",
+    "               coupling_map=couplings,                      \n",
+    "               routing_method=\"sabre\",                      \n",
+    "               initial_layout=[i for i in range(n_qubits)])\n",
+    "\n",
+    "print(qc)\n",
+    "print(\"Operations: \", qc.count_ops())\n",
+    "print(\"Depth: \", qc.depth())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f6fa79d-1d49-48a4-90bf-d1d152e7e126",
+   "metadata": {},
+   "source": [
+    "In pauliopt you can achieve architecture-aware synthesis by using the `synthesize_tableau` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "a454549c-f43f-4ae2-aaec-ceec61e71688",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pauliopt.clifford.tableau_synthesis import synthesize_tableau"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "015b1352-346c-4f0b-931c-74feb7dc2598",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "     ┌───┐                                             ┌───┐               »\n",
+      "q_0: ┤ X ├──■──────────────────────────────────────────┤ X ├───────■───────»\n",
+      "     └─┬─┘┌─┴─┐                                   ┌───┐└─┬─┘     ┌─┴─┐┌───┐»\n",
+      "q_1: ──■──┤ X ├───────■───────────────────────────┤ X ├──■────■──┤ X ├┤ H ├»\n",
+      "     ┌───┐├───┤┌───┐┌─┴─┐                    ┌───┐└─┬─┘     ┌─┴─┐├───┤└───┘»\n",
+      "q_2: ┤ H ├┤ X ├┤ H ├┤ X ├───────■────────────┤ X ├──■────■──┤ X ├┤ X ├──■──»\n",
+      "     ├───┤└─┬─┘├───┤├───┤┌───┐┌─┴─┐     ┌───┐└─┬─┘     ┌─┴─┐├───┤└─┬─┘┌─┴─┐»\n",
+      "q_3: ┤ H ├──■──┤ X ├┤ S ├┤ H ├┤ X ├──■──┤ H ├──■───────┤ X ├┤ H ├──■──┤ X ├»\n",
+      "     ├───┤     └─┬─┘├───┤├───┤├───┤┌─┴─┐└───┘          └───┘└───┘     └───┘»\n",
+      "q_4: ┤ S ├───────■──┤ S ├┤ H ├┤ S ├┤ X ├───────────────────────────────────»\n",
+      "     └───┘          └───┘└───┘└───┘└───┘                                   »\n",
+      "«     ┌───┐                                                                 »\n",
+      "«q_0: ┤ X ├─────────────────────────────────────────────────────────────────»\n",
+      "«     └─┬─┘┌───┐     ┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐               »\n",
+      "«q_1: ──■──┤ H ├──■──┤ S ├┤ H ├┤ S ├┤ X ├┤ H ├┤ S ├┤ S ├┤ H ├───────────────»\n",
+      "«          └───┘┌─┴─┐├───┤├───┤└───┘└─┬─┘├───┤└───┘├───┤├───┤┌───┐┌───┐┌───┐»\n",
+      "«q_2: ──────────┤ X ├┤ H ├┤ X ├───────■──┤ H ├──■──┤ S ├┤ H ├┤ S ├┤ X ├┤ H ├»\n",
+      "«     ┌───┐     └───┘└───┘└─┬─┘          └───┘┌─┴─┐└───┘└───┘└───┘└─┬─┘├───┤»\n",
+      "«q_3: ┤ H ├─────────────────■─────────────────┤ X ├─────────────────■──┤ S ├»\n",
+      "«     └───┘                                   └───┘                    └───┘»\n",
+      "«q_4: ──────────────────────────────────────────────────────────────────────»\n",
+      "«                                                                           »\n",
+      "«                    \n",
+      "«q_0: ───────────────\n",
+      "«                    \n",
+      "«q_1: ───────────────\n",
+      "«     ┌───┐┌───┐┌───┐\n",
+      "«q_2: ┤ S ├┤ S ├┤ H ├\n",
+      "«     └───┘└───┘└───┘\n",
+      "«q_3: ───────────────\n",
+      "«                    \n",
+      "«q_4: ───────────────\n",
+      "«                    \n",
+      "Operations:  OrderedDict([('cx', 21), ('h', 18), ('s', 13)])\n",
+      "Depth:  31\n"
+     ]
+    }
+   ],
+   "source": [
+    "qc_po, _ = synthesize_tableau(ct, topo, include_swaps=False)\n",
+    "qc_po = qc_po.to_qiskit()\n",
+    "\n",
+    "print(qc_po)\n",
+    "print(\"Operations: \", qc_po.count_ops())\n",
+    "print(\"Depth: \", qc_po.depth())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "bc6b3fb4-4a2e-4995-9114-89ff21041f81",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Circuits Match:  True\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Circuits Match: \", Operator.from_circuit(qc_po).equiv(Operator.from_circuit(inital_circuit)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d19d19f7-8b85-4a58-ab2c-62354fc58d05",
+   "metadata": {},
+   "source": [
+    "We can see that this clearly improves the performance of a sampling a random clifford operator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "792705e3-2602-46fc-8fd2-464b6ba5c380",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "## Initial and final placement\n",
+    "\n",
+    "You can additionally let the algorithm select a initial and final placement for you (which will typically decrease the CNOT-count further)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "11b72639-a5c9-4416-b295-8ae1e4888a29",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                    ┌───┐                    ┌───┐     ┌───┐┌───┐          »\n",
+      "q_0: ────────────■──┤ X ├───────■────────────┤ X ├──■──┤ S ├┤ X ├──────────»\n",
+      "     ┌───┐       │  └─┬─┘┌───┐  │  ┌───┐     └─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐     »\n",
+      "q_1: ┤ S ├──■────┼────■──┤ X ├──┼──┤ H ├───────┼──┤ X ├──■────┼──┤ H ├─────»\n",
+      "     └───┘┌─┴─┐  │       └─┬─┘  │  ├───┤┌───┐  │  ├───┤┌─┴─┐  │  ├───┤┌───┐»\n",
+      "q_2: ─────┤ X ├──┼─────────■────┼──┤ S ├┤ H ├──┼──┤ S ├┤ X ├──┼──┤ H ├┤ S ├»\n",
+      "     ┌───┐└───┘┌─┴─┐          ┌─┴─┐├───┤└───┘  │  └───┘└───┘  │  ├───┤├───┤»\n",
+      "q_3: ┤ H ├─────┤ X ├──■───────┤ X ├┤ X ├───────■────■─────────■──┤ X ├┤ H ├»\n",
+      "     └───┘     └───┘┌─┴─┐     └───┘└─┬─┘          ┌─┴─┐          └─┬─┘└───┘»\n",
+      "q_4: ───────────────┤ X ├────────────■────────────┤ X ├────────────■───────»\n",
+      "                    └───┘                         └───┘                    »\n",
+      "«               ┌───┐          ┌───┐┌───┐               ┌───┐┌───┐┌───┐     »\n",
+      "«q_0: ───────■──┤ S ├──■───────┤ X ├┤ X ├────────────■──┤ X ├┤ S ├┤ H ├─────»\n",
+      "«            │  └───┘┌─┴─┐┌───┐└─┬─┘└─┬─┘┌───┐       │  └─┬─┘├───┤├───┤┌───┐»\n",
+      "«q_1: ───────┼───────┤ X ├┤ H ├──┼────■──┤ S ├───────┼────■──┤ S ├┤ H ├┤ S ├»\n",
+      "«     ┌───┐  │  ┌───┐├───┤├───┤  │       └───┘       │       └───┘└───┘└───┘»\n",
+      "«q_2: ┤ S ├──┼──┤ H ├┤ S ├┤ S ├──┼───────────────────┼──────────────────────»\n",
+      "«     └───┘┌─┴─┐└───┘├───┤└───┘  │  ┌───┐┌───┐┌───┐┌─┴─┐┌───┐┌───┐          »\n",
+      "«q_3: ─────┤ X ├──■──┤ H ├───────■──┤ S ├┤ H ├┤ S ├┤ X ├┤ S ├┤ S ├──────────»\n",
+      "«          └───┘┌─┴─┐├───┤┌───┐┌───┐├───┤└───┘└───┘└───┘└───┘└───┘          »\n",
+      "«q_4: ──────────┤ X ├┤ H ├┤ S ├┤ S ├┤ H ├───────────────────────────────────»\n",
+      "«               └───┘└───┘└───┘└───┘└───┘                                   »\n",
+      "«          ┌───┐┌───┐┌───┐┌───┐┌───┐     \n",
+      "«q_0: ──■──┤ H ├┤ H ├┤ S ├┤ S ├┤ H ├─────\n",
+      "«     ┌─┴─┐├───┤├───┤├───┤├───┤├───┤┌───┐\n",
+      "«q_1: ┤ X ├┤ H ├┤ S ├┤ S ├┤ H ├┤ S ├┤ S ├\n",
+      "«     └───┘└───┘└───┘└───┘└───┘└───┘└───┘\n",
+      "«q_2: ───────────────────────────────────\n",
+      "«                                        \n",
+      "«q_3: ───────────────────────────────────\n",
+      "«                                        \n",
+      "«q_4: ───────────────────────────────────\n",
+      "«                                        \n",
+      "OrderedDict([('s', 25), ('cx', 21), ('h', 19)])\n"
+     ]
+    }
+   ],
+   "source": [
+    "qc_po, _ = synthesize_tableau(ct, topo, include_swaps=True)\n",
+    "qc_po = qc_po.to_qiskit()\n",
+    "\n",
+    "print(qc_po)\n",
+    "print(qc_po.count_ops())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bb0e9f6-e2f4-431e-82a5-e04106aeebb1",
+   "metadata": {},
+   "source": [
+    "## Experiments in arxiv: 2309.08972\n",
+    "\n",
+    "To verify our results we conducted a numerical study evaluating our algorithm against the typical used IBM Backends (2022).\n",
+    "\n",
+    "Let's just repeat this study for `IBM_Guadalupe`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "cbb5a60f-dd4d-4ef6-ba21-03299e6980af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def random_clifford_circuit(nr_gates=20, nr_qubits=4, gate_choice=None):\n",
+    "    qc = QuantumCircuit(nr_qubits)\n",
+    "    if gate_choice is None:\n",
+    "        gate_choice = [\"CY\", \"CZ\", \"CX\", \"H\", \"S\", \"V\"]\n",
+    "    for _ in range(nr_gates):\n",
+    "        gate_t = np.random.choice(gate_choice)\n",
+    "        if gate_t == \"CX\":\n",
+    "            control = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            target = np.random.choice([i for i in range(nr_qubits) if i != control])\n",
+    "            qc.cx(control, target)\n",
+    "        elif gate_t == \"CY\":\n",
+    "            control = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            target = np.random.choice([i for i in range(nr_qubits) if i != control])\n",
+    "            qc.cy(control, target)\n",
+    "        elif gate_t == \"CZ\":\n",
+    "            control = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            target = np.random.choice([i for i in range(nr_qubits) if i != control])\n",
+    "            qc.cz(control, target)\n",
+    "        elif gate_t == \"H\":\n",
+    "            qubit = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            qc.h(qubit)\n",
+    "        elif gate_t == \"S\":\n",
+    "            qubit = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            qc.s(qubit)\n",
+    "        elif gate_t == \"V\":\n",
+    "            qubit = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            qc.sx(qubit)\n",
+    "        elif gate_t == \"CX\":\n",
+    "            control = np.random.choice([i for i in range(nr_qubits)])\n",
+    "            target = np.random.choice([i for i in range(nr_qubits) if i != control])\n",
+    "            qc.cx(control, target)\n",
+    "    return qc\n",
+    "\n",
+    "\n",
+    "def random_hscx_circuit(nr_gates=20, nr_qubits=4):\n",
+    "    gate_choice = [\"CX\", \"H\", \"S\"]\n",
+    "    return random_clifford_circuit(nr_gates=nr_gates,\n",
+    "                                   nr_qubits=nr_qubits,\n",
+    "                                   gate_choice=gate_choice)\n",
+    "\n",
+    "def get_ops_count(qc: QuantumCircuit):\n",
+    "    count = {\"h\": 0, \"cx\": 0, \"s\": 0, \"depth\": qc.depth()}\n",
+    "    ops = qc.count_ops()\n",
+    "    if \"cx\" in ops.keys():\n",
+    "        count[\"cx\"] += ops['cx']\n",
+    "    if \"h\" in ops.keys():\n",
+    "        count[\"h\"] += ops[\"h\"]\n",
+    "    if \"s\" in ops.keys():\n",
+    "        count[\"s\"] += ops[\"s\"]\n",
+    "    return count\n",
+    "\n",
+    "\n",
+    "def our_compilation(circ: QuantumCircuit, topology):\n",
+    "    ct = CliffordTableau(circ.num_qubits)\n",
+    "    ct = tableau_from_circuit(ct, circ)\n",
+    "    circ_out, _ = synthesize_tableau(ct, topo, include_swaps=True)\n",
+    "    circ_out = circ_out.to_qiskit()\n",
+    "    column = get_ops_count(circ_out)\n",
+    "    return column\n",
+    "\n",
+    "def qiskit_compilation(circ: QuantumCircuit, topology):\n",
+    "    couplings = [[i, j] for i, j in topo.couplings]\n",
+    "    qc = qiskit.quantum_info.Clifford(circ).to_circuit()\n",
+    "    circ_out = transpile(qc, \n",
+    "               basis_gates=[\"h\", \"s\", \"cx\"],                                       \n",
+    "               coupling_map=couplings,                      \n",
+    "               routing_method=\"sabre\")\n",
+    "\n",
+    "    column = get_ops_count(circ_out)\n",
+    "    return column"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "4dc25ce4-4982-4363-bdd6-a760c4941417",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# see our paper for an outline of all connectivity graphs.\n",
+    "guadalupe_connectivity = [[0, 1], [1, 0], [1, 2], [1, 4], [2, 1], [2, 3], [3, 2], [3, 5], [4, 1], [4, 7], [5, 3], [5, 8], [6, 7], [7, 4], [7, 6], [7, 10], [8, 5], [8, 9], [8, 11], [9, 8], [10, 7], [10, 12], [11, 8], [11, 14], [12, 10], [12, 13], [12, 15], [13, 12], [13, 14], [14, 11], [14, 13], [15, 12]]\n",
+    "\n",
+    "topo = Topology.from_dict({\n",
+    "    \"num_qubits\": 16,\n",
+    "    \"couplings\": guadalupe_connectivity})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "d5bce23e-52ef-4cfd-a10c-141d13eebac8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame(columns=[\"n_rep\", \"nr_gates\", \"method\", \"h\", \"s\", \"cx\", \"depth\"])\n",
+    "\n",
+    "for num_gates in range(1, 400, 40):\n",
+    "    for _ in range(20):\n",
+    "        circ = random_hscx_circuit(nr_qubits=topo.num_qubits, nr_gates=num_gates)\n",
+    "\n",
+    "        column = {\"n_rep\": _, \"nr_gates\": num_gates, \"method\": \"ours\"} | our_compilation(circ, topo)\n",
+    "\n",
+    "        df.loc[len(df)] = column\n",
+    "\n",
+    "        column = {\"n_rep\": _, \"nr_gates\": num_gates, \"method\": \"qiskit\"} | qiskit_compilation(circ, topo)\n",
+    "\n",
+    "        df.loc[len(df)] = column\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "4080f94d-fbb0-41cd-b1cf-6a627ae030bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.lineplot(df, x=\"nr_gates\", y=\"h\", hue=\"method\")\n",
+    "plt.title(\"H-Gates\")\n",
+    "plt.xlabel(\"Number of input Gates\")\n",
+    "plt.ylabel(\"Number of H-Gates\")\n",
+    "plt.show()\n",
+    "\n",
+    "sns.lineplot(df, x=\"nr_gates\", y=\"s\", hue=\"method\")\n",
+    "plt.title(\"S-Gates\")\n",
+    "plt.xlabel(\"Number of input gates\")\n",
+    "plt.ylabel(\"Number of S-Gates\")\n",
+    "plt.show()\n",
+    "\n",
+    "sns.lineplot(df, x=\"nr_gates\", y=\"cx\", hue=\"method\")\n",
+    "plt.title(\"CNOT-Gates\")\n",
+    "plt.xlabel(\"Number of input Gates\")\n",
+    "plt.ylabel(\"Number of CNOT-Gates\")\n",
+    "plt.show()\n",
+    "\n",
+    "sns.lineplot(df, x=\"nr_gates\", y=\"depth\", hue=\"method\")\n",
+    "plt.title(\"Depth\")\n",
+    "plt.xlabel(\"Number of input Gates\")\n",
+    "plt.ylabel(\"Circuit Depth\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05876290-72c6-4b11-9269-c28d9880b769",
+   "metadata": {},
+   "source": [
+    "We can see that on average we can improve the CNOT count. \n",
+    "\n",
+    "Nevertheless there is quite some room for improvement, since we converge fast to the asymptotic upperbound of $\\mathcal{O}(n^2)$ in terms of H, S and CNOT-Gates,"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e9e51d1-27af-4eea-9b87-3a00a36dcf77",
+   "metadata": {},
+   "source": [
+    "Note that this is just a outline of our experiments. \n",
+    "For a complete implementation, see: https://github.com/daehiff/pauliopt/blob/dev/experiments/clifford_experiment.py "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "821b792f-5161-437a-ad17-1144a683cb7f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pauliopt/circuits.py b/pauliopt/circuits.py
index 3dfdc46a..7fdcc402 100644
--- a/pauliopt/circuits.py
+++ b/pauliopt/circuits.py
@@ -2,13 +2,54 @@
 A general class for quantum circuits, with a ZX / Gadget representation.
 """
 
-from math import ceil, log10
+from math import log10
 from typing import List
 
 import numpy as np
 
+from pauliopt.gates import *
 from pauliopt.utils import SVGBuilder
-from pauliopt.gates import Gate
+
+QISKIT_CONVERSION = {
+    "h": lambda qubits, _: H(*qubits),
+    "x": lambda qubits, _: X(*qubits),
+    "y": lambda qubits, _: Y(*qubits),
+    "z": lambda qubits, _: Z(*qubits),
+    "s": lambda qubits, _: S(*qubits),
+    "sdg": lambda qubits, _: Sdg(*qubits),
+    "t": lambda qubits, _: T(*qubits),
+    "tdg": lambda qubits, _: Tdg(*qubits),
+    "swap": lambda qubits, _: SWAP(*qubits),
+    "cx": lambda qubits, _: CX(*qubits),
+    "cy": lambda qubits, _: CY(*qubits),
+    "cz": lambda qubits, _: CZ(*qubits),
+    "ccx": lambda qubits, _: CCX(*qubits),
+    "ccz": lambda qubits, _: CCZ(*qubits),
+    "rx": lambda qubits, params: Rx(params[0], *qubits),
+    "ry": lambda qubits, params: Ry(params[0], *qubits),
+    "rz": lambda qubits, params: Rz(params[0], *qubits),
+    "crx": lambda qubits, params: CRx(params[0], *qubits),
+    "cry": lambda qubits, params: CRy(params[0], *qubits),
+    "crz": lambda qubits, params: CRz(params[0], *qubits),
+}
+
+
+def _get_phase_qiskit(params):
+    if len(params) == 0:
+        return None
+    else:
+        return params
+
+
+def _get_qubits_qiskit(qubits, qreg):
+    """
+    Helper method to read the qubit indices from the qiskit quantum register.
+    """
+    qubits_ = []
+    for qubit in qubits:
+        qubits_.append(qreg.index(qubit))
+
+    return tuple(qubits_)
 
 
 class Circuit:
@@ -38,14 +79,15 @@ def to_phase_circuit(self):
 
     def _check_gate(self, gate):
         n_qubits = self.n_qubits
-        for gate in self._gates:
-            if not isinstance(gate, Gate):
-                raise TypeError(f"{gate} is not a valid gate.")
-            if len(set(gate.qubits)) != len(gate.qubits):
-                raise ValueError(f"{gate.qubits} are not unique.")
-            if any(not (0 <= qubit < n_qubits) for qubit in gate.qubits):
-                msg = f"{gate} acts out of range for {n_qubits} qubit circuit."
-                raise ValueError(msg)
+        if not isinstance(gate, Gate):
+            raise TypeError(f"{gate} is not a valid gate.")
+
+        if len(set(gate.qubits)) != len(gate.qubits):
+            raise ValueError(f"{gate.qubits} are not unique.")
+
+        if any(not (0 <= qubit < n_qubits) for qubit in gate.qubits):
+            msg = f"{gate} acts out of range for {n_qubits} qubit circuit."
+            raise ValueError(msg)
 
     def __repr__(self) -> str:
         return f"Circuit({self.n_qubits}, {self._gates})"
@@ -129,3 +171,27 @@ def _to_svg(
         except ModuleNotFoundError:
             raise ModuleNotFoundError("You must install the 'IPython' library.")
         return SVG(svg_code)
+
+    @staticmethod
+    def from_qiskit(qc: "qiskit.QuantumCircuit"):
+        circ = Circuit(qc.num_qubits)
+
+        for inst in qc:
+            qubits = _get_qubits_qiskit(inst.qubits, qc.qregs[0])
+            phase = _get_phase_qiskit(inst.operation.params)
+            circ.add_gate(QISKIT_CONVERSION[inst.operation.name](qubits, phase))
+
+        return circ
+
+    def to_qiskit(self):
+        try:
+            from qiskit import QuantumCircuit
+        except ModuleNotFoundError:
+            raise ModuleNotFoundError("You must install the 'qiskit' library.")
+
+        qc = QuantumCircuit(self.n_qubits)
+
+        for gate in self._gates:
+            op, qubits = gate.to_qiskit()
+            qc.append(op, qubits)
+        return qc
diff --git a/pauliopt/py.typed b/pauliopt/clifford/__init__.py
similarity index 100%
rename from pauliopt/py.typed
rename to pauliopt/clifford/__init__.py
diff --git a/pauliopt/clifford/tableau.py b/pauliopt/clifford/tableau.py
new file mode 100644
index 00000000..b95ace5e
--- /dev/null
+++ b/pauliopt/clifford/tableau.py
@@ -0,0 +1,372 @@
+import numpy as np
+
+
+def mult_paulis(p1, p2, sign1, sign2, n_qubits):
+    """
+    Small helper function to multiply two Pauli strings and correctly update the sign.
+
+    Args:
+        p1 (np.ndarray): Pauli string 1
+        p2 (np.ndarray): Pauli string 2
+        sign1 (int): Sign of Pauli string 1
+        sign2 (int): Sign of Pauli string 2
+        n_qubits (int): Number of qubits in the Pauli strings
+
+    Returns:
+        np.ndarray: Pauli string 1 * Pauli string 2
+    """
+    x_1 = p1[:n_qubits].copy()
+    z_1 = p1[n_qubits:].copy()
+    x_2 = p2[:n_qubits].copy()
+    z_2 = p2[n_qubits:].copy()
+
+    x_1_z_2 = z_1 * x_2
+    z_1_x_2 = x_1 * z_2
+
+    ac = (x_1_z_2 + z_1_x_2) % 2
+
+    x_1 = (x_1 + x_2) % 2
+    z_1 = (z_1 + z_2) % 2
+
+    x_1_z_2 = ((x_1_z_2 + x_1 + z_1) % 2) * ac
+    sign_change = int(((np.sum(ac) + 2 * np.sum(x_1_z_2)) % 4) > 1)
+    new_sign = (sign1 + sign2 + sign_change) % 4
+    new_p1 = np.concatenate([x_1, z_1])
+    return new_p1, new_sign
+
+
+class CliffordTableau:
+    """
+    Class for storing and manipulating Clifford tableau.
+    A Clifford tableau is a representation of a Clifford circuit as a
+    2n x 2n binary matrix, where n is the number of qubits. The first n rows
+    represent the stabilizers, and the last n rows represent the destabilizers.
+    The first n columns represent the X operators, and the last n columns
+    represent the Z operators.
+    The sign of the operator in row i is given by the i-th entry of
+    the sign vector.
+
+    The tableau is initialized as the identity matrix with a zero sign vector.
+
+    Args:
+        n_qubits (int): Number of qubits in the tableau.
+
+
+    A more readable representation of the tableau is given by the string:
+    ```python
+    >>> from pauliopt.clifford.tableau import CliffordTableau
+    >>> ct = CliffordTableau(2)
+    >>> print(ct)
+    # Expected Output:
+    # X/Z I/I | +
+    # I/I X/Z | +
+    >>> ct.append_h(0)
+    >>> print(ct)
+    # Expected Output:
+    # Z/X I/I | +
+    # I/I X/Z | +
+    ```
+
+    To get the raw $2n \times 2n$ matrix representation of the tableau, use:
+    ```python
+    >>> ct.tableau
+    # Expected Output:
+    # array([[0, 0, 1, 0],
+    #        [0, 1, 0, 0],
+    #        [1, 0, 0, 0],
+    #        [0, 0, 0, 1]], dtype=uint8)
+    ```
+    To get the sign vector, use:
+    ```python
+    >>> ct.signs
+    # Expected Output:
+    # array([0, 0, 0, 0], dtype=uint8)
+    ```
+
+    """
+
+    def __init__(self, n_qubits):
+        self.tableau = np.eye(2 * n_qubits, dtype=np.uint8)
+        self.signs = np.zeros((2 * n_qubits), dtype=np.uint8)
+        self.n_qubits = n_qubits
+
+    def __str__(self) -> str:
+        out = str(self.string_repr(sep=" "))
+        return out
+
+    @staticmethod
+    def from_tableau(tableau, signs):
+        """
+        Create a CliffordTableau from a tableau and sign vector.
+
+        Args:
+            tableau (np.ndarray): $2n \times 2n$ binary matrix representing the tableau.
+            signs (np.ndarray): $2n$-dimensional binary vector representing the sign vector.
+
+        Returns:
+            CliffordTableau: CliffordTableau object.
+        """
+        n_qubits = tableau.shape[0] // 2
+        if not (
+            tableau.shape == (2 * n_qubits, 2 * n_qubits)
+            and signs.shape == (2 * n_qubits,)
+        ):
+            raise ValueError(
+                "Tableau and signs must have shape "
+                "(2 * n_qubits, 2 * n_qubits) and (2 * n_qubits,)"
+            )
+        ct = CliffordTableau(n_qubits)
+        ct.tableau = tableau
+        ct.signs = signs
+        return ct
+
+    @staticmethod
+    def from_qiskit_tableau(qiskit_ct: "qiskit.quantum_info.Clifford"):
+        """
+        Create a CliffordTableau from a qiskit Clifford object.
+
+        Args:
+            qiskit_ct (qiskit.quantum_info.Clifford): Clifford object.
+
+        Returns:
+            CliffordTableau: CliffordTableau object.
+        """
+        n_qubits = qiskit_ct.num_qubits
+        ct = CliffordTableau(n_qubits)
+        ct.tableau = qiskit_ct.symplectic_matrix
+        ct.signs = qiskit_ct.phase
+        return ct
+
+    def string_repr(self, sep=" ", sign_sep="| "):
+        """
+        Get a string representation of the tableau.
+
+        Args:
+            sep (str): Separator between the pauli operators
+            sign_sep (str): Separator between operators and sign.
+
+        """
+        out = ""
+        for i in range(self.n_qubits):
+            for j in range(self.n_qubits):
+                x_str = ["I", "X", "Z", "Y"][int(self.x_out(i, j))]
+                z_str = ["I", "X", "Z", "Y"][int(self.z_out(i, j))]
+                out += f"{x_str}/{z_str}" + sep
+            out += sign_sep + f"{'+' if self.signs[i] == 0 else '-'} \n"
+        return out
+
+    def x_out(self, row, col):
+        """
+        Get the X operator in row `row` and column `col`.
+
+        Args:
+            row (int): Row index.
+            col (int): Column index.
+        """
+        return self.tableau[row, col] + 2 * self.tableau[row, col + self.n_qubits]
+
+    def z_out(self, row, col):
+        """
+        Get the Z operator in row `row` and column `col`.
+
+        Args:
+            row (int): Row index.
+            col (int): Column index.
+        """
+        return (
+            self.tableau[row + self.n_qubits, col]
+            + 2 * self.tableau[row + self.n_qubits, col + self.n_qubits]
+        )
+
+    def _xor_row(self, i, j):
+        """
+        XOR the value of row j to row i and adjust the signs accordingly.
+
+        Args:
+            i (int): Row index.
+            j (int): Row index.
+        """
+        row_i = self.tableau[i, :]
+        row_j = self.tableau[j, :]
+        sign_i = self.signs[i]
+        sign_j = self.signs[j]
+
+        n = self.n_qubits
+        row_j, sign_j = mult_paulis(row_i, row_j, sign_i, sign_j, n)
+        self.insert_pauli_row(row_j, sign_j, i)
+
+    def prepend_h(self, qubit):
+        """
+        Prepend a Hadamard gate to the tableau.
+
+        Args:
+            qubit (int): Qubit the hadamard gate is applied to.
+        """
+        idx0, idx1 = qubit, self.n_qubits + qubit
+        self.signs[[idx0, idx1]] = self.signs[[idx1, idx0]]
+        self.tableau[[idx0, idx1], :] = self.tableau[[idx1, idx0], :]
+
+    def append_h(self, qubit):
+        """
+        Append a Hadamard gate to the tableau.
+
+        Args:
+            qubit (int): Qubit the hadamard gate is applied to.
+        """
+        idx0, idx1 = qubit, self.n_qubits + qubit
+        self.signs += self.tableau[:, idx0] * self.tableau[:, idx1]
+        self.signs %= 2
+        self.tableau[:, [idx0, idx1]] = self.tableau[:, [idx1, idx0]]
+
+    def prepend_s(self, qubit):
+        """
+        Prepend a S gate to the tableau.
+
+        Args:
+            qubit (int): Qubit the S gate is applied to.
+        """
+        self._xor_row(qubit, qubit + self.n_qubits)
+
+    def append_s(self, qubit):
+        """
+        Append a S gate to the tableau.
+
+        Args:
+            qubit (int): Qubit the S gate is applied to.
+        """
+        idx0, idx1 = qubit, self.n_qubits + qubit
+        self.signs += self.tableau[:, idx0] * self.tableau[:, idx1]
+        self.signs %= 2
+        self.tableau[:, idx1] ^= self.tableau[:, idx0]
+
+    def prepend_cnot(self, control, target):
+        """
+        Prepend a CNOT gate to the tableau.
+
+        Args:
+            control (int): Control qubit.
+            target (int): Target qubit.
+        """
+        self.signs = self.signs.astype(int)
+        self._xor_row(control, target)
+        self._xor_row(target + self.n_qubits, control + self.n_qubits)
+
+    def append_cnot(self, control, target):
+        """
+        Append a CNOT gate to the tableau.
+
+        Args:
+            control (int): Control qubit.
+            target (int): Target qubit.
+        """
+        x_ia = self.tableau[:, control]
+        x_ib = self.tableau[:, target]
+
+        z_ia = self.tableau[:, self.n_qubits + control]
+        z_ib = self.tableau[:, self.n_qubits + target]
+
+        control_n = control + self.n_qubits
+        target_n = target + self.n_qubits
+
+        self.tableau[:, target] ^= self.tableau[:, control]
+        self.tableau[:, control_n] ^= self.tableau[:, target_n]
+
+        self.signs += x_ia * z_ib * (x_ib + z_ia + 1)
+        self.signs %= 2
+
+    def insert_pauli_row(self, pauli, p_sign, row):
+        """
+        Insert a Pauli row into the tableau.
+
+        Args:
+            pauli (np.array): Pauli to be inserted.
+            p_sign (int): Sign of the Pauli.
+            row (int): Row to insert the Pauli.
+
+        """
+        self.tableau[row] = pauli.copy()
+        self.signs[row] = p_sign
+
+    def inverse(self):
+        """
+        Invert the tableau.
+
+
+        Note: this is will create a deep copy of the tableau.
+
+        Returns:
+            CliffordTableau: Inverted tableau.
+
+        """
+        n_qubits = self.n_qubits
+        assert self.tableau.shape == (2 * n_qubits, 2 * n_qubits)
+
+        x2x = self.tableau[:n_qubits, :n_qubits].copy()
+        z2z = self.tableau[n_qubits:, n_qubits:].copy()
+
+        x2z = self.tableau[:n_qubits, n_qubits:].copy()
+        z2x = self.tableau[n_qubits:, :n_qubits].copy()
+
+        top_row = np.hstack((z2z.T, x2z.T))
+        bottom_row = np.hstack((z2x.T, x2x.T))
+        new_tableau = np.vstack((top_row, bottom_row))
+
+        ct_new = CliffordTableau.from_tableau(new_tableau, self.signs.copy())
+        ct_intermediate = self.apply(ct_new)
+        ct_new.signs = (ct_new.signs + ct_intermediate.signs) % 2
+
+        return ct_new
+
+    def apply(self, other: "CliffordTableau"):
+        """
+        Apply a CliffordTableau to the current tableau.
+
+        Note: this is will create a deep copy of the tableau.
+
+        Args:
+            other (CliffordTableau): CliffordTableau to apply.
+
+        Returns:
+            CliffordTableau: Applied CliffordTableau.
+        """
+        new_tableau = (self.tableau @ other.tableau) % 2
+
+        phase = (other.tableau.dot(self.signs) + other.signs) % 2
+
+        # Correcting for phase due to Pauli multiplication
+        ifacts = np.zeros(2 * self.n_qubits, dtype=int)
+
+        for k in range(2 * self.n_qubits):
+            row2 = other.tableau[k]
+            x2 = other.tableau[k, : self.n_qubits]
+            z2 = other.tableau[k, self.n_qubits :]
+
+            # Adding a factor of i for each Y in the image of an operator under the
+            # first operation, since Y=iXZ
+
+            ifacts[k] += np.sum(x2 * z2)
+
+            # Adding factors of i due to qubit-wise Pauli multiplication
+
+            for j in range(self.n_qubits):
+                x = 0
+                z = 0
+                for i in range(2 * self.n_qubits):
+                    if row2[i]:
+                        x1 = self.tableau[i, j]
+                        z1 = self.tableau[i, j + self.n_qubits]
+                        if (x == 1 or z == 1) and (x1 == 1 or z1 == 1):
+                            # determine the phase change due to the product of Pauli matrices,
+                            # accounting for the possibilities of i, -i, and no phase change
+                            val = np.mod(np.abs(3 * z1 - x1) - np.abs(3 * z - x) - 1, 3)
+                            if val == 0:
+                                ifacts[k] += 1
+                            elif val == 1:
+                                ifacts[k] -= 1
+                        x ^= x1
+                        z ^= z1
+
+        p = np.mod(ifacts, 4) // 2
+        phase = np.mod(phase + p, 2)
+
+        return CliffordTableau.from_tableau(new_tableau, phase)
diff --git a/pauliopt/clifford/tableau_synthesis.py b/pauliopt/clifford/tableau_synthesis.py
new file mode 100644
index 00000000..5021105c
--- /dev/null
+++ b/pauliopt/clifford/tableau_synthesis.py
@@ -0,0 +1,438 @@
+import networkx as nx
+from networkx.algorithms.approximation import steiner_tree
+
+from pauliopt.circuits import Circuit
+from pauliopt.clifford.tableau import CliffordTableau
+from pauliopt.gates import CX, H, S
+from pauliopt.topologies import Topology
+
+
+def heurisitc_fkt(row, G, remaining: CliffordTableau):
+    """
+    The heuristic function for picking the pivot in the tableau synthesis algorithm.
+
+    :param row: The row to consider
+    :param G: The graph of the topology
+    :param remaining: The remaining tableau
+    """
+    row_x = [
+        nx.shortest_path_length(G, source=row, target=col)
+        for col in G.nodes
+        if remaining.x_out(row, col) != 0
+    ]
+    row_z = [
+        nx.shortest_path_length(G, source=row, target=col)
+        for col in G.nodes
+        if remaining.z_out(row, col) != 0
+    ]
+    dist_x = sum(row_x)
+    dist_z = sum(row_z)
+    return dist_x + dist_z
+
+
+def pick_pivot(G, remaining: "CliffordTableau", possible_swaps, include_swaps):
+    """
+    Pick the pivot to eliminate the next column in the tableau synthesis algorithm.
+
+    We currently use the heuristic function h to pick the pivot,
+    i.e choose the row with the smallest `heurisitc_fkt` value.
+
+    :param G: The graph of the topology
+    :param remaining: The remaining tableau
+    :param possible_swaps: The columns that can be swapped
+    :param include_swaps: Whether to include the columns that can be swapped
+    """
+    scores = []
+    has_cutting_swappable = any([not is_cutting(i, G) for i in possible_swaps])
+    for col in G.nodes:
+        if not is_cutting(col, G) or (
+            include_swaps and has_cutting_swappable and col in possible_swaps
+        ):
+            scores.append((col, col, heurisitc_fkt(col, G, remaining)))
+    assert len(scores) > 0
+    return min(scores, key=lambda x: x[2])[:2]
+
+
+def update_dfs(dfs, parent, child):
+    """
+    Helper function to update the dfs list in place. (See compute_steiner_tree)
+
+    :param dfs: The dfs list to update
+    :param parent: The parent node
+    :param child: The child node
+    """
+    for i, (p, c) in enumerate(dfs):
+        if c == parent:
+            dfs[i] = (p, child)
+        if p == parent:
+            dfs[i] = (child, c)
+        if c == child:
+            dfs[i] = (p, parent)
+        if p == child:
+            dfs[i] = (parent, c)
+    return dfs
+
+
+def relabel_graph_inplace(G, parent, child):
+    """
+    Helper function to relabel the graph in place. (See compute_steiner_tree)
+
+    :param G: The graph to relabel
+    :param parent: The parent node
+    :param child: The child node
+    """
+    swap = {parent: -1}
+    nx.relabel_nodes(G, swap, copy=False)
+    swap = {child: parent}
+    nx.relabel_nodes(G, swap, copy=False)
+    swap = {-1: child}
+    nx.relabel_nodes(G, swap, copy=False)
+
+
+def compute_steiner_tree(
+    root: int,
+    nodes: [int],
+    sub_graph: nx.Graph,
+    include_swaps=False,
+    lookup=None,
+    swappable_nodes=None,
+    permutation=None,
+    n_qubits=None,
+):
+    """
+    Compute the steiner tree of the sub_graph with the given nodes.
+    This function is a wrapper around the networkx steiner tree function.
+
+    It will additionally swap the columns of the remaining tableau to further reduce
+    the amount of CNOTs if include_swaps is True.
+    Include_swaps requires lookup, swappable_nodes, permutation and n_qubits to be set.
+
+    :param root: The root node of the steiner tree
+    :param nodes: The nodes to include in the steiner tree
+    :param sub_graph: The graph of the topology
+
+    :param include_swaps: Whether to include swaps in the steiner tree
+    :param lookup: The lookup table of the topology
+    :param swappable_nodes: The nodes that can be swapped
+    :param permutation: The permutation of the topology
+    :param n_qubits: The number of qubits
+    """
+    steiner_stree = steiner_tree(sub_graph, nodes)
+    steiner_stree = nx.Graph(steiner_stree)
+    if len(steiner_stree.nodes()) < 1:
+        return []
+    if include_swaps:
+        if lookup is None:
+            raise Exception("Lookup table is required to include swaps")
+        if swappable_nodes is None:
+            raise Exception("Swappable nodes are required to include swaps")
+        if permutation is None:
+            raise Exception("Permutation is required to include swaps")
+        if n_qubits is None:
+            raise Exception("Number of qubits is required to include swaps")
+
+        for _ in range(n_qubits):
+            dfs = list(reversed(list(nx.dfs_edges(steiner_stree, source=root))))
+            swapped = []
+            while dfs:
+                parent, child = dfs.pop(0)
+                if parent == root:
+                    continue
+
+                # if the parent is zero and the child is one and both are swappable
+                # then swap them
+                if (
+                    lookup[parent] == 0
+                    and lookup[child] == 1
+                    and child in swappable_nodes
+                    and parent in swappable_nodes
+                ):
+                    relabel_graph_inplace(steiner_stree, parent, child)
+                    relabel_graph_inplace(sub_graph, parent, child)
+                    dfs = update_dfs(dfs, parent, child)
+                    # remaining.swap_cols(parent, child)
+                    permutation[parent], permutation[child] = (
+                        permutation[child],
+                        permutation[parent],
+                    )
+
+                    swapped.append(parent)
+                    swapped.append(child)
+
+        steiner_stree = steiner_tree(sub_graph, nodes)
+    traversal = nx.bfs_edges(steiner_stree, source=root)
+    return list(reversed(list(traversal)))
+
+
+def is_cutting(vertex, g):
+    """
+    Check if the given vertex is a cutting vertex in the given graph.
+
+    :param vertex: The vertex to check
+    :param g: The graph to check
+    """
+    return vertex in nx.articulation_points(g)
+
+
+def sanitize_z(row, row_z, remaining, apply):
+    """
+    Sanitization process for the stabilizer part.
+
+    Essentially:
+    - If the z_out is Y (=3), then apply S
+    - If the z_out is X (=1), then apply H
+
+
+    :param row: The row of the tableau
+    :param row_z: The row of the tableau for the stabilizer part
+    :param remaining: The remaining tableau
+    :param apply: The function to apply a gate
+    """
+    for column in row_z:
+        if remaining.z_out(row, column) == 3:
+            apply("S", (column,))
+
+        if remaining.z_out(row, column) == 1:
+            apply("H", (column,))
+
+    # caveat for the pivot
+    if remaining.x_out(row, row) == 3:
+        apply("S", (row,))
+
+
+def sanitize_field_x(row, row_x, remaining, apply):
+    """
+    Sanitization process for the destabilizer part.
+
+    Essentially:
+    - If the x_out is Y (=3), then apply S
+    - If the x_out is X (=2), then apply H
+
+    :param row: The row of the tableau
+    :param row_x: The row of the tableau for the destabilizer part
+    :param remaining: The remaining tableau
+    :param apply: The function to apply a gate
+    """
+    for column in row_x:
+        if remaining.x_out(row, column) == 3:
+            apply("S", (column,))
+
+        if remaining.x_out(row, column) == 2:
+            apply("H", (column,))
+
+
+def remove_interactions(
+    pivot,
+    row,
+    sub_graph,
+    remaining,
+    apply,
+    basis,
+    include_swaps=False,
+    swappable_nodes=None,
+    permutation=None,
+):
+    """
+    Remove the interactions of the destabilizer/stabilizer part.
+    This function assumed that all elements are Z or I.
+
+    Include swaps requires swappable_nodes, permutation and include_swaps to be set.
+
+    :param pivot: The pivot of the tableau
+    :param row: The specific row of the tableau
+    :param sub_graph: The graph of the topology
+    :param remaining: The remaining tableau
+    :param apply: The function to apply a gate
+    :param basis: The basis of the tableau (x for destabilizer or z for stabilizer)
+    :param swappable_nodes: The nodes that can be swapped
+    :param permutation: The permutation of the topology
+    :param include_swaps: Whether to include swaps in the steiner tree
+
+    """
+    row = list(set([pivot] + row))
+    lookup = {node: int(remaining.x_out(pivot, node) != 0) for node in sub_graph.nodes}
+    traversal = compute_steiner_tree(
+        pivot,
+        row,
+        sub_graph,
+        include_swaps=include_swaps,
+        lookup=lookup,
+        swappable_nodes=swappable_nodes,
+        permutation=permutation,
+        n_qubits=remaining.n_qubits,
+    )
+    if basis == "x":
+        for parent, child in traversal:
+            if remaining.x_out(pivot, parent) == 0:
+                apply("CNOT", (child, parent))
+
+        for parent, child in traversal:
+            apply("CNOT", (parent, child))
+    elif basis == "z":
+        for parent, child in traversal:
+            if remaining.z_out(pivot, parent) == 0:
+                apply("CNOT", (parent, child))
+
+        for parent, child in traversal:
+            apply("CNOT", (child, parent))
+
+
+def steiner_reduce_column(
+    pivot,
+    sub_graph,
+    remaining,
+    apply,
+    swappable_nodes=None,
+    permutation=None,
+    include_swaps=False,
+):
+    """
+    Steiner reduce a column of the tableau.
+
+    :param pivot: The pivot of the tableau
+    :param sub_graph: The graph of the topology
+    :param remaining: The remaining tableau
+    :param apply: The function to apply a gate
+    :param swappable_nodes: The nodes that can be swapped
+    :param permutation: The permutation of the topology
+    :param include_swaps: Whether to include swaps in the steiner tree
+    """
+    # 2. Sanitize the destabilizer row
+    row_x = [col for col in sub_graph.nodes if remaining.x_out(pivot, col) != 0]
+    sanitize_field_x(pivot, row_x, remaining, apply)
+
+    # 3. Remove the interactions from the destabilizer row
+    remove_interactions(
+        pivot,
+        row_x,
+        sub_graph,
+        remaining,
+        apply,
+        "x",
+        include_swaps=include_swaps,
+        swappable_nodes=swappable_nodes,
+        permutation=permutation,
+    )
+
+    # 4. Sanitize the stabilizer row
+    row_z = [row for row in sub_graph.nodes if remaining.z_out(pivot, row) != 0]
+    sanitize_z(pivot, row_z, remaining, apply)
+
+    # 5. Remove the interactions from the stabilizer row
+    remove_interactions(
+        pivot,
+        row_z,
+        sub_graph,
+        remaining,
+        apply,
+        "z",
+        include_swaps=include_swaps,
+        swappable_nodes=swappable_nodes,
+        permutation=permutation,
+    )
+
+    # ensure that the pivots are in ZX basis
+    # (this is provided by the construction of a tableau)
+    assert remaining.x_out(pivot, pivot) == 1
+    assert remaining.z_out(pivot, pivot) == 2
+
+
+def get_non_cutting_vertex(G, pivot_col, swappable_nodes):
+    non_cutting_vertices = []
+    for node in G.nodes:
+        if not is_cutting(node, G) and node in swappable_nodes:
+            shortest_path_len = nx.shortest_path_length(
+                G, source=node, target=pivot_col, weight="weight"
+            )
+            non_cutting_vertices.append((node, shortest_path_len))
+    non_cutting = min(non_cutting_vertices, key=lambda x: x[1])[0]
+    return non_cutting
+
+
+def synthesize_tableau(tableau: CliffordTableau, topo: Topology, include_swaps=True):
+    """
+    Architecture aware synthesis of a Clifford tableau.
+    This is the implementation of the algorithm described in Winderl et. al. [1]
+
+    :param tableau: The Clifford tableau
+    :param topo: The topology
+    :param include_swaps: Whether to allow initial and final measurement permutations
+
+    :return (qc, perm): The synthesized circuit and a inital/final permutation
+
+
+    References
+
+    [1] Winderl, Huang, et al. "Architecture-Aware Synthesis of Stabilizer Circuits from Clifford Tableaus." arXiv preprint arXiv:2309.08972 (2023).
+
+    """
+
+    qc = Circuit(tableau.n_qubits)
+
+    remaining = tableau.inverse()
+    permutation = {v: v for v in range(tableau.n_qubits)}
+    swappable_nodes = list(range(tableau.n_qubits))
+
+    G = topo.to_nx
+    for e1, e2 in G.edges:
+        G[e1][e2]["weight"] = 0
+
+    def apply(gate_name: str, gate_data: tuple):
+        if gate_name == "CNOT":
+            remaining.append_cnot(gate_data[0], gate_data[1])
+            qc.add_gate(CX(gate_data[0], gate_data[1]))
+            if gate_data[0] in swappable_nodes:
+                swappable_nodes.remove(gate_data[0])
+            if gate_data[1] in swappable_nodes:
+                swappable_nodes.remove(gate_data[1])
+            G[gate_data[0]][gate_data[1]]["weight"] = 2
+        elif gate_name == "H":
+            remaining.append_h(gate_data[0])
+            qc.add_gate(H(gate_data[0]))
+        elif gate_name == "S":
+            remaining.append_s(gate_data[0])
+            qc.add_gate(S(gate_data[0]))
+        else:
+            raise Exception("Unknown Gate")
+
+    while G.nodes:
+        # 1. Pick a pivot
+        pivot_col, pivot_row = pick_pivot(G, remaining, swappable_nodes, include_swaps)
+
+        if is_cutting(pivot_col, G) and include_swaps:
+            non_cutting = get_non_cutting_vertex(G, pivot_col, swappable_nodes)
+
+            relabel_graph_inplace(G, non_cutting, pivot_col)
+            permutation[pivot_col], permutation[non_cutting] = (
+                permutation[non_cutting],
+                permutation[pivot_col],
+            )
+
+        steiner_reduce_column(
+            pivot_col, G, remaining, apply, swappable_nodes, permutation, include_swaps
+        )
+
+        if pivot_col in swappable_nodes:
+            swappable_nodes.remove(pivot_col)
+        G.remove_node(pivot_col)
+
+    signs_copy_z = remaining.signs[tableau.n_qubits : 2 * tableau.n_qubits].copy()
+    for col in range(tableau.n_qubits):
+        if signs_copy_z[col] != 0:
+            apply("H", (col,))
+
+    for col in range(tableau.n_qubits):
+        if signs_copy_z[col] != 0:
+            apply("S", (col,))
+            apply("S", (col,))
+
+    for col in range(tableau.n_qubits):
+        if signs_copy_z[col] != 0:
+            apply("H", (col,))
+
+    for col in range(tableau.n_qubits):
+        if remaining.signs[col] != 0:
+            apply("S", (col,))
+            apply("S", (col,))
+
+    return qc, permutation
diff --git a/pauliopt/gates.py b/pauliopt/gates.py
index f5630e7f..c007d1f0 100644
--- a/pauliopt/gates.py
+++ b/pauliopt/gates.py
@@ -1,10 +1,10 @@
-from abc import ABC
+from abc import ABC, abstractmethod
 from itertools import combinations
 from math import ceil
 
-from pauliopt.phase import pi
-from pauliopt.phase import Z as ZHead
 from pauliopt.phase import X as XHead
+from pauliopt.phase import Z as ZHead
+from pauliopt.phase import pi
 from pauliopt.phase.phase_circuits import PhaseGadget
 
 
@@ -108,6 +108,10 @@ def gadgets(self):
         ]
         return gadgets
 
+    @abstractmethod
+    def to_qiskit(self):
+        pass
+
 
 class PhaseGate(Gate):
     def __init__(self, phase, *qubits):
@@ -138,6 +142,14 @@ def draw(self, builder, base, row_width, params):
         y = base[1] + (qubit + 1) * line_height
         builder.rect((x, y), 1.5 * r, 1.5 * r, hcolor)
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import HGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return HGate(), self.qubits
+
 
 class X(Gate):
     n_qubits = 1
@@ -147,6 +159,14 @@ class X(Gate):
     def decomp(self):
         return [XHead(pi) @ {self.qubits[0]}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import XGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return XGate(), self.qubits
+
 
 class Z(Gate):
     n_qubits = 1
@@ -156,6 +176,14 @@ class Z(Gate):
     def decomp(self):
         return [ZHead(pi) @ {self.qubits[0]}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import ZGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return ZGate(), self.qubits
+
 
 class Y(Gate):
     n_qubits = 1
@@ -166,6 +194,14 @@ def decomp(self):
         # TODO check this
         return [ZHead(pi) @ {self.qubits[0]}, XHead(pi) @ {self.qubits[0]}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import YGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return YGate(), self.qubits
+
 
 class S(Gate):
     n_qubits = 1
@@ -175,6 +211,31 @@ class S(Gate):
     def decomp(self):
         return [ZHead(pi / 2) @ {self.qubits[0]}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import SGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return SGate(), self.qubits
+
+
+class Sdg(Gate):
+    n_qubits = 1
+    draw_as_zx = True
+
+    @property
+    def decomp(self):
+        return [ZHead(-pi / 2) @ {self.qubits[0]}]
+
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import SdgGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return SdgGate(), self.qubits
+
 
 class T(Gate):
     n_qubits = 1
@@ -184,6 +245,31 @@ class T(Gate):
     def decomp(self):
         return [ZHead(pi / 4) @ {self.qubits[0]}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import TGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return TGate(), self.qubits
+
+
+class Tdg(Gate):
+    n_qubits = 1
+    draw_as_zx = True
+
+    @property
+    def decomp(self):
+        return [ZHead(-pi / 4) @ {self.qubits[0]}]
+
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import TdgGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return TdgGate(), self.qubits
+
 
 class SWAP(Gate):
     n_qubits = 2
@@ -194,6 +280,14 @@ def decomp(self):
         q0, q1 = self.qubits
         return [CX(q0, q1), CX(q1, q0), CX(q0, q1)]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import SwapGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return SwapGate(), self.qubits
+
 
 class CX(Gate):
     n_qubits = 2
@@ -219,6 +313,14 @@ def draw(self, builder, base, row_width, params):
         builder.circle((x, y_ctrl), r, zcolor)
         builder.circle((x, y_trgt), r, xcolor)
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CXGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CXGate(), self.qubits
+
 
 class CY(Gate):
     n_qubits = 2
@@ -229,6 +331,14 @@ def decomp(self):
         q0, q1 = self.qubits
         return [XHead(pi / 2) @ {q1}, CZ(q0, q1), XHead(-pi / 2) @ {q1}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CYGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CYGate(), self.qubits
+
 
 class CZ(Gate):
     n_qubits = 2
@@ -255,6 +365,14 @@ def draw(self, builder, base, row_width, params):
         builder.circle((x, y_trgt), r, zcolor)
         builder.rect((x, y_mid), r, r, hcolor)
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CZGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CZGate(), self.qubits
+
 
 class CCX(Gate):
     n_qubits = 3
@@ -265,6 +383,14 @@ def decomp(self):
         q0, q1, q2 = self.qubits
         return [H(q2), CCZ(q0, q1, q2), H(q2)]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CCXGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CCXGate(), self.qubits
+
 
 class CCZ(Gate):
     n_qubits = 3
@@ -279,6 +405,14 @@ def decomp(self):
                 gs.append(ZHead(-(1 ** len(qs)) * pi / 2) @ set(qs))
         return gs
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CCZGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CCZGate(), self.qubits
+
 
 class Rx(PhaseGate):
     n_qubits = 1
@@ -289,6 +423,14 @@ def decomp(self):
         (q,) = self.qubits
         return [XHead(self.phase) @ {q}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import RXGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return RXGate(self.phase), self.qubits
+
 
 class Ry(PhaseGate):
     n_qubits = 1
@@ -299,6 +441,14 @@ def decomp(self):
         (q,) = self.qubits
         return [XHead(pi / 2) @ {q}, ZHead(self.phase) @ {q}, XHead(-pi / 2) @ {q}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import RYGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return RYGate(self.phase), self.qubits
+
 
 class Rz(PhaseGate):
     n_qubits = 1
@@ -309,6 +459,14 @@ def decomp(self):
         (q,) = self.qubits
         return [ZHead(self.phase) @ {q}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import RZGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return RZGate(self.phase), self.qubits
+
 
 class CRx(PhaseGate):
     n_qubits = 2
@@ -320,6 +478,14 @@ def decomp(self):
         q0, q1 = self.qubits
         return [H(q1), CRz(p, q0, q1), H(q1)]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CRXGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CRXGate(self.phase), self.qubits
+
 
 class CRy(PhaseGate):
     n_qubits = 2
@@ -331,6 +497,14 @@ def decomp(self):
         q0, q1 = self.qubits
         return [XHead(pi / 2, q1), CRz(p, q0, q1), XHead(-pi / 2, q1)]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CRYGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CRYGate(self.phase), self.qubits
+
 
 class CRz(PhaseGate):
     n_qubits = 2
@@ -342,6 +516,14 @@ def decomp(self):
         q0, q1 = self.qubits
         return [ZHead(-p / 2) @ {q0, q1}, ZHead(p / 2) @ {q1}]
 
+    def to_qiskit(self):
+        try:
+            from qiskit.circuit.library import CRZGate
+        except ImportError:
+            raise ImportError("Please install qiskit to use this feature.")
+
+        return CRZGate(self.phase), self.qubits
+
 
 CNOT = CX
 
diff --git a/pauliopt/pauli/pauli_gadget.py b/pauliopt/pauli/pauli_gadget.py
index ffdbc533..78b9079e 100644
--- a/pauliopt/pauli/pauli_gadget.py
+++ b/pauliopt/pauli/pauli_gadget.py
@@ -94,6 +94,14 @@ def two_qubit_count(self, topology, leg_cache=None):
         return cnot_amount
 
     def to_qiskit(self, topology=None):
+        if isinstance(self.angle, float):
+            angle = self.angle
+        elif isinstance(self.angle, AngleExpr):
+            angle = self.angle.to_qiskit
+        else:
+            raise TypeError(
+                f"Angle must either be float or AngleExpr, but got {type(self.angle)}"
+            )
         num_qubits = len(self.paulis)
         if topology is None:
             topology = Topology.complete(num_qubits)
@@ -106,7 +114,7 @@ def to_qiskit(self, topology=None):
         column = np.asarray(self.paulis)
         column_binary = np.where(column == I, 0, 1)
         if np.all(column_binary == 0):
-            circ.global_phase += self.angle
+            circ.global_phase += angle
             return circ
 
         cnot_ladder, q0 = find_minimal_cx_assignment(column_binary, topology)
@@ -126,13 +134,13 @@ def to_qiskit(self, topology=None):
             for pauli_idx, target in reversed(cnot_ladder):
                 circ.cx(pauli_idx, target)
 
-            circ.rz(self.angle, q0)
+            circ.rz(angle, q0)
 
             for pauli_idx, target in cnot_ladder:
                 circ.cx(pauli_idx, target)
         else:
             target = np.argmax(column_binary)
-            circ.rz(self.angle, target)
+            circ.rz(angle, target)
 
         for pauli_idx in range(len(column)):
             if column[pauli_idx] == Pauli.I:
diff --git a/pauliopt/pauli/pauli_polynomial.py b/pauliopt/pauli/pauli_polynomial.py
index 52c4fc9c..89f6f696 100644
--- a/pauliopt/pauli/pauli_polynomial.py
+++ b/pauliopt/pauli/pauli_polynomial.py
@@ -2,6 +2,9 @@
 from pauliopt.pauli.pauli_gadget import PauliGadget
 
 from pauliopt.topologies import Topology
+import math
+from pauliopt.pauli.utils import X, Y, Z, I
+from pauliopt.utils import SVGBuilder
 
 
 class PauliPolynomial:
@@ -28,6 +31,10 @@ def __repr__(self):
     def __len__(self):
         return len(self.pauli_gadgets)
 
+    @property
+    def num_gadgets(self):
+        return len(self.pauli_gadgets)
+
     def to_qiskit(self, topology=None):
         num_qubits = self.num_qubits
         if topology is None:
@@ -62,3 +69,118 @@ def two_qubit_count(self, topology, leg_cache=None):
         for gadget in self.pauli_gadgets:
             count += gadget.two_qubit_count(topology, leg_cache=leg_cache)
         return count
+
+    def to_svg(
+        self,
+        hscale: float = 1.0,
+        vscale: float = 1.0,
+        scale: float = 1.0,
+        svg_code_only=False,
+    ):
+        vscale *= scale
+        hscale *= scale
+
+        x_color = "#FF8888"
+        z_color = "#CCFFCC"
+        y_color = "ycolor"
+
+        num_qubits = self.num_qubits
+        num_gadgets = self.num_gadgets
+
+        # general width and height of a square
+        square_width = int(math.ceil(20 * vscale))
+        square_height = int(math.ceil(20 * vscale))
+
+        # width of the text of the phases # TODO round floats (!!)
+        text_width = int(math.ceil(50 * vscale))
+
+        bend_degree = 10
+
+        # margins between the angle and the legs
+        margin_angle_x = int(math.ceil(20 * hscale))
+        margin_angle_y = int(math.ceil(20 * hscale))
+
+        # margins between each element
+        margin_x = int(math.ceil(10 * hscale))
+        margin_y = int(math.ceil(10 * hscale))
+
+        width = (
+            num_gadgets * (square_width + margin_x + margin_angle_x + text_width)
+            + margin_x
+        )
+        height = (
+            (num_qubits) * (square_height + margin_y)
+            + (square_height + margin_y + margin_angle_y)
+            + margin_y
+        )
+
+        builder = SVGBuilder(width, height)
+        builder = builder.add_diagonal_fill(x_color, z_color, y_color)
+
+        prev_x = {qubit: 0 for qubit in range(num_qubits)}
+
+        x = margin_x
+
+        for gadget in self.pauli_gadgets:
+            paulis = gadget.paulis
+            y = margin_y
+            text_coords = (square_width + margin_x + margin_angle_x + x, y)
+            text_lower_mid = (
+                text_coords[0] + square_width,
+                text_coords[1] + square_height,
+            )
+            for qubit in range(num_qubits):
+                if qubit == 0:
+                    y += square_height + margin_y + margin_angle_y
+                else:
+                    y += square_height + margin_y
+                center_coords = (x + square_width, y)
+                if paulis[qubit] == I:
+                    continue
+
+                builder.line(
+                    (prev_x[qubit], y + square_height // 2), (x, y + square_height // 2)
+                )
+                prev_x[qubit] = x + square_width
+                builder.line_bend(
+                    text_lower_mid, center_coords, degree=qubit * bend_degree
+                )
+                if paulis[qubit] == X:
+                    builder.square((x, y), square_width, square_height, x_color)
+                elif paulis[qubit] == Y:
+                    builder.square((x, y), square_width, square_height, y_color)
+                elif paulis[qubit] == Z:
+                    builder.square((x, y), square_width, square_height, z_color)
+
+            builder = builder.text_with_square(
+                text_coords, text_width, square_height, str(gadget.angle)
+            )
+            x += square_width + margin_x + text_width + margin_angle_x
+
+        y = margin_y
+        for qubit in range(num_qubits):
+            if qubit == 0:
+                y += square_height + margin_y + margin_angle_y
+            else:
+                y += square_height + margin_y
+            builder.line(
+                (prev_x[qubit], y + square_height // 2), (width, y + square_height // 2)
+            )
+        svg_code = repr(builder)
+
+        if svg_code_only:
+            return svg_code
+        try:
+            # pylint: disable = import-outside-toplevel
+            from IPython.core.display import SVG  # type: ignore
+        except ModuleNotFoundError as e:
+            raise ModuleNotFoundError("You must install the 'IPython' library.") from e
+
+        return SVG(svg_code)
+
+    def _repr_svg_(self):
+        """
+        Magic method for IPython/Jupyter pretty-printing.
+        See https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html
+        """
+        return self.to_svg(svg_code_only=True)
diff --git a/pauliopt/utils.py b/pauliopt/utils.py
index f7a61c26..b92abd65 100644
--- a/pauliopt/utils.py
+++ b/pauliopt/utils.py
@@ -26,6 +26,24 @@
 )
 import numpy as np
 
+
+def calculate_orthogonal_point(a, b, d, left):
+    direction_vector = b - a
+    magnitude = np.linalg.norm(direction_vector)
+    normalized_direction_vector = direction_vector / magnitude
+    if left:
+        orthogonal_vector = np.array(
+            [-normalized_direction_vector[1], normalized_direction_vector[0]]
+        )
+    else:
+        orthogonal_vector = np.array(
+            [normalized_direction_vector[1], -normalized_direction_vector[0]]
+        )
+    midpoint = (a + b) / 2
+    orthogonal_point = midpoint + d * orthogonal_vector
+    return int(orthogonal_point[0]), int(orthogonal_point[1])
+
+
 AngleInitT = Union[int, Fraction, str, Decimal]
 
 
@@ -361,7 +379,9 @@ def random(
             raise TypeError("RNG seed must be integer or 'None'.")
         rng = np.random.default_rng(seed=rng_seed)
         if nonzero:
-            rs = 1 + rng.integers(2 * subdivision - 1, size=size)  # type: ignore[attr-defined]
+            rs = 1 + rng.integers(
+                2 * subdivision - 1, size=size
+            )  # type: ignore[attr-defined]
         else:
             rs = rng.integers(2 * subdivision, size=size)  # type: ignore[attr-defined]
         if size == 1:
@@ -379,7 +399,6 @@ def random(
 Angle.zero = Angle(0)  # type: ignore
 Angle.pi = Angle(1)  # type: ignore
 
-
 pi: Final[Angle] = Angle.pi
 """ Constant for `Angle.pi`. """
 
@@ -634,6 +653,7 @@ def __init__(self, width: int, height: int):
             raise TypeError("Height should be positive integer.")
         self._width = width
         self._height = height
+        self._def_object_ids = []
         self._tags = []
 
     @property
@@ -687,6 +707,75 @@ def line(self, fro: Tuple[int, int], to: Tuple[int, int]) -> "SVGBuilder":
         self._tags.append(tag)
         return self
 
+    def line_bend(
+        self, fro: Tuple[int, int], to: Tuple[int, int], left=False, degree=5
+    ):
+        _validate_vec2(fro)
+        _validate_vec2(to)
+
+        fx, fy = fro
+        tx, ty = to
+        bx, by = calculate_orthogonal_point(
+            np.asarray(fro), np.asarray(to), d=degree, left=left
+        )
+
+        tag = (
+            f'<path d="M {fx} {fy} Q {bx} {by} {tx} {ty}" fill="none" stroke="black"/>'
+        )
+        self._tags.append(tag)
+        return self
+
+    def add_diagonal_fill(self, color_1: str, color_2: str, id: str) -> "SVGBuilder":
+        tag = (
+            f'<linearGradient id="{id}" x1="0%" x2="100%" y1="100%" y2="0%">'
+            f'<stop offset="0%"  stop-color="{color_1}"/>'
+            f'<stop offset="50%"  stop-color="{color_1}"/>'
+            f'<stop offset="50%"  stop-color="{color_2}"/>'
+            f'<stop offset="100%"  stop-color="{color_2}"/>'
+            f"</linearGradient>"
+        )
+
+        self._def_object_ids.append(id)
+        self._tags.append(tag)
+        return self
+
+    def square(
+        self, centre: Tuple[int, int], width: int, height: int, fill
+    ) -> "SVGBuilder":
+        _validate_vec2(centre)
+        x, y = centre
+        if fill in self._def_object_ids:
+            tag = (
+                f'<rect fill="url(#{fill})" stroke="black" x="{x}" y="{y}" '
+                f'width="{width}" height="{height}"/>'
+            )
+            self._tags.append(tag)
+        elif isinstance(fill, str):
+            tag = (
+                f'<rect fill="{fill}" stroke="black" x="{x}" y="{y}" '
+                f'width="{width}" height="{height}"/>'
+            )
+            self._tags.append(tag)
+        else:
+            raise TypeError(f"Fill must be string or a defined Tag. Got: {fill} ")
+        return self
+
+    def text_with_square(
+        self, centre: Tuple[int, int], width: int, height: int, text: str
+    ) -> "SVGBuilder":
+        _validate_vec2(centre)
+        x, y = centre
+        tag = (
+            f'<svg x="{x}" y="{y}" height="{height}" width="{width}">'
+            f'<rect x="0" y="0" width="100%" height="100%" '
+            f'stroke="black" fill="white" stroke-width="5 %"/>'
+            f'<text x="50%" y="50%" width="100%" height="100%" font-size="100%" '
+            f'dominant-baseline="middle" text-anchor="middle" >{text}</text>'
+            f"</svg>"
+        )
+        self._tags.append(tag)
+        return self
+
     def circle(self, centre: Tuple[int, int], r: int, fill: str) -> "SVGBuilder":
         """
         Draws a circle with given centre and radius.
diff --git a/phase_gadget_snippet.png b/phase_gadget_snippet.png
deleted file mode 100644
index eec7068b..00000000
Binary files a/phase_gadget_snippet.png and /dev/null differ
diff --git a/pypi-distrib-archives.bat b/pypi-distrib-archives.bat
deleted file mode 100644
index 948c3dba..00000000
--- a/pypi-distrib-archives.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-@echo off
-python setup.py sdist bdist_wheel
-pause
diff --git a/pypi-distrib-upload.bat b/pypi-distrib-upload.bat
deleted file mode 100644
index e8b6a10c..00000000
--- a/pypi-distrib-upload.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-@echo off
-python -m twine upload dist/*
-pause
diff --git a/readme-example-1.png b/readme-example-1.png
deleted file mode 100644
index 17c065d7..00000000
Binary files a/readme-example-1.png and /dev/null differ
diff --git a/readme-example-2.png b/readme-example-2.png
deleted file mode 100644
index 414d64ad..00000000
Binary files a/readme-example-2.png and /dev/null differ
diff --git a/readme-example-3.png b/readme-example-3.png
deleted file mode 100644
index 331c0b03..00000000
Binary files a/readme-example-3.png and /dev/null differ
diff --git a/readme-example-4.png b/readme-example-4.png
deleted file mode 100644
index 26057013..00000000
Binary files a/readme-example-4.png and /dev/null differ
diff --git a/requirements-dev.txt b/requirements-dev.txt
new file mode 100644
index 00000000..05f852f8
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,9 @@
+networkx==2.6.2
+numpy>=1.21.0
+pytket==1.11.0
+pytket-qiskit==0.34.0
+qiskit==0.39.0
+galois==0.3.7
+parameterized==0.9.0
+notebook==7.0.6
+black==23.12.1
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 57cf7f26..00000000
--- a/requirements.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-networkx==2.6.2
-numpy>=1.21.0
-pytket==1.11.0
-pytket-qiskit==0.34.0
-qiskit==0.39.0
\ No newline at end of file
diff --git a/run-jupyter-notebook.bat b/run-jupyter-notebook.bat
deleted file mode 100644
index 030c3071..00000000
--- a/run-jupyter-notebook.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-cd notebooks
-jupyter notebook
diff --git a/run-mypy.bat b/run-mypy.bat
deleted file mode 100644
index b18f5dd4..00000000
--- a/run-mypy.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-mypy pauliopt
-@pause
diff --git a/run-pdoc.bat b/run-pdoc.bat
deleted file mode 100644
index f076441c..00000000
--- a/run-pdoc.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-pdoc --config latex_math=True --config show_type_annotations=True --force --html --output-dir docs pauliopt
-@pause
diff --git a/run-pylint.bat b/run-pylint.bat
deleted file mode 100644
index 61c1aa7c..00000000
--- a/run-pylint.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-pylint pauliopt
-@pause
diff --git a/scripts/check_imports.py b/scripts/check_imports.py
new file mode 100644
index 00000000..3b6b45a2
--- /dev/null
+++ b/scripts/check_imports.py
@@ -0,0 +1,45 @@
+import importlib
+import pkgutil
+import traceback
+
+
+def import_submodules(package):
+    """Import all submodules of a module, recursively, including subpackages.
+
+    :param package: package (name or actual module)
+    :type package: str | module
+    :rtype: dict[str, types.ModuleType]
+    """
+    try:
+        if isinstance(package, str):
+            package = importlib.import_module(package)
+        results = {}
+        for loader, name, is_pkg in pkgutil.walk_packages(package.__path__):
+            full_name = package.__name__ + "." + name
+            importlib.import_module(full_name)
+            if is_pkg:
+                import_submodules(full_name)
+        return results
+    except ModuleNotFoundError as e:
+        # Extracting and formatting the traceback for ModuleNotFoundError
+        tb_info = traceback.extract_tb(e.__traceback__)
+        last_entry = tb_info[-1]  # The last call before the error
+        filename, line_number, func, text = last_entry
+        error_message = f"ModuleNotFoundError occurred in file: {filename} at line: {line_number}, statement: {text}"
+        print(error_message)
+        exit(1)
+    except Exception as e:
+        # Extracting and formatting the traceback for all other exceptions
+        tb_info = traceback.extract_tb(e.__traceback__)
+        last_entry = tb_info[-1]  # The last call before the error
+        filename, line_number, func, text = last_entry
+        error_message = f"An exception occurred in file: {filename} at line: {line_number}, statement: {text}"
+        print(error_message)
+        exit(1)
+
+
+if __name__ == "__main__":
+    import pauliopt
+
+    import_submodules(pauliopt)
+    print("All imports successful!")
diff --git a/setup.py b/setup.py
index c545722c..19c66436 100644
--- a/setup.py
+++ b/setup.py
@@ -17,12 +17,10 @@
         "Natural Language :: English",
         "Typing :: Typed",
     ],
-    package_data={"": [],
-                  "pauliopt": ["pauliopt/py.typed"],
-                  },
+    package_data={
+        "": [],
+        "pauliopt": ["pauliopt/py.typed"],
+    },
     include_package_data=True,
-    install_requires=[
-        "networkx",
-        "numpy"
-    ],
+    install_requires=["networkx", "numpy"],
 )
diff --git a/update-local-package.bat b/update-local-package.bat
deleted file mode 100644
index be89ca40..00000000
--- a/update-local-package.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-robocopy pauliopt\ %PYPATH%\Lib\site-packages\pauliopt\ /s /e
-@pause


Test patch:
diff --git a/.github/workflows/build_test.yml b/.github/workflows/build_test.yml
new file mode 100644
index 00000000..79659a27
--- /dev/null
+++ b/.github/workflows/build_test.yml
@@ -0,0 +1,45 @@
+name: Build, lint and test package
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+    branches:
+      - 'main'
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [ "3.9", "3.10" ]
+    outputs:
+      error-check: ${{ steps.error-check.conclusion }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Check imports
+        working-directory: ./
+        run: |
+          pip install --upgrade pip
+          pip install .
+          python scripts/check_imports.py
+      - name: Linting
+        working-directory: ./
+        run: |
+          pip install --upgrade pip
+          pip install .
+          pip install -r requirements-dev.txt
+          black --check .
+      - name: Unit tests
+        working-directory: ./
+        run: |
+          pip install --upgrade pip
+          pip install .
+          pip install -r requirements-dev.txt
+          python -m unittest discover -s ./tests/ -p "test_*.py"
+
diff --git a/test.py b/test.py
new file mode 100644
index 00000000..82c77018
--- /dev/null
+++ b/test.py
@@ -0,0 +1,28 @@
+from math import pi
+
+from qiskit import QuantumCircuit
+from qiskit.circuit import CircuitInstruction
+from qiskit.circuit.random import random_circuit
+
+
+def get_qubits(qubits, qreg):
+    qubits_ = []
+    for qubit in qubits:
+        qubits_.append(qreg.index(qubit))
+
+    return tuple(qubits_)
+
+
+def main():
+    qc = random_circuit(10, 4)
+
+    qreg = qc.qregs[0]
+
+    ci = CircuitInstruction
+    for op in qc:
+        for qubit in op.qubits:
+            print(qubit)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/data/circ_reps/CCX_cli.txt b/tests/data/circ_reps/CCX_cli.txt
new file mode 100644
index 00000000..9d3dd5d8
--- /dev/null
+++ b/tests/data/circ_reps/CCX_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CCX(0, 1, 2)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CCX_svg.txt b/tests/data/circ_reps/CCX_svg.txt
new file mode 100644
index 00000000..2e2bf631
--- /dev/null
+++ b/tests/data/circ_reps/CCX_svg.txt
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="188" height="140"><path fill="none" stroke="black" d="M 34, 50 L 154, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="160" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 154, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="160" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 154, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="160" y="113" font-size="12">2</text>
+<rect fill="#FFFF00" stroke="black" x="90.0" y="106.0" width="9.0" height="9.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<text x="74.0" y="43.0" font-size="12">3π/2</text>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<text x="74.0" y="73.0" font-size="12">3π/2</text>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<text x="74.0" y="103.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 110 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 95.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 110 L 94.0, 95.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 95.0 L 124.0, 95.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="95.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="95.0" r="6"/>
+<text x="134.0" y="98.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 110 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">3π/2</text>
+<rect fill="#FFFF00" stroke="black" x="90.0" y="106.0" width="9.0" height="9.0"/>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CCZ_cli.txt b/tests/data/circ_reps/CCZ_cli.txt
new file mode 100644
index 00000000..917e3d25
--- /dev/null
+++ b/tests/data/circ_reps/CCZ_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CCZ(0, 1, 2)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CCZ_svg.txt b/tests/data/circ_reps/CCZ_svg.txt
new file mode 100644
index 00000000..c4d5a507
--- /dev/null
+++ b/tests/data/circ_reps/CCZ_svg.txt
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="188" height="140"><path fill="none" stroke="black" d="M 34, 50 L 154, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="160" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 154, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="160" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 154, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="160" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<text x="74.0" y="43.0" font-size="12">3π/2</text>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<text x="74.0" y="73.0" font-size="12">3π/2</text>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<text x="74.0" y="103.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 110 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 95.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 110 L 94.0, 95.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 95.0 L 124.0, 95.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="95.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="95.0" r="6"/>
+<text x="134.0" y="98.0" font-size="12">3π/2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 110 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="110" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">3π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CRx_cli.txt b/tests/data/circ_reps/CRx_cli.txt
new file mode 100644
index 00000000..cc1b4fec
--- /dev/null
+++ b/tests/data/circ_reps/CRx_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CRx(π/2, 0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CRx_svg.txt b/tests/data/circ_reps/CRx_svg.txt
new file mode 100644
index 00000000..0c8241f9
--- /dev/null
+++ b/tests/data/circ_reps/CRx_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="180" height="140"><path fill="none" stroke="black" d="M 34, 50 L 146, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="152" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 146, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="152" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 146, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="152" y="113" font-size="12">2</text>
+<rect fill="#FFFFFF" stroke="black" x="34.0" y="45.0" width="112" height="40"/>
+<text x="90.0" y="68.0" font-size="12" text-anchor="middle">CRx(π/2, 0, 1)</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CRy_cli.txt b/tests/data/circ_reps/CRy_cli.txt
new file mode 100644
index 00000000..049cf20f
--- /dev/null
+++ b/tests/data/circ_reps/CRy_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CRy(π/2, 0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CRy_svg.txt b/tests/data/circ_reps/CRy_svg.txt
new file mode 100644
index 00000000..ef8d85cb
--- /dev/null
+++ b/tests/data/circ_reps/CRy_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="180" height="140"><path fill="none" stroke="black" d="M 34, 50 L 146, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="152" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 146, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="152" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 146, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="152" y="113" font-size="12">2</text>
+<rect fill="#FFFFFF" stroke="black" x="34.0" y="45.0" width="112" height="40"/>
+<text x="90.0" y="68.0" font-size="12" text-anchor="middle">CRy(π/2, 0, 1)</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CRz_cli.txt b/tests/data/circ_reps/CRz_cli.txt
new file mode 100644
index 00000000..84483688
--- /dev/null
+++ b/tests/data/circ_reps/CRz_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CRz(π/2, 0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CRz_svg.txt b/tests/data/circ_reps/CRz_svg.txt
new file mode 100644
index 00000000..9d4ea195
--- /dev/null
+++ b/tests/data/circ_reps/CRz_svg.txt
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="188" height="140"><path fill="none" stroke="black" d="M 34, 50 L 154, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="160" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 154, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="160" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 154, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="160" y="113" font-size="12">2</text>
+<path fill="none" stroke="black" d="M 64.0, 50 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 64.0, 80 L 94.0, 65.0"/>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 94.0, 65.0 L 124.0, 65.0"/>
+<circle fill="#FF8888" stroke="black" cx="94.0" cy="65.0" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="124.0" cy="65.0" r="6"/>
+<text x="134.0" y="68.0" font-size="12">7π/4</text>
+<circle fill="#CCFFCC" stroke="black" cx="64.0" cy="80" r="6"/>
+<text x="74.0" y="93.0" font-size="12">π/4</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CX_cli.txt b/tests/data/circ_reps/CX_cli.txt
new file mode 100644
index 00000000..790c91c5
--- /dev/null
+++ b/tests/data/circ_reps/CX_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CX(0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CX_svg.txt b/tests/data/circ_reps/CX_svg.txt
new file mode 100644
index 00000000..6e7f16cc
--- /dev/null
+++ b/tests/data/circ_reps/CX_svg.txt
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="108" height="140"><path fill="none" stroke="black" d="M 34, 50 L 74, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="80" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 74, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="80" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 74, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="80" y="113" font-size="12">2</text>
+<path fill="none" stroke="black" d="M 54.0, 50 L 54.0, 80"/>
+<circle fill="#CCFFCC" stroke="black" cx="54.0" cy="50" r="6"/>
+<circle fill="#FF8888" stroke="black" cx="54.0" cy="80" r="6"/>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CY_cli.txt b/tests/data/circ_reps/CY_cli.txt
new file mode 100644
index 00000000..fbd7df8b
--- /dev/null
+++ b/tests/data/circ_reps/CY_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CY(0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CY_svg.txt b/tests/data/circ_reps/CY_svg.txt
new file mode 100644
index 00000000..2d6ba073
--- /dev/null
+++ b/tests/data/circ_reps/CY_svg.txt
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="188" height="140"><path fill="none" stroke="black" d="M 34, 50 L 154, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="160" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 154, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="160" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 154, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="160" y="113" font-size="12">2</text>
+<circle fill="#FF8888" stroke="black" cx="64.0" cy="80" r="6"/>
+<text x="74.0" y="73.0" font-size="12">π/2</text>
+<path fill="none" stroke="black" d="M 94.0, 50 L 94.0, 80"/>
+<circle fill="#CCFFCC" stroke="black" cx="94.0" cy="50" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="94.0" cy="80" r="6"/>
+<rect fill="#FFFF00" stroke="black" x="91.0" y="62.0" width="6" height="6"/>
+<circle fill="#FF8888" stroke="black" cx="124.0" cy="80" r="6"/>
+<text x="134.0" y="93.0" font-size="12">3π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/CZ_cli.txt b/tests/data/circ_reps/CZ_cli.txt
new file mode 100644
index 00000000..dfd3ed6b
--- /dev/null
+++ b/tests/data/circ_reps/CZ_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [CZ(0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/CZ_svg.txt b/tests/data/circ_reps/CZ_svg.txt
new file mode 100644
index 00000000..25001dc4
--- /dev/null
+++ b/tests/data/circ_reps/CZ_svg.txt
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="188" height="140"><path fill="none" stroke="black" d="M 34, 50 L 154, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="160" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 154, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="160" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 154, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="160" y="113" font-size="12">2</text>
+<path fill="none" stroke="black" d="M 94.0, 50 L 94.0, 80"/>
+<circle fill="#CCFFCC" stroke="black" cx="94.0" cy="50" r="6"/>
+<circle fill="#CCFFCC" stroke="black" cx="94.0" cy="80" r="6"/>
+<rect fill="#FFFF00" stroke="black" x="91.0" y="62.0" width="6" height="6"/>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/H_cli.txt b/tests/data/circ_reps/H_cli.txt
new file mode 100644
index 00000000..a36d1193
--- /dev/null
+++ b/tests/data/circ_reps/H_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [H(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/H_svg.txt b/tests/data/circ_reps/H_svg.txt
new file mode 100644
index 00000000..7ae689f9
--- /dev/null
+++ b/tests/data/circ_reps/H_svg.txt
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="108" height="140"><path fill="none" stroke="black" d="M 34, 50 L 74, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="80" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 74, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="80" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 74, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="80" y="113" font-size="12">2</text>
+<rect fill="#FFFF00" stroke="black" x="50.0" y="46.0" width="9.0" height="9.0"/>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Rx_cli.txt b/tests/data/circ_reps/Rx_cli.txt
new file mode 100644
index 00000000..73c893ae
--- /dev/null
+++ b/tests/data/circ_reps/Rx_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Rx(π/2, 0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Rx_svg.txt b/tests/data/circ_reps/Rx_svg.txt
new file mode 100644
index 00000000..d6e7af99
--- /dev/null
+++ b/tests/data/circ_reps/Rx_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#FF8888" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Ry_cli.txt b/tests/data/circ_reps/Ry_cli.txt
new file mode 100644
index 00000000..cdd9238b
--- /dev/null
+++ b/tests/data/circ_reps/Ry_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Ry(π/2, 0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Ry_svg.txt b/tests/data/circ_reps/Ry_svg.txt
new file mode 100644
index 00000000..99d84441
--- /dev/null
+++ b/tests/data/circ_reps/Ry_svg.txt
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="188" height="140"><path fill="none" stroke="black" d="M 34, 50 L 154, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="160" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 154, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="160" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 154, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="160" y="113" font-size="12">2</text>
+<circle fill="#FF8888" stroke="black" cx="64.0" cy="50" r="6"/>
+<text x="74.0" y="43.0" font-size="12">π/2</text>
+<circle fill="#CCFFCC" stroke="black" cx="94.0" cy="50" r="6"/>
+<text x="104.0" y="43.0" font-size="12">π/2</text>
+<circle fill="#FF8888" stroke="black" cx="124.0" cy="50" r="6"/>
+<text x="134.0" y="43.0" font-size="12">3π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Rz_cli.txt b/tests/data/circ_reps/Rz_cli.txt
new file mode 100644
index 00000000..8dced219
--- /dev/null
+++ b/tests/data/circ_reps/Rz_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Rz(π/2, 0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Rz_svg.txt b/tests/data/circ_reps/Rz_svg.txt
new file mode 100644
index 00000000..ed2cb5b2
--- /dev/null
+++ b/tests/data/circ_reps/Rz_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/SWAP_cli.txt b/tests/data/circ_reps/SWAP_cli.txt
new file mode 100644
index 00000000..5602855e
--- /dev/null
+++ b/tests/data/circ_reps/SWAP_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [SWAP(0, 1)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/SWAP_svg.txt b/tests/data/circ_reps/SWAP_svg.txt
new file mode 100644
index 00000000..c6c5fc7d
--- /dev/null
+++ b/tests/data/circ_reps/SWAP_svg.txt
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<path fill="none" stroke="black" d="M 74.0, 50 L 74.0, 80"/>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<circle fill="#FF8888" stroke="black" cx="74.0" cy="80" r="6"/>
+<path fill="none" stroke="black" d="M 74.0, 80 L 74.0, 50"/>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="80" r="6"/>
+<circle fill="#FF8888" stroke="black" cx="74.0" cy="50" r="6"/>
+<path fill="none" stroke="black" d="M 74.0, 50 L 74.0, 80"/>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<circle fill="#FF8888" stroke="black" cx="74.0" cy="80" r="6"/>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/S_cli.txt b/tests/data/circ_reps/S_cli.txt
new file mode 100644
index 00000000..4593fe54
--- /dev/null
+++ b/tests/data/circ_reps/S_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [S(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/S_svg.txt b/tests/data/circ_reps/S_svg.txt
new file mode 100644
index 00000000..ed2cb5b2
--- /dev/null
+++ b/tests/data/circ_reps/S_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Sdg_cli.txt b/tests/data/circ_reps/Sdg_cli.txt
new file mode 100644
index 00000000..6b5052fa
--- /dev/null
+++ b/tests/data/circ_reps/Sdg_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Sdg(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Sdg_svg.txt b/tests/data/circ_reps/Sdg_svg.txt
new file mode 100644
index 00000000..ec921bc0
--- /dev/null
+++ b/tests/data/circ_reps/Sdg_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">3π/2</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/T_cli.txt b/tests/data/circ_reps/T_cli.txt
new file mode 100644
index 00000000..e6c64174
--- /dev/null
+++ b/tests/data/circ_reps/T_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [T(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/T_svg.txt b/tests/data/circ_reps/T_svg.txt
new file mode 100644
index 00000000..5d7805ab
--- /dev/null
+++ b/tests/data/circ_reps/T_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">π/4</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Tdg_cli.txt b/tests/data/circ_reps/Tdg_cli.txt
new file mode 100644
index 00000000..fb78f7fa
--- /dev/null
+++ b/tests/data/circ_reps/Tdg_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Tdg(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Tdg_svg.txt b/tests/data/circ_reps/Tdg_svg.txt
new file mode 100644
index 00000000..d1733228
--- /dev/null
+++ b/tests/data/circ_reps/Tdg_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">7π/4</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/X_cli.txt b/tests/data/circ_reps/X_cli.txt
new file mode 100644
index 00000000..645b14d8
--- /dev/null
+++ b/tests/data/circ_reps/X_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [X(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/X_svg.txt b/tests/data/circ_reps/X_svg.txt
new file mode 100644
index 00000000..d0f48f44
--- /dev/null
+++ b/tests/data/circ_reps/X_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#FF8888" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">π</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Y_cli.txt b/tests/data/circ_reps/Y_cli.txt
new file mode 100644
index 00000000..c052449c
--- /dev/null
+++ b/tests/data/circ_reps/Y_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Y(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Y_svg.txt b/tests/data/circ_reps/Y_svg.txt
new file mode 100644
index 00000000..9c9eb0b9
--- /dev/null
+++ b/tests/data/circ_reps/Y_svg.txt
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="168" height="140"><path fill="none" stroke="black" d="M 34, 50 L 134, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="140" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 134, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="140" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 134, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="140" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="67.33333333333334" cy="50" r="6"/>
+<text x="77.33333333333334" y="43.0" font-size="12">π</text>
+<circle fill="#FF8888" stroke="black" cx="100.66666666666667" cy="50" r="6"/>
+<text x="110.66666666666667" y="43.0" font-size="12">π</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/circ_reps/Z_cli.txt b/tests/data/circ_reps/Z_cli.txt
new file mode 100644
index 00000000..dc9cf7e9
--- /dev/null
+++ b/tests/data/circ_reps/Z_cli.txt
@@ -0,0 +1,1 @@
+Circuit(3, [Z(0)])
\ No newline at end of file
diff --git a/tests/data/circ_reps/Z_svg.txt b/tests/data/circ_reps/Z_svg.txt
new file mode 100644
index 00000000..f227306d
--- /dev/null
+++ b/tests/data/circ_reps/Z_svg.txt
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="148" height="140"><path fill="none" stroke="black" d="M 34, 50 L 114, 50"/>
+<text x="0" y="53" font-size="12">0</text>
+<text x="120" y="53" font-size="12">0</text>
+<path fill="none" stroke="black" d="M 34, 80 L 114, 80"/>
+<text x="0" y="83" font-size="12">1</text>
+<text x="120" y="83" font-size="12">1</text>
+<path fill="none" stroke="black" d="M 34, 110 L 114, 110"/>
+<text x="0" y="113" font-size="12">2</text>
+<text x="120" y="113" font-size="12">2</text>
+<circle fill="#CCFFCC" stroke="black" cx="74.0" cy="50" r="6"/>
+<text x="84.0" y="43.0" font-size="12">π</text>
+</svg>
\ No newline at end of file
diff --git a/tests/data/clifford/representation.txt b/tests/data/clifford/representation.txt
new file mode 100644
index 00000000..d5a8dea8
--- /dev/null
+++ b/tests/data/clifford/representation.txt
@@ -0,0 +1,5 @@
+Z/X I/I I/I I/I I/I | + 
+I/I Y/Z I/I I/I I/I | + 
+I/I I/I X/Z X/I I/I | + 
+I/I I/I I/Z X/Z X/I | + 
+I/I I/I I/Z I/Z X/Z | + 
diff --git a/tests/tableau/__init__.py b/tests/tableau/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/tableau/test_clifford_synthesis.py b/tests/tableau/test_clifford_synthesis.py
new file mode 100644
index 00000000..06098bb1
--- /dev/null
+++ b/tests/tableau/test_clifford_synthesis.py
@@ -0,0 +1,39 @@
+import unittest
+
+from parameterized import parameterized
+from qiskit import QuantumCircuit
+
+from pauliopt.clifford.tableau import CliffordTableau
+from pauliopt.clifford.tableau_synthesis import synthesize_tableau
+from tests.tableau.utils import tableau_from_circuit
+from tests.utils import verify_equality, random_hscx_circuit
+from pauliopt.topologies import Topology
+
+
+class TestTableauSynthesis(unittest.TestCase):
+    @parameterized.expand(
+        [
+            ("line_5", 5, 1000, Topology.line(5), True),
+            ("line_6", 6, 1000, Topology.line(6), True),
+            ("line_8", 8, 1000, Topology.line(8), True),
+            ("grid_4", 4, 1000, Topology.grid(2, 2), True),
+            ("grid_8", 8, 1000, Topology.grid(2, 4), True),
+            ("line_5", 5, 1000, Topology.line(5), False),
+            ("line_8", 8, 1000, Topology.line(8), False),
+            ("grid_4", 4, 1000, Topology.grid(2, 2), False),
+            ("grid_8", 8, 1000, Topology.grid(2, 4), False),
+        ]
+    )
+    def test_clifford_synthesis(self, _, n_qubits, n_gates, topo, include_swaps):
+        circuit = random_hscx_circuit(nr_qubits=n_qubits, nr_gates=n_gates)
+
+        ct = CliffordTableau(n_qubits)
+        ct = tableau_from_circuit(ct, circuit)
+
+        qc, perm = synthesize_tableau(ct, topo, include_swaps=include_swaps)
+        qc = qc.to_qiskit()
+
+        self.assertTrue(
+            verify_equality(circuit, qc),
+            "The Synthesized circuit does not equal to original",
+        )
diff --git a/tests/tableau/test_tableau_operations.py b/tests/tableau/test_tableau_operations.py
new file mode 100644
index 00000000..93c23d66
--- /dev/null
+++ b/tests/tableau/test_tableau_operations.py
@@ -0,0 +1,102 @@
+import os
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+from qiskit import QuantumCircuit, transpile
+
+from pauliopt.clifford.tableau import CliffordTableau
+from pauliopt.clifford.tableau_synthesis import synthesize_tableau
+from pauliopt.topologies import Topology
+from tests.tableau.utils import tableau_from_circuit_prepend, tableau_from_circuit
+from tests.utils import verify_equality, random_hscx_circuit
+
+
+class TestTableauOperations(unittest.TestCase):
+    @parameterized.expand([(5,), (10,), (15,)])
+    def test_inverse(self, n_qubits):
+        circuit = random_hscx_circuit(nr_qubits=n_qubits, nr_gates=1000)
+
+        ct = CliffordTableau(n_qubits)
+        ct = tableau_from_circuit(ct, circuit)
+
+        ct_ = ct.inverse()
+
+        ct_ = ct_.inverse()
+
+        self.assertTrue(
+            np.allclose(ct.tableau, ct_.tableau),
+            "The twice inverted tableau did not match",
+        )
+
+        self.assertTrue(
+            np.allclose(ct.signs, ct_.signs), "The twice inverted tableau did not match"
+        )
+
+    @parameterized.expand([(5,), (10,), (15,)])
+    def test_tableau_construction(self, n_qubits):
+        circuit = random_hscx_circuit(nr_qubits=n_qubits, nr_gates=1000)
+
+        ct = CliffordTableau(n_qubits)
+        ct = tableau_from_circuit(ct, circuit)
+
+        ct_ = CliffordTableau.from_tableau(ct.tableau, ct.signs)
+
+        self.assertTrue(
+            np.allclose(ct.tableau, ct_.tableau),
+            "The twice inverted tableau did not match",
+        )
+
+        self.assertTrue(
+            np.allclose(ct.signs, ct_.signs), "The twice inverted tableau did not match"
+        )
+
+    @parameterized.expand([(5,), (10,), (15,)])
+    def test_tableau_apply(self, n_qubits):
+        circuit = random_hscx_circuit(nr_qubits=n_qubits, nr_gates=1000)
+
+        ct = CliffordTableau(n_qubits)
+        ct = tableau_from_circuit(ct, circuit)
+
+        circuit_ = transpile(circuit.inverse(), basis_gates=["h", "s", "cx"])
+
+        ct_ = CliffordTableau(n_qubits)
+        ct_ = tableau_from_circuit(ct_, circuit_)
+
+        ct = ct.apply(ct_)
+        self.assertTrue(
+            np.allclose(ct.tableau, np.eye(2 * n_qubits)),
+            "The inverted tableau did not match the identity",
+        )
+
+    @parameterized.expand([(5,), (6,)])
+    def test_tableau_construction_prepend(self, n_qubits):
+        topo = Topology.complete(n_qubits)
+
+        circuit = random_hscx_circuit(nr_qubits=n_qubits, nr_gates=1000)
+
+        ct = CliffordTableau(n_qubits)
+        ct = tableau_from_circuit_prepend(ct, circuit)
+
+        qc, perm = synthesize_tableau(ct, topo, include_swaps=False)
+        qc = qc.to_qiskit()
+        self.assertTrue(
+            verify_equality(circuit.reverse_ops(), qc),
+            "The Synthesized circuit does not equal "
+            "to the original with reversed ops",
+        )
+
+    def test_string_representation(self):
+        ct = CliffordTableau(5)
+        ct.append_h(0)
+        ct.append_s(1)
+        ct.append_cnot(2, 3)
+        ct.append_cnot(2, 4)
+        ct.append_cnot(3, 4)
+
+        with open(f"{os.getcwd()}/tests/data/clifford/representation.txt", "r") as f:
+            self.assertEqual(
+                str(ct),
+                f.read(),
+                "The string representation of the tableau is incorrect",
+            )
diff --git a/tests/tableau/utils.py b/tests/tableau/utils.py
new file mode 100644
index 00000000..0ca7eab3
--- /dev/null
+++ b/tests/tableau/utils.py
@@ -0,0 +1,35 @@
+from qiskit import QuantumCircuit
+
+
+def tableau_from_circuit(tableau, circ: QuantumCircuit):
+    qreg = circ.qregs[0]
+
+    for op in circ:
+        if op.operation.name == "h":
+            tableau.append_h(qreg.index(op.qubits[0]))
+        elif op.operation.name == "s":
+            tableau.append_s(qreg.index(op.qubits[0]))
+        elif op.operation.name == "cx":
+            tableau.append_cnot(qreg.index(op.qubits[0]), qreg.index(op.qubits[1]))
+        else:
+            raise TypeError(
+                f"Unrecongnized Gate type: {op.operation.name} for Clifford Tableaus"
+            )
+    return tableau
+
+
+def tableau_from_circuit_prepend(tableau, circ: QuantumCircuit):
+    qreg = circ.qregs[0]
+
+    for op in circ:
+        if op.operation.name == "h":
+            tableau.prepend_h(qreg.index(op.qubits[0]))
+        elif op.operation.name == "s":
+            tableau.prepend_s(qreg.index(op.qubits[0]))
+        elif op.operation.name == "cx":
+            tableau.prepend_cnot(qreg.index(op.qubits[0]), qreg.index(op.qubits[1]))
+        else:
+            raise TypeError(
+                f"Unrecongnized Gate type: {op.operation.name} for Clifford Tableaus"
+            )
+    return tableau
diff --git a/tests/test_circuits.py b/tests/test_circuits.py
new file mode 100644
index 00000000..10247e6e
--- /dev/null
+++ b/tests/test_circuits.py
@@ -0,0 +1,100 @@
+import os
+import unittest
+
+from parameterized import parameterized
+
+from pauliopt.circuits import Circuit
+from pauliopt.gates import (
+    H,
+    S,
+    Sdg,
+    X,
+    Y,
+    Z,
+    T,
+    Tdg,
+    SWAP,
+    CX,
+    CY,
+    CZ,
+    CCX,
+    CCZ,
+    Rx,
+    Ry,
+    Rz,
+    CRx,
+    CRy,
+    CRz,
+)
+from pauliopt.utils import pi
+from tests.utils import verify_equality, random_circuit
+
+GATES_TO_TEST = [
+    H(0),
+    S(0),
+    Sdg(0),
+    X(0),
+    Y(0),
+    Z(0),
+    T(0),
+    Tdg(0),
+    SWAP(0, 1),
+    CX(0, 1),
+    CY(0, 1),
+    CZ(0, 1),
+    CCX(0, 1, 2),
+    CCZ(0, 1, 2),
+    Rx(pi / 2, 0),
+    Ry(pi / 2, 0),
+    Rz(pi / 2, 0),
+    CRx(pi / 2, 0, 1),
+    CRy(pi / 2, 0, 1),
+    CRz(pi / 2, 0, 1),
+]
+
+
+class TestCircuitConstruction(unittest.TestCase):
+    @parameterized.expand(
+        [
+            (5,),
+            (6,),
+            (7,),
+            (8,),
+        ]
+    )
+    def test_circuit_construction(self, nr_qubits):
+        qc = random_circuit(nr_qubits=nr_qubits, nr_gates=1000)
+
+        circ = Circuit.from_qiskit(qc)
+
+        qc_ = circ.to_qiskit()
+
+        self.assertTrue(
+            verify_equality(qc, qc_), "The converted circuit does not equal to original"
+        )
+
+    @parameterized.expand(
+        [
+            (
+                gate.name,
+                gate,
+            )
+            for gate in GATES_TO_TEST
+        ]
+    )
+    def test_circuit_representation_cli(self, name, gate):
+        circ = Circuit(3).add_gate(gate)
+
+        with open(f"{os.getcwd()}/tests/data/circ_reps/{gate.name}_cli.txt", "r") as f:
+            self.assertEqual(
+                f.read(),
+                circ.__str__(),
+                f"The CLI representation of {gate.name} " f"is incorrect or changed!",
+            )
+
+        with open(f"{os.getcwd()}/tests/data/circ_reps/{gate.name}_svg.txt", "r") as f:
+            self.assertEqual(
+                f.read(),
+                circ._to_svg(svg_code_only=True),
+                f"The SVG representation of {gate.name} " f"is incorrect or changed!",
+            )
diff --git a/tests/test_pauli_annealing.py b/tests/test_pauli_annealing.py
index 6ebd6d0c..3ae9461f 100644
--- a/tests/test_pauli_annealing.py
+++ b/tests/test_pauli_annealing.py
@@ -15,6 +15,7 @@
 from pauliopt.pauli.pauli_polynomial import PauliPolynomial
 from pauliopt.pauli.utils import X, Y, Z, I
 from pauliopt.topologies import Topology
+from pauliopt.utils import pi
 
 PAULI_TO_TKET = {X: Pauli.X, Y: Pauli.Y, Z: Pauli.Z, I: Pauli.I}
 
@@ -28,7 +29,8 @@ def pauli_poly_to_tket(pp: PauliPolynomial):
     for gadget in pp.pauli_gadgets:
         circuit.add_pauliexpbox(
             PauliExpBox(
-                [PAULI_TO_TKET[p] for p in gadget.paulis], gadget.angle / np.pi
+                [PAULI_TO_TKET[p] for p in gadget.paulis],
+                gadget.angle.to_qiskit / np.pi,
             ),
             list(range(pp.num_qubits)),
         )
@@ -53,7 +55,7 @@ def verify_equality(qc_in, qc_out):
 
 
 def generate_all_combination_pauli_polynomial(n_qubits=2):
-    allowed_angels = [2 * np.pi, np.pi, 0.5 * np.pi, 0.25 * np.pi, 0.125 * np.pi]
+    allowed_angels = [2 * pi, pi, pi / 2, pi / 4, pi / 8]
     pp = PauliPolynomial(n_qubits)
     for comb in itertools.product([X, Y, Z, I], repeat=n_qubits):
         pp >>= PPhase(np.random.choice(allowed_angels)) @ list(comb)
@@ -92,7 +94,7 @@ def test_simulated_annealing_pauli(self):
         2) When synthesizing onto a different architecture the circuits should match the ones of tket
         3) Check that our to_qiskit method exports the Pauli Polynomial according to an architecture
         """
-        for num_qubits in [2, 3, 4]:
+        for num_qubits in [2, 3]:
             for topo_creation in [Topology.line, Topology.complete]:
                 pp = generate_all_combination_pauli_polynomial(n_qubits=num_qubits)
 
diff --git a/tests/test_pauli_propagation.py b/tests/test_pauli_propagation.py
index caf1d117..d57bcac2 100644
--- a/tests/test_pauli_propagation.py
+++ b/tests/test_pauli_propagation.py
@@ -29,6 +29,7 @@
 from pauliopt.pauli.utils import X, Y, Z, I
 
 from pauliopt.topologies import Topology
+from pauliopt.utils import pi
 
 PAULI_TO_TKET = {X: Pauli.X, Y: Pauli.Y, Z: Pauli.Z, I: Pauli.I}
 
@@ -42,7 +43,8 @@ def pauli_poly_to_tket(pp: PauliPolynomial):
     for gadget in pp.pauli_gadgets:
         circuit.add_pauliexpbox(
             PauliExpBox(
-                [PAULI_TO_TKET[p] for p in gadget.paulis], gadget.angle / np.pi
+                [PAULI_TO_TKET[p] for p in gadget.paulis],
+                gadget.angle.to_qiskit / np.pi,
             ),
             list(range(pp.num_qubits)),
         )
@@ -67,7 +69,7 @@ def verify_equality(qc_in, qc_out):
 
 
 def generate_all_combination_pauli_polynomial(n_qubits=2):
-    allowed_angels = [2 * np.pi, np.pi, 0.5 * np.pi, 0.25 * np.pi, 0.125 * np.pi]
+    allowed_angels = [2 * pi, pi, pi / 2, pi / 4, pi / 8]
     pp = PauliPolynomial(n_qubits)
     for comb in itertools.product([X, Y, Z, I], repeat=n_qubits):
         pp >>= PPhase(np.random.choice(allowed_angels)) @ list(comb)
diff --git a/tests/test_pauli_representation.py b/tests/test_pauli_representation.py
index 24130f28..7d74779f 100644
--- a/tests/test_pauli_representation.py
+++ b/tests/test_pauli_representation.py
@@ -3,20 +3,24 @@
 from pauliopt.pauli.pauli_gadget import PPhase
 from pauliopt.pauli.pauli_polynomial import PauliPolynomial
 from pauliopt.pauli.utils import *
+from pauliopt.utils import Angle, pi
+import os
 
-_PAULI_REPR = "(0.5) @ { I, X, Y, Z }\n(0.25) @ { X, X, Y, X }"
+_PAULI_REPR = "(π/2) @ { I, X, Y, Z }\n(π/4) @ { X, X, Y, X }"
+
+SVG_CODE_PAULI = '<?xml version="1.0" encoding="utf-8"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="610" height="210"><linearGradient id="ycolor" x1="0%" x2="100%" y1="100%" y2="0%"><stop offset="0%"  stop-color="#FF8888"/><stop offset="50%"  stop-color="#FF8888"/><stop offset="50%"  stop-color="#CCFFCC"/><stop offset="100%"  stop-color="#CCFFCC"/></linearGradient>\n<path fill="none" stroke="black" d="M 0, 130 L 10, 130"/>\n<path d="M 80 30 Q 72 84 30 120" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="10" y="120" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 0, 160 L 10, 160"/>\n<path d="M 80 30 Q 82 101 30 150" fill="none" stroke="black"/>\n<rect fill="#CCFFCC" stroke="black" x="10" y="150" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 0, 190 L 10, 190"/>\n<path d="M 80 30 Q 92 117 30 180" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="10" y="180" width="20" height="20"/>\n<svg x="60" y="10" height="20" width="50"><rect x="0" y="0" width="100%" height="100%" stroke="black" fill="white" stroke-width="5 %"/><text x="50%" y="50%" width="100%" height="100%" font-size="100%" dominant-baseline="middle" text-anchor="middle" >π</text></svg>\n<path fill="none" stroke="black" d="M 0, 70 L 110, 70"/>\n<path d="M 180 30 Q 155 45 130 60" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="110" y="60" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 0, 100 L 110, 100"/>\n<path d="M 180 30 Q 162 66 130 90" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="110" y="90" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 30, 190 L 110, 190"/>\n<path d="M 180 30 Q 192 117 130 180" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="110" y="180" width="20" height="20"/>\n<svg x="160" y="10" height="20" width="50"><rect x="0" y="0" width="100%" height="100%" stroke="black" fill="white" stroke-width="5 %"/><text x="50%" y="50%" width="100%" height="100%" font-size="100%" dominant-baseline="middle" text-anchor="middle" >π/2</text></svg>\n<path fill="none" stroke="black" d="M 130, 70 L 210, 70"/>\n<path d="M 280 30 Q 255 45 230 60" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="210" y="60" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 30, 160 L 210, 160"/>\n<path d="M 280 30 Q 282 101 230 150" fill="none" stroke="black"/>\n<rect fill="#CCFFCC" stroke="black" x="210" y="150" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 130, 190 L 210, 190"/>\n<path d="M 280 30 Q 292 117 230 180" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="210" y="180" width="20" height="20"/>\n<svg x="260" y="10" height="20" width="50"><rect x="0" y="0" width="100%" height="100%" stroke="black" fill="white" stroke-width="5 %"/><text x="50%" y="50%" width="100%" height="100%" font-size="100%" dominant-baseline="middle" text-anchor="middle" >π/256</text></svg>\n<path fill="none" stroke="black" d="M 230, 70 L 310, 70"/>\n<path d="M 380 30 Q 355 45 330 60" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="310" y="60" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 130, 100 L 310, 100"/>\n<path d="M 380 30 Q 362 66 330 90" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="310" y="90" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 30, 130 L 310, 130"/>\n<path d="M 380 30 Q 372 84 330 120" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="310" y="120" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 230, 160 L 310, 160"/>\n<path d="M 380 30 Q 382 101 330 150" fill="none" stroke="black"/>\n<rect fill="#CCFFCC" stroke="black" x="310" y="150" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 230, 190 L 310, 190"/>\n<path d="M 380 30 Q 392 117 330 180" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="310" y="180" width="20" height="20"/>\n<svg x="360" y="10" height="20" width="50"><rect x="0" y="0" width="100%" height="100%" stroke="black" fill="white" stroke-width="5 %"/><text x="50%" y="50%" width="100%" height="100%" font-size="100%" dominant-baseline="middle" text-anchor="middle" >π/8</text></svg>\n<path fill="none" stroke="black" d="M 330, 70 L 410, 70"/>\n<path d="M 480 30 Q 455 45 430 60" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="410" y="60" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 330, 100 L 410, 100"/>\n<path d="M 480 30 Q 462 66 430 90" fill="none" stroke="black"/>\n<rect fill="#CCFFCC" stroke="black" x="410" y="90" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 330, 190 L 410, 190"/>\n<path d="M 480 30 Q 492 117 430 180" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="410" y="180" width="20" height="20"/>\n<svg x="460" y="10" height="20" width="50"><rect x="0" y="0" width="100%" height="100%" stroke="black" fill="white" stroke-width="5 %"/><text x="50%" y="50%" width="100%" height="100%" font-size="100%" dominant-baseline="middle" text-anchor="middle" >π/4</text></svg>\n<path fill="none" stroke="black" d="M 430, 70 L 510, 70"/>\n<path d="M 580 30 Q 555 45 530 60" fill="none" stroke="black"/>\n<rect fill="#FF8888" stroke="black" x="510" y="60" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 330, 160 L 510, 160"/>\n<path d="M 580 30 Q 582 101 530 150" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="510" y="150" width="20" height="20"/>\n<path fill="none" stroke="black" d="M 430, 190 L 510, 190"/>\n<path d="M 580 30 Q 592 117 530 180" fill="none" stroke="black"/>\n<rect fill="url(#ycolor)" stroke="black" x="510" y="180" width="20" height="20"/>\n<svg x="560" y="10" height="20" width="50"><rect x="0" y="0" width="100%" height="100%" stroke="black" fill="white" stroke-width="5 %"/><text x="50%" y="50%" width="100%" height="100%" font-size="100%" dominant-baseline="middle" text-anchor="middle" >π/2</text></svg>\n<path fill="none" stroke="black" d="M 530, 70 L 610, 70"/>\n<path fill="none" stroke="black" d="M 430, 100 L 610, 100"/>\n<path fill="none" stroke="black" d="M 330, 130 L 610, 130"/>\n<path fill="none" stroke="black" d="M 530, 160 L 610, 160"/>\n<path fill="none" stroke="black" d="M 530, 190 L 610, 190"/>\n</svg>'
 
 
 class TestPauliConversion(unittest.TestCase):
     def test_circuit_construction(self):
         pp = PauliPolynomial(4)
 
-        pp >>= PPhase(0.5) @ [I, X, Y, Z]
+        pp >>= PPhase(Angle(pi / 2)) @ [I, X, Y, Z]
 
         self.assertEqual(pp.num_qubits, 4)
         self.assertEqual(len(pp), 1)
 
-        pp >>= PPhase(0.25) @ [X, X, Y, X]
+        pp >>= PPhase(Angle(pi / 4)) @ [X, X, Y, X]
 
         self.assertEqual(pp.__repr__(), _PAULI_REPR)
         self.assertEqual(len(pp), 2)
@@ -29,3 +33,15 @@ def test_circuit_construction(self):
             pp_.__repr__(),
             "Right shift resulted in different pauli Polynomials.",
         )
+
+    def test_circuit_visualisation_svg(self):
+        pp = PauliPolynomial(5)
+
+        pp >>= PPhase(Angle(pi)) @ [I, I, X, Z, Y]
+        pp >>= PPhase(Angle(pi / 2)) @ [X, X, I, I, Y]
+        pp >>= PPhase(Angle(pi / 256)) @ [X, I, I, Z, Y]
+        pp >>= PPhase(Angle(pi / 8)) @ [X, X, X, Z, Y]
+        pp >>= PPhase(Angle(pi / 4)) @ [X, Z, I, I, Y]
+        pp >>= PPhase(Angle(pi / 2)) @ [X, I, I, Y, Y]
+
+        self.assertEqual(pp.to_svg(svg_code_only=True), SVG_CODE_PAULI)
diff --git a/tests/test_phase_circuit_synthesis.py b/tests/test_phase_circuit_synthesis.py
index 59bc403a..ffa4cbdb 100644
--- a/tests/test_phase_circuit_synthesis.py
+++ b/tests/test_phase_circuit_synthesis.py
@@ -39,9 +39,9 @@ def unpermute(circuit: QuantumCircuit):
 
 class TestPhaseCircuitSynthesis(unittest.TestCase):
     def setUp(self):
-        self.n_tests = 20
+        self.n_tests = 2
         n_gadgets = 9
-        self.topology = Topology.grid(3, 3)
+        self.topology = Topology.grid(2, 3)
         self.circuits = [
             PhaseCircuit.random(self.topology.num_qubits, n_gadgets, rng_seed=SEED)
             for _ in range(self.n_tests)
diff --git a/tests/test_reverse_traversal.py b/tests/test_reverse_traversal.py
index e7dac5f0..72503605 100644
--- a/tests/test_reverse_traversal.py
+++ b/tests/test_reverse_traversal.py
@@ -44,7 +44,7 @@ def unpermute(circuit: QuantumCircuit):
 
 class TestPhaseCircuitSynthesis(unittest.TestCase):
     def setUp(self):
-        self.n_tests = 10
+        self.n_tests = 2
         n_gadgets = 10
         self.num_rt_iters = 10
         self.num_anneal_iters = 100
diff --git a/tests/utils.py b/tests/utils.py
new file mode 100644
index 00000000..8d978440
--- /dev/null
+++ b/tests/utils.py
@@ -0,0 +1,198 @@
+import numpy as np
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import (
+    CXGate,
+    HGate,
+    SGate,
+    SXGate,
+    TGate,
+    TdgGate,
+    SdgGate,
+    SXdgGate,
+    ZGate,
+    YGate,
+    XGate,
+    SwapGate,
+    CYGate,
+    CZGate,
+    CCXGate,
+    CCZGate,
+    RXGate,
+    RZGate,
+    RYGate,
+    CRXGate,
+    CRYGate,
+    CRZGate,
+)
+from qiskit.quantum_info import Operator
+
+guadalupe_connectivity = [
+    [0, 1],
+    [1, 0],
+    [1, 2],
+    [1, 4],
+    [2, 1],
+    [2, 3],
+    [3, 2],
+    [3, 5],
+    [4, 1],
+    [4, 7],
+    [5, 3],
+    [5, 8],
+    [6, 7],
+    [7, 4],
+    [7, 6],
+    [7, 10],
+    [8, 5],
+    [8, 9],
+    [8, 11],
+    [9, 8],
+    [10, 7],
+    [10, 12],
+    [11, 8],
+    [11, 14],
+    [12, 10],
+    [12, 13],
+    [12, 15],
+    [13, 12],
+    [13, 14],
+    [14, 11],
+    [14, 13],
+    [15, 12],
+]
+
+NAME_CONVERSION = {
+    "H": HGate,
+    "X": XGate,
+    "Y": YGate,
+    "Z": ZGate,
+    "S": SGate,
+    "Sdg": SdgGate,
+    # "V": SXGate,
+    # "Vdg": SXdgGate,
+    "T": TGate,
+    "Tdg": TdgGate,
+    "swap": SwapGate,
+    "CX": CXGate,
+    "CY": CYGate,
+    "CZ": CZGate,
+    "CCX": CCXGate,
+    "CCZ": CCZGate,
+    "rx": RXGate,
+    "ry": RYGate,
+    "rz": RZGate,
+    "crx": CRXGate,
+    "cry": CRYGate,
+    "crz": CRZGate,
+}
+
+
+def random_circuit(nr_gates, nr_qubits, gate_choice=None):
+    qc = QuantumCircuit(nr_qubits)
+
+    if gate_choice is None:
+        gate_choice = list(NAME_CONVERSION.values())
+
+    else:
+        gate_choice = [NAME_CONVERSION[gate_name] for gate_name in gate_choice]
+
+    single_qubit_gates = [
+        HGate,
+        SGate,
+        SXGate,
+        XGate,
+        YGate,
+        ZGate,
+        TGate,
+        TdgGate,
+        RXGate,
+        RYGate,
+        RZGate,
+    ]
+    two_qubit_gates = [CXGate, CYGate, CZGate, CRXGate, CRYGate, CRZGate]
+    three_qubit_gates = [CCXGate, CCZGate]
+    single_param_gates = [RXGate, RYGate, RZGate, CRXGate, CRYGate, CRZGate]
+
+    for _ in range(nr_gates):
+        gate_class = np.random.choice(gate_choice)
+        if gate_class in single_param_gates:
+            gate_instance = gate_class(np.random.uniform(0, 2 * np.pi))
+        else:
+            gate_instance = gate_class()
+
+        if gate_class in single_qubit_gates:
+            qubit = np.random.choice([i for i in range(nr_qubits)])
+            qc.append(gate_instance, [qubit])
+
+        elif gate_class in two_qubit_gates:
+            control = np.random.choice([i for i in range(nr_qubits)])
+            target = np.random.choice([i for i in range(nr_qubits) if i != control])
+            qc.append(gate_instance, [control, target])
+        elif gate_class in three_qubit_gates:
+            control1 = np.random.choice([i for i in range(nr_qubits)])
+            control2 = np.random.choice([i for i in range(nr_qubits) if i != control1])
+            target = np.random.choice(
+                [i for i in range(nr_qubits) if i not in [control1, control2]]
+            )
+            qc.append(gate_instance, [control1, control2, target])
+
+    return qc
+
+
+def verify_equality(qc_in, qc_out):
+    return Operator.from_circuit(qc_in).equiv(Operator.from_circuit(qc_out))
+
+
+def random_clifford_circuit(nr_gates=20, nr_qubits=4, gate_choice=None):
+    qc = QuantumCircuit(nr_qubits)
+    if gate_choice is None:
+        gate_choice = ["CY", "CZ", "CX", "H", "S", "V"]
+    for _ in range(nr_gates):
+        gate_t = np.random.choice(gate_choice)
+        if gate_t == "CX":
+            control = np.random.choice([i for i in range(nr_qubits)])
+            target = np.random.choice([i for i in range(nr_qubits) if i != control])
+            qc.cx(control, target)
+        elif gate_t == "CY":
+            control = np.random.choice([i for i in range(nr_qubits)])
+            target = np.random.choice([i for i in range(nr_qubits) if i != control])
+            qc.cy(control, target)
+        elif gate_t == "CZ":
+            control = np.random.choice([i for i in range(nr_qubits)])
+            target = np.random.choice([i for i in range(nr_qubits) if i != control])
+            qc.cz(control, target)
+        elif gate_t == "H":
+            qubit = np.random.choice([i for i in range(nr_qubits)])
+            qc.h(qubit)
+        elif gate_t == "S":
+            qubit = np.random.choice([i for i in range(nr_qubits)])
+            qc.s(qubit)
+        elif gate_t == "V":
+            qubit = np.random.choice([i for i in range(nr_qubits)])
+            qc.sx(qubit)
+        elif gate_t == "CX":
+            control = np.random.choice([i for i in range(nr_qubits)])
+            target = np.random.choice([i for i in range(nr_qubits) if i != control])
+            qc.cx(control, target)
+    return qc
+
+
+def random_hscx_circuit(nr_gates=20, nr_qubits=4):
+    gate_choice = ["CX", "H", "S"]
+    return random_clifford_circuit(
+        nr_gates=nr_gates, nr_qubits=nr_qubits, gate_choice=gate_choice
+    )
+
+
+def apply_permutation(qc: QuantumCircuit, permutation: list):
+    if len(qc.qregs) != 1:
+        raise ValueError("Quantum circuit must have exactly one quantum register")
+    register = qc.qregs[0]
+    qc_out = QuantumCircuit(register)
+    for instruction in qc:
+        op_qubits = [
+            register[permutation[register.index(q)]] for q in instruction.qubits
+        ]
+        instruction.qubits = tuple(op_qubits)
+        qc_out.append(instruction, instruction.qubits)
+    return qc_out