ExpressibilityEntanglingCapability.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp \n",
    "import scipy.linalg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating A from 1905.10876 \n",
    "\n",
    "We genearte $A$ and find $\\mid \\mid {A} \\mid \\mid^2_{HS}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_unitary(N):\n",
    "    \"\"\"Generate uniformly random unitary from U(N). \n",
    "       Credit to Jarrod McClean\"\"\"\n",
    "    Z = np.random.randn(N, N) + 1.0j * np.random.randn(N, N)\n",
    "    [Q, R] = sp.linalg.qr(Z)\n",
    "    D = np.diag(np.diagonal(R) / np.abs(np.diagonal(R)))\n",
    "    return np.dot(Q, D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can approximate the integral over $U(N)$ by \n",
    "$$ \\int_{U(N)} f(U) dU \\approx \\frac{1}{M} \\sum_{i=1}^M f(U_i) $$\n",
    "where $M$ is the number of samples nd $U_i$ is a uniformly random unitary. \n",
    "\n",
    "We can define $f(U) = U |0><0| U^{\\dagger}$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expressibility of 1-qubit Idle circuit consisting of only |0> \n",
    "M = 1000 \n",
    "int_harr = np.zeros((2,2))\n",
    "start_state = np.array([[1, 0], [0, 0]], dtype='complex128')\n",
    "for i in range(M):\n",
    "    u_i = random_unitary(2)\n",
    "    int_harr = int_harr + (u_i * start_state * np.conjugate(np.transpose(u_i)))\n",
    "int_harr /= M "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.2255817748232015+0j)\n"
     ]
    }
   ],
   "source": [
    "A = int_harr - start_state \n",
    "print(np.trace(np.conjugate(np.transpose(A)) * A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's try with |0> --- H --- R_z(a) --- R_X(b)\n",
    "H = 1 / np.sqrt(2) * np.array([[1, 1], [1, -1]], dtype='complex128')\n",
    "RZ = lambda a: np.array([[np.exp(-1j * a / 2), 0], [0, np.exp(1j * a / 2)]], dtype='complex128')\n",
    "RX = lambda b: np.array([[np.cos(b / 2), -1j * np.sin(b / 2)], \n",
    "                         [-1j * np.sin(b / 2), np.cos(b / 2)]], dtype='complex128')\n",
    "\n",
    "int_ansatz = np.zeros((2,2))\n",
    "for i in range(M):\n",
    "    a = np.random.uniform(-np.pi, np.pi)\n",
    "    b = np.random.uniform(-np.pi, np.pi)\n",
    "    \n",
    "    rho = H * start_state * H \n",
    "    rho = RZ(a) * rho * np.conjugate(np.transpose(RZ(a))) \n",
    "    rho = RX(b) * rho * np.conjugate(np.transpose(RX(b)))\n",
    "    int_ansatz = int_ansatz + rho \n",
    "\n",
    "int_ansatz /= M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.07285261876527102+0j)\n"
     ]
    }
   ],
   "source": [
    "A = int_harr - int_ansatz \n",
    "print(np.trace(np.conjugate(np.transpose(A)) * A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hm okay so expressibility is sort of expressed by how small $\\mathrm{Tr} A^\\dagger A$ is. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if I just defined expressibility as "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}