From 0d9f3c9772639b5d659f8499a50ef5f5f4a9f8ea Mon Sep 17 00:00:00 2001 From: Anton Quelle Date: Thu, 27 Aug 2026 09:50:05 +0200 Subject: [PATCH] exercise 2 and solutions for ex 1 --- ...le2_register_drive_program_EXERCISES.ipynb | 309 ++++++++++++++ .../module1_graphs_embedding_SOLUTIONS.ipynb | 396 ++++++++++++++++++ 2 files changed, 705 insertions(+) create mode 100644 exercises/module2_register_drive_program_EXERCISES.ipynb create mode 100644 solutions/module1_graphs_embedding_SOLUTIONS.ipynb diff --git a/exercises/module2_register_drive_program_EXERCISES.ipynb b/exercises/module2_register_drive_program_EXERCISES.ipynb new file mode 100644 index 0000000..0746bb0 --- /dev/null +++ b/exercises/module2_register_drive_program_EXERCISES.ipynb @@ -0,0 +1,309 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8454d054", + "metadata": {}, + "source": [ + "# QoolQit Exercises — Module 2\n", + "## Register, Drive and Quantum Programs\n", + "\n", + "In Module 1 we learned how to describe geometry with graphs. This module\n", + "introduces the three objects that define a computation in the Rydberg analog\n", + "model:\n", + "\n", + "- the **`Register`** — *where the atoms are*;\n", + "- the **`Drive`** — *what we do to them over time* (laser amplitude, detuning\n", + " and phase);\n", + "- the **`QuantumProgram`** — the combination of the two.\n", + "\n", + "### In this module you will learn\n", + "- How to build a `Register` from coordinates or from a graph, and inspect its\n", + " distances and interactions\n", + "- The waveform classes (`ConstantWaveform`, `RampWaveform`,\n", + " `PiecewiseLinearWaveform`, ...) and their rules\n", + "- How to compose a `Drive` and what QoolQit validates for you\n", + "- How to assemble a `QuantumProgram`\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": "037e35be", + "metadata": {}, + "source": [ + "## 1. The Register\n", + "\n", + "A `Register` describes the layout of atoms loaded on the device. " + ] + }, + { + "cell_type": "markdown", + "id": "6af3af8d", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.1 — Build and inspect a Register\n", + "\n", + "1. Build `register`, a 3-atom register at coordinates\n", + " `(0, 0)`, `(1, 0)` and `(0.5, 0.9)` (a near-equilateral triangle).\n", + "2. Print `n_qubits` and draw it.\n", + "3. Print the pairwise `distances()` and `interactions()`.\n", + "4. **Sanity check the physics yourself**: for the pair `(0, 1)` at distance\n", + " $r = 1$, verify by hand that the printed interaction equals $1/r^6 = 1$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa9b16f7", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: build the 3-atom register\n", + "register = ...\n", + "\n", + "print(\"Number of qubits:\", ...)\n", + "register.draw()\n", + "\n", + "print(\"Distances: \", register.distances())\n", + "print(\"Interactions:\", register.interactions())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "576a962c", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check\n", + "assert register.n_qubits == 3\n", + "assert abs(register.interactions()[(0, 1)] - 1.0) < 1e-9\n", + "print(\"Register built correctly — J(0,1) = 1/r^6 = 1 as expected.\")" + ] + }, + { + "cell_type": "markdown", + "id": "7bef6f88", + "metadata": {}, + "source": [ + "## 2. Waveforms\n", + "\n", + "A `Drive` is built out of **waveforms** — functions of (dimensionless) time.\n", + "The main ones:\n", + "\n", + "| Class | Signature | Shape |\n", + "|-------|-----------|-------|\n", + "| `ConstantWaveform` | `(duration, value)` | flat |\n", + "| `RampWaveform` | `(duration, initial_value, final_value)` | linear ramp |\n", + "| `PiecewiseLinearWaveform` | `(durations, values)` | N connected ramps through N+1 values (**N ≥ 2**) |\n", + "\n", + "Two handy facts:\n", + "- waveforms can be **rescaled** by multiplication: `wf * 2.0`;\n", + "- every waveform has `.duration`, `.max()`, `.min()` and can be inspected\n", + " with `Drive(...).draw()` once inside a drive." + ] + }, + { + "cell_type": "markdown", + "id": "dc351eb2", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.2 — Build the classic annealing waveforms\n", + "\n", + "1. Build `wf_trap`: a `PiecewiseLinearWaveform` with total duration `T = 4`\n", + " that ramps `0 → 1` in the first quarter (`T/4`), stays at `1` for half\n", + " (`T/2`), and ramps back `1 → 0` in the last quarter (`T/4`) — a\n", + " *trapezoid*. Remember: **N durations, N+1 values**.\n", + "2. Build `wf_ramp`: a `RampWaveform` of duration `T` from `-1` to `+1`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "921f4e6c", + "metadata": {}, + "outputs": [], + "source": [ + "from qoolqit import PiecewiseLinearWaveform, RampWaveform\n", + "\n", + "T = 4\n", + "\n", + "# TODO: trapezoid 0 -> 1 -> 1 -> 0 over [T/4, T/2, T/4]\n", + "wf_trap = PiecewiseLinearWaveform([...], [...])\n", + "\n", + "# TODO: ramp from -1 to +1 over T\n", + "wf_ramp = ..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79198629", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check\n", + "assert abs(wf_trap.duration - 4.0) < 1e-9\n", + "assert abs(wf_trap.max() - 1.0) < 1e-9\n", + "assert wf_ramp.min() == -1.0 and wf_ramp.max() == 1.0\n", + "print(\"Waveforms built correctly!\")" + ] + }, + { + "cell_type": "markdown", + "id": "a66b0685", + "metadata": {}, + "source": [ + "## 3. The Drive\n", + "\n", + "The `Drive` collects the control parameters of the time-dependent Hamiltonian\n", + "\n", + "$$\n", + "H_{\\mathrm{drive}}(t) = \\sum_i \\frac{\\Omega(t)}{2}\\left(\\cos\\varphi\\,\\hat\\sigma^x_i - \\sin\\varphi\\,\\hat\\sigma^y_i\\right) - \\sum_i \\delta(t)\\, \\hat n_i\n", + "$$\n", + "\n", + "- **amplitude** $\\Omega(t)$ — the Rabi frequency driving the qubits\n", + " (*required*, must be $\\geq 0$ at all times);\n", + "- **detuning** $\\delta(t)$ — the energy offset of the Rydberg state\n", + " (*optional*, defaults to zero);\n", + "- **phase** $\\varphi$ — a global phase (*optional*, defaults to 0).\n", + "\n", + "All arguments are **keyword-only**: `Drive(amplitude=..., detuning=...)`." + ] + }, + { + "cell_type": "markdown", + "id": "055488be", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.3 — Compose a Drive (and let QoolQit catch your mistakes)\n", + "\n", + "1. Build `drive = Drive(amplitude=wf_trap, detuning=wf_ramp)` and `draw()` it.\n", + " Print its `duration`.\n", + "2. **Negative amplitude is unphysical**: in a `try/except ValueError`, try\n", + " `Drive(amplitude=RampWaveform(2.0, 0.5, -0.5))` and print the error.\n", + "3. **Drive compositions**: `Drive`s can be composed with `>>` to concatenate them." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "786ace14", + "metadata": {}, + "outputs": [], + "source": [ + "from qoolqit import Drive\n", + "\n", + "# TODO 1: define and draw the drive\n", + "drive = ...\n", + "drive.draw()\n", + "print(\"Drive duration:\", drive.duration)\n", + "\n", + "# TODO 2: negative amplitude must be rejected\n", + "try:\n", + " Drive(amplitude=RampWaveform(2.0, 0.5, -0.5))\n", + "except ValueError as err:\n", + " print(\"As expected:\", err)\n", + "\n", + "# TODO 3: create a `Drive` that repeats drive twice and draw it\n", + "double_drive = ...\n", + "double_drive.draw()\n", + "print(\"Drive duration:\", double_drive.duration)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6cf4e95e", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check\n", + "assert abs(drive.duration - 4.0) < 1e-9\n", + "assert abs(double_drive.duration - 8.0) < 1e-9\n", + "print(\"Drive composition rules understood!\")" + ] + }, + { + "cell_type": "markdown", + "id": "1c016719", + "metadata": {}, + "source": [ + "## 4. The QuantumProgram\n", + "\n", + "A `QuantumProgram` is simply *register + drive*: where the atoms are, and\n", + "what we do to them. It is created **device-agnostic** — in dimensionless\n", + "units, without reference to any hardware. Turning it into something a real\n", + "machine can run is the job of *compilation* (Module 3)." + ] + }, + { + "cell_type": "markdown", + "id": "efe5b8fd", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.4 — Assemble a QuantumProgram\n", + "\n", + "1. Build `program = QuantumProgram(register, drive)` from the register of\n", + " Exercise 2.1 and the drive of Exercise 2.3, and print it.\n", + "2. Print `program.is_compiled` — it should be `False`: no device yet!\n", + "3. Draw the (uncompiled) program with `program.draw()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2cfc9a6d", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: assemble the program\n", + "program = ...\n", + "print(program)\n", + "print(\"Compiled?\", ...)\n", + "program.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e6d8461", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check\n", + "assert not program.is_compiled\n", + "print(\"Program assembled — and correctly not compiled yet.\")" + ] + }, + { + "cell_type": "markdown", + "id": "4ae9cbb9", + "metadata": {}, + "source": [ + "### Next module\n", + "In **Module 3** we bring in the hardware: compiling programs to devices with\n", + "real constraints, and executing them on an emulator — including your first\n", + "genuinely quantum experiment, the **Rydberg blockade**." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/solutions/module1_graphs_embedding_SOLUTIONS.ipynb b/solutions/module1_graphs_embedding_SOLUTIONS.ipynb new file mode 100644 index 0000000..3b25d1f --- /dev/null +++ b/solutions/module1_graphs_embedding_SOLUTIONS.ipynb @@ -0,0 +1,396 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "solution-banner", + "metadata": {}, + "source": [ + "> **📗 SOLUTION NOTEBOOK — Module 1.** All exercise cells are completed and\n", + "> annotated. Every explanation cell is identical to the exercise notebook." + ] + }, + { + "cell_type": "markdown", + "id": "713028f0", + "metadata": {}, + "source": [ + "# QoolQit Exercises — Module 1\n", + "## Graphs and Embedding\n", + "\n", + "Welcome to this hands-on introduction to **QoolQit**, the Python library for\n", + "algorithm development in the Rydberg analog model. Across four self-contained\n", + "modules you will learn all the building blocks of a QoolQit application, and\n", + "assemble them into a working quantum solver in the final module:\n", + "\n", + "| Module | Topic |\n", + "|--------|-------|\n", + "| 1 | Graphs and Embedding |\n", + "| 2 | Register, Drive and Quantum Programs |\n", + "| 3 | Compilation and Execution |\n", + "| 4 | Putting it all together: solving a QUBO |\n", + "\n", + "### In this module you will learn\n", + "- How to create graphs with the `DataGraph` class (pre-defined layouts,\n", + " random graphs, graphs from raw data)\n", + "- The difference between *abstract* graphs and graphs *with coordinates*\n", + "- How to give coordinates to an abstract graph" + ] + }, + { + "cell_type": "markdown", + "id": "6226deb9", + "metadata": {}, + "source": [ + "## 1. The `DataGraph` class\n", + "\n", + "In QoolQit, problems and atom layouts are described by graphs. The\n", + "`DataGraph` class (a subclass of `networkx.Graph`) is the central data\n", + "structure: it can hold **connectivity** (edges), **coordinates** (positions\n", + "of the nodes in the plane), and node and edge **weights**." + ] + }, + { + "cell_type": "markdown", + "id": "f89ebcdc", + "metadata": {}, + "source": [ + "### ✏️ Exercise 1.1 — Pre-defined graph layouts\n", + "\n", + "Create and draw three graphs:\n", + "1. `g_line`: a **line** graph with 5 nodes;\n", + "2. `g_circle`: a **circle** graph with 6 nodes and `spacing=1.0`;\n", + "3. `g_square`: a **square** grid graph with `m=3` rows and `n=3` columns.\n", + "\n", + "Use each graph's `.draw()` method to visualize it." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "af9b7821", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from qoolqit import DataGraph\n", + "\n", + "g_line = DataGraph.line(5)\n", + "g_circle = DataGraph.circle(n=6, spacing=1.0)\n", + "g_square = DataGraph.square(m=3, n=3)\n", + "\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 4))\n", + "g_line.draw(ax=ax1)\n", + "g_circle.draw(ax=ax2)\n", + "g_square.draw(ax=ax3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eca26aea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All three graphs look right!\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert g_line.number_of_nodes() == 5\n", + "assert g_circle.number_of_nodes() == 6\n", + "assert g_square.number_of_nodes() == 9\n", + "print(\"All three graphs look right!\")" + ] + }, + { + "cell_type": "markdown", + "id": "a9b0848c", + "metadata": {}, + "source": [ + "## 2. Abstract graphs vs. graphs with coordinates\n", + "\n", + "Not every graph has coordinates. What is required is only their connectivity: edges and nodes. \n", + "A **random Erdős–Rényi graph**, for\n", + "instance, is purely *abstract*: it defines which nodes are connected, but\n", + "says nothing about where the nodes sit in the plane. Since neutral atoms live\n", + "in real space, sooner or later every graph needs coordinates — that is the\n", + "job of *embedding* (Section 4).\n", + "\n", + "Useful properties to interrogate a graph: `has_coords`, `has_edges`,\n", + "`has_node_weights`, `has_edge_weights`." + ] + }, + { + "cell_type": "markdown", + "id": "e3ffa662", + "metadata": {}, + "source": [ + "### ✏️ Exercise 1.2 — An abstract random graph\n", + "\n", + "1. Create `g_er`, an Erdős–Rényi random graph with `n=8` nodes, edge\n", + " probability `p=0.4` and `seed=3` (for reproducibility).\n", + "2. Print whether it has coordinates (`has_coords`) and how many edges it has.\n", + "3. Try to compute `g_er.min_distance()` inside a `try/except Exception` block\n", + " and print the error — distances make no sense without coordinates!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "61d92e10", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Has coordinates: False\n", + "Number of edges: 10\n", + "As expected, this fails: Trying to compute distances for a graph without coordinates.\n" + ] + } + ], + "source": [ + "g_er = DataGraph.random_er(n=8, p=0.4, seed=3)\n", + "\n", + "print(\"Has coordinates:\", g_er.has_coords)\n", + "print(\"Number of edges:\", g_er.number_of_edges())\n", + "\n", + "try:\n", + " g_er.min_distance()\n", + "except AttributeError as err:\n", + " print(\"As expected, this fails:\", err)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "724d4d0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correct — g_er is an abstract graph.\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert g_er.number_of_nodes() == 8\n", + "assert not g_er.has_coords, \"An ER graph should be abstract (no coordinates)\"\n", + "print(\"Correct — g_er is an abstract graph.\")" + ] + }, + { + "cell_type": "markdown", + "id": "2a2264fd", + "metadata": {}, + "source": [ + "## 3. Embedding: assign coordinates to an abstract graph or interaction matrix\n", + "\n", + "**Embedding** is the process of assigning coordinates to a graph. QoolQit can take an\n", + " abstract graph and return the same graph *with coordinates* or take a symmetric matrix of *desired interactions* and return a graph whose node positions physically realize them (next section).\n" + ] + }, + { + "cell_type": "markdown", + "id": "d7a6df28", + "metadata": {}, + "source": [ + "### ✏️ Exercise 1.4 — Spring-layout embedding of the random graph\n", + "\n", + "1. Import `SpringLayoutEmbedder` from `qoolqit.embedding` and instantiate it.\n", + "2. Embed the abstract graph `g_er` from Exercise 1.2 into `g_er_embedded`.\n", + "3. Verify the embedded graph now has coordinates, print its `min_distance()`,\n", + " and draw it." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b0314e34", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Has coordinates: True\n", + "Minimum distance: 0.820294932137076\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qoolqit.embedding import SpringLayoutEmbedder\n", + "\n", + "embedder = SpringLayoutEmbedder()\n", + "g_er_embedded = embedder.embed(g_er)\n", + "\n", + "print(\"Has coordinates:\", g_er_embedded.has_coords)\n", + "print(\"Minimum distance:\", g_er_embedded.min_distance())\n", + "g_er_embedded.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0f8d3fcb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spring-layout embedding successful!\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert g_er_embedded.has_coords, \"The embedded graph should have coordinates\"\n", + "print(\"Spring-layout embedding successful!\")" + ] + }, + { + "cell_type": "markdown", + "id": "de059158", + "metadata": {}, + "source": [ + "### ✏️ Exercise 1.5 — Embed a target interaction matrix\n", + "\n", + "1. Define the symmetric 3×3 target matrix\n", + " `M = [[0, 1, 0.3], [1, 0, 0.5], [0.3, 0.5, 0]]` as a NumPy array.\n", + "2. Instantiate an `InteractionEmbedder` (from `qoolqit.embedding`) and embed\n", + " `M` into `g_int`.\n", + "3. Draw `g_int`, then print its `interactions()` dictionary side by side with\n", + " the corresponding entries of `M`. How close did the embedder get?\n", + "\n", + "> 💡 The `interactions()` method computes $1/r^6$ for each pair of nodes from\n", + "> the coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6b2d9b52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pair (0,1): J = 1.0000 target M = 1.0000\n", + "pair (0,2): J = 0.3000 target M = 0.3000\n", + "pair (1,2): J = 0.5000 target M = 0.5000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from qoolqit.embedding import InteractionEmbedder\n", + "\n", + "M = np.array([[0.0, 1.0, 0.3], [1.0, 0.0, 0.5], [0.3, 0.5, 0.0]])\n", + "\n", + "g_int = InteractionEmbedder().embed(M)\n", + "\n", + "g_int.draw()\n", + "\n", + "for (i, j), J in g_int.interactions().items():\n", + " print(f\"pair ({i},{j}): J = {J:.4f} target M = {M[i, j]:.4f}\")\n", + "\n", + "# For 3 nodes the embedder reproduces the targets almost exactly:\n", + "# the strongest coupling (1.0) corresponds to the closest pair of atoms." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "881fa9d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interaction embedding matches the target matrix!\n" + ] + } + ], + "source": [ + "# ✅ Check — every realized interaction within 5% of its target\n", + "for (i, j), J in g_int.interactions().items():\n", + " assert abs(J - M[i, j]) < 0.05, f\"pair ({i},{j}) is off: {J} vs {M[i, j]}\"\n", + "print(\"Interaction embedding matches the target matrix!\")" + ] + }, + { + "cell_type": "markdown", + "id": "f8f2abe6", + "metadata": {}, + "source": [ + "### Next module\n", + "Graphs describe *data* and *geometry*. In **Module 2** we turn geometry into\n", + "physics: the `Register` of atoms, the time-dependent `Drive`, and the\n", + "`QuantumProgram` that combines them." + ] + } + ], + "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 +}