diff --git a/grove/pyqaoa/getting-started/QAOA_overview_maxcut.ipynb b/grove/pyqaoa/getting-started/QAOA_overview_maxcut.ipynb index 3c4dada..1d77ca9 100644 --- a/grove/pyqaoa/getting-started/QAOA_overview_maxcut.ipynb +++ b/grove/pyqaoa/getting-started/QAOA_overview_maxcut.ipynb @@ -25,13 +25,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_compiler.py:324: UserWarning: No quilc server running at tcp://127.0.0.1:5555. Compilation using quilc will not be available.\n", + " warnings.warn(f'{e}. Compilation using quilc will not be available.')\n" + ] + } + ], "source": [ - "import pyquil.forest as qvm_module\n", "import numpy as np\n", "from grove.pyqaoa.maxcut_qaoa import maxcut_qaoa\n", "barbell = [(0, 1)] # graph is a defined by a list of edges. Edge weights are assumed to be 1.0\n", @@ -48,17 +54,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.5+0j)*Z0*Z1 + (-0.5+0j)*I\n", + "(-1+0j)*X0 + (-1+0j)*X1\n" + ] + } + ], + "source": [ + "from functools import reduce\n", "cost_list, ref_list = inst.cost_ham, inst.ref_ham\n", "cost_ham = reduce(lambda x,y: x + y, cost_list)\n", "ref_ham = reduce(lambda x,y: x + y, ref_list)\n", - "print cost_ham\n", - "print ref_ham" + "print(cost_ham)\n", + "print(ref_ham)" ] }, { @@ -86,15 +100,36 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H 0\n", + "H 1\n", + "CNOT 0 1\n", + "RZ(4.2) 1\n", + "CNOT 0 1\n", + "X 0\n", + "PHASE(2.1) 0\n", + "X 0\n", + "PHASE(2.1) 0\n", + "H 0\n", + "RZ(-2.4) 0\n", + "H 0\n", + "H 1\n", + "RZ(-2.4) 1\n", + "H 1\n", + "\n" + ] + } + ], "source": [ "param_prog = inst.get_parameterized_program()\n", "prog = param_prog([1.2, 4.2])\n", - "print prog" + "print(prog)" ] }, { @@ -106,14 +141,48 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Fast method for expectation will be used. Noise\n", + " models will be ineffective\n", + "\tParameters: [1.94980229 1.4744023 ] \n", + "\tE => 0.0015337456362040647\n", + "\tParameters: [1.98381047 1.51535792] \n", + "\tE => 0.0012077609643334486\n", + "\tParameters: [1.98381047 1.51535792] \n", + "\tE => 0.0015533454458819262\n", + "\tParameters: [1.9512193 1.53071628] \n", + "\tE => 0.0005018775110684492\n", + "\tParameters: [1.9512193 1.53071628] \n", + "\tE => 0.0009440667030610195\n", + "\tParameters: [1.95263631 1.58703025] \n", + "\tE => 0.0017344383549392495\n", + "\tParameters: [1.96857764 1.56527258] \n", + "\tE => 5.546960010061053e-05\n", + "\tParameters: [1.96857764 1.56527258] \n", + "\tE => 0.0001050191734196515\n", + "\tParameters: [1.95978777 1.58455052] \n", + "\tE => 5.113693939540198e-05\n", + "\tParameters: [1.9630646 1.55095411] \n", + "\tE => 0.00024455655341537597\n", + "\tParameters: [1.96500191 1.56651245] \n", + "\tE => 6.833004222661643e-06\n", + "\tParameters: [1.96191051 1.5716419 ] \n", + "\tE => 5.113152035884916e-06\n", + "\tParameters: [1.96191051 1.5716419 ] \n", + "\tE => 6.787833086330242e-06\n", + "[1.96191051] [1.5716419]\n" + ] + } + ], "source": [ "betas, gammas = inst.get_angles()\n", - "print betas, gammas" + "print(betas, gammas)" ] }, { @@ -125,19 +194,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "00 (5.11315203590504e-06+0j)\n", + "01 (0.4999948868479635+0j)\n", + "10 (0.4999948868479635+0j)\n", + "11 (5.11315203590504e-06+0j)\n" + ] + } + ], + "source": [ + "from pyquil.api import WavefunctionSimulator\n", + "\n", "param_prog = inst.get_parameterized_program()\n", "t = np.hstack((betas, gammas))\n", "prog = param_prog(t)\n", - "wf, _ = inst.qvm.wavefunction(prog)\n", + "\n", + "wf = WavefunctionSimulator().wavefunction(prog)\n", "wf = wf.amplitudes\n", - "for ii in range(2**inst.n_qubits):\n", - " print inst.states[ii], np.conj(wf[ii])*wf[ii]" + "for ii in range(2**len(inst.qubits)):\n", + " print(inst.states[ii], np.conj(wf[ii])*wf[ii])" ] }, { @@ -163,10 +244,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", @@ -176,17 +255,13 @@ "import matplotlib.pyplot as plt\n", "from pyquil.paulis import PauliSum, PauliTerm\n", "import pyquil.quil as pq\n", - "from pyquil.gates import H\n", - "import pyquil.forest as qvm_module\n", - "CXN = qvm_module.Connection()" + "from pyquil.gates import H" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 7, + "metadata": {}, "outputs": [], "source": [ "# define a 6-qubit ring\n", @@ -198,11 +273,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de1RU96E98D0jxDx0uawEa/HiDYlWgtakPEVAsEAgiV5RBgIakV5Rr4+IWWpaNfWRWm19RWwADYhgwFawgoomYNWEaEUZqq2oUQORhogmht8ECTCv8/sjITfNVeQxM9+Zc/bnz0RPdhaHtdnnDOeoJEmSQEREpBBq0QGIiIhsicVHRESKwuIjIiJFYfEREZGisPiIiEhRWHxERKQoLD4iIlIUFh8RESkKi4+IiBSFxUdERIrC4iMiIkVh8RERkaKw+IiISFFYfEREpChOogOQbTW3t6OyvgENuma0Gox4xNkJbgP6w999KPr3fUh0PCKr4vlPAKDi+/iU4UaTDmVXP8alW19ABcBgNn/375zVakgAnh7sgsgRT2LYwAHCchJZA89/+j4WnwJU1NbjQM0VGE1mdPbFVgFw6qNGjNdIBHu42yoekVXx/Kcf4qVOmev4pjeYzA/8sxIAg8mMAzVXAIDf/OTweP7TvfDDLTJ2o0nX5W/67+v45q9v0lkpGZH18fyn+2HxyVjZ1Y9h7OY3fQejyYyyq7UWTkRkOzz/6X5YfDLV3N6OS7e+6PSeRmckADW3Pkdzu96SsYhsguc/dYbFJ1OV9Q29PobKQschsjWe/9QZFp9MNeiaYTT37DJPB4PZjM90zRZKRGQ7PP+pM/xUp0y1GowWOc6+A39Bku8YixyLyFZeWL4KT/gG9Po4rQaDBdKQvWHxydQjzpb50sbFTMHhdastciwiW8mtuoCqT2/2+jiPODtbIA3ZG17qlCm3Af3hpO7dl9dZrcZPBvS3UCIi2+H5T51h8cmUv7tbr48hWeg4RLbG8586w+KTqf59++LpwS5Q9fDvqwB4DX6cD+4lh8TznzrD4pOxyBFPwqlPz77ETn3UiBzhYeFERLbD85/uh8UnY8MGDkCM10iouvmxbudvH9TrzqfUkwPrOP+du1l+zmqe/3LH4pO5R768jXMFuXBSqR542UeF/y09PqCX5CDYw/278uvK+W82GmC49A+e/zLH1xLJWFNTE7y9vbFx40b4TghH2dVa1Nz6/L7vI/Ma/DgiR3jwJ12SnfomXZfO/7FDHseksPHYsGEDNBqNsLxkXSw+mZIkCZMnT8YTTzyBN99887t/3tyuR2V9Az7TNaPVYMAjzs74yYD+8Hd34418kr2unP9arRZRUVE4deoURowYITgxWQOLT6Y2btyIv/zlL3j//ffx0EMsNKLuyMzMRHp6Os6cOYNHH31UdByyMBafDFVUVECj0eDs2bNwd+e9CqLukiQJ06dPx8MPP4zs7GzRccjC+OEWmbl9+zYSEhKQk5PD0iPqIZVKhR07duD06dPYvXu36DhkYVx8MmIymRAVFQU/Pz+sW7dOdBwih1dTU4PQ0FAcP34co0ePFh2HLISLT0beeOMNGI1GrFmzRnQUIlnw8vLCli1bEBsbi6+++kp0HLIQLj6ZKCsrQ3JyMrRaLX784x+LjkMkK7Nnz8ZXX32FvXv3QqXq6YPQyF5w8clAQ0MDkpKSkJ+fz9IjsoK0tDR89NFHSE9PFx2FLICLz8EZDAaEhYXh+eefx/Lly0XHIZKt69evIzAwEKWlpfD19RUdh3qBi8/BLV++HAMGDMCvfvUr0VGIZO2pp55CZmYm4uLi8OWXX4qOQ73AxefASkpKsGjRImi1WgwaNEh0HCJFWLx4Ma5fv46SkhKoe/myWxKDxeegamtrERAQgEOHDsHf3190HCLF0Ov1GD9+PGJiYrBs2TLRcagHWHwOqK2tDUFBQXj55ZexaNEi0XGIFKe+vh5+fn7Yt28fQkJCRMehbmLxOaB58+bh9u3bKCws5EeriQQ5evQoUlJSoNVqMXjwYNFxqBt4gdrBFBQUoLy8HNnZ2Sw9IoGio6Mxc+ZMJCYmwmQyiY5D3cDF50CuXLmC4OBgHDt2DGPGjBEdh0jxTCYTIiIiEBwczCcmORAWn4NoaWmBv78/UlNTMWvWLNFxiOhbjY2N8Pb2Rk5ODiIjI0XHoS5g8TkASZIwc+ZMAMDu3bt5iZPIzpw8eRIvvfQSqqqqMHToUNFx6AF4j88BZGdnQ6vVIj09naVHZIdCQ0OxaNEixMfHw2AwiI5DD8DFZ+fOnz+PiIgIVFRUYOTIkaLjENF9mM1mTJw4EZ6enti0aZPoONQJLj47ptPpoNFokJaWxtIjsnNqtRp5eXkoKipCcXGx6DjUCS4+OyVJEjQaDVxdXflEeCIHUllZiYkTJ+LMmTPw8PAQHYfugYvPTqWlpeGTTz7B1q1bRUchom7w9/fHypUrERsbi7a2NtFx6B64+OzQmTNnMGnSJFRWVuKJJ54QHYeIukmSJMTFxcHFxQUZGRmi49APcPHZmTt37iA+Ph5vv/02S4/IQalUKmRlZeHYsWMoKCgQHYd+gIvPjpjNZrz44ovw8vLCxo0bRcchol66cOECwsPD8cEHH8DT01N0HPoWF58d2bBhA5qbm/G73/1OdBQisoAxY8Zgw4YNiI2NRUtLi+g49C0uPjtx4sQJJCYmoqqqCm5ubqLjEJGFSJKE5ORkmM1m5Obm8iEUdoCLzw40NjZi+vTpyMvLY+kRyYxKpcJbb72F6upqZGVliY5D4OITzmg0IiIiAuPHj8fq1atFxyEiK+l4u0pZWRmeffZZ0XEUjYtPsFWrVsHJyQmvv/666ChEZEUjR47E9u3bodFooNPpRMdRNC4+gY4cOYI5c+ZAq9XC1dVVdBwisoH58+ejsbERRUVFvN8nCBefIPX19UhOTsbevXtZekQKsmXLFty4cQPbtm0THUWxuPgE0Ov1CAkJwdSpU7F06VLRcYjIxurq6uDv74+SkhKMHTtWdBzFYfEJkJqairq6OhQXF/NSB5FCHTx4EAsWLEB1dTVcXFxEx1EUFp+NFRUVYdmyZdBqtRg4cKDoOEQk0LJly/DPf/4TpaWlUKt558lWWHw2dO3aNQQGBuLo0aPw8fERHYeIBDMYDJgwYQKioqKwYsUK0XEUg8VnI62trRg7dixmz56NefPmiY5DRHaioaEBPj4+KCgoQFhYmOg4isDis5GUlBTcvXsXBQUFvK9HRP/m2LFjmDFjBrRaLYYMGSI6juzxorIN5OXloaKiAjt37mTpEdH/ER4ejjlz5iAhIQFGo1F0HNnj4rOyixcvIiwsDCdOnMCoUaNExyEiO2UymRAdHQ0fHx++ocXKuPis6O7du4iNjcWmTZtYekTUqT59+uCdd97Bnj17UFpaKjqOrHHxWYkkSZg2bRoeffRRPpGdiLrsww8/xNSpU3H27FkMGzZMdBxZ4uKzkszMTFy6dAnbt28XHYWIHEhQUBCWLl2KuLg46PV60XFkiYvPCqqqqhAdHY3Tp09j+PDhouMQkYORJAkxMTEYNmwYn+lpBVx8FtbU1IS4uDhkZGSw9IioR1QqFXJycnDo0CEUFhaKjiM7XHwWxJ/SiMiStFotoqKicOrUKYwYMUJ0HNng4rOgzZs3o7GxERs3bhQdhYhkwNvbG2vXroVGo0Fra6voOLLBxWchHZ/EOnfuHNzd3UXHISKZ4CfELY+LzwJu376NhIQE7Nq1i6VHRBalUqmwY8cOfPjhh8jNzRUdRxa4+HrJZDIhKioKvr6+fNoCEVlNx1Ogjh8/jtGjR4uO49C4+Hrpt7/9LQwGA9auXSs6ChHJ2KhRo7B582ZoNBo0NzeLjuPQuPh6oby8HElJSXyiOhHZDN/00ntcfD3U0NCAGTNmID8/n6VHRDaTlpaGy5cvIyMjQ3QUh8XF1wN8azIRiXTt2jUEBgbi6NGj8PHxER3H4XDx9cCKFSvQv39//PrXvxYdhYgUaPjw4cjMzIRGo0FTU5PoOA6Hi6+bDh48iIULF6K6uhqDBg0SHYeIFCw1NRW1tbUoKSnh/b5uYPF1Q11dHfz9/VFSUoKxY8eKjkNECqfX6xESEoKpU6di6dKlouM4DBZfF7W3t2PcuHGYPn06UlNTRcchIgIA1NfXw8/PD4WFhQgODhYdxyGw+Lpo/vz5uHXrFgoLC3lJgYjsytGjR5GSkoLq6mq4urqKjmP3+OGWLvjTn/6E9957D9nZ2Sw9IrI70dHRSEpKwrRp02AymUTHsXtcfA9w5coVBAcHo7y8HM8884zoOERE92Q0GhEeHo7Q0FCsXr1adBy7xuLrxNdffw0/Pz8sWrQIKSkpouMQEXXq5s2b8PHxQU5ODiIjI0XHsVssvvuQJAnJyckwm83Izc3lJU4icggnT55EQkICzp07h6FDh4qOY5d4j+8+du3ahaqqKmRkZLD0iMhhhIaGYuHChXjppZdgMBhEx7FLXHz3cOHCBYSHh+ODDz6Ap6en6DhERN1iNpvx4osvwsvLCxs3bhQdx+5w8f2ATqdDbGwstm3bxtIjIoekVquxZ88e7Nu3DyUlJaLj2B0uvu+RJAlxcXFwcXHhk8+JyOGdOXMGkyZNwpkzZ+Dh4SE6jt3g4vue7du3o7a2Flu3bhUdhYio1wICArBixQpoNBq0tbWJjmM3uPi+VVlZiYkTJ/InIyKSFUmSoNFo4OrqivT0dNFx7AIXH4A7d+4gLi4OO3fuZOkRkayoVCpkZ2ejvLwcBQUFouPYBcUvPrPZjIkTJ8LT0xObNm0SHYeIyCrOnz+PiIgIflodXHz4/e9/D51Oh/Xr14uOQkRkNc888wzWr1+P2NhYtLS0iI4jlKIXH59wQERKIkkSZs6cCUmSFP1EKsUuvsbGRkybNg25ubksPSJSBJVKhfT0dFRXVyM7O1t0HGEUufhMJhPCw8MREhKCNWvWiI5DRGRTly9fRkhIiGLfOqPIxbdq1So4OTnhN7/5jegoREQ25+npibS0NGg0Guh0OtFxbE5xi49vKiYi+sa8efNw+/ZtFBYWKup+n6IWX319PZKTk7F3716WHhEp3pYtW1BXV4e0tDTRUWxKMYtPr9cjJCQEU6ZMwbJly0THISKyC7W1tQgICMDBgwcREBAgOo5NKKb4Fi9ejI8//hjFxcVQqxU1dImIOlVSUoJXXnkF1dXVGDRokOg4VqeI4tu/fz+WLFmC6upqDBw4UHQcIiK7s3TpUtTU1ODw4cOyHweyL77r168jMDAQpaWl8PX1FR2HiMguGQwGhIWF4fnnn8fy5ctFx7EqWRdfa2srxo4di5SUFMyfP190HCIiu/bpp5/C19cXBQUFCAsLEx3HamRdfLNnz0ZzczMKCgoU9VFdIqKeKi8vR1JSErRaLYYMGSI6jlXI9kLunj178P7772Pnzp0sPSKiLoqIiMDs2bORkJAAo9EoOo5VyHLx1dTUIDQ0FMePH8fo0aNFxyEicigmkwlRUVHw8/PDunXrRMexONktvrt37yI2NhYbN25k6RER9UCfPn2Qn5+PvLw8HDlyRHQci5PV4pMkCdOnT8fDDz+s6CePExFZwocffoipU6fi3LlzcHd3Fx3HYmS1+Hbs2IGLFy/ij3/8o+goREQOLygoCEuWLEFcXBz0er3oOBYjm8Wn1WoRFRWFU6dOYcSIEaLjEBHJgtlsxuTJk+Hh4YE333xTdByLkMXia2pqgkajQXp6OkuPiMiC1Go1cnNzUVJSgqKiItFxLMLhF58kSYiJiYG7u7vinjBORGQrVVVViI6OxunTpzF8+HDRcXrF4Rffli1bcPPmTWzatEl0FCIi2fLx8cGaNWug0WjQ2toqOk6vOPTiO3XqFKZMmYKzZ89i2LBhouMQEcmaJElITExEv3798Pbbb4uO02MOu/g+//xzvPTSS9i1axdLj4jIBlQqFXbu3ImKigrk5eWJjtNjDrn4TCYToqOj4e3tjfXr14uOQ0SkKBcvXkRYWBhOnDiBUaNGiY7TbQ65+NatWwe9Xo833nhDdBQiIsUZNWoUNm3ahNjYWNy9e1d0nG5zuMV37NgxzJgxQ9ZPDicicgSzZs3C119/jfz8fId6GYBDLb6Ghga8/PLLeOedd1h6RESCbd++HTU1NcjMzBQdpVscZvEZDAZMmDABzz33HFauXCk6DhERAbh27RoCAwNx9OhR+Pj4iI7TJQ6z+FauXIl+/fph+fLloqMQEdG3hg8fjoyMDMTFxaGpqUl0nC5xiMV38OBBLFiwANXV1XBxcREdh4iIfmDRokX45JNPUFxcbPf3++y++Orq6uDv74+SkhKMHTtWdBwiIroHvV6P4OBgaDQaLFmyRHScTtl18bW3tyMoKAiJiYlYvHix6DhERNSJGzduwM/PD/v370dQUJDoOPdl18W3YMEC3Lx5E0VFRXY/nYmICCgtLcXcuXOh1Wrh6uoqOs492e2HW/785z/j3Xffxa5du1h6REQO4oUXXsDLL7+MadOmwWQyiY5zT3a5+D766CMEBQWhrKwMzz77rOg4RETUDUajEeHh4QgLC8OqVatEx/k/7K74vv76a/j7+2PhwoWYPXu26DhERNQDN2/ehLe3N3JzcxERESE6zr+xefE1t7ejsr4BDbpmtBqMeMTZCW4D+sPffSj6PeSM5ORkmEwm5OXl8RInEZEDO3HiBBITE1FVVQU3NzcAnXdA/74P2SSXzYrvRpMOZVc/xqVbX0AFwGA2f/fvnNVqSAAea23Bsewd+OuB/XjsscdsEYuIiKxo3bp1ePfdd7H7L8U4Xnuj0w54erALIkc8iWEDB1g1k02Kr6K2HgdqrsBoMqOz/5jZbMZDffpgymhPBHu4WzsWERFZmdlsRsKS1+A6LhSqPn067QAVAKc+asR4jbRqB1j9U50dpWd4QOkBgFqthlGScKDmCipq660djYiIrOzUJ5/CLTQCeEDpAYAEwGAyW70DrFp8N5p035Ved3T8j9c36ayUjIiIrO27DjDbVwdYtfjKrn4MYzdLr4PRZEbZ1VoLJyIiIlux1w6wWvE1t7fj0q0vHjht70cCUHPrczS36y0Zi4iIbMCeO8BqxVdZ39DrY6gsdBwiIrIte+4AqxVfg64Zxm5e1/0hg9mMz3TNFkpERES2Ys8dYLXiazUYLXQcg0WOQ0REtmPPHWC14nvE2clCx3G2yHGIiMh27LkDrFZ8bgP6w0ndu8M7q9X4yYD+FkpERES2Ys8dYLXi83d36/UxJAsdh4iIbMueO8Bqxde/b188PdgFPX3MtAqA1+DHbfbQUiIishx77gCr/gJ75Ign4dSnZ/8Jpz5qRI7wsHAiIiKyFXvtAKsW37CBAxDjNRLO3fwfd/72IaXuVn5CNxERWc+wgQMQ5jYYxvb2bv09a3eA1R9SHezh/l35dWXyGtvb8Wy/h/l2BiIiB2cwGLBh4TwM+vJWlzpAhf8tPWt2gM3ex1ffpEPZ1VrU3Pr8vu9i8hr8OJwabmD1q6morq7Gj370I1tEIyIiK1iyZAkuX76MQ4cO4VNdc5c6IHKEh9Wv9gl4A7selfUN+EzXjFaDAY84O+MnA/rD393tu5uYr776Kq5du4aSkhKoe/lxWCIisr3i4mKkpqZCq9Vi0KBB3/3zrnSAtdm8+LpCr9dj/PjxmDx5Ml577TXRcYiIqBtqa2sREBCAQ4cOwd/fX3Sc/8Muiw8A/vWvf8HX1xf79u1DSEiI6DhERNQFbW1tCAwMxMyZM/HKK6+IjnNPdlt8APDuu+9i1qxZ0Gq1GDx4sOg4RET0AHPnzsWXX36JP//5z1CpevpbfNZl1zfQoqKikJycjMTERJhMJtFxiIioE/n5+fjrX/+KrKwsuy09wM4XHwCYTCZEREQgKCgIa9euFR2HiIju4fLlywgJCcGxY8cwZswY0XE6ZffFBwCNjY3w9vbGrl278Nxzz4mOQ0RE39PS0gI/Pz+8+uqr+O///m/RcR7IIYoPAN5//33Ex8fj3Llz+I//+A/RcYiICIAkSZgxYwb69OmDnJwcu77E2cGu7/F93/jx45Gamor4+HgY+HJaIiK7kJWVhfPnzyM9Pd0hSg9woMUHAGazGZMmTcJPf/pTbN68WXQcIiJF+/vf/47IyEhUVFRg5MiRouN0mcMsPgBQq9XIzc3F/v37ceDAAdFxiIgUS6fTQaPRYPv27Q5VeoCDLb4OZ8+exYsvvoi//e1vePLJJ0XHISJSFEmSMHXqVAwZMgRvvfWW6Djd5lCLr4Ofnx9ef/11aDQatLW1iY5DRKQo27ZtQ319PbZs2SI6So845OIDvvmJIz4+Hj/60Y+QmZkpOg4RkSL87W9/w3/913+hsrISTzzxhOg4PeKQiw8AVCoVsrKycPz4ceTn54uOQ0Qke1988QXi4+ORlZXlsKUHOPDi6/CPf/wDv/jFL/D+++/j6aefFh2HiEiWzGYznn/+efzsZz/DH/7wB9FxesVhF1+Hn/3sZ/j973+P2NhYtLS0iI5DRCRL69evR0tLC9atWyc6Sq85/OLrkJycDKPRiLy8PIf5JUoiIkdw4sQJJCYmoqqqCm5ubqLj9JrDL74Ob731Fs6fP4+3335bdBQiItm4efMmpk2bhj179sii9AAZLT4A+OijjxAUFIT33nsPP//5z0XHISJyaEajEb/4xS8wYcIErFq1SnQci5HN4gOAn/70p/jjH/+IuLg46HQ60XGIiBzab37zG/Tt2xcrV64UHcWiZLX4OixYsACfffYZ9u/fz/t9REQ9UFpairlz50Kr1cLV1VV0HIuS1eLrsHnzZvzrX//Cm2++KToKEZHDuXHjBn75y19i7969sis9QKaLDwDq6uoQEBCAAwcOIDAwUHQcIiKHoNfrERwcDI1GgyVLloiOYxWyLT4AOHToEObPn4/q6mq4uLiIjkNEZPcWLVqEGzdu4MCBA7K9VSTr4gOA1157DRcuXMCRI0egVsvyyi4RkUUUFhbitddeg1arxcCBA0XHsRrZF5/RaMSECRMQGRkpu08mERFZytWrVzFu3Di8++678Pb2Fh3HqmRffADQ0NAAHx8f5OfnY8KECaLjEBHZldbWVgQEBGDu3Ln4n//5H9FxrE4RxQcAx44dw4wZM6DVajFkyBDRcYiI7MasWbPw9ddfIz8/X7b39b5PMTe9wsPDMXfuXLz00kswGo2i4xAR2YXc3FycOnUKO3fuVETpAQpafMA3r9WIjo7Gz3/+c6xfv150HCIiof75z39iwoQJOHHiBEaNGiU6js0oZvEBgFqtxjvvvIN33nkHhw8fFh2HiEiY5uZmaDQabN68WVGlByhs8XU4deoUpkyZgrNnz2LYsGGi4xAR2ZQkSUhMTES/fv0U+UYbRS2+DuPGjcOyZcsQFxcHvV4vOg4RkU1lZGTg8uXLSEtLEx1FCEUuPuCbn3hiYmLg7u6u2C8+ESlPVVUVoqOjcfr0aQwfPlx0HCEUufgAQKVSYffu3SgtLUVhYaHoOEREVtfU1ASNRoPMzEzFlh6g4MXXQavVIioqCqdOncKIESNExyEisgqz2YzJkyfDw8ND8W+uUezi6+Dt7Y033ngDsbGxaG1tFR2HiMgqNm/ejNu3b+MPf/iD6CjCKX7xAd/c75s+fToefvhhZGdni45DRGRRFRUV0Gg0OHv2LNzd3UXHEU7xiw/45n7fjh07cPr0aezevVt0HCIii7l9+zYSEhKQk5PD0vsWF9/31NTUIDQ0FMePH8fo0aNFxyEi6hWTyYTnnnsO/v7+WLduneg4doOL73u8vLywZcsWxMbGorm5WXQcIqJeeeONN2AymbBmzRrRUewKF989zJ49G1999RX27t2rmIe2EpG8lJWVITk5GVVVVXwjzQ9w8d1DWloaPvroI6Snp4uOQkTUbZ9++imSkpKQn5/P0rsHLr77uH79OgIDA1FaWgpfX1/RcYiIusRgMCA0NBQvvPACli9fLjqOXeLiu4+nnnoKmZmZiIuLQ1NTk+g4RERdsnz5cgwYMAC/+tWvREexW1x8D7B48WJ8/PHHKC4uhlrNnxOIyH6VlJTglVdeQXV1NQYNGiQ6jt1i8T2AXq/H+PHjERMTg2XLlomOQ0R0T7W1tQgICMDBgwcREBAgOo5dY/F1QX19Pfz8/LBv3z6EhISIjkNE9G/a2towbtw4zJgxA4sWLRIdx+6x+Lro6NGjSElJQXV1NVxdXUXHISL6zrx583D79m0UFhbyV7C6gDetuig6OhozZ85EYmIiTCaT6DhERACAgoIClJeXIzs7m6XXRVx83WAymRAREYHg4GA+CYGIhLt8+TJCQkJQXl6OZ555RnQch8Hi66bGxkZ4e3sjJycHkZGRouMQkUK1tLTAz88PixcvxqxZs0THcSgsvh44efIkEhIScO7cOQwdOlR0HCJSGEmSkJSUBJVKhd27d/MSZzfxHl8PhIaG4pVXXkF8fDwMBoPoOESkMNnZ2aiurkZ6ejpLrwe4+HrIbDZj4sSJ8PT0xKZNm0THISKFOH/+PCIiIvDBBx/A09NTdByHxMXXQ2q1Gnl5eSgqKkJxcbHoOESkADqdDhqNBmlpaSy9XuDi66XKykpMnDgRZ86cgYeHh+g4RCRTkiRBo9HA1dWVb47pJS6+XvL398fKlSuh0WjQ1tYmOg4RyVRaWho++eQTbN26VXQUh8fFZwGSJCE+Ph6DBg1CRkaG6DhEJDNnzpzBpEmTeGXJQrj4LEClUiErKwvHjh1DQUGB6DhEJCN37txBfHw83n77bZaehXDxWdCFCxcQHh7OT1sRkUWYzWa8+OKL8PLywsaNG0XHkQ0uPgsaM2YMNmzYgNjYWLS0tIiOQ0QObsOGDfjqq6/wu9/9TnQUWeHiszBJkpCcnAyz2Yzc3Fz+cikR9ciJEyeQmJjIJ0RZARefhalUKqSnp+Pvf/87srKyRMchIgd08+ZNTJs2DXl5eSw9K+Dis5IrV64gODgYZWVlePbZZ0XHISIHYTQaER4ejtDQUKxevVp0HFni4rOSkSNHYvv27dBoNNDpdKLjEJGDWLVqFZydnfH666+LjiJbXEO2TqAAAAjLSURBVHxWNn/+fDQ2NqKoqIj3+4ioU0eOHMGcOXOg1Wrh6uoqOo5scfFZ2ZYtW1BfX49t27aJjkJEdqy+vh7JycnYu3cvS8/KuPhsoK6uDgEBASguLsbYsWNFxyEiO6PX6xESEoKpU6di6dKlouPIHovPRg4ePIiFCxdCq9XCxcVFdBwisiOpqamora1FSUkJb4nYAIvPhpYtW4aLFy/i8OHDUKt5lZmIgKKiIixduhTV1dUYOHCg6DiKwOKzIYPBgAkTJiAqKgorVqwQHYeIBLt27RoCAwNx9OhR+Pj4iI6jGCw+G2toaICPjw8KCgoQFhYmOg4RCdLa2oqAgADMmTMH8+bNEx1HUVh8Ahw7dgwzZsyAVqvFkCFDRMchIgFSUlJw9+5dFBQU8L6ejfFGkwDh4eGYM2cOEhISYDQaRcchIhvLy8tDRUUFdu7cydITgItPEJPJhOjoaPj4+PDJ60QKcvHiRYSFheHEiRMYNWqU6DiKxMUnSJ8+fZCfn489e/agtLRUdBwisoHm5mbExsZi06ZNLD2BuPgE+/DDDzF16lScPXsWw4YNEx2HiKxEkiQkJibiscce45tbBOPiEywoKAhLly5FfHw89Hq96DhEZCWZmZm4dOkStm/fLjqK4nHx2QFJkhATE4Nhw4bxmZ5EMlRVVYXo6GicPn0aw4cPFx1H8bj47IBKpUJOTg4OHTqEwsJC0XGIyIKampoQFxeHjIwMlp6d4OKzI1qtFlFRUfypkEgmJEnC5MmT8Z//+Z+8mmNHuPjsiLe3N9auXYvY2Fi0traKjkNEvbR582Y0NjZi48aNoqPQ93Dx2RlJkjBt2jQ8+uij/OQXkQPjJ7btFxefnVGpVNi5cydOnTqF3Nxc0XGIqAdu376NhIQE7Nq1i6Vnh7j47FRNTQ1CQ0P5dAciB2MymRAVFQVfX18+lclOcfHZKS8vL2zevBmxsbFobm4WHYeIuui3v/0tDAYD1q5dKzoK3QcXn53jE9yJHEd5eTmSkpL45hU7x8Vn59LS0nDlyhVkZGSIjkJEnWhoaMCMGTOQn5/P0rNzXHwO4Pr16wgMDMSRI0f4lmYiO2QwGDBhwgRERUVhxYoVouPQA3DxOYCnnnoKGRkZiIuLQ1NTk+g4RPQDK1asQL9+/fDrX/9adBTqAi4+B5Kamoq6ujoUFxfzfh+RnTh48CAWLlwIrVYLFxcX0XGoC1h8DkSv12P8+PGYMmUKli5dKjoOkeLV1dXB398fJSUlGDt2rOg41EUsPgdTX18PPz8/FBYWIjg4WHQcIsVqa2tDUFAQpk+fjtTUVNFxqBtYfA7o6NGjSElJQXV1NVxdXUXHIVKk+fPno7GxEUVFRbz14GD44RYHFB0djaSkJEybNg0mk0l0HCLF+dOf/oT33nsPu3btYuk5IC4+B2U0GhEREYHx48dj9erVouMQKcaVK1cQHByM8vJyPPPMM6LjUA+w+BxYY2MjvL29kZOTg8jISNFxiGSvpaUF/v7+WLRoEVJSUkTHoR5i8Tm4kydPIiEhAVVVVXBzcxMdh0i2JEnCzJkzIUkScnNzeYnTgfEen4MLDQ3FwoULER8fD4PBIDoOkWzt2rULVVVVyMjIYOk5OC4+GTCbzZg4cSKefvppvumZyAouXLiA8PBwfPDBB/D09BQdh3qJi08G1Go18vLyUFhYiJKSEtFxiGRFp9MhNjYW27ZtY+nJBBefjFRWVmLixIk4c+YMPDw8RMchcniSJCEuLg4uLi58Q4qMcPHJiL+/P1asWIG4uDi0tbWJjkPk8LZv347a2lps3bpVdBSyIC4+mZEkCRqNBq6urkhPTxcdh8hh8QqKfHHxyYxKpUJ2djbKy8tRUFAgOg6RQ7pz5w7i4uKwc+dOlp4McfHJVMen0CoqKjBy5EjRcYgcRsenpD09PbFp0ybRccgKWHwylpWVhTfffBOVlZV47LHHAADN7e2orG9Ag64ZrQYjHnF2gtuA/vB3H4r+fR8SnJjIurpy/q9fvx6HDx/GyZMn4ezsLDgxWQOLT8Y6njQBAGu2bkP5tVpcuvUFVAAMZvN3f85ZrYYE4OnBLogc8SSGDRwgJC+Rtdxo0qHs6scPPP8HNf8/zJueiKqqKgwdOlRYXrIuFp/MtbS0IGZBKkZOigFU33yD348KgFMfNWK8RiLYw91WEYmsqqK2HgdqrsBoMnd6/gOAsb0dz/bri9kvRNkkG4nBD7fIXPWtO/CaHAvpAaUHABIAg8mMAzVXUFFbb4t4RFbVUXqGLpQeADj17YsrZjXPf5lj8cnYjSbdNz/pdnPUd5RffZPOSsmIrK/j/DeYzA/+w9/D81/+WHwyVnb1Yxi7+U3fwWgyo+xqrYUTEdkOz3+6HxafTDW3t+PSrS+6dHnnXiQANbc+R3O73pKxiGyC5z91hsUnU5X1Db0+hspCxyGyNZ7/1BkWn0w16JphNPfsMk8Hg9mMz3TNFkpEZDs8/6kzTqIDkHW0GowWOc6+A39Bku8YixyLyFZeWL4KT/gG9Po4rXy5syyx+GTqEWfLfGnjYqbg8LrVFjkWka3kVl1A1ac3e32cR/jkFlnipU6ZchvQH07q3n15ndVq/GRAfwslIrIdnv/UGRafTPm7u/X6GJKFjkNkazz/qTMsPpnq37cvnh7sAlUP/74KgNfgx/nganJIPP+pMyw+GYsc8SSc+vTsS+zUR43IEXwPGTkunv90Pyw+GRs2cABivEbCuZvf/M7fPqjanW9pIAfG85/uh5/qlLmOtyx05en0fDsDyQ3Pf7oXvpZIIeqbdCi7WouaW5/f931kXoMfR+QID/6kS7LD85++j8WnMM3telTWN+AzXTNaDQY84uyMnwzoD393N97IJ9nj+U8Ai4+IiBSGH24hIiJFYfEREZGisPiIiEhRWHxERKQoLD4iIlIUFh8RESkKi4+IiBSFxUdERIrC4iMiIkVh8RERkaKw+IiISFFYfEREpCgsPiIiUhQWHxERKcr/B3nnRBbB2dlsAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "nx.draw_circular(graph, node_color=\"#6CAFB7\")" ] @@ -223,10 +307,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ "cost_operators = []\n", @@ -246,10 +328,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 10, + "metadata": {}, "outputs": [], "source": [ "prog = pq.Program()\n", @@ -266,23 +346,47 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "ring_cut_inst = QAOA(CXN, len(graph.nodes()), steps=1, ref_ham=driver_operators, cost_ham=cost_operators,\n", - " driver_ref=prog, store_basis=True, rand_seed=42)" + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_quantum_computer.py:884: RuntimeWarning: Unable to start qvm server, since the specified port 5000 is in use.\n", + " warnings.warn(RuntimeWarning(warning_msg))\n", + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_compiler.py:324: UserWarning: No quilc server running at tcp://127.0.0.1:5555. Compilation using quilc will not be available.\n", + " warnings.warn(f'{e}. Compilation using quilc will not be available.')\n" + ] + } + ], + "source": [ + "from pyquil.api import local_forest_runtime\n", + "from pyquil import get_qc, Program\n", + "with local_forest_runtime():\n", + " qvm = get_qc('6q-qvm')\n", + " ring_cut_inst = QAOA(qvm, range(len(graph.nodes())), steps=1, ref_ham=driver_operators, cost_ham=cost_operators,\n", + " driver_ref=prog, store_basis=True, rand_seed=42)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Fast method for expectation will be used. Noise\n", + " models will be ineffective\n", + "Optimization terminated successfully.\n", + " Current function value: 8.250011\n", + " Iterations: 16\n", + " Function evaluations: 31\n" + ] + } + ], "source": [ "betas, gammas = ring_cut_inst.get_angles()" ] @@ -296,11 +400,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_quantum_computer.py:884: RuntimeWarning: Unable to start qvm server, since the specified port 5000 is in use.\n", + " warnings.warn(RuntimeWarning(warning_msg))\n", + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_compiler.py:324: UserWarning: No quilc server running at tcp://127.0.0.1:5555. Compilation using quilc will not be available.\n", + " warnings.warn(f'{e}. Compilation using quilc will not be available.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({(0, 1, 0, 1, 0, 1): 160, (1, 0, 1, 0, 1, 0): 137, (1, 1, 0, 1, 1, 0): 39, (0, 1, 0, 0, 1, 1): 38, (0, 0, 1, 0, 1, 1): 36, (1, 0, 0, 1, 0, 1): 36, (0, 1, 1, 0, 0, 1): 35, (1, 1, 0, 1, 0, 0): 34, (0, 1, 0, 0, 1, 0): 33, (1, 0, 0, 1, 1, 0): 33, (0, 0, 1, 0, 0, 1): 33, (0, 1, 1, 0, 1, 1): 32, (1, 0, 1, 1, 0, 0): 31, (0, 0, 1, 1, 0, 1): 31, (0, 1, 0, 1, 1, 0): 30, (1, 0, 1, 1, 0, 1): 30, (1, 1, 0, 0, 1, 0): 29, (1, 0, 1, 0, 0, 1): 26, (0, 1, 1, 0, 1, 0): 23, (1, 0, 0, 1, 0, 0): 20, (1, 0, 1, 0, 0, 0): 14, (0, 1, 0, 1, 1, 1): 12, (0, 1, 0, 0, 0, 1): 12, (1, 0, 1, 0, 1, 1): 11, (1, 1, 1, 0, 1, 0): 8, (0, 0, 0, 1, 0, 1): 8, (0, 1, 1, 1, 0, 1): 8, (1, 0, 0, 0, 1, 0): 7, (0, 1, 0, 1, 0, 0): 6, (0, 0, 1, 0, 1, 0): 6, (1, 1, 0, 1, 0, 1): 6, (1, 0, 1, 1, 1, 0): 5, (0, 0, 0, 0, 0, 1): 4, (1, 1, 1, 1, 0, 1): 3, (0, 1, 1, 1, 0, 0): 3, (1, 1, 1, 0, 0, 0): 3, (1, 1, 1, 1, 1, 0): 3, (1, 1, 1, 0, 1, 1): 3, (0, 0, 0, 1, 0, 0): 2, (1, 1, 0, 1, 1, 1): 2, (1, 0, 0, 0, 1, 1): 2, (0, 1, 0, 0, 0, 0): 1, (0, 0, 1, 1, 1, 0): 1, (1, 0, 1, 1, 1, 1): 1, (0, 0, 0, 0, 1, 0): 1, (1, 0, 0, 0, 0, 0): 1, (0, 0, 1, 0, 0, 0): 1})\n", + "The most frequently sampled string is (0, 1, 0, 1, 0, 1)\n" + ] + } + ], "source": [ "from collections import Counter\n", "\n", @@ -309,15 +430,18 @@ "sampling_prog = param_prog(np.hstack((betas, gammas)))\n", "\n", "# use the run_and_measure QVM API to prepare a circuit and then measure on the qubits\n", - "bitstring_samples = CXN.run_and_measure(sampling_prog, range(len(graph.nodes())), 1000)\n", - "bitstring_tuples = map(tuple, bitstring_samples)\n", + "with local_forest_runtime():\n", + " qvm = get_qc('6q-qvm')\n", + " bitstring_samples = qvm.run_and_measure(sampling_prog, 1000)\n", + " shots = np.array([bitstring_samples[qubit] for qubit in sorted(bitstring_samples)]).T\n", + " bitstring_tuples = map(tuple, shots)\n", "\n", "# aggregate the statistics\n", "freq = Counter(bitstring_tuples)\n", "most_frequent_bit_string = max(freq, key=lambda x: freq[x])\n", - "print freq\n", + "print(freq)\n", "\n", - "print \"The most frequently sampled string is \", most_frequent_bit_string" + "print(\"The most frequently sampled string is \", most_frequent_bit_string)" ] }, { @@ -329,10 +453,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ "# plotting strings!\n", @@ -345,9 +467,9 @@ " ax.set_xlabel(\"state\",fontsize=20)\n", " ax.set_ylabel(\"Probability\",fontsize=20)\n", " ax.set_xlim([0, 2**n_qubits ])\n", - " rec = ax.bar(range(2**n_qubits), probs, )\n", - " num_states = [0, int(\"\".join(str(x) for x in [0,1] * (n_qubits/2)), 2), \n", - " int(\"\".join(str(x) for x in [1,0] * (n_qubits/2)), 2), 2**n_qubits - 1 ]\n", + " rec = ax.bar(range(2**n_qubits),height=list(probs.T[0]))\n", + " num_states = [0, int(\"\".join(str(x) for x in [0,1] * int(n_qubits/2)), 2), \n", + " int(\"\".join(str(x) for x in [1,0] * int(n_qubits/2)), 2), 2**n_qubits - 1 ]\n", " ax.set_xticks(num_states)\n", " ax.set_xticklabels(map(lambda x: inst.states[x], num_states), rotation=90)\n", " plt.grid(True)\n", @@ -357,11 +479,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "t = np.hstack((betas, gammas))\n", "probs = ring_cut_inst.probabilities(t)\n", @@ -377,11 +510,44 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_quantum_computer.py:884: RuntimeWarning: Unable to start qvm server, since the specified port 5000 is in use.\n", + " warnings.warn(RuntimeWarning(warning_msg))\n", + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_compiler.py:324: UserWarning: No quilc server running at tcp://127.0.0.1:5555. Compilation using quilc will not be available.\n", + " warnings.warn(f'{e}. Compilation using quilc will not be available.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Fast method for expectation will be used. Noise\n", + " models will be ineffective\n", + "Optimization terminated successfully.\n", + " Current function value: 8.000007\n", + " Iterations: 97\n", + " Function evaluations: 162\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# get the angles from the last run\n", "beta = ring_cut_inst.betas\n", @@ -390,8 +556,10 @@ "betas = np.hstack((beta[0]/3, beta[0]*2/3))\n", "gammas = np.hstack((gamma[0]/3, gamma[0]*2/3))\n", "# set up a new QAOA instance.\n", - "ring_cut_inst_2 = QAOA(CXN, len(graph.nodes()), steps=2, ref_ham=driver_operators, cost_ham=cost_operators,\n", - " driver_ref=prog, store_basis=True, init_betas=betas, init_gammas=gammas)\n", + "with local_forest_runtime():\n", + " qvm = get_qc('6q-qvm')\n", + " ring_cut_inst_2 = QAOA(qvm, range(len(graph.nodes())), steps=2, ref_ham=driver_operators, cost_ham=cost_operators,\n", + " driver_ref=prog, store_basis=True, init_betas=list(betas), init_gammas=list(gammas))\n", "# run VQE to determine the optimal angles\n", "betas, gammas = ring_cut_inst_2.get_angles()\n", "t = np.hstack((betas, gammas))\n", @@ -408,44 +576,336 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { - "collapsed": false + "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_quantum_computer.py:884: RuntimeWarning: Unable to start qvm server, since the specified port 5000 is in use.\n", + " warnings.warn(RuntimeWarning(warning_msg))\n", + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_compiler.py:324: UserWarning: No quilc server running at tcp://127.0.0.1:5555. Compilation using quilc will not be available.\n", + " warnings.warn(f'{e}. Compilation using quilc will not be available.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Fast method for expectation will be used. Noise\n", + " models will be ineffective\n", + "Optimization terminated successfully.\n", + " Current function value: 7.500000\n", + " Iterations: 14\n", + " Function evaluations: 176\n", + " Gradient evaluations: 22\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from scipy.optimize import fmin_bfgs\n", "\n", - "ring_cut_inst_3 = QAOA(CXN, len(graph.nodes()), steps=3, ref_ham=driver_operators, cost_ham=cost_operators,\n", - " driver_ref=prog, store_basis=True, minimizer=fmin_bfgs, minimizer_kwargs={'gtol':1.0e-3},\n", - " rand_seed=42)\n", - "betas, gammas = ring_cut_inst_3.get_angles()\n", - "t = np.hstack((betas, gammas))\n", - "probs = ring_cut_inst_3.probabilities(t)\n", - "plot(ring_cut_inst_3, probs)" + "with local_forest_runtime():\n", + " qvm = get_qc('6q-qvm')\n", + " ring_cut_inst_3 = QAOA(qvm, range(len(graph.nodes())), steps=3, ref_ham=driver_operators, cost_ham=cost_operators,\n", + " driver_ref=prog, store_basis=True, minimizer=fmin_bfgs, minimizer_kwargs={'gtol':1.0e-3},\n", + " rand_seed=42)\n", + " betas, gammas = ring_cut_inst_3.get_angles()\n", + " t = np.hstack((betas, gammas))\n", + " probs = ring_cut_inst_3.probabilities(t)\n", + " plot(ring_cut_inst_3, probs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Let's generate a random (but seeded) k regular graph." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The most popular method to date was first proposed by Bollobás [2], and is called the pairing model (though it is also sometimes referred to as the configuration model). The algorithm itself is simple:\n", + "\n", + "Begin with a set of n vertices.\n", + "\n", + "Create a new set of nk points, distributing them across n buckets, such that each bucket contains k points.\n", + "\n", + "Take each point and pair it randomly with another one, until ½nk pairs are obtained (i.e., a perfect matching).\n", + "\n", + "Collapse the points, so that each bucket (and thus the points it contains) maps onto a single vertex of the original graph. Retain all edges between points as the edges of the corresponding vertices.\n", + "\n", + "Check if the resulting graph is simple. That is to say, make sure that none of the vertices have loops (i.e., self-connections) or multiple edges (i.e., more than one connection to the same vertex). If the graph is not simple, restart.\n", + "\n", + "Algorithm taken from: https://egtheory.wordpress.com/2012/03/29/random-regular-graphs/" ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "seed = 137\n", + "np.random.seed(seed)\n", + "k = 4\n", + "num_vertices = 12\n", + "n_qubits = num_vertices\n", + "def make_graph_instance(num_vertices, k):\n", + " node_edges = [[i,j] for i in range(num_vertices) for j in range(k)]\n", + " pairs = []\n", + " while len(node_edges) > 0:\n", + " el_1 = node_edges.pop(np.random.randint(len(node_edges)))\n", + " el_2 = node_edges.pop(np.random.randint(len(node_edges)))\n", + " pairs.append((el_1, el_2))\n", + " edges = [(pair[0][0], pair[1][0]) for pair in pairs]\n", + " return edges\n", + "\n", + "def make_simple_graph(num_vertices, k):\n", + " simple = True\n", + " edges = make_graph_instance(num_vertices, k)\n", + " for edge in edges:\n", + " if edge[0] == edge[1]:\n", + " simple = False\n", + " break\n", + " if simple:\n", + " return edges\n", + " else:\n", + " return make_simple_graph(num_vertices, k)\n", + " \n", + "edges = make_simple_graph(num_vertices, k)\n", + "graph = nx.Graph()\n", + "for edge in edges:\n", + " graph.add_edge(*edge)\n", + "nx.draw_circular(graph, node_color=\"#6CAFB7\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "cost_operators = []\n", + "driver_operators = []\n", + "for i, j in graph.edges():\n", + " cost_operators.append(PauliTerm(\"Z\", i, 0.5)*PauliTerm(\"Z\", j) + PauliTerm(\"I\", 0, -0.5))\n", + "for i in graph.nodes():\n", + " driver_operators.append(PauliSum([PauliTerm(\"X\", i, 1.0)]))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "prog = pq.Program()\n", + "for i in graph.nodes():\n", + " prog.inst(H(i))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Be careful, I think there is a reference to an external variable floating around with the ring cut instance.\n", + "from pyquil.api import local_forest_runtime\n", + "from pyquil import get_qc, Program\n", + "def k_regular_maxcut_with_particular_p(p):\n", + " with local_forest_runtime():\n", + " qvm = get_qc(f'{num_vertices}q-qvm')\n", + " cut_inst = QAOA(qvm, range(len(graph.nodes())), steps=p, ref_ham=driver_operators, cost_ham=cost_operators,\n", + " driver_ref=prog, store_basis=True, rand_seed=42)\n", + " betas, gammas = cut_inst.get_angles()\n", + " from collections import Counter\n", + "\n", + " # get the parameterized program\n", + " param_prog = cut_inst.get_parameterized_program()\n", + " sampling_prog = param_prog(np.hstack((betas, gammas)))\n", + "\n", + " # use the run_and_measure QVM API to prepare a circuit and then measure on the qubits\n", + " with local_forest_runtime():\n", + " qvm = get_qc(f'{num_vertices}q-qvm')\n", + " bitstring_samples = qvm.run_and_measure(sampling_prog, 1000)\n", + " shots = np.array([bitstring_samples[qubit] for qubit in sorted(bitstring_samples)]).T\n", + " bitstring_tuples = map(tuple, shots)\n", + "\n", + " # aggregate the statistics\n", + " freq = Counter(bitstring_tuples)\n", + " most_frequent_bit_string = max(freq, key=lambda x: freq[x])\n", + " print(\"The most frequently sampled string is \", most_frequent_bit_string)\n", + " n_qubits = graph.number_of_nodes()\n", + " t = np.hstack((betas, gammas))\n", + " probs = cut_inst.probabilities(t)\n", + " plot(cut_inst, probs)\n", + " return most_frequent_bit_string" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_quantum_computer.py:884: RuntimeWarning: Unable to start qvm server, since the specified port 5000 is in use.\n", + " warnings.warn(RuntimeWarning(warning_msg))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Fast method for expectation will be used. Noise\n", + " models will be ineffective\n", + "Optimization terminated successfully.\n", + " Current function value: 98.315049\n", + " Iterations: 15\n", + " Function evaluations: 29\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/apolloreno/anaconda3/envs/estuary/lib/python3.7/site-packages/pyquil/api/_quantum_computer.py:884: RuntimeWarning: Unable to start qvm server, since the specified port 5000 is in use.\n", + " warnings.warn(RuntimeWarning(warning_msg))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The most frequently sampled string is (1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cut = k_regular_maxcut_with_particular_p(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "18" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from networkx.algorithms.cuts import cut_size\n", + "def cut_to_cut_set(cut):\n", + " cut_set = []\n", + " for i, node in enumerate(cut):\n", + " if node == 1:\n", + " cut_set.append(i)\n", + " cut_size(graph, cut_set)\n", + " return cut_set\n", + "cut_size(graph, cut_to_cut_set(cut))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "max_cut = 0\n", + "for cut_string in range(2**graph.number_of_nodes()):\n", + " cut_string = list([int(s) for s in bin(cut_string)[2:]])\n", + " prepend = [0 for _ in range(graph.number_of_nodes() - len(cut_string))]\n", + " cut_string = prepend + cut_string\n", + " max_cut = max(max_cut, cut_size(graph, cut_to_cut_set(cut_string)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python [default]", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.13" + "pygments_lexer": "ipython3", + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 }