© 2022 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Compiling for Quantinuum Hardware without Querying Quantinuum API"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains an example of how to investigate circuits compiled for Quantinuum hardware without logging in or submitting to Quantinuum hardware. This may be useful if it is desired to explore circuit compilation in depth before submitting."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Circuit Preparation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Create your circuit."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, OpType\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(2, name=\"Bell Test\")\n", "circuit.H(0)\n", "circuit.CX(0, 1)\n", "circuit.measure_all()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Set up Backend"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up a `QuantinuumBackend` object. The difference is the `machine_debug` option uses the default `pytket-quantinuum` options such as pytket's version of the Quantinuum native gate set rather than querying the Quantinuum API for this information."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "backend = QuantinuumBackend(device_name=machine, machine_debug=True)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Investigate Native Gate Set"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Users can view the hard-coded native gate set for the Quantinuum backend using the following command."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import pytket.extensions.quantinuum.backends.quantinuum as qtm"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(qtm._GATE_SET)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It's possible that the hardcoded verion is not up to date with the latest native gate set as described in the [System Model H1 Product Data Sheet](https://www.quantinuum.com/hardware/h1). In this case, the Rzz gate, which is the `ZZPhase` gate in pytket, is missing. This can be added by running the following command."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qtm._GATE_SET.add(OpType.ZZPhase)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Circuits can now be compiled with the `get_compiled_circuit` function without querying the Quantinuum API."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=2)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2022 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
From 2e35caa43cf6634972716a0498ab48916c3a3275 Mon Sep 17 00:00:00 2001
From: Yao Tang \n", "# Arbitrary Angle ZZ Gates via pytket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains a comparison of circuits with and without use of Quantinuum's native arbitrary-angle ZZ gate in `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [Arbitrary Angle ZZ Gates](#arb-zz)
\n", "* [Quantum Fourier Transform](#qft)
\n", "* [QFT with Fixed Angle Gates](#qft-fixed)
\n", "* [QFT with Arbitrary Angle ZZ Gates](#qft-arb-zz)
\n", "* [Compare Results](#compare)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Arbitrary Angle ZZ Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Quantinuum System Model H1's native gate set includes arbitrary angle ZZ gates. This is beneficial for reducing the 2-qubit gate count for many quantum algorithms and gate sequences."]}, {"cell_type": "markdown", "metadata": {}, "source": ["$RZZ(\\theta) = e^{-i\\frac{\\theta}{2}\\hat{Z} \\otimes \\hat{Z}}= e^{-i \\frac{\\theta}{2}} \\begin{bmatrix} 1 & 0 & 0 & 0\\\\ 0 & e^{-i\\theta} & 0 & 0\\\\ 0 & 0 & e^{-i\\theta} & 0\\\\ 0 & 0 & 0 & 1 \\end{bmatrix}$
\n", "
"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that $RZZ(\\frac{\\pi}{2}) = ZZ()$."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Quantum circuits that use the gate sequence CNOT, RZ, CNOT can be replaced with the arbitrary angle ZZ gate, shown below. This enables a lower number of 2-qubit gates in a quantum circuit, improving performance by decreasing gate errors."]}, {"cell_type": "markdown", "metadata": {}, "source": ["
"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
\n", "
![](\"python/rzz.png\")
\n", "
\n", "- `n`: number of qubits to use in the QFT circuit
\n", "- `arbZZ`: specify whether to use the arbitrary-angle ZZ gate or not, `True`/`False`, default: `False`
\n", "- `approx`: if set to integer `k`, then controlled rotations by angles less than $\\frac{\\pi}{2}^{k}$ do not occur"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note:** In many presentations of the QFT, the circuit includes a round of SWAP gates at the end of the circuit that reverses the order of the qubits. The QFT circuits in this tutorial do not include this final SWAP step."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note:** In `pytket` the $RZZ$ gate is implemented with the $ZZPhase$ circuit function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "from pytket import Circuit\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def control_phase(circ, theta, q0, q1, arbZZ=False):\n", " \"\"\"circuit gadget for performing controlled-[1 0;0 e^i theta]\n", " Inputs:\n", " circ: pytket Circuit object\n", " theta: Z rotation angle (in units of pi)\n", " q0: control qubit\n", " q1: target qubit\n", " arbZZ (bool): enables arbitrary angle RZZ gate\n", " \"\"\"\n", " if arbZZ == False:\n", " # decompose into CNOTs\n", " circ.Rz(theta / 2, q1)\n", " circ.CX(q0, q1)\n", " circ.Rz(-theta / 2, q1)\n", " circ.CX(q0, q1)\n", " circ.Rz(theta / 2, q0)\n", " elif arbZZ == True:\n", " circ.Rz(theta / 2, q0)\n", " circ.Rz(theta / 2, q1)\n", " if theta > 0:\n", " circ.X(q0)\n", " circ.ZZPhase(theta / 2, q0, q1)\n", " circ.X(q0)\n", " elif theta <= 0:\n", " circ.ZZPhase(-theta / 2, q0, q1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def QFT(n, **kwargs):\n", " \"\"\"\n", " Function to implement the Quantum Fourier Transform\n", " n : number of qubits\n", " approx: if set to integer k, then sets that largest\n", " value of pi/2**k occuring in controlled rotation\n", " returns circ: pytket Circuit object\n", " \"\"\"\n\n", " # optional keyword arguments\n", " arbZZ = kwargs.get(\"arbZZ\", False)\n", " approx = kwargs.get(\"approx\", None)\n\n", " # initialize\n", " circ_name = \"QFT-arbZZ\" if arbZZ else \"QFT-fixed\"\n", " circ = Circuit(n, n, name=circ_name)\n", " for j in range(n - 1):\n", " q = n - 1 - j\n", " circ.H(q)\n", " for i in range(j + 1):\n", " if approx == None or approx >= j + 1 - i:\n", " control_phase(\n", " circ, 1 / (2 ** (j + 1 - i)), q - 1, n - 1 - i, arbZZ=arbZZ\n", " )\n", " circ.H(0)\n", " return circ"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## QFT with Fixed Angle Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["First, create the circuit with fixed-angle gates."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: `pytket` renders circuits in ZX-calculus notation. This can be toggled on and off by pressing the top left button."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_qubits = 12"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fixed = QFT(n_qubits, arbZZ=False)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(qft_fixed)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## QFT with Arbitrary Angle ZZ Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Second, create the circuit with arbitrary-angle ZZ gates."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_arbZZ = QFT(n_qubits, arbZZ=True)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(qft_arbZZ)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Compare Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we compare the results of the QFT circuits with and without use of the arbitrary-angle ZZ gates on hardware."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### State Fidelity"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The QFT circuit applied to the computational basis state $|x\\rangle$ creates the state"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\\begin{align}
\n", "QFT|x\\rangle&=\\frac{1}{\\sqrt{d}}\\sum_{y=0}^{d-1} e^{2\\pi i x y/d} |y\\rangle\\\\
\n", "&= \\bigotimes_{j=0}^{n-1}\\frac{1}{\\sqrt{2}}\\sum_{y_j=0}^1e^{2\\pi i x y_j/d}|y_j\\rangle\\\\
\n", "&= \\bigotimes_{j=0}^{n-1}\\frac{1}{\\sqrt{2}}\\big(|0\\rangle+e^{2\\pi i x/d}|1\\rangle\\big)
\n", "\\end{align}"]}, {"cell_type": "markdown", "metadata": {}, "source": ["where $d=2^n$. Note that this state is unentangled. Therefore the state fidelity can be measured by applying only single-qubit gates to map the state back to the computational basis. In the example circuits above, the initial state $|x\\rangle=|0\\rangle$, and so the output state is"]}, {"cell_type": "markdown", "metadata": {}, "source": ["$$\\bigotimes_{j=0}^{n-1}\\frac{1}{\\sqrt{2}}\\big(|0\\rangle + |1\\rangle\\big) = |+\\rangle^{\\otimes n}$$"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The state fidelity can then be measured by applying a Hadamard gate to each qubit and recording the probability of measuring $|0\\rangle$."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We define a function to measure all qubits in the Hadamard basis and append this circuit to the QFT circuits:"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def meas_Had_basis(orig_circ, n_qubits):\n", " circ = orig_circ.copy()\n", " for j in range(n_qubits):\n", " circ.H(j)\n", " circ.add_barrier(range(n_qubits))\n", " circ.measure_all()\n", " return circ"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed = meas_Had_basis(qft_fixed, n_qubits)\n", "render_circuit_jupyter(qft_fid_fixed)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ = meas_Had_basis(qft_arbZZ, n_qubits)\n", "render_circuit_jupyter(qft_fid_arbZZ)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Select Device"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Login to the Quantinuum API using your credentials and check the device status."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-2E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Compile the circuits to the Quantinuum backend."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled = backend.get_compiled_circuit(\n", " qft_fid_fixed, optimisation_level=1\n", ")\n", "render_circuit_jupyter(qft_fid_fixed_compiled)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ_compiled = backend.get_compiled_circuit(\n", " qft_fid_arbZZ, optimisation_level=1\n", ")\n", "render_circuit_jupyter(qft_fid_arbZZ_compiled)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Depth"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that the circuit depth for the fixed-angle vs. arbitrary angle is less. The difference increases as more qubits are used."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(\"Circuit Depth for fixed-angle QFT:\", qft_fixed.depth())\n", "print(\"Circuit Depth for arbitrary-angle QFT:\", qft_arbZZ.depth())\n", "print(\"Difference:\", qft_fixed.depth() - qft_arbZZ.depth())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Check Circuit Cost"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Check the cost in HQC's for each circuit. See that the Arbitrary angle ZZ QFT uses fewer HQCs, which is a plus."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that in this case because an emulator is used, the specific syntax checker the emulator uses is specified. This is an optional parameter not needed if you are using a quantum computer target."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 1000\n", "print(\n", " \"Fixed angle QFT:\",\n", " backend.cost(qft_fid_fixed_compiled, n_shots=n_shots, syntax_checker=\"H1-2SC\"),\n", ")\n", "print(\n", " \"Arbitrary angle ZZ QFT:\",\n", " backend.cost(qft_fid_arbZZ_compiled, n_shots=n_shots, syntax_checker=\"H1-2SC\"),\n", ")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Run the Circuit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now run the circuits on Quantinuum systems. First compiling the circuits to the backend, then submitting to the device."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_handle = backend.process_circuit(\n", " qft_fid_fixed_compiled, n_shots=n_shots\n", ")\n", "qft_fid_arbZZ_compiled_handle = backend.process_circuit(\n", " qft_fid_arbZZ_compiled, n_shots=n_shots\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_status = backend.circuit_status(qft_fid_fixed_compiled_handle)\n", "print(qft_fid_fixed_compiled_status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ_compiled_status = backend.circuit_status(qft_fid_arbZZ_compiled_handle)\n", "print(qft_fid_arbZZ_compiled_status)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Retrieve Results"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_result = backend.get_result(qft_fid_fixed_compiled_handle)\n", "qft_fid_arbZZ_compiled_result = backend.get_result(qft_fid_arbZZ_compiled_handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Analyze Results"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Here the distribution of bitstrings is retrieved to inspect."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_distro = qft_fid_fixed_compiled_result.get_distribution()\n", "qft_fid_arbZZ_compiled_distro = qft_fid_arbZZ_compiled_result.get_distribution()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["For the QFT with the appended measurement in the Hadamard basis, we expect the QFT to return all 0's in the result bitstring. Investigating the results for both the fixed and arbitrary ZZ versions of QFT, we see this is the bitstring with the highest frequency. This is good, this is what is desired."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_distro"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ_compiled_distro"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Comparing the results between the fixed and arbitrary ZZ versions we see that the fidelity is higher using the arbitrary ZZ gate."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(\n", " \"Fixed angle QFT:\",\n", " qft_fid_fixed_compiled_distro[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)],\n", ")\n", "print(\n", " \"Arbitrary Angle ZZ QFT:\",\n", " qft_fid_arbZZ_compiled_distro[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)],\n", ")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2022 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Arbitrary Angle ZZ Gates via pytket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains a comparison of circuits with and without use of Quantinuum's native arbitrary-angle ZZ gate in `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [Arbitrary Angle ZZ Gates](#arb-zz)
\n", "* [Quantum Fourier Transform](#qft)
\n", "* [QFT with Fixed Angle Gates](#qft-fixed)
\n", "* [QFT with Arbitrary Angle ZZ Gates](#qft-arb-zz)
\n", "* [Compare Results](#compare)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Arbitrary Angle ZZ Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Quantinuum System Model H1's native gate set includes arbitrary angle ZZ gates. This is beneficial for reducing the 2-qubit gate count for many quantum algorithms and gate sequences."]}, {"cell_type": "markdown", "metadata": {}, "source": ["$RZZ(\\theta) = e^{-i\\frac{\\theta}{2}\\hat{Z} \\otimes \\hat{Z}}= e^{-i \\frac{\\theta}{2}} \\begin{bmatrix} 1 & 0 & 0 & 0\\\\ 0 & e^{-i\\theta} & 0 & 0\\\\ 0 & 0 & e^{-i\\theta} & 0\\\\ 0 & 0 & 0 & 1 \\end{bmatrix}$
\n", "
"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that $RZZ(\\frac{\\pi}{2}) = ZZ()$."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Quantum circuits that use the gate sequence CNOT, RZ, CNOT can be replaced with the arbitrary angle ZZ gate, shown below. This enables a lower number of 2-qubit gates in a quantum circuit, improving performance by decreasing gate errors."]}, {"cell_type": "markdown", "metadata": {}, "source": ["
"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
\n", "
\n", "
\n", "- `n`: number of qubits to use in the QFT circuit
\n", "- `arbZZ`: specify whether to use the arbitrary-angle ZZ gate or not, `True`/`False`, default: `False`
\n", "- `approx`: if set to integer `k`, then controlled rotations by angles less than $\\frac{\\pi}{2}^{k}$ do not occur"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note:** In many presentations of the QFT, the circuit includes a round of SWAP gates at the end of the circuit that reverses the order of the qubits. The QFT circuits in this tutorial do not include this final SWAP step."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note:** In `pytket` the $RZZ$ gate is implemented with the $ZZPhase$ circuit function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "from pytket import Circuit\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def control_phase(circ, theta, q0, q1, arbZZ=False):\n", " \"\"\"circuit gadget for performing controlled-[1 0;0 e^i theta]\n", " Inputs:\n", " circ: pytket Circuit object\n", " theta: Z rotation angle (in units of pi)\n", " q0: control qubit\n", " q1: target qubit\n", " arbZZ (bool): enables arbitrary angle RZZ gate\n", " \"\"\"\n", " if arbZZ == False:\n", " # decompose into CNOTs\n", " circ.Rz(theta / 2, q1)\n", " circ.CX(q0, q1)\n", " circ.Rz(-theta / 2, q1)\n", " circ.CX(q0, q1)\n", " circ.Rz(theta / 2, q0)\n", " elif arbZZ == True:\n", " circ.Rz(theta / 2, q0)\n", " circ.Rz(theta / 2, q1)\n", " if theta > 0:\n", " circ.X(q0)\n", " circ.ZZPhase(theta / 2, q0, q1)\n", " circ.X(q0)\n", " elif theta <= 0:\n", " circ.ZZPhase(-theta / 2, q0, q1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def QFT(n, **kwargs):\n", " \"\"\"\n", " Function to implement the Quantum Fourier Transform\n", " n : number of qubits\n", " approx: if set to integer k, then sets that largest\n", " value of pi/2**k occuring in controlled rotation\n", " returns circ: pytket Circuit object\n", " \"\"\"\n\n", " # optional keyword arguments\n", " arbZZ = kwargs.get(\"arbZZ\", False)\n", " approx = kwargs.get(\"approx\", None)\n\n", " # initialize\n", " circ_name = \"QFT-arbZZ\" if arbZZ else \"QFT-fixed\"\n", " circ = Circuit(n, n, name=circ_name)\n", " for j in range(n - 1):\n", " q = n - 1 - j\n", " circ.H(q)\n", " for i in range(j + 1):\n", " if approx == None or approx >= j + 1 - i:\n", " control_phase(\n", " circ, 1 / (2 ** (j + 1 - i)), q - 1, n - 1 - i, arbZZ=arbZZ\n", " )\n", " circ.H(0)\n", " return circ"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## QFT with Fixed Angle Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["First, create the circuit with fixed-angle gates."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: `pytket` renders circuits in ZX-calculus notation. This can be toggled on and off by pressing the top left button."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_qubits = 12"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fixed = QFT(n_qubits, arbZZ=False)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(qft_fixed)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## QFT with Arbitrary Angle ZZ Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Second, create the circuit with arbitrary-angle ZZ gates."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_arbZZ = QFT(n_qubits, arbZZ=True)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(qft_arbZZ)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Compare Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we compare the results of the QFT circuits with and without use of the arbitrary-angle ZZ gates on hardware."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### State Fidelity"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The QFT circuit applied to the computational basis state $|x\\rangle$ creates the state"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\\begin{align}
\n", "QFT|x\\rangle&=\\frac{1}{\\sqrt{d}}\\sum_{y=0}^{d-1} e^{2\\pi i x y/d} |y\\rangle\\\\
\n", "&= \\bigotimes_{j=0}^{n-1}\\frac{1}{\\sqrt{2}}\\sum_{y_j=0}^1e^{2\\pi i x y_j/d}|y_j\\rangle\\\\
\n", "&= \\bigotimes_{j=0}^{n-1}\\frac{1}{\\sqrt{2}}\\big(|0\\rangle+e^{2\\pi i x/d}|1\\rangle\\big)
\n", "\\end{align}"]}, {"cell_type": "markdown", "metadata": {}, "source": ["where $d=2^n$. Note that this state is unentangled. Therefore the state fidelity can be measured by applying only single-qubit gates to map the state back to the computational basis. In the example circuits above, the initial state $|x\\rangle=|0\\rangle$, and so the output state is"]}, {"cell_type": "markdown", "metadata": {}, "source": ["$$\\bigotimes_{j=0}^{n-1}\\frac{1}{\\sqrt{2}}\\big(|0\\rangle + |1\\rangle\\big) = |+\\rangle^{\\otimes n}$$"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The state fidelity can then be measured by applying a Hadamard gate to each qubit and recording the probability of measuring $|0\\rangle$."]}, {"cell_type": "markdown", "metadata": {}, "source": ["We define a function to measure all qubits in the Hadamard basis and append this circuit to the QFT circuits:"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def meas_Had_basis(orig_circ, n_qubits):\n", " circ = orig_circ.copy()\n", " for j in range(n_qubits):\n", " circ.H(j)\n", " circ.add_barrier(range(n_qubits))\n", " circ.measure_all()\n", " return circ"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed = meas_Had_basis(qft_fixed, n_qubits)\n", "render_circuit_jupyter(qft_fid_fixed)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ = meas_Had_basis(qft_arbZZ, n_qubits)\n", "render_circuit_jupyter(qft_fid_arbZZ)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Select Device"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Login to the Quantinuum API using your credentials and check the device status."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-2E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Compile the circuits to the Quantinuum backend."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled = backend.get_compiled_circuit(\n", " qft_fid_fixed, optimisation_level=1\n", ")\n", "render_circuit_jupyter(qft_fid_fixed_compiled)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ_compiled = backend.get_compiled_circuit(\n", " qft_fid_arbZZ, optimisation_level=1\n", ")\n", "render_circuit_jupyter(qft_fid_arbZZ_compiled)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Depth"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that the circuit depth for the fixed-angle vs. arbitrary angle is less. The difference increases as more qubits are used."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(\"Circuit Depth for fixed-angle QFT:\", qft_fixed.depth())\n", "print(\"Circuit Depth for arbitrary-angle QFT:\", qft_arbZZ.depth())\n", "print(\"Difference:\", qft_fixed.depth() - qft_arbZZ.depth())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Check Circuit Cost"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Check the cost in HQC's for each circuit. See that the Arbitrary angle ZZ QFT uses fewer HQCs, which is a plus."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that in this case because an emulator is used, the specific syntax checker the emulator uses is specified. This is an optional parameter not needed if you are using a quantum computer target."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 1000\n", "print(\n", " \"Fixed angle QFT:\",\n", " backend.cost(qft_fid_fixed_compiled, n_shots=n_shots, syntax_checker=\"H1-2SC\"),\n", ")\n", "print(\n", " \"Arbitrary angle ZZ QFT:\",\n", " backend.cost(qft_fid_arbZZ_compiled, n_shots=n_shots, syntax_checker=\"H1-2SC\"),\n", ")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Run the Circuit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now run the circuits on Quantinuum systems. First compiling the circuits to the backend, then submitting to the device."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_handle = backend.process_circuit(\n", " qft_fid_fixed_compiled, n_shots=n_shots\n", ")\n", "qft_fid_arbZZ_compiled_handle = backend.process_circuit(\n", " qft_fid_arbZZ_compiled, n_shots=n_shots\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_status = backend.circuit_status(qft_fid_fixed_compiled_handle)\n", "print(qft_fid_fixed_compiled_status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ_compiled_status = backend.circuit_status(qft_fid_arbZZ_compiled_handle)\n", "print(qft_fid_arbZZ_compiled_status)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Retrieve Results"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_result = backend.get_result(qft_fid_fixed_compiled_handle)\n", "qft_fid_arbZZ_compiled_result = backend.get_result(qft_fid_arbZZ_compiled_handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Analyze Results"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Here the distribution of bitstrings is retrieved to inspect."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_distro = qft_fid_fixed_compiled_result.get_distribution()\n", "qft_fid_arbZZ_compiled_distro = qft_fid_arbZZ_compiled_result.get_distribution()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["For the QFT with the appended measurement in the Hadamard basis, we expect the QFT to return all 0's in the result bitstring. Investigating the results for both the fixed and arbitrary ZZ versions of QFT, we see this is the bitstring with the highest frequency. This is good, this is what is desired."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_fixed_compiled_distro"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["qft_fid_arbZZ_compiled_distro"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Comparing the results between the fixed and arbitrary ZZ versions we see that the fidelity is higher using the arbitrary ZZ gate."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(\n", " \"Fixed angle QFT:\",\n", " qft_fid_fixed_compiled_distro[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)],\n", ")\n", "print(\n", " \"Arbitrary Angle ZZ QFT:\",\n", " qft_fid_arbZZ_compiled_distro[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)],\n", ")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2023 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/examples/Quantinuum_circuit_submissions.ipynb b/examples/Quantinuum_circuit_submissions.ipynb
index 9bc224db..50d1e9b7 100644
--- a/examples/Quantinuum_circuit_submissions.ipynb
+++ b/examples/Quantinuum_circuit_submissions.ipynb
@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Quantinuum Circuit Submissions via pytket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains basic circuit submission examples to Quantinuum quantum hardware via `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [What is TKET?](#tket)
\n", "* [Step by Step](#step-by-step)
\n", " * [Circuit Preparation](#circuit-preparation)
\n", " * [Select Device](#select-device)
\n", " * [Circuit Compilation](#circuit-compilation)
\n", " * [Circuit Cost](#circuit-cost)
\n", " * [Run the Circuit](#run-circuit)
\n", " * [Retrieve Results](#retrieve-results)
\n", " * [Save Results](#save-results)
\n", " * [Analyze Results](#analyze-results)
\n", " * [Cancel Jobs](#cancel-jobs)
\n", "* [Additional Features](#additional-features)
\n", " * [Extended Circuit Compilation](#circuit-compilation-extended)
\n", " * [Batch Submission](#batch-submission)
\n", " * [Parametrized Circuits](#parametrized-circuits)
\n", " * [Conditional Gates](#conditional-gates)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## What is TKET? "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The TKET framework (pronounced \"ticket\") is a software platform for the development and execution of gate-level quantum computation, providing state-of-the-art performance in circuit compilation. It was created and is maintained by Quantinuum. The toolset is designed to extract the most out of the available NISQ devices of today and is platform-agnostic."]}, {"cell_type": "markdown", "metadata": {}, "source": ["In python, the `pytket` packages is available for python 3.9+. The `pytket` and `pytket-quantinuum` packages are included as part of the installation instructions on the user portal."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For more information on TKET, see the following links:
\n", "- [TKET manual](https://cqcl.github.io/pytket/manual/manual_intro.html)
\n", "- [TKET overview and demo video](https://www.youtube.com/watch?v=yXKSpvgAtrk)
\n", "- [Introduction to Quantum Compilation with TKET](https://github.com/CalMacCQ/tket_blog/blob/main/blog1_intro_to_qc.ipynb)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook covers how to use `pytket` in conjunction with `pytket-quantinuum` to submit to Quantinuum devices. The quantum compilation step is demonstrated, but for a full overview of quantum compilation with TKET, the last link above is recommended."]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the links below for the `pytket` and `pytket-quantinuum` documentation:
\n", "- [pytket](https://cqcl.github.io/tket/pytket/api/index.html)
\n", "- [pytket-quantinuum](https://cqcl.github.io/pytket-quantinuum/api/index.html)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Step by Step "]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Preparation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Create your circuit via the pytket python library. For details on getting started with `pytket`, see pytket's [Getting Started](https://cqcl.github.io/tket/pytket/api/getting_started.html) page."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: `pytket` renders circuits in ZX-calculus notation. This can be toggled on and off by pressing the top left button in the circuit display."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, fresh_symbol\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up Bell Test"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(2, name=\"Bell Test\")\n", "circuit.H(0)\n", "circuit.CX(0, 1)\n", "circuit.measure_all()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Select Device "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Select a machine and login to the Quantinuum API using your credentials. See the *Quantinuum Systems User Guide* in the *Examples* tab on the *Quantinuum User Portal* for information and target names for each of the H-Series systems available."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Users need to login once per session. In the notebook, a dialogue box will ask for credentials. If running a script, users be prompted at the shell. You can also [save your email in the pytket config](https://cqcl.github.io/pytket-extensions/api/quantinuum/api.html#pytket.extensions.quantinuum.backends.config.set_quantinuum_config)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The device status can be checked using `device_state`."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", QuantinuumBackend.device_state(device_name=machine))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Available devices can be viewed using the `available_devices` function. Additional information is returned, here just the device names are pulled in."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["[x.device_name for x in QuantinuumBackend.available_devices()]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Circuits submitted to Quantinuum H-Series quantum computers and emulators are automatically run through TKET compilation passes for H-Series hardware. This enables circuits to be automatically optimized for H-Series systems and run more efficiently."]}, {"cell_type": "markdown", "metadata": {}, "source": ["More information on the specific compilation passes applied can be found on the `pytket-quantinuum` documentation, specifically the [Default Compilation](https://cqcl.github.io/pytket-quantinuum/api/index.html#default-compilation) section. In the H-Series software stack, the optimization level applied is set with the `tket-opt-level` parameter. **The default compilation setting for circuits submited to H-Series sytems is optimization level 2.** More information is found in the *Quantinuum Application Programming Interface (API) Specification*."]}, {"cell_type": "markdown", "metadata": {}, "source": ["When using `pytket` before submitting to hardware, the `get_compiled_circuit` function performs the same compilation passes run after submission to Quantinuum systems. The advantage of using the function before submitting to H-Series hardware is to see exactly what circuit optimizations will be performed when submitted to hardware and determine if a different optimization level is desired. The `optimisation_level` parameter in the `get_compiled_circuit` function corresponds directly to the the level of optimisation after submitting to the H-Series systems and to the `tket-opt-level` parameter in the H-Series API. The default compilation for the `get_compiled_circuit` function is optimization level 2, the same as when submitting to the H-Series directly."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Since the TKET compilation passes have been integrated into the H-Series stack, performing circuit optimizations is redundant before submitting to hardware, unless the user would like to see the optimizations applied before submitting. Given this, users may take 1 of 3 approaches when submitting jobs:
\n", "1. Use `optimisation_level=0` when running `get_compiled_circuit`, then submit the circuit using `process_circuits` knowing that the corresponding optimization level actually run will be 2.
\n", "2. Use the `get_compiled_circuit` function with the desired optimization level to observe the transformed circuit before submitting and then specify `tket-opt-level=None` in the `process_circuits` function when submitting, in order for the optimizations to be applied as desired.
\n", "3. If the user desires to have no optimizations applied, use `optimisation_level=0` in `get_compiled_circuit` and `tket-opt-level=None` in `process_circuits`. This should be specified in both functions."]}, {"cell_type": "markdown", "metadata": {}, "source": ["In this example, option 1 is illustrated, using `get_compiled_circuit` just to rebase the circuit and leaving the optimizations to be done in the H-Series stack."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=0)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Cost "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Before running on Quantinuum systems, it is good practice to check how many HQCs a job will cost, in order to plan usage. In `pytket` this can be done using the `cost` function of the `QuantinuumBackend`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that in this case because an emulator is used, the specific syntax checker the emulator uses is specified. This is an optional parameter not needed if you are using a quantum computer target."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Run the Circuit "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now the circuit can be run on Quantinuum systems."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note:** As described above, the TKET compilation optimization level 2 will be applied since no `tket-opt-level` is specified."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The status of a submitted job can be viewed at any time, indicating if a job is in the queue or completed. Additional information is also provided, such as queue position, start times, completion time, and circuit cost in H-Series Quantum Credits (HQCs)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Retrieve Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Once a job's status returns completed, results can be returned using the `get_result` function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Save Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["It is recommended that users save job results as soon as jobs are completed due to the Quantinuum data retention policy."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Results can be loaded to their original format using `BackendResult.from_dict`."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.backends.backendresult import BackendResult"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_example.json\") as file:\n", " data = json.load(file)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = BackendResult.from_dict(data)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Analyze Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["There are multiple options for analyzing results with pytket. A few examples are highlighted here. More can be seen at [Interpreting Results](https://cqcl.github.io/pytket/manual/manual_backend.html#interpreting-results)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)\n", "print(result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Map from bit to position in the measured state"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(compiled_circuit.bit_readout)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Map from qubit to position in the measured state"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(compiled_circuit.qubit_readout)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Map from qubits to the bits to which their measurement values were written"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(compiled_circuit.qubit_to_bit_map)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Canceling jobs "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Jobs that have been submitted can also be cancelled if needed."]}, {"cell_type": "markdown", "metadata": {}, "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)
\n", "backend.cancel(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Additional Features "]}, {"cell_type": "markdown", "metadata": {}, "source": ["This section covers additional features available in `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [Extended Circuit Compilation](#circuit-compilation-extended)
\n", "* [Batch Submission](#batch-submission)
\n", "* [Parametrized Circuits](#parametrized-circuits)
\n", "* [Conditional Gates](#conditional-gates)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Extended Circuit Compilation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["This section leverages the discussion in the [Circuit Compilation](#circuit-compilation) section to illsutrate how to turn TKET compilations on or off in the `process_circuit` function, specifically for options 2 and 3."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For option 2 as described in [Circuit Compilation](#circuit-compilation), suppose a user explores the results of TKET compilation passes on a circuit and finds that `optimisation_level=1` is desirable. The submission below specifies this in the `get_compiled_circuit` function with optimization level 1. Because the circuit is optimized beforehand, the TKET optimization in the H-Series stack should be turned off. The value `tket-opt-level:None` turns off TKET optimization in the H-Series stack."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots, options={\"tket-opt-level\": None}\n", ")\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["For option 3 as described in [Circuit Compilation](#circuit-compilation), suppose a user wants to turn off all optimizations in the stack, even simple single-qubit combinations done by the H-Series compiler. This can be done by setting `optimisation_level=0` in `get_compiled_circuit` and setting `tket-opt-level:None` in the `process_circuits` function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=0)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots, options={\"tket-opt-level\": None}\n", ")\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Batch Submission "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The batch feature on Quantinuum systems gives users the ability to create \"ad-hoc\" reservations. Circuits submitted together in a batch will run at one time. The benefit to users is that once a batch hits the front of the queue, jobs in a batch will run uninterrupted until they are completed."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Once a batch is submitted, jobs can continue to be added to the batch, ending either when the user signifies the end of a batch or after 1 minute of inactivity."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Batches cannot exceed the maximum limit of 500 H-System Quantum Credits (HQCs) total. If the total HQCs for jobs in a batch hit this limit or a smaller limit set by the user, those jobs *will not be cancelled*. Instead, they will continue to run as regular jobs in the queue instead of as a batch."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Currently only the quantum computer and emulator targets support the batching feature. Batching is not supported on the syntax checkers."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For more information on using this feature in `pytket`, see [Batch Submission](https://cqcl.github.io/pytket-quantinuum/api/index.html#batching)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["To start a batch, use the `start_batch` function, specifying the `max_batch_cost` in HQCs to enforce."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "n_shots = 100\n", "max_batch_cost = 100"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["backend = QuantinuumBackend(device_name=machine)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["batch1 = backend.start_batch(\n", " max_batch_cost=max_batch_cost, circuit=compiled_circuit, n_shots=n_shots\n", ")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Additional jobs can be added to the batch using the `add_to_batch` function. The end of a batch can optionally be specified with the `batch_end` flag."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["batch2 = backend.add_to_batch(batch1, compiled_circuit, n_shots=n_shots)\n", "batch3 = backend.add_to_batch(batch1, compiled_circuit, n_shots=n_shots, batch_end=True)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The status for the batch jobs can be checked once submitted."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle_list = [batch1, batch2, batch3]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status_list = [backend.circuit_status(h) for h in handle_list]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status_list"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Results for batch submissions can be returned using `get_results` (note the plural)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_results(handle_list)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Parametrized Circuits "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Parametrized circuits are common in variational algorithms. Pytket supports parameters within circuits via symbols. For more information, see [Symbolic Circuits](https://cqcl.github.io/pytket/manual/manual_circuit.html?highlight=paramet#symbolic-circuits)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import fresh_symbol"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up parametrized circuit"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["a = fresh_symbol(\"a\")\n", "circuit = Circuit(3, name=\"Parametrized Circuit\")\n", "circuit.X(0)\n", "circuit.CX(0, 1).CX(1, 2)\n", "circuit.Rz(a, 2)\n", "circuit.CX(1, 2).CX(0, 1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note the substitution of an actual value to the `a` variable below."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Create a version of the circuit that utilizes a specific value for the variable a"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["simulation_circuit = circuit.copy()\n", "simulation_circuit.measure_all()\n", "simulation_circuit.symbol_substitution({a: -0.09})"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Compile the circuit: this includes optimizing the gates and resynthesizing the circuit to Quantinuum's native gate set"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(simulation_circuit)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Conditional Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Pytket supports conditional gates. This may be for implementing error correction or reducing noise. This capability is well-supported by Quantinuum hardware, which supports mid-circuit measurement and qubit reuse. See [Conditional Gates](https://cqcl.github.io/pytket/manual/manual_circuit.html#conditional-gates) for more information on pytket's implementation. The following example demonstrates the quantum teleportation protocol."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, if_bit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["create a circuit and add quantum and classical registers"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ = Circuit(name=\"Conditional Gates Example\")\n", "qreg = circ.add_q_register(\"q\", 3)\n", "creg = circ.add_c_register(\"b\", 2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["prepare q[0] to be in the state |->, which we wish to teleport to q[2]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.X(qreg[0]).H(qreg[0])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["prepare a Bell state on qubits q[1] and q[2]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.H(qreg[1])\n", "circ.CX(qreg[1], qreg[2])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["construct the teleportation protocol"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.CX(qreg[0], qreg[1])\n", "circ.H(qreg[0])\n", "circ.Measure(qreg[0], creg[0])\n", "circ.Measure(qreg[1], creg[1])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if (creg[1] == 1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.X(qreg[2], condition=if_bit(creg[1]))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if (creg[0] == 1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.Z(qreg[2], condition=if_bit(creg[0]))"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circ)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can utilise pytket's [Assertion](https://cqcl.github.io/pytket/manual/manual_assertion.html#assertion) feature to verify the successful teleportation of the state $| - \\rangle$."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import ProjectorAssertionBox\n", "import numpy as np"]}, {"cell_type": "markdown", "metadata": {}, "source": ["|-><-|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["proj = np.array([[0.5, -0.5], [-0.5, 0.5]])\n", "circ.add_assertion(ProjectorAssertionBox(proj), [qreg[2]], name=\"debug\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circ)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "n_shots = 100\n", "backend = QuantinuumBackend(device_name=machine)\n", "compiled_circuit = backend.get_compiled_circuit(circ)\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "status"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The `get_debug_info` function returns the success rate of the state assertion averaged across shots. Note that the failed shots are caused by the simulated device errors"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result.get_debug_info()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2022 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Quantinuum Circuit Submissions via pytket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains basic circuit submission examples to Quantinuum quantum hardware via `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [What is TKET?](#tket)
\n", "* [Step by Step](#step-by-step)
\n", " * [Circuit Preparation](#circuit-preparation)
\n", " * [Select Device](#select-device)
\n", " * [Circuit Compilation](#circuit-compilation)
\n", " * [Circuit Cost](#circuit-cost)
\n", " * [Run the Circuit](#run-circuit)
\n", " * [Retrieve Results](#retrieve-results)
\n", " * [Save Results](#save-results)
\n", " * [Analyze Results](#analyze-results)
\n", " * [Cancel Jobs](#cancel-jobs)
\n", "* [Additional Features](#additional-features)
\n", " * [Extended Circuit Compilation](#circuit-compilation-extended)
\n", " * [Batch Submission](#batch-submission)
\n", " * [Parametrized Circuits](#parametrized-circuits)
\n", " * [Conditional Gates](#conditional-gates)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## What is TKET? "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The TKET framework (pronounced \"ticket\") is a software platform for the development and execution of gate-level quantum computation, providing state-of-the-art performance in circuit compilation. It was created and is maintained by Quantinuum. The toolset is designed to extract the most out of the available NISQ devices of today and is platform-agnostic."]}, {"cell_type": "markdown", "metadata": {}, "source": ["In python, the `pytket` packages is available for python 3.9+. The `pytket` and `pytket-quantinuum` packages are included as part of the installation instructions on the user portal."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For more information on TKET, see the following links:
\n", "- [TKET manual](https://cqcl.github.io/pytket/manual/manual_intro.html)
\n", "- [TKET overview and demo video](https://www.youtube.com/watch?v=yXKSpvgAtrk)
\n", "- [Introduction to Quantum Compilation with TKET](https://github.com/CalMacCQ/tket_blog/blob/main/blog1_intro_to_qc.ipynb)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook covers how to use `pytket` in conjunction with `pytket-quantinuum` to submit to Quantinuum devices. The quantum compilation step is demonstrated, but for a full overview of quantum compilation with TKET, the last link above is recommended."]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the links below for the `pytket` and `pytket-quantinuum` documentation:
\n", "- [pytket](https://cqcl.github.io/tket/pytket/api/index.html)
\n", "- [pytket-quantinuum](https://cqcl.github.io/pytket-quantinuum/api/index.html)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Step by Step "]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Preparation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Create your circuit via the pytket python library. For details on getting started with `pytket`, see pytket's [Getting Started](https://cqcl.github.io/tket/pytket/api/getting_started.html) page."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: `pytket` renders circuits in ZX-calculus notation. This can be toggled on and off by pressing the top left button in the circuit display."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, fresh_symbol\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up Bell Test"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(2, name=\"Bell Test\")\n", "circuit.H(0)\n", "circuit.CX(0, 1)\n", "circuit.measure_all()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Select Device "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Select a machine and login to the Quantinuum API using your credentials. See the *Quantinuum Systems User Guide* in the *Examples* tab on the *Quantinuum User Portal* for information and target names for each of the H-Series systems available."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Users need to login once per session. In the notebook, a dialogue box will ask for credentials. If running a script, users be prompted at the shell. You can also [save your email in the pytket config](https://cqcl.github.io/pytket-extensions/api/quantinuum/api.html#pytket.extensions.quantinuum.backends.config.set_quantinuum_config)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The device status can be checked using `device_state`."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", QuantinuumBackend.device_state(device_name=machine))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Available devices can be viewed using the `available_devices` function. Additional information is returned, here just the device names are pulled in."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["[x.device_name for x in QuantinuumBackend.available_devices()]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Circuits submitted to Quantinuum H-Series quantum computers and emulators are automatically run through TKET compilation passes for H-Series hardware. This enables circuits to be automatically optimized for H-Series systems and run more efficiently."]}, {"cell_type": "markdown", "metadata": {}, "source": ["More information on the specific compilation passes applied can be found on the `pytket-quantinuum` documentation, specifically the [Default Compilation](https://cqcl.github.io/pytket-quantinuum/api/index.html#default-compilation) section. In the H-Series software stack, the optimization level applied is set with the `tket-opt-level` parameter. **The default compilation setting for circuits submited to H-Series sytems is optimization level 2.** More information is found in the *Quantinuum Application Programming Interface (API) Specification*."]}, {"cell_type": "markdown", "metadata": {}, "source": ["When using `pytket` before submitting to hardware, the `get_compiled_circuit` function performs the same compilation passes run after submission to Quantinuum systems. The advantage of using the function before submitting to H-Series hardware is to see exactly what circuit optimizations will be performed when submitted to hardware and determine if a different optimization level is desired. The `optimisation_level` parameter in the `get_compiled_circuit` function corresponds directly to the the level of optimisation after submitting to the H-Series systems and to the `tket-opt-level` parameter in the H-Series API. The default compilation for the `get_compiled_circuit` function is optimization level 2, the same as when submitting to the H-Series directly."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Since the TKET compilation passes have been integrated into the H-Series stack, performing circuit optimizations is redundant before submitting to hardware, unless the user would like to see the optimizations applied before submitting. Given this, users may take 1 of 3 approaches when submitting jobs:
\n", "1. Use `optimisation_level=0` when running `get_compiled_circuit`, then submit the circuit using `process_circuits` knowing that the corresponding optimization level actually run will be 2.
\n", "2. Use the `get_compiled_circuit` function with the desired optimization level to observe the transformed circuit before submitting and then specify `tket-opt-level=None` in the `process_circuits` function when submitting, in order for the optimizations to be applied as desired.
\n", "3. If the user desires to have no optimizations applied, use `optimisation_level=0` in `get_compiled_circuit` and `tket-opt-level=None` in `process_circuits`. This should be specified in both functions."]}, {"cell_type": "markdown", "metadata": {}, "source": ["In this example, option 1 is illustrated, using `get_compiled_circuit` just to rebase the circuit and leaving the optimizations to be done in the H-Series stack."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=0)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Cost "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Before running on Quantinuum systems, it is good practice to check how many HQCs a job will cost, in order to plan usage. In `pytket` this can be done using the `cost` function of the `QuantinuumBackend`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note that in this case because an emulator is used, the specific syntax checker the emulator uses is specified. This is an optional parameter not needed if you are using a quantum computer target."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Run the Circuit "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now the circuit can be run on Quantinuum systems."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note:** As described above, the TKET compilation optimization level 2 will be applied since no `tket-opt-level` is specified."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The status of a submitted job can be viewed at any time, indicating if a job is in the queue or completed. Additional information is also provided, such as queue position, start times, completion time, and circuit cost in H-Series Quantum Credits (HQCs)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Retrieve Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Once a job's status returns completed, results can be returned using the `get_result` function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Save Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["It is recommended that users save job results as soon as jobs are completed due to the Quantinuum data retention policy."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Results can be loaded to their original format using `BackendResult.from_dict`."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.backends.backendresult import BackendResult"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_example.json\") as file:\n", " data = json.load(file)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = BackendResult.from_dict(data)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Analyze Results "]}, {"cell_type": "markdown", "metadata": {}, "source": ["There are multiple options for analyzing results with pytket. A few examples are highlighted here. More can be seen at [Interpreting Results](https://cqcl.github.io/pytket/manual/manual_backend.html#interpreting-results)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)\n", "print(result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Map from bit to position in the measured state"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(compiled_circuit.bit_readout)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Map from qubit to position in the measured state"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(compiled_circuit.qubit_readout)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Map from qubits to the bits to which their measurement values were written"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(compiled_circuit.qubit_to_bit_map)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Canceling jobs "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Jobs that have been submitted can also be cancelled if needed."]}, {"cell_type": "markdown", "metadata": {}, "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)
\n", "backend.cancel(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Additional Features "]}, {"cell_type": "markdown", "metadata": {}, "source": ["This section covers additional features available in `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [Extended Circuit Compilation](#circuit-compilation-extended)
\n", "* [Batch Submission](#batch-submission)
\n", "* [Parametrized Circuits](#parametrized-circuits)
\n", "* [Conditional Gates](#conditional-gates)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Extended Circuit Compilation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["This section leverages the discussion in the [Circuit Compilation](#circuit-compilation) section to illsutrate how to turn TKET compilations on or off in the `process_circuit` function, specifically for options 2 and 3."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For option 2 as described in [Circuit Compilation](#circuit-compilation), suppose a user explores the results of TKET compilation passes on a circuit and finds that `optimisation_level=1` is desirable. The submission below specifies this in the `get_compiled_circuit` function with optimization level 1. Because the circuit is optimized beforehand, the TKET optimization in the H-Series stack should be turned off. The value `tket-opt-level:None` turns off TKET optimization in the H-Series stack."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots, options={\"tket-opt-level\": None}\n", ")\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["For option 3 as described in [Circuit Compilation](#circuit-compilation), suppose a user wants to turn off all optimizations in the stack, even simple single-qubit combinations done by the H-Series compiler. This can be done by setting `optimisation_level=0` in `get_compiled_circuit` and setting `tket-opt-level:None` in the `process_circuits` function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=0)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots, options={\"tket-opt-level\": None}\n", ")\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Batch Submission "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The batch feature on Quantinuum systems gives users the ability to create \"ad-hoc\" reservations. Circuits submitted together in a batch will run at one time. The benefit to users is that once a batch hits the front of the queue, jobs in a batch will run uninterrupted until they are completed."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Once a batch is submitted, jobs can continue to be added to the batch, ending either when the user signifies the end of a batch or after 1 minute of inactivity."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Batches cannot exceed the maximum limit of 500 H-System Quantum Credits (HQCs) total. If the total HQCs for jobs in a batch hit this limit or a smaller limit set by the user, those jobs *will not be cancelled*. Instead, they will continue to run as regular jobs in the queue instead of as a batch."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Currently only the quantum computer and emulator targets support the batching feature. Batching is not supported on the syntax checkers."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For more information on using this feature in `pytket`, see [Batch Submission](https://cqcl.github.io/pytket-quantinuum/api/index.html#batching)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["To start a batch, use the `start_batch` function, specifying the `max_batch_cost` in HQCs to enforce."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "n_shots = 100\n", "max_batch_cost = 100"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["backend = QuantinuumBackend(device_name=machine)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["batch1 = backend.start_batch(\n", " max_batch_cost=max_batch_cost, circuit=compiled_circuit, n_shots=n_shots\n", ")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Additional jobs can be added to the batch using the `add_to_batch` function. The end of a batch can optionally be specified with the `batch_end` flag."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["batch2 = backend.add_to_batch(batch1, compiled_circuit, n_shots=n_shots)\n", "batch3 = backend.add_to_batch(batch1, compiled_circuit, n_shots=n_shots, batch_end=True)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The status for the batch jobs can be checked once submitted."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle_list = [batch1, batch2, batch3]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status_list = [backend.circuit_status(h) for h in handle_list]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status_list"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Results for batch submissions can be returned using `get_results` (note the plural)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_results(handle_list)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Parametrized Circuits "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Parametrized circuits are common in variational algorithms. Pytket supports parameters within circuits via symbols. For more information, see [Symbolic Circuits](https://cqcl.github.io/pytket/manual/manual_circuit.html?highlight=paramet#symbolic-circuits)."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import fresh_symbol"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up parametrized circuit"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["a = fresh_symbol(\"a\")\n", "circuit = Circuit(3, name=\"Parametrized Circuit\")\n", "circuit.X(0)\n", "circuit.CX(0, 1).CX(1, 2)\n", "circuit.Rz(a, 2)\n", "circuit.CX(1, 2).CX(0, 1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Note the substitution of an actual value to the `a` variable below."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Create a version of the circuit that utilizes a specific value for the variable a"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["simulation_circuit = circuit.copy()\n", "simulation_circuit.measure_all()\n", "simulation_circuit.symbol_substitution({a: -0.09})"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Compile the circuit: this includes optimizing the gates and resynthesizing the circuit to Quantinuum's native gate set"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(simulation_circuit)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Conditional Gates "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Pytket supports conditional gates. This may be for implementing error correction or reducing noise. This capability is well-supported by Quantinuum hardware, which supports mid-circuit measurement and qubit reuse. See [Conditional Gates](https://cqcl.github.io/pytket/manual/manual_circuit.html#conditional-gates) for more information on pytket's implementation. The following example demonstrates the quantum teleportation protocol."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, if_bit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["create a circuit and add quantum and classical registers"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ = Circuit(name=\"Conditional Gates Example\")\n", "qreg = circ.add_q_register(\"q\", 3)\n", "creg = circ.add_c_register(\"b\", 2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["prepare q[0] to be in the state |->, which we wish to teleport to q[2]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.X(qreg[0]).H(qreg[0])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["prepare a Bell state on qubits q[1] and q[2]"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.H(qreg[1])\n", "circ.CX(qreg[1], qreg[2])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["construct the teleportation protocol"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.CX(qreg[0], qreg[1])\n", "circ.H(qreg[0])\n", "circ.Measure(qreg[0], creg[0])\n", "circ.Measure(qreg[1], creg[1])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if (creg[1] == 1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.X(qreg[2], condition=if_bit(creg[1]))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if (creg[0] == 1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circ.Z(qreg[2], condition=if_bit(creg[0]))"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circ)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We can utilise pytket's [Assertion](https://cqcl.github.io/pytket/manual/manual_assertion.html#assertion) feature to verify the successful teleportation of the state $| - \\rangle$."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import ProjectorAssertionBox\n", "import numpy as np"]}, {"cell_type": "markdown", "metadata": {}, "source": ["|-><-|"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["proj = np.array([[0.5, -0.5], [-0.5, 0.5]])\n", "circ.add_assertion(ProjectorAssertionBox(proj), [qreg[2]], name=\"debug\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circ)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "n_shots = 100\n", "backend = QuantinuumBackend(device_name=machine)\n", "compiled_circuit = backend.get_compiled_circuit(circ)\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "status"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The `get_debug_info` function returns the success rate of the state assertion averaged across shots. Note that the failed shots are caused by the simulated device errors"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result.get_debug_info()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2023 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/examples/Quantinuum_emulator.ipynb b/examples/Quantinuum_emulator.ipynb
index 097c646d..ada9bd7a 100644
--- a/examples/Quantinuum_emulator.ipynb
+++ b/examples/Quantinuum_emulator.ipynb
@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Submitting to Quantinuum Emulators via pytket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains examples for running quantum circuits on Quantinuum's emulators via `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["An emulator can be used to get an idea of what a quantum device will output for our quantum circuit. This enables circuit debugging and optimization before running on a physical machine. Emulators differ from simulators in that they model the physical and noise model of the device whereas simulators may model noise parameters, but not physical parameters. The Quantinuum emulators run on a physical noise model of the Quantinuum H-Series devices. There are various noise/error parameters modeled. For detailed information on the noise model, see the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or at [Quantinuum H-series](https://www.quantinuum.com/products/h1)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["There are a few options for using the emulator:"]}, {"cell_type": "markdown", "metadata": {}, "source": ["1. **Basic Usage:** Use the emulator as provided, which represents both the physical operations in the device as well as the noise. This the most common and simplest way to use the emulator.
\n", "2. **Noiseless Emulation:** Use the emulator without the physical noise model applied. The physical device operations are represented, but all errors are set to 0.
\n", "3. **Noise Parameters (*advanced option*):** Experiment with the noise parameters in the emulator. There is no guarantee that results achieved changing these parameters will represent outputs from the actual quantum computer represented.
\n", "4. **Stabilizer Emulator:** Use of the emulator for circuits involving only Clifford operations."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For more information, see the *Quantinuum System Model H1 Emulator Product Data Sheet*, *Quantinuum Systems User Guide*, and *Quantinuum Application Programming Interface (API)* on the Quantinuum User Portal for detailed information on each of the emulators available and workflow information including job submission, queueing, and the full list of options available."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Emulator Usage:**
\n", "* [Basic Usage](#basic-usage)
\n", "* [Noiseless Emulation](#no-noise)
\n", "* [Noise Parameters (*advanced*)](#noise)
\n", "* [Stabilizer Emulator](#stabilizer)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Emulator Usage"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Basic Usage "]}, {"cell_type": "markdown", "metadata": {}, "source": ["This section covers usage of the emulator which represents a physical and noise model of the device being used. For example, if using the `H1-1E` target, this emulates the H1-1 quantum computer."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Here the circuit is created via the pytket python library. For details on getting started with `pytket`, see pytket's [Getting Started](https://cqcl.github.io/tket/pytket/api/getting_started.html) page."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up Bell Test"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(2, name=\"Bell Test\")\n", "circuit.H(0)\n", "circuit.CX(0, 1)\n", "circuit.measure_all()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Select the emulation device. See the *Quantinuum Systems User Guide* in the *Examples* tab on the *Quantinuum User Portal* for information and target names for each of the emulators available."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", backend.device_state(device_name=machine))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Compile the circuit to the Quantinuum backend with `get_compiled_circuit`. See the `pytket` [User Manual](https://cqcl.github.io/pytket/manual/index.html) for more information on all the options that are available."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Check the circuit HQC cost before running on the emulator."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Run the circuit on the emulator chosen."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Check the job status."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Once a job's status returns completed, return results with the `get_result` function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It is recommended to save job results as soon as jobs are completed due to the Quantinuum data retention policy."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_emulator_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The result output is just like that of a quantum device. The simulation by default runs with noise."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)\n", "print(result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Noiseless Emulation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The Quantinuum emulators may be run with or without the physical device's noise model. The default is the emulator runs with the physical noise model turned on. The physical noise model can be turned off by setting `noisy_simulation=False`."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "no_error_model_handle = backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots, noisy_simulation=False\n", ")\n", "print(no_error_model_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_status = backend.circuit_status(no_error_model_handle)\n", "print(no_error_model_status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_result = backend.get_result(no_error_model_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_result"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_emulator_noiseless_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_result = backend.get_result(no_error_model_handle)\n", "print(no_error_model_result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(no_error_model_result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Noise Parameters "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The emulator runs with default error parameters that represent a noise environment similar to the physical devices. The `error-params` option can be used to override these error parameters and do finer-grain tweaks of the error model. For detailed information on the noise model, see the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) or the *Quantinuum Application Programming Interface (API)* on the user portal."]}, {"cell_type": "markdown", "metadata": {}, "source": ["In this section, examples are given for experimenting with the noise and error parameters of the emulators. These are advanced options and not recommended to start with when doing initial experiments. As mentioned above, there is no guarantee that results achieved changing these parameters will represent outputs from the actual quantum computer represented."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: All the noise parameters are used together any time a simulation is run. If only some of the parameters are specified, the rest of the parameters are used at their default settings. The parameters to override are specified with the `options` parameter."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [Physical Noise](#physical-noise)
\n", "* [Dephasing Noise](#dephasing-noise)
\n", "* [Arbitrary Angle Noise Scaling](#arbitrary-angle-noise)
\n", "* [Scaling](#scaling)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Physical Noise "]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for information on these parameters."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"p1\": 4e-5,\n", " \"p2\": 3e-3,\n", " \"p_meas\": 3e-3,\n", " \"p_init\": 4e-5,\n", " \"p_crosstalk_meas\": 1e-5,\n", " \"p_crosstalk_init\": 3e-5,\n", " \"p1_emission\": 6e-6,\n", " \"p2_emission\": 2e-4,\n", " }\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Dephasing Noise "]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for information on these parameters."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"coherent_dephasing_rate\": 0.2,\n", " \"incoherent_dephasing_rate\": 0.3,\n", " \"coherent_dephasing\": False, # False => run the incoherent noise model\n", " \"transport_dephasing\": False, # False => turn off transport dephasing error\n", " \"idle_dephasing\": False, # False => turn off idel dephasing error\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Arbitrary Angle Noise Scaling "]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for information on these parameters."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"przz_a\": 1.09,\n", " \"przz_b\": 0.051,\n", " \"przz_c\": 1.365,\n", " \"przz_d\": 0.035,\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Scaling "]}, {"cell_type": "markdown", "metadata": {}, "source": ["All the error rates can be scaled linearly using the `scale` parameter. See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for more information."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"scale\": 0.1, # scale error rates linearly by 0.1\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Other aspects of the noise model can scale specific error rates in the error model, which are modeled here."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"p1_scale\": 0.1,\n", " \"p2_scale\": 0.1,\n", " \"meas_scale\": 0.1,\n", " \"init_scale\": 0.1,\n", " \"memory_scale\": 0.1,\n", " \"emission_scale\": 0.1,\n", " \"crosstalk_scale\": 0.1,\n", " \"leakage_scale\": 0.1,\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Stabilizer Emulator "]}, {"cell_type": "markdown", "metadata": {}, "source": ["By default, emulations are run using a state-vector emulator, which simulates any quantum operation. However, if the quantum operations are all Clifford gates, it can be faster for complex circuits to use the `stabilizer` emulator. The stabilizer emulator is requested in the setup of the `QuantinuumBackend` with the `simulator` input option. This only applies to Quantinuum emulators."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\""]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_backend = QuantinuumBackend(device_name=machine, simulator=\"stabilizer\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", stabilizer_backend.device_state(device_name=machine))\n", "print(\"Simulation type:\", stabilizer_backend.simulator_type)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "stabilizer_handle = stabilizer_backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots\n", ")\n", "print(stabilizer_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_status = stabilizer_backend.circuit_status(stabilizer_handle)\n", "print(stabilizer_status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_result = stabilizer_backend.get_result(stabilizer_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_result"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_emulator_stabilizer_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_result = stabilizer_backend.get_result(stabilizer_handle)\n", "print(stabilizer_result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(stabilizer_result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Noiseless Stabilizer"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A noiseless stabilizer simulation can be specified via options in the `process_circuit` function with the following options:"]}, {"cell_type": "markdown", "metadata": {}, "source": ["- `simulator`: choose to run with a `stabilizer` simulator or `state-vector` (default is `state-vector`)
\n", "- `error-model`: whether to run with or without the physical device noise model on or off. The default is `True`, which means the physical noise model is turned on. If set to `False`, the physical noise model is turned off, performing noiseless simulation."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"simulator\": \"stabilizer\",\n", " \"error-model\": False,\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2022 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Submitting to Quantinuum Emulators via pytket"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains examples for running quantum circuits on Quantinuum's emulators via `pytket`."]}, {"cell_type": "markdown", "metadata": {}, "source": ["An emulator can be used to get an idea of what a quantum device will output for our quantum circuit. This enables circuit debugging and optimization before running on a physical machine. Emulators differ from simulators in that they model the physical and noise model of the device whereas simulators may model noise parameters, but not physical parameters. The Quantinuum emulators run on a physical noise model of the Quantinuum H-Series devices. There are various noise/error parameters modeled. For detailed information on the noise model, see the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or at [Quantinuum H-series](https://www.quantinuum.com/products/h1)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["There are a few options for using the emulator:"]}, {"cell_type": "markdown", "metadata": {}, "source": ["1. **Basic Usage:** Use the emulator as provided, which represents both the physical operations in the device as well as the noise. This the most common and simplest way to use the emulator.
\n", "2. **Noiseless Emulation:** Use the emulator without the physical noise model applied. The physical device operations are represented, but all errors are set to 0.
\n", "3. **Noise Parameters (*advanced option*):** Experiment with the noise parameters in the emulator. There is no guarantee that results achieved changing these parameters will represent outputs from the actual quantum computer represented.
\n", "4. **Stabilizer Emulator:** Use of the emulator for circuits involving only Clifford operations."]}, {"cell_type": "markdown", "metadata": {}, "source": ["For more information, see the *Quantinuum System Model H1 Emulator Product Data Sheet*, *Quantinuum Systems User Guide*, and *Quantinuum Application Programming Interface (API)* on the Quantinuum User Portal for detailed information on each of the emulators available and workflow information including job submission, queueing, and the full list of options available."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Emulator Usage:**
\n", "* [Basic Usage](#basic-usage)
\n", "* [Noiseless Emulation](#no-noise)
\n", "* [Noise Parameters (*advanced*)](#noise)
\n", "* [Stabilizer Emulator](#stabilizer)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Emulator Usage"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Basic Usage "]}, {"cell_type": "markdown", "metadata": {}, "source": ["This section covers usage of the emulator which represents a physical and noise model of the device being used. For example, if using the `H1-1E` target, this emulates the H1-1 quantum computer."]}, {"cell_type": "markdown", "metadata": {}, "source": ["Here the circuit is created via the pytket python library. For details on getting started with `pytket`, see pytket's [Getting Started](https://cqcl.github.io/tket/pytket/api/getting_started.html) page."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up Bell Test"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(2, name=\"Bell Test\")\n", "circuit.H(0)\n", "circuit.CX(0, 1)\n", "circuit.measure_all()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Select the emulation device. See the *Quantinuum Systems User Guide* in the *Examples* tab on the *Quantinuum User Portal* for information and target names for each of the emulators available."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", backend.device_state(device_name=machine))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Compile the circuit to the Quantinuum backend with `get_compiled_circuit`. See the `pytket` [User Manual](https://cqcl.github.io/pytket/manual/index.html) for more information on all the options that are available."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=1)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Check the circuit HQC cost before running on the emulator."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "backend.cost(compiled_circuit, n_shots=n_shots, syntax_checker=\"H1-1SC\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Run the circuit on the emulator chosen."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)\n", "print(handle)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Check the job status."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Once a job's status returns completed, return results with the `get_result` function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It is recommended to save job results as soon as jobs are completed due to the Quantinuum data retention policy."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_emulator_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The result output is just like that of a quantum device. The simulation by default runs with noise."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)\n", "print(result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Noiseless Emulation "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The Quantinuum emulators may be run with or without the physical device's noise model. The default is the emulator runs with the physical noise model turned on. The physical noise model can be turned off by setting `noisy_simulation=False`."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "no_error_model_handle = backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots, noisy_simulation=False\n", ")\n", "print(no_error_model_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_status = backend.circuit_status(no_error_model_handle)\n", "print(no_error_model_status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_result = backend.get_result(no_error_model_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_result"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_emulator_noiseless_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["no_error_model_result = backend.get_result(no_error_model_handle)\n", "print(no_error_model_result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(no_error_model_result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Noise Parameters "]}, {"cell_type": "markdown", "metadata": {}, "source": ["The emulator runs with default error parameters that represent a noise environment similar to the physical devices. The `error-params` option can be used to override these error parameters and do finer-grain tweaks of the error model. For detailed information on the noise model, see the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) or the *Quantinuum Application Programming Interface (API)* on the user portal."]}, {"cell_type": "markdown", "metadata": {}, "source": ["In this section, examples are given for experimenting with the noise and error parameters of the emulators. These are advanced options and not recommended to start with when doing initial experiments. As mentioned above, there is no guarantee that results achieved changing these parameters will represent outputs from the actual quantum computer represented."]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: All the noise parameters are used together any time a simulation is run. If only some of the parameters are specified, the rest of the parameters are used at their default settings. The parameters to override are specified with the `options` parameter."]}, {"cell_type": "markdown", "metadata": {}, "source": ["* [Physical Noise](#physical-noise)
\n", "* [Dephasing Noise](#dephasing-noise)
\n", "* [Arbitrary Angle Noise Scaling](#arbitrary-angle-noise)
\n", "* [Scaling](#scaling)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Physical Noise "]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for information on these parameters."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"p1\": 4e-5,\n", " \"p2\": 3e-3,\n", " \"p_meas\": 3e-3,\n", " \"p_init\": 4e-5,\n", " \"p_crosstalk_meas\": 1e-5,\n", " \"p_crosstalk_init\": 3e-5,\n", " \"p1_emission\": 6e-6,\n", " \"p2_emission\": 2e-4,\n", " }\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Dephasing Noise "]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for information on these parameters."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"coherent_dephasing_rate\": 0.2,\n", " \"incoherent_dephasing_rate\": 0.3,\n", " \"coherent_dephasing\": False, # False => run the incoherent noise model\n", " \"transport_dephasing\": False, # False => turn off transport dephasing error\n", " \"idle_dephasing\": False, # False => turn off idel dephasing error\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Arbitrary Angle Noise Scaling "]}, {"cell_type": "markdown", "metadata": {}, "source": ["See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for information on these parameters."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"przz_a\": 1.09,\n", " \"przz_b\": 0.051,\n", " \"przz_c\": 1.365,\n", " \"przz_d\": 0.035,\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Scaling "]}, {"cell_type": "markdown", "metadata": {}, "source": ["All the error rates can be scaled linearly using the `scale` parameter. See the *Quantinuum System Model H1 Emulator Product Data Sheet* on the user portal or [Quantinuum H-Series page](https://www.quantinuum.com/hardware/h1) for more information."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"scale\": 0.1, # scale error rates linearly by 0.1\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Other aspects of the noise model can scale specific error rates in the error model, which are modeled here."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"error-params\": {\n", " \"p1_scale\": 0.1,\n", " \"p2_scale\": 0.1,\n", " \"meas_scale\": 0.1,\n", " \"init_scale\": 0.1,\n", " \"memory_scale\": 0.1,\n", " \"emission_scale\": 0.1,\n", " \"crosstalk_scale\": 0.1,\n", " \"leakage_scale\": 0.1,\n", " },\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Stabilizer Emulator "]}, {"cell_type": "markdown", "metadata": {}, "source": ["By default, emulations are run using a state-vector emulator, which simulates any quantum operation. However, if the quantum operations are all Clifford gates, it can be faster for complex circuits to use the `stabilizer` emulator. The stabilizer emulator is requested in the setup of the `QuantinuumBackend` with the `simulator` input option. This only applies to Quantinuum emulators."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-1E\""]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_backend = QuantinuumBackend(device_name=machine, simulator=\"stabilizer\")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", stabilizer_backend.device_state(device_name=machine))\n", "print(\"Simulation type:\", stabilizer_backend.simulator_type)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "stabilizer_handle = stabilizer_backend.process_circuit(\n", " compiled_circuit, n_shots=n_shots\n", ")\n", "print(stabilizer_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_status = stabilizer_backend.circuit_status(stabilizer_handle)\n", "print(stabilizer_status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_result = stabilizer_backend.get_result(stabilizer_handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_result"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"pytket_emulator_stabilizer_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["stabilizer_result = stabilizer_backend.get_result(stabilizer_handle)\n", "print(stabilizer_result.get_distribution())"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(stabilizer_result.get_counts())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Noiseless Stabilizer"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A noiseless stabilizer simulation can be specified via options in the `process_circuit` function with the following options:"]}, {"cell_type": "markdown", "metadata": {}, "source": ["- `simulator`: choose to run with a `stabilizer` simulator or `state-vector` (default is `state-vector`)
\n", "- `error-model`: whether to run with or without the physical device noise model on or off. The default is `True`, which means the physical noise model is turned on. If set to `False`, the physical noise model is turned off, performing noiseless simulation."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["handle = backend.process_circuit(\n", " compiled_circuit,\n", " n_shots=100,\n", " request_options={\n", " \"options\": {\n", " \"simulator\": \"stabilizer\",\n", " \"error-model\": False,\n", " }\n", " },\n", ")"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(result.get_distribution())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2023 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/examples/Quantinuum_mid-circuit_measurement.ipynb b/examples/Quantinuum_mid-circuit_measurement.ipynb
index 4bdc219b..d98768e4 100644
--- a/examples/Quantinuum_mid-circuit_measurement.ipynb
+++ b/examples/Quantinuum_mid-circuit_measurement.ipynb
@@ -1 +1 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Mid-Circuit Measurement"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains an example using mid-circuit measurement using the Quantinuum machines."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Repetition Code Circuit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The use of mid-circuit measurement is straightforward, note the use of `measure` and `reset` on the ancilla qubits. This example also utlizes conditional logic available with Quantinuum devices as well as Registers and IDs available in `pytket`. See [Classical and conditional operations](https://cqcl.github.io/pytket/manual/manual_circuit.html#classical-and-conditional-operations) and [Registers and IDs](https://cqcl.github.io/pytket/manual/manual_circuit.html#registers-and-ids) for additional examples."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, Qubit, Bit, OpType, reg_eq\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up Repetition Code with mid-circuit measurement and corrections:
\n", "`2 1 0 = data: data qubits`
\n", "`*----*----*`
\n", "` ZZ ZZ`
\n", "` 1 0 = syndromes`
\n", "` 0 0 = ancillas`"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up circuit object"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(name=\"Repetition Code\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add qubit register, the data qubits"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["data = circuit.add_q_register(\"data\", 3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add qubit register, the ancilla qubit"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["ancilla = circuit.add_q_register(\"anc\", 1)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add classical registers for the syndromes"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["syndrome = circuit.add_c_register(\"syndrome\", 2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add classical registers for the output"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["output = circuit.add_c_register(\"output\", 3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Prepare the logical state. Qubits always start in $| 0 \\rangle$ and logical $ | 0 \\rangle == | 000 \\rangle$. So we already start in logical $| 0 \\rangle$.
\n", "Syndrome Extraction"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.add_gate(OpType.Reset, ancilla)\n", "circuit.CX(data[0], ancilla[0])\n", "circuit.CX(data[1], ancilla[0])\n", "circuit.Measure(ancilla[0], syndrome[0])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Syndrome Extraction"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.add_gate(OpType.Reset, ancilla)\n", "circuit.CX(data[1], ancilla[0])\n", "circuit.CX(data[2], ancilla[0])\n", "circuit.Measure(ancilla[0], syndrome[1])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Correction: if(syndromes==1) -> 01 -> check 0 bad -> X on qubit 0"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.X(data[0], condition=reg_eq(syndrome, 1))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if(syndromes==2) -> 10 -> check 1 bad -> X on qubit 2"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.X(data[2], condition=reg_eq(syndrome, 2))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if(syndromes==3) -> 11 -> check 1 and 2 bad -> X on qubit 1"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.X(data[1], condition=reg_eq(syndrome, 3))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Measure out data qubits"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.Measure(data[0], output[0])\n", "circuit.Measure(data[1], output[1])\n", "circuit.Measure(data[2], output[2])"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Select Device"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Login to the Quantinuum API using your credentials and check the device status."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-2E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", QuantinuumBackend.device_state(device_name=machine))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation"]}, {"cell_type": "markdown", "metadata": {}, "source": ["`pytket` includes many features for optimizing circuits. This includes reducing the number of gates where possible and resynthesizing circuits for a quantum computer's native gate set. See the `pytket` [User Manual](https://cqcl.github.io/pytket/manual/index.html) for more information on all the options that are available.
\n", "Here the circuit is compiled with `get_compiled_circuit`, which includes optimizing the gates and resynthesizing the circuit to Quantinuum's native gate set. The `optimisation_level` sets the level of optimization to perform during compilation, check pytket documentation for more details."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=1)\n", "render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Submit and Run the Circuit"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)\n", "print(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)\n", "with open(\"pytket_mcmr_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Analyze Results"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We will now take the raw results and apply a majority vote to determine how many times we got 0 vs 1.
\n", "First, define a majority vote function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def majority(result):\n", " \"\"\"Returns whether the output should be considered a 0 or 1.\"\"\"\n", " if result.count(0) > result.count(1):\n", " return 0\n", " elif result.count(0) < result.count(1):\n", " return 1\n", " else:\n", " raise Exception(\"count(0) should not equal count(1)\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now process the output"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result_output_cnts = result.get_counts([output[i] for i in range(output.size)])\n", "result_output_cnts"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["zeros = 0 # Counts the shots with majority zeros\n", "ones = 0 # Counts the shots with majority ones\n", "for out in result_output_cnts:\n", " m = majority(out)\n", " if m == 0:\n", " zeros += result_output_cnts[out]\n", " else:\n", " ones += result_output_cnts[out]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A logical zero was initialized, so our error rate should be number of ones / total number of shots: `ones/shots`"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["p = ones / n_shots\n", "print(f\"The error-rate is: p = {p}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2022 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["\n", "# Mid-Circuit Measurement"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This notebook contains an example using mid-circuit measurement using the Quantinuum machines."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Repetition Code Circuit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The use of mid-circuit measurement is straightforward, note the use of `measure` and `reset` on the ancilla qubits. This example also utlizes conditional logic available with Quantinuum devices as well as Registers and IDs available in `pytket`. See [Classical and conditional operations](https://cqcl.github.io/pytket/manual/manual_circuit.html#classical-and-conditional-operations) and [Registers and IDs](https://cqcl.github.io/pytket/manual/manual_circuit.html#registers-and-ids) for additional examples."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.circuit import Circuit, Qubit, Bit, OpType, reg_eq\n", "from pytket.circuit.display import render_circuit_jupyter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up Repetition Code with mid-circuit measurement and corrections:
\n", "`2 1 0 = data: data qubits`
\n", "`*----*----*`
\n", "` ZZ ZZ`
\n", "` 1 0 = syndromes`
\n", "` 0 0 = ancillas`"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Set up circuit object"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit = Circuit(name=\"Repetition Code\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add qubit register, the data qubits"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["data = circuit.add_q_register(\"data\", 3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add qubit register, the ancilla qubit"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["ancilla = circuit.add_q_register(\"anc\", 1)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add classical registers for the syndromes"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["syndrome = circuit.add_c_register(\"syndrome\", 2)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Add classical registers for the output"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["output = circuit.add_c_register(\"output\", 3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Prepare the logical state. Qubits always start in $| 0 \\rangle$ and logical $ | 0 \\rangle == | 000 \\rangle$. So we already start in logical $| 0 \\rangle$.
\n", "Syndrome Extraction"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.add_gate(OpType.Reset, ancilla)\n", "circuit.CX(data[0], ancilla[0])\n", "circuit.CX(data[1], ancilla[0])\n", "circuit.Measure(ancilla[0], syndrome[0])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Syndrome Extraction"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.add_gate(OpType.Reset, ancilla)\n", "circuit.CX(data[1], ancilla[0])\n", "circuit.CX(data[2], ancilla[0])\n", "circuit.Measure(ancilla[0], syndrome[1])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Correction: if(syndromes==1) -> 01 -> check 0 bad -> X on qubit 0"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.X(data[0], condition=reg_eq(syndrome, 1))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if(syndromes==2) -> 10 -> check 1 bad -> X on qubit 2"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.X(data[2], condition=reg_eq(syndrome, 2))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["if(syndromes==3) -> 11 -> check 1 and 2 bad -> X on qubit 1"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.X(data[1], condition=reg_eq(syndrome, 3))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Measure out data qubits"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["circuit.Measure(data[0], output[0])\n", "circuit.Measure(data[1], output[1])\n", "circuit.Measure(data[2], output[2])"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["render_circuit_jupyter(circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Select Device"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Login to the Quantinuum API using your credentials and check the device status."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["from pytket.extensions.quantinuum import QuantinuumBackend"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["machine = \"H1-2E\"\n", "backend = QuantinuumBackend(device_name=machine)\n", "backend.login()"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["print(machine, \"status:\", QuantinuumBackend.device_state(device_name=machine))"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Circuit Compilation"]}, {"cell_type": "markdown", "metadata": {}, "source": ["`pytket` includes many features for optimizing circuits. This includes reducing the number of gates where possible and resynthesizing circuits for a quantum computer's native gate set. See the `pytket` [User Manual](https://cqcl.github.io/pytket/manual/index.html) for more information on all the options that are available.
\n", "Here the circuit is compiled with `get_compiled_circuit`, which includes optimizing the gates and resynthesizing the circuit to Quantinuum's native gate set. The `optimisation_level` sets the level of optimization to perform during compilation, check pytket documentation for more details."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["compiled_circuit = backend.get_compiled_circuit(circuit, optimisation_level=1)\n", "render_circuit_jupyter(compiled_circuit)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Submit and Run the Circuit"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["n_shots = 100\n", "handle = backend.process_circuit(compiled_circuit, n_shots=n_shots)\n", "print(handle)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["status = backend.circuit_status(handle)\n", "print(status)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["import json"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result = backend.get_result(handle)\n", "with open(\"pytket_mcmr_example.json\", \"w\") as file:\n", " json.dump(result.to_dict(), file)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Analyze Results"]}, {"cell_type": "markdown", "metadata": {}, "source": ["We will now take the raw results and apply a majority vote to determine how many times we got 0 vs 1.
\n", "First, define a majority vote function."]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["def majority(result):\n", " \"\"\"Returns whether the output should be considered a 0 or 1.\"\"\"\n", " if result.count(0) > result.count(1):\n", " return 0\n", " elif result.count(0) < result.count(1):\n", " return 1\n", " else:\n", " raise Exception(\"count(0) should not equal count(1)\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now process the output"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["result_output_cnts = result.get_counts([output[i] for i in range(output.size)])\n", "result_output_cnts"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["zeros = 0 # Counts the shots with majority zeros\n", "ones = 0 # Counts the shots with majority ones\n", "for out in result_output_cnts:\n", " m = majority(out)\n", " if m == 0:\n", " zeros += result_output_cnts[out]\n", " else:\n", " ones += result_output_cnts[out]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["A logical zero was initialized, so our error rate should be number of ones / total number of shots: `ones/shots`"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["p = ones / n_shots\n", "print(f\"The error-rate is: p = {p}\")"]}, {"cell_type": "markdown", "metadata": {}, "source": ["
© 2023 by Quantinuum. All Rights Reserved.
"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "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.6.4"}}, "nbformat": 4, "nbformat_minor": 2}
\ No newline at end of file
diff --git a/examples/python/Quantinuum_arbitrary_zz.py b/examples/python/Quantinuum_arbitrary_zz.py
index 052d5b03..9365472c 100644
--- a/examples/python/Quantinuum_arbitrary_zz.py
+++ b/examples/python/Quantinuum_arbitrary_zz.py
@@ -261,4 +261,4 @@ def meas_Had_basis(orig_circ, n_qubits):
qft_fid_arbZZ_compiled_distro[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)],
)
-# © 2022 by Quantinuum. All Rights Reserved.
+# © 2023 by Quantinuum. All Rights Reserved.
diff --git a/examples/python/Quantinuum_circuit_submissions.py b/examples/python/Quantinuum_circuit_submissions.py
index 374e8cd7..13ad5408 100644
--- a/examples/python/Quantinuum_circuit_submissions.py
+++ b/examples/python/Quantinuum_circuit_submissions.py
@@ -344,4 +344,4 @@
result.get_debug_info()
-# © 2022 by Quantinuum. All Rights Reserved.
+# © 2023 by Quantinuum. All Rights Reserved.
diff --git a/examples/python/Quantinuum_emulator.py b/examples/python/Quantinuum_emulator.py
index ee49b684..33c5d8dc 100644
--- a/examples/python/Quantinuum_emulator.py
+++ b/examples/python/Quantinuum_emulator.py
@@ -300,4 +300,4 @@
print(result.get_distribution())
-# © 2022 by Quantinuum. All Rights Reserved.
+# © 2023 by Quantinuum. All Rights Reserved.
diff --git a/examples/python/Quantinuum_mid-circuit_measurement.py b/examples/python/Quantinuum_mid-circuit_measurement.py
index 43521cc9..a3525055 100644
--- a/examples/python/Quantinuum_mid-circuit_measurement.py
+++ b/examples/python/Quantinuum_mid-circuit_measurement.py
@@ -130,4 +130,4 @@ def majority(result):
p = ones / n_shots
print(f"The error-rate is: p = {p}")
-# © 2022 by Quantinuum. All Rights Reserved.
+# © 2023 by Quantinuum. All Rights Reserved.
diff --git a/pytket/extensions/quantinuum/__init__.py b/pytket/extensions/quantinuum/__init__.py
index e583d89d..acd118f4 100644
--- a/pytket/extensions/quantinuum/__init__.py
+++ b/pytket/extensions/quantinuum/__init__.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/pytket/extensions/quantinuum/backends/__init__.py b/pytket/extensions/quantinuum/backends/__init__.py
index 512576e1..6d285bef 100644
--- a/pytket/extensions/quantinuum/backends/__init__.py
+++ b/pytket/extensions/quantinuum/backends/__init__.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/pytket/extensions/quantinuum/backends/api_wrappers.py b/pytket/extensions/quantinuum/backends/api_wrappers.py
index 058aac45..c82f04a2 100644
--- a/pytket/extensions/quantinuum/backends/api_wrappers.py
+++ b/pytket/extensions/quantinuum/backends/api_wrappers.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/pytket/extensions/quantinuum/backends/config.py b/pytket/extensions/quantinuum/backends/config.py
index 0bb01799..37392d4f 100644
--- a/pytket/extensions/quantinuum/backends/config.py
+++ b/pytket/extensions/quantinuum/backends/config.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/pytket/extensions/quantinuum/backends/credential_storage.py b/pytket/extensions/quantinuum/backends/credential_storage.py
index ae6f7bfd..5e2a6924 100644
--- a/pytket/extensions/quantinuum/backends/credential_storage.py
+++ b/pytket/extensions/quantinuum/backends/credential_storage.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/pytket/extensions/quantinuum/backends/federated_login.py b/pytket/extensions/quantinuum/backends/federated_login.py
index 0db23d21..14ae80d7 100644
--- a/pytket/extensions/quantinuum/backends/federated_login.py
+++ b/pytket/extensions/quantinuum/backends/federated_login.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/pytket/extensions/quantinuum/backends/quantinuum.py b/pytket/extensions/quantinuum/backends/quantinuum.py
index 9e74f5ad..5fc6ee66 100644
--- a/pytket/extensions/quantinuum/backends/quantinuum.py
+++ b/pytket/extensions/quantinuum/backends/quantinuum.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/setup.py b/setup.py
index c0e20468..e7703c03 100644
--- a/setup.py
+++ b/setup.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/tests/api1_test.py b/tests/api1_test.py
index 24161cc1..bfaa86e8 100644
--- a/tests/api1_test.py
+++ b/tests/api1_test.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/tests/api_test.py b/tests/api_test.py
index 1848bb45..d73dcd34 100644
--- a/tests/api_test.py
+++ b/tests/api_test.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/tests/backend_test.py b/tests/backend_test.py
index 528bf63f..8ac7a520 100644
--- a/tests/backend_test.py
+++ b/tests/backend_test.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/tests/conftest.py b/tests/conftest.py
index 97911075..4303aca6 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
diff --git a/tests/convert_test.py b/tests/convert_test.py
index 1a114d9c..f7fe5fbb 100644
--- a/tests/convert_test.py
+++ b/tests/convert_test.py
@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Cambridge Quantum Computing
+# Copyright 2020-2023 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
From dcbd0388aeb8d3221b25cff5ca2c946e0314ab27 Mon Sep 17 00:00:00 2001
From: Yao Tang