{ "cells": [ { "cell_type": "markdown", "id": "caeb98e4", "metadata": {}, "source": [ "# Expressibility of Quantum Neural Network\n", "\n", "Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." ] }, { "cell_type": "markdown", "id": "e2ca4dd8", "metadata": {}, "source": [ "## Overview" ] }, { "cell_type": "markdown", "id": "64692af7", "metadata": {}, "source": [ "In quantum machine learning, the **expressibility** of quantum neural networks is a crucial factor in quantum machine learning tasks. In general, the stronger the expressiveness of the proposed quantum neural network, the higher the likelihood that quantum machine learning can search for the global optimal solution. This tutorial first introduces the basic concept of the expressibility of quantum neural networks. Then we will show how to exhibit the difference in the expressibility of different ansatz through Bloch spheres in Paddle Quantum. Finally, a method for quantitatively analyzing the expressibility of quantum neural networks is introduced, and the expressibility of quantum neural network templates provided by Paddle Quantum is evaluated at different depths." ] }, { "cell_type": "markdown", "id": "482a9afe", "metadata": {}, "source": [ "## Background" ] }, { "cell_type": "markdown", "id": "1ddbe430", "metadata": {}, "source": [ "Let us first review the basic process of quantum machine learning algorithms. In quantum machine learning, we tend to design a loss function $\\mathcal{L}$ and minimize the loss function by optimizing a unitary $U$\n", "\n", "$$\n", "\\min_U\\mathcal{L}(U)=\\min_U \\text{Tr}[HU\\rho_{in}U^\\dagger].\\tag{1}\n", "$$\n", "\n", "The mathematical principle behind the algorithm guarantees that the minimum value that the loss function can take corresponds to the solution of our problem when we have traversed all possible unitaries. In practice, we use quantum neural networks to parameterize the unitaries as follows\n", "\n", "$$\n", "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n", "$$\n", "\n", "where each $U_j(\\vec{\\theta}_j),j\\in[1,D]$ represents a layer of the quantum neural network, and $\\vec{\\theta}_j$ represents the parameters corresponding to that layer. At this point, by adjusting the parameters $\\vec{\\theta}$ in the quantum neural network, we can perform the optimization of the unitary $U$ and thus minimize the loss function $\\mathcal{L}$.\n", "\n", "$$\n", "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{Tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n", "$$\n", "\n", "However, careful readers may have noticed a shortcoming of quantum neural networks at this point: for a given neural network fit, ** traversing all the parameters does not necessarily guarantee traversing all the unitaries**. As a simple example, if we allow only one $R_Y$ rotation gate as a single-qubit quantum neural network $U(\\theta)=R_Y(\\theta)$, it is clear that (up to a global phase) $U(\\theta)$ cannot represent any complex unitary with the imaginary part of matrix elements. And when allowing the use of $R_Y$ and $R_Z$ revolving gates, if we build the quantum neural network as $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$, $U(\\vec{\\theta})$ (up to a global phase) will be able to represent all the single-qubit unitaries [1].\n", "\n", "If we define the expressibility of a neural network as **the number of unitaries that the circuit can express when traversing the circuit parameters $\\vec{\\theta}$**, then a quantum neural network with strong expressibility will be more likely to contain those unitaries that globally minimize the loss function $\\mathcal{L}$; conversely, if a quantum neural network $U_{ weak}$ is so weak that it does not contain any unitary that minimize the loss function, then a quantum machine learning task based on optimizing $U_{weak}$ is likely to fail.\n", "\n", "Next, we visualize the expressibility of quantum neural networks based on Paddle Quantum by looking at the ability of a single qubit to traverse the Bloch sphere through unitaries." ] }, { "cell_type": "markdown", "id": "b8205717", "metadata": {}, "source": [ "## Intuition: traversing the Bloch sphere" ] }, { "cell_type": "markdown", "id": "df8f0a68", "metadata": {}, "source": [ "In the one qubit case, we can directly observe how a quantum neural network traverses the surface of a Bloch sphere with a fixed input. For a given neural network ansatz $U(\\vec{\\theta})$, since the input to the network tends to be fixed (we set it to $|0\\rangle$), by uniformly sampling the neural network parameters $\\vec{\\theta}$, the output state of the neural network $U(\\vec{\\theta})|0\\rangle$ will be scattered over the surface of the Bloch sphere. Obviously, if the output states are more widely and uniformly distributed on the surface of the sphere, the more expressive the neural network ansatz $U$ will be, and the more likely it will contain the global optimum of the loss function.\n", "\n", "To implement this function in Paddle, we first import necessary packages." ] }, { "cell_type": "code", "execution_count": 2, "id": "3810b843", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import paddle\n", "import paddle_quantum as pq\n", "from paddle_quantum.ansatz.circuit import Circuit\n", "from paddle_quantum.visual import plot_state_in_bloch_sphere" ] }, { "cell_type": "markdown", "id": "2dc0318c", "metadata": {}, "source": [ "First, we allow only one $R_Y$ rotation gate to construct quantum neural network $U(\\theta)=R_Y(\\theta)$. By uniformly sampling the parameter $\\theta$ at $[0,2\\pi]$ and acting $U(\\theta)$ on a fixed input $|0\\rangle$, we obtain the output distribution of the quantum neural network $U(\\theta)$. With the built-in plot_bloch_sphere_from_input function of Paddle Quantum, we can directly observe the distribution of $U(\\theta)|0\\rangle$ on the Bloch sphere as follows." ] }, { "cell_type": "code", "execution_count": 4, "id": "8cc9cff3", "metadata": {}, "outputs": [], "source": [ "num_qubit = 1 # the number of qubit\n", "num_sample = 2000 # the number of sample\n", "outputs_y = list() # save QNN outputs\n", "\n", "for _ in range(num_sample):\n", " # initialize QNN ansatz\n", " pq.set_backend('density_matrix')\n", " cir = Circuit(num_qubit)\n", " # apply Ry with a random rotating angle\n", " cir.ry(0)\n", " # output a density operator\n", " rho = cir(pq.state.zero_state(num_qubit))\n", " outputs_y.append(rho)\n", " \n", "# built-in function of Paddle Quantum to plot on Bloch sphere\n", "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')" ] }, { "cell_type": "markdown", "id": "351b12a4", "metadata": {}, "source": [ "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)" ] }, { "cell_type": "markdown", "id": "1bd42a83", "metadata": {}, "source": [ "It can be seen that the output of the quantum neural network $U(\\theta)=R_Y(\\theta)$ can only be distributed in a circle on the Bloch sphere (although the distribution is uniform over the circle). Similarly, we consider the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ with two parameters and the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ with three parameters. The output distribution is:" ] }, { "cell_type": "code", "execution_count": 5, "id": "c0330832", "metadata": {}, "outputs": [], "source": [ "outputs_yz = list() # save QNN outputs\n", "for _ in range(num_sample):\n", " # initialize QNN ansatz\n", " cir = Circuit(num_qubit)\n", " # apply Ry and Rz with random rotating angles\n", " cir.ry(0)\n", " cir.rz(0)\n", " # output a density operator\n", " rho = cir(pq.state.zero_state(num_qubit))\n", " outputs_yz.append(rho)\n", "\n", "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n", "\n", "\n", "outputs_yzy = list() # save QNN outputs\n", "for _ in range(num_sample):\n", " # initialize QNN ansatz\n", " cir = Circuit(num_qubit)\n", " # apply Ry, Rz, and Ry with random rotating angles\n", " cir.ry(0)\n", " cir.rz(0)\n", " cir.ry(0)\n", " # output a density operator\n", " rho = cir(pq.state.zero_state(num_qubit))\n", " outputs_yzy.append(rho)\n", " \n", "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')" ] }, { "cell_type": "markdown", "id": "02877b2a", "metadata": {}, "source": [ "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)" ] }, { "cell_type": "markdown", "id": "377bbcbf", "metadata": {}, "source": [ "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)" ] }, { "cell_type": "markdown", "id": "2213837b", "metadata": {}, "source": [ "It can be seen that the output of the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ can be distributed over the entire surface of the Bloch sphere now, although the distribution is more concentrated near the two polars ($|0\\rangle$ and $|1\\rangle$); and the output of the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ is more uniformly distributed over the surface of the sphere." ] }, { "cell_type": "markdown", "id": "7d225e68", "metadata": {}, "source": [ "In the low-dimensional case of single qubit, we can qualitatively observe the expressibility of quantum neural networks with the help of Bloch spheres. In general situations with multiple qubits, we have to analyze the expressibility quantitatively via statistical mathematical tools. Next, we will introduce the K-L divergence of the fidelity distribution among quantum states to quantify the expressibility of a quantum neural network and calculate the expressibility of a commonly used ansatz." ] }, { "cell_type": "markdown", "id": "5638c30a", "metadata": {}, "source": [ "## Quantitative analysis of expressibility by the K-L divergence" ] }, { "cell_type": "markdown", "id": "f35faa47", "metadata": {}, "source": [ "### Fidelity distribution and the K-L divergence" ] }, { "cell_type": "markdown", "id": "c681b230", "metadata": {}, "source": [ "In [2], the authors proposed a method for quantifying the expressive power based on the probability distribution of fidelity between the output states of a quantum neural network. For any quantum neural network $U(\\vec{\\theta})$, sampling the neural network parameters twice (let them be $\\vec{\\phi}$ and $\\vec{\\psi}$), the fidelity $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi}) |0\\rangle|^2$ subjects to some probability distribution\n", "$$\n", "F\\sim{P}(f).\\tag{4}\n", "$$\n", "According to [2], when a quantum neural network $U$ can uniformly represent unitaries (now we call that $U$ subjects to the Haar measure), the probability distribution of fidelity $P_\\text{Haar}(f)$ satisfies\n", "$$\n", "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n", "$$\n", "\n", "Paddle Quantum provides functions that sample unitaries from the Haar measure. We evaluate the probability distribution that the fidelity of the outputs of the Haar random unitaries subjects to:" ] }, { "cell_type": "code", "execution_count": 6, "id": "409b2dc8", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from paddle_quantum.linalg import haar_unitary\n", "from paddle_quantum.qinfo import state_fidelity\n", "from paddle_quantum.state.common import to_state\n", "import matplotlib.pyplot as plt\n", "from matplotlib.ticker import FuncFormatter\n", "from scipy import integrate\n", "\n", "# plot histgram\n", "def plot_hist(data, num_bin, title_str):\n", " def to_percent(y, position):\n", " return str(np.around(y*100, decimals=2)) + '%'\n", " plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n", " plt.xlabel(\"Fidelity\")\n", " plt.ylabel(\"frequency\")\n", " plt.title(title_str)\n", " formatter = FuncFormatter(to_percent)\n", " plt.gca().yaxis.set_major_formatter(formatter)\n", " plt.show()\n", " \n", " \n", "# evaluate the probability distribution of F generated by a Haar random unitary\n", "def p_F_haar(n, s, b=50, draw=False):\n", " f_list = list()\n", " # sampling\n", " for i in range(s):\n", " # sample a unitary\n", " u1 = haar_unitary(n)\n", " # the output of u1\n", " phi1 = u1[:,0]\n", " rho1 = to_state(np.outer(phi1, phi1.conj()))\n", " # sample a unitary\n", " u2 = haar_unitary(n)\n", " phi2 = u2[:,0]\n", " # the output of u2\n", " rho2 = to_state(np.outer(phi2, phi2.conj()))\n", " # compute fidality\n", " f_list.append(state_fidelity(rho1, rho2)**2)\n", " f_list = np.array(f_list)\n", " # plot histgram\n", " if draw:\n", " title_str = \"haar, %d qubit(s)\" % num_qubit\n", " plot_hist(f_list, b, title_str)\n", " sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", " # compute a theoretical distribution\n", " theory_distribution = np.zeros_like(sample_distribution)\n", " for index in range(len(theory_distribution)):\n", " def p_continues(f):\n", " return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n", " lower = 1/b*index\n", " upper = lower + 1/b\n", " theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n", " return sample_distribution, theory_distribution\n", "\n", "\n", "num_qubit = 1\n", "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", "num_qubit = 2\n", "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)" ] }, { "cell_type": "markdown", "id": "581fe296", "metadata": {}, "source": [ "It can be seen that the fidelity distribution roughly obeys $P_\\text{Haar}$. Similarly, we can compute the probability distributions of the fidelity of the outputs of the previously defined single-qubit quantum neural networks $R_Y(\\theta)$, $R_Y(\\theta_1)R_Z(\\theta_2)$ and $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$." ] }, { "cell_type": "code", "execution_count": 7, "id": "eeb57c55", "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAbk0lEQVR4nO3de5RlZXnn8e9PaNEOKsRuL+mmbS+gISYqdBRkRTEGB4mAFxSMgjqaNqgDZDAOKpdEB2ZpFKORyDSKchNxjJrOpB3jjUEdQJuLyCVqhxCuBgUFCSgN/cwfe7c5FlW1T3XVPlXV9f2sddY6+93v2fvZ55zqp9/LeXeqCkmSJvOg2Q5AkjT3mSwkSZ1MFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAGJLkuyT1J7krywySfSLL9Fhynkvx7e5ybkpycZJstOM7K9lh3tY/rkhwz1eNI02WykB5o/6raHng68Azg7Vt4nKe1x3kucDDwn6cR0w7tsQ4CjkuyzzSOJU2ZyUKaQFX9EPgi8PQkVybZf/O+JIuS/DjJM4Y4zgbgmzTJhyR7DrQU7kry8yTXDRnTeuCqNqbHJLk7ySMH4totyY+SLJrKtUpdTBbSBJIsB14IbADOBF49sHs/4JaqumyI4zwF+L32OFTVhVW1fdtS2BG4GDh3yJj2AJ4KbGiT2fnAKwaqHAp8qqo2DnM8aVhxbSjpP7T/w18CFLA98FXgZcBi4HvAsqq6M8lngG9V1XsnOE4BPwO2aV/7KeC1VfWLMfU+AuwEHFBVm8Y5zkrgX4A7gO2AhwDvB/6sqirJwcARVbVXOyZyU3usb03rjZDGsGUhPdCLq+phwN7AU4AlVXUzTVfSy5LsQNPiOAcgyVUDXUq/N3Cc3WgSzsHAs4BfGzxJkje25/ijzYliTPfUioHqS9pjHd2+ZnM3098BuyZ5PLAPcIeJQn0wWUgTqKr/C3wCeF9bdAZNV9TLgQur6qa23m9t7laqqq+POUZV1aeBC4HjN5e3SeXdwIFVdedA/e0HHtePOdb9VXUy8HPgTW3Zz4FPt3EdCpw1Y2+ANMBuKGlA2w31hqr6cru9FLgOeDbwfeBmmq6e91bVmZMcp4Cd28Ftkvw2cBHwRJpWwbeA11XV/+mIZyVNN9SiqrqvLXsRsAZ4QlX9PMleNGMqjwKeWlX/ukUXL03CloU0iar6Ec0/xMdX1T3A3wKPBz47xeN8F7gA+DPg+cCjgc8MdDldNYXD/QPwE+CP22N/E9gEXGqiUF9sWUhTkOR4YJeqenVn5RFK8lXgk1X10dmORVunbWc7AGm+SPLrwOtpxgbmjCS/SzOYfuBsx6Ktl91Q0hCS/DFwA/CFqrpgtuPZLMkZwJeBo6rqZ7Mdj7ZedkNJkjrZspAkddpqxyyWLFlSK1eunO0wJGneuOSSS35cVUvH27fVJouVK1eyfv362Q5DkuaNJBNOvbYbSpLUyWQhSepkspAkdTJZSJI6mSwkSZ1MFpKkTiYLSVInk4UkqZPJQpLUaav9Bfdc99KXvp7rrrv1AeUrVz6Kz372Y7MQkSRNzGQxS6677laWLfv7ccr3n4VoJGlydkNJkjr1liySPCTJt5J8J8lVSf5inDrbJTkvyYYkF7c3pyfJXkmuSLI+yc5t2Q5J/jGJCU6SRqzPf3h/Afx+VT0NeDqwb5I9xtR5PfCTqnoS8AHgPW350cB+wFHAn7RlxwInVdWmHmOWJI2jt2RRjbvazUXtY+xt+Q4EzmiffwZ4fpIAG4HF7WNjkicCO1XV+X3FK0maWK8D3Em2AS4BngScUlUXj6myjOa+xlTVfUnuAB4J/A/gTOAe4FDgfTQti67zrQZWA6xYsWKGrkKS1Gv/f1XdX1VPB5YDz0zy1CFfd3lV7VFVzwOeANwCpB3fODvJoyd43ZqqWlVVq5YuHfdmT5KkLTCSweKq+inwNWDfMbtuAnYCSLIt8Ajgts072y6pY4F3AycAbwNOA47oPWhJ0i/1ORtqaZId2ucPBfYB/mlMtbXAa9rnBwFfrarBcY3DgHVVdTvN+MWm9rG4r7glSQ/U55jFY4Ez2nGLBwGfrqr/neRdwPqqWgt8DDgryQbgduCQzS9Oshh4LfCCtuhkYB1wL/BHPcYtSRqjt2RRVVcAzxin/PiB5z8HXj7B6+8Gnjew/XXgt2c+UklSF3/gJknq5NpQmtNccPGBZvM98fNYuEwWmtNccPGBZvM98fNYuOyGkiR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjp5W9Up8P7Dkvoy1/99MVlMgfcfltSXuf7vi91QkqROJgtJUqfekkWSnZJ8LcnVSa5KcuQ4dfZOckeSy9vH8W350iTfSHJlkhcP1P+7JL/RV8ySpPH1OWZxH3B0VV2a5GHAJUm+VFVXj6n39ap60ZiyVwKnAp8F1gGfT7I/cFlV3dxjzJKkcfSWLKrqFuCW9vnPklwDLAPGJovxbAQWA9sB9yfZFjgKmBsjPZK0wIxkNlSSlcAzgIvH2b1nku8ANwNvraqrgE+2j9XAfwPeBJxVVXd3nGd1+xpWrFgxY/Fr5sz16YGSxtd7skiyPfC3wFFVdeeY3ZcCj6uqu5LsB3we2Lmq7gD+sH39jsAxwEuSnAbsCLy/qi4ce66qWgOsAVi1alX1dEmahrk+PVDS+HqdDZVkEU2iOKeqPjt2f1XdWVV3tc/XAYuSLBlT7TjgRJpxjG8ArwH+vM+4JUm/qs/ZUAE+BlxTVSdPUOcxbT2SPLON57aB/TsDy6vqfJoxjE1AAQ/tK25J0gP12Q21F3Ao8N0kl7dl7wBWAFTVqcBBwOFJ7gPuAQ6pqsHuoxOBd7bPz6XppjoGOL7HuCVJY/Q5G+obQDrqfBj48CT7XzHw/Fbg2TMWoCRpaP6CW5LUyWQhSepkspAkdTJZSJI6mSwkSZ1MFpKkTiYLSVInb6vao4kWzQO49tp/Zdmy/s6xJQvzucjfcCb7XBfqe3Xttf/Mbrs9cH2vUbwfo/je+rdhsujVRIvmAfzTP+3a6zm2ZGE+F/kbzmSf60J9r+69l1n77ozie+vfht1QkqQhmCwkSZ1MFpKkTiYLSVInk4UkqZOzobRgTHX640T1Z2ras7ZeE313fvjDG3nMY5aP+5q5/r0yWWjBmOr0x4nqz9S0Z229Jvvu7L57v9Pp+2I3lCSpk8lCktTJZCFJ6mSykCR1MllIkjo5G2ocU50yOdGKm3N9KlyfFuq005lafXW+rVg8F031sxjFez6TRv35mSzGMdUpkxOtuDnXp8L1aaFOO52p1Vfn24rFc9FUP4tRvOczadSfn91QkqROvSWLJDsl+VqSq5NcleTIceokyYeSbEhyRZLd2vInJ7mkLduzLds2yZeTLO4rZknS+PpsWdwHHF1VuwJ7AG9OMrYt90Jg5/axGvhIW/5G4EhgP+CtbdnhwNlVdXePMUuSxtHbmEVV3QLc0j7/WZJrgGXA1QPVDgTOrKoCLkqyQ5LHAhuBxe1jY5IdgP2BffuKV5I0sZEMcCdZCTwDuHjMrmXADQPbN7ZlpwBnAtvRtDKOA06qqk0d51lN00JhxYoVMxG6JjGbs0cmmukCW89sHmku6T1ZJNke+FvgqKq6c5jXVNX1wN7t658ELAeuSXIW8GDguKr6/jivWwOsAVi1alXNyAVoQrM5e2SimS6w9czmkeaSXmdDJVlEkyjOqarPjlPlJmCnge3lbdmgE4FjgSOAjwJvA06Y+WglSRPpTBbtrKQ3J9lxKgdOEuBjwDVVdfIE1dYCh7WzovYA7mjHOjYf47nAzVX1A5rxi03twxlRkjRCw3RDHQy8Dvh2kvXAx4F/bAelJ7MXcCjw3SSXt2XvAFYAVNWpwDqaGU8bgLvb8wC/TDbHtueHpnvpnDbmw4eIW5I0QzqTRVVtAN6Z5DjgRcDpwP1JPg58sKpun+B13wDScewC3jzJvn0Gtq8BduuKV5I084Yas0jyO8D7gb+kGYN4OXAn8NX+QpMkzRWdLYsklwA/pRl/OKaqftHuujjJXj3GJo3EKBaCnKkFBuebia57ontRj+L9cOHPLTPMmMXLq+ra8XZU1UtnOB5p5EaxEORMLTA430z23o53L+pRvB8u/LllhumGekP7C2oAkuyY5L/3F5Ikaa4ZJlm8sKp+unmjqn5CM4NJkrRADJMstkmy3eaNJA+lWYZDkrRADDNmcQ7wlXaqLDS/hTijv5AkSXPNML+zeE+SK4Dnt0Xvrqov9huWJGkuGWohwar6AvCFnmPRDHJVVkkzaZjfWbwUeA/wKJpfZIfmB9YP7zk2TYOrskqaScO0LN4L7N8utyFJWoCGmQ31byYKSVrYhmlZrE9yHvB5YPNSH0xwfwpJ0lZomGTxcJrlw18wUFaAyUKSFohhps6+rquONF0LdXG3UVz3RPdKn2/v7dZyHVM1V/42hpkNtQvwEeDRVfXUdrnyA6rK9aE0Yxbq4m6juO6J7pU+397breU6pmqu/G0MM8B9GvB2YCNAVV0BHNJnUJKkuWWYZLG4qr41puy+PoKRJM1NwySLHyd5Is2gNkkOAm7pNSpJ0pwyzGyoNwNrgKckuQn4F+DVvUYlSZpThpkNdS3wB0l+DXhQVf2s/7AkSXPJMLOhjh+zDUBVvaunmNSzqU7FmytT97T1m2wBzLn4fVtIfxvDdEP9+8DzhwAvAlz+Yx6b6lS8uTJ1T1u/yRbAnIvft4X0tzFMN9T7B7eTvA/wfhaStIAMMxtqrMXA8q5KSU5PcmuSKyfYv3eSO5Jc3j6Ob8uXJvlGkiuTvHig/t8l+Y0tiFeSNE3DjFl8l3baLLANsBQYZrziE8CHgTMnqfP1qnrRmLJXAqfSrD21Dvh8kv2By6rq5iHOK0maYcOMWQz+Y34fzZLlnT/Kq6oLkqzcgpg20rRetgPuT7ItcBTgHXskaZYM0w31s4HHPcDDk/z65sc0z79nku8k+UKS32rLPgkcCHwJOAl4E3BWVd09zXNJkrbQMC2LS4GdgJ/Q3FJ1B+D6dl8BT9jCc18KPK6q7kqyH839MnauqjuAPwRIsiNwDPCSJKcBOwLvr6oLxztgktXAaoAVK1ZsYViza6KpeN43e3gLaTqjNCrDJIsvAZ+rqnUASV4IvLiq3jidE1fVnQPP1yX5myRLqurHA9WOA06kGcf4BvAZmrGM/zTBMdfQ/NqcVatW1Xh15rqJpuJ53+zhLaTpjNKoDNMNtcfmRAFQVV8Anj3dEyd5TNpf+CV5ZhvLbQP7dwaWV9X5NGMYm2haMg+d7rklSVMzTMvi5iTHAme3268COmclJTkX2BtYkuRG4ARgEUBVnQocBBye5D6asZBDqmqwNXAi8M72+bk03VTHAL/yi3JJUv+GSRavpPmH/nM0/7O/oC2bVFVNWqeqPkwztXai/a8YeH4rM9CakSRtmWF+wX07cGSSX6uqf++qL0na+nSOWSR5dpKradeDSvK0JH/Te2SSpDljmAHuD9DMProNoKq+Azynz6AkSXPLUGtDVdUNY4ru7yEWSdIcNcwA9w1Jng1UkkXAkbhEuSQtKMO0LP6E5taqy4CbgKe325KkBWLSlkWSbYAPVtWrRhSPJGkOmrRlUVX3A49L8uARxSNJmoOGGbO4FvhmkrUM3GK1qk7uLSpJs2a+3QdbozFhskhyVlUdChxAM332QcDDRhWYpNkx3+6DrdGYrGWxe3sb0+uBvx5RPJKkOWiyZHEq8BXg8cD6gfIwvftYSJLmmQkHuKvqQ1X1m8DHq+oJA4/HV5WJQpIWkM7fWVTV4aMIRJI0dw213IckaWEzWUiSOpksJEmdTBaSpE4mC0lSJ5OFJKmTyUKS1GmYhQQ1B0y0uJsLu2kzvyPqk8linphocTcXdtNmfkfUJ7uhJEmdTBaSpE69JYskpye5NcmVE+xPkg8l2ZDkiiS7teVPTnJJW7ZnW7Ztki8nWdxXvJKkifXZsvgEsO8k+18I7Nw+VgMfacvfCBwJ7Ae8tS07HDi7qu7uJVJJ0qR6G+CuqguSrJykyoHAmVVVwEVJdkjyWGAjsLh9bEyyA7A/kyceSVKPZnM21DLghoHtG9uyU4Azge1oWhnHASdV1aauAyZZTdNKYcWKFTMdryQtWHNugLuqrq+qvatqT+BuYDlwTZKzkpyXZJdJXrumqlZV1aqlS5eOLGZJ2trNZrK4CdhpYHt5WzboROBY4Ajgo8DbgBNGEp0k6ZdmM1msBQ5rZ0XtAdxRVbds3pnkucDNVfUDmvGLTe3DGVGSNGK9jVkkORfYG1iS5EaaFsEigKo6FVhHM+NpA0130+sGXhuaFsXBbdEa4Jw2Xm/zKkkj1udsqFd27C/gzZPs22dg+xpgtxkNUJI0tDk3wC1JmntMFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAkdTJZSJI6mSwkSZ1MFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAkdTJZSJI6mSwkSZ1MFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAkdTJZSJI69Zoskuyb5HtJNiQ5Zpz9r03yoySXt483tOVPTnJJkiuS7NmWbZvky0kW9xmzJOmBtu3rwEm2AU4B9gFuBL6dZG1VXT2m6nlV9ZYxZW8EjgSuAz4IvAw4HDi7qu7uK2ZJ0vj6bFk8E9hQVddW1b3Ap4ADh3ztRmBx+9iYZAdgf+DMPgKVJE2ut5YFsAy4YWD7RuBZ49R7WZLnAN8H/rSqbqBpkZwJbEfTyjgOOKmqNk12wiSrgdUAK1asmPYFSJIasz3A/ffAyqr6HeBLwBkAVXV9Ve1dVXsCdwPLgWuSnJXkvCS7jHewqlpTVauqatXSpUtHdQ2StNXrM1ncBOw0sL28Lfulqrqtqn7Rbn4U2H2c45wIHAsc0dZ5G3DCjEcrSZpQn8ni28DOSR6f5MHAIcDawQpJHjuweQBwzZj9zwVurqof0IxfbGofzoiSpBHqbcyiqu5L8hbgi8A2wOlVdVWSdwHrq2otcESSA4D7gNuB125+fZLQtCgObovWAOe0MR/eV9ySpAfqc4CbqloHrBtTdvzA87cDb5/gtUUz7Xbz9jXAbv1EKkmazGwPcEuS5gGThSSpk8lCktTJZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUqdek0WSfZN8L8mGJMeMs3+7JOe1+y9OsrIt3yvJFUnWJ9m5LdshyT8mMcFJ0oj19g9vkm2AU4AXArsCr0yy65hqrwd+UlVPAj4AvKctPxrYDzgK+JO27FjgpKra1FfMkqTx9fm/9GcCG6rq2qq6F/gUcOCYOgcCZ7TPPwM8P0mAjcDi9rExyROBnarq/B7jlSRNIFXVz4GTg4B9q+oN7fahwLOq6i0Dda5s69zYbv8z8CxgOXAqcA9wKPA+4Liq+kHHOVcDq9vNJwPf28LwlwA/3sLXzlde89ZvoV0veM1T9biqWjrejm23PJ7+VNXlwB4ASZ4D3NI8zXk0rY6jq+rfxnndGmDNdM+fZH1VrZruceYTr3nrt9CuF7zmmdRnN9RNwE4D28vbsnHrJNkWeARw2+adbZfUscC7gROAtwGnAUf0FrUk6QH6TBbfBnZO8vgkDwYOAdaOqbMWeE37/CDgq/Wr/WKHAeuq6naa8YtN7WNxj3FLksborRuqqu5L8hbgi8A2wOlVdVWSdwHrq2ot8DHgrCQbgNtpEgoASRYDrwVe0BadDKwD7gX+qK+4W9PuypqHvOat30K7XvCaZ0xvA9ySpK2HP3CTJHUyWUiSOi3oZLGly5HMV0Nc739NcnW71MpXkjxuNuKcSV3XPFDvZUkqybyfZjnMNSd5RftZX5Xkk6OOcaYN8d1ekeRrSS5rv9/7zUacMyXJ6UlubX+rNt7+JPlQ+35ckWS3aZ+0qhbkg2bQ/Z+BJwAPBr4D7DqmzpuAU9vnhwDnzXbcPV/v84DF7fPD5/P1DnvNbb2HARcAFwGrZjvuEXzOOwOXATu224+a7bhHcM1rgMPb57sC18123NO85ucAuwFXTrB/P+ALQGh+s3bxdM+5kFsW01mOZD7qvN6q+lpV3d1uXkTz25j5bJjPGJrf8bwH+Pkog+vJMNf8x8ApVfUTgKq6dcQxzrRhrrmAh7fPHwHcPML4ZlxVXUAzg3QiBwJnVuMiYIckj53OORdyslgG3DCwfWNbNm6dqroPuAN45Eiim3nDXO+g19P8z2Q+67zmtnm+U1X9wygD69Ewn/MuwC5JvpnkoiT7jiy6fgxzzX8OvDrJjTRT8P/LaEKbNVP9e+80J5f70OxK8mpgFfDc2Y6lT+1y9yfT/J5nIdmWpitqb5rW4wVJfruqfjqbQfXslcAnqur9Sfak+X3XU8tVrIe2kFsW016OZJ4Z5npJ8gfAO4EDquoXI4qtL13X/DDgqcD5Sa6j6dtdO88HuYf5nG8E1lbVxqr6F+D7NMljvhrmml8PfBqgqi4EHkKz4N7Waqi/96lYyMliJpYjmU86rzfJM4D/SZMo5ns/NnRcc1XdUVVLqmplVa2kGac5oKrWz064M2KY7/XnaVoVJFlC0y117QhjnGnDXPP1wPMBkvwmTbL40UijHK21wGHtrKg9gDuq6pbpHHDBdkPVNJcjmW+GvN6/BLYH/lc7jn99VR0wa0FP05DXvFUZ8pq/CLwgydXA/cCfVdV8bTEPe81HA6cl+VOawe7XzuP/+JHkXJqEv6QdhzkBWARQVafSjMvsB2wA7gZeN+1zzuP3S5I0Igu5G0qSNCSThSSpk8lCktTJZCFJ6mSykCR1MllIU5Dk/iSXDzxWJvl/E9T9RJKDOo73yzpJPppk1/b5O2Y+emnLLdjfWUhb6J6qevqYsmfPxIGr6g0Dm+8ATpqJ40ozwWQhTVOSu6pq+3ZF4r8G9qFZxO3egTq706xDtT3wY5ofhd0y5jjnA2+lWS3goUkuB66iWX779qr6q7beicCtVfXBfq9M+g92Q0lT89CBLqjPjdn3EuDJNPdLOIy2xZFkEU0SOaiqdgdOB06c6ARVdQxtC6aqXtXWP6w91oNoVhI4e2YvS5qcLQtpasbrhtrsOcC5VXU/cHOSr7blT6ZZsPBL7TIq2wBDr9NTVdclua1du+vRwGXzeXkOzU8mC6l/Aa6qqj2ncYyP0iyl/hialoY0UnZDSTPnAuDgJNu0dyV7Xlv+PWBpex8FkixK8lsdx9rYdl9t9jlgX+B3aRbMk0bKloU0cz4H/D5wNc2S2BcCVNW97fTYDyV5BM3f3V/RDF5PZA1wRZJLq+pV7TG+Bvy07eaSRspVZ6V5oB3YvhR4eVX9YLbj0cJjN5Q0x7U/1NsAfMVEodliy0KS1MmWhSSpk8lCktTJZCFJ6mSykCR1MllIkjr9fwNfMc0aH2qZAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# evaluate the probability distribution of F generated by QNNs\n", "def p_F_qnn(n, s, g, b=50, draw=False):\n", " f_list = list()\n", " rho_sample = outputs_y\n", " title_str = \"Ry\"\n", " if g == 2:\n", " rho_sample = outputs_yz\n", " title_str = \"Ry-Rz\"\n", " elif g == 3:\n", " rho_sample = outputs_yzy\n", " title_str = \"Ry-Rz-Ry\"\n", " # use previously collected data to compute fidelity\n", " for index in range(int(s / 2)):\n", " rho1 = rho_sample[index]\n", " rho2 = rho_sample[index+int(num_sample / 2)]\n", " f_list.append(state_fidelity(rho1, rho2)**2)\n", " f_list = np.array(f_list)\n", " # plot histgram\n", " if draw:\n", " plot_hist(f_list, b, title_str)\n", " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", " return distribution\n", " \n", " \n", "num_qubit = 1\n", "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n", "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n", "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)" ] }, { "cell_type": "markdown", "id": "d204622b", "metadata": {}, "source": [ "Evidently, the fidelity distribution of the outputs of the neural network composed of $R_Y-R_Z-R_Y$ gates is closest to that of the Haar random unitary. The K-L divergence (also called relative entropy) in statistical mathematics can measure the difference between two probability distributions. The K-L divergence between two discrete probability distributions $P,Q$ is defined as\n", "$$\n", "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n", "$$\n", "If the fidelity distribution of the outputs of a quantum neural network is denoted as $P_\\text{QNN}(f)$, the expressibility of the quantum neural network is defined as the K-L divergence between $P_\\text{QNN}(f)$ and $P_\\text{Haar}(f)$ [2]\n", "$$\n", "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n", "$$\n", "Therefore, the closer $P_\\text{QNN}(f)$ is to $P_\\text{Haar}(f)$, the smaller the $\\text{Expr}$ will be (more close to 0), and the more expressive the quantum neural network will be; conversely, the larger the $\\text{Expr}$ is, the less expressive the quantum neural network will be.\n", "\n", "We can directly calculate the expressibility of single-qubit quantum neural networks $R_Y(\\theta)$, $R_Y(\\theta_1)R_Z(\\theta_2)$ and $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ according to this definition." ] }, { "cell_type": "code", "execution_count": 8, "id": "cc1bb1b3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The expressiblity of Ry, Ry-Rz, and Ry-Rz-Rz are 0.21, 0.05, and 0.02, respectively.\n" ] } ], "source": [ "from scipy.stats import entropy\n", "# calcutale relative entropy (K-L divergence)\n", "expr_y = entropy(p_y, theory_haar_1qubit)\n", "expr_yz = entropy(p_yz, theory_haar_1qubit)\n", "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n", "print(\"The expressiblity of Ry, Ry-Rz, and Ry-Rz-Rz are %.2f, %.2f, and %.2f, respectively.\" %(expr_y, expr_yz, expr_yzy))" ] }, { "cell_type": "markdown", "id": "6c781089", "metadata": {}, "source": [ "### Evaluate the expressibility of QNNs" ] }, { "cell_type": "markdown", "id": "c35a6791", "metadata": {}, "source": [ "We now have our tool, the K-L divergence, to quantitatively study the expressibility of any quantum neural network ansatz. As a practical application, let us explore the variation of the expressibility of a Paddle Quantum QNN tamplate with different circuit depth. Here we set the width of the circuit to 4-qubit." ] }, { "cell_type": "code", "execution_count": 10, "id": "17d5b27b", "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "F generated by a Haar random unitaty：\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "sampling QNNs with depth 1...\n", " sampling 0-th sample...\n", " sampling 400-th sample...\n", " sampling 800-th sample...\n", " sampling 1200-th sample...\n", " sampling 1600-th sample...\n", " sample finished\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "sampling QNNs with depth 2...\n", " sampling 0-th sample...\n", " sampling 400-th sample...\n", " sampling 800-th sample...\n", " sampling 1200-th sample...\n", " sampling 1600-th sample...\n", " sample finished\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAgvUlEQVR4nO3deZwcVb338c+XJCxhxwSEIWFQFkUvS4gExasoOwpRRDZlUZBdgQcXVBQuXHhQWb0iGCAPBBDRS8CgQchluVwVkBCQHYE4QEIgrAFFbwj5PX+cM1DpdM9UKtPT6cz3/Xr1a6pOnar6nZme/nWdU4siAjMzsyqWaXUAZmbWvpxEzMysMicRMzOrzEnEzMwqcxIxM7PKnETMzKwyJxHrF5Juk3RIq+NolcVpf0/rSjpZ0hWLF13rSQpJG7Ro3ztJuq5EvbMkHdEPIbUVJxEbkCRtK2lGq+NYWkk6UNI9kl6TNEPSDyUNbnVcDZwGnFGi3pnAdyQt2+R42oqTiJktkpLJYChwLDAMGANsB3y9iWEtMkmDJH0IWDUi7uytfkTMAh4Fdm96cG3ESWQAkDRC0kRJL0h6SdJPcvkykk6U9JSk2ZImSFo1L+vMXQxfkvSMpFckHS7pQ5Lul/Rq93Zy/YMk/UHSTyTNkfSopO16iOnLkh7J271R0nq5/FuS7ur+oJJ0hKSHJC3fYDuflnRfjuePkjYtLOuS9PUc7xxJV0taXtKKwA3AOpL+ll/rSNpK0h15W7NyW5YtbC/y7+DxXOd8ScrLBuXujhcl/VXS0bl+3Q/cRu3Py3bIv785+XesEn/m7nV/Jem5vO7tkj6Qyz8k6XlJgwp195D05zy9jKQTJD2Z3yO/lLRGXtb9XjhY0tPALb3FEREXRMT/RMTciJgJXAlsU7INn5J0bz6KeUbSyYVlv5X01Zr690v6bJ5+n6Qpkl6W9JikvQr1LpV0gaTJkv4OfALYBfjvQh1JOif/P7wm6QFJHyzs7jbgU2XaMWBEhF9L8QsYBPwZOAdYEVge+Ghe9mXgCeA9wErARODyvKwTCODCvM6OwD+B64A1gQ5gNvDxXP8gYB5wHDAE2BuYA6yRl98GHJKnx+b9vh8YDJwI/DEvWwa4HTgZ2BB4BdiiQdu2yDGMye08EOgClsvLu4A/AesAawCPAIfnZdsCM2q2tyWwdY6pM9c/trA8gN8AqwEjgReAnfOyw4GHgXWB1YH/yvUHL2L7hwGvA3vm3+Nx+fd6SIPfwcnAFYX5LwMrA8sB5wL3FZY9DOxSmL8WOD5PHwPcmeNfDvgZcFXNe2EC6T20QoX34XXAGT0sD2CDwt/mX/J7YVPgeeAzedlewF2F9TYDXgKWzbE9A3wp/163AF4ENsl1LyW9J7fJ214e+BXwjcL2dgLuyX9j5b/R2oXlewDTWv1/vSS9Wh6AX03+A8OH84fd4DrLbgaOLMxvDLzJOx+iAXQUlr8E7F2Yv4b8IUtKIs8CKiz/E7B/ni5+iN4AHFyotwzwBrBenu8EXiZ9iH+7h7ZdAJxaU/YY7yS2LuCLhWU/BC7M09tSk0TqbP9Y4NrCfJATcJ7/JXBCnr4FOKywbHsaJ5GG7QcOAO4sLBMwg5JJpGbZajmGVfP8t4Ar8/QaeZ9r5/lHgO0K665d573wnorvwS/nNgzroc7bSaTOsnOBc/L08qQvFhvm+TOBn+bpvYH/qVn3Z8BJefpSYELN8inkLxZ5/pPAX0hfJpapE8sOwPTF/b9cml7uzlr6jQCeioh5dZatAzxVmH+K9KGxVqHs+cL0P+rMr1SYnxn5P62wvXXq7Hc94LzcJfQqKWGIdHRDRHQBt5I+vM5v0K7u7RzfvZ28rRE1+3yuMP1GTbwLkLSRpN/k7qDXgNNJRwZFjba3DulbcLfidL24G7V/ge3k32dP2yrGP0jSGblL6jVSEqXQhiuA3XJ33l6kD9xZhZiuLcT0CPAWC74XSsVRE9NngP9LOgJ6seQ6YyTdqtT9Ood0lDcMICL+CVwNfFHSMsC+wOWFNoypeT98AXh3D214hXTkRt7+LcBPSO+72ZLGSVqlUH9l4NUy7RgonESWfs8AIxv0zT9L+sfrNpLUdfJ8nbpldHSPERS292yDmA6LiNUKrxUi4o+Q+sRJR1A3Az/qYX/PAKfVbGdoRFxVItZ6t6++gDRwumFErAJ8h/LjEbNIXUHdRvQSd6P2zyqum3+fPW2raD9SV9n2wKqkJAy5DZHGJu4gdcnszzsfvt0x7VIT0/J5nW6LdMtvSTsDFwG7RcQDi7Dqz4FJwIiIWJXUpVr8O1xGSg7bAW9ExB2FNvx3TRtWiojiabm1bbgf2KhYEBE/jogtgU3ysm8UFr+f1D1smZPI0u9PpA+mMyStmAeWuwc4rwKOk7S+pJVI37yvbnDUUsaawNckDZH0edI/3OQ69S4Evl0Y9F0110fSMOBi4BDSGMduknZtsL+LgMPzN1fl9n1K0soN6hc9D7xL+USCbGXgNeBvkt4HLMo1Ab8EjpHUIWk1UtdRIw3bD/wW+EAe9B4MfI0Fv0n3ZGXgf0ndjkNJf89aE4BvksYcJtbEdJreOcFhuKSxPe1M6cSFgxos+yRpMP1zEfGnkvEX2/FyRPxT0lak5Pi2nDTmA2exYCL8DbCRpP3ze3BIPqHg/T3sazLw8ULcH8rvpyHA30njgPML9T9O6o60zElkKRcRbwG7ARsAT5P6pvfOi8eT/glvB/5K+of5ap3NlHUXaTD8RdK593tGxEt1YroW+AHwi9zt8iDpLBmAccCvI2JyXvdg4GJJ76qznanAV0jdD6+QBqsPKhNoRDxKSqLTc9fHOqRTUPcjDWxfROo2Kesi4CbSN9t7SR9O80hdQrX7btj+3OXzedJ1Cy+Rfp9/KBnDBFIX4kzSIHq901avJXddRcQbhfLzSN/+b5L0el53TKMdKZ219q4G+wD4HuloaLLeOQOu7IfvkcApOY7vkxJ0rQmkRPj2hZYR8TrpBJB9SEfAz5F+z8s12lFETAPmSOpu6yqkv+UrpN/lS+SjYUlrk45OrivZjgFBC3Zhm1WTv5EeEhEfbXUsSwJJu5AG8dfrtXI/k/QkqTvtvxZjGx8FjoqIffsuskXa/wHAoX3xfpO0I+kEk8/0Uu8s4MmI+Oni7nNpsqReQWrWViStQLru4CbSYPRJpG/9SxRJnyONC/R6rUdPIuL3wO/7JKhFJGko6WilTz7MI+Im0t+tt3rH98X+ljbuzjLrGwL+jdQNci/p7KbvtzSiGpJuI508cFREzO+l+hJJ0k6kU9afJw3AW4u5O8vMzCrzkYiZmVU24MZEhg0bFp2dna0Ow8ysrdxzzz0vRsTw2vIBl0Q6OzuZOnVqq8MwM2srkp6qV+7uLDMzq8xJxMzMKnMSMTOzypxEzMysMicRMzOrzEnEzMwqa1oSUXqu962SHlZ6RvYxufxkSTOVnot9X6PbfEvaWekZyU9IOqFQfqXSM5VPL5SdmB9+Y2Zm/aiZ14nMIz2/eVp+vsM9kqbkZedExJmNVpQ0iPRksR1Ity6/W9KkHO8/ImJTSVPysyCGAmMi4t+b2BYzM6ujaUciETEr36u/+z7/j5Aff1rCVsATETE9IuYCvyA9se1NYIX8WMwhpGc1nEK6Y6qZmfWzfrliXVInsAXpoUXbAEfn5wFMJR2tvFKzSgcLPgt5Bulo4xFJLwDTSA9T2gBYpjtZNdseexxMV9fshco7O9dk4sRL+iMEM7MlStOTSH7s6jXAsRHxmqQLgFNJzzQ4lfSIyy+X3V5EHFvY9vXAYZK+C2wGTImIi+rEcChwKMDIkSMrt6WrazYdHdfXKd+t8jbNzNpZU8/Oys8pvga4MiImAkTE8xHxVn6ewUWkrqtaM4ERhfl1c1lx22OBe4CVgPdGxF7AnvmBNQuIiHERMToiRg8fvtD9w8zMrKJmnp0l4BLgkYg4u1C+dqHaZ0nPl651N7ChpPXzs5z3IT3/uXsbQ4BjgR8CK5COagAGAcv2YTPMzKwHzezO2gbYH3hA0n257DvAvpI2J33wdwGHAUhaB7g4InaNiHmSjgZuJCWG8RHxUGHbRwGXRcQbku4Hhkp6AJgcEa82sU1mZlbQtCSSn8GsOosmN6j/LLBrYX5yD3XPLUwHsO/ixGpmZtX4inUzM6vMScTMzCpzEjEzs8qcRMzMrDInETMzq8xJxMzMKnMSMTOzypxEzMysMicRMzOrzEnEzMwqcxIxM7PKnETMzKwyJxEzM6vMScTMzCpzEjEzs8qcRMzMrDInETMzq8xJxMzMKnMSMTOzypxEzMysMicRMzOrzEnEzMwqcxIxM7PKnETMzKwyJxEzM6vMScTMzCpzEjEzs8qcRMzMrDInETMzq8xJxMzMKnMSMTOzypxEzMysMicRMzOrrGlJRNIISbdKeljSQ5KOyeVrSJoi6fH8c/UG6x+Y6zwu6cBctpyk30l6UNKRhbrjJI1qVlvMzKy+Zh6JzAOOj4hNgK2BoyRtApwA3BwRGwI35/kFSFoDOAkYA2wFnJSTzU7A74FNgf1z3c2AQRExrYltMTOzOgY3a8MRMQuYladfl/QI0AGMBbbN1S4DbgO+VbP6TsCUiHgZQNIUYGfgVWAoMARQrnsqcHiTmlHK9OlPMmrUbguVd3auycSJl7QgIjOz/tG0JFIkqRPYArgLWCsnGIDngLXqrNIBPFOYn5HLfkU6ArkT+JGk3YFpEfFsL/s/FDgUYOTIkdUb0sDcudDRcf1C5V1dCycWM7OlSdOTiKSVgGuAYyPiNUlvL4uIkBRltxUR84D98naHADcCYyWdDYwEJkTEpDrrjQPGAYwePbr0/szMrGdNPTsrf9BfA1wZERNz8fOS1s7L1wZm11l1JjCiML9uLis6EphAGm+ZA+wNHN930ZuZWW+aeXaWgEuARyLi7MKiScCBefpA4Nd1Vr8R2FHS6nlAfcdc1r3t1YFPk5LIUGA+EMAKfd0OMzNrrJlHItuQxi8+Kem+/NoVOAPYQdLjwPZ5HkmjJV0MkAfUTwXuzq9TugfZs+8Dp0XEfFJy+VfgAeDyJrbHzMxqNPPsrN/zzhlUtbarU38qcEhhfjwwvsG2jytM/5N0pGJmZv3MV6ybmVllTiJmZlaZk4iZmVXmJGJmZpU5iZiZWWVOImZmVpmTiJmZVeYkYmZmlTmJmJlZZU4iZmZWmZOImZlV5iRiZmaVOYmYmVllTiJmZlaZk4iZmVXmJGJmZpU5iZiZWWVOImZmVpmTiJmZVeYkYmZmlTmJmJlZZU4iZmZWmZOImZlV5iRiZmaVOYmYmVllTiJmZlaZk4iZmVXmJGJmZpX1mkQk3SPpKEmr90dAZmbWPsociewNrAPcLekXknaSpCbHZWZmbaDXJBIRT0TEd4GNgJ8D44GnJP2bpDWaHaCZmS25So2JSNoUOAv4EXAN8HngNeCW5oVmZmZLulJjIsA5wN3AphHxtYi4KyLOAqb3sN54SbMlPVgoO1nSTEn35deuDdbdWdJjkp6QdEKh/EpJ90s6vVB2oqTPlGqtmZn1qcEl6nw+Iuomi4jYo4f1LgV+AkyoKT8nIs5stJKkQcD5wA7ADNJYzKQc6z8iYlNJUyStCgwFxkTEv5doh5mZ9bEy3VmHSFqte0bS6pJ6/dCOiNuBlyvEtBXwRERMj4i5wC+AscCbwAqSlgGGAG8BpwAnVdiHmZn1gTJJZJeIeLV7JiJeAep2Q5V0dO6SGt/gtOEO4JnC/AygIyIeAV4ApgHXAxsAy0TEtN52KOlQSVMlTX3hhRcWI3QzMysqk0QGSVque0bSCsByPdTvyQXAe4HNgVmkwfrSIuLYiNg8j8ecCnxP0ncl/VLSV3pYb1xEjI6I0cOHD68YupmZ1SqTRK4EbpZ0sKSDgSnAZVV2FhHPR8RbETEfuIjUdVVrJjCiML9uLnubpLHAPcBKwHsjYi9gT0lDq8RlZmbV9DqwHhE/kHQ/sF0uOjUibqyyM0lrR8SsPPtZ4ME61e4GNpS0Pil57APsV9jGEOBY4FPAhkDkRYOAZYE3qsRmZmaLrszZWUTEDcANi7JhSVcB2wLDJM0gDYBvK2lz0gd/F3BYrrsOcHFE7BoR8yQdDdxISgzjI+KhwqaPAi6LiDdychsq6QFgcnHsZkkwffqTjBq1W91lnZ1rMnHiJf0ckZlZ3+o1iUjaA/gBsCag/IqIWKWn9SJi3zrFdT81I+JZCoP1ETEZmNyg7rmF6QDq7WeJMHcudHRcX3dZV1f95GJm1k7KHIn8ENgtnx1lZmb2tjID6887gZiZWT1ljkSmSroauA743+7CiJjYrKDMzKw9lEkiq5DOeNqxUBaAk4iZ2QBX5hTfL/VHIGZm1n7K3MV3I0k3d9+NV9Kmkk5sfmhmZrakKzOwfhHwbdINEImI+0kXAJqZ2QBXJokMjYg/1ZTNa0YwZmbWXsokkRclvZd8exFJe5JunmhmZgNcmbOzjgLGAe+TNBP4K/DFpkZlZmZtoczZWdOB7SWtSHp+x+vND8vMzNpBmXtnfb9mHoCIOKVJMZmZWZso053198L08sCnAd8GxczMSnVnLfD0QUlnkm7TbmZmA1yZs7NqDSU9bdDMzAa4MmMiD7Dg0wOHAx4PMTOzUmMiny5MzyPdGt4XG5qZWakkUntK7yrdZ2gBRMTLfRqRmZm1jTJJZBowAniF9Gjc1YCn87IA3tOUyMzMbIlXZmB9CunxuMMi4l2k7q2bImL9iHACMTMbwMociWwdEV/pnomIGyT9sIkxDQjTpz/JqFG7LVTe2bkmEyde0oKIzMwWXZkk8mx+fsgVef4LwLPNC2lgmDsXOjquX6i8q2vhxGJmtqQq0521L+m03mtJj8QdnsvMzGyAK3PF+svAMZJWjIi/91bfzMwGjjKPx/2IpIfJ98uStJmknzY9MjMzW+KV6c46B9gJeAkgIv4MfKyZQZmZWXsode+siHimpuitJsRiZmZtpszZWc9I+ggQkoYAx+BbwZuZGeWORA4nPSK3A5gJbJ7nzcxsgOvxSETSIOC8iPhCP8VjZmZtpMcjkYh4C1hP0rL9FI+ZmbWRMmMi04E/SJpE4VG5EXF206IyM7O20PBIRNLleXJ34De57sqFV48kjZc0W9KDhbI1JE2R9Hj+uXqDdQ/MdR6XdGAuW07S7yQ9KOnIQt1xkkaVaayZmfWtnrqztpS0Dum27/9R59WbS4Gda8pOAG6OiA2Bm/P8AiStAZwEjAG2Ak7KyWYn4PfApsD+ue5mwKCImFYiHjMz62M9dWddSPqgXx+YWigXJZ4jEhG3S+qsKR4LbJunLwNuA75VU2cnYEr3w64kTSElo1dJz3cfkmMAOJV09piZmbVAwyORiPhxRLwf+H8R8Z7Ca3GeI7JWRMzK088Ba9Wp0wEUL26ckcumAJ3AncCPJe0OTIuIXu8oLOlQSVMlTX3hhRcqhm5mZrXK3IDxiGbsOCJCUixC/XnAfgD5oscbgbGSzgZGAhMiYlKDdccB4wBGjx5dep9mZtazUrc96UPPS1obIP+cXafOTNLjeLutm8uKjgQmAFsDc4C9geP7PFozM+tRfyeRScCBefpA4Nd16twI7Chp9TygvmMuAyCXfZqURIYC80ljNCs0MW4zM6ujaUlE0lXAHcDGkmZIOhg4A9hB0uPA9nkeSaMlXQxvP7/kVODu/Dqle5A9+z5wWkTMJyWXfwUeAC7HzMz6VZmLDSuJiEZPP9yuTt2pwCGF+fHA+AbbPa4w/U/SkYqZmbVAf3dnmZnZUsRJxMzMKnMSMTOzypxEzMysMicRMzOrzEnEzMwqcxIxM7PKnETMzKwyJxEzM6vMScTMzCpzEjEzs8qcRMzMrDInETMzq8xJxMzMKnMSMTOzypxEzMysMicRMzOrzEnEzMwqcxIxM7PKnETMzKwyJxEzM6vMScTMzCob3OoAbEHTpz/JqFG7LVTe2bkmEyde0oKIzMwacxJZwsydCx0d1y9U3tW1cGIxM2s1d2eZmVllTiJmZlaZk4iZmVXmJGJmZpU5iZiZWWVOImZmVpmTiJmZVebrRNqEL0I0syVRS5KIpC7gdeAtYF5EjK5ZLuA8YFfgDeCgiJgmaWPg58AQ4LCIuEPSYOB3wO4R8UY/NqNf+SJEM1sStfJI5BMR8WKDZbsAG+bXGOCC/PMw4Bigi5RkPgccAVyxNCcQM7Ml1ZLanTUWmBARAdwpaTVJawNvAkPz601JqwG7ATu3LFIzswGsVUkkgJskBfCziBhXs7wDeKYwPyOXnQ9MAJYjHZV8Dzg9IuY3P2QzM6vVqiTy0YiYKWlNYIqkRyPi9t5WioingW0BJG0ArAs8IulyYFngexHxl9r1JB0KHAowcuTIvmuFmdkA15JTfCNiZv45G7gW2KqmykxgRGF+3VxWdBpwIvA14GLgm8BJDfY3LiJGR8To4cOHL34DzMwMaEESkbSipJW7p4EdgQdrqk0CDlCyNTAnImYVtvFx4NmIeJw0PjI/v4b2RxvMzCxpRXfWWsC16SxeBgM/j4jfSTocICIuBCaTTu99gnSK75e6V86n/54I7J2LxgFX5m0d0U9tMDMzWpBEImI6sFmd8gsL0wEc1WD9AHYozD8CjOr7SM3MrDe+7YmZmVW2pF4nYiU1uh0K+JYoZtZ8TiJtrtHtUMC3RDGz5nN3lpmZVeYkYmZmlTmJmJlZZU4iZmZWmZOImZlV5iRiZmaV+RTfpVija0iee24G7373uguV+7oSM1tUTiJLsUbXkDz66CZsuaUftWtmi8/dWWZmVpmTiJmZVeYkYmZmlTmJmJlZZU4iZmZWmZOImZlV5iRiZmaVOYmYmVllTiJmZlaZk4iZmVXmJGJmZpU5iZiZWWVOImZmVpmTiJmZVeYkYmZmlfl5ItarPfY4mK6u2QuV+yFWZuYkYr3q6ppd9+FWfoiVmTmJ2NsaPU53+vSn6OgoXx98lGI2UDiJ2Nt6epzuotSHxkcp7hozW7o4iVi/cteY2dLFZ2eZmVllPhKxpuir8RV3c5kt2VqSRCTtDJwHDAIujogzapYvB0wAtgReAvaOiC5J2wAXAHOBfSPicUmrAb8Edo6I+f3YDOtBX42vuJvLbMnW70lE0iDgfGAHYAZwt6RJEfFwodrBwCsRsYGkfYAfAHsDxwO7Ap3A4Xn+ROB0J5ClU5UjFA/em/WfVhyJbAU8ERHTAST9AhgLFJPIWODkPP2fwE8kCXgTGJpfb0p6LzAiIm7rn9Ctv1U5Qmk0eH/LLZssFV1mTpK2JFFE9O8OpT1JXU+H5Pn9gTERcXShzoO5zow8/yQwBlgXuBD4B7A/cCbwvYh4vJd9Hgocmmc3Bh6rGP4w4MWK67Yrt3lgcJuXfovb3vUiYnhtYVsNrEfEfcDWAJI+BsxKk7qadJRyfEQ8X2e9ccC4xd2/pKkRMXpxt9NO3OaBwW1e+jWrva04xXcmMKIwv24uq1tH0mBgVdIAO7lMpLGQU4GTgG8CFwFfa1rUZma2kFYkkbuBDSWtL2lZYB9gUk2dScCBeXpP4JZYsN/tAGByRLxMGh+Zn19Dmxq5mZktoN+7syJinqSjgRtJp/iOj4iHJJ0CTI2IScAlwOWSngBeJiUaACQNBQ4CdsxFZwOTSaf97tfk8Be7S6wNuc0Dg9u89GtKe/t9YN3MzJYevu2JmZlV5iRiZmaVOYnUIWlnSY9JekLSCXWWLyfp6rz8LkmdLQizT5Vo8/+R9LCk+yXdLGm9VsTZl3prc6He5ySFpLY+HbRMeyXtlf/OD0n6eX/H2NdKvK9HSrpV0r35vb1rK+LsS5LGS5qdr7ert1ySfpx/J/dLGrVYO4wIvwov0mD/k8B7gGWBPwOb1NQ5ErgwT+8DXN3quPuhzZ8AhubpIwZCm3O9lYHbgTuB0a2Ou8l/4w2Be4HV8/yarY67H9o8DjgiT28CdLU67j5o98eAUcCDDZbvCtwAiHTd3V2Lsz8fiSzs7duyRMRcoPu2LEVjgcvy9H8C2+VrV9pVr22OiFsj4o08eyfp+p52VubvDOlapB8A/+zP4JqgTHu/ApwfEa8ARMTC91ZpL2XaHMAqeXpV4Nl+jK8pIuJ20lmtjYwFJkRyJ7CapLWr7s9JZGEdwDOF+Rm5rG6diJgHzAHe1S/RNUeZNhcdTPom0856bXM+zB8REb/tz8CapMzfeCNgI0l/kHRnvtt2OyvT5pOBL0qaQbpU4Kv9E1pLLer/e4/a6rYn1nqSvgiMBj7e6liaSdIypGuQDmpxKP1pMKlLa1vSkebtkv4lIl5tZVBNti9waUScJenDpOvTPhi+K3hpPhJZ2GLflqUNlWkzkrYHvgvsHhH/20+xNUtvbV4Z+CBwm6QuUt/xpDYeXC/zN54BTIqINyPir8BfSEmlXZVp88Gk5xEREXcAy5NuVLg0K/X/XpaTyML64rYs7abXNkvaAvgZKYG0e1859NLmiJgTEcMiojMiOknjQLtHxNTWhLvYyryvryMdhSBpGKl7a3o/xtjXyrT5aWA7AEnvJyWRF/o1yv43CTggn6W1NTAnImZV3Zi7s2rEYt6WpR2VbPOPgJWAX+VzCJ6OiN1bFvRiKtnmpUbJ9t4I7CjpYeAt4BsR0bZH2CXbfDxwkaTjSIPsB7X5F0IkXUX6MjAsj/WcBAwBiIgLSWM/uwJPAG8AX1qs/bX578vMzFrI3VlmZlaZk4iZmVXmJGJmZpU5iZiZWWVOImZmVpmTiFkfkPSWpPsKr05Jf2xQ91JJe/ayvbfrSLpY0iZ5+jt9H71Zdb5OxKxv/CMiNq8p+0hfbDgiDinMfgc4vS+2a9YXnETMmkTS3yJipXyH5/8AdiDd+G5uoc6WpHt0rQS8SLrYbVbNdm4Dvk66O8IKku4DHiLd5vzliDg31zsNmB0R5zW3ZWbvcHeWWd9YodCVdW3Nss8CG5OeV3EA+QhF0hBSctkzIrYExgOnNdpBRJxAPuKJiC/k+gfkbS1DunPCFX3bLLOe+UjErG/U687q9jHgqoh4C3hW0i25fGPSTR6n5FvJDAJK38MoIrokvZTva7YWcG8736bE2pOTiFnrCHgoIj68GNu4mHS7+neTjkzM+pW7s8ya73Zgb0mD8hPkPpHLHwOG5+dYIGmIpA/0sq03czdYt2uBnYEPkW40aNavfCRi1nzXAp8EHibdevwOgIiYm0/j/bGkVUn/j+eSBs0bGQfcL2laRHwhb+NW4NXcXWbWr3wXX7M2lgfUpwGfj4jHWx2PDTzuzjJrU/kCxCeAm51ArFV8JGJmZpX5SMTMzCpzEjEzs8qcRMzMrDInETMzq8xJxMzMKvv/UmLIvPjM2PcAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "sampling QNNs with depth 3...\n", " sampling 0-th sample...\n", " sampling 400-th sample...\n", " sampling 800-th sample...\n", " sampling 1200-th sample...\n", " sampling 1600-th sample...\n", " sample finished\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "The expressibility of depth 1, 2 and 3 is [0.2715 0.0152 0.0096]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# evaluate the probability distribution of F generated by the complex entangled QNN\n", "def p_F_cel(n, d, s, b=50, draw=False):\n", " pq.set_backend('state_vector')\n", " f_list = list()\n", " for index in range(int(s / 2)):\n", " if 2 * index % 400 == 0:\n", " print(\" sampling %d-th sample...\" % (2 * index))\n", " cir1 = Circuit(n)\n", " # add complex entangled layers\n", " cir1.complex_entangled_layer('full', n, d)\n", " # output a state vector\n", " rho1 = cir1(pq.state.zero_state(n))\n", " \n", " cir2 = Circuit(n)\n", " # add complex entangled layers\n", " cir2.complex_entangled_layer('full', n, d)\n", " # output another state vector\n", " rho2 = cir2(pq.state.zero_state(n))\n", " \n", " # calculate fidelity\n", " f_list.append(abs(np.inner(rho1.data.numpy(), rho2.data.numpy().conj()))**2)\n", " \n", " print(\" sample finished\")\n", " f_list = np.array(f_list)\n", " # plot histgram\n", " if draw:\n", " title_str = \"complex entangled layer, %d layer(s)\" % d\n", " plot_hist(f_list, b, title_str)\n", " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", " return distribution\n", "\n", "\n", "# set the width and maximal depth \n", "num_qubit = 4\n", "max_depth = 3\n", "# evaluate the probability distribution of F generated by a Haar random unitaty\n", "print(\"F generated by a Haar random unitaty：\")\n", "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", "Expr_cel = list()\n", "# evaluate the expressibility of QNNs with different depth\n", "for DEPTH in range(1, max_depth + 1):\n", " print(\"sampling QNNs with depth %d...\" % DEPTH)\n", " p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n", " expr = entropy(p_cel, theory_haar_4qubit)\n", " Expr_cel.append(expr)\n", "# compare the expressibility\n", "print(\"The expressibility of depth 1, 2 and 3 is\", np.around(Expr_cel, decimals=4))\n", "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n", "plt.xlabel(\"depth\")\n", "plt.yscale('log')\n", "plt.ylabel(\"Expr.\")\n", "plt.xticks(range(1, max_depth + 1))\n", "plt.title(\"Expressibility vs Circuit Depth\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "3548ed5c", "metadata": {}, "source": [ "As we would observe, the expressibility of the quantum neural network is gradually enhanced with the increase of circuit depth. Interested readers are welcome to try to evaluate the expressibility of other Paddle Quantum QNN templates, and compare the difference in expressibility between different templates." ] }, { "cell_type": "markdown", "id": "699d3925", "metadata": {}, "source": [ "_______\n", "\n", "## References\n", "\n", "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n", "\n", "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.8.13" } }, "nbformat": 4, "nbformat_minor": 5 }