{

  "cells": [

    {

      "cell_type": "code",

      "execution_count": 19,

      "metadata": {

        "id": "saZVT5NBpGsV",

        "colab": {

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

          "height": 0

        },

        "outputId": "45472146-4257-4c48-c627-b86085093472"

      },

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

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

            "Mon Nov 20 17:55:44 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 pennylane-lightning-gpu custatevec-cu11 --upgrade\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": 20,

      "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": 21,

      "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(\"lightning.gpu\", 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": 22,

      "metadata": {

        "colab": {

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

          "height": 0

        },

        "id": "PDxmRpoDpGsa",

        "outputId": "04cf423b-ba91-4beb-b0bb-112972def1b4"

      },

      "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": 23,

      "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": 24,

      "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": 25,

      "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": 26,

      "metadata": {

        "colab": {

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

          "height": 430

        },

        "id": "MVbFwU-LpGsc",

        "outputId": "60e4f0e0-34d6-46e5-bf60-6867d7de593b"

      },

      "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": 27,

      "metadata": {

        "colab": {

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

          "height": 430

        },

        "id": "tfVK7J8OpGsc",

        "outputId": "87c7dc8f-0a62-46a7-8a6a-54b8b47ec20f"

      },

      "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": 28,

      "metadata": {

        "id": "jpZYLZkzpGsc"

      },

      "outputs": [],

      "source": [

        "n_shots = 50\n",

        "qubits = 8\n",

        "\n",

        "dev = qml.device(\"lightning.gpu\", 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": 29,

      "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": 30,

      "metadata": {

        "colab": {

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

          "height": 430

        },

        "id": "PoL0WA_ypGsd",

        "outputId": "eab8b7d6-d973-4af8-8cfa-59263a53f331"

      },

      "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": 31,

      "metadata": {

        "colab": {

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

          "height": 0

        },

        "id": "tJPkMr8XpGsd",

        "outputId": "12b29b76-e6a9-4e83-c8b8-286845d6dc6a"

      },

      "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": 31

        }

      ],

      "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": 32,

      "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": 33,

      "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": 34,

      "metadata": {

        "colab": {

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

          "height": 430

        },

        "id": "NnBgZF7TpGse",

        "outputId": "5c7b82ce-4053-497c-c3bb-40b8a12a1ee1"

      },

      "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": "3edf565a-425e-44d9-a441-ec1df50fc6c0"

      },

      "execution_count": 35,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

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

            "Mon Nov 20 17:56:19 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",

      "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": [],

      "gpuType": "V100"

    },

    "accelerator": "GPU"

  },

  "nbformat": 4,

  "nbformat_minor": 0

}