diff --git a/circuit_descriptors.ipynb b/circuit_descriptors.ipynb new file mode 100644 index 0000000..9983a94 --- /dev/null +++ b/circuit_descriptors.ipynb @@ -0,0 +1,602 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## _*Circuit Descriptors*_\n", + "\n", + "#### Written by Hojun Lee\n", + "\n", + "\n", + "### Introduction\n", + "Parameterized quantum circuit(PQC) can be the framework of variational quantum algorithms.\n", + "\n", + "[1] presented two circuit descriptors of parameterized quantum circuit, expressibility and entangling capability.\n", + "\n", + "To learn how to implement parameterized quantum circuits, see [this file](https://qiskit.org/documentation/tutorials/circuits_advanced/01_advanced_circuits.html)." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "import numpy as np\n", + "from scipy.stats import norm\n", + "from matplotlib import pyplot as plt\n", + "from scipy.stats import rv_continuous\n", + "from qiskit.circuit import Parameter, ParameterVector\n", + "from qiskit import *\n", + "from sklearn.metrics.cluster import adjusted_mutual_info_score as mi" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Make a parameterized quantum circuit\n", + "\n", + "This PQC class has a method `get()` which returns statevector by using statevector simulator.\n", + "\n", + "It has two modes, \"pqc\" and \"random\".\n", + "\n", + "In \"pqc\" mode, it samples parameter values from unifrom distribution and bind it to the parameterized quantum circuit.\n", + "\n", + "\"random\" mode is for random quantum circuits. it uses `qiskit.quantum_info.random_unitary` which samples unitary operator from the unitary Haar measure." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "class PQC:\n", + " def __init__(self,name,size,num_params,backend=Aer.get_backend('statevector_simulator')):\n", + " self.backend = backend\n", + " self.circ = QuantumCircuit(size)\n", + " self.name = name\n", + " self.size = size\n", + " self.num_params = num_params\n", + " seed = 14256\n", + " np.random.seed(seed)\n", + " self.params = ParameterVector('θ', self.num_params)\n", + " def get(self,mode=\"pqc\"):\n", + " if mode == \"pqc\":\n", + " circ = self.circ.bind_parameters({self.params: np.random.uniform(0,2*np.pi,len(self.params.params))})\n", + " elif mode == \"random\":\n", + " rand = qiskit.quantum_info.random_unitary(dims=2**self.size)\n", + " circ = QuantumCircuit(self.size)\n", + " circ.data = self.circ.data\n", + " circ.append(rand,range(self.size))\n", + " result = execute(circ,self.backend).result()\n", + " out_state = result.get_statevector()\n", + " statevector = np.asmatrix(out_state).T\n", + " return statevector" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Following quantum circuit is similar from with `Circuit 19` in [1]" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "pqc = PQC(name=\"MyCirc\",size=4,num_params=12)\n", + "for i in range(pqc.size):\n", + " pqc.circ.rx(pqc.params[i],i)\n", + "for i in range(pqc.size):\n", + " pqc.circ.rz(pqc.params[i+pqc.size],i)\n", + "pqc.circ.crz(pqc.params[2*pqc.size],pqc.size-1,0)\n", + "for i in range(pqc.size-1):\n", + " pqc.circ.crz(pqc.params[i+1+2*pqc.size],pqc.size-i-2,pqc.size-i-1)\n", + "pqc.circ.draw('mpl')" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "execution_count": 3 + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "`get()` method returns the statevector" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "pqc.get(mode=\"pqc\")" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "matrix([[ 0.12530701+1.27546047e-02j],\n", + " [-0.16961975+1.54238235e-01j],\n", + " [-0.0044316 +3.40098926e-03j],\n", + " [-0.0032801 -9.62435063e-03j],\n", + " [-0.27942712+3.34385164e-01j],\n", + " [-0.11325471-7.85049126e-01j],\n", + " [-0.0040606 +1.88953655e-02j],\n", + " [-0.03021272-1.80194588e-02j],\n", + " [ 0.04366029+8.41178169e-03j],\n", + " [ 0.0782669 -2.05952042e-02j],\n", + " [-0.00166481+1.05695980e-03j],\n", + " [-0.00054407+3.54791646e-03j],\n", + " [ 0.14319123+5.62141380e-02j],\n", + " [ 0.27924256-2.05741649e-02j],\n", + " [ 0.00678106-7.51180781e-04j],\n", + " [ 0.0070887 -1.01962833e-02j]])" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "pqcr = PQC(name=\"rand\",size=4,num_params=0)\n", + "rand = qiskit.quantum_info.random_unitary(dims=2**pqcr.size)\n", + "circ = QuantumCircuit(pqcr.size)\n", + "circ.data = pqcr.circ.data\n", + "circ.append(rand,range(pqcr.size))\n", + "circ.draw('mpl')\n" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "execution_count": 5 + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 6, + "source": [ + "pqcr.get(mode=\"random\")" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "matrix([[-3.98714123e-02+0.13250183j],\n", + " [ 1.25384717e-01+0.01745208j],\n", + " [ 4.11904779e-02-0.04681158j],\n", + " [-2.26546495e-01-0.184279j ],\n", + " [ 8.92090819e-02-0.12638076j],\n", + " [-6.45155493e-05+0.14151557j],\n", + " [ 2.90019967e-02+0.28616342j],\n", + " [ 1.06946742e-01-0.25793945j],\n", + " [ 2.84696075e-01-0.1614268j ],\n", + " [-1.26314751e-02-0.02909431j],\n", + " [ 2.91752140e-01+0.17953406j],\n", + " [ 1.76719194e-01-0.33373948j],\n", + " [-3.14102597e-01-0.19002397j],\n", + " [ 1.13760790e-03+0.37750962j],\n", + " [-1.14572826e-02+0.05289444j],\n", + " [ 1.20602728e-01-0.09033893j]])" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Expressibility" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Expressibility is a measure of how the quantum states generated by parameterized quantum circuit represent Hilbert space well.\n", + "\n", + "To quantify this non-uniformity, [1] looked $\\epsilon$-approximate state $t$-design.\n", + "$\\begin{equation*}\n", + "A=\\int_{Haar}\\left(|\\psi\\rangle\\langle\\psi|\\right)^{\\otimes t} d\\psi - \\int_{\\mathbf{\\Theta}}\\left(|\\psi_\\mathbf{\\theta}\\rangle\\langle\\psi_\\mathbf{\\theta}|\\right)^{\\otimes t} d\\mathbf{\\theta}\n", + "\\end{equation*}$\n", + "\n", + "And $||A||_{HS}^2$ can thought as one of the measure of non-uniformity. ($HS$ is Hilbert-Schmidt norm)\n", + "\n", + "$||A||_{HS}^2$ can be expressed as a term of `frame potential`[2] $\\mathcal{F}^{(t)}$\n", + "\n", + "$\\begin{equation*}\n", + "||A||_{HS}^2 = \\mathcal{F}^{(t)} - \\mathcal{F}_{Haar}^{(t)}\n", + "\\end{equation*}$\n", + "\n", + "$\\begin{equation*}\n", + "\\mathcal{F}^{(t)} = \\int_{\\mathbf{\\Theta}}\\int_{\\mathbf{\\Phi}}{\\left|\\langle\\psi_{\\mathbf{\\theta}}|\\psi_{\\mathbf{\\phi}}\\rangle\\right|}^{2t} d\\mathbf{\\theta}d\\mathbf{\\phi},\\ \\ \\ \\mathcal{F}_{Haar}^{(t)} = {{1}\\over{d_{sym}^{(t)}}} = {{t! (N-1)!}\\over{(t+N-1)!}}\n", + "\\end{equation*}$\n", + "\n", + "where $N=2^n$ for $n$ qubits.\n", + "\n", + "Since $||A||_{HS}^2\\ge 0$, $\\mathcal{F}^{(t)}$ has a lower bound $\\mathcal{F}_{Haar}^{(t)}$\n", + "\n", + "$\\mathcal{F}^{(t)}$ can be understood as $t$-th momentum of the distribution of fidelity.\n", + "\n", + "$\\begin{equation*}\n", + "\\mathcal{F}^{(t)} = \\mathbb{E}\\left[F^t\\right], \\ \\ \\ F={\\left|\\langle\\psi_{\\mathbf{\\theta}}|\\phi_{\\mathbf{\\theta}}\\rangle\\right|}^2\n", + "\\end{equation*}$\n", + "\n", + "And expressibility is defined as the Kullback-Leibler(KL) divergence of estimated fidelity distribution and fidelity distribution of the Haar distribution.\n", + "\n", + "$\\begin{equation*}\n", + "Expr = D_{KL}\\left(\\hat{P}_{PQC}(F;\\mathbf{\\theta})||P_{Haar}(F)\\right)\n", + "\\end{equation*}$\n", + "\n", + "And the probability of haar distribution is known as $P_{Haar}(F) = (N-1){(1-F)}^{N-2}$" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Implement expressibility function\n", + "\n", + "We can estimate the probability distribution function with histogram of sampled fidelities.\n", + "\n", + "Natural logarithm is used in Kullback-Leibler divergence." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "def kl_divergence(p, q):\n", + " return np.sum(np.where(p*q!=0, p * np.log(p / q), 0))\n", + "\n", + "def Haar(F,N):\n", + " if F<0 or F>1:\n", + " return 0;\n", + " return (N-1)*((1-F)**(N-2))\n", + "\n", + "class Haar_dist(rv_continuous):\n", + " def _pdf(self,x,n):\n", + " return Haar(x,2**n)\n", + "\n", + "def getHaar(reps,bins=250,qubits=4):\n", + " haar = []\n", + " N = qubits ** 2\n", + " for i in range(bins):\n", + " haar.append(Haar((i+0.5)/bins,N)/bins)\n", + " return np.array(haar)\n", + "def expressibility(pqc, bins=250, reps=10000, verbose = 2, get_mode=\"pqc\"):\n", + " arr = []\n", + " for i in range(reps):\n", + " v1 = pqc.get(mode=get_mode).getH()\n", + " v2 = pqc.get(mode=get_mode)\n", + " fid = np.abs(v1*v2)**2\n", + " arr.append(fid[0,0])\n", + " if verbose == 2:\n", + " if i%100==0 and i!=0:\n", + " print(\"\\r\",\"reps \",i,end=' ')\n", + " if i==reps-1:\n", + " print(\"\\rdone.\",end=' ')\n", + " haar = []\n", + " h = Haar_dist(a=0,b=1,name=\"haar\")\n", + " for i in range(reps):\n", + " haar.append(h.ppf((i+1)/reps,pqc.size))\n", + " haar_pdf = plt.hist(np.array(haar), bins=bins, alpha=0.5,range=(0,1),density=True,label=\"haar\")[0]\n", + " pqc_pdf = plt.hist(np.array(arr), bins=bins, alpha=0.5, range=(0,1),density=True,label=get_mode)[0]\n", + " kl = kl_divergence(pqc_pdf/bins,haar_pdf/bins)\n", + " if verbose >= 1:\n", + " plt.title(\"%s KL(P||Q) = %1.4f\" % (pqc.name, kl))\n", + " plt.legend()\n", + " return kl" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Calculate the expressibility of `pqc`" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "expressibility(pqc,reps=1000,get_mode='pqc')" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " reps 200 " + ] + } + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "You can see that the random quantum circuit has much lower value than parameterized quantum circuits. The expressibility of random quantum circuit is ideally 0." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "expressibility(pqcr,reps=1000,get_mode='random')" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Entangling capability" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Entangling capability is the average of Meyer-Wallach entanglement[3] of states generated by the parameterized quantum circuit.\n", + "\n", + "$Ent. = {1\\over{|S|}}\\sum\\limits_{\\boldsymbol{\\theta_i}\\in S}Q(|\\psi_{{\\boldsymbol{\\theta_i}}}\\rangle)$\n", + "\n", + "For pure states, we can calculate the Meyer-Wallach entanglement as following.[4]\n", + "\n", + "$Q(|\\psi\\rangle) = {4\\over n}\\sum\\limits_{j=1}^n D(\\iota_j(0)|\\psi\\rangle,\\iota_j(1)|\\psi\\rangle)$\n", + "\n", + "$D(|u\\rangle, |v\\rangle) = {1\\over 2}\\sum\\limits_{i,j}{|u_iv_j-u_jv_i|}^2$\n", + "\n", + "$\\iota_j(b)|b_1 b_2 \\cdots b_n\\rangle = \\delta_{bb_j}|b_1 b_2 \\cdots\\hat{b_j}\\cdots b_n\\rangle$\n", + "\n", + "where the symbol ^ denotes absence of the $j$-th qubit." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "def I(b,j,n,vec):\n", + " newvec = np.zeros((2**(n-1)), dtype=complex)\n", + " for new_index in range(2**(n-1)):\n", + " original_index = new_index%(2**(j-1)) + (new_index//(2**(j-1)))*(2**(j)) + b*(2**(j-1))\n", + " newvec[new_index]=vec[int(original_index),0]\n", + " return newvec\n", + "\n", + "\n", + "def D(u,v,m):\n", + " dist = 0\n", + " for i in range(m):\n", + " for j in range(m):\n", + " a = u[i]*v[j]-u[j]*v[i]\n", + " dist += (1/2)*(np.abs(a)**2)\n", + " return dist\n", + "\n", + "\n", + "def Q(n,vec):\n", + " sum = 0;\n", + " for j in range(n):\n", + " sum += D(I(0,j+1,n,vec),I(1,j+1,n,vec),2**(n-1))\n", + " return sum * 4 / n\n", + "\n", + "\n", + "def entangling_capability(pqc, reps=10000,verbose=1,get_mode=\"pqc\"):\n", + " sum = 0;\n", + " for i in range(reps):\n", + " sum += Q(pqc.size,pqc.get(mode=get_mode))\n", + " if verbose == 1:\n", + " if i%100==0 and i!=0:\n", + " print(\"\\r\",\"reps \",i,end=' ')\n", + " if i==reps-1:\n", + " print(\"\\rdone.\",end=' ')\n", + " return sum/reps" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "entangling_capability(pqc,reps=1000)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "The mean $Q$ value of Haar random states are known as $\\langle Q\\rangle_{Haar} = {{N-2}\\over{N+1}}$ where $N=2^n$ [5]" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "N = 2**pqcr.size\n", + "Q_haar = (N-2)/(N+1)\n", + "print(Q_haar)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "entangling_capability(pqcr,reps=1000,get_mode=\"random\")" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Get expressibility with qasm_simulator\n", + "For pure quantum states, we can get fidelity with swap test [6]" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "def get_fidelity(pqc):\n", + " backend = Aer.get_backend('qasm_simulator')\n", + " qc = QuantumCircuit(2*pqc.size + 1,1)\n", + " circ1 = pqc.circ.copy()\n", + " circ2 = pqc.circ.copy()\n", + " circ1 = circ1.bind_parameters({pqc.params: np.random.uniform(0,2*np.pi,len(pqc.params.params))})\n", + " circ2 = circ2.bind_parameters({pqc.params: np.random.uniform(0,2*np.pi,len(pqc.params.params))})\n", + " circ1.name=\"pqc\"\n", + " circ2.name=\"pqc\"\n", + " qc.h(0)\n", + " qc.append(circ1,range(1,1+pqc.size))\n", + " qc.append(circ2,range(1+pqc.size,1+2*pqc.size))\n", + " for i in range(pqc.size):\n", + " qc.cswap(0,i+1,i+1+pqc.size)\n", + " qc.h(0)\n", + " qc.measure(0,0)\n", + " shots = 10000\n", + " result = execute(qc,backend,shots=shots).result()\n", + " counts = result.get_counts()\n", + " fid = 2*(counts['0']/shots)-1\n", + " fid = fid if fid>0 else 0\n", + " return (qc, fid)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "qc,fid=get_fidelity(pqc)\n", + "print(fid)\n", + "qc.draw('mpl')" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "def expressibility_swap(pqc, bins=250, reps=10000, verbose = 2):\n", + " arr = []\n", + " for i in range(reps):\n", + " _, fid = get_fidelity(pqc)\n", + " arr.append(fid)\n", + " if verbose == 2:\n", + " if i%100==0 and i!=0:\n", + " print(\"\\r\",\"reps \",i,end=' ')\n", + " if i==reps-1:\n", + " print(\"\\rdone.\",end=' ')\n", + " haar = []\n", + " h = Haar_dist(a=0,b=1,name=\"haar\")\n", + " for i in range(reps):\n", + " haar.append(h.ppf((i+1)/reps,pqc.size))\n", + " haar_pdf = plt.hist(np.array(haar), bins=bins, alpha=0.5,range=(0,1),density=True,label=\"haar\")[0]\n", + " pqc_pdf = plt.hist(np.array(arr), bins=bins, alpha=0.5, range=(0,1),density=True,label=\"pqc\")[0]\n", + " kl = kl_divergence(pqc_pdf/bins,haar_pdf/bins)\n", + " if verbose >= 1:\n", + " plt.title(\"%s KL(P||Q) = %1.4f\" % (pqc.name, kl))\n", + " plt.legend()\n", + " return kl" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "expressibility_swap(pqc,reps=1000)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### References\n", + "1. 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.\n", + "2. Roberts, Daniel A., and Beni Yoshida. \"Chaos and complexity by design.\" Journal of High Energy Physics 2017.4 (2017): 1-64.\n", + "3. Meyer, David A., and Nolan R. Wallach. \"Global entanglement in multiparticle systems.\" Journal of Mathematical Physics 43.9 (2002): 4273-4278.\n", + "4. Brennen, Gavin K. \"An observable measure of entanglement for pure states of multi-qubit systems.\" arXiv preprint quant-ph/0305094 (2003).\n", + "5. Scott, Andrew J., and Carlton M. Caves. \"Entangling power of the quantum baker's map.\" Journal of Physics A: Mathematical and General 36.36 (2003): 9553.\n", + "6. Wikipedia, Swap_test, https://en.wikipedia.org/wiki/Swap_test" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "752579dbebe7f4dfe7c1aa72eac13e23fc88be2cc1ea7ab14e1f8d69b2d97d12" + }, + "kernelspec": { + "display_name": "Python 3.8.5 64-bit ('3.8')", + "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.5" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file