diff --git a/docs/tutorials/pasqal/getting_started.ipynb b/docs/tutorials/pasqal/getting_started.ipynb index 6b4b5a9e103..e0e9e675072 100644 --- a/docs/tutorials/pasqal/getting_started.ipynb +++ b/docs/tutorials/pasqal/getting_started.ipynb @@ -75,7 +75,8 @@ "except ImportError:\n", " print(\"installing cirq...\")\n", " !pip install --quiet cirq\n", - " print(\"installed cirq.\")" + " print(\"installed cirq.\")\n", + " import cirq" ] }, { @@ -86,7 +87,7 @@ "source": [ "\n", "\n", - "In this notebook, we show how to program a quantum circuit for Pasqal using cirq. The first step is to import cirq, and Pasqal custom classes. We use ``PasqalVirtualDevice`` to showcase how Cirq enforces Pasqal's devices' restrictions throughout the process (note that unconstrained circuit generation is also supported through the ``PasqalDevice`` class)." + "In this notebook, we show how to program a quantum circuit for Pasqal using cirq. The first step is to import cirq, and Pasqal custom classes. We use ``PasqalVirtualDevice`` to showcase how Cirq enforces Pasqal's devices' restrictions throughout the process." ] }, { @@ -97,8 +98,6 @@ }, "outputs": [], "source": [ - "import cirq\n", - "from cirq import ops\n", "from cirq_pasqal import ThreeDQubit, TwoDQubit, PasqalVirtualDevice, PasqalNoiseModel" ] }, @@ -110,11 +109,11 @@ "source": [ "## Create an array of qubits on a lattice\n", "\n", - "The QPU of Pasqal is made of neutral atoms controlled by lasers. Individual atoms are trapped at well-defined positions in 1, 2 or even 3D, as shown on the following plot (Nature 561, 79 (2018)).\n", + "The QPU of Pasqal is made of neutral atoms controlled by lasers. Individual atoms are trapped at well-defined positions in 1, 2 or even 3D, as shown on the following plot ( [Nature 561, 79 (2018)](https://www.nature.com/articles/s41586-018-0450-2)).\n", "\n", "\n", "\n", - "We created a custom class in cirq, ThreeDQubit, that corresponds to a qubit placed in 3D space. Let us start by creating a register comprising $36=6\\times6$ qubits in 2D, regularly arranged on a square lattice. It corresponds to the following configuration (image taken from Nature 561, 79 (2018))\n", + "We created a custom class in cirq, ThreeDQubit, that corresponds to a qubit placed in 3D space. Let us start by creating a register comprising $36=6\\times6$ qubits in 2D, regularly arranged on a square lattice. It corresponds to the following configuration (image taken from [Nature 561, 79 (2018)](https://www.nature.com/articles/s41586-018-0450-2))\n", "\n", "" ] @@ -131,10 +130,10 @@ "height=6\n", "depth=1\n", "# Creating p_qubits, a list of ThreeDQubits.\n", - "p_qubits=[ThreeDQubit(row, col, lay) \n", + "p_qubits=[ThreeDQubit(row, col, layer) \n", " for row in range(width) \n", " for col in range(height)\n", - " for lay in range(depth)]" + " for layer in range(depth)]" ] }, { @@ -143,11 +142,18 @@ "id": "0c70e0cd44b6" }, "source": [ - "Notice how we are fixing `depth=1` to keep all qubits in the $z=0$ plane. The same can also be achieved by using the `TwoDQubit` class, which is nothing more than a `ThreeDQubit` confined to the `z=0` plane. We can create the same $6 x 6$ square array, this time using one of the built-in methods:\n", - "\n", - "```\n", - "p_qubits = TwoDQubit.square(6) # 6x6 square array of TwoDQubits\n", - "```" + "Notice how we are fixing `depth=1` to keep all qubits in the $z=0$ plane. The same can also be achieved by using the `TwoDQubit` class, which is nothing more than a `ThreeDQubit` confined to the `z=0` plane. We can create the same $6 x 6$ square array, this time using one of the built-in methods:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YPyeqF3EReB2" + }, + "outputs": [], + "source": [ + "p_qubits = TwoDQubit.square(6) # 6x6 square array of TwoDQubits" ] }, { @@ -158,9 +164,9 @@ "source": [ "## Create a PasqalDevice\n", "\n", - "Multi-qubit gates can be applied between qubits in the device, provided that the distance between them is smaller than the so-called Rydberg blocade radius (or control radius), that can be passed as a parameter of the device (in units of the lattice size). Here, we instantiate a ``PasqalVirtualDevice`` with 36 qubits and a control radius of $2.1$. \n", + "Multi-qubit gates can be applied between qubits in the device, provided that the distance between them is smaller than the so-called Rydberg blocade radius (or control radius), that can be passed as a parameter of the device (in units of the lattice size). Here, we instantiate a `PasqalVirtualDevice` with 36 qubits and a control radius of $2.1$. \n", "\n", - "Using the ``Circuit`` class of Cirq, one can then build a circuit that will be implemented with a ``PasqalVirtualDevice`` as a backend." + "This `PasqalVirtualDevice` can be used to validate the operations within a `Circuit`." ] }, { @@ -171,16 +177,23 @@ }, "outputs": [], "source": [ + "from cirq_pasqal.pasqal_device import PasqalConverter\n", + "\n", + "# Initialize and create a circuit\n", + "initial_circuit = cirq.Circuit()\n", + "initial_circuit.append(cirq.CZ(p_qubits[0], p_qubits[1]))\n", + "initial_circuit.append(cirq.Z(p_qubits[0]))\n", + "initial_circuit.append(cirq.CX(p_qubits[0], p_qubits[2]))\n", + "\n", "# Create a Pasqal device with a control radius of 2.1 (in units of the lattice spacing)\n", "p_device=PasqalVirtualDevice(control_radius=2.1, qubits=p_qubits)\n", "\n", - "# Initialize a circuit, specifying the device\n", - "p_circuit = cirq.Circuit(device=p_device)\n", - "\n", - "# Create the circuit\n", - "p_circuit.append(cirq.CZ(p_qubits[0], p_qubits[1]))\n", - "p_circuit.append(cirq.Z(p_qubits[0]))\n", - "p_circuit.append(cirq.CX(p_qubits[0], p_qubits[2]))" + "# Validate the circuit using the device\n", + "try:\n", + " p_device.validate_circuit(initial_circuit)\n", + "except ValueError as e:\n", + " # Uh oh! This circuit does not pass validation.\n", + " print(e)" ] }, { @@ -189,30 +202,30 @@ "id": "aa25f2e644ce" }, "source": [ - "Notice how, by declaring the device at the beginning, all non-native gates are automatically decomposed and each moment forced to have a single gate." + "Notice that the `CX` gate, also called a `CNOT` gate is not valid on this device. We can use a `PasqalConverter` object to convert it.\n", + "\n", + "This will convert the logical gates into native hardware gates. When inserting into circuits designed for Pasqal devices, be sure to insert each operation into its own `Moment` (for example, using `cirq.InsertStrategy.NEW`)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "id": "dc88c397a982" + "id": "1JbgjTVzZg6u" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(0, 0, 0): ───@───Z───────────────────@──────────────────\n", - " │ │\n", - "(0, 1, 0): ───@───────────────────────┼──────────────────\n", - " │\n", - "(0, 2, 0): ───────────PhX(-0.5)^0.5───@───PhX(0.5)^0.5───\n" - ] - } - ], + "outputs": [], "source": [ - "print(p_circuit)" + "from cirq.circuits import insert_strategy\n", + "converter = PasqalConverter()\n", + "\n", + "pasqal_circuit=cirq.Circuit(*[converter.pasqal_convert(op, keep=p_device.is_pasqal_device_op)\n", + " for op in initial_circuit.all_operations()],\n", + " strategy=cirq.InsertStrategy.NEW)\n", + "\n", + "print(pasqal_circuit)\n", + "\n", + "# Now the circuit validates correctly!\n", + "p_device.validate_circuit(pasqal_circuit)\n" ] }, { @@ -232,19 +245,11 @@ "metadata": { "id": "25d50548ab09" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ERROR: Qubits pasqal.ThreeDQubit(0, 0, 0), pasqal.ThreeDQubit(5, 5, 0) are too far away\n" - ] - } - ], + "outputs": [], "source": [ "# It is impossible to add a multi-qubit gate if the qubits involved are too far away\n", "try:\n", - " p_circuit.append(cirq.CZ(p_qubits[0], p_qubits[-1]))\n", + " p_device.validate_operation(cirq.CZ(p_qubits[0], p_qubits[-1]))\n", "except ValueError as msg:\n", " print(\"ERROR:\", msg)\n", "else:\n", @@ -314,8 +319,15 @@ " yield oracle()\n", " yield grover_operator()\n", " \n", + "def generate_pasqal_grover():\n", + " return cirq.Circuit(\n", + " *[converter.pasqal_convert(op, keep=p_device.is_pasqal_device_op)\n", + " for op in generate_grover()],\n", + " strategy=cirq.InsertStrategy.NEW)\n", + " \n", "device = PasqalVirtualDevice(control_radius=1.1, qubits=qs) \n", - "grover_circuit = cirq.Circuit(generate_grover(), device=device)\n", + "grover_circuit = generate_pasqal_grover()\n", + "device.validate_circuit(grover_circuit)\n", "grover_circuit.append(cirq.measure(*q_meas, key='x'))" ] }, @@ -347,18 +359,7 @@ "id": "70151da8a002" }, "source": [ - "Alternatively, small circuits can also be simullated locally using Cirq's `Simulator`, which we will do here. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "62cf1663781b" - }, - "outputs": [], - "source": [ - "sampler = cirq.Simulator()" + "Alternatively, small circuits can also be simulated locally using Cirq's `Simulator`, which we will do here. " ] }, { @@ -369,6 +370,7 @@ }, "outputs": [], "source": [ + "sampler = cirq.Simulator()\n", "data_raw = sampler.run(grover_circuit, repetitions=200)" ] }, @@ -387,24 +389,11 @@ "metadata": { "id": "ab8f82fc985a" }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light", - "tags": [] - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", + "# Create dictionary of results\n", "data0 = data_raw.data.to_dict()\n", "vec=[j for j in range(4)]\n", "res=np.zeros(len(vec))\n", @@ -413,6 +402,7 @@ " res[number] += 1\n", "res=res/200.\n", "\n", + "# Display plot of states\n", "fig = plt.figure()\n", "ax = fig.add_axes([0.16, 0.16, 0.78, 0.78])\n", "ax.plot(vec, res,'o')\n", @@ -449,25 +439,11 @@ "metadata": { "id": "675a72331dca" }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light", - "tags": [] - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Use the custom noise model of Pasqal devices\n", "noise_model = PasqalNoiseModel(device)\n", - "grover_circuit = cirq.Circuit(generate_grover(), device=device)\n", + "grover_circuit = generate_pasqal_grover()\n", "grover_circuit = grover_circuit.with_noise(noise_model)\n", "grover_circuit.append(cirq.measure(*q_meas, key='x'))\n", "\n",