### Installation

Source: https://docs.quantinuum.com/tket/extensions/pytket-qiskit/index.html

Install pytket-qiskit using pip. This will also install pytket if not already present.

```APIDOC
## Installation

To install pytket-qiskit, run the following command:

```bash
pip install pytket-qiskit
```

This command will install `pytket` if it is not already installed and add new classes and methods to the `pytket.extensions` namespace.
```

--------------------------------

### Installation

Source: https://docs.quantinuum.com/tket/extensions/pytket-qulacs

Instructions for installing the pytket-qulacs library and the GPU-accelerated version.

```APIDOC
## Installation

To install pytket-qulacs, run:
```
pip install pytket-qulacs
```

For GPU acceleration, first install the CUDA toolset and then install qulacs-gpu:
```
pip install qulacs-gpu
```
```

--------------------------------

### Run Circuit and Get Metadata with IQMBackend

Source: https://docs.quantinuum.com/tket/extensions/pytket-iqm/api.html

Example demonstrating how to run a circuit on an IQM backend, process circuits, retrieve results, and fetch metadata including qubit mapping. Supports specifying the number of shots and a timeout for the job.

```python
n_shots = 100
backend.run_circuit(circuit, n_shots=n_shots, timeout=30)
handle = backend.process_circuits([circuit], n_shots=n_shots)[0]
result = backend.get_result(handle)
metadata = backend.get_metadata(handle)
print([qm.physical_name for qm in metadata.request.qubit_mapping])
```

--------------------------------

### Install pytket-qiskit

Source: https://docs.quantinuum.com/tket/extensions/pytket-qiskit/_sources/index.md.txt

Install the pytket-qiskit extension using pip. This command also installs pytket if it is not already present.

```bash
pip install pytket-qiskit
```

--------------------------------

### Install pytket and extensions

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/d922c7adacb2f32bc2e4c3ecd7e6f7c3/backends_example.ipynb

Install the core pytket package along with necessary provider extensions and openfermion.

```bash
pip install pytket pytket-qiskit pytket-projectq openfermion
```

--------------------------------

### Install Quantinuum Emulator

Source: https://docs.quantinuum.com/tket/extensions/pytket-quantinuum

Commands to install the necessary packages for local emulation of Quantinuum circuits.

```bash
pip install pytket-quantinuum[pecos]
```

```bash
uv pip install pytket-pecos --prerelease=allow
```

--------------------------------

### Install pytket-qulacs

Source: https://docs.quantinuum.com/tket/extensions/pytket-qulacs/_sources/index.rst.txt

Standard installation command for the pytket-qulacs package.

```bash
pip install pytket-qulacs
```

--------------------------------

### Install pytket extension modules

Source: https://docs.quantinuum.com/tket/api-docs/_sources/install.md.txt

Command to install additional pytket-X modules, where X is the target framework.

```bash
pip install pytket-X
```

--------------------------------

### Install pytket

Source: https://docs.quantinuum.com/tket/api-docs/_sources/getting_started.md.txt

Install the pytket package and tket compiler binaries using pip.

```bash
pip install pytket
```

--------------------------------

### Setup Circuit Renderer with Fallback

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/a72d4b407bcc3c831a20f7353744a159/compilation_example.ipynb

This script loads the Vue.js framework and the pytket-circuit-renderer library. It includes fallback mechanisms to load these resources from jsdelivr if unpkg is unavailable. This setup is necessary for rendering quantum circuits in a web environment.

```javascript
<!-- Bypass some Iframe origin concerns for VS Code and import the scripts needed
Directly so they will be cached for the subsequent IFrame. -->
<!-- Download Vue 3-->
<script type="application/javascript" src="https://unpkg.com/vue@3"></script>
<!-- Download Circuit Renderer with styles -->
<script type="application/javascript" src="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js"></script>
<link rel="stylesheet" href="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css">

<!-- Fallback to jsdelivr in case UNPKG is down -->
<script type="application/javascript">
    if (typeof Vue === "undefined") {
        const loadVue = new Promise(resolve => {
            const vueFallback = document.createElement("script")
            vueFallback.type = "application/javascript"
            vueFallback.src = "https://cdn.jsdelivr.net/npm/vue@3"
            vueFallback.async = false
            vueFallback.defer = false
            vueFallback.addEventListener('load', () => {
              console.log("vue loaded");
              resolve(true)
            })
            document.head.appendChild(vueFallback)
        })
        const loadRenderer = new Promise(resolve => {
            const rendererFallback = document.createElement("script")
            rendererFallback.type = "application/javascript"
            rendererFallback.src = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js"
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>
```

--------------------------------

### Install pytket-pennylane

Source: https://docs.quantinuum.com/tket/extensions/pytket-pennylane/index.html

Use pip to install the extension package in your Python environment.

```bash
pip install pytket-pennylane
```

--------------------------------

### Install Quantinuum Backend with Pecos

Source: https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/_sources/index.md.txt

Installs the pytket-quantinuum package with the pecos emulator option.

```bash
pip install pytket-quantinuum[pecos]
```

--------------------------------

### Install pytket-braket

Source: https://docs.quantinuum.com/tket/extensions/pytket-braket/index.html

Install the pytket-braket extension using pip. Requires an Amazon Braket account.

```bash
pip install pytket-braket

```

--------------------------------

### Install pytket-iqm via pip

Source: https://docs.quantinuum.com/tket/extensions/pytket-iqm/_sources/index.rst.txt

Use this command to install the pytket-iqm extension for Python environments.

```bash
pip install pytket-iqm
```

--------------------------------

### Install pytket-iqm

Source: https://docs.quantinuum.com/tket/extensions/pytket-iqm

Install the pytket-iqm extension using pip. This command is used to add the library to your Python environment.

```bash
pip install pytket-iqm

```

--------------------------------

### Basic Circuit Compilation Example

Source: https://docs.quantinuum.com/tket/user-guide/examples/backends/creating_backends.html

This example demonstrates adding gates to a circuit and printing the result of running it. It uses QubitPauliString for gate definition.

```python
circ.add_gate(QubitPauliString(Qubit(0), Pauli.Z), -np.pi / 2)
circ.add_gate(QubitPauliString(Qubit(1), Pauli.X), -np.pi / 2)
circ.add_gate(QubitPauliString({Qubit(0): Pauli.Z, Qubit(1): Pauli.X}), np.pi / 2)
print(run_mycircuit(circ))

```

--------------------------------

### Initialize QuantinuumBackend

Source: https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/_sources/index.md.txt

Example of setting up a circuit and initializing a Quantinuum backend.

```python
from pytket import Circuit
from pytket.extensions.quantinuum import QuantinuumBackend

circ = Circuit(2).H(0).CX(0, 1).CZ(0, 1)
backend = QuantinuumBackend('H2-1E')
```

--------------------------------

### Initialize IBMQEmulatorBackend

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/156628c2393654f0b29d4758749fdf48/qiskit_integration.ipynb

Set up a pytket IBMQEmulatorBackend to simulate noisy device characteristics.

```python
from pytket.extensions.qiskit import IBMQEmulatorBackend

b_emu = IBMQEmulatorBackend("ibm_kyiv", instance="ibm-q/open/main")
```

--------------------------------

### Install Qulacs with GPU Acceleration

Source: https://docs.quantinuum.com/tket/extensions/pytket-qulacs/index.html

To utilize the QulacsGPUBackend for faster simulation on CUDA-enabled GPUs, first install the CUDA toolset. Then, install the qulacs-gpu package.

```bash
pip install qulacs-gpu

```

--------------------------------

### Local Emulators Setup

Source: https://docs.quantinuum.com/tket/extensions/pytket-quantinuum

Instructions for setting up and using local emulators for the Quantinuum backend.

```APIDOC
## Local Emulators

If `pytket-quantinuum` is installed with the `pecos` option:

```bash
pip install pytket-quantinuum[pecos]
```

For `uv` virtual environments it is possible that this does not work, because prereleases are not picked up automatically. This can be solved by installing the latest `pytket-pecos` version via:

```bash
uv pip install pytket-pecos --prerelease=allow
```

then it is possible to run circuits on an emulator running on the local machine.
Currently this emulation is noiseless.
```

--------------------------------

### Initialize Circuit Renderer Environment

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/f32d5da976ec5cfd7b1586757fa22371/circuit_generation_example.ipynb

This script sets up the environment for rendering quantum circuits by loading Vue and the pytket circuit renderer, with fallback mechanisms for CDN availability.

```html







<!-- Bypass some Iframe origin concerns for VS Code and import the scripts needed
directly so they will be cached for the subsequent IFrame. -->
<!-- Download Vue 3-->
<script type="application/javascript" src="https://unpkg.com/vue@3"></script>
<!-- Download Circuit Renderer with styles -->
<script type="application/javascript" src="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js"></script>
<link rel="stylesheet" href="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css">

<!-- Fallback to jsdelivr in case UNPKG is down -->
<script type="application/javascript">
    if (typeof Vue === "undefined") {
        const loadVue = new Promise(resolve => {
            const vueFallback = document.createElement("script")
            vueFallback.type = "application/javascript"
            vueFallback.src = "https://cdn.jsdelivr.net/npm/vue@3"
            vueFallback.async = false
            vueFallback.defer = false
            vueFallback.addEventListener('load', () => {
              console.log("vue loaded");
              resolve(true)
            })
            document.head.appendChild(vueFallback)
        })
        const loadRenderer = new Promise(resolve => {
            const rendererFallback = document.createElement("script")
            rendererFallback.type = "application/javascript"
            rendererFallback.src = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js"
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>

<div style="resize: vertical; overflow: auto; height: 400px; display: block">
    <iframe srcdoc="
<!DOCTYPE html>
<html lang=&quot;en&quot;>
<head>
    <meta charset=&quot;UTF-8&quot;>
    <!-- Download Vue 3-->
<script type=&quot;application/javascript&quot; src=&quot;https://unpkg.com/vue@3&quot;></script>
<!-- Download Circuit Renderer with styles -->
<script type=&quot;application/javascript&quot; src=&quot;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js&quot;></script>
<link rel=&quot;stylesheet&quot; href=&quot;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css&quot;>

<!-- Fallback to jsdelivr in case UNPKG is down -->
<script type=&quot;application/javascript&quot;>
    if (typeof Vue === &quot;undefined&quot;) {
```

--------------------------------

### Initialize ProjectQ Backend

Source: https://docs.quantinuum.com/tket/user-guide/examples/algorithms_and_protocols/expectation_value_example.html

Import the ProjectQ backend for statevector simulation.

```python
from pytket.extensions.projectq import ProjectQBackend
```

--------------------------------

### Install pytket-pysimplex

Source: https://docs.quantinuum.com/tket/extensions/pytket-pysimplex/index.html

Use pip to install the pytket-pysimplex package.

```bash
pip install pytket-pysimplex
```

--------------------------------

### Debug Output Example

Source: https://docs.quantinuum.com/tket/user-guide/manual/manual_assertion.html

Example output from the get_debug_info method.

```text
{'Rx(0.3)|0>': 0.79, '|bell>': 1.0}
```

--------------------------------

### Initialize ProjectQ Backend

Source: https://docs.quantinuum.com/tket/user-guide/_sources/examples/algorithms_and_protocols/expectation_value_example.ipynb.txt

Initializes the ProjectQBackend for simulating quantum circuits and calculating expectation values.

```python
from pytket.extensions.projectq import ProjectQBackend
```

```python
backend = ProjectQBackend()
```

--------------------------------

### Install qiskit-aer-gpu

Source: https://docs.quantinuum.com/tket/extensions/pytket-qiskit/_sources/index.md.txt

Install the qiskit-aer-gpu package for GPU simulation support.

```bash
pip install qiskit-aer-gpu
```

--------------------------------

### Initialize Circuit and Display

Source: https://docs.quantinuum.com/tket/user-guide/_sources/examples/circuit_construction/circuit_generation_example.ipynb.txt

Import the Circuit class and the Jupyter renderer to begin building and visualizing quantum circuits.

```python
from pytket.circuit import Circuit
from pytket.circuit.display import render_circuit_jupyter as draw
```

--------------------------------

### Example Expectation Value Output

Source: https://docs.quantinuum.com/tket/user-guide/manual/manual_backend.html

This is an example of the calculated expectation value.

```python
0.009000000000000008
```

--------------------------------

### Define Start Transformation

Source: https://docs.quantinuum.com/tket/api-docs/_modules/pytket/quipper/quipper.html

Transforms the starting point of a circuit definition.

```python
def start(self, t: list) -> _Start:
        circuit = t.pop(0)
        return _Start(circuit, list(t))
```

--------------------------------

### Initialize Circuit Renderer with Fallbacks

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/f32d5da976ec5cfd7b1586757fa22371/circuit_generation_example.ipynb

HTML and JavaScript setup to load Vue and the circuit renderer, including a fallback to jsDelivr if UNPKG is unavailable.

```html
<!-- Bypass some Iframe origin concerns for VS Code and import the scripts needed
directly so they will be cached for the subsequent IFrame. -->
<!-- Download Vue 3-->
<script type="application/javascript" src="https://unpkg.com/vue@3"></script>
<!-- Download Circuit Renderer with styles -->
<script type="application/javascript" src="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js"></script>
<link rel="stylesheet" href="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css">

<!-- Fallback to jsdelivr in case UNPKG is down -->
<script type="application/javascript">
    if (typeof Vue === "undefined") {
        const loadVue = new Promise(resolve => {
            const vueFallback = document.createElement("script")
            vueFallback.type = "application/javascript"
            vueFallback.src = "https://cdn.jsdelivr.net/npm/vue@3"
            vueFallback.async = false
            vueFallback.defer = false
            vueFallback.addEventListener('load', () => {
              console.log("vue loaded");
              resolve(true)
            })
            document.head.appendChild(vueFallback)
        })
        const loadRenderer = new Promise(resolve => {
            const rendererFallback = document.createElement("script")
            rendererFallback.type = "application/javascript"
            rendererFallback.src = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js"
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>

<div style="resize: vertical; overflow: auto; height: 400px; display: block">
    <iframe srcdoc="
&lt;!DOCTYPE html&gt;
&lt;html lang=&#34;en&#34;&gt;
&lt;head&gt;
    &lt;meta charset=&#34;UTF-8&#34;&gt;
    &lt;!-- Download Vue 3--&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/vue@3&#34;&gt;&lt;/script&gt;
&lt;!-- Download Circuit Renderer with styles --&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js&#34;&gt;&lt;/script&gt;
&lt;link rel=&#34;stylesheet&#34; href=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css&#34;&gt;

&lt;!-- Fallback to jsdelivr in case UNPKG is down --&gt;
&lt;script type=&#34;application/javascript&#34;&gt;
```

--------------------------------

### Install pytket-stim

Source: https://docs.quantinuum.com/tket/extensions/pytket-stim/index.html

Use pip to install the pytket-stim package in your Python environment.

```bash
pip install pytket-stim
```

--------------------------------

### Initialize Circuit Renderer

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/f32d5da976ec5cfd7b1586757fa22371/circuit_generation_example.ipynb

HTML and JavaScript setup for rendering quantum circuits within a web container.

```html
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>
</head>
<body>


    <div id="circuit-display-vue-container-52d8424a-6582-4084-9f5e-effb19692c27" class="pytket-circuit-display-container">
        <div style="display: none">
            <div id="circuit-json-to-display">{"bits": [], "commands": [{"args": [["x", []], ["y", []]], "op": {"type": "CX"}}, {"args": [["y", []], ["x", []]], "op": {"type": "CZ"}}, {"args": [["y", []], ["x", []]], "op": {"type": "CZ"}}, {"args": [["y", []], ["z", []]], "op": {"type": "CY"}}], "created_qubits": [], "discarded_qubits": [], "implicit_permutation": [[["x", []], ["x", []]], [["y", []], ["y", []]], [["z", []], ["z", []]]], "phase": "0.0", "qubits": [["x", []], ["y", []], ["z", []]]}</div>
        </div>
        <circuit-display-container
                :circuit-element-str="'#circuit-json-to-display'"
                :init-render-options="initRenderOptions"
                view-format="None"
        ></circuit-display-container>
    </div>
    <script type="application/javascript">
      (async function () {
        await window['_circuitRendererLoading']

        const circuitRendererUid = "52d8424a-6582-4084-9f5e-effb19692c27";
        const displayOptions = JSON.parse('{}');

        // Script to initialise the circuit renderer app

const { createApp } = Vue;
const circuitDisplayContainer = window["pytket-circuit-renderer"].default;
// Init variables to be shared between circuit display instances
if (typeof window.pytketCircuitDisplays === "undefined") {
    window.pytketCircuitDisplays = {};
}
// Create the root Vue component
const app = createApp({
    delimiters: ['[[#', '#]]'],
    components: { circuitDisplayContainer },
    data () {
      return {
        initRenderOptions: displayOptions,
      }
    }
})
app.config.unwrapInjectedRef = true;
app.mount("#circuit-display-vue-container-"+circuitRendererUid);
window.pytketCircuitDisplays[circuitRendererUid] = app;
      })()
    </script>



</body>
</html>
```

--------------------------------

### Install pytket-offline-display

Source: https://docs.quantinuum.com/tket/api-docs/display.html

Install the pytket-offline-display extension to enable offline circuit rendering.

```bash
pip install pytket-offline-display

```

--------------------------------

### Setup Simulation Backend

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/4061fb72cb75444721fd25b83d4f0e10/entanglement_swapping.ipynb

Imports and initializes the AerBackend for noiseless simulation.

```python
from pytket.extensions.qiskit import AerBackend
```

```python
backend = AerBackend()
```

--------------------------------

### Install offline renderer

Source: https://docs.quantinuum.com/tket/api-docs/_sources/display.md.txt

Install the extension to enable offline circuit rendering.

```bash
pip install pytket-offline-display
```

--------------------------------

### ForestStateBackend Initialization

Source: https://docs.quantinuum.com/tket/extensions/pytket-pyquil/_modules/pytket/extensions/pyquil/backends/forest.html

Initializes the ForestStateBackend for running simulations using Rigetti's QVM Wavefunction Simulator. No specific setup is required beyond instantiation.

```python
super().__init__()
self._sim = WavefunctionSimulator()
```

--------------------------------

### TketBackend.__init__

Source: https://docs.quantinuum.com/tket/extensions/pytket-qiskit/api.html

Initializes a new TketBackend from a pytket Backend.

```APIDOC
## TketBackend.__init__

### Description
Create a new `TketBackend` from a `Backend`.

### Method
N/A (Constructor)

### Endpoint
N/A (Constructor)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Noisy Debug Output Example

Source: https://docs.quantinuum.com/tket/user-guide/manual/manual_assertion.html

Example output from a noisy backend execution.

```text
{'|bell>': 0.95, '|Rx(0.3)>': 0.98}
```

--------------------------------

### Initialize AerBackend for Quantum Experiments

Source: https://docs.quantinuum.com/tket/user-guide/_sources/manual/manual_backend.md.txt

Choose a backend, such as AerBackend, for your quantum experiments. This example demonstrates selecting a backend in one place, which is crucial for hardware-agnostic development. Note that some backends, like AerStateBackend, might be incompatible with certain experimental requirements (e.g., mid-circuit measurements).

```python
from pytket import Circuit
from pytket.extensions.qiskit import AerBackend #, AerStateBackend
from pytket.predicates import NoMidMeasurePredicate

backend = AerBackend()      # Choose backend in one place
# backend = AerStateBackend()   # A backend that is incompatible with the experiment
```

--------------------------------

### Install qulacs-gpu

Source: https://docs.quantinuum.com/tket/extensions/pytket-qulacs/_sources/index.rst.txt

Install the GPU-enabled version of Qulacs after setting up the required CUDA toolset.

```bash
pip install qulacs-gpu
```

--------------------------------

### Running quilc and qvm with Docker

Source: https://docs.quantinuum.com/tket/user-guide/_sources/examples/backends/comparing_simulators.ipynb.txt

To use the ForestBackend locally, ensure quilc and qvm are running in server mode. Docker provides an easy way to set this up.

```bash
docker run --rm -it -p 5555:5555 rigetti/quilc -R
```

```bash
docker run --rm -it -p 5000:5000 rigetti/qvm -S
```

--------------------------------

### Install pytket-pyquil via pip

Source: https://docs.quantinuum.com/tket/extensions/pytket-pyquil/_sources/index.rst.txt

Use this command to install the extension in a Python environment.

```bash
pip install pytket-pyquil
```

--------------------------------

### Upgrade pytket installation

Source: https://docs.quantinuum.com/tket/api-docs/_sources/install.md.txt

Command to update the existing pytket installation to the latest version.

```bash
pip install --upgrade pytket
```

--------------------------------

### Build a basic quantum circuit

Source: https://docs.quantinuum.com/tket/api-docs/_sources/getting_started.md.txt

Demonstrates how to create a quantum circuit, add gates, and measure qubits using pytket's native interface.

```python
from pytket import Circuit

c = Circuit(2, 2) # define a circuit with 2 qubits and 2 bits
c.H(0)            # add a Hadamard gate to qubit 0
c.Rz(0.25, 0)     # add an Rz gate of angle 0.25*pi to qubit 0
c.CX(1, 0)         # add a CX gate with control qubit 1 and target qubit 0
c.measure_all()   # measure qubits 0 and 1, recording the results in bits 0 and 1
```

--------------------------------

### Initialize Circuit Example

Source: https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/_modules/pytket/extensions/quantinuum/backends/quantinuum.html

Creates a single-qubit circuit with a PhasedX gate and a global phase.

```python
_xcirc = Circuit(1).add_gate(OpType.PhasedX, [1, 0], [0])
_xcirc.add_phase(0.5)
```

--------------------------------

### Initialize Circuits with Different Resource Counts

Source: https://docs.quantinuum.com/tket/user-guide/_sources/manual/manual_circuit.md.txt

Demonstrates how to instantiate a Circuit with varying numbers of qubits and bits, including an optional name.

```python
from pytket import Circuit

trivial_circ = Circuit()        # no qubits or bits
quantum_circ = Circuit(4)       # 4 qubits and no bits
mixed_circ   = Circuit(4, 2)    # 4 qubits and 2 bits
named_circ   = Circuit(2, 2, "my_circ")
```

--------------------------------

### Install Pytket Extension

Source: https://docs.quantinuum.com/tket/api-docs/_sources/extensions.md.txt

Command to install a specific pytket extension package via pip.

```bash
pip install pytket-quantinuum
```

--------------------------------

### Download and Initialize Circuit Renderer

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/528d200ab47405cf6cd04f1ebe19db9d/contextual_optimisation.ipynb

Includes scripts to download Vue 3 and the pytket-circuit-renderer. Provides a fallback mechanism to load resources from jsdelivr if UNPKG is unavailable. Ensures all necessary components are loaded before proceeding.

```html
<script type="application/javascript" src="https://unpkg.com/vue@3"></script>
<script type="application/javascript" src="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js"></script>
<link rel="stylesheet" href="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css">

<!-- Fallback to jsdelivr in case UNPKG is down -->
<script type="application/javascript">
    if (typeof Vue === "undefined") {
        const loadVue = new Promise(resolve => {
            const vueFallback = document.createElement("script")
            vueFallback.type = "application/javascript"
            vueFallback.src = "https://cdn.jsdelivr.net/npm/vue@3"
            vueFallback.async = false
            vueFallback.defer = false
            vueFallback.addEventListener('load', () => {
              console.log("vue loaded");
              resolve(true)
            })
            document.head.appendChild(vueFallback)
        })
        const loadRenderer = new Promise(resolve => {
            const rendererFallback = document.createElement("script")
            rendererFallback.type = "application/javascript"
            rendererFallback.src = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js"
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>
```

--------------------------------

### Example Result of Asynchronous Job Submission

Source: https://docs.quantinuum.com/tket/user-guide/manual/manual_backend.html

This is an example output from the asynchronous job submission code.

```text
(1.2087999999999999-0.002400000000000002j)

```

--------------------------------

### Example Counts Output

Source: https://docs.quantinuum.com/tket/user-guide/manual/manual_backend.html

This is an example of the counts dictionary returned by a backend after processing a circuit with measurements.

```python
Counter({(1, 0, 1): 145, (0, 0, 1): 133, (1, 1, 1): 133, (1, 1, 0): 126, (0, 1, 0): 122, (1, 0, 0): 119, (0, 1, 1): 115, (0, 0, 0): 107})
```

--------------------------------

### Initialize Circuit Renderer

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/a72d4b407bcc3c831a20f7353744a159/compilation_example.ipynb

Loads necessary scripts (Vue.js and pytket-circuit-renderer) and CSS for rendering quantum circuits in a web environment. Includes fallback mechanisms for loading resources.

```html
<script type="application/javascript" src="https://unpkg.com/vue@3"></script>
<script type="application/javascript" src="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js"></script>
<link rel="stylesheet" href="https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css">
<script type="application/javascript">
    if (typeof Vue === "undefined") {
        const loadVue = new Promise(resolve => {
            const vueFallback = document.createElement("script")
            vueFallback.type = "application/javascript"
            vueFallback.src = "https://cdn.jsdelivr.net/npm/vue@3"
            vueFallback.async = false
            vueFallback.defer = false
            vueFallback.addEventListener('load', () => {
              console.log("vue loaded");
              resolve(true)
            })
            document.head.appendChild(vueFallback)
        })
        const loadRenderer = new Promise(resolve => {
            const rendererFallback = document.createElement("script")
            rendererFallback.type = "application/javascript"
            rendererFallback.src = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js"
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>
```

--------------------------------

### Example Circuit Output

Source: https://docs.quantinuum.com/tket/user-guide/examples/backends/creating_backends.html

This is the expected output from running the example circuit, showing a statevector representation.

```text
[ 5.00000000e-01-5.00000000e-01j -8.32667268e-17-1.11022302e-16j
  0.00000000e+00+0.00000000e+00j  5.00000000e-01-5.00000000e-01j]

```

--------------------------------

### State Tomography Example

Source: https://docs.quantinuum.com/tket/user-guide/_sources/examples/algorithms_and_protocols/pytket-qujax-classification.ipynb.txt

Illustrates how to perform state tomography on a quantum circuit to reconstruct the state vector.

```python
from pytket import Circuit
from pytket.extensions.qiskit import AerBackend
from pytket.state_tomography import StateTomography

# Create a circuit
circ = Circuit(2)
circ.H(0)
circ.CX(0, 1)

# Create a state tomography experiment
experiment = StateTomography(circ)

# Define the backend
backend = AerBackend()

# Run the experiment and get the reconstructed state vector
state_vector = experiment.run(backend)

print(state_vector)

```

--------------------------------

### Initialize IBMQEmulatorBackend

Source: https://docs.quantinuum.com/tket/extensions/pytket-qiskit/_modules/pytket/extensions/qiskit/backends/ibmq_emulator.html

Constructor for the IBMQEmulatorBackend class. Requires a backend name and optional IBM account credentials.

```python
    def __init__(
        self,
        backend_name: str,
        instance: str | None = None,
        service: Optional["QiskitRuntimeService"] = None,
        token: str | None = None,
        use_fractional_gates: bool = False,
    ):
        super().__init__()
        self._ibmq = IBMQBackend(
            backend_name=backend_name,
            instance=instance,
            service=service,
            token=token,
            use_fractional_gates=use_fractional_gates,
        )

        # Get noise model:
        self._noise_model = NoiseModel.from_backend(self._ibmq._backend)  # noqa: SLF001

        # Construct AerBackend based on noise model:
        self._aer = AerBackend(noise_model=self._noise_model)

        # cache of results keyed by job id and circuit index
        self._ibm_res_cache: dict[tuple[str, int], Counter] = dict()  # noqa: C408
```

--------------------------------

### Initialize Pytket Circuit Renderer

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/2f5abb5bb77911a138c908735cd89da1/symbolics_example.ipynb

This script handles the asynchronous loading of Vue, the renderer library, and the required CSS before mounting the circuit display component.

```html
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>
</head>
<body>


    <div id="circuit-display-vue-container-b75bb54e-54ee-4746-9d55-5b9416064b78" class="pytket-circuit-display-container">
        <div style="display: none">
            <div id="circuit-json-to-display">{"bits": [], "commands": [{"args": [["q", [0]], ["q", [1]]], "op": {"type": "CX"}}, {"args": [["q", [1]], ["q", [3]]], "op": {"type": "CX"}}, {"args": [["q", [3]], ["q", [2]]], "op": {"type": "CX"}}, {"args": [["q", [2]]], "op": {"params": ["0.0", "0.0", "0.5 + a + b"], "type": "TK1"}}, {"args": [["q", [3]], ["q", [2]]], "op": {"type": "CX"}}, {"args": [["q", [1]], ["q", [3]]], "op": {"type": "CX"}}, {"args": [["q", [0]], ["q", [1]]], "op": {"type": "CX"}}], "created_qubits": [], "discarded_qubits": [], "implicit_permutation": [[["q", [0]], ["q", [0]]], [["q", [1]], ["q", [1]]], [["q", [2]], ["q", [2]]], [["q", [3]], ["q", [3]]]], "phase": "0.0", "qubits": [["q", [0]], ["q", [1]], ["q", [2]], ["q", [3]]]}</div>
        </div>
        <circuit-display-container
                :circuit-element-str="'#circuit-json-to-display'"
                :init-render-options="initRenderOptions"
                view-format="None"
        ></circuit-display-container>
    </div>
    <script type="application/javascript">
      (async function () {
        await window['_circuitRendererLoading']

        const circuitRendererUid = "b75bb54e-54ee-4746-9d55-5b9416064b78";
        const displayOptions = JSON.parse('{}');

        // Script to initialise the circuit renderer app

const { createApp } = Vue;
const circuitDisplayContainer = window["pytket-circuit-renderer"].default;
// Init variables to be shared between circuit display instances
if (typeof window.pytketCircuitDisplays === "undefined") {
    window.pytketCircuitDisplays = {};
}
// Create the root Vue component
const app = createApp({
    delimiters: ['[[#', '#]]'],
    components: { circuitDisplayContainer },
    data () {
      return {
        initRenderOptions: displayOptions,
      }
    }
})
app.config.unwrapInjectedRef = true;
app.mount("#circuit-display-vue-container-"+circuitRendererUid);
window.pytketCircuitDisplays[circuitRendererUid] = app;
      })()
    </script>



</body>
</html>
```

--------------------------------

### Initialize Pytket Circuit Renderer

Source: https://docs.quantinuum.com/tket/user-guide/_downloads/f32d5da976ec5cfd7b1586757fa22371/circuit_generation_example.ipynb

This script handles the asynchronous loading of Vue, the renderer library, and CSS, and mounts the circuit display component to the DOM.

```html
            rendererFallback.type = "application/javascript"
            rendererFallback.src = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js"
            rendererFallback.async = false
            rendererFallback.defer = false
            rendererFallback.addEventListener('load', () => {
              console.log("renderer loaded");
              resolve(true)
            })
            document.head.appendChild(rendererFallback)
        })
        const loadCSS = new Promise(resolve => {
            const cssFallback = document.createElement("link")
            cssFallback.rel = "stylesheet"
            cssFallback.href = "https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css"
            cssFallback.addEventListener('load', () => {
              console.log("css loaded");
              resolve(true)
            })
            document.head.appendChild(cssFallback)
        })
        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])
    } else {
        window['_circuitRendererLoading'] = new Promise(resolve => resolve("already loaded"))
    }
</script>
</head>
<body>


    <div id="circuit-display-vue-container-e978c1d0-b8eb-4c11-bffe-d696e2f52d07" class="pytket-circuit-display-container">
        <div style="display: none">
            <div id="circuit-json-to-display">{"bits": [["c", [0]], ["c", [1]]], "commands": [{"args": [["alpha", [0]]], "op": {"type": "H"}}, {"args": [["q", [0]], ["beta", [2, 1]]], "op": {"type": "CX"}}, {"args": [["delta", [0]], ["delta", [1]]], "op": {"type": "CX"}}, {"args": [["beta", [2, 1]]], "op": {"params": ["0.5"], "type": "Rz"}}], "created_qubits": [], "discarded_qubits": [], "implicit_permutation": [[["alpha", [0]], ["alpha", [0]]], [["beta", [2, 1]], ["beta", [2, 1]]], [["delta", [0]], ["delta", [0]]], [["delta", [1]], ["delta", [1]]], [["q", [0]], ["q", [0]]]], "phase": "0.0", "qubits": [["alpha", [0]], ["beta", [2, 1]], ["delta", [0]], ["delta", [1]], ["q", [0]]]}</div>
        </div>
        <circuit-display-container
                :circuit-element-str="'#circuit-json-to-display'"
                :init-render-options="initRenderOptions"
                view-format="None"
        ></circuit-display-container>
    </div>
    <script type="application/javascript">
      (async function () {
        await window['_circuitRendererLoading']

        const circuitRendererUid = "e978c1d0-b8eb-4c11-bffe-d696e2f52d07";
        const displayOptions = JSON.parse('{}');

        // Script to initialise the circuit renderer app

const { createApp } = Vue;
const circuitDisplayContainer = window["pytket-circuit-renderer"].default;
// Init variables to be shared between circuit display instances
if (typeof window.pytketCircuitDisplays === "undefined") {
    window.pytketCircuitDisplays = {};
}
// Create the root Vue component
const app = createApp({
    delimiters: ['[[#', '#]]'],
    components: { circuitDisplayContainer },
    data () {
      return {
        initRenderOptions: displayOptions,
      }
    }
})
app.config.unwrapInjectedRef = true;
app.mount("#circuit-display-vue-container-"+circuitRendererUid);
window.pytketCircuitDisplays[circuitRendererUid] = app;
      })()
    </script>



</body>
</html>
```

--------------------------------

### Install pytket-qir

Source: https://docs.quantinuum.com/tket/extensions/pytket-qir

Install the pytket-qir package using pip. This command is used to add the library to your Python environment.

```bash
pip install pytket-qir

```

--------------------------------

### Create QuantinuumBackend from BackendInfo

Source: https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/_modules/pytket/extensions/quantinuum/backends/quantinuum.html

Creates a QuantinuumBackend instance from BackendInfo, compilation configuration, and backend data. Raises a ValueError if the provided BackendInfo lacks a device_name.

```python
@staticmethod
    def pass_from_info(
        backend_info: BackendInfo,
        compilation_config: QuantinuumBackendCompilationConfig | None = None,
        data: QuantinuumBackendData | None = None,
        optimisation_level: int = 2,
        timeout: int = 300,
    ) -> BasePass:
        if backend_info.device_name is None:
            raise ValueError("The provided BackendInfo has no device_name.")

        backend = QuantinuumBackend(
            device_name=backend_info.device_name,
            compilation_config=compilation_config,
            data=data,
        )
        backend._backend_info = backend_info
        return backend.default_compilation_pass(optimisation_level, timeout)
```

--------------------------------

### Install pytket-pyzx

Source: https://docs.quantinuum.com/tket/extensions/pytket-pyzx/index.html

Use pip to install the pytket-pyzx package for supported Python versions on Linux, MacOS, or Windows.

```bash
pip install pytket-pyzx
```

--------------------------------

### Install pytket-pysimplex

Source: https://docs.quantinuum.com/tket/extensions/pytket-pysimplex

Install the pytket-pysimplex package using pip. This command is used to add the library to your Python environment.

```bash
pip install pytket-pysimplex

```

--------------------------------

### Initialize TketBackend

Source: https://docs.quantinuum.com/tket/extensions/pytket-qiskit/_modules/pytket/extensions/qiskit/tket_backend.html

Constructor for wrapping a pytket backend into a Qiskit-compatible BackendV2 instance.

```python
    def __init__(self, backend: Backend, comp_pass: BasePass | None = None):
        """Create a new :py:class:`TketBackend` from a :py:class:`~pytket.backends.backend.Backend`.

        :param backend: The device or simulator to wrap up
        :param comp_pass: The (optional) tket compilation pass to apply to each circuit
         before submitting to the :py:class:`~pytket.backends.backend.Backend`, defaults to None
        """
        arch = backend.backend_info.architecture if backend.backend_info else None
        coupling: list[list[Any]] | None
        if isinstance(arch, FullyConnected):
            coupling = [
                [n1.index[0], n2.index[0]]
                for n1 in arch.nodes
                for n2 in arch.nodes
                if n1 != n2
            ]
        else:
            coupling = (
                [[n.index[0], m.index[0]] for n, m in arch.coupling] if arch else None
            )

        super().__init__(
            name=("statevector_" if backend.supports_state else "")
            + "pytket/"
            + str(type(backend)),
            backend_version="0.0.1",
        )
        self._backend = backend
        self._comp_pass = comp_pass
        self._target = Target.from_configuration(
            basis_gates=_extract_basis_gates(backend),
            num_qubits=len(arch.nodes) if arch and arch.nodes else 40,
            coupling_map=CouplingMap(coupling),
        )
```

--------------------------------

### Basic Circuit Construction

Source: https://docs.quantinuum.com/tket/user-guide/_sources/examples/algorithms_and_protocols/pytket-qujax-classification.ipynb.txt

Demonstrates the fundamental steps to create a quantum circuit using tket, including adding gates and qubits.

```python
from pytket import Circuit

# Create a circuit with 2 qubits and 3 classical bits
circ = Circuit(2, 3)

# Add a Hadamard gate to qubit 0
circ.H(0)

# Add a CNOT gate between qubit 0 and qubit 1
circ.CX(0, 1)

# Add a measurement from qubit 0 to classical bit 0
circ.Measure(0, 0)

# Add a measurement from qubit 1 to classical bit 1
circ.Measure(1, 1)

print(circ.to_qasm().strip())

```

--------------------------------

### Install pytket-pennylane

Source: https://docs.quantinuum.com/tket/extensions/pytket-pennylane

Install the pytket-pennylane library using pip. This package is compatible with Python 3.10, 3.11, and 3.12.

```bash
pip install pytket-pennylane

```

--------------------------------

### Install pytket-cutensornet on Ubuntu

Source: https://docs.quantinuum.com/tket/extensions/pytket-cutensornet/_sources/index.rst.txt

Commands to install the necessary CUDA toolkit and Python packages on an Ubuntu 24.04 system.

```bash
sudo apt install cuda-toolkit
pip install cuquantum-python
pip install pytket-cutensornet
```