From 6aba92509e2286e50276bafd61af695b95c61598 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Thu, 3 Apr 2025 17:02:04 -0400 Subject: [PATCH 01/20] Create demo Jupyter notebook --- demonstrations/hidden_cut.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 demonstrations/hidden_cut.ipynb diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb new file mode 100644 index 0000000000..e69de29bb2 From c5ae8553eb56a255e50aa949b099be77648ea34f Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Mon, 7 Apr 2025 16:45:49 -0400 Subject: [PATCH 02/20] Working on hidden cut demo --- demonstrations/hidden_cut.ipynb | 257 ++++++++++++++++++++++++++++++++ 1 file changed, 257 insertions(+) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index e69de29bb2..06dee53114 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The hidden cut algorithm for locating unentanglement" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pennylane as qml\n", + "from scipy.stats import unitary_group" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def random_state(dim):\n", + " return unitary_group.rvs(dim)[0]\n", + "\n", + "def separable_state(*sizes):\n", + " state = np.array([1])\n", + " for n in sizes:\n", + " component = random_state(2**n)\n", + " state = np.kron(state, component)\n", + " return state\n", + "\n", + "state = separable_state(2, 3)\n", + "n = int(np.log2(len(state)))\n", + "\n", + "dev = qml.device('default.qubit')\n", + "\n", + "@qml.qnode(dev)\n", + "def purity(state, qubits):\n", + " qml.StatePrep(state, wires=range(n))\n", + " return qml.purity(wires=qubits)\n", + "\n", + "# p = purity(state, qubits=[0,1])\n", + "\n", + "@qml.qnode(dev)\n", + "def density_matrix(state, qubits):\n", + " qml.StatePrep(state, wires=range(n))\n", + " return qml.density_matrix(qubits)\n", + "\n", + "# rho = density_matrix(state, [0,1])\n", + "# np.trace(rho @ rho).round(5).item()\n", + "\n", + "bitstrings = []\n", + "purities = []\n", + "\n", + "for x in range(1, len(state)):\n", + " bitstring = [int(bit) for bit in bin(x)[2:].zfill(n)]\n", + " subsystem = [i for i in range(n) if bitstring[i] == 1]\n", + " bitstrings.append(''.join(str(bit) for bit in bitstring))\n", + " purities.append(purity(state, subsystem))\n", + "\n", + "plt.bar(bitstrings, purities)\n", + "plt.xticks(rotation=90)\n", + "plt.axhline(y=1.0, color='r', ls='--')\n", + "plt.xlabel('subsystem')\n", + "plt.title('Subsystem purities')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [1, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [1, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [1, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [1, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [1, 1, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [0, 0, 1, 0, 1],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 1],\n", + " [1, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 1, 1, 0],\n", + " [1, 1, 0, 0, 0],\n", + " [1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [1, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0]])" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_pairs = 1\n", + "n_qubits = n * (2 * n_pairs + 1)\n", + "dev = qml.device('lightning.qubit', shots=100, wires=n_qubits)\n", + "\n", + "@qml.qnode(dev)\n", + "def hidden_cut_circuit(state):\n", + " # Create state\n", + " for pair in range(n_pairs):\n", + " for copy in range(2):\n", + " offset = n + 2 * n * pair + n * copy\n", + " qml.StatePrep(state, wires=range(offset, offset + n))\n", + " \n", + " # Hadamard transform\n", + " for wire in range(n):\n", + " qml.Hadamard(wires=wire)\n", + "\n", + " # Controlled swaps\n", + " for c in range(n):\n", + " for pair in range(n_pairs):\n", + " a = c + n + 2*n*pair\n", + " b = c + n + 2*n*pair + n\n", + " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", + "\n", + " # Hadamard transform\n", + " for wire in range(0, n):\n", + " qml.Hadamard(wires=wire)\n", + "\n", + " # Measure\n", + " return qml.sample(wires=range(n))\n", + "\n", + "hidden_cut_circuit(state)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qml", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 3cddafcc8f93d0ac1b81fa140ccaa27f1cb567ee Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Fri, 11 Apr 2025 16:38:52 -0400 Subject: [PATCH 03/20] Work on hidden cut demo --- demonstrations/hidden_cut.ipynb | 142 +++++++------------------------- 1 file changed, 32 insertions(+), 110 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index 06dee53114..7d2669b372 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -85,128 +85,30 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 166, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "array([[0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [1, 1, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [1, 1, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [1, 1, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [1, 1, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [1, 1, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [0, 0, 1, 0, 1],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 1, 1],\n", - " [1, 1, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0],\n", - " [1, 1, 0, 0, 0],\n", - " [1, 1, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [1, 1, 1, 1, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0],\n", - " [0, 0, 0, 0, 0]])" + "
" ] }, - "execution_count": 84, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "n_pairs = 1\n", - "n_qubits = n * (2 * n_pairs + 1)\n", - "dev = qml.device('lightning.qubit', shots=100, wires=n_qubits)\n", + "t = 1\n", + "total_qubits = (2*t + 1) * n\n", + "# dev = qml.device('lightning.qubit', shots=100, wires=n_qubits)\n", + "dev = qml.device('default.qubit', shots=100)\n", "\n", "@qml.qnode(dev)\n", "def hidden_cut_circuit(state):\n", - " # Create state\n", - " for pair in range(n_pairs):\n", + " # Create copies of state\n", + " for pair in range(t):\n", " for copy in range(2):\n", " offset = n + 2 * n * pair + n * copy\n", " qml.StatePrep(state, wires=range(offset, offset + n))\n", @@ -217,19 +119,39 @@ "\n", " # Controlled swaps\n", " for c in range(n):\n", - " for pair in range(n_pairs):\n", + " for pair in range(t):\n", " a = c + n + 2*n*pair\n", " b = c + n + 2*n*pair + n\n", " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", "\n", + " qml.Snapshot('after_swaps', qml.density_matrix(range(n)))\n", + "\n", " # Hadamard transform\n", " for wire in range(0, n):\n", " qml.Hadamard(wires=wire)\n", "\n", " # Measure\n", + " qml.Snapshot('final', qml.density_matrix(range(n)))\n", " return qml.sample(wires=range(n))\n", "\n", - "hidden_cut_circuit(state)" + "snapshots = qml.snapshots(hidden_cut_circuit)(state)\n", + "rho_after_swaps = snapshots['after_swaps']\n", + "evals, evecs = np.linalg.eig(rho_after_swaps)\n", + "probs = np.abs(evecs[1])**2\n", + "bitstrings = [bin(x)[2:].zfill(n) for x in range(2**n)]\n", + "\n", + "plt.bar(bitstrings, probs)\n", + "plt.xticks(rotation=90)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# why does this work for a single pair??" ] } ], From 2c64bf39a7b922c49bb233df419bab454a111a75 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Thu, 17 Apr 2025 16:36:46 -0400 Subject: [PATCH 04/20] Work on demo outline --- demonstrations/hidden_cut.ipynb | 195 +++++++++++++++++++++++--------- 1 file changed, 139 insertions(+), 56 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index 7d2669b372..6acc3efaea 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -19,6 +19,65 @@ "from scipy.stats import unitary_group" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# motivation: given a separable state, find hidden cut\n", + "\n", + "# create separable state\n", + "\n", + "# verify that state is separable by plotting all purities\n", + "\n", + "# how do we find hidden cut? \n", + "\n", + "# one way would be compute purities of all subsytems and see which subsystem has purity = 1. But this is impractical since there are exponentially many subsystems\n", + "\n", + "# let's look at subsystem purity function more closely - colour in bars that are the same height the same colour.\n", + "\n", + "# how are bars of the same height related? by adding eg (10100) and (01011).\n", + "\n", + "# ie pi(s) = pi(s + 10100) + pi(s + 01011) + pi(s + 11111).\n", + "\n", + "# ie the symmetry is generated by the group H = ...\n", + "\n", + "# H is a subgroup of the full group G = {00000, 00001, ...} with the group operation being bitwise addition modulo 2.\n", + "\n", + "# Notice that H has 4 elements but it can be \"generated\" by ... and ..., meaning that the other elements (... and ...) can be obtained via the two generators and the group operation.\n", + "\n", + "# do you notice anything interesting about the generators? they directly encode the separable components of the state!\n", + "\n", + "# so in order to find the separable components of the state, we just have to find the symmetry subgroup of the purity function pi(s), and look at its generators.\n", + "\n", + "# this is an example of a \"hidden subgroup problem\" a very important class of problems that quantum computers can solve efficiently. \n", + "\n", + "# Notice that it wasnt at all obvious that our problem of finding the separable components of a state was a hidden subgroup problem; we needed to think a bit to frame it in this way. In fact the same is true for the most famous problem solveable by quantum computers: factoring large integers. At first this doesn't look anything like a hidden subgroup problem, but as Peter Shor showed with some clever math it can be phrased as one, and can therefore be solved by the general quantum circuit for hidden subgroup problems.\n", + "\n", + "# We'd like to use this quantum circuit to solve our \"hidden cut\" problem. So how does the HSP quantum circuit look?\n", + "\n", + "# Suppose we want to find the hidden symmetry subgroup of a function f(s) over n-bit strings s. we start with two n-qubit registers initialized in the all |0> states. \n", + "# the first step is to apply a Hadamard to each qubit in the first register to create a uniform superposition sum |s>.\n", + "# the second step assumes that we have access to a unitary U_f that maps |s>|0> to |s>|f(s)>, such that |f(s)> and |f(s')> are equal if f(s) = f(s') and orthogonal if f(s) != f(s').\n", + "# the final step is to again apply Hadamards to the first register, and measure this register.\n", + "# the circuit looks like:\n", + "\n", + "\n", + "# where U(f) is the unitary computing f into the second register.\n", + "# the measurement bitstrings are guaranteed to be orthogonal to the hidden subgroup bitstrings (ie the bitstrings defining the symmetry of f(s)).\n", + "# for example if we get a measurement outcome ..., then a hidden subgroup element might be ... because ..., but ... is definitely not in the hidden subgroup, because ....\n", + "# Therefore by obtaining measurment outcomes and finding the bitstrings orthogonal to all measurments, we will identify the hidden symmetry of f.\n", + "\n", + "# Now let's apply this to solve the hidden cut problem for the state psi. Remember that here the function f(s) is pi(s), the purity of psi's subsystems.\n", + "# We immediately run into a problem however. Unlike in the basic HSP problem, we arent provided with a unitary mapping |s>|0> to |s>|pi(s)>.\n", + "# So what do we do? Let's create the unitary!\n", + "\n", + "# Recall the key property that the unitary is supposed to have: |f(s)> and |f(s')> should be equal if f(s) = f(s') and orthogonal if f(s) != f(s').\n", + "# Consider the controlled swap unitary, mapping |s>|psi>|psi> to |s>SWAP_s(|psi>|psi>), where \n", + "\n" + ] + }, { "cell_type": "code", "execution_count": 75, @@ -85,73 +144,97 @@ }, { "cell_type": "code", - "execution_count": 166, + "execution_count": 205, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "t = 1\n", - "total_qubits = (2*t + 1) * n\n", - "# dev = qml.device('lightning.qubit', shots=100, wires=n_qubits)\n", - "dev = qml.device('default.qubit', shots=100)\n", "\n", - "@qml.qnode(dev)\n", - "def hidden_cut_circuit(state):\n", - " # Create copies of state\n", - " for pair in range(t):\n", - " for copy in range(2):\n", - " offset = n + 2 * n * pair + n * copy\n", - " qml.StatePrep(state, wires=range(offset, offset + n))\n", - " \n", - " # Hadamard transform\n", - " for wire in range(n):\n", - " qml.Hadamard(wires=wire)\n", - "\n", - " # Controlled swaps\n", - " for c in range(n):\n", - " for pair in range(t):\n", - " a = c + n + 2*n*pair\n", - " b = c + n + 2*n*pair + n\n", - " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", - "\n", - " qml.Snapshot('after_swaps', qml.density_matrix(range(n)))\n", - "\n", - " # Hadamard transform\n", - " for wire in range(0, n):\n", - " qml.Hadamard(wires=wire)\n", - "\n", - " # Measure\n", - " qml.Snapshot('final', qml.density_matrix(range(n)))\n", - " return qml.sample(wires=range(n))\n", - "\n", - "snapshots = qml.snapshots(hidden_cut_circuit)(state)\n", - "rho_after_swaps = snapshots['after_swaps']\n", - "evals, evecs = np.linalg.eig(rho_after_swaps)\n", - "probs = np.abs(evecs[1])**2\n", + "def hidden_cut_circuit(state, n_copies=1):\n", + "\n", + " n = int(np.log2(len(state)))\n", + " n_qubits = (2 * n_copies + 1) * n\n", + " dev = qml.device('lightning.qubit', wires=n_qubits)\n", + "\n", + " @qml.qnode(dev)\n", + " def _circuit():\n", + " # Create copies of state\n", + " for pair in range(n_copies):\n", + " for copy in range(2):\n", + " offset = n + 2 * n * pair + n * copy\n", + " qml.StatePrep(state, wires=range(offset, offset + n))\n", + " \n", + " # Hadamard transform\n", + " for wire in range(n):\n", + " qml.Hadamard(wires=wire)\n", + "\n", + " # Controlled swaps\n", + " for c in range(n):\n", + " for pair in range(n_copies):\n", + " a = c + n + 2*n*pair\n", + " b = c + n + 2*n*pair + n\n", + " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", + "\n", + " # Hadamard transform\n", + " for wire in range(0, n):\n", + " qml.Hadamard(wires=wire)\n", + "\n", + " # Return probs of first register\n", + " return qml.probs(wires=range(n))\n", + "\n", + " return _circuit()\n", + " \n", + "probs = hidden_cut_circuit(state, n_copies=1)\n", "bitstrings = [bin(x)[2:].zfill(n) for x in range(2**n)]\n", "\n", - "plt.bar(bitstrings, probs)\n", - "plt.xticks(rotation=90)\n", - "plt.show()" + "# plt.bar(bitstrings, probs)\n", + "# plt.xticks(rotation=90)\n", + "# plt.show()\n", + "\n", + "# np.random.choice(len(probs), size=100, p=probs)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 219, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/petar.simidzija/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/debugging/snapshot.py:243: UserWarning: Snapshots are not supported for the given device. Therefore, a tape will be created for each snapshot, resulting in a total of n_snapshots + 1 executions.\n", + " warnings.warn(\n" + ] + }, + { + "ename": "DeviceError", + "evalue": "Measurement state(wires=[]) not accepted with finite shots on lightning.qubit", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mDeviceError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[219], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# return qml.state()\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mprobs()\n\u001b[0;32m----> 9\u001b[0m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msnapshots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:987\u001b[0m, in \u001b[0;36mQNode.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 985\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mcapture\u001b[38;5;241m.\u001b[39menabled():\n\u001b[1;32m 986\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mcapture\u001b[38;5;241m.\u001b[39mqnode_call(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 987\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impl_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:977\u001b[0m, in \u001b[0;36mQNode._impl_call\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_interface \u001b[38;5;241m=\u001b[39m interface\n\u001b[1;32m 976\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 977\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_component\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 978\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 979\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m old_interface \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mauto\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:935\u001b[0m, in \u001b[0;36mQNode._execution_component\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 932\u001b[0m interface \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minterface \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnumpy\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minterface\n\u001b[1;32m 934\u001b[0m \u001b[38;5;66;03m# pylint: disable=unexpected-keyword-arg\u001b[39;00m\n\u001b[0;32m--> 935\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 936\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_tape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 937\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 938\u001b[0m \u001b[43m \u001b[49m\u001b[43mgradient_fn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgradient_fn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 939\u001b[0m \u001b[43m \u001b[49m\u001b[43minterface\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterface\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 940\u001b[0m \u001b[43m \u001b[49m\u001b[43mtransform_program\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfull_transform_program\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 941\u001b[0m \u001b[43m \u001b[49m\u001b[43minner_transform\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minner_transform_program\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 942\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 943\u001b[0m \u001b[43m \u001b[49m\u001b[43mgradient_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgradient_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 944\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mexecute_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 945\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 946\u001b[0m res \u001b[38;5;241m=\u001b[39m res[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 948\u001b[0m \u001b[38;5;66;03m# convert result to the interface in case the qfunc has no parameters\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/execution.py:523\u001b[0m, in \u001b[0;36mexecute\u001b[0;34m(tapes, device, gradient_fn, interface, transform_program, inner_transform, config, grad_on_execution, gradient_kwargs, cache, cachesize, max_diff, device_vjp, mcm_config)\u001b[0m\n\u001b[1;32m 521\u001b[0m \u001b[38;5;66;03m# Exiting early if we do not need to deal with an interface boundary\u001b[39;00m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m no_interface_boundary_required:\n\u001b[0;32m--> 523\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43minner_execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m post_processing(results)\n\u001b[1;32m 526\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m config\u001b[38;5;241m.\u001b[39muse_device_jacobian_product \u001b[38;5;129;01mand\u001b[39;00m interface \u001b[38;5;129;01min\u001b[39;00m jpc_interfaces:\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/execution.py:199\u001b[0m, in \u001b[0;36m_make_inner_execute..inner_execute\u001b[0;34m(tapes, **_)\u001b[0m\n\u001b[1;32m 196\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cache \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 197\u001b[0m transform_program\u001b[38;5;241m.\u001b[39madd_transform(_cache_transform, cache\u001b[38;5;241m=\u001b[39mcache)\n\u001b[0;32m--> 199\u001b[0m transformed_tapes, transform_post_processing \u001b[38;5;241m=\u001b[39m \u001b[43mtransform_program\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m transformed_tapes:\n\u001b[1;32m 202\u001b[0m results \u001b[38;5;241m=\u001b[39m device\u001b[38;5;241m.\u001b[39mexecute(transformed_tapes, execution_config\u001b[38;5;241m=\u001b[39mexecution_config)\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/transforms/core/transform_program.py:515\u001b[0m, in \u001b[0;36mTransformProgram.__call__\u001b[0;34m(self, tapes)\u001b[0m\n\u001b[1;32m 513\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_argnums \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_argnums[i] \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 514\u001b[0m tape\u001b[38;5;241m.\u001b[39mtrainable_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_argnums[i][j]\n\u001b[0;32m--> 515\u001b[0m new_tapes, fn \u001b[38;5;241m=\u001b[39m \u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 516\u001b[0m execution_tapes\u001b[38;5;241m.\u001b[39mextend(new_tapes)\n\u001b[1;32m 518\u001b[0m fns\u001b[38;5;241m.\u001b[39mappend(fn)\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/devices/preprocess.py:525\u001b[0m, in \u001b[0;36mvalidate_measurements\u001b[0;34m(tape, analytic_measurements, sample_measurements, name)\u001b[0m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m sample_measurements(m):\n\u001b[0;32m--> 525\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mDeviceError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMeasurement \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mm\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not accepted with finite shots on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 527\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 528\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n", + "\u001b[0;31mDeviceError\u001b[0m: Measurement state(wires=[]) not accepted with finite shots on lightning.qubit" + ] + } + ], "source": [ - "# why does this work for a single pair??" + "dev = qml.device('lightning.qubit', shots=10, wires=[0])\n", + "@qml.qnode(dev)\n", + "def circuit():\n", + " qml.Hadamard(wires=0)\n", + " qml.Snapshot('tag', qml.state())\n", + " # return qml.state()\n", + " return qml.probs()\n", + "\n", + "qml.snapshots(circuit)()" ] } ], From 6217b8167e85aadeff0acf26cffb6ee458d5cdbd Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Mon, 21 Apr 2025 16:20:36 -0400 Subject: [PATCH 05/20] Finish outline of hidden cut demo --- demonstrations/hidden_cut.ipynb | 74 +++++++++++++++++++++++++++++++-- 1 file changed, 70 insertions(+), 4 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index 6acc3efaea..2e9c3576d6 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -63,9 +63,7 @@ "# the final step is to again apply Hadamards to the first register, and measure this register.\n", "# the circuit looks like:\n", "\n", - "\n", - "# where U(f) is the unitary computing f into the second register.\n", - "# the measurement bitstrings are guaranteed to be orthogonal to the hidden subgroup bitstrings (ie the bitstrings defining the symmetry of f(s)).\n", + "# The crucial feature of this circuit is that the measurement outcomes are guaranteed to be orthogonal to the hidden subgroup bitstrings (ie the bitstrings defining the symmetry of f(s)).\n", "# for example if we get a measurement outcome ..., then a hidden subgroup element might be ... because ..., but ... is definitely not in the hidden subgroup, because ....\n", "# Therefore by obtaining measurment outcomes and finding the bitstrings orthogonal to all measurments, we will identify the hidden symmetry of f.\n", "\n", @@ -74,7 +72,75 @@ "# So what do we do? Let's create the unitary!\n", "\n", "# Recall the key property that the unitary is supposed to have: |f(s)> and |f(s')> should be equal if f(s) = f(s') and orthogonal if f(s) != f(s').\n", - "# Consider the controlled swap unitary, mapping |s>|psi>|psi> to |s>SWAP_s(|psi>|psi>), where \n", + "# Consider the controlled swap unitary, mapping |s>|psi>|psi> to |s>SWAP_s(|psi>|psi>), where s denotes the qubits to be swapped between the two copies of |psi>\n", + "\n", + "# Let's check if the controlled swap unitary has the desired properties.\n", + "# First, if pi(s) = pi(s') we want SWAP_s(|psi>|psi>) to equal SWAP_s(|psi>|psi>). \n", + "# Let's consider an example. We see from our plot of pi(s) that ... and ... have the same value of pi.\n", + "# Let's check the inner product of SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>):\n", + "\n", + "# Since the inner product is 1, the SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>) must be identical.\n", + "\n", + "# Now let's check whether pi(s) != pi(s') implies SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>)...\n", + "\n", + "# So it turns out that SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>) are not orthogonal and so the SWAP_s unitary does not satisfy the second requirement for the unitary in the HSP circuit.\n", + "\n", + "# Even though we don't expect it to work, let's nevertheless try running the HSP circuit with the SWAP_s unitary, and see what happens.\n", + "\n", + "# ...10 samples\n", + "\n", + "# Remember the final postprocessing step to solving an HSP via a quantum computer: we have to determine the bitstrings orthogonal to the measurement outcomes, where two bitstrings s and t are orthogonal if s.t = 0 modulo 2. This is a basic linear algebra problem that amounts to finding the nullspace of the matrix of measurement outcomes over the finite field GF(2).\n", + "\n", + "# But by being clever we can avoid doing any linear algebra.\n", + "\n", + "# Look at the allowed measurement outcomes very carefully. Do you notice anything in common between them?\n", + "\n", + "# The answer: they are exactly those bitstrings that have an even number of 1s in positions ... *and* an even number of 1s in positions ...\n", + "\n", + "# This means that the only bitstrings orthogonal to the allowed measurement outcomes are the all 0 bitstring, the all 1 bitstring, the bitstring ... and the bitstring ...\n", + "\n", + "# This is exactly the hidden subgroup generated by ... and ..., where the generators encode the separable components ... and ... of the original state |psi>.\n", + "\n", + "# Therefore the HSP circuit with the SWAP_s unitary finds the separable components!\n", + "\n", + "# Let's check it with another state to make sure we didn't just get lucky.\n", + "\n", + "# This time let's consider a 4 qubit state ...\n", + "\n", + "\n", + "# again it works!\n", + "\n", + "# So we have solved the hidden cut problem by rephrasing it as an HSP and using the unitary SWAP_s.\n", + "\n", + "# but why does this work? Recall that in the standard quantum circuit for HSP we need |f(s)> and |f(s')> should be equal if f(s) = f(s') and orthogonal if f(s) != f(s'). However in our case f(s) is the purity function pi(s), and we set |pi(s)> = SWAP_s(|psi>|psi>). We saw above that this satisfies the equality requirement, but not the orthogonality requirement. Namely pi(s) != pi(s') doesn't generally imply that |pi(s)> and |pi(s')> are orthogonal.\n", + "\n", + "# To understand why our circuit worked despite this non-orthogonality, let's think about how we could have defined |pi(s)> differently so that the orthogonality requirement *was* satisfied.\n", + "# This is actually quite straightforward: just define |pi(s)> = [SWAP_s(|psi>|psi>)]^t for some large t. \n", + "# Then as long as the inner product between SWAP_s(|psi>|psi>) and SWAP_s(|psi>|psi>) is not 1 (ie they aren't identical), the inner product between |pi(s)> and |pi(s')> will be effectively 0 (exponentially approach 0 as t increases).\n", + "\n", + "# So if instead of using only 1 pair |psi>|psi> in our quantum circuit we used t pairs, for large enough t this would've exactly functioned like a standard issue HSP circuit.\n", + "\n", + "# Unfortunately the circuit with t pairs of |psi>|psi> requires (1 + 2t) * n qubits (the 1 is for the control register and the 2t for the 2t pairs of |psi>|psi>), so simulating this with n=4 is not feasible for t > 2.\n", + "\n", + "# With that in mind let's look consider the circuit with t=2 and compare with what we got above with t=1. Hopefully we'll see something interesting that we can extrapolate to t -> inf.\n", + "\n", + "# ...\n", + "\n", + "# plot probs histograms\n", + "\n", + "# we notice that the same measurement outcomes are allowed, and only their probabilities differ.\n", + "\n", + "# in particular the distribution is more skewed towards outcomes with fewer 1s for t=1, and more uniform for t=2\n", + "\n", + "# we can conjecture that this trend continues for larger t: the allowed outcomes remain the same as in the t=1 case, but the distribution becomes more and more uniform.\n", + "\n", + "# in fact this it can be proven analytically that this conjecture is correct, and if we had a powerful enough simulator (or a quantum computer), we'd be able to verify this.\n", + "\n", + "# So now we can understand why our hidden cut circuit with only 1 pair of |psi>s worked, when naively we didn't expect it to. It is because the allowed measurement outcomes from the output of this t=1 circuit are exactly the allowed measurmenet outcomes from the t-> infty circuit. Because the outcome of the final postprocessing step of the quantum HSP algorithm only depends on the allowed measurement outcomes and not on their probabilities, the t=1 algorithm is able to get the same outcome as the large t algorithm. \n", + "\n", + "# So should we use small t or large t?\n", + "\n", + "# do sample efficiency experiment. Expect result to be: use large t if you can because it's more sample efficient. \n", "\n" ] }, From 7b343879ad73d1f0a0fbd66f94ffbb0f98e7c566 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Wed, 23 Apr 2025 16:46:30 -0400 Subject: [PATCH 06/20] Write intro and define function for creating separable state --- demonstrations/hidden_cut.ipynb | 111 +++++++++++++++++++++++++++++--- 1 file changed, 102 insertions(+), 9 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index 2e9c3576d6..d7a6c4e32e 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -7,16 +7,113 @@ "# The hidden cut algorithm for locating unentanglement" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the most interesting and counterintuitive features of quantum physics is entanglement.\n", + "Entanglement is a form of correlation between quantum systems that is fundamentally different from any form of correlation that can exist between classical systems.\n", + "To define entanglement, consider a quantum state $\\ket{\\psi}$ describing a system with two parts, $A$ and $B$.\n", + "For example $A$ and $B$ might each be single qubits in which case $\\ket{\\psi}$ is a two qubit state.\n", + "$A$ and $B$ are *unentangled* or *separable* if $\\ket{\\psi}$ can be written as\n", + "$$\n", + "\\ket{\\psi} = \\ket{\\psi_A}\\otimes \\ket{\\psi_B}\n", + "$$,\n", + "where $\\ket{\\psi_A}$ is a state of system $A$ and $\\ket{\\psi_B}$ is a state of system $B$.\n", + "If $\\ket{\\psi}$ can't be written in this form then $A$ and $B$ are entangled.\n", + "\n", + "Now imagine we're given a system of $n$ qubits instead of just two.\n", + "We're told that it's possible to split the $n$ qubits into two subsets, call them $S$ and $\\bar S$, so that these two subsets are unentangled.\n", + "In other words the n-qubit state $\\ket{\\psi}$ can be written as\n", + "$$\n", + "\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}}\n", + "$$\n", + "for some $S$ and $\\bar S$, but we aren't told what $S$ and $\\bar S$ are.\n", + "The problem that we're given is to determine $S$ and $\\bar S$, that is to determine the ``cut'' of the qubits into two unentangled pieces.\n", + "In this demo, following ..., we'll develop a quantum algorithm that solves this problem!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Separable state\n", + "\n", + "Let's start by creating a separable state with $n=5$ qubits.\n", + "We'll set qubits $S=\\{0,3\\}$ to be in a random pure state and qubits $\\bar S=\\{1,2,4\\}$ to be in a random pure state, so that the two sets of qubits are unentangled with each other." + ] + }, { "cell_type": "code", - "execution_count": 70, + "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.05104179+0.0768874j , 0.14573223+0.05676977j,\n", + " -0.02354117+0.15181157j, 0.11545076+0.233352j ,\n", + " 0.00194962+0.11960138j, 0.11936 +0.16384958j,\n", + " -0.1131419 -0.0587655j , -0.21411859+0.02891661j,\n", + " 0.16545246-0.00938228j, -0.07068761+0.06361661j,\n", + " 0.21393898+0.17415643j, -0.15830249-0.00112338j,\n", + " 0.18713396+0.10543924j, -0.12162686+0.02000843j,\n", + " -0.19368165+0.12206295j, 0.04285733-0.12419041j,\n", + " -0.0698666 +0.09858457j, -0.0006671 +0.20477203j,\n", + " -0.0711748 -0.03430414j, -0.13209853+0.02188239j,\n", + " 0.13602099+0.02532102j, 0.21320445-0.09758215j,\n", + " 0.13686031+0.03430691j, 0.22313239-0.0859476j ,\n", + " 0.08943398+0.19768549j, -0.11102345-0.05636713j,\n", + " -0.11771187+0.07920249j, 0.02424504-0.07772378j,\n", + " 0.16259521-0.18785167j, -0.005317 +0.14247389j,\n", + " 0.17728326-0.18100362j, -0.01435067+0.14468343j])" + ] + }, + "execution_count": 239, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import pennylane as qml\n", - "from scipy.stats import unitary_group" + "from scipy.stats import unitary_group\n", + "\n", + "def random_state(n_qubits):\n", + " dim = 2**n_qubits\n", + " return unitary_group.rvs(dim)[0]\n", + "\n", + "def separable_state(partitions):\n", + " # Number of qubits\n", + " n_qubits = sum(len(part) for part in partitions)\n", + "\n", + " # Sort partitions\n", + " partitions = [sorted(part) for part in partitions]\n", + "\n", + " # Create random state for each partition\n", + " partition_states = [(part, random_state(len(part))) for part in partitions]\n", + " \n", + " # Initialize full state\n", + " full_state = np.zeros(2**n_qubits, dtype=complex)\n", + " \n", + " # Fill in amplitudes\n", + " for idx in range(2**n_qubits):\n", + " # Convert idx to binary string\n", + " bits = format(idx, f'0{n_qubits}b')\n", + " \n", + " # Calculate amplitude as product of partition amplitudes\n", + " amplitude = 1.0\n", + " for part, state in partition_states:\n", + " # Extract partition bits, convert to decimal, update amplitude\n", + " part_bits = ''.join(bits[n_qubits-1-q] for q in part)\n", + " part_idx = int(part_bits, 2)\n", + " amplitude *= state[part_idx]\n", + " \n", + " full_state[idx] = amplitude\n", + " \n", + " return full_state\n", + "\n", + "# create 5 qubit state\n", + "state = separable_state([(0,3), (1,2,4)])" ] }, { @@ -25,10 +122,6 @@ "metadata": {}, "outputs": [], "source": [ - "# motivation: given a separable state, find hidden cut\n", - "\n", - "# create separable state\n", - "\n", "# verify that state is separable by plotting all purities\n", "\n", "# how do we find hidden cut? \n", From 1b8759d6180b174f8425c2e50651638387cbbe35 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Thu, 24 Apr 2025 16:07:39 -0400 Subject: [PATCH 07/20] Create separable state --- demonstrations/hidden_cut.ipynb | 287 +++++++++++++++++++++----------- 1 file changed, 188 insertions(+), 99 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index d7a6c4e32e..b51b765445 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -11,77 +11,86 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "One of the most interesting and counterintuitive features of quantum physics is entanglement.\n", - "Entanglement is a form of correlation between quantum systems that is fundamentally different from any form of correlation that can exist between classical systems.\n", - "To define entanglement, consider a quantum state $\\ket{\\psi}$ describing a system with two parts, $A$ and $B$.\n", - "For example $A$ and $B$ might each be single qubits in which case $\\ket{\\psi}$ is a two qubit state.\n", - "$A$ and $B$ are *unentangled* or *separable* if $\\ket{\\psi}$ can be written as\n", + "One of the most interesting and counterintuitive aspects of quantum physics is entanglement.\n", + "Entanglement is a form of correlation between quantum systems that is fundamentally different from any correlation that can exist between classical systems.\n", + "To define entanglement, let $\\ket{\\psi}$ be a state of a quantum system with two parts, $A$ and $B$.\n", + "For example $A$ and $B$ might each be single qubits; then $\\ket{\\psi}$ is a two qubit state.\n", + "We say $A$ and $B$ are *unentangled* or *separable* if $\\ket{\\psi}$ can be written as\n", "$$\n", "\\ket{\\psi} = \\ket{\\psi_A}\\otimes \\ket{\\psi_B}\n", "$$,\n", "where $\\ket{\\psi_A}$ is a state of system $A$ and $\\ket{\\psi_B}$ is a state of system $B$.\n", - "If $\\ket{\\psi}$ can't be written in this form then $A$ and $B$ are entangled.\n", + "If $\\ket{\\psi}$ can't be written in this separable form then we say $A$ and $B$ are *entangled*.\n", "\n", - "Now imagine we're given a system of $n$ qubits instead of just two.\n", - "We're told that it's possible to split the $n$ qubits into two subsets, call them $S$ and $\\bar S$, so that these two subsets are unentangled.\n", - "In other words the n-qubit state $\\ket{\\psi}$ can be written as\n", + "Now suppose we're given a system of $n$ qubits.\n", + "We're told that it's possible to split the qubits into two unentangled subsets, $S$ and $\\bar S$, i.e.\n", + "$\\ket{\\psi}$ can be written as\n", "$$\n", - "\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}}\n", + "\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}},\n", "$$\n", - "for some $S$ and $\\bar S$, but we aren't told what $S$ and $\\bar S$ are.\n", - "The problem that we're given is to determine $S$ and $\\bar S$, that is to determine the ``cut'' of the qubits into two unentangled pieces.\n", - "In this demo, following ..., we'll develop a quantum algorithm that solves this problem!" + "but we aren't told what $S$ and $\\bar S$ are.\n", + "The question is: how can we determine $S$ and $\\bar S$, i.e. how do we determine the ``hidden cut'' that splits the qubits into two unentangled subsystems.\n", + "Following ..., in this demo we'll develop a quantum algorithm that solves this problem!" + ] + }, + { + "cell_type": "code", + "execution_count": 244, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pennylane as qml\n", + "from scipy.stats import unitary_group" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Separable state\n", + "## Creating a separable state\n", "\n", - "Let's start by creating a separable state with $n=5$ qubits.\n", - "We'll set qubits $S=\\{0,3\\}$ to be in a random pure state and qubits $\\bar S=\\{1,2,4\\}$ to be in a random pure state, so that the two sets of qubits are unentangled with each other." + "Let's create a separable state.\n", + "To ensure the quantum algorithm we construct can be simulated in reasonable time, we'll keep things small and consider a state with $n=5$ qubits.\n", + "First we define a function that creates a random state with a specified number of qubits, $n$.\n", + "We do this by creating an $2^n$ by $2^n$ random unitary and taking the first row.\n", + "Because all the rows (and columns) in a unitary matrix have norm equal to 1, this defines a valid quantum state." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, + "outputs": [], + "source": [ + "def random_state(n_qubits):\n", + " dim = 2**n_qubits\n", + " return unitary_group.rvs(dim)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll use this function to set qubits $S=\\{0,3\\}$ and $\\bar S=\\{1,2,4\\}$ to each be in a random pure state.\n", + "The full 5 qubit state will then be separable along this 2-qubit and 3-qubit partition. " + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "array([ 0.05104179+0.0768874j , 0.14573223+0.05676977j,\n", - " -0.02354117+0.15181157j, 0.11545076+0.233352j ,\n", - " 0.00194962+0.11960138j, 0.11936 +0.16384958j,\n", - " -0.1131419 -0.0587655j , -0.21411859+0.02891661j,\n", - " 0.16545246-0.00938228j, -0.07068761+0.06361661j,\n", - " 0.21393898+0.17415643j, -0.15830249-0.00112338j,\n", - " 0.18713396+0.10543924j, -0.12162686+0.02000843j,\n", - " -0.19368165+0.12206295j, 0.04285733-0.12419041j,\n", - " -0.0698666 +0.09858457j, -0.0006671 +0.20477203j,\n", - " -0.0711748 -0.03430414j, -0.13209853+0.02188239j,\n", - " 0.13602099+0.02532102j, 0.21320445-0.09758215j,\n", - " 0.13686031+0.03430691j, 0.22313239-0.0859476j ,\n", - " 0.08943398+0.19768549j, -0.11102345-0.05636713j,\n", - " -0.11771187+0.07920249j, 0.02424504-0.07772378j,\n", - " 0.16259521-0.18785167j, -0.005317 +0.14247389j,\n", - " 0.17728326-0.18100362j, -0.01435067+0.14468343j])" - ] - }, - "execution_count": 239, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Created 5 qubit state.\n" + ] } ], "source": [ - "import numpy as np\n", - "from scipy.stats import unitary_group\n", - "\n", - "def random_state(n_qubits):\n", - " dim = 2**n_qubits\n", - " return unitary_group.rvs(dim)[0]\n", - "\n", "def separable_state(partitions):\n", " # Number of qubits\n", " n_qubits = sum(len(part) for part in partitions)\n", @@ -104,7 +113,7 @@ " amplitude = 1.0\n", " for part, state in partition_states:\n", " # Extract partition bits, convert to decimal, update amplitude\n", - " part_bits = ''.join(bits[n_qubits-1-q] for q in part)\n", + " part_bits = ''.join(bits[q] for q in part)\n", " part_idx = int(part_bits, 2)\n", " amplitude *= state[part_idx]\n", " \n", @@ -112,18 +121,144 @@ " \n", " return full_state\n", "\n", - "# create 5 qubit state\n", - "state = separable_state([(0,3), (1,2,4)])" + "# create separable 5 qubit state\n", + "state = separable_state([(0,3), (1,2,4)])\n", + "n = int(np.log2(len(state)))\n", + "print(f'Created {n} qubit state.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$.\n", + "A general way to check whether a subsystem $S$ of a pure state $\\ket{\\psi}$ is entangled with the complementary subsystem $\\bar S$\n", + "is to consider the reduced density matrix $\\rho_S$ describing the state of $S$ and compute its purity, \n", + "$$\n", + "P(S) := \\text{Tr}(\\rho_S^2).\n", + "$$\n", + "If $S$ and $\\bar S$ are unentangled, i.e. $\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}}$, then $\\rho_S = \\ket{\\psi_S}\\bra{\\psi_S}$\n", + "and the purity of $S$ is $P(S)=1$.\n", + "On the other hand if $S$ and $\\bar S$ *are* entangled, then $\\rho_S$ will be a mixed state, and $P(S)$ will necessarily be less than 1\n", + "(can you prove this?).\n", + "\n", + "So all we need to do to verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$ in our 5 qubit state\n", + "is to check that $P(S) = 1$. \n", + "For fun (and because it'll be instructive) instead of just computing $P(\\{0,3\\})$, let's compute the purities of *all* possible subsystems.\n", + "Because there are 5 qubits we can denote the subsystems using 5 bit strings, where a 1 bit indicates that a qubit belongs to the subsystem.\n", + "For example '10010' denotes the subsystem $S=\\{0,3\\}$.\n", + "Since each bit can be a 1 or a 0, there are $2^5=32$ different subsystems.\n", + "Let's create a histogram showing all 32 subsystem purities.\n", + "First we define a function to compute the purity of a subsystem.\n", + "`qml.purity()` does the heavy lifting:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 254, "metadata": {}, "outputs": [], "source": [ - "# verify that state is separable by plotting all purities\n", + "dev = qml.device('default.qubit')\n", "\n", + "@qml.qnode(dev)\n", + "def get_purity(state, subsystem):\n", + " qml.StatePrep(state, wires=range(n))\n", + " return qml.purity(wires=np.nonzero(subsystem)[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we use this function to compute all subsystem purities and store them in a `purities` list.\n", + "We'll also store the subsystems, encoded as 5-bit strings, into a `bitstrings` list.\n", + "The empty subsystem '00000' is and edge case that `qml.purity()` can't handle, so we add it by hand.\n", + "Because complementary subsystems have identical purities (prove this!), $P('00000') = P('11111') = 1$." + ] + }, + { + "cell_type": "code", + "execution_count": 260, + "metadata": {}, + "outputs": [], + "source": [ + "bitstrings = ['0' * 5]\n", + "purities = [1.]\n", + "\n", + "for subsystem_idx in range(1, 2**n):\n", + " # convert integer index to list of bits\n", + " subsystem = [int(bit) for bit in format(subsystem_idx, f'0{n}b')]\n", + " \n", + " # compute purity and append\n", + " purity = get_purity(state, subsystem)\n", + " purities.append(purity)\n", + "\n", + " # convert bit list to bit string and append\n", + " bitstring = ''.join(str(bit) for bit in subsystem)\n", + " bitstrings.append(bitstring)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can plot the purities in a histogram" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(bitstrings, purities)\n", + "plt.xticks(rotation=90)\n", + "plt.axhline(y=1.0, color='r', ls='--')\n", + "plt.xlabel('subsystem')\n", + "plt.ylabel('purity')\n", + "plt.title('Subsystem purities')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice the 4 subsystems that have purity equal to 1: \n", + "- the entire system '11111' and its empty complement '00000'\n", + "- the subsystem '10010' and its complement '01101'\n", + "\n", + "Remember that a purity of 1 means that the subsystem is pure.\n", + "This tells us that besides the entire state $\\ket{\\psi}$ and the trivial empty state, which are pure by definition,\n", + "the only subsystems that are pure are $S=\\{0,3\\}$ (encoded as '10010') and $\\bar S=\\{1,2,4\\}$ (encoded as '01101').\n", + "This tells us $\\ket{\\psi}$ is separable along the cut between $S$ and $\\bar S$, exactly as we expected." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Finding the hidden cut" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "# how do we find hidden cut? \n", "\n", "# one way would be compute purities of all subsytems and see which subsystem has purity = 1. But this is impractical since there are exponentially many subsystems\n", @@ -239,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -253,53 +388,7 @@ "output_type": "display_data" } ], - "source": [ - "def random_state(dim):\n", - " return unitary_group.rvs(dim)[0]\n", - "\n", - "def separable_state(*sizes):\n", - " state = np.array([1])\n", - " for n in sizes:\n", - " component = random_state(2**n)\n", - " state = np.kron(state, component)\n", - " return state\n", - "\n", - "state = separable_state(2, 3)\n", - "n = int(np.log2(len(state)))\n", - "\n", - "dev = qml.device('default.qubit')\n", - "\n", - "@qml.qnode(dev)\n", - "def purity(state, qubits):\n", - " qml.StatePrep(state, wires=range(n))\n", - " return qml.purity(wires=qubits)\n", - "\n", - "# p = purity(state, qubits=[0,1])\n", - "\n", - "@qml.qnode(dev)\n", - "def density_matrix(state, qubits):\n", - " qml.StatePrep(state, wires=range(n))\n", - " return qml.density_matrix(qubits)\n", - "\n", - "# rho = density_matrix(state, [0,1])\n", - "# np.trace(rho @ rho).round(5).item()\n", - "\n", - "bitstrings = []\n", - "purities = []\n", - "\n", - "for x in range(1, len(state)):\n", - " bitstring = [int(bit) for bit in bin(x)[2:].zfill(n)]\n", - " subsystem = [i for i in range(n) if bitstring[i] == 1]\n", - " bitstrings.append(''.join(str(bit) for bit in bitstring))\n", - " purities.append(purity(state, subsystem))\n", - "\n", - "plt.bar(bitstrings, purities)\n", - "plt.xticks(rotation=90)\n", - "plt.axhline(y=1.0, color='r', ls='--')\n", - "plt.xlabel('subsystem')\n", - "plt.title('Subsystem purities')\n", - "plt.show()" - ] + "source": [] }, { "cell_type": "code", From 3942074ead40cf9b4f06736991092004f5167541 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Mon, 28 Apr 2025 16:36:54 -0400 Subject: [PATCH 08/20] Plot subsystem purities with coloured bars --- demonstrations/hidden_cut.ipynb | 152 ++++++++++++++++++++++++++------ 1 file changed, 123 insertions(+), 29 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index b51b765445..bbe75c03e2 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -49,8 +49,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Creating a separable state\n", - "\n", + "## Creating a separable state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "Let's create a separable state.\n", "To ensure the quantum algorithm we construct can be simulated in reasonable time, we'll keep things small and consider a state with $n=5$ qubits.\n", "First we define a function that creates a random state with a specified number of qubits, $n$.\n", @@ -127,6 +132,13 @@ "print(f'Created {n} qubit state.')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Subsystem purities" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -242,31 +254,131 @@ "\n", "Remember that a purity of 1 means that the subsystem is pure.\n", "This tells us that besides the entire state $\\ket{\\psi}$ and the trivial empty state, which are pure by definition,\n", - "the only subsystems that are pure are $S=\\{0,3\\}$ (encoded as '10010') and $\\bar S=\\{1,2,4\\}$ (encoded as '01101').\n", - "This tells us $\\ket{\\psi}$ is separable along the cut between $S$ and $\\bar S$, exactly as we expected." + "the only other subsystems that are pure are $S=\\{0,3\\}$ (encoded as '10010') and $\\bar S=\\{1,2,4\\}$ (encoded as '01101').\n", + "So $\\ket{\\psi}$ is separable along the cut between $S$ and $\\bar S$, exactly as we expected." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Finding the hidden cut" + "## Finding the hidden cut: the naive approach" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember our goal: given a state of many qubits, find the separable components.\n", + "\n", + "The above discussion suggests one way of achieving this goal: \n", + "compute the purities of all subsystems and look for the subsystems with purity equal to 1.\n", + "There are two obvious problems with this approach.\n", + "\n", + "First, here we had access to the entire mathematical description of the state vector, so we could compute the purities analytically (via pennylane).\n", + "But in practice we would only have access to the *physical* realization of the state (i.e. the qubits), so we would need an algorithm that could take\n", + "these qubits and compute any desired subsystem purity.\n", + "In fact there is a well-known algorithm called the \"swap test\" which does exactly this.\n", + "This algorithm requires many copies of the state.\n", + "Let's suppose that we do have access to many copies of the state.\n", + "In this case computing the purity of any subsystem is doable.\n", + "\n", + "Although we can use the swap test to determine the purity of any given subsystem, \n", + "the bigger problem with this approach to finding the hidden cut is that there are $2^n$ subsystems.\n", + "Therefore it would be impractical to look for pure subsystems by brute force search.\n", + "\n", + "We need a more efficient way to find the hidden cut." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finding the hidden cut: a better approach" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the subsystem purity function---the historgram we plotted above---more closely.\n", + "Notice that some of the bars seem like they're the same height.\n", + "To make this easier to see, let's colour in the bars according to their height:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 281, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# colour map\n", + "cmap = plt.cm.tab10\n", + "purities = np.round(purities, 5)\n", + "unique_purities = set(purities)\n", + "colours = cmap(np.linspace(0, 1, len(unique_purities)))\n", + "purity_to_colour = dict(zip(unique_purities, colours))\n", + "bar_colours = [purity_to_colour[purity] for purity in purities]\n", + "\n", + "# plot\n", + "plt.bar(bitstrings, purities, color=bar_colours)\n", + "plt.xticks(rotation=90)\n", + "plt.axhline(y=1.0, color='r', ls='--')\n", + "plt.xlabel('subsystem')\n", + "plt.ylabel('purity')\n", + "plt.title('Subsystem purities')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# how do we find hidden cut? \n", + "Notice that there are 8 sets of 4 bitstrings each with the same purity. \n", + "\n", + "Question: how are bitstrings of the same purity related? \n", + "I encourage you to pause and stare at the graph for a minute or two to try and figure it out.\n", + "\n", + "Ready for the answer?\n", "\n", - "# one way would be compute purities of all subsytems and see which subsystem has purity = 1. But this is impractical since there are exponentially many subsystems\n", + "Answer: same purity bitstrings are related by bitstring addition of '01101' and '10010'.\n", "\n", - "# let's look at subsystem purity function more closely - colour in bars that are the same height the same colour.\n", + "For example, start with the first orange bar, '00000'.\n", + "- Adding '01101' to '00000' gives '01101', the second orange bar. \n", + "- Adding '10010' to '00000' gives '10010', the third orange bar.\n", + "- Adding both '01101' and '10010' to '00000' gives '11111', the fourth orange bar.\n", "\n", - "# how are bars of the same height related? by adding eg (10100) and (01011).\n", + "These four orange bars are the subsystems of purity 1 that we discussed above.\n", "\n", + "As a second example, start with the third violet bar, '10110'.\n", + "- Adding '01101' (bitwise modulo 2) to '10110' gives '11011', the fourth violet bar.\n", + "- Adding '10010' to '10110' gives '00100', the first violet bar.\n", + "- Adding both '01101' and '10010' to '10110' gives '01001', the second violet bar.\n", + "\n", + "\n", + "Try this by starting with any of the other bars.\n", + "Adding '01101' and/or '10010' to this bar will always give the other 3 bars of the same colour!\n", + "\n", + "We can summarize this neat observation by saying:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "# ie pi(s) = pi(s + 10100) + pi(s + 01011) + pi(s + 11111).\n", "\n", "# ie the symmetry is generated by the group H = ...\n", @@ -372,24 +484,6 @@ "\n" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [] - }, { "cell_type": "code", "execution_count": 205, From 2dc0a8906a9fb109f09871e932406b5367ce2192 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Wed, 30 Apr 2025 16:51:23 -0400 Subject: [PATCH 09/20] Work on hidden cut demo --- demonstrations/hidden_cut.ipynb | 100 ++++++++++++++++++++++++-------- 1 file changed, 76 insertions(+), 24 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index bbe75c03e2..1c1e149a5f 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -185,8 +185,8 @@ "source": [ "Now we use this function to compute all subsystem purities and store them in a `purities` list.\n", "We'll also store the subsystems, encoded as 5-bit strings, into a `bitstrings` list.\n", - "The empty subsystem '00000' is and edge case that `qml.purity()` can't handle, so we add it by hand.\n", - "Because complementary subsystems have identical purities (prove this!), $P('00000') = P('11111') = 1$." + "The empty subsystem 00000 is an edge case that `qml.purity()` can't handle, so we add it by hand.\n", + "Because complementary subsystems have identical purities (prove this!), $P(00000) = P(11111) = 1$." ] }, { @@ -249,8 +249,8 @@ "metadata": {}, "source": [ "Notice the 4 subsystems that have purity equal to 1: \n", - "- the entire system '11111' and its empty complement '00000'\n", - "- the subsystem '10010' and its complement '01101'\n", + "- the entire system 11111 and its empty complement 00000\n", + "- the subsystem 10010 and its complement 01101\n", "\n", "Remember that a purity of 1 means that the subsystem is pure.\n", "This tells us that besides the entire state $\\ket{\\psi}$ and the trivial empty state, which are pure by definition,\n", @@ -262,7 +262,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Finding the hidden cut: the naive approach" + "## The naive approach to hidden cuts" ] }, { @@ -294,7 +294,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Finding the hidden cut: a better approach" + "## Symmetries of the purity function" ] }, { @@ -303,7 +303,7 @@ "source": [ "Let's look at the subsystem purity function---the historgram we plotted above---more closely.\n", "Notice that some of the bars seem like they're the same height.\n", - "To make this easier to see, let's colour in the bars according to their height:" + "To visualize this, let's colour in the bars according to their height:" ] }, { @@ -348,29 +348,84 @@ "Notice that there are 8 sets of 4 bitstrings each with the same purity. \n", "\n", "Question: how are bitstrings of the same purity related? \n", - "I encourage you to pause and stare at the graph for a minute or two to try and figure it out.\n", + "Pause for a bit (no pun intended) and think about it!\n", "\n", "Ready for the answer?\n", "\n", - "Answer: same purity bitstrings are related by bitstring addition of '01101' and '10010'.\n", + "Answer: same purity bitstrings are related by bitstring addition of 01101 and 10010.\n", "\n", - "For example, start with the first orange bar, '00000'.\n", - "- Adding '01101' to '00000' gives '01101', the second orange bar. \n", - "- Adding '10010' to '00000' gives '10010', the third orange bar.\n", - "- Adding both '01101' and '10010' to '00000' gives '11111', the fourth orange bar.\n", + "For example, start with the first orange bar, 00000.\n", + "- Adding 01101 to 00000 gives 01101, the second orange bar. \n", + "- Adding 10010 to 00000 gives 10010, the third orange bar.\n", + "- Adding both 01101 and 10010 to 00000 gives 11111, the fourth orange bar.\n", "\n", - "These four orange bars are the subsystems of purity 1 that we discussed above.\n", + "These four orange bars are the subsystems of purity 1 that we discussed earlier.\n", "\n", - "As a second example, start with the third violet bar, '10110'.\n", - "- Adding '01101' (bitwise modulo 2) to '10110' gives '11011', the fourth violet bar.\n", - "- Adding '10010' to '10110' gives '00100', the first violet bar.\n", - "- Adding both '01101' and '10010' to '10110' gives '01001', the second violet bar.\n", + "As a second example, start with the third violet bar, 10110.\n", + "- Adding 01101 (bitwise modulo 2) to 10110 gives 11011, the fourth violet bar.\n", + "- Adding 10010 to 10110 gives 00100, the first violet bar.\n", + "- Adding both 01101 and 10010 to 10110 gives 01001, the second violet bar.\n", "\n", "\n", - "Try this by starting with any of the other bars.\n", - "Adding '01101' and/or '10010' to this bar will always give the other 3 bars of the same colour!\n", + "In fact, this approach to getting all of the bars of the same height (the same colour) always works.\n", + "You should try it by starting with a bar of another colour.\n", + "You'll find that adding 01101 and/or 10010 to this bar will always give the other 3 bars of the same colour!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The observation that we have made is that the purity function $P(s)$ has a symmetry: \n", + "$$\n", + "P(s) = P(s + 10100) = P(s + 01011) = P(s + 11111)\n", + "$$\n", + "for any bitstring $s$.\n", + "We can associate the set $H = \\{00000, 10100, 01011, 11111\\}$ to our symmetry;\n", + "these are the bitstrings that we can add to $s$ without changing its purity.\n", + "The set $H$ has 3 notable properties:\n", + "1. It contains the unique \"identity\" bitstring 00000, for which $s + 00000 = s$ for all $s$\n", + "2. The set is closed under addition\n", + "3. Every element in $H$ has an inverse in $H$, such that the element plus its inverse give the identity. \n", + "Namely 00000 is its own inverse, as is 11111, while 10100 and 01011 are each other's inverses.\n", + "\n", + "These three properties (along with the obvious property that bitstring addition is associative) turn $H$ into what is called a *group* in math.\n", + "Indeed a group is just a set closed under an associative operation (here bitstring addition), containing an identity and inverses for every element.\n", + "So what we discovered is that our purity function has a symmetry, and that this symmetry is associated with a group.\n", + "Thinking of symmetries as groups is arguably the most successful guiding principle in quantum physics, and we'll see that it's useful here as well." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hidden cut as a hidden subgroup problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To see how this can help us solve the hidden cut problem, take another look at the symmetry group $H$.\n", + "$H$ has 4 elements but it can be \"generated\" by only 2 elements, 10100 and 01011,\n", + "meaning that the other elements in $H$ (00000 and 11111) can be obtained via the two generators and bitwise addition.\n", + "This is actually something we already knew: when we were trying to find subsystems of the same purity,\n", + "it was enough to start with a subsystem and add to it different combinations of the generators.\n", + "\n", + "Very important question: is there anything special about the generators 10100 and 01011 of the symmetry group $H$?\n", + "Pause and think about it!\n", + "\n", + "Here comes the answer:\n", "\n", - "We can summarize this neat observation by saying:" + "Answer: the generators directly give us the separable subsets $S$ and $\\bar S$! \n", + "What I mean is that the first generator 10100 has 1s in positions 0 and 2, so this gives the subset $S=\\{0,2\\}, \n", + "and the second generator 01011 has 1s in positions 1, 3, and 4, so this gives the complementary subset $S=\\{1,3,4\\}$.\n", + "\n", + "This direct relationship between generators of the symmetry group $H$ of $P(s)$ and the separable components of $\\ket\\psi$\n", + "is not a coincidence:\n", + "for any state $\\ket\\psi$ the generators of $H$ will always determine the hidden cut that separates $\\ket\\psi$ into unentangled components!\n", + "\n", + "Explain why with a picture..." ] }, { @@ -379,9 +434,6 @@ "metadata": {}, "outputs": [], "source": [ - "# ie pi(s) = pi(s + 10100) + pi(s + 01011) + pi(s + 11111).\n", - "\n", - "# ie the symmetry is generated by the group H = ...\n", "\n", "# H is a subgroup of the full group G = {00000, 00001, ...} with the group operation being bitwise addition modulo 2.\n", "\n", From 769eadcca9a42e22b384039100135d79b1703924 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Thu, 1 May 2025 14:39:56 -0400 Subject: [PATCH 10/20] Work on hidden cut demo --- demonstrations/hidden_cut.ipynb | 55 +++++++++++++++++++++++++++------ 1 file changed, 45 insertions(+), 10 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index 1c1e149a5f..f0a523e21a 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -399,7 +399,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Hidden cut as a hidden subgroup problem" + "## Relating symmetries to separable components" ] }, { @@ -415,17 +415,55 @@ "Very important question: is there anything special about the generators 10100 and 01011 of the symmetry group $H$?\n", "Pause and think about it!\n", "\n", - "Here comes the answer:\n", - "\n", "Answer: the generators directly give us the separable subsets $S$ and $\\bar S$! \n", "What I mean is that the first generator 10100 has 1s in positions 0 and 2, so this gives the subset $S=\\{0,2\\}, \n", "and the second generator 01011 has 1s in positions 1, 3, and 4, so this gives the complementary subset $S=\\{1,3,4\\}$.\n", "\n", - "This direct relationship between generators of the symmetry group $H$ of $P(s)$ and the separable components of $\\ket\\psi$\n", - "is not a coincidence:\n", - "for any state $\\ket\\psi$ the generators of $H$ will always determine the hidden cut that separates $\\ket\\psi$ into unentangled components!\n", + "This relationship between generators and separable components is not a coincidence:\n", + "for any state $\\ket\\psi$ the separable components are equal to the generators of $H$!\n", + "\n", + "To understand why, let's work through an example using our state $\\ket\\psi = \\ket{\\psi_{0,2}}\\otimes\\ket{\\psi_{1,3,4}}$.\n", + "We can schematically visualize this state as:\n", + "\n", + "[Picture: graph with nodes 0,2 connected and nodes 1,3,4 connected]\n", + "\n", + "As an example let's consider subsystem $A=01110$ containing qubits 1, 2, and 3.\n", + "We can shade in the qubits corresponding to subsystem $A$:\n", + "\n", + "[Picture: same graph but now with nodes 1,2,3 shaded in]\n", + "\n", + "Because qubit 2 is separated from qubits 1 and 3, the density matrix of subsystem $A$ is $\\rho_A = \\rho_{\\{1,3\\}}\\otimes\\rho_{\\{2\\}}$.\n", + "Using the property that the trace of a tensor product of matrices is the product of traces, the purity of $A$ becomes:\n", + "$$\n", + "P(A) = \n", + "\\text{Tr}(\\rho_{\\{1,3\\}}^2)\n", + "\\text{Tr}(\\rho_{\\{2\\}}^2).\n", + "$$\n", + "\n", + "Ok, now let's look at subsystem $B$ obtained by adding to $A$ the bitstring $10100$, corresponding to the separable component $\\bar S = \\{0,2\\}$. \n", + "Bitstring addition gives $B = 11010$, the subsystem containing qubits 0, 1, and 3.\n", + "Because we added the bitstring corresponding to $\\bar S = \\{0,2\\}$, this just toggles the shading on those bits:\n", + "\n", + "[Picture: same graph but now with nodes 0,1,3 shaded in]\n", "\n", - "Explain why with a picture..." + "The density matrix of subsystem $B$ is $\\rho_B = \\rho_{\\{1,3\\}}\\otimes\\rho_{\\{0\\}}$ and the purity of $B$ is:\n", + "$$\n", + "P(B) = \n", + "\\text{Tr}(\\rho_{\\{1,3\\}}^2)\n", + "\\text{Tr}(\\rho_{\\{0\\}}^2).\n", + "$$\n", + "So the only difference between $P(A)$ and $P(B)$ is that the factor $\\text{Tr}(\\rho_{\\{2\\}}^2)$ got replaced by the factor $\\text{Tr}(\\rho_{\\{0\\}}^2)$.\n", + "This corresponds to the \"toggling\" of the bits in $\\bar S=\\{0,2\\}$.\n", + "But because $\\bar S$ is a separable system $\\text{Tr}(\\rho_{\\{2\\}}^2)$ is equal to $\\text{Tr}(\\rho_{\\{0\\}}^2)$, and so $P(A) = P(B)$!\n", + "The general point is: toggling bits in a separable component doesn't change the purity.\n", + "Or in other words: separable components are symmetry generators of the purity function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hidden cut problem as a hidden subgroup problem" ] }, { @@ -437,9 +475,6 @@ "\n", "# H is a subgroup of the full group G = {00000, 00001, ...} with the group operation being bitwise addition modulo 2.\n", "\n", - "# Notice that H has 4 elements but it can be \"generated\" by ... and ..., meaning that the other elements (... and ...) can be obtained via the two generators and the group operation.\n", - "\n", - "# do you notice anything interesting about the generators? they directly encode the separable components of the state!\n", "\n", "# so in order to find the separable components of the state, we just have to find the symmetry subgroup of the purity function pi(s), and look at its generators.\n", "\n", From 2bdacb9c78fe15759d71ffdb3bb38f76d26a86d1 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Wed, 21 May 2025 12:37:00 -0400 Subject: [PATCH 11/20] Edit hidden cut demo --- demonstrations/hidden_cut.ipynb | 239 +++++++++++++++++--------------- 1 file changed, 126 insertions(+), 113 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index f0a523e21a..5914178887 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -11,38 +11,41 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "One of the most interesting and counterintuitive aspects of quantum physics is entanglement.\n", + "One of the most interesting and counterintuitive features of quantum physics is entanglement.\n", "Entanglement is a form of correlation between quantum systems that is fundamentally different from any correlation that can exist between classical systems.\n", "To define entanglement, let $\\ket{\\psi}$ be a state of a quantum system with two parts, $A$ and $B$.\n", "For example $A$ and $B$ might each be single qubits; then $\\ket{\\psi}$ is a two qubit state.\n", - "We say $A$ and $B$ are *unentangled* or *separable* if $\\ket{\\psi}$ can be written as\n", + "We say $A$ and $B$ are *unentangled* or *separable* if $\\ket{\\psi}$ can be written as a tensor product\n", "$$\n", "\\ket{\\psi} = \\ket{\\psi_A}\\otimes \\ket{\\psi_B}\n", "$$,\n", "where $\\ket{\\psi_A}$ is a state of system $A$ and $\\ket{\\psi_B}$ is a state of system $B$.\n", - "If $\\ket{\\psi}$ can't be written in this separable form then we say $A$ and $B$ are *entangled*.\n", + "If $\\ket{\\psi}$ isn't separable then we say $A$ and $B$ are *entangled*.\n", "\n", - "Now suppose we're given a system of $n$ qubits.\n", - "We're told that it's possible to split the qubits into two unentangled subsets, $S$ and $\\bar S$, i.e.\n", - "$\\ket{\\psi}$ can be written as\n", + "Now suppose we're given a state of $n$ qubits.\n", + "We're told that it's possible to split the qubits into two unentangled subsets, $S$ and $\\bar S$, \n", + "in other words $\\ket{\\psi}$ can be written as\n", "$$\n", "\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}},\n", "$$\n", - "but we aren't told what $S$ and $\\bar S$ are.\n", - "The question is: how can we determine $S$ and $\\bar S$, i.e. how do we determine the ``hidden cut'' that splits the qubits into two unentangled subsystems.\n", + "but we aren't told what $S$ and $\\bar S$ are. \n", + "Question: how can we determine $S$ and $\\bar S$, or in other words, how do we determine the ``hidden cut'' that splits the qubits into two unentangled subsystems.\n", "Following ..., in this demo we'll develop a quantum algorithm that solves this problem!" ] }, { "cell_type": "code", - "execution_count": 244, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pennylane as qml\n", - "from scipy.stats import unitary_group" + "from scipy.stats import unitary_group\n", + "\n", + "# set random seed\n", + "np.random.seed(hash('hidden_cut') % 2**32)" ] }, { @@ -56,16 +59,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's create a separable state.\n", - "To ensure the quantum algorithm we construct can be simulated in reasonable time, we'll keep things small and consider a state with $n=5$ qubits.\n", - "First we define a function that creates a random state with a specified number of qubits, $n$.\n", - "We do this by creating an $2^n$ by $2^n$ random unitary and taking the first row.\n", + "Let's create a separable state with $n=5$ qubits.\n", + "First we define a function that creates a random state with a specified number of qubits.\n", + "We do this by creating a $2^n$ by $2^n$ random unitary and taking the first row.\n", "Because all the rows (and columns) in a unitary matrix have norm equal to 1, this defines a valid quantum state." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -79,19 +81,19 @@ "metadata": {}, "source": [ "We'll use this function to set qubits $S=\\{0,3\\}$ and $\\bar S=\\{1,2,4\\}$ to each be in a random pure state.\n", - "The full 5 qubit state will then be separable along this 2-qubit and 3-qubit partition. " + "The full 5 qubit state will then be separable along this partition. " ] }, { "cell_type": "code", - "execution_count": 259, + "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Created 5 qubit state.\n" + "Created 5 qubit state with qubits [0, 3] unentangled from [1, 2, 4].\n" ] } ], @@ -127,9 +129,11 @@ " return full_state\n", "\n", "# create separable 5 qubit state\n", - "state = separable_state([(0,3), (1,2,4)])\n", + "S = [0,3]\n", + "S_bar = [1,2,4]\n", + "state = separable_state([S, S_bar])\n", "n = int(np.log2(len(state)))\n", - "print(f'Created {n} qubit state.')" + "print(f'Created {n} qubit state with qubits {S} unentangled from {S_bar}.')" ] }, { @@ -144,22 +148,22 @@ "metadata": {}, "source": [ "Let's verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$.\n", - "A general way to check whether a subsystem $S$ of a pure state $\\ket{\\psi}$ is entangled with the complementary subsystem $\\bar S$\n", + "One way to check if a subsystem $S$ of a pure state $\\ket{\\psi}$ is entangled with the complementary subsystem $\\bar S$\n", "is to consider the reduced density matrix $\\rho_S$ describing the state of $S$ and compute its purity, \n", "$$\n", "P(S) := \\text{Tr}(\\rho_S^2).\n", "$$\n", "If $S$ and $\\bar S$ are unentangled, i.e. $\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}}$, then $\\rho_S = \\ket{\\psi_S}\\bra{\\psi_S}$\n", "and the purity of $S$ is $P(S)=1$.\n", - "On the other hand if $S$ and $\\bar S$ *are* entangled, then $\\rho_S$ will be a mixed state, and $P(S)$ will necessarily be less than 1\n", + "Meanwhile if $S$ and $\\bar S$ *are* entangled, then $\\rho_S$ will be a mixed state and $P(S)$ will be less than 1\n", "(can you prove this?).\n", "\n", - "So all we need to do to verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$ in our 5 qubit state\n", - "is to check that $P(S) = 1$. \n", - "For fun (and because it'll be instructive) instead of just computing $P(\\{0,3\\})$, let's compute the purities of *all* possible subsystems.\n", - "Because there are 5 qubits we can denote the subsystems using 5 bit strings, where a 1 bit indicates that a qubit belongs to the subsystem.\n", - "For example '10010' denotes the subsystem $S=\\{0,3\\}$.\n", - "Since each bit can be a 1 or a 0, there are $2^5=32$ different subsystems.\n", + "So to verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$ we just need to check that $P(S) = 1$. \n", + "Instead of just computing $P(\\{0,3\\})$, let's go a step further and compute the purities of *all* subsystems of qubits.\n", + "Because there are 5 qubits we can denote a subsystem as a 5-bit string, where a 1 bit indicates that a qubit belongs to the subsystem and a 0 bit that it doesn't belong.\n", + "For example '10010' denotes the subsystem $S=\\{0,3\\}$ because it has 1s in positions 0 and 3.\n", + "\n", + "Since there are $2^5=32$ different 5-bit strings, there are 32 total subsystems.\n", "Let's create a histogram showing all 32 subsystem purities.\n", "First we define a function to compute the purity of a subsystem.\n", "`qml.purity()` does the heavy lifting:" @@ -167,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 254, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -183,7 +187,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we use this function to compute all subsystem purities and store them in a `purities` list.\n", + "Now let's compute all subsystem purities and store them in a `purities` list.\n", "We'll also store the subsystems, encoded as 5-bit strings, into a `bitstrings` list.\n", "The empty subsystem 00000 is an edge case that `qml.purity()` can't handle, so we add it by hand.\n", "Because complementary subsystems have identical purities (prove this!), $P(00000) = P(11111) = 1$." @@ -191,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 260, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -220,12 +224,12 @@ }, { "cell_type": "code", - "execution_count": 261, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHjCAYAAADfbz4KAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQKhJREFUeJzt3XtYlHX+//HXAHIQBVQSpRDNNDXPmAbmmprnNDcrs13xWJmaeajdzC0P38q0UtpKq02lWk2y1K20jA5a66HSJDPNWk9ggJYHPGSo8Pn94c+xiQFhGLiZ2+fjuua6nPv+vOfz/twz4It7Tg5jjBEAAIBN+FndAAAAgDcRbgAAgK0QbgAAgK0QbgAAgK0QbgAAgK0QbgAAgK0QbgAAgK0QbgAAgK0QbgAAgK0QboAK6osvvtCf//xn1alTR0FBQYqKilJ8fLwmTpzo0e0lJyfL4XBo06ZNXu60dLZv366pU6dq7969Vrdiubp162rIkCHO65mZmZo6darS0tIKjJ06daocDkf5NQf4EMINUAGtXLlSCQkJOnbsmGbNmqUPP/xQzz77rNq3b6+UlBSr2/Oq7du3a9q0aYQbScuXL9cjjzzivJ6Zmalp06a5DTcjRozQhg0byrE7wHcEWN0AgIJmzZqlevXqafXq1QoIuPBjescdd2jWrFkWdoaycOrUKYWEhKhVq1bFrrniiit0xRVXlGFXgO/izA1QAR06dEiRkZEuweY8Pz/XH1uHw6GpU6cWGPfHpzjOO3LkiIYOHarq1asrNDRUffr00e7du13GbNmyRTfddJNq1qypoKAgRUdHq3fv3tq/f78kqUuXLmrUqJH++L27xhhdddVV6t27t3PbvHnz1KJFC1WpUkVVq1ZVo0aN9PDDD0s691TZbbfdJknq1KmTHA6HHA6HkpOTnfUfffSRunTporCwMFWuXFnt27fXxx9/7DLv+adotm7dqttuu03h4eGqXr26JkyYoLNnz2rnzp3q0aOHqlatqrp16xY7IDocDo0ZM0YvvfSSGjZsqKCgIDVp0kRLlixxO/8fnX8q8PdnperWraubbrpJy5YtU6tWrRQcHKxp06Y5952/z9asWaNrr71WkjR06FDnsTl/Xxc2Z0pKiuLj4xUaGqoqVaqoe/fu2rJli8uY3bt364477lB0dLTzKc8uXbq4PUME+CLCDVABxcfH64svvtDYsWP1xRdf6MyZM1677eHDh8vPz0+LFy9WUlKSvvzyS91www06evSoJOnkyZPq2rWrDhw4oBdeeEGpqalKSkpSnTp1dPz4cUnS/fffr507dxYIGe+//7527dql0aNHS5KWLFmiUaNGqWPHjlq+fLlWrFih8ePH6+TJk5Kk3r1764knnpAkvfDCC9qwYYM2bNjgDEf//ve/1a1bN4WFhenVV1/Vm2++qerVq6t79+4F5pak22+/XS1atNDbb7+tu+66S3PmzNH48ePVr18/9e7dW8uXL1fnzp3197//XcuWLSvW8XrnnXf0z3/+U9OnT9dbb72l2NhYDRw4UG+99VbJD/7/9/XXX+vBBx/U2LFj9cEHH6h///4FxrRu3VoLFy6UJP3jH/9wHpsRI0YUertPPPGEBg4cqCZNmujNN9/U66+/ruPHj6tDhw7avn27c1yvXr20efNmzZo1S6mpqZo3b55atWrlfAwAPs8AqHB++eUXc/311xtJRpKpVKmSSUhIMDNmzDDHjx93GSvJTJkypcBtxMbGmsGDBzuvL1y40Egyf/7zn13GrVu3zkgyjz32mDHGmE2bNhlJZsWKFYX2l5eXZ6688kpz8803u2zv2bOnqV+/vsnPzzfGGDNmzBgTERFR5FqXLl1qJJlPP/3UZfvJkydN9erVTZ8+fQrM3aJFC9O2bVvntilTphhJ5plnnnEZ27JlSyPJLFu2zLntzJkz5rLLLjO33HJLkX0Zc+7YhoSEmOzsbOe2s2fPmkaNGpmrrrqqwPx/dP6Y79mzx7ktNjbW+Pv7m507dxYY/8f77KuvvjKSzMKFCwuM/eOc6enpJiAgwNx3330u444fP25q1aplbr/9dmPMuceWJJOUlHTR9QO+ijM3QAVUo0YNff755/rqq6/05JNP6uabb9YPP/ygSZMmqVmzZvrll188vu2//OUvLtcTEhIUGxurTz/9VJJ01VVXqVq1avr73/+uF1980eUv/vP8/Pw0ZswYvffee0pPT5ck7dq1Sx988IFGjRrlfLqkbdu2Onr0qAYOHKj//Oc/Jep7/fr1Onz4sAYPHqyzZ886L/n5+erRo4e++uor5xmg82666SaX640bN5bD4VDPnj2d2wICAnTVVVdp3759xeqjS5cuioqKcl739/fXgAED9L///c/5NF1JNW/eXA0bNvSotjCrV6/W2bNnlZiY6HK8goOD1bFjR61Zs0aSVL16ddWvX19PPfWUZs+erS1btig/P9+rvQBWI9wAFVibNm3097//XUuXLlVmZqbGjx+vvXv3lupFxbVq1XK77dChQ5Kk8PBwrV27Vi1bttTDDz+sa665RtHR0ZoyZYrL02PDhg1TSEiIXnzxRUnnnlYKCQnRsGHDnGMGDRqkBQsWaN++ferfv79q1qypdu3aKTU19aJ9HjhwQJJ06623qlKlSi6XmTNnyhijw4cPu9RUr17d5XpgYKAqV66s4ODgAtt/++23i/Zw/tgUtu38MSup2rVre1RXlPPH69prry1wvFJSUpzB0uFw6OOPP1b37t01a9YstW7dWpdddpnGjh3rfNoR8HW8WwrwEZUqVdKUKVM0Z84cbdu2zbk9KChIubm5BcYX9h9vdna2221XXXWV83qzZs20ZMkSGWO0detWJScna/r06QoJCdFDDz0k6VwIGjx4sF555RU98MADWrhwoe68805FRES43PbQoUM1dOhQnTx5Up999pmmTJmim266ST/88INiY2MLXW9kZKQk6bnnntN1113ndszvz6iUlcKOl3TuDJskZ3jKzc1VUFCQc1xhZ6rK4vNpzh+v868LKkpsbKzmz58vSfrhhx/05ptvaurUqTp9+rQzrAK+jHADVEBZWVlu/7rfsWOHJCk6Otq5rW7dutq6davLuE8++UQnTpxwe9uLFi1yeQHr+vXrtW/fPrcvVHU4HGrRooXmzJmj5ORkff311y77x44dq7lz5+rWW2/V0aNHNWbMmELXFBoaqp49e+r06dPq16+fvvvuO8XGxjrDwKlTp1zGt2/fXhEREdq+fXuRt1vWPv74Yx04cMAZpPLy8pSSkqL69es734pdt25dSdLWrVud73CSpHfffbdUcxd2bNzp3r27AgICtGvXLrcvUC5Mw4YN9Y9//ENvv/12gfsX8FWEG6AC6t69u6644gr16dNHjRo1Un5+vtLS0vTMM8+oSpUquv/++51jBw0apEceeUSPPvqoOnbsqO3bt+v5559XeHi429vetGmTRowYodtuu00ZGRmaPHmyLr/8co0aNUqS9N5772nu3Lnq16+frrzyShljtGzZMh09elRdu3Z1ua2GDRuqR48eev/993X99derRYsWLvvvuusuhYSEqH379qpdu7ays7M1Y8YMhYeHO0NA06ZNJUkvv/yyqlatquDgYNWrV081atTQc889p8GDB+vw4cO69dZbVbNmTf3888/65ptv9PPPP2vevHleO+aFiYyMVOfOnfXII48oNDRUc+fO1ffff+/ydvBevXqpevXqGj58uKZPn66AgAAlJycrIyOjVHPXr19fISEhWrRokRo3bqwqVaooOjraJdyeV7duXU2fPl2TJ0/W7t271aNHD1WrVk0HDhzQl19+qdDQUE2bNk1bt27VmDFjdNttt6lBgwYKDAzUJ598oq1btzrPygE+z+IXNANwIyUlxdx5552mQYMGpkqVKqZSpUqmTp06ZtCgQWb79u0uY3Nzc83f/vY3ExMTY0JCQkzHjh1NWlpaoe+W+vDDD82gQYNMRESECQkJMb169TI//vijc9z3339vBg4caOrXr29CQkJMeHi4adu2rUlOTnbba3JyspFklixZUmDfq6++ajp16mSioqJMYGCgiY6ONrfffrvZunWry7ikpCRTr1494+/vX+DdQWvXrjW9e/c21atXN5UqVTKXX3656d27t1m6dKlzzPl3Dv38888utzt48GATGhpaoK+OHTuaa665xu16fk+SGT16tJk7d66pX7++qVSpkmnUqJFZtGhRgbFffvmlSUhIMKGhoebyyy83U6ZMMa+88orbd0v17t3b7Xx/vM+MMeaNN94wjRo1MpUqVXJ5Z1xh79BasWKF6dSpkwkLCzNBQUEmNjbW3Hrrreajjz4yxhhz4MABM2TIENOoUSMTGhpqqlSpYpo3b27mzJljzp49e9FjAvgChzF/+BQuACiB/v37a+PGjdq7d68qVapkdTte5XA4NHr0aD3//PNWtwKgBHhaCkCJ5ebm6uuvv9aXX36p5cuXa/bs2bYLNgB8F+EGQIllZWUpISFBYWFhuueee3TfffdZ3RIAOPG0FAAAsBU+xA8AANgK4QYAANgK4QYAANjKJfeC4vz8fGVmZqpq1apl8hHoAADA+4wxOn78uKKjo+XnV/S5mUsu3GRmZiomJsbqNgAAgAcyMjKcX31SmEsu3FStWlXSuYMTFhZmcTcAAKA4jh07ppiYGOf/40W55MLN+aeiwsLCCDcAAPiY4rykhBcUAwAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAW7E03Hz22Wfq06ePoqOj5XA4tGLFiovWrF27VnFxcQoODtaVV16pF198sewbBQAAPsPScHPy5Em1aNFCzz//fLHG79mzR7169VKHDh20ZcsWPfzwwxo7dqzefvvtMu4UAAD4Cku/OLNnz57q2bNnsce/+OKLqlOnjpKSkiRJjRs31qZNm/T000+rf//+JZv85EnJ37/gdn9/KTjYdVxh/PykkBDPxv76q2SM+7EOh1S5smdjT52S8vML7yM01LOxv/0m5eV5Z2zlyuf6lqTcXOnsWe+MDQk5d5wl6fRp6cwZ74wNDr7wWCnJ2DNnzo0vTFCQFBBQ8rFnz547FoUJDJQqVSr52Ly8c/ddYSpVOje+pGPz88891rwxNiDg3LGQzv1M/Pqrd8aW5Oee3xHux/I7ouRj+R1x7t8l+R1RXKaCkGSWL19e5JgOHTqYsWPHumxbtmyZCQgIMKdPn3Zb89tvv5mcnBznJSMjw0gyOed+FRS89OrlegOVK7sfJxnTsaPr2MjIwse2aeM6Nja28LFNmriObdKk8LGxsa5j27QpfGxkpOvYjh0LH1u5suvYXr0KH/vHh9GttxY99sSJC2MHDy567MGDF8aOGlX02D17Lox94IGix27bdmHslClFj/3yywtjZ80qeuynn14Y+/zzRY99770LYxcuLHrsm29eGPvmm0WPXbjwwtj33it67PPPXxj76adFj50168LYL78seuyUKRfGbttW9NgHHrgwds+eoseOGnVh7MGDRY8dPPjC2BMnih57663GRVFj+R1x7sLviAsXfkecu5Tx74icnBwjyeTk5JiLsfTMTUllZ2crKirKZVtUVJTOnj2rX375RbVr1y5QM2PGDE2bNq28WizUN/tzdPNDK53X/3vklK6wsB/AE3X//2O4edYPeqeIcUkf/aCk31Zq75O9y6exCmrj7kO643c/95tPnlYNC/sBSuOOlzdoSRH7n1i1Qy8fOvd439u/Zvk0VQiHMcZY2sH/53A4tHz5cvXr16/QMQ0bNtTQoUM1adIk57Z169bp+uuvV1ZWlmrVqlWgJjc3V7m/O+V27NgxxcTEKCczU2FhYQUnKeUp58aPfOB2aL7DodxKQc7rwWd+0/fTe7i/XU45ezaWU87nlOEp57qPpkqS/PLzFHS28ONw1t9fZ/wrnQs3l8jTUu5+9v/4cx9y+sLx3fF/f/j552mpC/gdcU4F+x1x5d/eKdbPvSTtfbyH15+WOnbsmMLDw5WTk+P+/+/f8akzN7Vq1VJ2drbLtoMHDyogIEA1arj/eygoKEhBQUEFd4SGuv6wFaY4Y3439lRg8MXHSfqtUnDxb/v3v5gu5ve/HL05Nrh46yrx2KCgC/8BeXNsYGDxn6Mtq7GVKl34BeLNsQEBF36JeXOsv3+xH5P5fv46FejmNWvu+PkV/7FekrEOR9mMlTwaW5yffZcxF5ujJD/3/I4o+Vh+R5R4bIl+7kvw+6REP/fF5FOfcxMfH6/U1FSXbR9++KHatGmjSsW90wEAgK1ZGm5OnDihtLQ0paWlSTr3Vu+0tDSlp6dLkiZNmqTExETn+JEjR2rfvn2aMGGCduzYoQULFmj+/Pl64IEHrGgfAABUQJY+LbVp0yZ16tTJeX3ChAmSpMGDBys5OVlZWVnOoCNJ9erV06pVqzR+/Hi98MILio6O1j//+c+Svw0cAADYlqXh5oYbblBRr2dOTk4usK1jx476+uuvy7ArAADgy3zqNTcAAAAXQ7gBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2QrgBAAC2EmB1A7h01H1oZbHH7n2ydxl2UrSS9ClZ2yvgC3zlZ1/yrV5ROM7cAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAWyHcAAAAW7E83MydO1f16tVTcHCw4uLi9Pnnnxc5ftGiRWrRooUqV66s2rVra+jQoTp06FA5dQsAACo6S8NNSkqKxo0bp8mTJ2vLli3q0KGDevbsqfT0dLfj//vf/yoxMVHDhw/Xd999p6VLl+qrr77SiBEjyrlzAABQUVkabmbPnq3hw4drxIgRaty4sZKSkhQTE6N58+a5Hb9x40bVrVtXY8eOVb169XT99dfrnnvu0aZNm8q5cwAAUFFZFm5Onz6tzZs3q1u3bi7bu3XrpvXr17utSUhI0P79+7Vq1SoZY3TgwAG99dZb6t278E+JzM3N1bFjx1wuAADAviwLN7/88ovy8vIUFRXlsj0qKkrZ2dluaxISErRo0SINGDBAgYGBqlWrliIiIvTcc88VOs+MGTMUHh7uvMTExHh1HQAAoGKx/AXFDofD5boxpsC287Zv366xY8fq0Ucf1ebNm/XBBx9oz549GjlyZKG3P2nSJOXk5DgvGRkZXu0fAABULJZ9cWZkZKT8/f0LnKU5ePBggbM5582YMUPt27fXgw8+KElq3ry5QkND1aFDBz322GOqXbt2gZqgoCAFBQV5fwEAAKBCsuzMTWBgoOLi4pSamuqyPTU1VQkJCW5rfv31V/n5ubbs7+8v6dwZHwAAAEuflpowYYJeeeUVLViwQDt27ND48eOVnp7ufJpp0qRJSkxMdI7v06ePli1bpnnz5mn37t1at26dxo4dq7Zt2yo6OtqqZQAAgArEsqelJGnAgAE6dOiQpk+frqysLDVt2lSrVq1SbGysJCkrK8vlM2+GDBmi48eP6/nnn9fEiRMVERGhzp07a+bMmVYtAQAAVDCWhhtJGjVqlEaNGuV2X3JycoFt9913n+67774y7goAAPgqy98tBQAA4E2EGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuEGwAAYCuWfys4zqn70Mpij937ZO8y7ASXAh5vFUdJ7guJ+wOlc6k83jhzAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbCXA6gZQOnUfWlmi8Xuf7F1GnQBloySP8d8/vj2tA3wBj++iceYGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYCuEGAADYSoDVDcD31H1oZbHH7n2ydxl2UvFwbGBnPL4Lx7GpWDhzAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbIVwAwAAbMXycDN37lzVq1dPwcHBiouL0+eff17k+NzcXE2ePFmxsbEKCgpS/fr1tWDBgnLqFgAAVHSWfit4SkqKxo0bp7lz56p9+/Z66aWX1LNnT23fvl116tRxW3P77bfrwIEDmj9/vq666iodPHhQZ8+eLefOAQBARWVpuJk9e7aGDx+uESNGSJKSkpK0evVqzZs3TzNmzCgw/oMPPtDatWu1e/duVa9eXZJUt27d8mwZAABUcJY9LXX69Glt3rxZ3bp1c9nerVs3rV+/3m3NO++8ozZt2mjWrFm6/PLL1bBhQz3wwAM6depUofPk5ubq2LFjLhcAAGBflp25+eWXX5SXl6eoqCiX7VFRUcrOznZbs3v3bv33v/9VcHCwli9frl9++UWjRo3S4cOHC33dzYwZMzRt2jSv9w8AAComy19Q7HA4XK4bYwpsOy8/P18Oh0OLFi1S27Zt1atXL82ePVvJycmFnr2ZNGmScnJynJeMjAyvrwEAAFQclp25iYyMlL+/f4GzNAcPHixwNue82rVr6/LLL1d4eLhzW+PGjWWM0f79+9WgQYMCNUFBQQoKCvJu8wAAoMKy7MxNYGCg4uLilJqa6rI9NTVVCQkJbmvat2+vzMxMnThxwrnthx9+kJ+fn6644ooy7RcAAPgGS5+WmjBhgl555RUtWLBAO3bs0Pjx45Wenq6RI0dKOveUUmJionP8nXfeqRo1amjo0KHavn27PvvsMz344IMaNmyYQkJCrFoGAACoQCx9K/iAAQN06NAhTZ8+XVlZWWratKlWrVql2NhYSVJWVpbS09Od46tUqaLU1FTdd999atOmjWrUqKHbb79djz32mFVLAAAAFYyl4UaSRo0apVGjRrndl5ycXGBbo0aNCjyVBQAAcJ7l4QYoK3UfWlmi8Xuf7F1GnVxcSXq1sk/Yg6883nzpZxgVi+VvBQcAAPAmwg0AALAVj8JNcnKyfv31V2/3AgAAUGoehZtJkyapVq1aGj58eKHfAwUAAGAFj8LN/v379e9//1tHjhxRp06d1KhRI82cObPQ74QCAAAoLx6FG39/f/Xt21fLli1TRkaG7r77bi1atEh16tRR37599Z///Ef5+fne7hUAAOCiSv2C4po1a6p9+/aKj4+Xn5+fvv32Ww0ZMkT169fXmjVrvNAiAABA8Xkcbg4cOKCnn35a11xzjW644QYdO3ZM7733nvbs2aPMzEzdcsstGjx4sDd7BQAAuCiPPsSvT58+Wr16tRo2bKi77rpLiYmJql69unN/SEiIJk6cqDlz5nitUQAAgOLwKNzUrFlTa9euVXx8fKFjateurT179njcGAAAgCc8elqqY8eOat26dYHtp0+f1muvvSZJcjgczi/ABAAAKC8ehZuhQ4cqJyenwPbjx49r6NChpW4KAADAUx6FG2OMHA5Hge379+9XeHh4qZsCAADwVIlec9OqVSs5HA45HA516dJFAQEXyvPy8rRnzx716NHD600CAAAUV4nCTb9+/SRJaWlp6t69u6pUqeLcFxgYqLp166p///5ebRAAAKAkShRupkyZIkmqW7euBgwYoODg4DJpCgAAwFMevRWcD+cDAAAVVbHDTfXq1fXDDz8oMjJS1apVc/uC4vMOHz7sleYAAABKqtjhZs6cOapataokKSkpqaz6AQAAKJVih5vzT0WdPXtWktS9e3fVqlWrbLoCAADwUIk/5yYgIED33nuvcnNzy6IfAACAUvHoBcXt2rXTli1b+HoFH1b3oZUlGr/3yd5l1AkuBb70eCtJr/xcoLR4vJUNj8LNqFGjNHHiRO3fv19xcXEKDQ112d+8eXOvNAcAAFBSHoWbAQMGSJLGjh3r3OZwOJxfy5CXl+ed7gAAAErIo3CzZ88eb/cBAADgFR6FG15rAwAAKiqPws1rr71W5P7ExESPmgEAACgtj8LN/fff73L9zJkz+vXXXxUYGKjKlSsTbgAAgGVK/Dk3knTkyBGXy4kTJ7Rz505df/31euONN7zdIwAAQLF5FG7cadCggZ588skCZ3UAAADKk9fCjST5+/srMzPTmzcJAABQIh695uadd95xuW6MUVZWlp5//nm1b9/eK40BAAB4wqNw069fP5frDodDl112mTp37qxnnnnGG30BAAB4xKNwk5+fX+Dffn5efYYLAADAIx4nkvnz56tp06YKCQlRSEiImjZtqldeecWbvQEAAJSYR2duHnnkEc2ZM0f33Xef4uPjJUkbNmzQ+PHjtXfvXj322GNebRIAAKC4PAo38+bN07/+9S8NHDjQua1v375q3ry57rvvPsINAACwjEdPS+Xl5alNmzYFtsfFxens2bOlbgoAAMBTHoWbv/71r5o3b16B7S+//LL+8pe/lLopAAAAT3n0tJR07gXFH374oa677jpJ0saNG5WRkaHExERNmDDBOW727Nml7xIAAKCYPAo327ZtU+vWrSVJu3btkiRddtlluuyyy7Rt2zbnOIfD4YUWAQAAis+jcPPpp596uw8AAACv4JP3AACArRBuAACArXj8gmKgvNR9aGWxx+59sncZdlLxcGwubdz/7pXkuEiX1rG5VHDmBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2ArhBgAA2Irl4Wbu3LmqV6+egoODFRcXp88//7xYdevWrVNAQIBatmxZtg0CAACfYmm4SUlJ0bhx4zR58mRt2bJFHTp0UM+ePZWenl5kXU5OjhITE9WlS5dy6hQAAPgKS8PN7NmzNXz4cI0YMUKNGzdWUlKSYmJiNG/evCLr7rnnHt15552Kj48vp04BAICvsCzcnD59Wps3b1a3bt1ctnfr1k3r168vtG7hwoXatWuXpkyZUqx5cnNzdezYMZcLAACwL8vCzS+//KK8vDxFRUW5bI+KilJ2drbbmh9//FEPPfSQFi1apICAgGLNM2PGDIWHhzsvMTExpe4dAABUXJa/oNjhcLhcN8YU2CZJeXl5uvPOOzVt2jQ1bNiw2Lc/adIk5eTkOC8ZGRml7hkAAFRcxTv9UQYiIyPl7+9f4CzNwYMHC5zNkaTjx49r06ZN2rJli8aMGSNJys/PlzFGAQEB+vDDD9W5c+cCdUFBQQoKCiqbRQAAgArHsjM3gYGBiouLU2pqqsv21NRUJSQkFBgfFhamb7/9Vmlpac7LyJEjdfXVVystLU3t2rUrr9YBAEAFZtmZG0maMGGCBg0apDZt2ig+Pl4vv/yy0tPTNXLkSEnnnlL66aef9Nprr8nPz09NmzZ1qa9Zs6aCg4MLbAcAAJcuS8PNgAEDdOjQIU2fPl1ZWVlq2rSpVq1apdjYWElSVlbWRT/zBgAA4PcsDTeSNGrUKI0aNcrtvuTk5CJrp06dqqlTp3q/KQAA4LMsf7cUAACANxFuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArVgebubOnat69eopODhYcXFx+vzzzwsdu2zZMnXt2lWXXXaZwsLCFB8fr9WrV5djtwAAoKKzNNykpKRo3Lhxmjx5srZs2aIOHTqoZ8+eSk9Pdzv+s88+U9euXbVq1Spt3rxZnTp1Up8+fbRly5Zy7hwAAFRUloab2bNna/jw4RoxYoQaN26spKQkxcTEaN68eW7HJyUl6W9/+5uuvfZaNWjQQE888YQaNGigd999t5w7BwAAFZVl4eb06dPavHmzunXr5rK9W7duWr9+fbFuIz8/X8ePH1f16tULHZObm6tjx465XAAAgH1ZFm5++eUX5eXlKSoqymV7VFSUsrOzi3UbzzzzjE6ePKnbb7+90DEzZsxQeHi48xITE1OqvgEAQMVm+QuKHQ6Hy3VjTIFt7rzxxhuaOnWqUlJSVLNmzULHTZo0STk5Oc5LRkZGqXsGAAAVV4BVE0dGRsrf37/AWZqDBw8WOJvzRykpKRo+fLiWLl2qG2+8scixQUFBCgoKKnW/AADAN1h25iYwMFBxcXFKTU112Z6amqqEhIRC69544w0NGTJEixcvVu/evcu6TQAA4GMsO3MjSRMmTNCgQYPUpk0bxcfH6+WXX1Z6erpGjhwp6dxTSj/99JNee+01SeeCTWJiop599lldd911zrM+ISEhCg8Pt2wdAACg4rA03AwYMECHDh3S9OnTlZWVpaZNm2rVqlWKjY2VJGVlZbl85s1LL72ks2fPavTo0Ro9erRz++DBg5WcnFze7QMAgArI0nAjSaNGjdKoUaPc7vtjYFmzZk3ZNwQAAHya5e+WAgAA8CbCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXCDQAAsBXLw83cuXNVr149BQcHKy4uTp9//nmR49euXau4uDgFBwfryiuv1IsvvlhOnQIAAF9gabhJSUnRuHHjNHnyZG3ZskUdOnRQz549lZ6e7nb8nj171KtXL3Xo0EFbtmzRww8/rLFjx+rtt98u584BAEBFZWm4mT17toYPH64RI0aocePGSkpKUkxMjObNm+d2/Isvvqg6deooKSlJjRs31ogRIzRs2DA9/fTT5dw5AACoqAKsmvj06dPavHmzHnroIZft3bp10/r1693WbNiwQd26dXPZ1r17d82fP19nzpxRpUqVCtTk5uYqNzfXeT0nJ0eSdOzYsdIuwa383F+LPfb3PZRH3e9rPa0raa2v1P2+lmPjnbrf13JMC6/l2Hin7ve1HFPv1HlrTm85f5vGmIsPNhb56aefjCSzbt06l+2PP/64adiwoduaBg0amMcff9xl27p164wkk5mZ6bZmypQpRhIXLly4cOHCxQaXjIyMi2YMy87cnOdwOFyuG2MKbLvYeHfbz5s0aZImTJjgvJ6fn6/Dhw+rRo0aRc7jTceOHVNMTIwyMjIUFhZGnQ/26it1vtSrr9T5Uq8cG9+v86VeS7NGTxhjdPz4cUVHR190rGXhJjIyUv7+/srOznbZfvDgQUVFRbmtqVWrltvxAQEBqlGjhtuaoKAgBQUFuWyLiIjwvPFSCAsL8+gBYPc6K+a0e50Vc9q9zoo5faXOijntXmfFnFassaTCw8OLNc6yFxQHBgYqLi5OqampLttTU1OVkJDgtiY+Pr7A+A8//FBt2rRx+3obAABw6bH03VITJkzQK6+8ogULFmjHjh0aP3680tPTNXLkSEnnnlJKTEx0jh85cqT27dunCRMmaMeOHVqwYIHmz5+vBx54wKolAACACsbS19wMGDBAhw4d0vTp05WVlaWmTZtq1apVio2NlSRlZWW5fOZNvXr1tGrVKo0fP14vvPCCoqOj9c9//lP9+/e3agnFEhQUpClTphR4euxSr7NiTrvXWTGn3eusmNNX6qyY0+51VsxpxRrLmsOY4rynCgAAwDdY/vULAAAA3kS4AQAAtkK4AQAAtkK4AQAAtkK4AQAAtkK4AQAAtmL5d0vZ0YkTJ7R582ZlZ2fL4XAoKipKcXFxqlKlise3efbsWWVmZqpOnTrlMmdFm8+KOe0+nxVzWrFGAJegi39/N4rrzJkzZuzYsSYkJMQ4HA4TFBRkAgMDjcPhMCEhIeb+++83p0+f9ui209LSjJ+fX7nNWVHmuxTWyDEtmzWed/z4cbNmzRqzZMkSk5KSYtasWWOOHz9e4rnOO3PmjNm3b1+5zWfFnHafz4o5K9p8Vs1ZXgg3XjR27Fhz+eWXmyVLlpgjR444tx85csQsWbLExMTEmPvvv9+j2y7sl3hZzVlR5rNiTrvPZ8WcVqzRLgHOijntPt+lsMaK9LNhBcKNF0VGRpqPP/640P0fffSRiYyMdLuvVatWRV4aNWrk9kHj6Zy+Mt+lsEaOadms0S4Bzoo57T6fFXNWlPmsmrO88ZobLzp16pQiIyML3V+jRg2dOnXK7b7t27frjjvuUL169dzuz8rK0g8//OC1OX1lPivmtPt8VsxpxRoXL16slJQUde7c2WV7RESEBgwYoMjISN1xxx1KSkpy2d+6detC+zy/Fm/OZ8Wcdp/Pijl9ZT6r5ixvhBsv6tSpkyZMmKBFixYpKirKZd+BAwf0t7/9rcCD6bymTZuqXbt2uvfee93uT0tL07/+9S+vzekr810Ka+SYls0afSXAWTGn3eezYk5fmc+qOcud1aeO7CQ9Pd00bdrUBAQEmJYtW5ru3bubHj16mJYtW5qAgADTvHlzk5GR4bb2/vvvL/I04P/+9z9zww03eG1OX5nvUlgjx7Rs1njTTTeZLl26mOzs7AL7srOzTdeuXU2fPn0K7IuLizNz584tdM4tW7a4PfXu6XxWzGn3+ayY01fms2rO8sa3gntZfn6+Vq9erY0bNyo7O1uSVKtWLcXHx6tbt27y8/P+RwuV95ys0ffns2LO8p4vIyNDvXr10vfff6+mTZsqKipKDodD2dnZ2rZtm5o0aaKVK1fqiiuucKkbN26cJLl9qkOSdu3apREjRujTTz/1ynxWzGn3+S6FNXo6n1VzljfCDQDbsnuAs2JOu89nxZyXwhrLG+GmDPz4449av369yweVJSQkqEGDBmVa687Jkye1efNm/elPf/Jqnad9ent9xenV07qKssayWl9pevWlNQK49BBuvCgnJ0eJiYl69913FR4erpo1a8oYo59//lnHjh1Tnz599NprryksLMyrtUX55ptv1Lp1a+Xl5XmlztM+y2p9l8Iavb2+S2WN5/l6gCtOra+vsazWV9paT3r1tK6i3IfF6dXbdWWi/F/mY1+DBg0yzZo1Mxs3biywb+PGjaZ58+YmMTHR67VF8fRzBwqr87TPslpfUb16WlfR1ujt9ZWmV19a49GjR03fvn2Nw+EwERERpmHDhqZBgwYmIiLC+Pn5mZtvvtnk5OR4ra6s1lhUrV3W6O31XQprLKv1lcUarUC48aLw8HC3v/TP27BhgwkPD/dqbbVq1Yq8hIWFuX2weVrnaZ+lOTZ2X2N5r+9SWaNdAlxRtXZZo7fXV9paT3r1tK6i3YdF9VpWdWWBz7nxMofD4dE+T2tzc3N17733qlmzZm7379u3T9OmTfNanad9lmaf3ddoxfo87dXTfVas8Z133tHq1avVrl27AvvatWunl156ST169PBaXfXq1d32cV5RT515Wusrayzv9ZWm1lfWWJpjU95rtALhxov69Omju+66S/Pnz1ebNm1c9m3atEkjR45U3759vVrbsmVLxcTEaPDgwW5v95tvvnH7y9/TOk/7LM2xsfsay3t9l8oaJd8IcKWt9YU1WrE+T2t9aY2+9AdjubP61JGdHDlyxPTo0cM4HA5TrVo1c/XVV5tGjRqZatWqGT8/P9OzZ0+X7/HwRu3jjz9upk6dWmhP6enpZsiQIV6r87TP0hwbu6+xvNd3qazxr3/9q2nevLn56quvCuz76quvTMuWLc2gQYO8VpeQkGCSkpIK7bWoU/ae1vrKGst7faWp9ZU1lubYlPcarcC7pcrAjh073H52QKNGjcq0tjx9//332rBhQ4n79LTOCp7eF75yH0r2vh+PHj2qgQMHavXq1YqIiFDNmjXlcDh04MAB5eTkqHv37lq8eLEiIiK8UvfEE0/ozJkzmjJlitt+MjIy9Oijj2rhwoUF9nla6ytrLO/1XQprLM2xKe81WoFwA8DWCKnerytv/MHo/Tq7I9x4mTFGH330UYHPHWjfvr26dOlS5POgntaWd11Rjhw5onfffVeJiYnlUldWc/rKfVEW9+HFjo0d6gDYG+HGi3766SfddNNN+vbbb53f12GM0cGDB7Vt2za1aNFC77zzji6//HKv1ZZ33cWU5YexldecvnJflNV9WNSx8bU6XwqbdvhjoyL9oVGa2or0x4Zd/mAsd2X/sp5LR9++fU3nzp1NZmZmgX2ZmZmmc+fO5uabb/ZqbXnX5eTkFHn5/PPP3b6gzNM6K+b0lfuiNI+38j6mVjxu9u/fb1q2bGn8/f1NixYtTLdu3UzXrl1NixYtjL+/v2ndurXZv3+/5XWlrS1KeX9eibfrrDimVtz/nhybsqqzak5vI9x4UWhoqElLSyt0/9dff21CQ0O9WlvedQ6Hw/j5+RV6Ob/fW3VWzOkr90VpHm/lfUyteNz4Utj0lT82fOUPjdLU8gdj2cxZ3vicGy8KCQnR4cOHC91/5MgRhYSEeLW2vOuqVq2qyZMnu/3gKOnc95zcc889XquzYk5fuS9K83gr72NqxePm448/1rp161S7du0C+2rXrq2nn35aHTp0sLyuNLUREREXfVrG3X5fqbPimJZ3XXkfU6vmLG+EGy+64447NHjwYM2ePVtdu3ZVeHi4pHNfNpiamqqJEyfqzjvv9Gptede1bt1aktSxY0e364iIiJBx8zIuT+usmNNX7ovSPN7K+5ha8bjxpbDpK39s+MofGqWp5Q/Gspmz3JX/ySL7ys3NNSNHjjSBgYHGz8/PBAcHm+DgYOPn52cCAwPNvffea3Jzc71aW951L7/8snn22WcLPQbZ2dluP3TN0zor5vSV+6I0j7fyPqZWPG7GjBljYmJizNKlS83Ro0ed248ePWqWLl1q6tSpY8aOHWt5XWlqb7jhBjNz5ky3t2nMuddAOBwOn62z4piWd115H1Or5ixvhJsykJOTYz7++GOzePFis3jxYvPJJ5+YnJzifTurp7XlXXcpyMnJMZ988olHx9QX6uzOl8Kmr/yx4St/aJSmlj8Yy2bO8sZbwQHY2rFjx7Rp0yYdOHBA0rkPOYuLi1NYWFiFqittrZ0dO3ZMmzdvdvmgupIcU09qy7sO3kW48bKTJ09q8eLFbj/nYODAgQoNDfV6rd3rrJqzMAcOHNBLL72kRx991JZ1VsxpxRoB2Bfhxou2b9+url276tdff1XHjh1dPlRt7dq1Cg0N1YcffqgmTZp4rdbudVbNWZSK9kF13q6zYs6yqiPA+35dUQjw3q+zak5vI9x4UadOnVSrVi29+uqrCgwMdNl3+vRpDRkyRFlZWfr000+9Vmv3Oivm3Lp1a4Eefu/777/XwIEDC/yH6it1vtRradZIgPf9uoshwHu/zqo5vY1w40WVK1fWpk2bCv0B3bZtm9q2batff/3Va7V2r7NiTj8/PzkcDrdvMT6/3eFwFPgB9pU6X+q1NGskwPt+HQHeHn/cWKKsXql8KYqOjjYrVqwodP/y5ctNdHS0V2vtXmfFnJGRkWb+/Plm7969bi8rV650+ymcvlLnS72WZo0hISHmu+++c7vPGGO+/fZbExISYnmdL/Va3nXnP4Ha4XAUuBT3k81LWmv3OqvmLG98iJ8X3XXXXRo8eLD+8Y9/qGvXroqKipLD4VB2drZSU1P1xBNPaNy4cV6ttXudFXPGxcUpMzNTsbGxbvs5evSo2zMJvlLnS72WZo3VqlXTjz/+WOiZu//973+qVq2a5XW+1Gt519WoUUMzZ85Uly5d3NZ999136tOnj9t9ntbavc6qOcuddbnKnp588klTu3Ztl+/EcTgcpnbt2kV++FFpau1eV95zLlu2zLz++uuF3ubhw4dNcnKyz9b5Uq+lWeOUKVNMeHi4eeqpp0xaWprJysoy2dnZJi0tzTz11FOmWrVqZtq0aZbX+VKv5V3XvXt383//939uj5kxRX9onKe1dq+zas7yRrgpI7t37zbr168369evN7t37y6XWrvXWTUnfBcB3rfrCPD2+OPGCryg2Mv279+vefPmuX274z333KOYmBiv19q9riL1mpCQoJEjR/p8nS/1Wpo1nrdnzx6XD1WrV6/eRWusqPOlXq04NkBxEW686L///a969uypmJgYdevWzeXtjqmpqcrIyND777+v9u3be63W7nW+1Kuv1PlSr6VZ48VkZGRoypQpWrBgQYWus2JOu9dZMaev1Fk1p9eV74kie2vTpo0ZN25cofvHjRtn2rRp49Vau9f5Uq++UudLvZZmjReTlpbm0Ts7yrvOijntXmfFnL5SZ9Wc3saZGy8KCQlRWlqarr76arf7v//+e7Vq1UqnTp3yWq3d63ypV1+p86VeS7PGd955x23Nebt379bEiRMLfCZHedf5Uq++UudLvV4Kx8YKvBXci2rXrq3169cX+ot4w4YNql27tldr7V7nS736Sp0v9VqaNfbr16/QDwA8z+FwWF7nS736Sp0v9XopHBtLlPepIjt74YUXTGBgoBk9erRZsWKF2bBhg9m4caNZsWKFGT16tAkKCjLz5s3zaq3d63ypV1+p86VeS7PG6Ohos3z5crf7jDFmy5Ytbk+hl3edL/XqK3W+1OulcGysQLjxsiVLlph27dqZgIAA5yc3BgQEmHbt2pmUlJQyqbV7nS/16it1vtSrp3V9+vQxjzzySKH7C/tMjvKu86VefaXOl3q9FI6NFQg3ZeT06dMmMzPTZGZmmtOnT5dLrd3rfKlXX6nzpV5LWvfZZ5+Z999/v9D9J06cMGvWrLG8zpd69ZU6X+r1Ujg2VuAFxQAAwFb8rG4AAADAmwg3AADAVgg3AADAVgg3AADAVgg3ACxVt25dJSUlWd0GABsh3AC4ZE2dOlUtW7a0ug0AXka4AQAAtkK4AVBqb731lpo1a6aQkBDVqFFDN954o06ePKkbbrhB48aNcxnbr18/DRkyxGXb8ePHdeedd6pKlSqKjo7Wc88957J/6tSpqlOnjoKCghQdHa2xY8dKkqZPn65mzZoV6CcuLk6PPvqoJGnNmjVq27atQkNDFRERofbt22vfvn1KTk7WtGnT9M0338jhcMjhcCg5OVmSlJOTo7vvvls1a9ZUWFiYOnfurG+++caln5YtW2rBggWqU6eOqlSponvvvVd5eXmaNWuWatWqpZo1a+rxxx8v5ZEF4AnCDYBSycrK0sCBAzVs2DDt2LFDa9as0S233FLkl+v90VNPPaXmzZvr66+/1qRJkzR+/HilpqZKOhec5syZo5deekk//vijVqxY4Qw0w4YN0/bt2/XVV185b2vr1q3asmWLhgwZorNnz6pfv37q2LGjtm7dqg0bNujuu++Ww+HQgAEDNHHiRF1zzTXKyspSVlaWBgwYIGOMevfurezsbK1atUqbN29W69at1aVLFx0+fNg5z65du/T+++/rgw8+0BtvvKEFCxaod+/e2r9/v9auXauZM2fqH//4hzZu3OilIw2guPhWcAClkpWVpbNnz+qWW25RbGysJLk9m1KU9u3b66GHHpIkNWzYUOvWrdOcOXPUtWtXpaenq1atWrrxxhtVqVIl1alTR23btpUkXXHFFerevbsWLlyoa6+9VpK0cOFCdezYUVdeeaUOHz6snJwc3XTTTapfv74kqXHjxs55q1SpooCAANWqVcu57ZNPPtG3336rgwcPKigoSJL09NNPa8WKFXrrrbd09913S5Ly8/O1YMECVa1aVU2aNFGnTp20c+dOrVq1Sn5+frr66qs1c+ZMrVmzRtddd50nhxaAhzhzA6BUWrRooS5duqhZs2a67bbb9K9//UtHjhwp0W3Ex8cXuL5jxw5J0m233aZTp07pyiuv1F133aXly5fr7NmzzrF33XWX3njjDf322286c+aMFi1apGHDhkmSqlevriFDhqh79+7q06ePnn32WWVlZRXZy+bNm3XixAnVqFFDVapUcV727NmjXbt2OcfVrVtXVatWdV6PiopSkyZN5Ofn57Lt4MGDJToWAEqPcAOgVPz9/ZWamqr3339fTZo00XPPPaerr75ae/bskZ+fX4Gnp86cOVOs23U4HJKkmJgY7dy5Uy+88IJCQkI0atQo/elPf3LeTp8+fRQUFKTly5fr3XffVW5urvr37++8nYULF2rDhg1KSEhQSkqKGjZsWORTRfn5+apdu7bS0tJcLjt37tSDDz7oHFepUqUC/brblp+fX6z1AvAenpYCUGoOh0Pt27dX+/bt9eijjyo2NlbLly/XZZdd5nKmJC8vT9u2bVOnTp1c6v8YNjZu3KhGjRo5r4eEhKhv377q27evRo8erUaNGunbb79V69atFRAQoMGDB2vhwoUKCgrSHXfcocqVK7vcXqtWrdSqVStNmjRJ8fHxWrx4sa677joFBgYqLy/PZWzr1q2VnZ2tgIAA1a1b10tHCEB5ItwAKJUvvvhCH3/8sbp166aaNWvqiy++0M8//6zGjRsrNDRUEyZM0MqVK1W/fn3NmTNHR48eLXAb69at06xZs9SvXz+lpqZq6dKlWrlypSQpOTlZeXl5ateunSpXrqzXX39dISEhztf3SNKIESOcr6VZt26dc/uePXv08ssvq2/fvoqOjtbOnTv1ww8/KDExUdK5p5b27NmjtLQ0XXHFFapatapuvPFGxcfHq1+/fpo5c6auvvpqZWZmatWqVerXr5/atGlThkcTgDcQbgCUSlhYmD777DMlJSXp2LFjio2N1TPPPKOePXvqzJkz+uabb5SYmKiAgACNHz++wFkbSZo4caI2b96sadOmqWrVqnrmmWfUvXt3SVJERISefPJJTZgwQXl5eWrWrJneffdd1ahRw1nfoEEDJSQk6NChQ2rXrp1ze+XKlfX999/r1Vdf1aFDh1S7dm2NGTNG99xzjySpf//+WrZsmTp16qSjR49q4cKFGjJkiFatWqXJkydr2LBh+vnnn1WrVi396U9/UlRUVBkfTQDe4DAleb8mAFRAxhg1atRI99xzjyZMmGB1OwAsxpkbAD7t4MGDev311/XTTz9p6NChVrcDoAIg3ADwaVFRUYqMjNTLL7+satWqWd0OgAqAcAPAp/HMOoA/4nNuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArRBuAACArfw/3lJCsLoBgBIAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -269,23 +273,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Remember our goal: given a state of many qubits, find the separable components.\n", + "Remember our problem: given a state of many qubits, find the separable components.\n", "\n", - "The above discussion suggests one way of achieving this goal: \n", + "The above discussion suggests one way to solve the problem: \n", "compute the purities of all subsystems and look for the subsystems with purity equal to 1.\n", - "There are two obvious problems with this approach.\n", - "\n", - "First, here we had access to the entire mathematical description of the state vector, so we could compute the purities analytically (via pennylane).\n", - "But in practice we would only have access to the *physical* realization of the state (i.e. the qubits), so we would need an algorithm that could take\n", - "these qubits and compute any desired subsystem purity.\n", - "In fact there is a well-known algorithm called the \"swap test\" which does exactly this.\n", - "This algorithm requires many copies of the state.\n", - "Let's suppose that we do have access to many copies of the state.\n", - "In this case computing the purity of any subsystem is doable.\n", - "\n", - "Although we can use the swap test to determine the purity of any given subsystem, \n", - "the bigger problem with this approach to finding the hidden cut is that there are $2^n$ subsystems.\n", - "Therefore it would be impractical to look for pure subsystems by brute force search.\n", + "The problem with this approach is that a system of $n$ qubits has $2^n$ subsystems, \n", + "so looking for pure subsystems by brute force search has an exponential complexity in $n$.\n", "\n", "We need a more efficient way to find the hidden cut." ] @@ -301,19 +294,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's look at the subsystem purity function---the historgram we plotted above---more closely.\n", + "Let's look at the subsystem purity function (the historgram we plotted above) more closely.\n", "Notice that some of the bars seem like they're the same height.\n", "To visualize this, let's colour in the bars according to their height:" ] }, { "cell_type": "code", - "execution_count": 281, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -345,14 +338,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Notice that there are 8 sets of 4 bitstrings each with the same purity. \n", + "Notice that there are 8 sets of 4 bitstrings each with the same purity. \n", + "**Question**: How are bitstrings of the same purity related? \n", "\n", - "Question: how are bitstrings of the same purity related? \n", - "Pause for a bit (no pun intended) and think about it!\n", + "Pause here for a bit, stare at the histogram, and try to answer the question yourself! \n", "\n", "Ready for the answer?\n", "\n", - "Answer: same purity bitstrings are related by bitstring addition of 01101 and 10010.\n", + "**Answer**: Same purity bitstrings are related by bitstring addition of 01101 and 10010.\n", "\n", "For example, start with the first orange bar, 00000.\n", "- Adding 01101 to 00000 gives 01101, the second orange bar. \n", @@ -361,13 +354,13 @@ "\n", "These four orange bars are the subsystems of purity 1 that we discussed earlier.\n", "\n", - "As a second example, start with the third violet bar, 10110.\n", + "As another example, start with the third violet bar, 10110.\n", "- Adding 01101 (bitwise modulo 2) to 10110 gives 11011, the fourth violet bar.\n", "- Adding 10010 to 10110 gives 00100, the first violet bar.\n", "- Adding both 01101 and 10010 to 10110 gives 01001, the second violet bar.\n", "\n", "\n", - "In fact, this approach to getting all of the bars of the same height (the same colour) always works.\n", + "In fact, this approach to getting bars of the same height always works.\n", "You should try it by starting with a bar of another colour.\n", "You'll find that adding 01101 and/or 10010 to this bar will always give the other 3 bars of the same colour!" ] @@ -376,53 +369,54 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The observation that we have made is that the purity function $P(s)$ has a symmetry: \n", + "What this observation tells us is that the purity function $P(s)$ has a symmetry: \n", + "For any bitstring $s$,\n", "$$\n", - "P(s) = P(s + 10100) = P(s + 01011) = P(s + 11111)\n", + "P(s) = P(s + 10010) = P(s + 01101) = P(s + 11111)\n", "$$\n", - "for any bitstring $s$.\n", - "We can associate the set $H = \\{00000, 10100, 01011, 11111\\}$ to our symmetry;\n", + "We can associate the set $H = \\{00000, 10010, 01101, 11111\\}$ to our symmetry;\n", "these are the bitstrings that we can add to $s$ without changing its purity.\n", - "The set $H$ has 3 notable properties:\n", + "The set $H$ has three important properties:\n", "1. It contains the unique \"identity\" bitstring 00000, for which $s + 00000 = s$ for all $s$\n", "2. The set is closed under addition\n", "3. Every element in $H$ has an inverse in $H$, such that the element plus its inverse give the identity. \n", - "Namely 00000 is its own inverse, as is 11111, while 10100 and 01011 are each other's inverses.\n", + "(In fact every element is its own inverse.)\n", "\n", - "These three properties (along with the obvious property that bitstring addition is associative) turn $H$ into what is called a *group* in math.\n", - "Indeed a group is just a set closed under an associative operation (here bitstring addition), containing an identity and inverses for every element.\n", - "So what we discovered is that our purity function has a symmetry, and that this symmetry is associated with a group.\n", - "Thinking of symmetries as groups is arguably the most successful guiding principle in quantum physics, and we'll see that it's useful here as well." + "These three properties turn $H$ into what is called a *group* in math.\n", + "A group is just a set closed under an associative \"addition\" operation (here bitstring addition), containing an identity and inverses for every element.\n", + "So what we discovered is that the purity function has a symmetry and that this symmetry is associated with a group.\n", + "Thinking of symmetries as groups is arguably the most successful guiding principle in quantum physics (if not all of physics), and we'll see that it's useful here as well." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Relating symmetries to separable components" + "## Hidden cut problem as a hidden subgroup problem" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "To see how this can help us solve the hidden cut problem, take another look at the symmetry group $H$.\n", - "$H$ has 4 elements but it can be \"generated\" by only 2 elements, 10100 and 01011,\n", - "meaning that the other elements in $H$ (00000 and 11111) can be obtained via the two generators and bitwise addition.\n", - "This is actually something we already knew: when we were trying to find subsystems of the same purity,\n", - "it was enough to start with a subsystem and add to it different combinations of the generators.\n", + "To see how symmetries can help us find separable components, take another look at the symmetry group $H$.\n", + "Notice that by adding the two bitstrings 10100 and 01011 in different linear combinations, we can generate any element of $H$. \n", + "We say that 10010 and 01101 are \"generators\" of $H$.\n", + "\n", + "**Question**: Is there anything special about the generators 10010 and 01101 of the symmetry group $H$?\n", "\n", - "Very important question: is there anything special about the generators 10100 and 01011 of the symmetry group $H$?\n", "Pause and think about it!\n", "\n", - "Answer: the generators directly give us the separable subsets $S$ and $\\bar S$! \n", - "What I mean is that the first generator 10100 has 1s in positions 0 and 2, so this gives the subset $S=\\{0,2\\}, \n", - "and the second generator 01011 has 1s in positions 1, 3, and 4, so this gives the complementary subset $S=\\{1,3,4\\}$.\n", + "**Answer**: The generators directly give us the separable subsets $S$ and $\\bar S$ of the original 5-qubit state! \n", + "What I mean is that the first generator 10010 has 1s in positions 0 and 3, so this gives the subset $S=\\{0,3\\}, \n", + "and the second generator 01101 has 1s in positions 1, 2, and 4, so this gives the complementary subset $S=\\{1,2,4\\}$.\n", + "\n", + "In fact, this relationship between generators and separable components is not a coincidence:\n", + "for any multi-qubit state $\\ket\\psi$ the separable components are equal to the generators of $H$, the symmetry group of the purity function!\n", + "(Optional exercise for curious readers: prove this statement!)\n", "\n", - "This relationship between generators and separable components is not a coincidence:\n", - "for any state $\\ket\\psi$ the separable components are equal to the generators of $H$!\n", "\n", - "To understand why, let's work through an example using our state $\\ket\\psi = \\ket{\\psi_{0,2}}\\otimes\\ket{\\psi_{1,3,4}}$.\n", + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Hidden cut problem as a hidden subgroup problem" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ + "This is a very important observation!\n", + "It means that to determine the separable components of $\\ket\\psi$ we just need to find $H$, the symmetry group of the purity function!\n", + "\n", "\n", - "# H is a subgroup of the full group G = {00000, 00001, ...} with the group operation being bitwise addition modulo 2.\n", "\n", "\n", - "# so in order to find the separable components of the state, we just have to find the symmetry subgroup of the purity function pi(s), and look at its generators.\n", + "Just as the bitstrings $H = \\{00000, 10100, 01011, 11111\\}$ form group, the set $G$ of all $n$-bit strings also forms a group: \n", + "it's closed under addition, it contains the identity, and every element in $G$ has an inverse in $G$.\n", + "$G$ contains $2^n$ elements.\n", + "In fact, the group $H$ is a subset of the group $G$.\n", + "We say that $H$ is a *subgroup* of $G$.\n", + "Because the generators of $H$ encode the separable components of $\\ket\\psi$, we can find the hidden cut of $\\ket\\psi$ by finding the hidden subgroup $H$ of $G$.\n", + "This is an example of a *hidden subgroup problem* (HSP), an important class of problems that quantum computers can solve efficiently. \n", + "The most famous HSP is the problem of factoring large integers.\n", + "Like the hidden cut problem, it's not immediately obvious that factoring is related to finding a subgroup, but in fact it is.\n", + "We'll use the HSP algorithm to solve the hidden cut problem.\n", "\n", - "# this is an example of a \"hidden subgroup problem\" a very important class of problems that quantum computers can solve efficiently. \n", + "In the general HSP we want to find the symmetry subgroup $H$ of a function $f$ over a group $G$. \n", + "When $G$ is the group of $n$-bit strings, the algorithm to solve the HSP is particularly simple.\n", + "The algorithm assumes that we have access to a quantum version of the function $f$, meaning a unitary $U_f$\n", + "that maps $\\ket g \\ket 0$ to $\\ket g \\ket{f(g)}$ for every element $g$ of the group $G$.\n", + "Here $\\ket g$ is an encoding of $g$ into an $n$-qubit register, and $\\ket{f(g)}$ is a second register that encodes $f(g)$ such that\n", + "$\\ket{f(g)}$ and $\\ket{f(g')}$ are equal if $f(g) = f(g')$ and otherwise orthogonal.\n", "\n", - "# Notice that it wasnt at all obvious that our problem of finding the separable components of a state was a hidden subgroup problem; we needed to think a bit to frame it in this way. In fact the same is true for the most famous problem solveable by quantum computers: factoring large integers. At first this doesn't look anything like a hidden subgroup problem, but as Peter Shor showed with some clever math it can be phrased as one, and can therefore be solved by the general quantum circuit for hidden subgroup problems.\n", + "The HSP algorithm works by obtaining measurements from a quantum circuit and then postprocessing the measurements.\n", + "The quantum circuit first applies Hadamards to the $\\ket 0$ state to create a uniform superposition $\\sum_g \\ket g$ in the group register, \n", + "then applies $U_f$ to create the state $\\sum_g \\ket g\\ket{f(g)}$, and finally again applies Hadamards to the first register.\n", + "The circuit looks like:\n", "\n", - "# We'd like to use this quantum circuit to solve our \"hidden cut\" problem. So how does the HSP quantum circuit look?\n", + "[Picture of circuit]\n", "\n", + "The key feature of this circuit is that measurments of the group register are guaranteed to be orthogonal to the hidden subgroup $H$.\n", + "For example if we run the circuit and get a measurement outcome $m=10101$, then we know that $a = 00011$ is not in $H$ because $a\\cdot m != 0 \\text{ mod }2$.\n", + "Repeatedly running the circuit and performing measurements tells us what bitstrings cannot be in $H$.\n", + "After $\\mathcal O(n)$ measurements, the bitstrings that are orthogonal to all measurements are very likely in $H$.\n", + "At this point we stop the algorithm and predict that $H$ is given by these bitstrings.\n", + "\n", + "Now let's apply this to solve the hidden cut problem for the state $\\ket \\psi$.\n", + "The general function $f(s)$ is now the subsystem purity function $P(s)$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ "# Suppose we want to find the hidden symmetry subgroup of a function f(s) over n-bit strings s. we start with two n-qubit registers initialized in the all |0> states. \n", "# the first step is to apply a Hadamard to each qubit in the first register to create a uniform superposition sum |s>.\n", "# the second step assumes that we have access to a unitary U_f that maps |s>|0> to |s>|f(s)>, such that |f(s)> and |f(s')> are equal if f(s) = f(s') and orthogonal if f(s) != f(s').\n", @@ -573,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 205, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -624,17 +644,9 @@ }, { "cell_type": "code", - "execution_count": 219, + "execution_count": 46, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/petar.simidzija/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/debugging/snapshot.py:243: UserWarning: Snapshots are not supported for the given device. Therefore, a tape will be created for each snapshot, resulting in a total of n_snapshots + 1 executions.\n", - " warnings.warn(\n" - ] - }, { "ename": "DeviceError", "evalue": "Measurement state(wires=[]) not accepted with finite shots on lightning.qubit", @@ -642,14 +654,15 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mDeviceError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[219], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# return qml.state()\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mprobs()\n\u001b[0;32m----> 9\u001b[0m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msnapshots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:987\u001b[0m, in \u001b[0;36mQNode.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 985\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mcapture\u001b[38;5;241m.\u001b[39menabled():\n\u001b[1;32m 986\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mcapture\u001b[38;5;241m.\u001b[39mqnode_call(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 987\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impl_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:977\u001b[0m, in \u001b[0;36mQNode._impl_call\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 974\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_interface \u001b[38;5;241m=\u001b[39m interface\n\u001b[1;32m 976\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 977\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_component\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 978\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 979\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m old_interface \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mauto\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:935\u001b[0m, in \u001b[0;36mQNode._execution_component\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 932\u001b[0m interface \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minterface \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnumpy\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minterface\n\u001b[1;32m 934\u001b[0m \u001b[38;5;66;03m# pylint: disable=unexpected-keyword-arg\u001b[39;00m\n\u001b[0;32m--> 935\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 936\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_tape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 937\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 938\u001b[0m \u001b[43m \u001b[49m\u001b[43mgradient_fn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgradient_fn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 939\u001b[0m \u001b[43m \u001b[49m\u001b[43minterface\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterface\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 940\u001b[0m \u001b[43m \u001b[49m\u001b[43mtransform_program\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfull_transform_program\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 941\u001b[0m \u001b[43m \u001b[49m\u001b[43minner_transform\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minner_transform_program\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 942\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 943\u001b[0m \u001b[43m \u001b[49m\u001b[43mgradient_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgradient_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 944\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mexecute_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 945\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 946\u001b[0m res \u001b[38;5;241m=\u001b[39m res[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 948\u001b[0m \u001b[38;5;66;03m# convert result to the interface in case the qfunc has no parameters\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/execution.py:523\u001b[0m, in \u001b[0;36mexecute\u001b[0;34m(tapes, device, gradient_fn, interface, transform_program, inner_transform, config, grad_on_execution, gradient_kwargs, cache, cachesize, max_diff, device_vjp, mcm_config)\u001b[0m\n\u001b[1;32m 521\u001b[0m \u001b[38;5;66;03m# Exiting early if we do not need to deal with an interface boundary\u001b[39;00m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m no_interface_boundary_required:\n\u001b[0;32m--> 523\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43minner_execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m post_processing(results)\n\u001b[1;32m 526\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m config\u001b[38;5;241m.\u001b[39muse_device_jacobian_product \u001b[38;5;129;01mand\u001b[39;00m interface \u001b[38;5;129;01min\u001b[39;00m jpc_interfaces:\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/execution.py:199\u001b[0m, in \u001b[0;36m_make_inner_execute..inner_execute\u001b[0;34m(tapes, **_)\u001b[0m\n\u001b[1;32m 196\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cache \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 197\u001b[0m transform_program\u001b[38;5;241m.\u001b[39madd_transform(_cache_transform, cache\u001b[38;5;241m=\u001b[39mcache)\n\u001b[0;32m--> 199\u001b[0m transformed_tapes, transform_post_processing \u001b[38;5;241m=\u001b[39m \u001b[43mtransform_program\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m transformed_tapes:\n\u001b[1;32m 202\u001b[0m results \u001b[38;5;241m=\u001b[39m device\u001b[38;5;241m.\u001b[39mexecute(transformed_tapes, execution_config\u001b[38;5;241m=\u001b[39mexecution_config)\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/transforms/core/transform_program.py:515\u001b[0m, in \u001b[0;36mTransformProgram.__call__\u001b[0;34m(self, tapes)\u001b[0m\n\u001b[1;32m 513\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_argnums \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_argnums[i] \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 514\u001b[0m tape\u001b[38;5;241m.\u001b[39mtrainable_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_argnums[i][j]\n\u001b[0;32m--> 515\u001b[0m new_tapes, fn \u001b[38;5;241m=\u001b[39m \u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 516\u001b[0m execution_tapes\u001b[38;5;241m.\u001b[39mextend(new_tapes)\n\u001b[1;32m 518\u001b[0m fns\u001b[38;5;241m.\u001b[39mappend(fn)\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/devices/preprocess.py:525\u001b[0m, in \u001b[0;36mvalidate_measurements\u001b[0;34m(tape, analytic_measurements, sample_measurements, name)\u001b[0m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m sample_measurements(m):\n\u001b[0;32m--> 525\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mDeviceError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMeasurement \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mm\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not accepted with finite shots on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 527\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 528\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n", + "Cell \u001b[0;32mIn[46], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# return qml.state()\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mprobs()\n\u001b[0;32m----> 9\u001b[0m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msnapshots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:882\u001b[0m, in \u001b[0;36mQNode.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 879\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_capture_qnode\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m capture_qnode \u001b[38;5;66;03m# pylint: disable=import-outside-toplevel\u001b[39;00m\n\u001b[1;32m 881\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m capture_qnode(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 882\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impl_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:855\u001b[0m, in \u001b[0;36mQNode._impl_call\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 852\u001b[0m \u001b[38;5;66;03m# Calculate the classical jacobians if necessary\u001b[39;00m\n\u001b[1;32m 853\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_transform_program\u001b[38;5;241m.\u001b[39mset_classical_component(\u001b[38;5;28mself\u001b[39m, args, kwargs)\n\u001b[0;32m--> 855\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 856\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mtape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mdiff_method\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdiff_method\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43minterface\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minterface\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 860\u001b[0m \u001b[43m \u001b[49m\u001b[43mtransform_program\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform_program\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 861\u001b[0m \u001b[43m \u001b[49m\u001b[43mgradient_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgradient_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 862\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 863\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 864\u001b[0m res \u001b[38;5;241m=\u001b[39m res[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 866\u001b[0m \u001b[38;5;66;03m# convert result to the interface in case the qfunc has no parameters\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/execution.py:244\u001b[0m, in \u001b[0;36mexecute\u001b[0;34m(tapes, device, diff_method, interface, transform_program, grad_on_execution, cache, cachesize, max_diff, device_vjp, postselect_mode, mcm_method, gradient_kwargs, mcm_config, config, inner_transform)\u001b[0m\n\u001b[1;32m 241\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m transform_program\u001b[38;5;241m.\u001b[39mis_informative:\n\u001b[1;32m 242\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m post_processing(tapes)\n\u001b[0;32m--> 244\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minner_transform\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 245\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m post_processing(results)\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/run.py:286\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(tapes, device, config, inner_transform_program)\u001b[0m\n\u001b[1;32m 282\u001b[0m no_interface_boundary_required \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 283\u001b[0m config\u001b[38;5;241m.\u001b[39minterface \u001b[38;5;241m==\u001b[39m Interface\u001b[38;5;241m.\u001b[39mNUMPY \u001b[38;5;129;01mor\u001b[39;00m config\u001b[38;5;241m.\u001b[39mgradient_method \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbackprop\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 284\u001b[0m )\n\u001b[1;32m 285\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m no_interface_boundary_required:\n\u001b[0;32m--> 286\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43minner_execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m results\n\u001b[1;32m 289\u001b[0m \u001b[38;5;66;03m# TODO: Prune once support for tf-autograph is dropped\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/run.py:248\u001b[0m, in \u001b[0;36m_make_inner_execute..inner_execute\u001b[0;34m(tapes)\u001b[0m\n\u001b[1;32m 239\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_execute\u001b[39m(tapes: QuantumScriptBatch) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResultBatch:\n\u001b[1;32m 240\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Execution that occurs within a ML framework boundary.\u001b[39;00m\n\u001b[1;32m 241\u001b[0m \n\u001b[1;32m 242\u001b[0m \u001b[38;5;124;03m Closure Variables:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 245\u001b[0m \u001b[38;5;124;03m device (qml.devices.Device): a Pennylane device\u001b[39;00m\n\u001b[1;32m 246\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 248\u001b[0m transformed_tapes, transform_post_processing \u001b[38;5;241m=\u001b[39m \u001b[43minner_transform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m transformed_tapes:\n\u001b[1;32m 251\u001b[0m results \u001b[38;5;241m=\u001b[39m device\u001b[38;5;241m.\u001b[39mexecute(transformed_tapes, execution_config\u001b[38;5;241m=\u001b[39mexecution_config)\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/transforms/core/transform_program.py:643\u001b[0m, in \u001b[0;36mTransformProgram.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 641\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mtype\u001b[39m(args[\u001b[38;5;241m0\u001b[39m])\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJaxpr\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__call_jaxpr(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__call_tapes\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/transforms/core/transform_program.py:580\u001b[0m, in \u001b[0;36mTransformProgram.__call_tapes\u001b[0;34m(self, tapes)\u001b[0m\n\u001b[1;32m 578\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m argnums \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 579\u001b[0m tape\u001b[38;5;241m.\u001b[39mtrainable_params \u001b[38;5;241m=\u001b[39m argnums[j]\n\u001b[0;32m--> 580\u001b[0m new_tapes, fn \u001b[38;5;241m=\u001b[39m \u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 581\u001b[0m execution_tapes\u001b[38;5;241m.\u001b[39mextend(new_tapes)\n\u001b[1;32m 583\u001b[0m fns\u001b[38;5;241m.\u001b[39mappend(fn)\n", + "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/devices/preprocess.py:526\u001b[0m, in \u001b[0;36mvalidate_measurements\u001b[0;34m(tape, analytic_measurements, sample_measurements, name)\u001b[0m\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n\u001b[1;32m 525\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m sample_measurements(m):\n\u001b[0;32m--> 526\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mDeviceError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMeasurement \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mm\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not accepted with finite shots on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 528\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 529\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n", "\u001b[0;31mDeviceError\u001b[0m: Measurement state(wires=[]) not accepted with finite shots on lightning.qubit" ] } From 91289c7647ee62831cb8a47066c8fc3eb1f16e65 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Tue, 10 Jun 2025 14:31:04 -0400 Subject: [PATCH 12/20] Finish first draft of hidden cut demo --- demonstrations/hidden_cut.ipynb | 784 ++++++++++++-------------------- 1 file changed, 303 insertions(+), 481 deletions(-) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/hidden_cut.ipynb index 5914178887..2359e7912d 100644 --- a/demonstrations/hidden_cut.ipynb +++ b/demonstrations/hidden_cut.ipynb @@ -2,72 +2,96 @@ "cells": [ { "cell_type": "markdown", + "id": "91a53a55", "metadata": {}, "source": [ - "# The hidden cut algorithm for locating unentanglement" + "# The hidden cut problem for locating unentanglement" ] }, { "cell_type": "markdown", + "id": "4345b999", "metadata": {}, "source": [ - "One of the most interesting and counterintuitive features of quantum physics is entanglement.\n", - "Entanglement is a form of correlation between quantum systems that is fundamentally different from any correlation that can exist between classical systems.\n", - "To define entanglement, let $\\ket{\\psi}$ be a state of a quantum system with two parts, $A$ and $B$.\n", - "For example $A$ and $B$ might each be single qubits; then $\\ket{\\psi}$ is a two qubit state.\n", - "We say $A$ and $B$ are *unentangled* or *separable* if $\\ket{\\psi}$ can be written as a tensor product\n", + "One of the most provocative and counterintuitive features of quantum physics is *entanglement*, a form of correlation that can exist between quantum systems.\n", + "To illustrate the striking nature of entanglement, imagine two entangled qubits, with the first one located at Xanadu's headquarters in Toronto, and the second located in the [JADES-GS-z13-0](https://en.wikipedia.org/wiki/JADES-GS-z13-0) galaxy, the furthest galaxy ever measured.\n", + "The proper cosmological distance between these qubits is about 33 billion light-years.\n", + "Nevertheless, because they are entangled, the measurement outcome of the qubit in Toronto will necessarily be correlated with the measurement of the qubit in JADES-GS-z13-0!\n", + "How this is possible when it takes light itself 33 billion years to travel between the qubits is one of the most philosophically loaded questions at the heart of quantum foundations.\n", + "\n", + "Despite entanglement being so philosophically provocative, it's somewhat surprising that in fact it is ubiquitous:\n", + "given a random state of a two-component quantum system, it's almost certain that the two components will be entangled. \n", + "For this reason, it's sometimes more interesting when a state is *not* entangled rather than when it is!\n", + "For example, when [building a quantum computer at Xanadu](https://www.xanadu.ai/photonics), we spend a ton of effort to ensure that our qubits are as *unentangled* as possible with their environment!\n", + "\n", + "In this demo we'll investigate *unentanglement* more closely.\n", + "More specifically we'll consider a problem related to unentanglement, called the *hidden cut problem*. \n", + "In this problem we assume that we're given a state consisting of many components. \n", + "As we discussed, it'll generally be the case that most of these components are entangled with one another.\n", + "But in the hidden cut problem we are guaranteed that it's possible to split the components up into two groups, so that between the two groups there is *no* entanglement.\n", + "The problem asks us to find this \"hidden cut\" that splits the state up into two *unentangled* pieces.\n", + "\n", + "Let's define the hidden cut problem a bit more precisely.\n", + "First we need to define *unentanglement*.\n", + "We say that a quantum state $\\ket\\psi$ describing a system with two parts, $A$ and $B$, is *unentangled*, if it can be written as a tensor product\n", "$$\n", "\\ket{\\psi} = \\ket{\\psi_A}\\otimes \\ket{\\psi_B}\n", "$$,\n", "where $\\ket{\\psi_A}$ is a state of system $A$ and $\\ket{\\psi_B}$ is a state of system $B$.\n", - "If $\\ket{\\psi}$ isn't separable then we say $A$ and $B$ are *entangled*.\n", + "We also use the term *separable* or *factorizable* to describe an unentagled state.\n", + "We'll usually not bother writing the tensor product sign and just write $\\ket{\\psi} = \\ket{\\psi_A}\\ket{\\psi_B}$.\n", + "And if $\\ket{\\psi}$ isn't unentangled we say it's *entangled*.\n", "\n", - "Now suppose we're given a state of $n$ qubits.\n", - "We're told that it's possible to split the qubits into two unentangled subsets, $S$ and $\\bar S$, \n", - "in other words $\\ket{\\psi}$ can be written as\n", + "Now let's suppose $\\ket\\psi$ is a state of $n$-qubits.\n", + "We're told it's possible to split the qubits into two unentangled subsets, $S$ and $\\bar S$, \n", "$$\n", - "\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}},\n", + "\\ket{\\psi} = \\ket{\\psi_S}\\ket{\\psi_{\\bar S}},\n", "$$\n", - "but we aren't told what $S$ and $\\bar S$ are. \n", - "Question: how can we determine $S$ and $\\bar S$, or in other words, how do we determine the ``hidden cut'' that splits the qubits into two unentangled subsystems.\n", + "but we aren't told what $S$ and $\\bar S$ are. \n", + "The hidden cut problem asks us, given access to $\\ket\\psi$, to determine $S$ and $\\bar S$.\n", "Following ..., in this demo we'll develop a quantum algorithm that solves this problem!" ] }, + { + "cell_type": "markdown", + "id": "c4cca12b", + "metadata": {}, + "source": [ + "## Creating an unentangled state" + ] + }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 47, + "id": "87f21042", "metadata": {}, "outputs": [], "source": [ + "import galois\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pennylane as qml\n", "from scipy.stats import unitary_group\n", "\n", "# set random seed\n", - "np.random.seed(hash('hidden_cut') % 2**32)" + "np.random.seed(123)" ] }, { "cell_type": "markdown", + "id": "4c3a0a35", "metadata": {}, "source": [ - "## Creating a separable state" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's create a separable state with $n=5$ qubits.\n", - "First we define a function that creates a random state with a specified number of qubits.\n", + "Before we can solve the hidden cut problem, we first need a state $\\ket\\psi$ to solve it on!\n", + "First we define a function `random_state()` that creates a random state with a specified number of qubits.\n", "We do this by creating a $2^n$ by $2^n$ random unitary and taking the first row.\n", "Because all the rows (and columns) in a unitary matrix have norm equal to 1, this defines a valid quantum state." ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 48, + "id": "bd854cdf", "metadata": {}, "outputs": [], "source": [ @@ -78,25 +102,19 @@ }, { "cell_type": "markdown", + "id": "a8000a8c", "metadata": {}, "source": [ - "We'll use this function to set qubits $S=\\{0,3\\}$ and $\\bar S=\\{1,2,4\\}$ to each be in a random pure state.\n", - "The full 5 qubit state will then be separable along this partition. " + "However we can't just use this function to construct our state $\\ket\\psi$, because the random state created by the function will almost certainly *not* be unentagled.\n", + "So we'll define a function `separable_state()` that takes as input a list of qubit partitions, creates a random state for each partition, and tensors them together into a separable state." ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 49, + "id": "b52893dc", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created 5 qubit state with qubits [0, 3] unentangled from [1, 2, 4].\n" - ] - } - ], + "outputs": [], "source": [ "def separable_state(partitions):\n", " # Number of qubits\n", @@ -126,558 +144,362 @@ " \n", " full_state[idx] = amplitude\n", " \n", - " return full_state\n", - "\n", - "# create separable 5 qubit state\n", - "S = [0,3]\n", - "S_bar = [1,2,4]\n", - "state = separable_state([S, S_bar])\n", - "n = int(np.log2(len(state)))\n", - "print(f'Created {n} qubit state with qubits {S} unentangled from {S_bar}.')" + " return full_state" ] }, { "cell_type": "markdown", + "id": "ea087ba6", "metadata": {}, "source": [ - "## Subsystem purities" + "We'll use this to create a 5-qubit state $\\ket\\psi$ in which qubits $S=\\{0,1\\}$ are unentangled with qubits $\\bar S=\\{2,3,4\\}$." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "e3080187", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created 5 qubit state with qubits [0, 1] unentangled from [2, 3, 4].\n" + ] + } + ], + "source": [ + "partitions = [[0,1], [2,3,4]]\n", + "state = separable_state(partitions)\n", + "n = int(np.log2(len(state)))\n", + "print(f'Created {n} qubit state with qubits {partitions[0]} unentangled from {partitions[1]}.')" ] }, { "cell_type": "markdown", + "id": "bae2878f", "metadata": {}, "source": [ - "Let's verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$.\n", - "One way to check if a subsystem $S$ of a pure state $\\ket{\\psi}$ is entangled with the complementary subsystem $\\bar S$\n", - "is to consider the reduced density matrix $\\rho_S$ describing the state of $S$ and compute its purity, \n", - "$$\n", - "P(S) := \\text{Tr}(\\rho_S^2).\n", - "$$\n", - "If $S$ and $\\bar S$ are unentangled, i.e. $\\ket{\\psi} = \\ket{\\psi_S}\\otimes \\ket{\\psi_{\\bar S}}$, then $\\rho_S = \\ket{\\psi_S}\\bra{\\psi_S}$\n", - "and the purity of $S$ is $P(S)=1$.\n", - "Meanwhile if $S$ and $\\bar S$ *are* entangled, then $\\rho_S$ will be a mixed state and $P(S)$ will be less than 1\n", - "(can you prove this?).\n", - "\n", - "So to verify that qubits $S=\\{0,3\\}$ are unentangled with qubits $\\bar S=\\{1,2,4\\}$ we just need to check that $P(S) = 1$. \n", - "Instead of just computing $P(\\{0,3\\})$, let's go a step further and compute the purities of *all* subsystems of qubits.\n", - "Because there are 5 qubits we can denote a subsystem as a 5-bit string, where a 1 bit indicates that a qubit belongs to the subsystem and a 0 bit that it doesn't belong.\n", - "For example '10010' denotes the subsystem $S=\\{0,3\\}$ because it has 1s in positions 0 and 3.\n", - "\n", - "Since there are $2^5=32$ different 5-bit strings, there are 32 total subsystems.\n", - "Let's create a histogram showing all 32 subsystem purities.\n", - "First we define a function to compute the purity of a subsystem.\n", - "`qml.purity()` does the heavy lifting:" + "Now imagine we're given $\\ket \\psi$ but aren't told that qubits 0,1 are unentangled from qubits 2,3,4.\n", + "How could we figure this out?\n", + "This is the hidden cut problem: given a many-qubit quantum state, figure out which qubits are unentangled with which other qubits.\n", + "Now we'll develop a quantum algorithm that solves this problem, and then we'll implement it in Pennylane and see that it works!" ] }, { - "cell_type": "code", - "execution_count": 40, + "cell_type": "markdown", + "id": "322cb418", "metadata": {}, - "outputs": [], "source": [ - "dev = qml.device('default.qubit')\n", - "\n", - "@qml.qnode(dev)\n", - "def get_purity(state, subsystem):\n", - " qml.StatePrep(state, wires=range(n))\n", - " return qml.purity(wires=np.nonzero(subsystem)[0])" + "## Hidden cut problem as a hidden subgroup problem" ] }, { "cell_type": "markdown", + "id": "88dcebee", "metadata": {}, "source": [ - "Now let's compute all subsystem purities and store them in a `purities` list.\n", - "We'll also store the subsystems, encoded as 5-bit strings, into a `bitstrings` list.\n", - "The empty subsystem 00000 is an edge case that `qml.purity()` can't handle, so we add it by hand.\n", - "Because complementary subsystems have identical purities (prove this!), $P(00000) = P(11111) = 1$." + "The key to solving the hidden cut problem is to recast it as a *hidden symmetry problem*, or in more mathematical language a *hidden subgroup problem* (HSP).\n", + "Then we can use a famous quantum algorithm for solving HSPs to solve the hidden cut problem.\n", + "The traditional HSP algorithm is useful for finding symmetries of functions $f(x)$, i.e. figuring out for what values of $a$ we have $f(x+a) = f(x)$ for all $x$. \n", + "However we're interested in a *state* $\\ket\\psi$ and not a *function* $f(x)$, so we'll instead use a modified version of the HSP algorithm, called StateHSP, which finds *symmetries of states*.\n", + "\n", + "We'll explain the StateHSP algorithm below, but first let's see how we can recast the hidden cut problem as one of finding a hidden symmetry of a state.\n", + "To see this, remember our example state $\\ket\\psi=\\ket{\\psi_{01}}\\ket{\\psi_{234}}$.\n", + "Now consider two copies $\\ket\\psi\\ket\\psi$ of $\\ket\\psi$.\n", + "We can visualize this as \n", + "\n", + "[...picture...]\n", + "\n", + "The top row corresponds to the first copy of $\\ket\\psi$, and the bottom row to the second copy.\n", + "In each row, qubits 0 and 1 are disconnected from qubits 2, 3, and 4.\n", + "This schematically indicates the fact that in each $\\ket\\psi$ qubits 0,1 are unentangled from qubits 2,3,4.\n", + "\n", + "Now consider what happens when we swap some qubits in the top row with the corresponding qubits in the bottom row.\n", + "We can denote which pairs of qubits we're swapping with a 5-bit string. \n", + "For example, the bitstring 10101 corresponds to swapping the qubits in positions 0, 2, and 4 in the top row with qubits 0, 2, and 4 in the bottom row.\n", + "Because there are $2^5=32$ 5-bit strings, there are 32 possible swap operations we can perform.\n", + "Interestingly, the set of all 32 5-bit strings forms a mathematical *group* under bitwise addition.\n", + "\n", + "BOX: Group (take from Maria's demo)\n", + "\n", + "We'll call the group of 5-bit strings $G$.\n", + "We can now ask: which elements of $G$ correspond to swap operations that leave the state $\\ket\\psi\\ket\\psi$ invariant?\n", + "These operations are the symmetries of $\\ket\\psi\\ket\\psi$ and the corresponding bitstrings form a subgroup $H$ of $G$.\n", + "For example the identity element 00000 corresponds to performing no swaps at all.\n", + "This is clearly a symmetry, so 00000 is in $H$.\n", + "On the other hand 11111 swaps *all* the qubits in the top row with the corresponding qubits in the bottom row, so in effect it just swaps the entire first copy of $\\ket\\psi$ with the entire second copy of $\\ket\\psi$.\n", + "This is clearly also a symmetry, so 11111 is also in $H$.\n", + "Are there any other elements in $H$?\n", + "Stop and think about it!\n", + "\n", + "In fact, there are two more elements in $H$: 11000 and 00111.\n", + "11000 corresponds to swapping the $\\ket{\\psi_{01}}$ component of the first copy of $\\ket\\psi$ with the same component of the second copy of $\\ket\\psi$, and 00111 corresponds to swapping the $\\ket{\\psi_{234}}$ components between the two copies.\n", + "Because in each copy of $\\ket\\psi$ the $\\ket{\\psi_{01}}$ and $\\ket{\\psi_{234}}$ components are completely unentangled, after either of these swaps the full state remains the same, namely $\\ket\\psi\\ket\\psi$.\n", + "So the symmetry subgroup is $H = {00000, 11111, 11000, 00111}$.\n", + "We'll call this a *hidden* symmetry subgroup because it wasn't given to us - we had to find it!\n", + "\n", + "Now, a shorthand way to write any group is to specify a set of *generators*, group elements that can be added together to generate any other element of the group.\n", + "For $H$ the generators are 11000 and 00111: we can add either generator to itself to get the identity 00000, and we can add the generators to each other to get 11111.\n", + "Here's the important point: notice that the generators of $H$ *directly* tell us the unentangled components of $\\ket\\psi=\\ket{\\psi_{01}}\\ket{\\psi_{234}}$!\n", + "The first generator 11000 has 1s in bits 0 and 1: this corresponds to the first unentangled component $\\ket{\\psi_{01}}$.\n", + "And the second generator 00111 has 1s in bits 2, 3, 4: this corresponds to the second unentangled component $\\ket{\\psi_{234}}$.\n", + "So finding the hidden subgroup $H$ gives us the unentangled components - it solves the hidden cut problem!\n", + "\n", + "So now that we recast the hidden cut problem as a problem of finding a hidden subgroup $H$, lets see how the StateHSP algorithm can be used to find $H$.\n", + "The general algorithm works for any abelian group $G$, but here we'll just focus on the case where $G$ is the group of $n$-bit strings, since this is the case that's relevant to solving the hidden cut problem.\n", + "\n", + "The algorithm involves running a quantum circuit, taking measurements, and postprocessing the measurements.\n", + "The circuit involves three $n$-qubit registers.\n", + "Registers 2 and 3 are each initialized to $\\ket\\psi$, and register 1 is initialized to the all $\\ket 0$ state.\n", + "We call register 1 the *group register* because we'll use it to encode elements of the group $G$.\n", + "For example if $n=5$ the group element 10101 of $G$ would be encoded as $\\ket{10101}$.\n", + "\n", + "After this register initialization, the StateHSP circuit involves three steps:\n", + "1. Apply a Hadamard to each qubit in the group register; this puts the group register in a uniform superposition of all group elements, which up to normalization we can write as $\\sum_{g\\in G} \\ket g$.\n", + "2. Apply a controlled SWAP operator, which acts on all 3 registers by mapping $\\ket{g}\\ket\\psi\\ket\\psi$ to $\\ket{g}\\text{SWAP}_g(\\ket\\psi\\ket\\psi)$.\n", + "Here $\\text{SWAP}_g$ performs swaps at the positions indicated by $g$; for example if $g=10101$ then qubits 0, 2 and 4 in the first copy of $\\ket\\psi$ will get swapped with the corresponding qubits in the second copy of $\\ket\\psi$.\n", + "3. Again apply a Hadamard to each qubit in the group register.\n", + "\n", + "Finally we measure the group register.\n", + "Here's the circuit diagram:\n", + "\n", + "[...picture...]\n", + "\n", + "We'll implement this in Pennylane, and then we'll show how the measurement results can be postprocessed to find the hidden subgroup $H$ that encodes the hidden cut!" ] }, { - "cell_type": "code", - "execution_count": 41, + "cell_type": "markdown", + "id": "1f33de6e", "metadata": {}, - "outputs": [], "source": [ - "bitstrings = ['0' * 5]\n", - "purities = [1.]\n", - "\n", - "for subsystem_idx in range(1, 2**n):\n", - " # convert integer index to list of bits\n", - " subsystem = [int(bit) for bit in format(subsystem_idx, f'0{n}b')]\n", - " \n", - " # compute purity and append\n", - " purity = get_purity(state, subsystem)\n", - " purities.append(purity)\n", - "\n", - " # convert bit list to bit string and append\n", - " bitstring = ''.join(str(bit) for bit in subsystem)\n", - " bitstrings.append(bitstring)" + "## Solving the hidden cut problem in Pennylane" ] }, { "cell_type": "markdown", + "id": "50bb242e", "metadata": {}, "source": [ - "Now we can plot the purities in a histogram" + "Let's implement this circuit in Pennylane!\n", + "We'll use a device with `shots=100`: this will run the circuit 100 times and record a 5-bit measurement for each run.\n", + "We'll store these measurements in an array `M`:" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 51, + "id": "a877887e", "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "The shape of M is (100, 5).\n", + "The first 3 rows of M are:\n", + "[[0 0 0 0 0]\n", + " [0 0 1 0 1]\n", + " [0 0 1 1 0]]\n" + ] } ], "source": [ - "plt.bar(bitstrings, purities)\n", - "plt.xticks(rotation=90)\n", - "plt.axhline(y=1.0, color='r', ls='--')\n", - "plt.xlabel('subsystem')\n", - "plt.ylabel('purity')\n", - "plt.title('Subsystem purities')\n", - "plt.show()" + "dev = qml.device('default.qubit', shots=100)\n", + "\n", + "@qml.qnode(dev)\n", + "def circuit():\n", + " # Initialize psi x psi in registers 2 and 3\n", + " qml.StatePrep(state, wires=range(n, 2*n))\n", + " qml.StatePrep(state, wires=range(2*n, 3*n))\n", + " \n", + " # Hadamards\n", + " for a in range(n):\n", + " qml.Hadamard(a)\n", + "\n", + " # Controlled swaps\n", + " for c in range(n):\n", + " a = c + n\n", + " b = c + 2*n\n", + " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", + "\n", + " # Hadamards\n", + " for a in range(n):\n", + " qml.Hadamard(a)\n", + "\n", + " # Measure\n", + " return qml.sample(wires=range(n))\n", + "\n", + "M = circuit()\n", + "\n", + "print(f'The shape of M is {M.shape}.')\n", + "print(f'The first 3 rows of M are:\\n{M[:3]}')" ] }, { "cell_type": "markdown", + "id": "a99d1cd7", "metadata": {}, "source": [ - "Notice the 4 subsystems that have purity equal to 1: \n", - "- the entire system 11111 and its empty complement 00000\n", - "- the subsystem 10010 and its complement 01101\n", - "\n", - "Remember that a purity of 1 means that the subsystem is pure.\n", - "This tells us that besides the entire state $\\ket{\\psi}$ and the trivial empty state, which are pure by definition,\n", - "the only other subsystems that are pure are $S=\\{0,3\\}$ (encoded as '10010') and $\\bar S=\\{1,2,4\\}$ (encoded as '01101').\n", - "So $\\ket{\\psi}$ is separable along the cut between $S$ and $\\bar S$, exactly as we expected." + "Now let's process the measurement results $M$ to determine the hidden subgroup $H$!\n", + "This postprocessing step is common to all hidden subgroup algorithms.\n", + "The key fact that connects the measurement results $M$ to the hidden subgroup $H$ is this: the elements of $H$ are the vectors that are orthogonal to all measurements (i.e. rows) in $M$.\n", + "Since we're working with the group of bitstrings, two bitstrings are orthogonal if their dot product mod 2 is equal to 0.\n", + "For example 10101 and 11100 are orthogonal since their dot product is $2\\equiv0\\mod 2$, while 10101 and 11111 are *not* orthogonal, since their dot product is $3\\equiv1\\mod 2$.\n", + "\n", + "So to get $H$ we just have to find the binary vectors $\\vec b$ orthogonal to every row of $M$.\n", + "Mathematically we write this as $M\\vec b = 0$, where all operations are assumed to be performed mod 2.\n", + "In linear algebra lingo we say that the solutions $\\vec b$ to this equation form the *nullspace* of $M$.\n", + "We can straightforwardly find the nullspace using basic linear algebra techniques.\n", + "\n", + "Instead of doing the algebra by hand though, here we'll use the `galois` python library, which can perform linear algebra mod 2.\n", + "To ensure that operations on $M$ are performed mod 2, we first convert it to a `galois.GF2` array.\n", + "The GF2 stands for [\"Galois field of order 2\"](https://en.wikipedia.org/wiki/Finite_field), which is a fancy way of saying that all operations are performed mod 2." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 52, + "id": "acc04c3c", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The shape of M is (100, 5).\n", + "The first 3 rows of M are:\n", + "[[0 0 0 0 0]\n", + " [0 0 1 0 1]\n", + " [0 0 1 1 0]]\n" + ] + } + ], "source": [ - "## The naive approach to hidden cuts" + "M = galois.GF2(M)\n", + "\n", + "print(f'The shape of M is {M.shape}.')\n", + "print(f'The first 3 rows of M are:\\n{M[:3]}')" ] }, { "cell_type": "markdown", + "id": "ad3011f6", "metadata": {}, "source": [ - "Remember our problem: given a state of many qubits, find the separable components.\n", - "\n", - "The above discussion suggests one way to solve the problem: \n", - "compute the purities of all subsystems and look for the subsystems with purity equal to 1.\n", - "The problem with this approach is that a system of $n$ qubits has $2^n$ subsystems, \n", - "so looking for pure subsystems by brute force search has an exponential complexity in $n$.\n", - "\n", - "We need a more efficient way to find the hidden cut." + "So `M` is the same array as before.\n", + "Let's check that addition is performed mod 2 by adding rows 1 and 2 of `M`:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 53, + "id": "56d7212a", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " r1 = [0 0 1 0 1]\n", + " r2 = [0 0 1 1 0]\n", + "r1 + r2 = [0 0 0 1 1]\n" + ] + } + ], "source": [ - "## Symmetries of the purity function" + "r1 = M[1]\n", + "r2 = M[2]\n", + "\n", + "print(f' r1 = {r1}')\n", + "print(f' r2 = {r2}')\n", + "print(f'r1 + r2 = {r1 + r2}')" ] }, { "cell_type": "markdown", + "id": "2163cd5a", "metadata": {}, "source": [ - "Let's look at the subsystem purity function (the historgram we plotted above) more closely.\n", - "Notice that some of the bars seem like they're the same height.\n", - "To visualize this, let's colour in the bars according to their height:" + "Looking at the middle column we see that $1+1=0$, so addition is mod 2 as desired!\n", + "\n", + "Now we can finally compute the nullspace of `M`, which will give us the hidden subgroup $H$.\n", + "We can do this easily now that `M` is a `galois.GF2` array just by calling `M.null_space()`.\n", + "In fact this method doesn't return all of the bitstrings in the nullspace, but instead saves space by only returning the generators of the nullspace." ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 54, + "id": "c433a9b6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "GF([[1, 1, 0, 0, 0],\n", + " [0, 0, 1, 1, 1]], order=2)" ] }, + "execution_count": 54, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "# colour map\n", - "cmap = plt.cm.tab10\n", - "purities = np.round(purities, 5)\n", - "unique_purities = set(purities)\n", - "colours = cmap(np.linspace(0, 1, len(unique_purities)))\n", - "purity_to_colour = dict(zip(unique_purities, colours))\n", - "bar_colours = [purity_to_colour[purity] for purity in purities]\n", - "\n", - "# plot\n", - "plt.bar(bitstrings, purities, color=bar_colours)\n", - "plt.xticks(rotation=90)\n", - "plt.axhline(y=1.0, color='r', ls='--')\n", - "plt.xlabel('subsystem')\n", - "plt.ylabel('purity')\n", - "plt.title('Subsystem purities')\n", - "plt.show()" + "M.null_space()" ] }, { "cell_type": "markdown", + "id": "5b95d571", "metadata": {}, "source": [ - "Notice that there are 8 sets of 4 bitstrings each with the same purity. \n", - "**Question**: How are bitstrings of the same purity related? \n", - "\n", - "Pause here for a bit, stare at the histogram, and try to answer the question yourself! \n", - "\n", - "Ready for the answer?\n", - "\n", - "**Answer**: Same purity bitstrings are related by bitstring addition of 01101 and 10010.\n", - "\n", - "For example, start with the first orange bar, 00000.\n", - "- Adding 01101 to 00000 gives 01101, the second orange bar. \n", - "- Adding 10010 to 00000 gives 10010, the third orange bar.\n", - "- Adding both 01101 and 10010 to 00000 gives 11111, the fourth orange bar.\n", - "\n", - "These four orange bars are the subsystems of purity 1 that we discussed earlier.\n", - "\n", - "As another example, start with the third violet bar, 10110.\n", - "- Adding 01101 (bitwise modulo 2) to 10110 gives 11011, the fourth violet bar.\n", - "- Adding 10010 to 10110 gives 00100, the first violet bar.\n", - "- Adding both 01101 and 10010 to 10110 gives 01001, the second violet bar.\n", - "\n", - "\n", - "In fact, this approach to getting bars of the same height always works.\n", - "You should try it by starting with a bar of another colour.\n", - "You'll find that adding 01101 and/or 10010 to this bar will always give the other 3 bars of the same colour!" + "Because the nullspace of $M$ equals $H$, we conclude that the generators of $H$ are 11000 and 00111.\n", + "If we didn't know that $\\ket\\psi$ could be factored as $\\ket\\psi=\\ket{\\psi_{01}}\\ket{\\psi_{234}}$, the generators would directly tell us the factors!\n", + "So we have solved the hidden cut problem for our state $\\ket\\psi$!" ] }, { "cell_type": "markdown", + "id": "040d4979", "metadata": {}, "source": [ - "What this observation tells us is that the purity function $P(s)$ has a symmetry: \n", - "For any bitstring $s$,\n", - "$$\n", - "P(s) = P(s + 10010) = P(s + 01101) = P(s + 11111)\n", - "$$\n", - "We can associate the set $H = \\{00000, 10010, 01101, 11111\\}$ to our symmetry;\n", - "these are the bitstrings that we can add to $s$ without changing its purity.\n", - "The set $H$ has three important properties:\n", - "1. It contains the unique \"identity\" bitstring 00000, for which $s + 00000 = s$ for all $s$\n", - "2. The set is closed under addition\n", - "3. Every element in $H$ has an inverse in $H$, such that the element plus its inverse give the identity. \n", - "(In fact every element is its own inverse.)\n", - "\n", - "These three properties turn $H$ into what is called a *group* in math.\n", - "A group is just a set closed under an associative \"addition\" operation (here bitstring addition), containing an identity and inverses for every element.\n", - "So what we discovered is that the purity function has a symmetry and that this symmetry is associated with a group.\n", - "Thinking of symmetries as groups is arguably the most successful guiding principle in quantum physics (if not all of physics), and we'll see that it's useful here as well." + "## The power of hidden symmetries" ] }, { "cell_type": "markdown", + "id": "b67f367b", "metadata": {}, "source": [ - "## Hidden cut problem as a hidden subgroup problem" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To see how symmetries can help us find separable components, take another look at the symmetry group $H$.\n", - "Notice that by adding the two bitstrings 10100 and 01011 in different linear combinations, we can generate any element of $H$. \n", - "We say that 10010 and 01101 are \"generators\" of $H$.\n", - "\n", - "**Question**: Is there anything special about the generators 10010 and 01101 of the symmetry group $H$?\n", - "\n", - "Pause and think about it!\n", - "\n", - "**Answer**: The generators directly give us the separable subsets $S$ and $\\bar S$ of the original 5-qubit state! \n", - "What I mean is that the first generator 10010 has 1s in positions 0 and 3, so this gives the subset $S=\\{0,3\\}, \n", - "and the second generator 01101 has 1s in positions 1, 2, and 4, so this gives the complementary subset $S=\\{1,2,4\\}$.\n", - "\n", - "In fact, this relationship between generators and separable components is not a coincidence:\n", - "for any multi-qubit state $\\ket\\psi$ the separable components are equal to the generators of $H$, the symmetry group of the purity function!\n", - "(Optional exercise for curious readers: prove this statement!)\n", - "\n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is a very important observation!\n", - "It means that to determine the separable components of $\\ket\\psi$ we just need to find $H$, the symmetry group of the purity function!\n", - "\n", - "\n", - "\n", - "\n", - "Just as the bitstrings $H = \\{00000, 10100, 01011, 11111\\}$ form group, the set $G$ of all $n$-bit strings also forms a group: \n", - "it's closed under addition, it contains the identity, and every element in $G$ has an inverse in $G$.\n", - "$G$ contains $2^n$ elements.\n", - "In fact, the group $H$ is a subset of the group $G$.\n", - "We say that $H$ is a *subgroup* of $G$.\n", - "Because the generators of $H$ encode the separable components of $\\ket\\psi$, we can find the hidden cut of $\\ket\\psi$ by finding the hidden subgroup $H$ of $G$.\n", - "This is an example of a *hidden subgroup problem* (HSP), an important class of problems that quantum computers can solve efficiently. \n", - "The most famous HSP is the problem of factoring large integers.\n", - "Like the hidden cut problem, it's not immediately obvious that factoring is related to finding a subgroup, but in fact it is.\n", - "We'll use the HSP algorithm to solve the hidden cut problem.\n", - "\n", - "In the general HSP we want to find the symmetry subgroup $H$ of a function $f$ over a group $G$. \n", - "When $G$ is the group of $n$-bit strings, the algorithm to solve the HSP is particularly simple.\n", - "The algorithm assumes that we have access to a quantum version of the function $f$, meaning a unitary $U_f$\n", - "that maps $\\ket g \\ket 0$ to $\\ket g \\ket{f(g)}$ for every element $g$ of the group $G$.\n", - "Here $\\ket g$ is an encoding of $g$ into an $n$-qubit register, and $\\ket{f(g)}$ is a second register that encodes $f(g)$ such that\n", - "$\\ket{f(g)}$ and $\\ket{f(g')}$ are equal if $f(g) = f(g')$ and otherwise orthogonal.\n", - "\n", - "The HSP algorithm works by obtaining measurements from a quantum circuit and then postprocessing the measurements.\n", - "The quantum circuit first applies Hadamards to the $\\ket 0$ state to create a uniform superposition $\\sum_g \\ket g$ in the group register, \n", - "then applies $U_f$ to create the state $\\sum_g \\ket g\\ket{f(g)}$, and finally again applies Hadamards to the first register.\n", - "The circuit looks like:\n", - "\n", - "[Picture of circuit]\n", - "\n", - "The key feature of this circuit is that measurments of the group register are guaranteed to be orthogonal to the hidden subgroup $H$.\n", - "For example if we run the circuit and get a measurement outcome $m=10101$, then we know that $a = 00011$ is not in $H$ because $a\\cdot m != 0 \\text{ mod }2$.\n", - "Repeatedly running the circuit and performing measurements tells us what bitstrings cannot be in $H$.\n", - "After $\\mathcal O(n)$ measurements, the bitstrings that are orthogonal to all measurements are very likely in $H$.\n", - "At this point we stop the algorithm and predict that $H$ is given by these bitstrings.\n", - "\n", - "Now let's apply this to solve the hidden cut problem for the state $\\ket \\psi$.\n", - "The general function $f(s)$ is now the subsystem purity function $P(s)$.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [], - "source": [ - "# Suppose we want to find the hidden symmetry subgroup of a function f(s) over n-bit strings s. we start with two n-qubit registers initialized in the all |0> states. \n", - "# the first step is to apply a Hadamard to each qubit in the first register to create a uniform superposition sum |s>.\n", - "# the second step assumes that we have access to a unitary U_f that maps |s>|0> to |s>|f(s)>, such that |f(s)> and |f(s')> are equal if f(s) = f(s') and orthogonal if f(s) != f(s').\n", - "# the final step is to again apply Hadamards to the first register, and measure this register.\n", - "# the circuit looks like:\n", - "\n", - "# The crucial feature of this circuit is that the measurement outcomes are guaranteed to be orthogonal to the hidden subgroup bitstrings (ie the bitstrings defining the symmetry of f(s)).\n", - "# for example if we get a measurement outcome ..., then a hidden subgroup element might be ... because ..., but ... is definitely not in the hidden subgroup, because ....\n", - "# Therefore by obtaining measurment outcomes and finding the bitstrings orthogonal to all measurments, we will identify the hidden symmetry of f.\n", - "\n", - "# Now let's apply this to solve the hidden cut problem for the state psi. Remember that here the function f(s) is pi(s), the purity of psi's subsystems.\n", - "# We immediately run into a problem however. Unlike in the basic HSP problem, we arent provided with a unitary mapping |s>|0> to |s>|pi(s)>.\n", - "# So what do we do? Let's create the unitary!\n", - "\n", - "# Recall the key property that the unitary is supposed to have: |f(s)> and |f(s')> should be equal if f(s) = f(s') and orthogonal if f(s) != f(s').\n", - "# Consider the controlled swap unitary, mapping |s>|psi>|psi> to |s>SWAP_s(|psi>|psi>), where s denotes the qubits to be swapped between the two copies of |psi>\n", - "\n", - "# Let's check if the controlled swap unitary has the desired properties.\n", - "# First, if pi(s) = pi(s') we want SWAP_s(|psi>|psi>) to equal SWAP_s(|psi>|psi>). \n", - "# Let's consider an example. We see from our plot of pi(s) that ... and ... have the same value of pi.\n", - "# Let's check the inner product of SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>):\n", - "\n", - "# Since the inner product is 1, the SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>) must be identical.\n", - "\n", - "# Now let's check whether pi(s) != pi(s') implies SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>)...\n", - "\n", - "# So it turns out that SWAP_s(|psi>|psi>) and SWAP_s'(|psi>|psi>) are not orthogonal and so the SWAP_s unitary does not satisfy the second requirement for the unitary in the HSP circuit.\n", - "\n", - "# Even though we don't expect it to work, let's nevertheless try running the HSP circuit with the SWAP_s unitary, and see what happens.\n", + "We solved the hidden cut problem—finding the factors of a multi-qubit quantum state—by thinking about it from the perspective of symmetries.\n", + "The key insight was to recognize that the question \"*What are the unentangled factors of the state?*\" can be rephrased as the question \"*What is the hidden symmetry of the state?*\".\n", + "With this rephrasing the hidden cut problem became a hidden subgroup problem, and we could solve it using a modification of the standard algorithm for HSPs that allows for finding symmetries of *states* rather than functions.\n", + "\n", + "In fact, many of the most well-known problems that benefit from access to a quantum computer are also instances of an HSP!\n", + "In some cases, like with the hidden cut problem, it isn't obvious by looking at it that the problem involves finding a hidden symmetry.\n", + "The most famous example of this is the problem of factoring large integers, a problem with fundamental importance in cryptography.\n", + "It's not at all obvious that this problem is related to finding the symmetry of a function, but with some clever algebra it can be phrased in this way, and hence solved efficiently using the HSP algorithm.\n", + "As a speculative side comment, it's interesting that problem of *factoring* states and the problem of *factoring* integers can both be phrased as HSPs!\n", + "Is there something about *factoring* problems that enables them to be expressed as HSPs?\n", + "Are there other important factoring problems that can also be recast as HSPs and solved on a quantum computer?\n", + "Or is this just a complete coincidence?\n", + "I invite you to think about this if you're interested - maybe you find a deep connection!\n", + "\n", + "Less speculatively, there definitely *is* one deep and generalizable lesson that we should take away from this hidden cut demo, and that is the *power of looking for hidden symmetries*.\n", + "This goes well beyond quantum computing.\n", + "In fact some of the most significant discoveries in physics are just recognitions of a hidden symmetry!\n", + "For example, recognizing the symmetries of fundamental particles led to the development of the standard model of particle physics, \n", + "recognizing the symmetry of systems in different inertial reference frames led to discovery of special relativity, \n", + "and recognizing the symmetry between freefalling and accelerating objects led to the discovery of general relativity.\n", + "Indeed, looking for hidden symmetries is a very powerful approach, both in quantum computing and beyond!\n", "\n", - "# ...10 samples\n", "\n", - "# Remember the final postprocessing step to solving an HSP via a quantum computer: we have to determine the bitstrings orthogonal to the measurement outcomes, where two bitstrings s and t are orthogonal if s.t = 0 modulo 2. This is a basic linear algebra problem that amounts to finding the nullspace of the matrix of measurement outcomes over the finite field GF(2).\n", - "\n", - "# But by being clever we can avoid doing any linear algebra.\n", - "\n", - "# Look at the allowed measurement outcomes very carefully. Do you notice anything in common between them?\n", - "\n", - "# The answer: they are exactly those bitstrings that have an even number of 1s in positions ... *and* an even number of 1s in positions ...\n", - "\n", - "# This means that the only bitstrings orthogonal to the allowed measurement outcomes are the all 0 bitstring, the all 1 bitstring, the bitstring ... and the bitstring ...\n", - "\n", - "# This is exactly the hidden subgroup generated by ... and ..., where the generators encode the separable components ... and ... of the original state |psi>.\n", - "\n", - "# Therefore the HSP circuit with the SWAP_s unitary finds the separable components!\n", - "\n", - "# Let's check it with another state to make sure we didn't just get lucky.\n", - "\n", - "# This time let's consider a 4 qubit state ...\n", - "\n", - "\n", - "# again it works!\n", - "\n", - "# So we have solved the hidden cut problem by rephrasing it as an HSP and using the unitary SWAP_s.\n", - "\n", - "# but why does this work? Recall that in the standard quantum circuit for HSP we need |f(s)> and |f(s')> should be equal if f(s) = f(s') and orthogonal if f(s) != f(s'). However in our case f(s) is the purity function pi(s), and we set |pi(s)> = SWAP_s(|psi>|psi>). We saw above that this satisfies the equality requirement, but not the orthogonality requirement. Namely pi(s) != pi(s') doesn't generally imply that |pi(s)> and |pi(s')> are orthogonal.\n", - "\n", - "# To understand why our circuit worked despite this non-orthogonality, let's think about how we could have defined |pi(s)> differently so that the orthogonality requirement *was* satisfied.\n", - "# This is actually quite straightforward: just define |pi(s)> = [SWAP_s(|psi>|psi>)]^t for some large t. \n", - "# Then as long as the inner product between SWAP_s(|psi>|psi>) and SWAP_s(|psi>|psi>) is not 1 (ie they aren't identical), the inner product between |pi(s)> and |pi(s')> will be effectively 0 (exponentially approach 0 as t increases).\n", - "\n", - "# So if instead of using only 1 pair |psi>|psi> in our quantum circuit we used t pairs, for large enough t this would've exactly functioned like a standard issue HSP circuit.\n", - "\n", - "# Unfortunately the circuit with t pairs of |psi>|psi> requires (1 + 2t) * n qubits (the 1 is for the control register and the 2t for the 2t pairs of |psi>|psi>), so simulating this with n=4 is not feasible for t > 2.\n", - "\n", - "# With that in mind let's look consider the circuit with t=2 and compare with what we got above with t=1. Hopefully we'll see something interesting that we can extrapolate to t -> inf.\n", - "\n", - "# ...\n", - "\n", - "# plot probs histograms\n", - "\n", - "# we notice that the same measurement outcomes are allowed, and only their probabilities differ.\n", - "\n", - "# in particular the distribution is more skewed towards outcomes with fewer 1s for t=1, and more uniform for t=2\n", - "\n", - "# we can conjecture that this trend continues for larger t: the allowed outcomes remain the same as in the t=1 case, but the distribution becomes more and more uniform.\n", - "\n", - "# in fact this it can be proven analytically that this conjecture is correct, and if we had a powerful enough simulator (or a quantum computer), we'd be able to verify this.\n", - "\n", - "# So now we can understand why our hidden cut circuit with only 1 pair of |psi>s worked, when naively we didn't expect it to. It is because the allowed measurement outcomes from the output of this t=1 circuit are exactly the allowed measurmenet outcomes from the t-> infty circuit. Because the outcome of the final postprocessing step of the quantum HSP algorithm only depends on the allowed measurement outcomes and not on their probabilities, the t=1 algorithm is able to get the same outcome as the large t algorithm. \n", - "\n", - "# So should we use small t or large t?\n", - "\n", - "# do sample efficiency experiment. Expect result to be: use large t if you can because it's more sample efficient. \n", "\n" ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def hidden_cut_circuit(state, n_copies=1):\n", - "\n", - " n = int(np.log2(len(state)))\n", - " n_qubits = (2 * n_copies + 1) * n\n", - " dev = qml.device('lightning.qubit', wires=n_qubits)\n", - "\n", - " @qml.qnode(dev)\n", - " def _circuit():\n", - " # Create copies of state\n", - " for pair in range(n_copies):\n", - " for copy in range(2):\n", - " offset = n + 2 * n * pair + n * copy\n", - " qml.StatePrep(state, wires=range(offset, offset + n))\n", - " \n", - " # Hadamard transform\n", - " for wire in range(n):\n", - " qml.Hadamard(wires=wire)\n", - "\n", - " # Controlled swaps\n", - " for c in range(n):\n", - " for pair in range(n_copies):\n", - " a = c + n + 2*n*pair\n", - " b = c + n + 2*n*pair + n\n", - " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", - "\n", - " # Hadamard transform\n", - " for wire in range(0, n):\n", - " qml.Hadamard(wires=wire)\n", - "\n", - " # Return probs of first register\n", - " return qml.probs(wires=range(n))\n", - "\n", - " return _circuit()\n", - " \n", - "probs = hidden_cut_circuit(state, n_copies=1)\n", - "bitstrings = [bin(x)[2:].zfill(n) for x in range(2**n)]\n", - "\n", - "# plt.bar(bitstrings, probs)\n", - "# plt.xticks(rotation=90)\n", - "# plt.show()\n", - "\n", - "# np.random.choice(len(probs), size=100, p=probs)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "ename": "DeviceError", - "evalue": "Measurement state(wires=[]) not accepted with finite shots on lightning.qubit", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mDeviceError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[46], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# return qml.state()\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mprobs()\n\u001b[0;32m----> 9\u001b[0m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msnapshots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcircuit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:882\u001b[0m, in \u001b[0;36mQNode.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 879\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01m_capture_qnode\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m capture_qnode \u001b[38;5;66;03m# pylint: disable=import-outside-toplevel\u001b[39;00m\n\u001b[1;32m 881\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m capture_qnode(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 882\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_impl_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/qnode.py:855\u001b[0m, in \u001b[0;36mQNode._impl_call\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 852\u001b[0m \u001b[38;5;66;03m# Calculate the classical jacobians if necessary\u001b[39;00m\n\u001b[1;32m 853\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_transform_program\u001b[38;5;241m.\u001b[39mset_classical_component(\u001b[38;5;28mself\u001b[39m, args, kwargs)\n\u001b[0;32m--> 855\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mqml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 856\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mtape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 857\u001b[0m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 858\u001b[0m \u001b[43m \u001b[49m\u001b[43mdiff_method\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdiff_method\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 859\u001b[0m \u001b[43m \u001b[49m\u001b[43minterface\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minterface\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 860\u001b[0m \u001b[43m \u001b[49m\u001b[43mtransform_program\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_transform_program\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 861\u001b[0m \u001b[43m \u001b[49m\u001b[43mgradient_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgradient_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 862\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 863\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 864\u001b[0m res \u001b[38;5;241m=\u001b[39m res[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 866\u001b[0m \u001b[38;5;66;03m# convert result to the interface in case the qfunc has no parameters\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/execution.py:244\u001b[0m, in \u001b[0;36mexecute\u001b[0;34m(tapes, device, diff_method, interface, transform_program, grad_on_execution, cache, cachesize, max_diff, device_vjp, postselect_mode, mcm_method, gradient_kwargs, mcm_config, config, inner_transform)\u001b[0m\n\u001b[1;32m 241\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m transform_program\u001b[38;5;241m.\u001b[39mis_informative:\n\u001b[1;32m 242\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m post_processing(tapes)\n\u001b[0;32m--> 244\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minner_transform\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 245\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m post_processing(results)\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/run.py:286\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(tapes, device, config, inner_transform_program)\u001b[0m\n\u001b[1;32m 282\u001b[0m no_interface_boundary_required \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 283\u001b[0m config\u001b[38;5;241m.\u001b[39minterface \u001b[38;5;241m==\u001b[39m Interface\u001b[38;5;241m.\u001b[39mNUMPY \u001b[38;5;129;01mor\u001b[39;00m config\u001b[38;5;241m.\u001b[39mgradient_method \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbackprop\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 284\u001b[0m )\n\u001b[1;32m 285\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m no_interface_boundary_required:\n\u001b[0;32m--> 286\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43minner_execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m results\n\u001b[1;32m 289\u001b[0m \u001b[38;5;66;03m# TODO: Prune once support for tf-autograph is dropped\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/workflow/run.py:248\u001b[0m, in \u001b[0;36m_make_inner_execute..inner_execute\u001b[0;34m(tapes)\u001b[0m\n\u001b[1;32m 239\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner_execute\u001b[39m(tapes: QuantumScriptBatch) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ResultBatch:\n\u001b[1;32m 240\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Execution that occurs within a ML framework boundary.\u001b[39;00m\n\u001b[1;32m 241\u001b[0m \n\u001b[1;32m 242\u001b[0m \u001b[38;5;124;03m Closure Variables:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 245\u001b[0m \u001b[38;5;124;03m device (qml.devices.Device): a Pennylane device\u001b[39;00m\n\u001b[1;32m 246\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 248\u001b[0m transformed_tapes, transform_post_processing \u001b[38;5;241m=\u001b[39m \u001b[43minner_transform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtapes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m transformed_tapes:\n\u001b[1;32m 251\u001b[0m results \u001b[38;5;241m=\u001b[39m device\u001b[38;5;241m.\u001b[39mexecute(transformed_tapes, execution_config\u001b[38;5;241m=\u001b[39mexecution_config)\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/transforms/core/transform_program.py:643\u001b[0m, in \u001b[0;36mTransformProgram.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 641\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mtype\u001b[39m(args[\u001b[38;5;241m0\u001b[39m])\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mJaxpr\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__call_jaxpr(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__call_tapes\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/transforms/core/transform_program.py:580\u001b[0m, in \u001b[0;36mTransformProgram.__call_tapes\u001b[0;34m(self, tapes)\u001b[0m\n\u001b[1;32m 578\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m argnums \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 579\u001b[0m tape\u001b[38;5;241m.\u001b[39mtrainable_params \u001b[38;5;241m=\u001b[39m argnums[j]\n\u001b[0;32m--> 580\u001b[0m new_tapes, fn \u001b[38;5;241m=\u001b[39m \u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 581\u001b[0m execution_tapes\u001b[38;5;241m.\u001b[39mextend(new_tapes)\n\u001b[1;32m 583\u001b[0m fns\u001b[38;5;241m.\u001b[39mappend(fn)\n", - "File \u001b[0;32m~/miniconda3/envs/qml/lib/python3.11/site-packages/pennylane/devices/preprocess.py:526\u001b[0m, in \u001b[0;36mvalidate_measurements\u001b[0;34m(tape, analytic_measurements, sample_measurements, name)\u001b[0m\n\u001b[1;32m 524\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n\u001b[1;32m 525\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m sample_measurements(m):\n\u001b[0;32m--> 526\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m qml\u001b[38;5;241m.\u001b[39mDeviceError(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMeasurement \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mm\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not accepted with finite shots on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 528\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 529\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m m \u001b[38;5;129;01min\u001b[39;00m chain(snapshot_measurements, tape\u001b[38;5;241m.\u001b[39mmeasurements):\n", - "\u001b[0;31mDeviceError\u001b[0m: Measurement state(wires=[]) not accepted with finite shots on lightning.qubit" - ] - } - ], - "source": [ - "dev = qml.device('lightning.qubit', shots=10, wires=[0])\n", - "@qml.qnode(dev)\n", - "def circuit():\n", - " qml.Hadamard(wires=0)\n", - " qml.Snapshot('tag', qml.state())\n", - " # return qml.state()\n", - " return qml.probs()\n", - "\n", - "qml.snapshots(circuit)()" - ] } ], "metadata": { @@ -700,5 +522,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } From ce6b36bad31c7f3dc8eea7132237ce19788a9af1 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Tue, 10 Jun 2025 14:52:09 -0400 Subject: [PATCH 13/20] Rename file --- demonstrations/{hidden_cut.ipynb => tutorial_hidden_cut.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename demonstrations/{hidden_cut.ipynb => tutorial_hidden_cut.ipynb} (100%) diff --git a/demonstrations/hidden_cut.ipynb b/demonstrations/tutorial_hidden_cut.ipynb similarity index 100% rename from demonstrations/hidden_cut.ipynb rename to demonstrations/tutorial_hidden_cut.ipynb From f9846a0e8bda3470272443697967434ffc6b2c02 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Tue, 10 Jun 2025 15:05:18 -0400 Subject: [PATCH 14/20] Convert to .py --- _static/authors/petar_simidzija.png | Bin 0 -> 342859 bytes _static/authors/petar_simidzija.txt | 4 + demonstrations/tutorial_hidden_cut.py | 374 ++++++++++++++++++++++++++ 3 files changed, 378 insertions(+) create mode 100644 _static/authors/petar_simidzija.png create mode 100644 _static/authors/petar_simidzija.txt create mode 100644 demonstrations/tutorial_hidden_cut.py diff --git a/_static/authors/petar_simidzija.png b/_static/authors/petar_simidzija.png new file mode 100644 index 0000000000000000000000000000000000000000..cbc7403183ee1c78266c0ca129ea48692534efc6 GIT binary patch literal 342859 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Π|7ROg4|IC}@bGx){_ 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

PQ;U!J2 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 literal 0 HcmV?d00001 diff --git a/_static/authors/petar_simidzija.txt b/_static/authors/petar_simidzija.txt new file mode 100644 index 0000000000..c842489f3e --- /dev/null +++ b/_static/authors/petar_simidzija.txt @@ -0,0 +1,4 @@ +.. bio:: Petar Simidzija + :photo: ../_static/authors/headshot.png + + Used to think about black holes and quantum gravity, now thinks about quantum computers and machine learning. \ No newline at end of file diff --git a/demonstrations/tutorial_hidden_cut.py b/demonstrations/tutorial_hidden_cut.py new file mode 100644 index 0000000000..18577cfb3c --- /dev/null +++ b/demonstrations/tutorial_hidden_cut.py @@ -0,0 +1,374 @@ +r""" +The hidden cut problem for locating unentanglement +================================================== +""" + +###################################################################### +# One of the most provocative and counterintuitive features of quantum physics is *entanglement*, a +# form of correlation that can exist between quantum systems. To illustrate the striking nature of +# entanglement, imagine two entangled qubits, with the first one located at Xanadu’s headquarters in +# Toronto, and the second located in the +# `JADES-GS-z13-0 `__ galaxy, the furthest galaxy ever +# measured. The proper cosmological distance between these qubits is about 33 billion light-years. +# Nevertheless, because they are entangled, the measurement outcome of the qubit in Toronto will +# necessarily be correlated with the measurement of the qubit in JADES-GS-z13-0! How this is possible +# when it takes light itself 33 billion years to travel between the qubits is one of the most +# philosophically loaded questions at the heart of quantum foundations. +# +# Despite entanglement being so philosophically provocative, it’s somewhat surprising that in fact it +# is ubiquitous: given a random state of a two-component quantum system, it’s almost certain that the +# two components will be entangled. For this reason, it’s sometimes more interesting when a state is +# *not* entangled rather than when it is! For example, when `building a quantum computer at +# Xanadu `__, we spend a ton of effort to ensure that our qubits are +# as *unentangled* as possible with their environment! +# +# In this demo we’ll investigate *unentanglement* more closely. More specifically we’ll consider a +# problem related to unentanglement, called the *hidden cut problem*. In this problem we assume that +# we’re given a state consisting of many components. As we discussed, it’ll generally be the case that +# most of these components are entangled with one another. But in the hidden cut problem we are +# guaranteed that it’s possible to split the components up into two groups, so that between the two +# groups there is *no* entanglement. The problem asks us to find this “hidden cut” that splits the +# state up into two *unentangled* pieces. +# +# Let’s define the hidden cut problem a bit more precisely. First we need to define *unentanglement*. +# We say that a quantum state :math:`\ket\psi` describing a system with two parts, :math:`A` and +# :math:`B`, is *unentangled*, if it can be written as a tensor product +# +# .. math:: +# +# +# \ket{\psi} = \ket{\psi_A}\otimes \ket{\psi_B} +# +# , where :math:`\ket{\psi_A}` is a state of system :math:`A` and :math:`\ket{\psi_B}` is a state of +# system :math:`B`. We also use the term *separable* or *factorizable* to describe an unentagled +# state. We’ll usually not bother writing the tensor product sign and just write +# :math:`\ket{\psi} = \ket{\psi_A}\ket{\psi_B}`. And if :math:`\ket{\psi}` isn’t unentangled we say +# it’s *entangled*. +# +# Now let’s suppose :math:`\ket\psi` is a state of :math:`n`-qubits. We’re told it’s possible to split +# the qubits into two unentangled subsets, :math:`S` and :math:`\bar S`, +# +# .. math:: +# +# +# \ket{\psi} = \ket{\psi_S}\ket{\psi_{\bar S}}, +# +# but we aren’t told what :math:`S` and :math:`\bar S` are. The hidden cut problem asks us, given +# access to :math:`\ket\psi`, to determine :math:`S` and :math:`\bar S`. Following …, in this demo +# we’ll develop a quantum algorithm that solves this problem! +# + +###################################################################### +# Creating an unentangled state +# ----------------------------- +# + +import galois +import matplotlib.pyplot as plt +import numpy as np +import pennylane as qml +from scipy.stats import unitary_group + +# set random seed +np.random.seed(123) + +###################################################################### +# Before we can solve the hidden cut problem, we first need a state :math:`\ket\psi` to solve it on! +# First we define a function ``random_state()`` that creates a random state with a specified number of +# qubits. We do this by creating a :math:`2^n` by :math:`2^n` random unitary and taking the first row. +# Because all the rows (and columns) in a unitary matrix have norm equal to 1, this defines a valid +# quantum state. +# + +def random_state(n_qubits): + dim = 2**n_qubits + return unitary_group.rvs(dim)[0] + +###################################################################### +# However we can’t just use this function to construct our state :math:`\ket\psi`, because the random +# state created by the function will almost certainly *not* be unentagled. So we’ll define a function +# ``separable_state()`` that takes as input a list of qubit partitions, creates a random state for +# each partition, and tensors them together into a separable state. +# + +def separable_state(partitions): + # Number of qubits + n_qubits = sum(len(part) for part in partitions) + + # Sort partitions + partitions = [sorted(part) for part in partitions] + + # Create random state for each partition + partition_states = [(part, random_state(len(part))) for part in partitions] + + # Initialize full state + full_state = np.zeros(2**n_qubits, dtype=complex) + + # Fill in amplitudes + for idx in range(2**n_qubits): + # Convert idx to binary string + bits = format(idx, f'0{n_qubits}b') + + # Calculate amplitude as product of partition amplitudes + amplitude = 1.0 + for part, state in partition_states: + # Extract partition bits, convert to decimal, update amplitude + part_bits = ''.join(bits[q] for q in part) + part_idx = int(part_bits, 2) + amplitude *= state[part_idx] + + full_state[idx] = amplitude + + return full_state + +###################################################################### +# We’ll use this to create a 5-qubit state :math:`\ket\psi` in which qubits :math:`S=\{0,1\}` are +# unentangled with qubits :math:`\bar S=\{2,3,4\}`. +# + +partitions = [[0,1], [2,3,4]] +state = separable_state(partitions) +n = int(np.log2(len(state))) +print(f'Created {n} qubit state with qubits {partitions[0]} unentangled from {partitions[1]}.') + +###################################################################### +# Now imagine we’re given :math:`\ket \psi` but aren’t told that qubits 0,1 are unentangled from +# qubits 2,3,4. How could we figure this out? This is the hidden cut problem: given a many-qubit +# quantum state, figure out which qubits are unentangled with which other qubits. Now we’ll develop a +# quantum algorithm that solves this problem, and then we’ll implement it in Pennylane and see that it +# works! +# + +###################################################################### +# Hidden cut problem as a hidden subgroup problem +# ----------------------------------------------- +# + +###################################################################### +# The key to solving the hidden cut problem is to recast it as a *hidden symmetry problem*, or in more +# mathematical language a *hidden subgroup problem* (HSP). Then we can use a famous quantum algorithm +# for solving HSPs to solve the hidden cut problem. The traditional HSP algorithm is useful for +# finding symmetries of functions :math:`f(x)`, i.e. figuring out for what values of :math:`a` we have +# :math:`f(x+a) = f(x)` for all :math:`x`. However we’re interested in a *state* :math:`\ket\psi` and +# not a *function* :math:`f(x)`, so we’ll instead use a modified version of the HSP algorithm, called +# StateHSP, which finds *symmetries of states*. +# +# We’ll explain the StateHSP algorithm below, but first let’s see how we can recast the hidden cut +# problem as one of finding a hidden symmetry of a state. To see this, remember our example state +# :math:`\ket\psi=\ket{\psi_{01}}\ket{\psi_{234}}`. Now consider two copies :math:`\ket\psi\ket\psi` +# of :math:`\ket\psi`. We can visualize this as +# +# […picture…] +# +# The top row corresponds to the first copy of :math:`\ket\psi`, and the bottom row to the second +# copy. In each row, qubits 0 and 1 are disconnected from qubits 2, 3, and 4. This schematically +# indicates the fact that in each :math:`\ket\psi` qubits 0,1 are unentangled from qubits 2,3,4. +# +# Now consider what happens when we swap some qubits in the top row with the corresponding qubits in +# the bottom row. We can denote which pairs of qubits we’re swapping with a 5-bit string. For example, +# the bitstring 10101 corresponds to swapping the qubits in positions 0, 2, and 4 in the top row with +# qubits 0, 2, and 4 in the bottom row. Because there are :math:`2^5=32` 5-bit strings, there are 32 +# possible swap operations we can perform. Interestingly, the set of all 32 5-bit strings forms a +# mathematical *group* under bitwise addition. +# +# BOX: Group (take from Maria’s demo) +# +# We’ll call the group of 5-bit strings :math:`G`. We can now ask: which elements of :math:`G` +# correspond to swap operations that leave the state :math:`\ket\psi\ket\psi` invariant? These +# operations are the symmetries of :math:`\ket\psi\ket\psi` and the corresponding bitstrings form a +# subgroup :math:`H` of :math:`G`. For example the identity element 00000 corresponds to performing no +# swaps at all. This is clearly a symmetry, so 00000 is in :math:`H`. On the other hand 11111 swaps +# *all* the qubits in the top row with the corresponding qubits in the bottom row, so in effect it +# just swaps the entire first copy of :math:`\ket\psi` with the entire second copy of +# :math:`\ket\psi`. This is clearly also a symmetry, so 11111 is also in :math:`H`. Are there any +# other elements in :math:`H`? Stop and think about it! +# +# In fact, there are two more elements in :math:`H`: 11000 and 00111. 11000 corresponds to swapping +# the :math:`\ket{\psi_{01}}` component of the first copy of :math:`\ket\psi` with the same component +# of the second copy of :math:`\ket\psi`, and 00111 corresponds to swapping the +# :math:`\ket{\psi_{234}}` components between the two copies. Because in each copy of :math:`\ket\psi` +# the :math:`\ket{\psi_{01}}` and :math:`\ket{\psi_{234}}` components are completely unentangled, +# after either of these swaps the full state remains the same, namely :math:`\ket\psi\ket\psi`. So the +# symmetry subgroup is :math:`H = {00000, 11111, 11000, 00111}`. We’ll call this a *hidden* symmetry +# subgroup because it wasn’t given to us - we had to find it! +# +# Now, a shorthand way to write any group is to specify a set of *generators*, group elements that can +# be added together to generate any other element of the group. For :math:`H` the generators are 11000 +# and 00111: we can add either generator to itself to get the identity 00000, and we can add the +# generators to each other to get 11111. Here’s the important point: notice that the generators of +# :math:`H` *directly* tell us the unentangled components of +# :math:`\ket\psi=\ket{\psi_{01}}\ket{\psi_{234}}`! The first generator 11000 has 1s in bits 0 and 1: +# this corresponds to the first unentangled component :math:`\ket{\psi_{01}}`. And the second +# generator 00111 has 1s in bits 2, 3, 4: this corresponds to the second unentangled component +# :math:`\ket{\psi_{234}}`. So finding the hidden subgroup :math:`H` gives us the unentangled +# components - it solves the hidden cut problem! +# +# So now that we recast the hidden cut problem as a problem of finding a hidden subgroup :math:`H`, +# lets see how the StateHSP algorithm can be used to find :math:`H`. The general algorithm works for +# any abelian group :math:`G`, but here we’ll just focus on the case where :math:`G` is the group of +# :math:`n`-bit strings, since this is the case that’s relevant to solving the hidden cut problem. +# +# The algorithm involves running a quantum circuit, taking measurements, and postprocessing the +# measurements. The circuit involves three :math:`n`-qubit registers. Registers 2 and 3 are each +# initialized to :math:`\ket\psi`, and register 1 is initialized to the all :math:`\ket 0` state. We +# call register 1 the *group register* because we’ll use it to encode elements of the group :math:`G`. +# For example if :math:`n=5` the group element 10101 of :math:`G` would be encoded as +# :math:`\ket{10101}`. +# +# After this register initialization, the StateHSP circuit involves three steps: 1. Apply a Hadamard +# to each qubit in the group register; this puts the group register in a uniform superposition of all +# group elements, which up to normalization we can write as :math:`\sum_{g\in G} \ket g`. 2. Apply a +# controlled SWAP operator, which acts on all 3 registers by mapping :math:`\ket{g}\ket\psi\ket\psi` +# to :math:`\ket{g}\text{SWAP}_g(\ket\psi\ket\psi)`. Here :math:`\text{SWAP}_g` performs swaps at the +# positions indicated by :math:`g`; for example if :math:`g=10101` then qubits 0, 2 and 4 in the first +# copy of :math:`\ket\psi` will get swapped with the corresponding qubits in the second copy of +# :math:`\ket\psi`. 3. Again apply a Hadamard to each qubit in the group register. +# +# Finally we measure the group register. Here’s the circuit diagram: +# +# […picture…] +# +# We’ll implement this in Pennylane, and then we’ll show how the measurement results can be +# postprocessed to find the hidden subgroup :math:`H` that encodes the hidden cut! +# + +###################################################################### +# Solving the hidden cut problem in Pennylane +# ------------------------------------------- +# + +###################################################################### +# Let’s implement this circuit in Pennylane! We’ll use a device with ``shots=100``: this will run the +# circuit 100 times and record a 5-bit measurement for each run. We’ll store these measurements in an +# array ``M``: +# + +dev = qml.device('default.qubit', shots=100) + +@qml.qnode(dev) +def circuit(): + # Initialize psi x psi in registers 2 and 3 + qml.StatePrep(state, wires=range(n, 2*n)) + qml.StatePrep(state, wires=range(2*n, 3*n)) + + # Hadamards + for a in range(n): + qml.Hadamard(a) + + # Controlled swaps + for c in range(n): + a = c + n + b = c + 2*n + qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b)) + + # Hadamards + for a in range(n): + qml.Hadamard(a) + + # Measure + return qml.sample(wires=range(n)) + +M = circuit() + +print(f'The shape of M is {M.shape}.') +print(f'The first 3 rows of M are:\n{M[:3]}') + +###################################################################### +# Now let’s process the measurement results :math:`M` to determine the hidden subgroup :math:`H`! This +# postprocessing step is common to all hidden subgroup algorithms. The key fact that connects the +# measurement results :math:`M` to the hidden subgroup :math:`H` is this: the elements of :math:`H` +# are the vectors that are orthogonal to all measurements (i.e. rows) in :math:`M`. Since we’re +# working with the group of bitstrings, two bitstrings are orthogonal if their dot product mod 2 is +# equal to 0. For example 10101 and 11100 are orthogonal since their dot product is +# :math:`2\equiv0\mod 2`, while 10101 and 11111 are *not* orthogonal, since their dot product is +# :math:`3\equiv1\mod 2`. +# +# So to get :math:`H` we just have to find the binary vectors :math:`\vec b` orthogonal to every row +# of :math:`M`. Mathematically we write this as :math:`M\vec b = 0`, where all operations are assumed +# to be performed mod 2. In linear algebra lingo we say that the solutions :math:`\vec b` to this +# equation form the *nullspace* of :math:`M`. We can straightforwardly find the nullspace using basic +# linear algebra techniques. +# +# Instead of doing the algebra by hand though, here we’ll use the ``galois`` python library, which can +# perform linear algebra mod 2. To ensure that operations on :math:`M` are performed mod 2, we first +# convert it to a ``galois.GF2`` array. The GF2 stands for `“Galois field of order +# 2” `__, which is a fancy way of saying that all +# operations are performed mod 2. +# + +M = galois.GF2(M) + +print(f'The shape of M is {M.shape}.') +print(f'The first 3 rows of M are:\n{M[:3]}') + +###################################################################### +# So ``M`` is the same array as before. Let’s check that addition is performed mod 2 by adding rows 1 +# and 2 of ``M``: +# + +r1 = M[1] +r2 = M[2] + +print(f' r1 = {r1}') +print(f' r2 = {r2}') +print(f'r1 + r2 = {r1 + r2}') + +###################################################################### +# Looking at the middle column we see that :math:`1+1=0`, so addition is mod 2 as desired! +# +# Now we can finally compute the nullspace of ``M``, which will give us the hidden subgroup :math:`H`. +# We can do this easily now that ``M`` is a ``galois.GF2`` array just by calling ``M.null_space()``. +# In fact this method doesn’t return all of the bitstrings in the nullspace, but instead saves space +# by only returning the generators of the nullspace. +# + +M.null_space() + +###################################################################### +# Because the nullspace of :math:`M` equals :math:`H`, we conclude that the generators of :math:`H` +# are 11000 and 00111. If we didn’t know that :math:`\ket\psi` could be factored as +# :math:`\ket\psi=\ket{\psi_{01}}\ket{\psi_{234}}`, the generators would directly tell us the factors! +# So we have solved the hidden cut problem for our state :math:`\ket\psi`! +# + +###################################################################### +# The power of hidden symmetries +# ------------------------------ +# + +###################################################################### +# We solved the hidden cut problem—finding the factors of a multi-qubit quantum state—by thinking +# about it from the perspective of symmetries. The key insight was to recognize that the question +# “*What are the unentangled factors of the state?*” can be rephrased as the question “*What is the +# hidden symmetry of the state?*”. With this rephrasing the hidden cut problem became a hidden +# subgroup problem, and we could solve it using a modification of the standard algorithm for HSPs that +# allows for finding symmetries of *states* rather than functions. +# +# In fact, many of the most well-known problems that benefit from access to a quantum computer are +# also instances of an HSP! In some cases, like with the hidden cut problem, it isn’t obvious by +# looking at it that the problem involves finding a hidden symmetry. The most famous example of this +# is the problem of factoring large integers, a problem with fundamental importance in cryptography. +# It’s not at all obvious that this problem is related to finding the symmetry of a function, but with +# some clever algebra it can be phrased in this way, and hence solved efficiently using the HSP +# algorithm. As a speculative side comment, it’s interesting that problem of *factoring* states and +# the problem of *factoring* integers can both be phrased as HSPs! Is there something about +# *factoring* problems that enables them to be expressed as HSPs? Are there other important factoring +# problems that can also be recast as HSPs and solved on a quantum computer? Or is this just a +# complete coincidence? I invite you to think about this if you’re interested - maybe you find a deep +# connection! +# +# Less speculatively, there definitely *is* one deep and generalizable lesson that we should take away +# from this hidden cut demo, and that is the *power of looking for hidden symmetries*. This goes well +# beyond quantum computing. In fact some of the most significant discoveries in physics are just +# recognitions of a hidden symmetry! For example, recognizing the symmetries of fundamental particles +# led to the development of the standard model of particle physics, recognizing the symmetry of +# systems in different inertial reference frames led to discovery of special relativity, and +# recognizing the symmetry between freefalling and accelerating objects led to the discovery of +# general relativity. Indeed, looking for hidden symmetries is a very powerful approach, both in +# quantum computing and beyond! +# + +###################################################################### +# About the author +# ---------------- +# # .. include:: ../_static/authors/petar_simidzija.txt From 1e260ce94cb2c1480a22e14dc6420c09bed448f7 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Tue, 10 Jun 2025 15:23:33 -0400 Subject: [PATCH 15/20] Add arxiv link --- demonstrations/tutorial_hidden_cut.ipynb | 526 ----------------------- demonstrations/tutorial_hidden_cut.py | 20 +- 2 files changed, 14 insertions(+), 532 deletions(-) delete mode 100644 demonstrations/tutorial_hidden_cut.ipynb diff --git a/demonstrations/tutorial_hidden_cut.ipynb b/demonstrations/tutorial_hidden_cut.ipynb deleted file mode 100644 index 2359e7912d..0000000000 --- a/demonstrations/tutorial_hidden_cut.ipynb +++ /dev/null @@ -1,526 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "91a53a55", - "metadata": {}, - "source": [ - "# The hidden cut problem for locating unentanglement" - ] - }, - { - "cell_type": "markdown", - "id": "4345b999", - "metadata": {}, - "source": [ - "One of the most provocative and counterintuitive features of quantum physics is *entanglement*, a form of correlation that can exist between quantum systems.\n", - "To illustrate the striking nature of entanglement, imagine two entangled qubits, with the first one located at Xanadu's headquarters in Toronto, and the second located in the [JADES-GS-z13-0](https://en.wikipedia.org/wiki/JADES-GS-z13-0) galaxy, the furthest galaxy ever measured.\n", - "The proper cosmological distance between these qubits is about 33 billion light-years.\n", - "Nevertheless, because they are entangled, the measurement outcome of the qubit in Toronto will necessarily be correlated with the measurement of the qubit in JADES-GS-z13-0!\n", - "How this is possible when it takes light itself 33 billion years to travel between the qubits is one of the most philosophically loaded questions at the heart of quantum foundations.\n", - "\n", - "Despite entanglement being so philosophically provocative, it's somewhat surprising that in fact it is ubiquitous:\n", - "given a random state of a two-component quantum system, it's almost certain that the two components will be entangled. \n", - "For this reason, it's sometimes more interesting when a state is *not* entangled rather than when it is!\n", - "For example, when [building a quantum computer at Xanadu](https://www.xanadu.ai/photonics), we spend a ton of effort to ensure that our qubits are as *unentangled* as possible with their environment!\n", - "\n", - "In this demo we'll investigate *unentanglement* more closely.\n", - "More specifically we'll consider a problem related to unentanglement, called the *hidden cut problem*. \n", - "In this problem we assume that we're given a state consisting of many components. \n", - "As we discussed, it'll generally be the case that most of these components are entangled with one another.\n", - "But in the hidden cut problem we are guaranteed that it's possible to split the components up into two groups, so that between the two groups there is *no* entanglement.\n", - "The problem asks us to find this \"hidden cut\" that splits the state up into two *unentangled* pieces.\n", - "\n", - "Let's define the hidden cut problem a bit more precisely.\n", - "First we need to define *unentanglement*.\n", - "We say that a quantum state $\\ket\\psi$ describing a system with two parts, $A$ and $B$, is *unentangled*, if it can be written as a tensor product\n", - "$$\n", - "\\ket{\\psi} = \\ket{\\psi_A}\\otimes \\ket{\\psi_B}\n", - "$$,\n", - "where $\\ket{\\psi_A}$ is a state of system $A$ and $\\ket{\\psi_B}$ is a state of system $B$.\n", - "We also use the term *separable* or *factorizable* to describe an unentagled state.\n", - "We'll usually not bother writing the tensor product sign and just write $\\ket{\\psi} = \\ket{\\psi_A}\\ket{\\psi_B}$.\n", - "And if $\\ket{\\psi}$ isn't unentangled we say it's *entangled*.\n", - "\n", - "Now let's suppose $\\ket\\psi$ is a state of $n$-qubits.\n", - "We're told it's possible to split the qubits into two unentangled subsets, $S$ and $\\bar S$, \n", - "$$\n", - "\\ket{\\psi} = \\ket{\\psi_S}\\ket{\\psi_{\\bar S}},\n", - "$$\n", - "but we aren't told what $S$ and $\\bar S$ are. \n", - "The hidden cut problem asks us, given access to $\\ket\\psi$, to determine $S$ and $\\bar S$.\n", - "Following ..., in this demo we'll develop a quantum algorithm that solves this problem!" - ] - }, - { - "cell_type": "markdown", - "id": "c4cca12b", - "metadata": {}, - "source": [ - "## Creating an unentangled state" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "87f21042", - "metadata": {}, - "outputs": [], - "source": [ - "import galois\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pennylane as qml\n", - "from scipy.stats import unitary_group\n", - "\n", - "# set random seed\n", - "np.random.seed(123)" - ] - }, - { - "cell_type": "markdown", - "id": "4c3a0a35", - "metadata": {}, - "source": [ - "Before we can solve the hidden cut problem, we first need a state $\\ket\\psi$ to solve it on!\n", - "First we define a function `random_state()` that creates a random state with a specified number of qubits.\n", - "We do this by creating a $2^n$ by $2^n$ random unitary and taking the first row.\n", - "Because all the rows (and columns) in a unitary matrix have norm equal to 1, this defines a valid quantum state." - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "bd854cdf", - "metadata": {}, - "outputs": [], - "source": [ - "def random_state(n_qubits):\n", - " dim = 2**n_qubits\n", - " return unitary_group.rvs(dim)[0]" - ] - }, - { - "cell_type": "markdown", - "id": "a8000a8c", - "metadata": {}, - "source": [ - "However we can't just use this function to construct our state $\\ket\\psi$, because the random state created by the function will almost certainly *not* be unentagled.\n", - "So we'll define a function `separable_state()` that takes as input a list of qubit partitions, creates a random state for each partition, and tensors them together into a separable state." - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "b52893dc", - "metadata": {}, - "outputs": [], - "source": [ - "def separable_state(partitions):\n", - " # Number of qubits\n", - " n_qubits = sum(len(part) for part in partitions)\n", - "\n", - " # Sort partitions\n", - " partitions = [sorted(part) for part in partitions]\n", - "\n", - " # Create random state for each partition\n", - " partition_states = [(part, random_state(len(part))) for part in partitions]\n", - " \n", - " # Initialize full state\n", - " full_state = np.zeros(2**n_qubits, dtype=complex)\n", - " \n", - " # Fill in amplitudes\n", - " for idx in range(2**n_qubits):\n", - " # Convert idx to binary string\n", - " bits = format(idx, f'0{n_qubits}b')\n", - " \n", - " # Calculate amplitude as product of partition amplitudes\n", - " amplitude = 1.0\n", - " for part, state in partition_states:\n", - " # Extract partition bits, convert to decimal, update amplitude\n", - " part_bits = ''.join(bits[q] for q in part)\n", - " part_idx = int(part_bits, 2)\n", - " amplitude *= state[part_idx]\n", - " \n", - " full_state[idx] = amplitude\n", - " \n", - " return full_state" - ] - }, - { - "cell_type": "markdown", - "id": "ea087ba6", - "metadata": {}, - "source": [ - "We'll use this to create a 5-qubit state $\\ket\\psi$ in which qubits $S=\\{0,1\\}$ are unentangled with qubits $\\bar S=\\{2,3,4\\}$." - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "e3080187", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created 5 qubit state with qubits [0, 1] unentangled from [2, 3, 4].\n" - ] - } - ], - "source": [ - "partitions = [[0,1], [2,3,4]]\n", - "state = separable_state(partitions)\n", - "n = int(np.log2(len(state)))\n", - "print(f'Created {n} qubit state with qubits {partitions[0]} unentangled from {partitions[1]}.')" - ] - }, - { - "cell_type": "markdown", - "id": "bae2878f", - "metadata": {}, - "source": [ - "Now imagine we're given $\\ket \\psi$ but aren't told that qubits 0,1 are unentangled from qubits 2,3,4.\n", - "How could we figure this out?\n", - "This is the hidden cut problem: given a many-qubit quantum state, figure out which qubits are unentangled with which other qubits.\n", - "Now we'll develop a quantum algorithm that solves this problem, and then we'll implement it in Pennylane and see that it works!" - ] - }, - { - "cell_type": "markdown", - "id": "322cb418", - "metadata": {}, - "source": [ - "## Hidden cut problem as a hidden subgroup problem" - ] - }, - { - "cell_type": "markdown", - "id": "88dcebee", - "metadata": {}, - "source": [ - "The key to solving the hidden cut problem is to recast it as a *hidden symmetry problem*, or in more mathematical language a *hidden subgroup problem* (HSP).\n", - "Then we can use a famous quantum algorithm for solving HSPs to solve the hidden cut problem.\n", - "The traditional HSP algorithm is useful for finding symmetries of functions $f(x)$, i.e. figuring out for what values of $a$ we have $f(x+a) = f(x)$ for all $x$. \n", - "However we're interested in a *state* $\\ket\\psi$ and not a *function* $f(x)$, so we'll instead use a modified version of the HSP algorithm, called StateHSP, which finds *symmetries of states*.\n", - "\n", - "We'll explain the StateHSP algorithm below, but first let's see how we can recast the hidden cut problem as one of finding a hidden symmetry of a state.\n", - "To see this, remember our example state $\\ket\\psi=\\ket{\\psi_{01}}\\ket{\\psi_{234}}$.\n", - "Now consider two copies $\\ket\\psi\\ket\\psi$ of $\\ket\\psi$.\n", - "We can visualize this as \n", - "\n", - "[...picture...]\n", - "\n", - "The top row corresponds to the first copy of $\\ket\\psi$, and the bottom row to the second copy.\n", - "In each row, qubits 0 and 1 are disconnected from qubits 2, 3, and 4.\n", - "This schematically indicates the fact that in each $\\ket\\psi$ qubits 0,1 are unentangled from qubits 2,3,4.\n", - "\n", - "Now consider what happens when we swap some qubits in the top row with the corresponding qubits in the bottom row.\n", - "We can denote which pairs of qubits we're swapping with a 5-bit string. \n", - "For example, the bitstring 10101 corresponds to swapping the qubits in positions 0, 2, and 4 in the top row with qubits 0, 2, and 4 in the bottom row.\n", - "Because there are $2^5=32$ 5-bit strings, there are 32 possible swap operations we can perform.\n", - "Interestingly, the set of all 32 5-bit strings forms a mathematical *group* under bitwise addition.\n", - "\n", - "BOX: Group (take from Maria's demo)\n", - "\n", - "We'll call the group of 5-bit strings $G$.\n", - "We can now ask: which elements of $G$ correspond to swap operations that leave the state $\\ket\\psi\\ket\\psi$ invariant?\n", - "These operations are the symmetries of $\\ket\\psi\\ket\\psi$ and the corresponding bitstrings form a subgroup $H$ of $G$.\n", - "For example the identity element 00000 corresponds to performing no swaps at all.\n", - "This is clearly a symmetry, so 00000 is in $H$.\n", - "On the other hand 11111 swaps *all* the qubits in the top row with the corresponding qubits in the bottom row, so in effect it just swaps the entire first copy of $\\ket\\psi$ with the entire second copy of $\\ket\\psi$.\n", - "This is clearly also a symmetry, so 11111 is also in $H$.\n", - "Are there any other elements in $H$?\n", - "Stop and think about it!\n", - "\n", - "In fact, there are two more elements in $H$: 11000 and 00111.\n", - "11000 corresponds to swapping the $\\ket{\\psi_{01}}$ component of the first copy of $\\ket\\psi$ with the same component of the second copy of $\\ket\\psi$, and 00111 corresponds to swapping the $\\ket{\\psi_{234}}$ components between the two copies.\n", - "Because in each copy of $\\ket\\psi$ the $\\ket{\\psi_{01}}$ and $\\ket{\\psi_{234}}$ components are completely unentangled, after either of these swaps the full state remains the same, namely $\\ket\\psi\\ket\\psi$.\n", - "So the symmetry subgroup is $H = {00000, 11111, 11000, 00111}$.\n", - "We'll call this a *hidden* symmetry subgroup because it wasn't given to us - we had to find it!\n", - "\n", - "Now, a shorthand way to write any group is to specify a set of *generators*, group elements that can be added together to generate any other element of the group.\n", - "For $H$ the generators are 11000 and 00111: we can add either generator to itself to get the identity 00000, and we can add the generators to each other to get 11111.\n", - "Here's the important point: notice that the generators of $H$ *directly* tell us the unentangled components of $\\ket\\psi=\\ket{\\psi_{01}}\\ket{\\psi_{234}}$!\n", - "The first generator 11000 has 1s in bits 0 and 1: this corresponds to the first unentangled component $\\ket{\\psi_{01}}$.\n", - "And the second generator 00111 has 1s in bits 2, 3, 4: this corresponds to the second unentangled component $\\ket{\\psi_{234}}$.\n", - "So finding the hidden subgroup $H$ gives us the unentangled components - it solves the hidden cut problem!\n", - "\n", - "So now that we recast the hidden cut problem as a problem of finding a hidden subgroup $H$, lets see how the StateHSP algorithm can be used to find $H$.\n", - "The general algorithm works for any abelian group $G$, but here we'll just focus on the case where $G$ is the group of $n$-bit strings, since this is the case that's relevant to solving the hidden cut problem.\n", - "\n", - "The algorithm involves running a quantum circuit, taking measurements, and postprocessing the measurements.\n", - "The circuit involves three $n$-qubit registers.\n", - "Registers 2 and 3 are each initialized to $\\ket\\psi$, and register 1 is initialized to the all $\\ket 0$ state.\n", - "We call register 1 the *group register* because we'll use it to encode elements of the group $G$.\n", - "For example if $n=5$ the group element 10101 of $G$ would be encoded as $\\ket{10101}$.\n", - "\n", - "After this register initialization, the StateHSP circuit involves three steps:\n", - "1. Apply a Hadamard to each qubit in the group register; this puts the group register in a uniform superposition of all group elements, which up to normalization we can write as $\\sum_{g\\in G} \\ket g$.\n", - "2. Apply a controlled SWAP operator, which acts on all 3 registers by mapping $\\ket{g}\\ket\\psi\\ket\\psi$ to $\\ket{g}\\text{SWAP}_g(\\ket\\psi\\ket\\psi)$.\n", - "Here $\\text{SWAP}_g$ performs swaps at the positions indicated by $g$; for example if $g=10101$ then qubits 0, 2 and 4 in the first copy of $\\ket\\psi$ will get swapped with the corresponding qubits in the second copy of $\\ket\\psi$.\n", - "3. Again apply a Hadamard to each qubit in the group register.\n", - "\n", - "Finally we measure the group register.\n", - "Here's the circuit diagram:\n", - "\n", - "[...picture...]\n", - "\n", - "We'll implement this in Pennylane, and then we'll show how the measurement results can be postprocessed to find the hidden subgroup $H$ that encodes the hidden cut!" - ] - }, - { - "cell_type": "markdown", - "id": "1f33de6e", - "metadata": {}, - "source": [ - "## Solving the hidden cut problem in Pennylane" - ] - }, - { - "cell_type": "markdown", - "id": "50bb242e", - "metadata": {}, - "source": [ - "Let's implement this circuit in Pennylane!\n", - "We'll use a device with `shots=100`: this will run the circuit 100 times and record a 5-bit measurement for each run.\n", - "We'll store these measurements in an array `M`:" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "a877887e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The shape of M is (100, 5).\n", - "The first 3 rows of M are:\n", - "[[0 0 0 0 0]\n", - " [0 0 1 0 1]\n", - " [0 0 1 1 0]]\n" - ] - } - ], - "source": [ - "dev = qml.device('default.qubit', shots=100)\n", - "\n", - "@qml.qnode(dev)\n", - "def circuit():\n", - " # Initialize psi x psi in registers 2 and 3\n", - " qml.StatePrep(state, wires=range(n, 2*n))\n", - " qml.StatePrep(state, wires=range(2*n, 3*n))\n", - " \n", - " # Hadamards\n", - " for a in range(n):\n", - " qml.Hadamard(a)\n", - "\n", - " # Controlled swaps\n", - " for c in range(n):\n", - " a = c + n\n", - " b = c + 2*n\n", - " qml.ctrl(qml.SWAP, c, control_values=1)(wires=(a,b))\n", - "\n", - " # Hadamards\n", - " for a in range(n):\n", - " qml.Hadamard(a)\n", - "\n", - " # Measure\n", - " return qml.sample(wires=range(n))\n", - "\n", - "M = circuit()\n", - "\n", - "print(f'The shape of M is {M.shape}.')\n", - "print(f'The first 3 rows of M are:\\n{M[:3]}')" - ] - }, - { - "cell_type": "markdown", - "id": "a99d1cd7", - "metadata": {}, - "source": [ - "Now let's process the measurement results $M$ to determine the hidden subgroup $H$!\n", - "This postprocessing step is common to all hidden subgroup algorithms.\n", - "The key fact that connects the measurement results $M$ to the hidden subgroup $H$ is this: the elements of $H$ are the vectors that are orthogonal to all measurements (i.e. rows) in $M$.\n", - "Since we're working with the group of bitstrings, two bitstrings are orthogonal if their dot product mod 2 is equal to 0.\n", - "For example 10101 and 11100 are orthogonal since their dot product is $2\\equiv0\\mod 2$, while 10101 and 11111 are *not* orthogonal, since their dot product is $3\\equiv1\\mod 2$.\n", - "\n", - "So to get $H$ we just have to find the binary vectors $\\vec b$ orthogonal to every row of $M$.\n", - "Mathematically we write this as $M\\vec b = 0$, where all operations are assumed to be performed mod 2.\n", - "In linear algebra lingo we say that the solutions $\\vec b$ to this equation form the *nullspace* of $M$.\n", - "We can straightforwardly find the nullspace using basic linear algebra techniques.\n", - "\n", - "Instead of doing the algebra by hand though, here we'll use the `galois` python library, which can perform linear algebra mod 2.\n", - "To ensure that operations on $M$ are performed mod 2, we first convert it to a `galois.GF2` array.\n", - "The GF2 stands for [\"Galois field of order 2\"](https://en.wikipedia.org/wiki/Finite_field), which is a fancy way of saying that all operations are performed mod 2." - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "acc04c3c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The shape of M is (100, 5).\n", - "The first 3 rows of M are:\n", - "[[0 0 0 0 0]\n", - " [0 0 1 0 1]\n", - " [0 0 1 1 0]]\n" - ] - } - ], - "source": [ - "M = galois.GF2(M)\n", - "\n", - "print(f'The shape of M is {M.shape}.')\n", - "print(f'The first 3 rows of M are:\\n{M[:3]}')" - ] - }, - { - "cell_type": "markdown", - "id": "ad3011f6", - "metadata": {}, - "source": [ - "So `M` is the same array as before.\n", - "Let's check that addition is performed mod 2 by adding rows 1 and 2 of `M`:" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "56d7212a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " r1 = [0 0 1 0 1]\n", - " r2 = [0 0 1 1 0]\n", - "r1 + r2 = [0 0 0 1 1]\n" - ] - } - ], - "source": [ - "r1 = M[1]\n", - "r2 = M[2]\n", - "\n", - "print(f' r1 = {r1}')\n", - "print(f' r2 = {r2}')\n", - "print(f'r1 + r2 = {r1 + r2}')" - ] - }, - { - "cell_type": "markdown", - "id": "2163cd5a", - "metadata": {}, - "source": [ - "Looking at the middle column we see that $1+1=0$, so addition is mod 2 as desired!\n", - "\n", - "Now we can finally compute the nullspace of `M`, which will give us the hidden subgroup $H$.\n", - "We can do this easily now that `M` is a `galois.GF2` array just by calling `M.null_space()`.\n", - "In fact this method doesn't return all of the bitstrings in the nullspace, but instead saves space by only returning the generators of the nullspace." - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "c433a9b6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "GF([[1, 1, 0, 0, 0],\n", - " [0, 0, 1, 1, 1]], order=2)" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "M.null_space()" - ] - }, - { - "cell_type": "markdown", - "id": "5b95d571", - "metadata": {}, - "source": [ - "Because the nullspace of $M$ equals $H$, we conclude that the generators of $H$ are 11000 and 00111.\n", - "If we didn't know that $\\ket\\psi$ could be factored as $\\ket\\psi=\\ket{\\psi_{01}}\\ket{\\psi_{234}}$, the generators would directly tell us the factors!\n", - "So we have solved the hidden cut problem for our state $\\ket\\psi$!" - ] - }, - { - "cell_type": "markdown", - "id": "040d4979", - "metadata": {}, - "source": [ - "## The power of hidden symmetries" - ] - }, - { - "cell_type": "markdown", - "id": "b67f367b", - "metadata": {}, - "source": [ - "We solved the hidden cut problem—finding the factors of a multi-qubit quantum state—by thinking about it from the perspective of symmetries.\n", - "The key insight was to recognize that the question \"*What are the unentangled factors of the state?*\" can be rephrased as the question \"*What is the hidden symmetry of the state?*\".\n", - "With this rephrasing the hidden cut problem became a hidden subgroup problem, and we could solve it using a modification of the standard algorithm for HSPs that allows for finding symmetries of *states* rather than functions.\n", - "\n", - "In fact, many of the most well-known problems that benefit from access to a quantum computer are also instances of an HSP!\n", - "In some cases, like with the hidden cut problem, it isn't obvious by looking at it that the problem involves finding a hidden symmetry.\n", - "The most famous example of this is the problem of factoring large integers, a problem with fundamental importance in cryptography.\n", - "It's not at all obvious that this problem is related to finding the symmetry of a function, but with some clever algebra it can be phrased in this way, and hence solved efficiently using the HSP algorithm.\n", - "As a speculative side comment, it's interesting that problem of *factoring* states and the problem of *factoring* integers can both be phrased as HSPs!\n", - "Is there something about *factoring* problems that enables them to be expressed as HSPs?\n", - "Are there other important factoring problems that can also be recast as HSPs and solved on a quantum computer?\n", - "Or is this just a complete coincidence?\n", - "I invite you to think about this if you're interested - maybe you find a deep connection!\n", - "\n", - "Less speculatively, there definitely *is* one deep and generalizable lesson that we should take away from this hidden cut demo, and that is the *power of looking for hidden symmetries*.\n", - "This goes well beyond quantum computing.\n", - "In fact some of the most significant discoveries in physics are just recognitions of a hidden symmetry!\n", - "For example, recognizing the symmetries of fundamental particles led to the development of the standard model of particle physics, \n", - "recognizing the symmetry of systems in different inertial reference frames led to discovery of special relativity, \n", - "and recognizing the symmetry between freefalling and accelerating objects led to the discovery of general relativity.\n", - "Indeed, looking for hidden symmetries is a very powerful approach, both in quantum computing and beyond!\n", - "\n", - "\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "qml", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/demonstrations/tutorial_hidden_cut.py b/demonstrations/tutorial_hidden_cut.py index 18577cfb3c..1e2afb9148 100644 --- a/demonstrations/tutorial_hidden_cut.py +++ b/demonstrations/tutorial_hidden_cut.py @@ -54,7 +54,7 @@ # \ket{\psi} = \ket{\psi_S}\ket{\psi_{\bar S}}, # # but we aren’t told what :math:`S` and :math:`\bar S` are. The hidden cut problem asks us, given -# access to :math:`\ket\psi`, to determine :math:`S` and :math:`\bar S`. Following …, in this demo +# access to :math:`\ket\psi`, to determine :math:`S` and :math:`\bar S`. Following `Bouland et al `__, in this demo # we’ll develop a quantum algorithm that solves this problem! # @@ -158,7 +158,7 @@ def separable_state(partitions): # :math:`\ket\psi=\ket{\psi_{01}}\ket{\psi_{234}}`. Now consider two copies :math:`\ket\psi\ket\psi` # of :math:`\ket\psi`. We can visualize this as # -# […picture…] +# [FIGURE 1] # # The top row corresponds to the first copy of :math:`\ket\psi`, and the bottom row to the second # copy. In each row, qubits 0 and 1 are disconnected from qubits 2, 3, and 4. This schematically @@ -170,9 +170,17 @@ def separable_state(partitions): # qubits 0, 2, and 4 in the bottom row. Because there are :math:`2^5=32` 5-bit strings, there are 32 # possible swap operations we can perform. Interestingly, the set of all 32 5-bit strings forms a # mathematical *group* under bitwise addition. -# -# BOX: Group (take from Maria’s demo) -# +# +# .. admonition:: Group +# :class: note +# +# A group is a set of elements that has: +# 1. an operation that maps two elements a and b of the set into a third element of the set, for example c = a + b, +# 2. an "identity element" e such that e + a = a for any element a, and +# 3. an inverse -a for every element a, such that a + (-a) = e. +# +# A group is called "Abelian" if a + b = b + a for all a and b, otherwise it is called non-Abelian. +# # We’ll call the group of 5-bit strings :math:`G`. We can now ask: which elements of :math:`G` # correspond to swap operations that leave the state :math:`\ket\psi\ket\psi` invariant? These # operations are the symmetries of :math:`\ket\psi\ket\psi` and the corresponding bitstrings form a @@ -226,7 +234,7 @@ def separable_state(partitions): # # Finally we measure the group register. Here’s the circuit diagram: # -# […picture…] +# [FIGURE 2] # # We’ll implement this in Pennylane, and then we’ll show how the measurement results can be # postprocessed to find the hidden subgroup :math:`H` that encodes the hidden cut! From bd40a419389c59964569b151e7a4f2f9698c77a5 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Tue, 10 Jun 2025 15:26:52 -0400 Subject: [PATCH 16/20] Minor text changes --- demonstrations/tutorial_hidden_cut.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/demonstrations/tutorial_hidden_cut.py b/demonstrations/tutorial_hidden_cut.py index 1e2afb9148..7b4de5f155 100644 --- a/demonstrations/tutorial_hidden_cut.py +++ b/demonstrations/tutorial_hidden_cut.py @@ -368,11 +368,11 @@ def circuit(): # Less speculatively, there definitely *is* one deep and generalizable lesson that we should take away # from this hidden cut demo, and that is the *power of looking for hidden symmetries*. This goes well # beyond quantum computing. In fact some of the most significant discoveries in physics are just -# recognitions of a hidden symmetry! For example, recognizing the symmetries of fundamental particles -# led to the development of the standard model of particle physics, recognizing the symmetry of -# systems in different inertial reference frames led to discovery of special relativity, and +# recognitions of a hidden symmetry! For example: recognizing the symmetries of fundamental particles +# led to the development of the standard model of particle physics; recognizing the symmetry of +# systems in different inertial reference frames led to discovery of special relativity; and # recognizing the symmetry between freefalling and accelerating objects led to the discovery of -# general relativity. Indeed, looking for hidden symmetries is a very powerful approach, both in +# general relativity. It's clear that looking for hidden symmetries is a very powerful approach, both in # quantum computing and beyond! # From 6b8e3a4d02de7553f90d82974f217d475784e42e Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Tue, 10 Jun 2025 15:48:48 -0400 Subject: [PATCH 17/20] Update figures --- demonstrations/tutorial_hidden_cut.py | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/demonstrations/tutorial_hidden_cut.py b/demonstrations/tutorial_hidden_cut.py index 7b4de5f155..eb688c82f7 100644 --- a/demonstrations/tutorial_hidden_cut.py +++ b/demonstrations/tutorial_hidden_cut.py @@ -157,9 +157,13 @@ def separable_state(partitions): # problem as one of finding a hidden symmetry of a state. To see this, remember our example state # :math:`\ket\psi=\ket{\psi_{01}}\ket{\psi_{234}}`. Now consider two copies :math:`\ket\psi\ket\psi` # of :math:`\ket\psi`. We can visualize this as -# -# [FIGURE 1] -# +# +#.. figure:: ../_static/demonstration_assets/hidden_cut/qubits.png +# :align: center +# :width: 80% +# +# Figure 2. A schematic of the quantum state :math:`\ket\psi\ket\psi`. +# # The top row corresponds to the first copy of :math:`\ket\psi`, and the bottom row to the second # copy. In each row, qubits 0 and 1 are disconnected from qubits 2, 3, and 4. This schematically # indicates the fact that in each :math:`\ket\psi` qubits 0,1 are unentangled from qubits 2,3,4. @@ -233,9 +237,13 @@ def separable_state(partitions): # :math:`\ket\psi`. 3. Again apply a Hadamard to each qubit in the group register. # # Finally we measure the group register. Here’s the circuit diagram: -# -# [FIGURE 2] -# +# +#.. figure:: ../_static/demonstration_assets/hidden_cut/circuit.png +# :align: center +# :width: 80% +# +# Figure 2. Hidden cut circuit +# # We’ll implement this in Pennylane, and then we’ll show how the measurement results can be # postprocessed to find the hidden subgroup :math:`H` that encodes the hidden cut! # From d205507a0564604764bffa43eec26a50ce798f8b Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Fri, 11 Jul 2025 16:16:15 -0400 Subject: [PATCH 18/20] Implement PR review changes --- demonstrations/tutorial_hidden_cut.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/demonstrations/tutorial_hidden_cut.py b/demonstrations/tutorial_hidden_cut.py index eb688c82f7..6a63647eaa 100644 --- a/demonstrations/tutorial_hidden_cut.py +++ b/demonstrations/tutorial_hidden_cut.py @@ -15,8 +15,8 @@ # when it takes light itself 33 billion years to travel between the qubits is one of the most # philosophically loaded questions at the heart of quantum foundations. # -# Despite entanglement being so philosophically provocative, it’s somewhat surprising that in fact it -# is ubiquitous: given a random state of a two-component quantum system, it’s almost certain that the +# Despite entanglement being so philosophically provocative, it’s somewhat surprising that it is so +# ubiquitous: given a random state of a two-component quantum system, it’s almost certain that the # two components will be entangled. For this reason, it’s sometimes more interesting when a state is # *not* entangled rather than when it is! For example, when `building a quantum computer at # Xanadu `__, we spend a ton of effort to ensure that our qubits are @@ -26,7 +26,7 @@ # problem related to unentanglement, called the *hidden cut problem*. In this problem we assume that # we’re given a state consisting of many components. As we discussed, it’ll generally be the case that # most of these components are entangled with one another. But in the hidden cut problem we are -# guaranteed that it’s possible to split the components up into two groups, so that between the two +# guaranteed that it’s possible to split the components into two groups, so that between the two # groups there is *no* entanglement. The problem asks us to find this “hidden cut” that splits the # state up into two *unentangled* pieces. # @@ -42,8 +42,7 @@ # , where :math:`\ket{\psi_A}` is a state of system :math:`A` and :math:`\ket{\psi_B}` is a state of # system :math:`B`. We also use the term *separable* or *factorizable* to describe an unentagled # state. We’ll usually not bother writing the tensor product sign and just write -# :math:`\ket{\psi} = \ket{\psi_A}\ket{\psi_B}`. And if :math:`\ket{\psi}` isn’t unentangled we say -# it’s *entangled*. +# :math:`\ket{\psi} = \ket{\psi_A}\ket{\psi_B}`. # # Now let’s suppose :math:`\ket\psi` is a state of :math:`n`-qubits. We’re told it’s possible to split # the qubits into two unentangled subsets, :math:`S` and :math:`\bar S`, @@ -53,8 +52,8 @@ # # \ket{\psi} = \ket{\psi_S}\ket{\psi_{\bar S}}, # -# but we aren’t told what :math:`S` and :math:`\bar S` are. The hidden cut problem asks us, given -# access to :math:`\ket\psi`, to determine :math:`S` and :math:`\bar S`. Following `Bouland et al `__, in this demo +# but we aren’t told what :math:`S` and :math:`\bar S` are. The hidden cut problem asks us to determine :math:`S` and :math:`\bar S`, given access to :math:`\ket\psi`. +# Following Bouland *et al.* [#Bouland2024]_, in this demo # we’ll develop a quantum algorithm that solves this problem! # From 2e0c93ad11097b07d0c17d862461e3cbf9bb1937 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Fri, 11 Jul 2025 16:16:31 -0400 Subject: [PATCH 19/20] create metadata file --- .../tutorial_hidden_cut.metadata.json | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 demonstrations/tutorial_hidden_cut.metadata.json diff --git a/demonstrations/tutorial_hidden_cut.metadata.json b/demonstrations/tutorial_hidden_cut.metadata.json new file mode 100644 index 0000000000..fb8bf529fa --- /dev/null +++ b/demonstrations/tutorial_hidden_cut.metadata.json @@ -0,0 +1,57 @@ +{ + "title": "The hidden cut problem for locating unentanglement", + "authors": [ + { + "username": "simidzija" + } + ], + "dateOfPublication": "2025-07-11T10:00:00+00:00", + "dateOfLastModification": "2025-07-11T10:00:00+00:00", + "categories": [ + "Algorithms" + ], + "tags": [], + "previewImages": [ + { + "type": "thumbnail", + "uri": "/_static/demo_thumbnails/regular_demo_thumbnails/thumbnail_period_finding.png" + }, + { + "type": "large_thumbnail", + "uri": "/_static/demo_thumbnails/large_demo_thumbnails/thumbnail_large_period_finding.png" + } + ], + "seoDescription": "Learn about a quantum algorithm that determines how to cut a many-body quantum state into unentangled components.", + "doi": "", + "references": [ + { + "id": "Bouland2024", + "type": "article", + "title": "The State Hidden Subgroup Problem and an Efficient Algorithm for Locating Unentanglement", + "authors": "Adam Bouland, Tudor Giurgică-Tiron, John Wright", + "year": "2024", + "journal": "STOC '25", + "doi": "10.1145/3717823.3718118", + "url": "https://doi.org/10.1145/3717823.3718118" + } + ], + "basedOnPapers": ["10.1145/3717823.3718118"], + "referencedByPapers": [], + "relatedContent": [ + { + "type": "demonstration", + "id": "tutorial_qft", + "weight": 1.0 + }, + { + "type": "demonstration", + "id": "tutorial_qft_arithmetics", + "weight": 1.0 + }, + { + "type": "demonstration", + "id": "tutorial_period_finding", + "weight": 1.0 + } + ] +} From 809fc69818e2104e12e1c26331e68b90f394eb10 Mon Sep 17 00:00:00 2001 From: Petar Simidzija Date: Mon, 14 Jul 2025 11:37:33 -0400 Subject: [PATCH 20/20] Add galois package dependency --- poetry.lock | 21 +++++++++++++++++++-- pyproject.toml | 1 + 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/poetry.lock b/poetry.lock index 28103c2499..71f597e621 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand. +# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand. [[package]] name = "absl-py" @@ -2445,6 +2445,23 @@ files = [ orderedmultidict = ">=1.0.1" six = ">=1.8.0" +[[package]] +name = "galois" +version = "0.4.6" +description = "A performant NumPy extension for Galois fields and their applications" +optional = false +python-versions = ">=3.7" +groups = ["executable-dependencies"] +files = [ + {file = "galois-0.4.6-py3-none-any.whl", hash = "sha256:1e6a6230ffd21c39d60f165e17bfd6c1a685a023a967d84d240f2ef3eb0bf62c"}, + {file = "galois-0.4.6.tar.gz", hash = "sha256:b5da70bca8d29bda71a832dde908a65591a9c30fa50fa5c5e7aab0a9aacf17df"}, +] + +[package.dependencies] +numba = ">=0.55,<0.62" +numpy = ">=1.21.0" +typing-extensions = ">=4.0.0" + [[package]] name = "gast" version = "0.6.0" @@ -9472,4 +9489,4 @@ files = [ [metadata] lock-version = "2.1" python-versions = "~3.10.0" -content-hash = "b259bee232437bc221b8520099bb9797dfd235fd3e2e2ac604c675fdfceded18" +content-hash = "5694da3ebcd2702750ef00d16634f0a9ad68a9ec447ad7b5d80f42832c88906b" diff --git a/pyproject.toml b/pyproject.toml index 9e70b72faf..fe3787ec41 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -106,6 +106,7 @@ sphinxcontrib-applehelp = "1.0.8" sphinx-gallery = "0.17.1" qrisp = ">=0.6.1" iqpopt = { git = "https://github.com/XanaduAI/iqpopt.git" } +galois = "0.4.6" # Install a difference version of torch from PyPI as the one from PyTorch repo is not compatible with MacOS