{ "cells": [ { "cell_type": "markdown", "id": "d108e1e8", "metadata": {}, "source": [ "# Quantum Optimization: Max-Cut with QAOA, VQE, and FALQON\n", "\n", "In this tutorial, we will explore three different quantum optimization algorithms to solve the **Max-Cut problem** using the Ket language:\n", "\n", "| Algorithm | Approach | Description |\n", "| :--- | :--- | :--- |\n", "| **QAOA** | Hybrid Variational | Ansatz inspired by adiabatic evolution, scales well with layers ($p$) |\n", "| **VQE** | Hybrid Variational | Hardware-efficient ansatz with automatic gradients |\n", "| **FALQON** | Deterministic Feedback | No classical iterative optimizer required |\n", "\n", "> ๐Ÿ’ก **Prerequisite:** Basic knowledge of quantum computing\n" ] }, { "cell_type": "markdown", "id": "4a145ce0", "metadata": {}, "source": [ "## ๐Ÿ”ง Environment Setup\n", "\n", "Before we begin, let's install the necessary dependencies.\n", "We'll use `ket-lang` as our core quantum programming library.\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "74599c2c", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:20.726300Z", "iopub.status.busy": "2026-08-05T16:37:20.726087Z", "iopub.status.idle": "2026-08-05T16:37:21.243395Z", "shell.execute_reply": "2026-08-05T16:37:21.243040Z" } }, "outputs": [ { "data": { "text/plain": [ "['Ket v0.10.1',\n", " 'libket v0.7.1 [rustc 1.97.0 (2d8144b78 2026-07-07) x86_64-unknown-linux-gnu]',\n", " 'kbw v0.5.1 [rustc 1.97.0 (2d8144b78 2026-07-07) x86_64-unknown-linux-gnu]']" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from functools import partial\n", "from scipy.optimize import minimize\n", "import networkx as nx\n", "import plotly.express as px\n", "import plotly.graph_objects as go\n", "\n", "import plotly.io as pio\n", "pio.renderers.default = \"notebook_connected\"\n", "\n", "# Import all elements from the Ket API\n", "from ket import *\n", "from ket import ket_version\n", "\n", "ket_version()" ] }, { "cell_type": "markdown", "id": "ff8c8cb5", "metadata": {}, "source": [ "## โœ‚๏ธ Part 1: The Max-Cut Problem\n", "\n", "### What is Max-Cut?\n", "\n", "**Max-Cut** is a classic problem in graph theory.\n", "Given a graph $G = (V, \\mathcal{E})$, the goal is:\n", "\n", "> **Partition** the set of vertices $V$ into two disjoint subsets $S$ and $\\bar{S}$ such that we\n", "> **maximize** the number of edges crossing the partition (i.e., edges with one endpoint in $S$ and the other in $\\bar{S}$).\n", "\n", "Formally, we want to maximize:\n", "\n", "$$\n", "\\text{cut}(S, \\bar{S}) = |\\{(u, v) \\in \\mathcal{E} : u \\in S, v \\in \\bar{S}\\}|\n", "$$\n", "\n", "![](https://upload.wikimedia.org/wikipedia/commons/c/cf/Max-cut.svg)\n", "\n", "### Why is it hard?\n", "\n", "The number of possible partitions grows **exponentially** with the number of vertices: for $n$ vertices,\n", "there are $2^{n-1}$ distinct partitions. Checking all of them is impractical even for moderately sized graphs.\n", "\n", "### Why is it interesting for quantum computing?\n", "\n", "Max-Cut is a **paradigmatic** problem for quantum optimization algorithms because:\n", "\n", "- It maps directly to a **quantum Hamiltonian** (Pauli operators)\n", "- It serves as a benchmark for NISQ (Noisy Intermediate-Scale Quantum) devices\n", "- It has real-world applications in VLSI circuit cutting, statistical physics, and machine learning\n", "\n", "### Intuitive Example\n", "\n", "Imagine a social network where edges represent **conflicts** between people.\n", "We want to divide the group into two teams such that the **maximum number of conflicts** are placed between the teams (rather than inside them).\n", "\n", "### Available Instances\n", "\n", "For this tutorial, we've prepared six graphs of increasing complexity.\n", "You can swap the instance at any time to see how the algorithms behave!\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "286704a6", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:21.244844Z", "iopub.status.busy": "2026-08-05T16:37:21.244700Z", "iopub.status.idle": "2026-08-05T16:37:21.247352Z", "shell.execute_reply": "2026-08-05T16:37:21.247078Z" } }, "outputs": [], "source": [ "# ================================================================\n", "# GRAPH INSTANCES\n", "# ================================================================\n", "\n", "graphs = {\n", " # number of nodes: edges\n", " # Instance 1: Simple Ring (4 nodes)\n", " # Trivial solution: alternating colors. Optimal = 4 cut edges.\n", " 4: [(0, 1), (1, 2), (2, 3), (3, 0)],\n", " # Instance 2: Butterfly (5 nodes), geometric frustration\n", " # The triangle (0,1,2) prevents a perfect coloring (odd cycle).\n", " 5: [(0, 1), (0, 2), (1, 2), (2, 3), (2, 4), (3, 4)],\n", " # Instance 3: Triangular Prism (6 nodes), 3-regular graph\n", " # Two triangles connected by lateral edges.\n", " 6: [(0, 1), (1, 2), (2, 0), (3, 4), (4, 5), (5, 3), (0, 3), (1, 4), (2, 5)],\n", " # Instance 4: Cube (8 nodes), hypercube topology\n", " # 3-regular graph with 12 edges. Optimal = 8 cut edges (bipartite!).\n", " 8: [(0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 7), (7, 4), (0, 4), (1, 5), (2, 6), (3, 7)],\n", " # Instance 5: Petersen Graph (10 nodes), classic benchmark\n", " # Famous for being 3-regular, highly symmetric and internally connected.\n", " 10: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0), (0, 5), (1, 6), (2, 7), (3, 8), (4, 9), (5, 7), (7, 9), (9, 6), (6, 8), (8, 5)],\n", " # Instance 6: 3x4 Grid (12 nodes), lattice topology\n", " # Simulates square grid interactions, common in superconducting quantum hardware.\n", " 12: [(0, 1), (1, 2), (2, 3), (4, 5), (5, 6), (6, 7), (8, 9), (9, 10), (10, 11), (0, 4), (4, 8), (1, 5), (5, 9), (2, 6), (6, 10), (3, 7), (7, 11)],\n", "}" ] }, { "cell_type": "markdown", "id": "ced29e55", "metadata": {}, "source": [ "### Graph and Cut Visualization\n", "\n", "The `plot_maxcut` function below serves two purposes:\n", "\n", "1. **No result** (`result=None`): shows the original graph with all nodes in the same color.\n", "2. **With result** (`result=`): interprets the integer as an $n$-bit binary string,\n", " colors the nodes in set $S$ ๐Ÿ”ต blue and those in set $\\bar{S}$ ๐Ÿ”ด red,\n", " and highlights the **cut edges** with dashed red lines.\n", "\n", "> **Binary representation:** An $n$-qubit state measured as integer `r` maps qubit $i$\n", "> to bit $i$ of the binary representation of `r`. Bit `0` โ†’ vertex in blue group; bit `1` โ†’ red group.\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "7f5e9c21", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:21.248297Z", "iopub.status.busy": "2026-08-05T16:37:21.248230Z", "iopub.status.idle": "2026-08-05T16:37:21.252266Z", "shell.execute_reply": "2026-08-05T16:37:21.251932Z" } }, "outputs": [], "source": [ "def plot_maxcut(n: int, result: int | None = None):\n", " \"\"\"\n", " Plots the graph with n vertices, highlighting the cut if 'result' is provided.\n", "\n", " Parameters\n", " ----------\n", " n : number of vertices (selects the graph from the `graphs` dictionary)\n", " result : n-bit integer representing the partition (optional)\n", " - bit 0 โ†’ blue group (set S)\n", " - bit 1 โ†’ red group (set Sฬ„)\n", " \"\"\"\n", " G = nx.Graph()\n", " G.add_edges_from(graphs[n])\n", " pos = nx.spring_layout(G, seed=42)\n", "\n", " # โ”€โ”€ Node colors โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " node_colors = [\"#00dfff\"] * n # default blue (no result)\n", " bin_str = None\n", " if result is not None:\n", " bin_str = bin(result)[2:].zfill(n)\n", " node_colors = [\"#EF553B\" if bit == \"1\" else \"#00dfff\" for bit in bin_str]\n", "\n", " # โ”€โ”€ Edge classification โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " uncut_x, uncut_y = [], []\n", " cut_x, cut_y = [], []\n", " for u, v in G.edges():\n", " x0, y0 = pos[u]\n", " x1, y1 = pos[v]\n", " # An edge is \"cut\" if the two nodes have different bits\n", " if bin_str is not None and bin_str[u] != bin_str[v]:\n", " cut_x.extend([x0, x1, None])\n", " cut_y.extend([y0, y1, None])\n", " else:\n", " uncut_x.extend([x0, x1, None])\n", " uncut_y.extend([y0, y1, None])\n", "\n", " # โ”€โ”€ Plotly traces construction โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " traces = []\n", " if uncut_x: # uncut edges: solid gray\n", " traces.append(\n", " go.Scatter(\n", " x=uncut_x,\n", " y=uncut_y,\n", " line=dict(width=3, color=\"#888\"),\n", " hoverinfo=\"none\",\n", " mode=\"lines\",\n", " )\n", " )\n", " if cut_x: # cut edges: dashed red\n", " traces.append(\n", " go.Scatter(\n", " x=cut_x,\n", " y=cut_y,\n", " line=dict(width=3, color=\"#EF553B\", dash=\"dot\"),\n", " hoverinfo=\"none\",\n", " mode=\"lines\",\n", " name=\"Cut edge\",\n", " )\n", " )\n", "\n", " # โ”€โ”€ Node trace โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " traces.append(\n", " go.Scatter(\n", " x=[pos[v][0] for v in G.nodes()],\n", " y=[pos[v][1] for v in G.nodes()],\n", " mode=\"markers+text\",\n", " text=list(G.nodes()),\n", " textposition=\"middle center\",\n", " textfont=dict(color=\"white\", size=16),\n", " marker=dict(size=45, color=node_colors, line_width=2),\n", " )\n", " )\n", "\n", " # โ”€โ”€ Cut count (if result exists) โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " cut_count = \"\"\n", " if bin_str is not None:\n", " n_cut = sum(1 for (u, v) in G.edges() if bin_str[u] != bin_str[v])\n", " cut_count = f\", {n_cut} edges cut out of {len(graphs[n])}\"\n", "\n", " title = (\n", " (\"Max-Cut Result\" + cut_count)\n", " if result is not None\n", " else f\"Graph with {n} vertices\"\n", " )\n", "\n", " fig = go.Figure(\n", " data=traces,\n", " layout=go.Layout(\n", " title=title,\n", " title_x=0.5,\n", " showlegend=False,\n", " xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n", " yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n", " width=500,\n", " height=500,\n", " ),\n", " )\n", " fig.show()" ] }, { "cell_type": "code", "execution_count": 4, "id": "f69691e1", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:21.253203Z", "iopub.status.busy": "2026-08-05T16:37:21.253116Z", "iopub.status.idle": "2026-08-05T16:37:22.515154Z", "shell.execute_reply": "2026-08-05T16:37:22.514061Z" } }, "outputs": [ { "data": { "text/html": [ " \n", " \n", " " ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Initial graph visualization (no result)\n", "plot_maxcut(4)" ] }, { "cell_type": "markdown", "id": "ce88e3dd", "metadata": {}, "source": [ "## ๐Ÿงฎ Part 2: Quantum Mapping โ€” Hamiltonians\n", "\n", "The first step to solving Max-Cut quantumly is to **translate the problem** into the language of\n", "quantum mechanics. Instead of maximizing the number of cut edges, we want to **minimize the energy**\n", "of a physical system described by an operator called the **Hamiltonian**.\n", "\n", "### Variable Encoding\n", "\n", "Each vertex $v_i$ is mapped to a **qubit** $i$. The state of each qubit (0 or 1) indicates which\n", "group the vertex belongs to. Measuring the system at the end of the circuit reveals the partition found.\n", "\n", "### ๐ŸŸข Cost Hamiltonian ($H_C$)\n", "\n", "The Cost Hamiltonian encodes the Max-Cut objective function using the **Pauli-Z** operator\n", "(which has eigenvalues $+1$ and $-1$ corresponding to qubits in state $|0\\rangle$ and $|1\\rangle$).\n", "\n", "For each edge $(a, b) \\in \\mathcal{E}$, the product $Z_a Z_b$ equals:\n", "\n", "- $+1$ if the vertices are in the **same** group (edge **not** cut)\n", "- $-1$ if the vertices are in **different groups** (edge **cut**)\n", "\n", "Therefore, the Hamiltonian:\n", "\n", "$$H_C = -\\frac{1}{2}\\sum_{(a,b) \\in \\mathcal{E}} \\left(1 - Z_a Z_b\\right)$$\n", "\n", "evaluates to $-1$ for each cut edge and $0$ for each uncut edge.\n", "**Minimizing $H_C$ is equivalent to maximizing the number of cut edges!**\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "a299265d", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:22.518849Z", "iopub.status.busy": "2026-08-05T16:37:22.518546Z", "iopub.status.idle": "2026-08-05T16:37:23.814437Z", "shell.execute_reply": "2026-08-05T16:37:23.813181Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_maxcut(4, 0b1011)" ] }, { "cell_type": "markdown", "id": "f0ec00ac", "metadata": {}, "source": [ "### ๐ŸŸก Mixer Hamiltonian ($H_M$)\n", "\n", "To allow the algorithm to explore the state space and avoid getting stuck in a local minimum,\n", "we need a second Hamiltonian that **does not commute** with $H_C$. The standard choice is the sum\n", "of **Pauli-X** operators (quantum NOT gate) on all qubits:\n", "\n", "$$H_M = \\sum_{q} X_q$$\n", "\n", "The non-commutativity $[H_C, H_M] \\neq 0$ ensures that the alternating evolution of the two\n", "Hamiltonians creates quantum interference, efficiently exploring the solution space.\n", "\n", "### Implementation in Ket\n", "\n", "In Ket, Hamiltonians are constructed inside a `{func}\\`~ket.gates.obs\\`` block, which creates a\n", "`{class}\\`~ket.expv.Hamiltonian\\`` object โ€” an algebraic representation of the operator that can be\n", "used both to calculate expected values and to generate time-evolution unitaries $e^{-i t H}$.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "a50946fe", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:23.819249Z", "iopub.status.busy": "2026-08-05T16:37:23.818868Z", "iopub.status.idle": "2026-08-05T16:37:23.825394Z", "shell.execute_reply": "2026-08-05T16:37:23.824283Z" } }, "outputs": [], "source": [ "def cost_h(edges: list[tuple[int, int]], q: Quant) -> Hamiltonian:\n", " \"\"\"\n", " Builds the Max-Cut Cost Hamiltonian:\n", " H_C = -1/2 * ฮฃ_{(a,b) โˆˆ E} (1 - Z_aยทZ_b)\n", "\n", " The `with obs()` block tells Ket we are building an observable\n", " (not executing gates in the circuit). The result is a Hamiltonian\n", " object that can be used in `evolve()` or `exp_value()`.\n", "\n", " Parameters\n", " ----------\n", " edges : list of graph edges, e.g. [(0,1), (1,2), ...]\n", " q : qubit register allocated in the current process\n", " \"\"\"\n", " with obs():\n", " # For each edge (a,b), (1 - Z_a*Z_b) equals 2 if the edge is cut, 0 otherwise.\n", " # Summing and dividing by -2 gives -1 per cut edge (minimization โ†” maximization).\n", " Hc = sum(1 - Z(q[a]) * Z(q[b]) for a, b in edges)\n", " return -Hc / 2\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "098ec8c6", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:23.828170Z", "iopub.status.busy": "2026-08-05T16:37:23.827852Z", "iopub.status.idle": "2026-08-05T16:37:23.833172Z", "shell.execute_reply": "2026-08-05T16:37:23.832203Z" } }, "outputs": [], "source": [ "def mixer_h(nodes: Quant) -> Hamiltonian:\n", " \"\"\"\n", " Builds the Mixer Hamiltonian:\n", " H_M = ฮฃ_q X_q\n", "\n", " The X operator (Pauli-X = NOT gate) creates transitions between states |0โŸฉ and |1โŸฉ,\n", " allowing the system to explore different vertex colorings.\n", " Its non-commutativity with Z is fundamental: [X, Z] = 2iY โ‰  0.\n", "\n", " Parameters\n", " ----------\n", " nodes : list/Quant of qubits to be connected by the mixer\n", " \"\"\"\n", " with obs():\n", " Hm = sum(X(q) for q in nodes)\n", " return Hm\n" ] }, { "cell_type": "markdown", "id": "216f522f", "metadata": {}, "source": [ "## 1๏ธโƒฃ QAOA โ€” Quantum Approximate Optimization Algorithm\n", "\n", "### How QAOA Works\n", "\n", "QAOA was proposed by Farhi, Goldstone, and Gutmann in 2014 as a hybrid\n", "quantum-classical method for combinatorial optimization problems.\n", "\n", "The algorithm prepares an initial state and applies $p$ layers of alternating unitary evolutions:\n", "\n", "1. **Cost Evolution**: $e^{-i \\gamma H_C}$ (adds phases according to the cost function)\n", "2. **Mixer Evolution**: $e^{-i \\beta H_M}$ (creates transitions between states)\n", "\n", "The parameters $\\gamma$ and $\\beta$ are optimized by a classical algorithm (like COBYLA) to minimize the expected value $\\langle H_C \\rangle$.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "422aa5f3", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:23.836177Z", "iopub.status.busy": "2026-08-05T16:37:23.835926Z", "iopub.status.idle": "2026-08-05T16:37:23.840556Z", "shell.execute_reply": "2026-08-05T16:37:23.839820Z" } }, "outputs": [], "source": [ "def qaoa_ansatz(edges, qubits, gamma, beta):\n", " \"\"\"\n", " Builds the QAOA variational circuit with p layers.\n", "\n", " Structure:\n", " 1. Initial state: uniform superposition with H on all qubits\n", " 2. For each pair (ฮณ_k, ฮฒ_k):\n", " a. Cost Hamiltonian evolution: e^{-i ฮณ_k H_C}\n", " b. Mixer Hamiltonian evolution: e^{-i ฮฒ_k H_M}\n", "\n", " The `evolve(t * H)` function in Ket directly applies the matrix exponential\n", " e^{-i t H} to the current circuit state, without manually decomposing\n", " into primitive gates!\n", "\n", " Parameters\n", " ----------\n", " edges : list of graph edges\n", " qubits : qubit register of the process\n", " gamma : list of p angles ฮณ (cost evolution)\n", " beta : list of p angles ฮฒ (mixer evolution)\n", " \"\"\"\n", " # Step 1: prepare uniform superposition |+โŸฉ^โŠ—n\n", " H(qubits)\n", "\n", " # Step 2: apply p alternating layers of cost and mixer\n", " for g, b in zip(gamma, beta):\n", " evolve(g * cost_h(edges, qubits)) # e^{-i ฮณ H_C}\n", " evolve(b * mixer_h(qubits)) # e^{-i ฮฒ H_M}\n" ] }, { "cell_type": "markdown", "id": "d2e42729", "metadata": {}, "source": [ "### QAOA Circuit Visualization\n", "\n", "Ket's `qulib.draw` function allows us to visualize the quantum circuit that will be executed.\n", "Let's see what a **1-layer** ($p=1$) QAOA circuit looks like for the selected graph:\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "b37eb4e2", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:23.842888Z", "iopub.status.busy": "2026-08-05T16:37:23.842612Z", "iopub.status.idle": "2026-08-05T16:37:24.117884Z", "shell.execute_reply": "2026-08-05T16:37:24.117390Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# QAOA circuit visualization for p=1 (one layer)\n", "# Using parameters ฮณ=0.7, ฮฒ=0.3 as an illustrative example\n", "n = 6\n", "qulib.draw(lambda q: qaoa_ansatz(graphs[n], q, gamma=[0.7], beta=[0.3]), n, fold=-1)\n" ] }, { "cell_type": "markdown", "id": "ba111e4f", "metadata": {}, "source": [ "### Objective Function and Classical-Quantum Loop\n", "\n", "The `qaoa_objective` function is called repeatedly by the COBYLA optimizer.\n", "In each call, it:\n", "\n", "1. Creates a new Ket **Process** (qubit allocation in the simulator).\n", "2. Executes the ansatz with the current parameters.\n", "3. Calculates and returns the expected value $\\langle H_C \\rangle$.\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "5de4278f", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:24.119303Z", "iopub.status.busy": "2026-08-05T16:37:24.119141Z", "iopub.status.idle": "2026-08-05T16:37:24.121415Z", "shell.execute_reply": "2026-08-05T16:37:24.121068Z" } }, "outputs": [], "source": [ "def qaoa_objective(edges, n, parameters, final=False):\n", " \"\"\"\n", " Hybrid classical-quantum objective function for QAOA.\n", "\n", " This function is called in two contexts:\n", " - During optimization (final=False): returns โŸจH_CโŸฉ for the optimizer to minimize.\n", " - After convergence (final=True): returns samples of the optimized state.\n", "\n", " Parameters\n", " ----------\n", " edges : graph edges\n", " n : number of vertices (= number of qubits)\n", " parameters : 1D vector with [ฮณ_1,...,ฮณ_p, ฮฒ_1,...,ฮฒ_p] concatenated\n", " final : if True, returns samples instead of the expected value\n", " \"\"\"\n", " # Split parameters into two vectors: gamma and beta\n", " p = len(parameters) // 2\n", " gamma = parameters[:p]\n", " beta = parameters[p:]\n", "\n", " process = Process(num_qubits=n, simulator=\"dense\", execution=\"batch\")\n", " qubits = process.alloc(n)\n", "\n", " qaoa_ansatz(edges, qubits, gamma, beta)\n", "\n", " if final:\n", " return sample(qubits)\n", "\n", " return exp_value(cost_h(edges, qubits)).get()\n" ] }, { "cell_type": "markdown", "id": "a922b2f2", "metadata": {}, "source": [ "### Executing QAOA\n", "\n", "Now we run the full optimization loop. SciPy (COBYLA) will call `qaoa_objective`\n", "repeatedly, adjusting parameters until it converges to a local minimum of $\\langle H_C \\rangle$.\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "d8f8a69a", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:24.122399Z", "iopub.status.busy": "2026-08-05T16:37:24.122317Z", "iopub.status.idle": "2026-08-05T16:37:27.632224Z", "shell.execute_reply": "2026-08-05T16:37:27.630758Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial parameters:\n", " ฮณ (cost, increasing): [0.25, 0.5]\n", " ฮฒ (mixer, decreasing): [0.25, 0.0]\n", "\n", "QAOA optimization completed in 99 objective function evaluations.\n", "Final energy โŸจH_CโŸฉ = -6.3919 (lower = more cut edges)\n", "Optimal parameters: ฮณ = [0.6747 1.5856], ฮฒ = [ 1.3373 -0.2674]\n" ] }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Most probable state: 011100 (integer: 28)\n" ] }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# โ”€โ”€ Configuration โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "p = 2 # number of QAOA layers\n", "dt = 0.5 # initial parameter scale\n", "\n", "# Initialization inspired by adiabatic annealing:\n", "# ฮณ increasing: small at the start, larger at the end โ†’ cost gains importance gradually\n", "# ฮฒ decreasing: large at the start, smaller at the end โ†’ mixer dominates early on\n", "gamma_init = [i / p * dt for i in range(1, p + 1)] # [dt/p, 2dt/p, ..., dt]\n", "beta_init = [(1 - i / p) * dt for i in range(1, p + 1)] # [dt(1-1/p), ..., 0]\n", "\n", "print(\"Initial parameters:\")\n", "print(f\" ฮณ (cost, increasing): {gamma_init}\")\n", "print(f\" ฮฒ (mixer, decreasing): {beta_init}\")\n", "\n", "# Concatenate [ฮณ_1,...,ฮณ_p, ฮฒ_1,...,ฮฒ_p] into a single vector for SciPy\n", "initial_params_qaoa = gamma_init + beta_init\n", "\n", "# โ”€โ”€ Optimization โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "res_qaoa = minimize(\n", " partial(qaoa_objective, graphs[n], n), # function for COBYLA to minimize\n", " initial_params_qaoa,\n", " method=\"COBYLA\",\n", ")\n", "\n", "print(f\"\\nQAOA optimization completed in {res_qaoa.nfev} objective function evaluations.\")\n", "print(f\"Final energy โŸจH_CโŸฉ = {res_qaoa.fun:.4f} (lower = more cut edges)\")\n", "print(\n", " f\"Optimal parameters: ฮณ = {res_qaoa.x[:p].round(4)}, ฮฒ = {res_qaoa.x[p:].round(4)}\"\n", ")\n", "\n", "# โ”€โ”€ Final result โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "# Use the optimal parameters to sample the final quantum state\n", "samples_qaoa = qaoa_objective(graphs[n], n, res_qaoa.x, final=True)\n", "\n", "# Histogram colored by energy: darker bars = states with higher cost (better cuts)\n", "samples_qaoa.histogram(\"bin\", hamiltonian=partial(cost_h, graphs[n])).show()\n", "\n", "# Visualize the cut found in the graph\n", "best_state_qaoa = samples_qaoa.most_frequent_state()\n", "print(\n", " f\"\\nMost probable state: {bin(best_state_qaoa)[2:].zfill(n)} (integer: {best_state_qaoa})\"\n", ")\n", "plot_maxcut(n, best_state_qaoa)\n" ] }, { "cell_type": "markdown", "id": "598946a2", "metadata": {}, "source": [ "## 2๏ธโƒฃ VQE โ€” Variational Quantum Eigensolver\n", "\n", "### How VQE Works\n", "\n", "VQE was originally proposed by Peruzzo et al. (2014) to calculate molecular energies,\n", "but it applies to any problem that can be mapped to a Hamiltonian.\n", "\n", "Unlike QAOA, which uses Hamiltonians that encode the problem directly into the circuit's gates,\n", "VQE uses a **Hardware-Efficient Ansatz (HEA)**. This ansatz consists of generic parametrized\n", "rotation gates (like $R_Y$) and fixed entangling gates (like $CZ$), which are easy to implement on real quantum hardware.\n", "\n", "VQE relies heavily on the classical optimizer to find the right angles that minimize the energy.\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "2125ff36", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:27.636237Z", "iopub.status.busy": "2026-08-05T16:37:27.635705Z", "iopub.status.idle": "2026-08-05T16:37:27.642402Z", "shell.execute_reply": "2026-08-05T16:37:27.641390Z" } }, "outputs": [], "source": [ "def vqe_ansatz(qubits, parameters):\n", " \"\"\"\n", " Hardware-Efficient Ansatz (HEA) for VQE.\n", "\n", " Structure of each layer:\n", " 1. RY rotations(ฮธ_i) on each qubit โ†’ free parameterization\n", " 2. CZ gates between neighboring qubits โ†’ local entanglement\n", "\n", " The iterator `p` steps through the parameters sequentially.\n", " When parameters are exhausted (next returns False), the function returns.\n", " This lets the number of layers be controlled simply by the length of the parameter vector.\n", "\n", " Parameters\n", " ----------\n", " qubits : qubit register of the current process\n", " parameters : vector of angles ฮธ (can be a list of floats or Ket Param objects)\n", " \"\"\"\n", " p = iter(parameters)\n", "\n", " while True:\n", " # โ”€โ”€ Individual rotation layer โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " for q in qubits:\n", " angle = next(p, False)\n", " if angle is False: # parameters exhausted: circuit complete\n", " return\n", " RY(angle, q) # rotation around the Y axis: Ry(ฮธ) = e^{-iฮธY/2}\n", "\n", " # โ”€โ”€ Entanglement layer โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", " # CZ between consecutive qubits creates quantum correlations between neighboring vertices\n", " for i in range(len(qubits) - 1):\n", " CZ(qubits[i], qubits[i + 1])\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "d25cced0", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:27.645255Z", "iopub.status.busy": "2026-08-05T16:37:27.645061Z", "iopub.status.idle": "2026-08-05T16:37:27.650967Z", "shell.execute_reply": "2026-08-05T16:37:27.649820Z" } }, "outputs": [], "source": [ "def vqe_objective(edges, n, parameters, final=False):\n", " \"\"\"\n", " VQE objective function with support for automatic gradients.\n", "\n", " Unlike QAOA, here we enable `gradient=True` in the Process so that\n", " Ket automatically computes โˆ‚โŸจH_CโŸฉ/โˆ‚ฮธ_i for each parameter.\n", "\n", " With gradients available, we can use SciPy's L-BFGS-B optimizer,\n", " which converges much faster than COBYLA on smooth cost surfaces.\n", "\n", " Parameters\n", " ----------\n", " edges : graph edges\n", " n : number of qubits\n", " parameters : vector of angles ฮธ\n", " final : if True, returns samples; if False, returns (energy, gradient)\n", " \"\"\"\n", " process = Process(\n", " num_qubits=n,\n", " simulator=\"dense\",\n", " execution=\"batch\",\n", " gradient=not final, # gradients only during optimization (not in the final call)\n", " )\n", "\n", " if not final:\n", " # Register parameters as differentiable variables of the process.\n", " # This allows Ket to track their derivatives automatically.\n", " parameters = process.param(*parameters)\n", "\n", " qubits = process.alloc(n)\n", " vqe_ansatz(qubits, parameters)\n", "\n", " if final:\n", " return sample(qubits)\n", "\n", " # Expected value of the energy\n", " result = exp_value(cost_h(edges, qubits)).get()\n", "\n", " # Extract gradients: โˆ‚โŸจH_CโŸฉ/โˆ‚ฮธ_i for each parameter.\n", " # Ket computes this automatically using the Parameter Shift Rule.\n", " grad = [p.grad for p in parameters]\n", "\n", " return result, grad\n" ] }, { "cell_type": "markdown", "id": "6783e5e8", "metadata": {}, "source": [ "### VQE Circuit Visualization\n", "\n", "Let's visualize the VQE circuit before running the optimization:\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "fb98a0cd", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:27.654046Z", "iopub.status.busy": "2026-08-05T16:37:27.653789Z", "iopub.status.idle": "2026-08-05T16:37:27.702809Z", "shell.execute_reply": "2026-08-05T16:37:27.702270Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# VQE circuit visualization (one layer of n parameters)\n", "qulib.draw(lambda q: vqe_ansatz(q, [0.1] * n), n, fold=-1)" ] }, { "cell_type": "markdown", "id": "4758bc67", "metadata": {}, "source": [ "### Executing VQE\n", "\n", "VQE uses SciPy's **L-BFGS-B** optimizer, which is a second-order quasi-Newton method.\n", "It uses the gradients calculated by Ket to converge much faster than COBYLA.\n", "\n", "**Tip:** The number of parameters controls the expressive power of the ansatz.\n", "With `num_layers * n` parameters, we have `num_layers` layers of RY + CZ rotations.\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "cc5536dd", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:27.703840Z", "iopub.status.busy": "2026-08-05T16:37:27.703767Z", "iopub.status.idle": "2026-08-05T16:37:30.425559Z", "shell.execute_reply": "2026-08-05T16:37:30.424097Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "VQE with 2 layers ร— 6 qubits = 12 parameters\n", "\n", "VQE optimization completed in 30 objective function evaluations.\n", "Final energy โŸจH_CโŸฉ = -7.0000\n" ] }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Most probable state: 101010 (integer: 42)\n" ] }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# โ”€โ”€ Configuration โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "num_layers = 2 # number of RY + CZ layers\n", "num_params = num_layers * n # total number of parameters ฮธ\n", "\n", "# Initialization with small random perturbations to break symmetry\n", "import random\n", "\n", "random.seed(42)\n", "initial_params_vqe = [random.uniform(0.0, 0.3) for _ in range(num_params)]\n", "\n", "print(f\"VQE with {num_layers} layers ร— {n} qubits = {num_params} parameters\")\n", "\n", "# โ”€โ”€ Optimization โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "res_vqe = minimize(\n", " partial(vqe_objective, graphs[n], n),\n", " initial_params_vqe,\n", " method=\"L-BFGS-B\", # uses gradients provided by Ket\n", " jac=True, # indicates the function returns (value, gradient)\n", ")\n", "\n", "print(f\"\\nVQE optimization completed in {res_vqe.nfev} objective function evaluations.\")\n", "print(f\"Final energy โŸจH_CโŸฉ = {res_vqe.fun:.4f}\")\n", "\n", "# โ”€โ”€ Final result โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "samples_vqe = vqe_objective(graphs[n], n, res_vqe.x, final=True)\n", "samples_vqe.histogram(\"bin\", hamiltonian=partial(cost_h, graphs[n])).show()\n", "\n", "best_state_vqe = samples_vqe.most_frequent_state()\n", "print(\n", " f\"\\nMost probable state: {bin(best_state_vqe)[2:].zfill(n)} (integer: {best_state_vqe})\"\n", ")\n", "plot_maxcut(n, best_state_vqe)\n" ] }, { "cell_type": "markdown", "id": "08cb489f", "metadata": {}, "source": [ "## 3๏ธโƒฃ FALQON โ€” Feedback-based ALgorithm for Quantum OptimizatioN\n", "\n", "### How FALQON Works\n", "\n", "FALQON was proposed by Magann et al. (2021) as an alternative to QAOA that **completely eliminates\n", "the classical iterative optimizer**. Instead of adjusting parameters via minimization,\n", "FALQON uses a **feedback control law** based on **Lyapunov theory**:\n", "\n", "> If we choose the parameter $\\beta_k$ such that the energy **never increases** from one\n", "> layer to the next, we guarantee monotonic convergence to a minimum.\n", "\n", "![](https://ar5iv.labs.arxiv.org/html/2103.08619/assets/Concept4.png)\n", "\n", "### The Lyapunov Feedback Law\n", "\n", "The central theorem of FALQON establishes that if we define:\n", "\n", "$$\\beta_k = -\\langle i[H_M, H_C] \\rangle_k$$\n", "\n", "where $\\langle \\cdot \\rangle_k$ is the expected value in the state **after** the $k$-th layer,\n", "then the energy **must decrease** (or remain the same) at each step:\n", "\n", "$$\\langle H_C \\rangle_{k+1} \\leq \\langle H_C \\rangle_k \\quad \\forall k$$\n", "\n", "The term $i[H_M, H_C] = i(H_M H_C - H_C H_M)$ is called the **commutator Hamiltonian**\n", "and measures the \"flow\" of energy between the two Hamiltonians.\n", "\n", "### Advantage and Limitation\n", "\n", "โœ… **Advantage:** Guaranteed monotonic convergence, no risk of barren plateaus or bad local minima.\n", "โš ๏ธ **Limitation:** May require more layers than QAOA to achieve the same solution quality.\n", "\n", "### `execution=\"live\"` Mode in Ket\n", "\n", "FALQON requires measuring the system **between** layers (to calculate $\\beta_k$) and continuing\n", "to apply gates to the same state. This is possible in Ket using `execution=\"live\"`, which keeps\n", "the quantum state active in the simulator and allows interleaved reading/writing.\n", "\n", "This is an exclusive Ket feature that greatly facilitates FALQON implementation!\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "7e1abe7b", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:30.429182Z", "iopub.status.busy": "2026-08-05T16:37:30.428890Z", "iopub.status.idle": "2026-08-05T16:37:30.434613Z", "shell.execute_reply": "2026-08-05T16:37:30.433637Z" } }, "outputs": [], "source": [ "def falqon_layer(edges, qubits, beta, delta_t):\n", " \"\"\"\n", " Applies one FALQON layer to the current state.\n", "\n", " Each layer consists of:\n", " 1. Cost evolution: e^{-i ฮ”t H_C}\n", " 2. Mixer evolution: e^{-i ฮฒยทฮ”t H_M}\n", "\n", " The parameter ฮฒ is determined by the feedback from the previous state,\n", " while ฮ”t is a fixed time step (analogous to a numerical integration step).\n", "\n", " Parameters\n", " ----------\n", " edges : graph edges\n", " qubits : process qubits (state preserved between calls with execution='live')\n", " beta : feedback parameter computed in the previous iteration\n", " delta_t : time step (controls the magnitude of the evolution per layer)\n", " \"\"\"\n", " evolve(delta_t * cost_h(edges, qubits)) # e^{-i ฮ”t H_C}\n", " evolve(beta * delta_t * mixer_h(qubits)) # e^{-i ฮฒยทฮ”t H_M}\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "93c4aeca", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:30.436996Z", "iopub.status.busy": "2026-08-05T16:37:30.436768Z", "iopub.status.idle": "2026-08-05T16:37:30.441505Z", "shell.execute_reply": "2026-08-05T16:37:30.440633Z" } }, "outputs": [], "source": [ "def beta_h(edges, qubits):\n", " \"\"\"\n", " Builds the commutator Hamiltonian for computing the feedback parameter ฮฒ.\n", "\n", " The Lyapunov law of FALQON determines:\n", " ฮฒ_k = -โŸจi[H_M, H_C]โŸฉ_k = -โŸจi(H_MยทH_C - H_CยทH_M)โŸฉ_k\n", "\n", " The expected value of this Hamiltonian in the current state gives exactly\n", " the ฮฒ that guarantees the energy will not increase in the next layer.\n", "\n", " Note: The @ operator in Ket represents the product of Hamiltonians (composition).\n", " \"\"\"\n", " Hm = mixer_h(qubits)\n", " Hc = cost_h(edges, qubits)\n", " # Commutator: [H_M, H_C] = H_MยทH_C - H_CยทH_M\n", " # Multiplied by i and negated, we get ฮฒ that guarantees energy decrease\n", " A = 1j * (Hm @ Hc - Hc @ Hm)\n", " return -A\n" ] }, { "cell_type": "markdown", "id": "2720c79b", "metadata": {}, "source": [ "### FALQON Circuit Visualization\n", "\n", "Let's see what a FALQON layer looks like with example parameters:\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "2d652966", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:30.443534Z", "iopub.status.busy": "2026-08-05T16:37:30.443339Z", "iopub.status.idle": "2026-08-05T16:37:30.523771Z", "shell.execute_reply": "2026-08-05T16:37:30.523257Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# FALQON layer visualization with ฮฒ=0.1, ฮ”t=0.2\n", "delta_t = 0.01 # time step, small value for smooth evolution\n", "\n", "qulib.draw(partial(falqon_layer, graphs[n], beta=0.1, delta_t=0.2), n, fold=-1)\n" ] }, { "cell_type": "markdown", "id": "82ef6c86", "metadata": {}, "source": [ "### Executing FALQON\n", "\n", "The FALQON loop is simple and deterministic: at each iteration, we apply a layer and\n", "calculate the next $\\beta$ from the current state.\n", "\n", "**Difference from QAOA/VQE:** There is no call to SciPy! The entire process is quantum-deterministic.\n" ] }, { "cell_type": "code", "execution_count": 19, "id": "92c002b1", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:30.525597Z", "iopub.status.busy": "2026-08-05T16:37:30.525517Z", "iopub.status.idle": "2026-08-05T16:37:30.528085Z", "shell.execute_reply": "2026-08-05T16:37:30.527795Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "FALQON: 64 layers, ฮ”t = 0.01\n", "Running...\n" ] } ], "source": [ "# โ”€โ”€ Configuration โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "num_layers = 64 # number of layers (more layers = better approximation)\n", "delta_t = 0.01 # time step (smaller = smoother evolution, but more layers needed)\n", "\n", "# History for convergence visualization\n", "beta_list = [0.0] # ฮฒโ‚€ = 0 (no mixer evolution in the first layer)\n", "cost_list = [] # energy โŸจH_CโŸฉ over the layers\n", "\n", "# โ”€โ”€ Process with execution='live' โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "# This mode keeps the quantum state active between calls, allowing\n", "# measurements and new gates to be interleaved on the same state.\n", "process = Process(\n", " num_qubits=n,\n", " simulator=\"dense\",\n", " execution=\"live\", # persistent state between operations!\n", ")\n", "\n", "# Initial state: uniform superposition |+โŸฉ^โŠ—n\n", "qubits = H(process.alloc(n))\n", "\n", "print(f\"FALQON: {num_layers} layers, ฮ”t = {delta_t}\")\n", "print(\"Running...\")\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "d1d16004", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:30.529075Z", "iopub.status.busy": "2026-08-05T16:37:30.529011Z", "iopub.status.idle": "2026-08-05T16:37:30.581475Z", "shell.execute_reply": "2026-08-05T16:37:30.580870Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial energy: -4.5000\n", "Final energy: -5.7050\n", "Energy reduction: 1.2050\n" ] } ], "source": [ "# โ”€โ”€ Feedback loop โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "for k in range(num_layers):\n", " # Step 1: apply the k-th layer with ฮฒ computed in the previous step\n", " falqon_layer(graphs[n], qubits, beta_list[-1], delta_t)\n", "\n", " # Step 2: FEEDBACK โ€” measure the commutator to get the next ฮฒ\n", " # exp_value() queries the current state WITHOUT collapsing the quantum state\n", " beta_k = exp_value(beta_h(graphs[n], qubits)).get()\n", " beta_list.append(beta_k)\n", "\n", " # Step 3: record the current energy for monitoring\n", " cost_k = exp_value(cost_h(graphs[n], qubits)).get()\n", " cost_list.append(cost_k)\n", "\n", "print(f\"Initial energy: {cost_list[0]:.4f}\")\n", "print(f\"Final energy: {cost_list[-1]:.4f}\")\n", "print(f\"Energy reduction: {cost_list[0] - cost_list[-1]:.4f}\")\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "97d2ba04", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:30.582762Z", "iopub.status.busy": "2026-08-05T16:37:30.582666Z", "iopub.status.idle": "2026-08-05T16:37:33.072892Z", "shell.execute_reply": "2026-08-05T16:37:33.071335Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Most probable state: 110001 (integer: 49)\n" ] }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# โ”€โ”€ Final result โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "samples_falqon = sample(qubits)\n", "samples_falqon.histogram(\"bin\", hamiltonian=partial(cost_h, graphs[n])).show()\n", "\n", "best_state_falqon = samples_falqon.most_frequent_state()\n", "print(\n", " f\"\\nMost probable state: {bin(best_state_falqon)[2:].zfill(n)} (integer: {best_state_falqon})\"\n", ")\n", "plot_maxcut(n, best_state_falqon)\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "3015446f", "metadata": { "execution": { "iopub.execute_input": "2026-08-05T16:37:33.076436Z", "iopub.status.busy": "2026-08-05T16:37:33.076173Z", "iopub.status.idle": "2026-08-05T16:37:35.684628Z", "shell.execute_reply": "2026-08-05T16:37:35.683350Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# โ”€โ”€ FALQON convergence charts โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€\n", "layers = list(range(1, len(cost_list) + 1))\n", "\n", "# Energy trajectory (must be monotonically decreasing!)\n", "fig_cost = px.line(\n", " x=layers,\n", " y=cost_list,\n", " labels={\"x\": \"Layer k\", \"y\": \"โŸจH_CโŸฉ (Energy)\"},\n", " title=\"FALQON: Energy Trajectory over Layers
Monotonic convergence guaranteed by Lyapunov's law\",\n", " markers=True,\n", " color_discrete_sequence=[\"#636EFA\"],\n", ")\n", "fig_cost.add_hline(\n", " y=min(cost_list),\n", " line_dash=\"dash\",\n", " line_color=\"red\",\n", " annotation_text=f\"Minimum energy: {min(cost_list):.4f}\",\n", ")\n", "fig_cost.show()\n", "\n", "# Feedback parameter ฮฒ evolution over layers\n", "fig_beta = px.line(\n", " x=layers,\n", " y=beta_list[1:], # discard initial ฮฒโ‚€ = 0\n", " labels={\"x\": \"Layer k\", \"y\": \"ฮฒ_k (feedback parameter)\"},\n", " title=\"FALQON: Feedback Parameter ฮฒ over Layers
Computed from the commutator i[H_M, H_C]\",\n", " markers=True,\n", " color_discrete_sequence=[\"#EF553B\"],\n", ")\n", "fig_beta.add_hline(y=0, line_dash=\"dot\", line_color=\"gray\")\n", "fig_beta.show()" ] }, { "cell_type": "markdown", "id": "9b184936", "metadata": {}, "source": [ "Note that the energy is monotonically decreasing, a theoretical guarantee of FALQON!" ] }, { "cell_type": "markdown", "id": "ad3d2e6a", "metadata": {}, "source": [ "## ๐ŸŽ“ Conclusions and Next Steps\n", "\n", "### What we learned\n", "\n", "In this tutorial, we implemented three quantum optimization algorithms using the **Ket** language:\n", "\n", "| Algorithm | Strength | When to use |\n", "| :--- | :--- | :--- |\n", "| **QAOA** | Physically motivated ansatz, good scaling with $p$ | When problem structure is well known |\n", "| **VQE** | Automatic gradients, fast convergence | When using real hardware with limited connectivity |\n", "| **FALQON** | Guaranteed monotonic convergence, no classical optimizer | When avoiding barren plateaus is critical |\n", "\n", "### Ket Features Used\n", "\n", "- **`with obs()`**: Building Hamiltonians as quantum observables\n", "- **`evolve(t * H)`**: Exact time evolution $e^{-i t H}$ without manual decomposition\n", "- **`exp_value(H).get()`**: Calculating the expected value $\\langle H \\rangle$\n", "- **`sample(q)`**: Sampling the final quantum state\n", "- **`process.param(*ฮธ)`**: Differentiable parameters for automatic gradients\n", "- **`execution=\"batch\"`**: Efficient batch submission to the simulator\n", "- **`execution=\"live\"`**: Persistent state between operations (essential for FALQON)\n" ] } ], "metadata": { "kernelspec": { "display_name": "quantum-ket.gitlab.io (3.14.6.final.0)", "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.14.6" } }, "nbformat": 4, "nbformat_minor": 5 }