From d30d02e689c22f413a9adc8fe90022b5d4799359 Mon Sep 17 00:00:00 2001 From: v-vitale Date: Fri, 4 Sep 2026 09:57:00 +0200 Subject: [PATCH] Exercise 4 and solution to Exercise 3 --- .../module4_capstone_qubo_EXERCISES.ipynb | 399 +++++++++++++ ...ule3_compilation_execution_SOLUTIONS.ipynb | 524 ++++++++++++++++++ 2 files changed, 923 insertions(+) create mode 100644 exercises/module4_capstone_qubo_EXERCISES.ipynb create mode 100644 solutions/module3_compilation_execution_SOLUTIONS.ipynb diff --git a/exercises/module4_capstone_qubo_EXERCISES.ipynb b/exercises/module4_capstone_qubo_EXERCISES.ipynb new file mode 100644 index 0000000..15d7001 --- /dev/null +++ b/exercises/module4_capstone_qubo_EXERCISES.ipynb @@ -0,0 +1,399 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e6824407", + "metadata": {}, + "source": [ + "# QoolQit Exercises — Module 4 (Capstone)\n", + "## Putting it all together: solving a QUBO problem\n", + "\n", + "Time to assemble everything from Modules 1–3 into a complete application:\n", + "solving a **QUBO** (Quadratic Unconstrained Binary Optimization) problem on a\n", + "neutral-atom quantum computer. Every step of the pipeline is one exercise —\n", + "each uses a tool you already practiced:\n", + "\n", + "```\n", + "QUBO matrix ──▶ classical baseline (NumPy)\n", + " │\n", + " ▶ DataGraph.from_matrix (Module 1)\n", + " ▶ InteractionEmbedder (Module 1)\n", + " ▶ Register.from_graph (Module 2)\n", + " ▶ annealing Drive (Module 2)\n", + " ▶ QuantumProgram + compile_to (Modules 2–3)\n", + " ▶ LocalEmulator + histogram (Module 3)\n", + "```\n", + "\n", + "\n", + "> **How to use this notebook.** \n", + "> - Cells marked **✏️ Exercise** contain gaps\n", + "> indicated by `...` or `# TODO` — replace them with working code following\n", + "> the instructions. \n", + "> - Cells marked **✅ Check** verify your answer: run them\n", + "> after completing the exercise. Everything else is provided and runs as-is.\n", + "> A separate **solution notebook** will be published.\n", + ">\n", + "> **API note:** we use qoolqit version 1.4" + ] + }, + { + "cell_type": "markdown", + "id": "17dd00c7", + "metadata": {}, + "source": [ + "## 1. The problem\n", + "\n", + "A QUBO instance on $N$ variables is a symmetric $N\\times N$ matrix $Q$.\n", + "Solving it means finding the bitstring $z \\in \\{0,1\\}^N$ minimizing\n", + "\n", + "$$\n", + "f(z) = z^TQz= \\sum_i Q_{ii} z_i + \\sum_{i2 and\n", + "# 3<->4 simultaneously leaves Q invariant and maps one optimum to the other.)" + ] + }, + { + "cell_type": "markdown", + "id": "d75ea118", + "metadata": {}, + "source": [ + "### ✏️ Exercise 4.2 — Load and embed the problem *(Module 1 tools)*\n", + "\n", + "1. Since the QUBO is **scale invariant**, normalize it: `Q = Q / Q.max()`\n", + " (this matches the embedder's convention $\\max \\tilde J = 1$ and\n", + " simplifies the drive design).\n", + "2. *(Optional but instructive)* Build `DataGraph.from_matrix(Q.copy())` and\n", + " draw it — the QUBO *is* a weighted graph.\n", + "3. Embed the matrix with an `InteractionEmbedder` into `embedded_graph`,\n", + " draw it, and print each realized interaction next to its target `Q[i, j]`.\n", + " The large couplings should match closely; exact zeros can only be\n", + " approximated (atoms at finite distance always interact a little)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d138668e", + "metadata": {}, + "outputs": [], + "source": [ + "from qoolqit import DataGraph\n", + "\n", + "# TODO 1: normalize the QUBO (scale invariance)\n", + "Q = ...\n", + "\n", + "# TODO 2 (optional): the QUBO as a weighted graph\n", + "graph = DataGraph.from_matrix(Q.copy())\n", + "graph.draw()\n", + "\n", + "# TODO 3: embed the interaction matrix\n", + "embedded_graph = ...\n", + "embedded_graph.draw()\n", + "\n", + "for (i, j), J in embedded_graph.interactions().items():\n", + " print(f\"pair ({i},{j}): J = {J:.4f} target Q = {Q[i, j]:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9f8199ff", + "metadata": {}, + "source": [ + "### ✏️ Exercise 4.3 — Register and annealing Drive *(Module 2 tools)*\n", + "\n", + "1. Build the register directly from the embedded graph:\n", + " `Register.from_graph(embedded_graph)`.\n", + "2. Choose the annealing parameters:\n", + " - `omega`: the **median** of the strictly positive entries of `Q`\n", + " (a good handwavy value for the peak amplitude);\n", + " - `delta_i = -1.0` (initial detuning: with $\\Omega=0$ and $\\delta<0$,\n", + " $|0\\rangle^{\\otimes N}$ is the unique ground state);\n", + " - `delta_f = -np.diag(Q)[0]` (final detuning matching the QUBO diagonal\n", + " under $Q_{ii} \\leftrightarrow -\\delta_i$; all diagonal entries are\n", + " equal here).\n", + "3. Build the schedule with `T = 40` (safely adiabatic, $\\tilde t \\gg 1$):\n", + " a trapezoidal `PiecewiseLinearWaveform` amplitude\n", + " ($0 \\to \\omega \\to \\omega \\to 0$ over $[T/4, T/2, T/4]$ — exactly\n", + " Exercise 2.2!) and a `RampWaveform` detuning from `delta_i` to `delta_f`.\n", + "4. Assemble the `Drive` and `draw()` it: check the boundary conditions of the\n", + " annealing protocol at $t=0$ and $t=T$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "888008b9", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO 1: the register from the embedded graph\n", + "register = ...\n", + "\n", + "# TODO 2: annealing parameters\n", + "omega = ...\n", + "delta_i = ...\n", + "delta_f = ...\n", + "\n", + "# TODO 3: annealing schedule\n", + "T = 40\n", + "wf_amp = ...\n", + "wf_det = ...\n", + "\n", + "# TODO 4: the drive\n", + "drive = ...\n", + "drive.draw()" + ] + }, + { + "cell_type": "markdown", + "id": "63e7a867", + "metadata": {}, + "source": [ + "### ✏️ Exercise 4.4 — Program, compilation and execution *(Module 3 tools)*\n", + "\n", + "1. Assemble the `QuantumProgram` and compile it to an `AnalogDevice()`.\n", + "2. Run it on a `LocalEmulator` and store the measured\n", + " `results.final_bitstrings` in `counts`.\n", + "3. Print the five most common bitstrings (`counts.most_common(5)`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77dd3eb6", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: assemble and compile\n", + "program = ...\n", + "program.compile_to(device=..., profile=\"max_energy\")\n", + "\n", + "# TODO: run and collect counts\n", + "emulator = ...\n", + "counts = ...\n", + "\n", + "print(counts.most_common(5))" + ] + }, + { + "cell_type": "markdown", + "id": "da8d6c7b", + "metadata": {}, + "source": [ + "### Plotting helper (provided)\n", + "\n", + "Histogram of the sampled bitstrings; the classical optima from Exercise 4.1\n", + "are highlighted in **green**. Run as-is." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fa23740", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import Counter\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def plot_distribution(counter, solutions, bins=10):\n", + " \"\"\"Histogram of sampled bitstrings; known optimal `solutions` in green.\"\"\"\n", + " counter = Counter(counter)\n", + " counter = dict(counter.most_common(bins))\n", + " color = [\n", + " \"tab:green\" if key in solutions.tolist() else \"tab:blue\" for key in counter\n", + " ]\n", + " _, ax = plt.subplots()\n", + " ax.set_xlabel(\"Bitstrings\")\n", + " ax.set_ylabel(\"Counts\")\n", + " ax.bar(\n", + " range(len(counter)), counter.values(), color=color, tick_label=counter.keys()\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "e5e4ed4b", + "metadata": {}, + "source": [ + "### ✏️ Exercise 4.5 — Analyze… and improve!\n", + "\n", + "1. Plot the distribution with the optima highlighted. **Look carefully**: the\n", + " green bars are high, but is the *top* bar green? With this schedule the\n", + " evolution is not adiabatic enough, and a suboptimal bitstring can win.\n", + "2. Now use the trick from the tutorial: recompile with\n", + " `device_max_duration_ratio=1`, stretching the schedule to the device's\n", + " **maximum allowed duration** (slower ⇒ more adiabatic). Re-run and plot\n", + " again. The optima should now dominate clearly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5686356d", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO 1: plot the first result\n", + "plot_distribution(..., ...)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10987e66", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO 2: recompile stretched to the device's maximum duration, re-run, re-plot\n", + "program.compile_to(device=..., profile=\"max_energy\", device_max_duration_ratio=...)\n", + "counts_slow = ...\n", + "plot_distribution(..., ...)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da80ea6e", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check — the two most sampled bitstrings are the classical optima\n", + "top2 = {b for b, _ in counts_slow.most_common(2)}\n", + "assert top2 == set(first_two_best_solutions), f\"Top-2 sampled {top2} != optima\"\n", + "print(\"🎉 QUBO solved: the classical optima are the most sampled bitstrings!\")" + ] + }, + { + "cell_type": "markdown", + "id": "b74c6661", + "metadata": {}, + "source": [ + "## Going further\n", + "\n", + "**Ideas to explore**\n", + "- Generate your own QUBO from a geometry (place atoms, compute $1/r^6$\n", + " couplings, add a diagonal) and check the pipeline solves it.\n", + "- Shorten `T` and watch the solution quality degrade — quantify adiabaticity.\n", + "- Trigger the two classic `CompilationError`s from Module 3 with this\n", + " register (amplitude too large; register too big).\n", + "\n", + "## 🎓 Congratulations!\n", + "\n", + "You built a complete neutral-atom application from first principles:\n", + "**graphs → embedding → register → drive → program → compilation → execution\n", + "→ verified quantum solution.** Every tool you used generalizes far beyond\n", + "QUBOs — happy experimenting with QoolQit!" + ] + }, + { + "cell_type": "markdown", + "id": "bf2d866c", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/solutions/module3_compilation_execution_SOLUTIONS.ipynb b/solutions/module3_compilation_execution_SOLUTIONS.ipynb new file mode 100644 index 0000000..bc48819 --- /dev/null +++ b/solutions/module3_compilation_execution_SOLUTIONS.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "solution-banner", + "metadata": {}, + "source": [ + "> **📗 SOLUTION NOTEBOOK — Module 3.** All exercise cells are completed and\n", + "> annotated. Every explanation cell is identical to the exercise notebook." + ] + }, + { + "cell_type": "markdown", + "id": "4168bf47", + "metadata": {}, + "source": [ + "# QoolQit Exercises — Module 3\n", + "## Compilation and Execution\n", + "\n", + "In Module 2 we assembled device-agnostic `QuantumProgram`s. This module makes\n", + "them run: we **compile** programs to devices with real physical constraints,\n", + "and **execute** them on an emulator. Along the way you will run your first\n", + "genuinely quantum experiments: a **π-pulse** and the **Rydberg blockade**.\n", + "\n", + "### In this module you will learn\n", + "- The built-in devices (`MockDevice`, `AnalogDevice`, ...) and their\n", + " constraints\n", + "- How `compile_to` adapts a dimensionless program to hardware limits\n", + "- How to run a compiled program on the `LocalEmulator` and read out the\n", + " measured bitstrings\n", + "- What a `CompilationError` means and how to reason about it" + ] + }, + { + "cell_type": "markdown", + "id": "a1a0339c", + "metadata": {}, + "source": [ + "## 1. Devices\n", + "\n", + "A `Device` bundles the physical constraints of a machine: maximum amplitude,\n", + "maximum sequence duration, minimum atom spacing, maximum radial distance.\n", + "QoolQit ships default devices you can use offline:\n", + "\n", + "- **`MockDevice`** — a *virtual* device with (almost) no constraints, for\n", + " unconstrained prototyping;\n", + "- **`AnalogDevice`** — a *realistic* analog device;\n", + "- **`AnalogDeviceWithDMM`**, **`DigitalAnalogDevice`** — variants with extra\n", + " capabilities.\n", + "\n", + "Real remote devices (e.g. Pasqal's FRESNEL) can be fetched with\n", + "`Device.from_connection(connection=PasqalCloud(), name=\"FRESNEL\")` — same\n", + "interface, specs downloaded from the cloud." + ] + }, + { + "cell_type": "markdown", + "id": "cba9bf8e", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.1 — Meet the devices\n", + "\n", + "1. Call `available_default_devices()` (imported from `qoolqit`) to list the\n", + " built-in devices and their constraints.\n", + "2. Instantiate `device = AnalogDevice()` and print it.\n", + "3. Read the printout and note down (mentally or in a comment): its\n", + " **max_duration**, **max_amplitude** and **max_radial_distance**. Compare\n", + " with `MockDevice()` — what is different?" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7e3954d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnalogDevice: A realistic device for analog sequence execution.\n", + " └── max_duration: 332.43763968\n", + " └── max_amplitude: 0.22680411206965717\n", + " └── max_abs_detuning: 2.268041120696572\n", + " └── min_distance: 1.0\n", + " └── max_radial_distance: 7.6\n", + "\n", + "AnalogDeviceWithDMM: \n", + " └── max_duration: 332.43763968\n", + " └── max_amplitude: 0.22680411206965717\n", + " └── max_abs_detuning: 2.268041120696572\n", + " └── min_distance: 1.0\n", + " └── max_radial_distance: 7.6\n", + "\n", + "MockDevice: A virtual device for unconstrained prototyping.\n", + " └── max_duration: None\n", + " └── max_amplitude: None\n", + " └── max_abs_detuning: None\n", + " └── min_distance: 0.0\n", + " └── max_radial_distance: None\n", + "\n", + "AnalogDevice: A realistic device for analog sequence execution.\n", + " └── max_duration: 332.43763968\n", + " └── max_amplitude: 0.22680411206965717\n", + " └── max_abs_detuning: 2.268041120696572\n", + " └── min_distance: 1.0\n", + " └── max_radial_distance: 7.6\n", + "\n", + "MockDevice: A virtual device for unconstrained prototyping.\n", + " └── max_duration: None\n", + " └── max_amplitude: None\n", + " └── max_abs_detuning: None\n", + " └── min_distance: 0.0\n", + " └── max_radial_distance: None\n", + "\n" + ] + } + ], + "source": [ + "from qoolqit import AnalogDevice, MockDevice, available_default_devices\n", + "\n", + "available_default_devices()\n", + "\n", + "device = AnalogDevice()\n", + "print(device)\n", + "\n", + "print(MockDevice())\n", + "\n", + "# AnalogDevice has finite max_duration, max_amplitude and max_radial_distance.\n", + "# MockDevice has None for all of them: it accepts (almost) anything, which is\n", + "# useful for prototyping but tells you nothing about hardware feasibility." + ] + }, + { + "cell_type": "markdown", + "id": "22037080", + "metadata": {}, + "source": [ + "## 2. Compilation: your first physical experiment, the π-pulse\n", + "\n", + "Compilation translates the dimensionless program into a concrete pulse\n", + "sequence in physical units, rescaling amplitude, duration and atom spacing to\n", + "fit the device (by default with the `MAX_ENERGY` profile, which uses the\n", + "device's maximum capabilities while preserving the program's ratios).\n", + "\n", + "**The experiment.** Drive a *single atom* with a constant amplitude\n", + "$\\Omega$ and zero detuning. The atom oscillates between $|0\\rangle$ and\n", + "$|1\\rangle$ (*Rabi oscillation*), and is fully flipped to $|1\\rangle$ when\n", + "\n", + "$$\n", + "\\Omega \\cdot t = \\pi \\qquad \\text{(a \"π-pulse\")}.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "19943521", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.2 — Compile a π-pulse\n", + "\n", + "1. Build a **single-atom** register at the origin.\n", + "2. Build a drive with a `ConstantWaveform` amplitude of value `1.0` and a\n", + " duration realizing a π-pulse. No detuning needed.\n", + "3. Assemble the program, compile it to the `AnalogDevice` with\n", + " `program.compile_to(device=..., profile=\"max_energy\")`, check `is_compiled`, and draw the\n", + " compiled sequence with `program.draw(compiled=True)`.\n", + "\n", + "Note the units in the drawing: compilation has translated dimensionless time\n", + "and amplitude into nanoseconds and rad/µs." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fbafe7f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compiled? True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from qoolqit import ConstantWaveform, Drive, QuantumProgram, Register\n", + "\n", + "register_1atom = Register.from_coordinates([(0.0, 0.0)])\n", + "\n", + "# A pi-pulse requires Omega * t = pi. With Omega = 1.0 -> t = pi.\n", + "pi_pulse = ConstantWaveform(np.pi, 1.0)\n", + "drive_pi = Drive(amplitude=pi_pulse)\n", + "\n", + "program_pi = QuantumProgram(register_1atom, drive_pi)\n", + "program_pi.compile_to(device=device, profile=\"max_energy\")\n", + "print(\"Compiled?\", program_pi.is_compiled)\n", + "program_pi.draw(compiled=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "39a2adba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "π-pulse compiled!\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert program_pi.is_compiled\n", + "assert abs(drive_pi.duration - np.pi) < 1e-9\n", + "print(\"π-pulse compiled!\")" + ] + }, + { + "cell_type": "markdown", + "id": "d3483f79", + "metadata": {}, + "source": [ + "## 3. Execution on the LocalEmulator\n", + "\n", + "Executing follows a simple, backend-independent workflow:\n", + "\n", + "```\n", + "emulator = LocalEmulator() # from qoolqit.execution\n", + "job = emulator.run(program)\n", + "results = job.results()\n", + "counts = results.final_bitstrings # a Counter of measured bitstrings\n", + "```\n", + "\n", + "Remote backends (`RemoteEmulator`, `QPU`) expose exactly the same `run` /\n", + "`results` interface — only the construction differs (they need a cloud\n", + "connection)." + ] + }, + { + "cell_type": "markdown", + "id": "b748f67f", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.3 — Run the π-pulse\n", + "\n", + "Run `program_pi` on a `LocalEmulator` and print the measured bitstring\n", + "counts. If your pulse is a true π-pulse, (almost) **all shots should return**\n", + "`'1'` — the atom is deterministically flipped." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "72154f94", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({'1': 1000})\n" + ] + } + ], + "source": [ + "from qoolqit.execution import LocalEmulator\n", + "\n", + "emulator = LocalEmulator()\n", + "job = emulator.run(program_pi)\n", + "results = job.results()\n", + "counts = results.final_bitstrings\n", + "\n", + "print(counts)\n", + "\n", + "# Virtually all shots return '1': the pi-pulse flips |0> to |1>." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e5a587bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "π-pulse verified: 1000/1000 shots measured '1'.\n" + ] + } + ], + "source": [ + "# ✅ Check — at least 95% of shots in '1'\n", + "total = sum(counts.values())\n", + "assert counts.get(\"1\", 0) / total > 0.95, \"Expected (almost) all shots in '1'\"\n", + "print(f\"π-pulse verified: {counts.get('1', 0)}/{total} shots measured '1'.\")" + ] + }, + { + "cell_type": "markdown", + "id": "f9c4e178", + "metadata": {}, + "source": [ + "## 4. A two-atom experiment: the Rydberg blockade\n", + "\n", + "Now the same π-pulse on **two atoms**. The interaction $J = 1/r^6$ changes\n", + "everything:\n", + "\n", + "- **Far apart** ($J \\ll \\Omega$): the atoms don't feel each other and are\n", + " *independently* flipped → you measure `'11'`.\n", + "- **Close together** ($J \\gg \\Omega$): exciting *both* atoms costs a huge\n", + " interaction energy, so the doubly-excited state is **blockaded** → `'11'`\n", + " is (almost) never measured. This *Rydberg blockade* is the fundamental\n", + " mechanism behind unit-disk connectivity (Module 1) and neutral-atom\n", + " entanglement." + ] + }, + { + "cell_type": "markdown", + "id": "cc51d1ec", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.4 — Observe the blockade\n", + "\n", + "1. `register_far`: two atoms at distance **3.0** (so $J = 1/3^6 \\approx\n", + " 0.0014 \\ll 1$). Apply the same π-pulse drive, compile to the\n", + " `AnalogDevice`, run, and print the counts.\n", + "2. `register_close`: two atoms at distance **0.7** (so $J = 1/0.7^6 \\approx\n", + " 8.5 \\gg 1$). Same pulse, compile, run, print.\n", + "3. Compare the frequency of `'11'` in the two cases. Blockade in action!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8d5ff774", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "far (r=3.0): Counter({'11': 1000})\n", + "close(r=0.7): Counter({'00': 383, '01': 307, '10': 305, '11': 5})\n" + ] + } + ], + "source": [ + "register_far = Register.from_coordinates([(0.0, 0.0), (3.0, 0.0)])\n", + "program_far = QuantumProgram(register_far, Drive(amplitude=pi_pulse))\n", + "program_far.compile_to(device=device, profile=\"max_energy\")\n", + "counts_far = emulator.run(program_far).results().final_bitstrings\n", + "print(\"far (r=3.0):\", counts_far)\n", + "\n", + "register_close = Register.from_coordinates([(0.0, 0.0), (0.7, 0.0)])\n", + "program_close = QuantumProgram(register_close, Drive(amplitude=pi_pulse))\n", + "program_close.compile_to(device=device, profile=\"max_energy\")\n", + "counts_close = emulator.run(program_close).results().final_bitstrings\n", + "print(\"close(r=0.7):\", counts_close)\n", + "\n", + "# Far atoms: '11' dominates (both flipped independently).\n", + "# Close atoms: '11' is strongly suppressed — the Rydberg blockade forbids\n", + "# the doubly excited state; the atoms share a single excitation instead." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d4ed1447", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rydberg blockade observed!\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "tot_far = sum(counts_far.values())\n", + "tot_close = sum(counts_close.values())\n", + "assert counts_far.get(\"11\", 0) / tot_far > 0.9, (\n", + " \"Far atoms should (almost) always give '11'\"\n", + ")\n", + "assert counts_close.get(\"11\", 0) / tot_close < 0.05, (\n", + " \"Close atoms should (almost) never give '11'\"\n", + ")\n", + "print(\"Rydberg blockade observed!\")" + ] + }, + { + "cell_type": "markdown", + "id": "cd39b586", + "metadata": {}, + "source": [ + "## 5. When compilation fails: `CompilationError`\n", + "\n", + "Compilation rescales amplitude, duration and spacing *together* to fit the\n", + "device. Sometimes no consistent rescaling exists — e.g. bringing a large\n", + "amplitude down to the device maximum stretches the duration beyond the device\n", + "limit. QoolQit then raises a **`CompilationError`** with a message explaining\n", + "which constraint broke." + ] + }, + { + "cell_type": "markdown", + "id": "d3e0cabd", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.5 — Trigger and read a CompilationError\n", + "\n", + "1. Build `program_bad`: the **close** two-atom register with a\n", + " `ConstantWaveform(400, 1.0)` amplitude — a very long pulse.\n", + "2. Try to compile it to the `AnalogDevice` inside a\n", + " `try/except CompilationError` block (import it from `qoolqit.exceptions`)\n", + " and print the message. Read it: which device limit was violated?\n", + "3. Now compile the **same** program to a `MockDevice()` — it succeeds! Why is\n", + " that both useful and dangerous?" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1166e97c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CompilationError: After rescaling the input program to the maximum energy scale available for the selected device, the following exception was raised:\n", + "\n", + "The drive's duration went over the maximum value allowed.\n", + "To compile this program on the selected device `AnalogDevice`, set the drive's duration below 39.11095587071232\n", + "Compiled on MockDevice? True\n" + ] + } + ], + "source": [ + "from qoolqit.exceptions import CompilationError\n", + "\n", + "program_bad = QuantumProgram(\n", + " register_close, Drive(amplitude=ConstantWaveform(400, 1.0))\n", + ")\n", + "\n", + "try:\n", + " program_bad.compile_to(device=device, profile=\"max_energy\")\n", + "except CompilationError as err:\n", + " print(\"CompilationError:\", err)\n", + "\n", + "program_bad.compile_to(device=MockDevice(), profile=\"max_energy\")\n", + "print(\"Compiled on MockDevice?\", program_bad.is_compiled)\n", + "\n", + "# Rescaling the amplitude to the device maximum stretches the duration\n", + "# beyond AnalogDevice's max_duration -> CompilationError.\n", + "# MockDevice has no limits: great for prototyping algorithms, but it gives\n", + "# no guarantee the program can ever run on real hardware." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b890980", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46b946df", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ddd41ce", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}