{

  "cells": [

    {

      "cell_type": "code",

      "execution_count": 114,

      "metadata": {

        "id": "saZVT5NBpGsV",

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 0

        },

        "outputId": "d310461d-8bac-4264-8d62-7db80a91fe14"

      },

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "Time in seconds since beginning of run: 1693257294.98402\n",

            "Mon Aug 28 21:14:54 2023\n"

          ]

        }

      ],

      "source": [

        "# This cell is added by sphinx-gallery\n",

        "# It can be customized to whatever you like\n",

        "%matplotlib inline\n",

        "# !pip install pennylane\n",

        "import time\n",

        "seconds = time.time()\n",

        "print(\"Time in seconds since beginning of run:\", seconds)\n",

        "local_time = time.ctime(seconds)\n",

        "print(local_time)"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "IrRdSTiapGsX"

      },

      "source": [

        "Quantum advantage in learning from experiments\n",

        "==============================================\n",

        "\n",

        "::: {.meta}\n",

        ":property=\\\"og:description\\\": Learn how quantum memory can boost quantum\n",

        "machine learning algorithms :property=\\\"og:image\\\":\n",

        "<https://pennylane.ai/qml/_images/learning_from_exp_thumbnail.png>\n",

        ":::\n",

        "\n",

        "*Author: Joseph Bowles --- Posted: 18 April 2022. Last updated: 30 June\n",

        "2022.*\n",

        "\n",

        "This demo is based on the article [Quantum advantage in learning from\n",

        "experiments](https://arxiv.org/abs/2112.00778) [\\[1\\]](#ref1) by\n",

        "Hsin-Yuan Huang and co-authors. The article investigates the following\n",

        "question:\n",

        "\n",

        "*How useful is access to quantum memory for quantum machine learning?*\n",

        "\n",

        "They show that access to quantum memory can make a big difference, and\n",

        "prove that there exist learning problems for which algorithms with\n",

        "quantum memory require *exponentially less resources* than those\n",

        "without. We look at one learning task studied in [\\[1\\]](#ref1) for\n",

        "which this is the case.\n",

        "\n",

        "The learning task\n",

        "-----------------\n",

        "\n",

        "The learning task we focus on involves deciding if a unitary is\n",

        "time-reversal symmetric (we'll call them T-symmetric) or not.\n",

        "Mathematically, time-reversal symmetry in quantum mechanics involves\n",

        "reversing the sense of $i$ so that $i \\rightarrow -i$. Hence, a unitary\n",

        "$U$ is T-symmetric if\n",

        "\n",

        "$$U^*=U.$$\n",

        "\n",

        "Now for the learning task. Let's say we have a bunch of quantum circuits\n",

        "$U_1, \\cdots, U_n$, some of which are T-symmetric and some not, but we\n",

        "are not told which ones are which.\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "LkLkc0PApGsY"

      },

      "source": [

        "![](../demonstrations/learning_from_experiments/fig1b.png){.align-center\n",

        "width=\"50.0%\"}\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "5ExBGwcOpGsY"

      },

      "source": [

        "The task is to design an algorithm to determine which of the $U$'s are\n",

        "T-symmetric and which are not, given query access to the unitaries. Note\n",

        "that we do not have any labels here, so this is an unsupervised learning\n",

        "task. To make things concrete, let's consider unitaries acting on 8\n",

        "qubits. We will also limit the number of times we can use each unitary:\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 115,

      "metadata": {

        "id": "lLqfHqpCpGsY"

      },

      "outputs": [],

      "source": [

        "qubits = 8  # the number of qubits on which the unitaries act\n",

        "n_shots = 100  # the number of times we can use each unitary"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "QqtOm_d4pGsY"

      },

      "source": [

        "Experiments with and without a quantum memory\n",

        "=============================================\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "4lhh8844pGsZ"

      },

      "source": [

        "To tackle this task we consider experiments with and without quantum\n",

        "memory. We also assume that we have access to a single physical\n",

        "realization of each unitary; in other words, we do not have multiple\n",

        "copies of the devices that implement $U_i$.\n",

        "\n",

        "An experiment without quantum memory can therefore only make use of a\n",

        "single query to $U_i$ in each circuit, since querying $U_i$ again would\n",

        "require storing the state of the first query in memory and re-using the\n",

        "unitary. In the paper these experiments are called **conventional\n",

        "experiments**.\n",

        "\n",

        "Experiments with quantum memory do not have the limitations of\n",

        "conventional experiments. This means that multiple queries can be made\n",

        "to $U_i$ in a single circuit, which can be realized in practice by using\n",

        "a quantum memory. These experiments are called **quantum-enhanced\n",

        "experiments**.\n",

        "\n",

        "Note that we are not comparing classical and quantum algorithms here,\n",

        "but rather two classes of quantum algorithms.\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "NQUrpuZmpGsZ"

      },

      "source": [

        "![](../demonstrations/learning_from_experiments/experiments.png){.align-center\n",

        "width=\"60.0%\"}\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "gVDTZPuLpGsZ"

      },

      "source": [

        "The conventional way\n",

        "====================\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "H4NZdjTMpGsZ"

      },

      "source": [

        "First, we will try to solve the task with a conventional experiment. Our\n",

        "strategy will be as follows:\n",

        "\n",

        "-   For each $U_i$, we prepare `n_shots` copies of the state\n",

        "    $U_i\\vert0\\rangle$ and measure each state to generate classical\n",

        "    measurement data.\n",

        "-   Use an unsupervised classical machine learning algorithm (kernel\n",

        "    PCA), to try and separate the data into two clusters corresponding\n",

        "    to T-symmetric unitaries vs. the rest.\n",

        "\n",

        "If we succeed in clustering the data then we have successfully managed\n",

        "to discriminate the two classes!\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "3cBEdL1QpGsa"

      },

      "source": [

        "![](../demonstrations/learning_from_experiments/fig2b.png){.align-center\n",

        "width=\"70.0%\"}\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "VEg1RDR4pGsa"

      },

      "source": [

        "To generate the measurement data, we will measure the states\n",

        "$U_i\\vert0\\rangle$ in the $y$ basis. The local expectation values take\n",

        "the form\n",

        "\n",

        "$$E_i  = \\langle 0\\vert U^{\\dagger}\\sigma_y^{(i)} U \\vert 0 \\rangle.$$\n",

        "\n",

        "where $\\sigma_y^{(i)}$ acts on the $i^{\\text{th}}$ qubit.\n",

        "\n",

        "Using the fact that $\\sigma_y^*=-\\sigma_y$ and the property $U^*=U$ for\n",

        "T-symmetric unitaries, one finds\n",

        "\n",

        "$$E_i^*=\\langle 0\\vert (U^{\\dagger})^*(\\sigma_y^{(i)})^* (U)^* \\vert 0 \\rangle = - \\langle 0\\vert U^{\\dagger}\\sigma_y^{(i)} U \\vert 0 \\rangle = - E_i.$$\n",

        "\n",

        "Since $E_i$ is a real number, the only solution to this is $E_i=0$,\n",

        "which implies that all local expectations values are 0 for this class.\n",

        "\n",

        "For general unitaries it is not the case that $E_i=0$, and so it seems\n",

        "as though this will allow us to discriminate the two classes of circuits\n",

        "easily. However, for general random unitaries the local expectation\n",

        "values approach zero exponentially with the number of qubits: from\n",

        "finite measurement data it can still be very hard to see any difference!\n",

        "In fact, in the article [exponential separations between learning with\n",

        "and without quantum memory](https://arxiv.org/abs/2111.05881)\n",

        "[\\[2\\]](#ref2) it is proven that using conventional experiments, any\n",

        "successful algorithm *must* use the unitaries an exponential number of\n",

        "times.\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "VeMMzIc7pGsa"

      },

      "source": [

        "Let's see how this looks in practice. First we define a function to\n",

        "generate random unitaries, making use of Pennylane's\n",

        "[RandomLayers](https://pennylane.readthedocs.io/en/stable/code/api/pennylane.RandomLayers.html)\n",

        "template. For the time-symmetric case we will only allow for Y\n",

        "rotations, since these unitaries contain only real numbers, and\n",

        "therefore result in T-symmetric unitaries. For the other unitaries, we\n",

        "will allow rotations about X,Y, and Z.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 116,

      "metadata": {

        "id": "IIqOveLhpGsa"

      },

      "outputs": [],

      "source": [

        "import pennylane as qml\n",

        "from pennylane.templates.layers import RandomLayers\n",

        "from pennylane import numpy as np\n",

        "\n",

        "np.random.seed(234087)\n",

        "\n",

        "layers, gates = 10, 10  # the number of layers and gates used in RandomLayers\n",

        "\n",

        "\n",

        "def generate_circuit(shots):\n",

        "    \"\"\"\n",

        "    generate a random circuit that returns a number of measuement samples\n",

        "    given by shots\n",

        "    \"\"\"\n",

        "    dev = qml.device(\"default.qubit\", wires=qubits, shots=shots)\n",

        "\n",

        "    @qml.qnode(dev)\n",

        "    def circuit(ts=False):\n",

        "\n",

        "        if ts == True:\n",

        "            ops = [qml.RY]  # time-symmetric unitaries\n",

        "        else:\n",

        "            ops = [qml.RX, qml.RY, qml.RZ]  # general unitaries\n",

        "\n",

        "        weights = np.random.rand(layers, gates) * np.pi\n",

        "        RandomLayers(weights, wires=range(qubits), ratio_imprim=0.0001, rotations=ops, seed=np.random.randint(0, 10000))\n",

        "\n",

        "        return [qml.sample(op=qml.PauliY(q)) for q in range(qubits)]\n",

        "\n",

        "    return circuit"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "hjafWs6opGsa"

      },

      "source": [

        "let's check if that worked:\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 117,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 0

        },

        "id": "PDxmRpoDpGsa",

        "outputId": "67766f1c-70c1-4bbc-f151-0fcd1324874e"

      },

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "[[-1  1 -1]\n",

            " [-1 -1 -1]\n",

            " [-1 -1  1]\n",

            " [-1 -1  1]\n",

            " [ 1  1  1]\n",

            " [ 1  1 -1]\n",

            " [ 1  1  1]\n",

            " [-1  1 -1]]\n",

            "\n",

            "\n",

            "[[ 1  1  1]\n",

            " [ 1  1 -1]\n",

            " [-1  1  1]\n",

            " [ 1 -1 -1]\n",

            " [-1 -1 -1]\n",

            " [-1 -1  1]\n",

            " [ 1  1 -1]\n",

            " [-1 -1 -1]]\n"

          ]

        }

      ],

      "source": [

        "# the measurement outcomes for the first 3 shots\n",

        "circuit = generate_circuit(n_shots)\n",

        "print(np.array(circuit(ts=True))[:, 0:3])\n",

        "print(\"\\n\")\n",

        "print(np.array(circuit(ts=False))[:, 0:3])"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "fqoyiIk3pGsb"

      },

      "source": [

        "Now we can generate some data. The first 30 circuits in the data set are\n",

        "T-symmetric and the second 30 circuits are not. Since we are in an\n",

        "unsupervised setting, the algorithm will not know this information.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 118,

      "metadata": {

        "id": "m8naW3HRpGsb"

      },

      "outputs": [],

      "source": [

        "circuits = 30  # the number of circuits in each data set\n",

        "\n",

        "raw_data = []\n",

        "\n",

        "for ts in [True, False]:\n",

        "    for __ in range(circuits):\n",

        "        circuit = generate_circuit(n_shots)\n",

        "        raw_data.append(circuit(ts=ts))"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "XJIyrRYMpGsb"

      },

      "source": [

        "Before feeding the data to a clustering algorithm, we will process it a\n",

        "little. For each circuit, we calculate the mean and the variance of each\n",

        "output bit and store this in a vector of size `2*qubits`. These vectors\n",

        "make up our classical data set.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 119,

      "metadata": {

        "id": "_tpgsRE_pGsb"

      },

      "outputs": [],

      "source": [

        "def process_data(raw_data):\n",

        "    \"convert raw data to vectors of means and variances of each qubit\"\n",

        "\n",

        "    raw_data = np.array(raw_data)\n",

        "    nc = len(raw_data)  # the number of circuits used to generate the data\n",

        "    nq = len(raw_data[0])  # the number of qubits in each circuit\n",

        "    new_data = np.zeros([nc, 2 * nq])\n",

        "\n",

        "    for k, outcomes in enumerate(raw_data):\n",

        "        means = [np.mean(outcomes[q, :]) for q in range(nq)]\n",

        "        variances = [np.var(outcomes[q, :]) for q in range(nq)]\n",

        "        new_data[k] = np.array(means + variances)\n",

        "\n",

        "    return new_data\n",

        "\n",

        "\n",

        "data = process_data(raw_data)"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "GWRIxXZcpGsb"

      },

      "source": [

        "Now we use scikit-learn's [kernel\n",

        "PCA](https://en.wikipedia.org/wiki/Kernel_principal_component_analysis)\n",

        "package to try and cluster the data. This performs principal component\n",

        "analysis in a high dimensional feature space defined by a kernel (below\n",

        "we use the radial basis function kernel).\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 120,

      "metadata": {

        "id": "3r7XYPtspGsb"

      },

      "outputs": [],

      "source": [

        "from sklearn.decomposition import KernelPCA\n",

        "from sklearn import preprocessing\n",

        "\n",

        "kernel_pca = KernelPCA(\n",

        "    n_components=None, kernel=\"rbf\", gamma=None, fit_inverse_transform=True, alpha=0.1\n",

        ")\n",

        "\n",

        "# rescale the data so it has unit standard deviation and zero mean.\n",

        "scaler = preprocessing.StandardScaler().fit(data)\n",

        "data = scaler.transform(data)\n",

        "# try to cluster the data\n",

        "fit = kernel_pca.fit(data).transform(data)"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "Ebvo16Y5pGsb"

      },

      "source": [

        "Let's plot the result. Here we look at the first two principal\n",

        "components.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 121,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 430

        },

        "id": "MVbFwU-LpGsc",

        "outputId": "2d7d6ac7-3af6-486f-d607-4704a86aeec2"

      },

      "outputs": [

        {

          "output_type": "display_data",

          "data": {

            "text/plain": [

              "<Figure size 640x480 with 1 Axes>"

            ],

            "image/png": "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\n"

          },

          "metadata": {}

        }

      ],

      "source": [

        "import matplotlib.pyplot as plt\n",

        "\n",

        "# make a colour map for the points\n",

        "c = np.array([0 for __ in range(circuits)] + [1 for __ in range(circuits)])\n",

        "\n",

        "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n",

        "plt.show()"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "SlrsWm7ZpGsc"

      },

      "source": [

        "Looks like the algorithm failed to cluster the data. We can try to get a\n",

        "separation by increasing the number of shots. Let's increase the number\n",

        "of shots by 100 and see what happens.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 122,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 430

        },

        "id": "tfVK7J8OpGsc",

        "outputId": "05f9bade-0d2f-4fa0-f85b-2ac50ea95182"

      },

      "outputs": [

        {

          "output_type": "display_data",

          "data": {

            "text/plain": [

              "<Figure size 640x480 with 1 Axes>"

            ],

            "image/png": "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\n"

          },

          "metadata": {}

        }

      ],

      "source": [

        "n_shots = 10000  # 100 x more shots\n",

        "\n",

        "raw_data = []\n",

        "\n",

        "for ts in [True, False]:\n",

        "    for __ in range(circuits):\n",

        "        circuit = generate_circuit(n_shots)\n",

        "        raw_data.append(circuit(ts=ts))\n",

        "\n",

        "data = process_data(raw_data)\n",

        "scaler = preprocessing.StandardScaler().fit(data)\n",

        "data = scaler.transform(data)\n",

        "\n",

        "fit = kernel_pca.fit(data).transform(data)\n",

        "\n",

        "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n",

        "plt.show()"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "n2F2k_CRpGsc"

      },

      "source": [

        "Now we have a separation, however we required a lot of shots from the\n",

        "quantum circuit. As we increase the number of qubits, the number of\n",

        "shots we need will scale exponentially (as shown in [\\[2\\]](#ref2)), and\n",

        "so conventional strategies cannot learn to separate the data\n",

        "efficiently.\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "aLJp5ud_pGsc"

      },

      "source": [

        "The quantum-enhanced way\n",

        "========================\n",

        "\n",

        "Now let's see what difference having a quantum memory can make. Instead\n",

        "of using a single unitary to generate measurement data, we will make use\n",

        "of twice the number of qubits, and apply the unitary twice:\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "jSO6utq0pGsc"

      },

      "source": [

        "![](../demonstrations/learning_from_experiments/fig3b.png){.align-center\n",

        "width=\"70.0%\"}\n"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "UNE5n_sGpGsc"

      },

      "source": [

        "In practice, this could be done by storing the output state from the\n",

        "first unitary in quantum memory and preparing the same state by using\n",

        "the unitary again. Let's define a function `enhanced_circuit()` to\n",

        "implement that. Note that since we now have twice as many qubits, we use\n",

        "half the number of shots as before so that the total number of uses of\n",

        "the unitary is unchanged.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 123,

      "metadata": {

        "id": "jpZYLZkzpGsc"

      },

      "outputs": [],

      "source": [

        "n_shots = 50\n",

        "qubits = 8\n",

        "\n",

        "dev = qml.device(\"default.qubit\", wires=qubits * 2, shots=n_shots)\n",

        "\n",

        "\n",

        "@qml.qnode(dev)\n",

        "def enhanced_circuit(ts=False):\n",

        "    \"implement the enhanced circuit, using a random unitary\"\n",

        "\n",

        "    if ts == True:\n",

        "        ops = [qml.RY]\n",

        "    else:\n",

        "        ops = [qml.RX, qml.RY, qml.RZ]\n",

        "\n",

        "    weights = np.random.rand(layers, n_shots) * np.pi\n",

        "    seed = np.random.randint(0, 10000)\n",

        "\n",

        "    for q in range(qubits):\n",

        "        qml.Hadamard(wires=q)\n",

        "\n",

        "    qml.broadcast(\n",

        "        qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)\n",

        "    )\n",

        "    RandomLayers(weights, wires=range(0, qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n",

        "    RandomLayers(weights, wires=range(qubits, 2 * qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n",

        "    qml.broadcast(\n",

        "        qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)\n",

        "    )\n",

        "\n",

        "    for q in range(qubits):\n",

        "        qml.Hadamard(wires=q)\n",

        "\n",

        "    return [qml.sample(op=qml.PauliZ(q)) for q in range(2 * qubits)]"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "EgGQFWO6pGsc"

      },

      "source": [

        "Now we generate some raw measurement data, and calculate the mean and\n",

        "variance of each qubit as before. Our data vectors are now twice as long\n",

        "since we have twice the number of qubits.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 124,

      "metadata": {

        "id": "PeJwszSvpGsd"

      },

      "outputs": [],

      "source": [

        "raw_data = []\n",

        "\n",

        "for ts in [True, False]:\n",

        "    for __ in range(circuits):\n",

        "        raw_data.append(enhanced_circuit(ts))\n",

        "\n",

        "data = process_data(raw_data)"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "6BhOJM0XpGsd"

      },

      "source": [

        "Let's throw that into Kernel PCA again and plot the result.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 125,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 430

        },

        "id": "PoL0WA_ypGsd",

        "outputId": "1b570573-fd7e-47c4-cbdd-dfe597720b91"

      },

      "outputs": [

        {

          "output_type": "display_data",

          "data": {

            "text/plain": [

              "<Figure size 640x480 with 1 Axes>"

            ],

            "image/png": "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\n"

          },

          "metadata": {}

        }

      ],

      "source": [

        "kernel_pca = KernelPCA(\n",

        "    n_components=None, kernel=\"rbf\", gamma=None, fit_inverse_transform=True, alpha=0.1\n",

        ")\n",

        "\n",

        "scaler = preprocessing.StandardScaler().fit(data)\n",

        "data = scaler.transform(data)\n",

        "\n",

        "fit = kernel_pca.fit(data).transform(data)\n",

        "\n",

        "c = np.array([0 for __ in range(circuits)] + [1 for __ in range(circuits)])\n",

        "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n",

        "plt.show()"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "Ylz4xQPupGsd"

      },

      "source": [

        "Kernel PCA has perfectly separated the two classes! In fact, all the\n",

        "T-symmetric unitaries have been mapped to the same point. This is\n",

        "because the circuit is actually equivalent to performing\n",

        "$U^TU\\otimes \\mathbb{I}\\vert 0 \\rangle$, which for T-symmetric unitaries\n",

        "is just the identity operation.\n",

        "\n",

        "To see this, note that the Hadamard and CNOT gates before\n",

        "$U_i\\otimes U_i$ map the $\\vert0\\rangle$ state to the maximally entanged\n",

        "state\n",

        "$\\vert \\Phi^+\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 00...0\\rangle+ \\vert11...1\\rangle$,\n",

        "and the gates after $U_i\\otimes U_i$ are just the inverse\n",

        "transformation. The probability that all measurement outcomes give the\n",

        "result $+1$ is therefore.\n",

        "\n",

        "$$p(11\\cdots 1) = \\langle \\Phi^+ \\vert U_i \\otimes U_i \\vert\\Phi^+ \\rangle.$$\n",

        "\n",

        "A well known fact about the maximally entanged state is that\n",

        "$U\\otimes \\mathbb{I}\\vert\\Phi^+\\rangle= \\mathbb{I}\\otimes U^T\\vert\\Phi^+\\rangle$.\n",

        "The probabilty is therefore\n",

        "\n",

        "$$p(11\\cdots 1) = \\langle \\Phi^+ \\vert U_i^T U_i \\otimes \\mathbb{I} \\vert\\Phi^+ \\rangle.$$\n",

        "\n",

        "For T-symmetric unitaries $U_i^T=U_i^\\dagger$, so this probability is\n",

        "equal to one: the $11\\cdots 1$ outcome is always obtained.\n",

        "\n",

        "If we look at the raw measurement data for the T-symmetric unitaries:\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 126,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 0

        },

        "id": "tJPkMr8XpGsd",

        "outputId": "49211621-c4b8-4e68-eb57-886fbb840bfd"

      },

      "outputs": [

        {

          "output_type": "execute_result",

          "data": {

            "text/plain": [

              "tensor([[1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1],\n",

              "        [1, 1, 1, 1, 1]], requires_grad=True)"

            ]

          },

          "metadata": {},

          "execution_count": 126

        }

      ],

      "source": [

        "np.array(raw_data[0])[:, 0:5]  # outcomes of first 5 shots of the first T-symmetric circuit"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "RCbeEgB9pGsd"

      },

      "source": [

        "We see that indeed this is the only measurement outcome.\n",

        "\n",

        "To make things a bit more interesting, let's add some noise to the\n",

        "circuit. We will define a function `noise_layer(epsilon)` that adds some\n",

        "random single qubit rotations, where the maximum rotation angle is\n",

        "`epsilon`.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 127,

      "metadata": {

        "id": "oj_9u5_ipGsd"

      },

      "outputs": [],

      "source": [

        "def noise_layer(epsilon):\n",

        "    \"apply a random rotation to each qubit\"\n",

        "    for q in range(2 * qubits):\n",

        "        angles = (2 * np.random.rand(3) - 1) * epsilon\n",

        "        qml.Rot(angles[0], angles[1], angles[2], wires=q)"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "R1FYa3ltpGse"

      },

      "source": [

        "We redefine our `enhanced_circuit()` function with a noise layer applied\n",

        "after the unitaries\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 128,

      "metadata": {

        "id": "dFNylIKDpGse"

      },

      "outputs": [],

      "source": [

        "@qml.qnode(dev)\n",

        "def enhanced_circuit(ts=False):\n",

        "    \"implement the enhanced circuit, using a random unitary with a noise layer\"\n",

        "\n",

        "    if ts == True:\n",

        "        ops = [qml.RY]\n",

        "    else:\n",

        "        ops = [qml.RX, qml.RY, qml.RZ]\n",

        "\n",

        "    weights = np.random.rand(layers, n_shots) * np.pi\n",

        "    seed = np.random.randint(0, 10000)\n",

        "\n",

        "    for q in range(qubits):\n",

        "        qml.Hadamard(wires=q)\n",

        "\n",

        "    qml.broadcast(\n",

        "        qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)\n",

        "    )\n",

        "    RandomLayers(weights, wires=range(0, qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n",

        "    RandomLayers(weights, wires=range(qubits, 2 * qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n",

        "    noise_layer(np.pi / 4)  # added noise layer\n",

        "    qml.broadcast(\n",

        "        qml.CNOT, pattern=[[qubits + q, q] for q in range(qubits)], wires=range(qubits * 2)\n",

        "    )\n",

        "\n",

        "    for q in range(qubits):\n",

        "        qml.Hadamard(wires=qubits + q)\n",

        "\n",

        "    return [qml.sample(op=qml.PauliZ(q)) for q in range(2 * qubits)]"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "oke1LvWDpGse"

      },

      "source": [

        "Now we generate the data and feed it to kernel PCA again.\n"

      ]

    },

    {

      "cell_type": "code",

      "execution_count": 129,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 430

        },

        "id": "NnBgZF7TpGse",

        "outputId": "72dcde16-77b8-428d-a888-b071273f12ad"

      },

      "outputs": [

        {

          "output_type": "display_data",

          "data": {

            "text/plain": [

              "<Figure size 640x480 with 1 Axes>"

            ],

            "image/png": "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\n"

          },

          "metadata": {}

        }

      ],

      "source": [

        "raw_data = []\n",

        "\n",

        "for ts in [True, False]:\n",

        "    for __ in range(circuits):\n",

        "        raw_data.append(enhanced_circuit(ts))\n",

        "\n",

        "data = process_data(raw_data)\n",

        "\n",

        "kernel_pca = KernelPCA(\n",

        "    n_components=None, kernel=\"rbf\", gamma=None, fit_inverse_transform=True, alpha=0.1\n",

        ")\n",

        "scaler = preprocessing.StandardScaler().fit(data)\n",

        "data = scaler.transform(data)\n",

        "fit = kernel_pca.fit(data).transform(data)\n",

        "\n",

        "c = np.array([0 for __ in range(circuits)] + [1 for __ in range(circuits)])\n",

        "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n",

        "plt.show()"

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "dQHy4Y0ZpGse"

      },

      "source": [

        "Nice! Even in the presence of noise we still have a clean separation of\n",

        "the two classes. This shows that using entanglement can make a big\n",

        "difference to learning.\n"

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "seconds = time.time()\n",

        "print(\"Time in seconds since end of run:\", seconds)\n",

        "local_time = time.ctime(seconds)\n",

        "print(local_time)"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 0

        },

        "id": "znxK-ted5Yae",

        "outputId": "1070eff6-9026-4f8b-88ee-1f5bb4e9d6f8"

      },

      "execution_count": 130,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "Time in seconds since end of run: 1693257506.7590938\n",

            "Mon Aug 28 21:18:26 2023\n"

          ]

        }

      ]

    },

    {

      "cell_type": "markdown",

      "metadata": {

        "id": "QNYu0GLrpGse"

      },

      "source": [

        "References\n",

        "==========\n",

        "\n",

        "\\[1\\] *Quantum advantage in learning from experiments*, Hsin-Yuan Huang\n",

        "et. al., [arxiv:2112.00778](https://arxiv.org/pdf/2112.00778.pdf) (2021)\n",

        "\n",

        "\\[2\\] *Exponential separations between learning with and without quantum\n",

        "memory*, Sitan Chen, Jordan Cotler, Hsin-Yuan Huang, Jerry Li,\n",

        "[arxiv:2111.05881](https://arxiv.org/abs/2111.05881) (2021)\n",

        "\n",

        "About the author\n",

        "================\n"

      ]

    }

  ],

  "metadata": {

    "kernelspec": {

      "display_name": "Python 3",

      "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.9.17"

    },

    "colab": {

      "provenance": []

    }

  },

  "nbformat": 4,

  "nbformat_minor": 0

}