{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Gate-based computation\n", "This example demonstrates how gate-based computation can be converted into photonic-native systems, and shows some of the tools included within Lightworks to simplify this process." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import lightworks as lw\n", "from lightworks import qubit, remote\n", "\n", "try:\n", " remote.token.load(\"main_token\")\n", "except remote.TokenError:\n", " print(\n", " \"Token could not be automatically loaded, this will need to be \"\n", " \"manually configured.\"\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Start by defining the target QPU which will be used for all computations within this Notebook." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "qpu = remote.QPU(\"Artemis\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Dual-rail encoding\n", "\n", "To perform gate-based circuits on photonic systems such as Artemis, the qubit needs to be encoded within the properties of the photon. Due to the nature of Artemis, this needs to be through the spatial degree of freedom, by dedicating a pair of modes to each qubit in the system. Then, the state of the system is dictated by the photon probability distribution across these modes. In Lightworks, the convention used is that the first mode (the upper mode visually) corresponds to $\\ket{0}$ and the second mode corresponds to $\\ket{1}$. This is shown in the diagram below.\n", "\n", "\n", "\n", "To simplify the process of converting between the two encodings, there are included functions for this. For example, below we convert the basic qubit states into their corresponding dual-rail encoding." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|0> -> |1,0>\n", "|1> -> |0,1>\n" ] } ], "source": [ "print(f\"|0> -> {lw.convert.qubit_to_dual_rail('0')}\")\n", "print(f\"|1> -> {lw.convert.qubit_to_dual_rail('1')}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This also scales to multi-qubit systems, for example $\\ket{01}$ in qubit encoding would be the following in a dual-rail encoding. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|01> -> |1,0,0,1>\n" ] } ], "source": [ "print(f\"|01> -> {lw.convert.qubit_to_dual_rail('01')}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Likewise, it is possible to convert back from dual-rail to qubit encoding." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|1001> -> |0,1>\n" ] } ], "source": [ "print(f\"|1001> -> {lw.convert.dual_rail_to_qubit(lw.State([1, 0, 0, 1]))}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Circuit execution\n", "We can then move on to running circuits on Artemis. Below, a circuit is created to transform the $\\ket{00}$ state into the 2-qubit bell state $\\ket{\\Phi^+} = \\frac{1}{\\sqrt{2}}(\\ket{00}+\\ket{11})$. The exact operation of this is as follows, first a Hadamard is applied to the first qubit:\n", "\n", "\\begin{equation}\n", "\\text{H}_0\\ket{00} = \\frac{1}{\\sqrt{2}}(\\ket{00}+\\ket{10})\n", "\\end{equation}\n", "\n", "A CNOT gate is then applied between the first and second qubits:\n", "\n", "\\begin{equation}\n", "\\text{CNOT}_{01}\\frac{1}{\\sqrt{2}}(\\ket{00}+\\ket{10}) = \\frac{1}{\\sqrt{2}}(\\ket{00}+\\ket{11})\n", "\\end{equation}\n", "\n", "This is created within Lightworks using the code below, where a 4 mode circuit (2 qubit * 2) is defined and the relevant components added to it. The built-in heralding tools are used to automatically manage the heralding required for the implementation of a CNOT gate." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-\n", "0\n", "1\n", "2\n", "3\n", "-\n", "\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CNOT (0, 1)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "\n", "\n", "0\n", "\n", "\n", "\n", "0\n", "\n", "\n", "\n", "0\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "circuit = lw.PhotonicCircuit(4)\n", "\n", "circuit.add(qubit.H(), 0)\n", "circuit.add(qubit.CNOT(), 0)\n", "\n", "circuit.display()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Something to be aware of when using heralded modes is that each herald requires a dedicated mode in the photonic processor, which means that circuits can require more resources than may initially appear. For example, in the circuit above, there are 4 input modes and 2 heralded modes, meaning the actual circuit size is 6 modes. The size of circuit can be monitored using the ``n_modes`` attribute. Likewise, ``input_modes`` can be used to check the number of user specified modes in a circuit." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Required modes = 6\n", "Input modes = 4\n" ] } ], "source": [ "print(f\"Required modes = {circuit.n_modes}\")\n", "print(f\"Input modes = {circuit.input_modes}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The input state is then defined, using the conversion function to switch from qubit to dual-rail encoding." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|1,0,1,0>\n" ] } ], "source": [ "in_state = lw.convert.qubit_to_dual_rail(\"00\")\n", "print(in_state)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lastly, the CNOT gate above requires post-selection to function correctly, in which it is required only 1 photon is measured across each pair of modes. This can be applied using the PostSelection object in Lightworks, as is shown below." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "post_selection = lw.PostSelection()\n", "post_selection.add((0, 1), 1)\n", "post_selection.add((2, 3), 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The sampler task is then created and can be run on the target QPU." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "sampler = lw.Sampler(circuit, in_state, 10000, post_selection=post_selection)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "job = qpu.run(sampler)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once complete, the results from the job are retrieved and plotted. These will be in a dual-rail encoding by default, which may make them slightly tricky to interpret." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "job.wait_until_complete()\n", "\n", "results = job.get_result()\n", "results.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To resolve this, we can use the results map method and dual_rail_to_qubit function to convert all results into the qubit encoding. Once complete, it can be seen how the states measured are now the 3-qubit outputs expected from the system. " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "conv_results = results.map(lw.convert.dual_rail_to_qubit)\n", "conv_results.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Qiskit conversion\n", "To simplify the process of running gate-based systems on Artemis, a qiskit converter is included within Lightworks for the conversion of a qiskit QuantumCircuit into the Lightworks equivalent.\n", "\n", "This requires the importing of the qiskit module. This may need to be installed if not already completed - ``pip install lightworks[qiskit]`` can be used to ensure all the correct dependencies are installed." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "import qiskit" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then, a quantum circuit is built. In this case, we recreate the bell state circuit from above.\n", "\n", ".. note::\n", "There are some limitations as to what can be converted within Lightworks, and circuits which contain mid-circuit measurement of writing of data to classical bits are not currently compatible." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc = qiskit.QuantumCircuit(2)\n", "\n", "qc.h(0)\n", "qc.cx(0, 1)\n", "\n", "qc.draw(output=\"mpl\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This circuit is then converted using the qiskit converter, it can be seen how this produces the same circuit as the previous example. In this function there is an allow_post_selection option which controls whether to allow post-selected versions of gates where possible (rather than just heralding). This defaults to False, but we recommend setting to True in most-cases as post-selected gates tend to have lower resource requirements - the converter uses an algorithm to ensure post-selection is only used where possible. When this option is True, a PostSelection object is returned by the conversion function which needs to be supplied on configuration of the Sampler.\n", "\n", ".. note::\n", "Some care needs to be taken if this circuit is modified further within Lightworks, as any other two-qubit gates will break the post-selection and cause significant errors. If intending to modify then use ``allow_post_selection=False``." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-\n", "0\n", "1\n", "2\n", "3\n", "-\n", "\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CNOT (0, 1)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "\n", "\n", "\n", "0\n", "\n", "\n", "\n", "0\n", "\n", "\n", "\n", "0\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "circuit, post_selection = qubit.qiskit_converter(qc, allow_post_selection=True)\n", "\n", "circuit.display()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The sampler is then created and the job run on the target QPU." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "sampler = lw.Sampler(circuit, in_state, 10000, post_selection=post_selection)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "job = qpu.run(sampler)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once complete, again the results are downloaded, and then the results re-mapped and plotted." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "job.wait_until_complete()\n", "\n", "results = job.get_result()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This produces a set of results which should look similar to the previous run in which qiskit conversion was not used." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "conv_results = results.map(lw.convert.dual_rail_to_qubit)\n", "conv_results.plot()" ] } ], "metadata": { "kernelspec": { "display_name": "venv", "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.11.6" } }, "nbformat": 4, "nbformat_minor": 2 }