{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "(hadamrd-test)=\n", "\n", "# Hadamard test y swap test\n", "\n", "```{index} Hadamard test, Swap test\n", "```\n", "\n", "\n", "En este apartado vamos a ver dos cuestiones muy útiles en el mundo de la programación cuántica\n", "\n", "* El Hadamard test que no permite calcular la parte real imaginaria del valor esperado de un qubit vía una puerta unitaria U\n", "\n", "* El swap test, que nos permite ver si dos qubits son los mimos o son ortogonales\n", "\n", "## Hadamard test\n", "\n", "```{index} ancilla registro\n", "```\n", "\n", "Con este test lo que se pretende es encontrar una expresión que aparece muchas veces en los problemas de computación cuántica, y este valor sería el siguiente:\n", "\n", "$$\\langle\\psi|U|\\psi\\rangle$$\n", "\n", "Es decir, con esa expresión lo que calculamos es valor esperado de $|\\psi\\rangle$ a través de U.\n", "\n", "Para calcular estos valores deberemos montar el siguiente circuito\n", "\n", "![](../images/HadamardTest.PNG)\n", "\n", "Es decir, hacemos pasar nuestro estado $|\\psi \\rangle$ por nuestra puerta U , y además creamos otro qubit auxiliar (ancilla qubit ) en estado $|0\\rangle$ al que aplicamos una puerta H y después una puerta control sobre dicha puerta U y además en el qubit auxiliar se vuelve a aplicar una puerta H y medimos ese circuito auxiliar. Pues bien el resultado que obtenemos con esta medición es $Re($\\langle\\psi|U|\\psi\\rangle$). La demostración de que esto es así se puede encontrar en este documento que se ha entresacado de este vídeo .\n", "\n", "Al hacer la medición tenemos que :\n", "\n", "$$Re(\\langle\\psi|U|\\psi\\rangle)=P(|0\\rangle)-P(|1\\rangle)$$\n", "\n", "Para obtener la parte imaginaría tendremos que añadir al circuito anterior un puerta $R_{Z}\\left(\\frac{-\\pi}{2}\\right)$ en el primer qubit auxiliar justo después de la primera puerta H,\n", "\n", "\n", "![](../images/HadamardTest_2.PNG)\n", "\n", "El resultado anterior tiene su mérito, pues es muy utilizado en computación cuántica, pero se puede extender su resultado para que podamos podamos obtener por ejemplo el valor de un producto interno como $<\\varphi|\\psi>$. Como vemos aquí entran en juego dos estados quánticos, mientras que en el test de Hadamard sólo se trabaja con un qubit. LA idea es que de alguna forma se pueda poner lo anterior en la forma $\\langle0|U|0\\rangle$, y después de construir la puerta U (como se verá a continuación) entonces aplicando el test de Hadamard se podrá obtener $Re(<\\varphi|\\psi>)$. La forma de conseguir esto lo vemos en el siguiente gráfico:\n", "\n", "![](../images/TestHadamard_3.PNG)\n", "\n", "\n", "La puerta U que conseguimos con este enfoque sigue siendo una puerta unitaria, por lo que podremos aplicar el test de Hadamard al qubit $|0\\rangle$ y a esta puerta U. La situación en la que nos encontraremos ahora, se muestra en el siguiente gráfico:\n", "\n", "![](../images/TestHadamard_4.PNG)\n", "\n", "Y la parte imaginaria la conseguimos siguiendo el siguiente esquema:\n", "\n", "![](../images/TestHadamerd_5.PNG)\n", "\n", "A continuación implementamos el código en qiskit que utiliza toda esta teoría para obtener el producto interno de dos estados cuánticos\n" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'qiskit': '0.46.0', 'qiskit-aer': '0.13.2', 'qiskit-ignis': None, 'qiskit-ibmq-provider': None, 'qiskit-nature': None, 'qiskit-finance': None, 'qiskit-optimization': None, 'qiskit-machine-learning': None}" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import qiskit\n", "qiskit.__qiskit_version__" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [], "source": [ "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, transpile\n", "from qiskit import execute, Aer\n", "import numpy as np\n", "from qiskit.tools.visualization import circuit_drawer" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A continuación creamos una función que sirve para crear un circuito cuántico parametrizado y que servirá para crear los estados " ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAADuCAYAAADiHtp5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxgElEQVR4nO3de1xU5f73/9ccOAqIAwoIHtgcREFRI0msLeaRb1mW1ZftIb+l+2flt3Zb9/ZWv9nD+3Zv687qtp/btrttj1/5VSt3bQ9pWmlp7W41RVFBwUMmAiMKyEGOM8z8/qAZRWaEwWHNDH6ej8c8irXWtdY1OMx7Xde6rrVU5eXlZoQQQggFqF1dASGEEHcPCR0hhBCKkdARQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYCR0hhBCKkdARQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYCR0hhBCKkdARQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYCR0hhBCKkdARQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYCR0hhBCKkdARQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYCR0hhBCKkdARQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYrasrIDyf2QyGJlfXwjFeGlCpnLMvsxlMRufsSylqrfPevxCOkNARd8zQBK991cPV1XDI4gnX8HbSp99khOz1nvX+hz59DY2Xq2sh7kbSvSaEEEIxEjpCCCEUI6EjhBBCMRI6QgghFCOhI4QQQjESOkIIIRQjoSOEEEIxMk9HCBc5fn4ff1g7psUyX+9uRPWMZ9zwmUwZ9SIajfyJiq5FPtFCuFh68r+TOvBhzJi5Vn2Zr7PWs/bz+RRcOc3vn3jP1dUTwqkkdIRwsZjeQxl3zwzrz5PTXmD2yoHs+nEdz0z6M8EBPV1YOyGcS67pOFl0dDQ6nY6SkhKHyvXr1w+dTkdFRUXnVEx4DD/vbiT0TcVsNlNcdt7V1RHCqaSl40QFBQVUVlYSGhpKWFiYQ+Wqq6sJDw8nODi41frVq1dTU1PDvHnzCAwMdGKNhbvS/xI2Qf4hLq6JEM4loeNEOTk5ACQmJjpUrrCwkLi4OFJSUlqtq6qqYtmyZfj7+7Nw4UKn1FO4l3pDLZU1pZjNzdd0Pj+wlnNFxxjQ516iesa5unpCOJWEjhOdPHkScDx00tLSOHTokM11x48fx2w2k5iYiFotvaFd0cY9y9m4Z3mLZaMSp/DS4391UY1cq8EAx4t8uHRNS2MT+GjNRIcYSerdiJfG1bUTd0pCx4lyc3MBSEpKcto+jx8/DsCQIUOctk93VXhqH5+tGEPaU69x7yOLbG7z7uwAekWn8MQr+5StXCeaNGI2Y5IzaTIZ+flyDh9/+zrXrpfg4+Vn3abR2MC8VfcwZtg0po1dYl3+xsf/QcX1ElbM2eWKqjtVkwn25PmRdckHQ1PLh/2cLPbhqzw/Uvs18Ou4etTyLCCP1eVPncvKyli6dCnDhw8nIiKCpKQkXnnlFerq6pg7dy46nY7169dbtz9//jw6nY5BgwbZ3efIkSPR6XRkZ2e3WH5zS+fgwYNMnz6d2NhYIiMjycjI4Pvvv7e5v8TERHQ6HRcuXLAu27ZtGzqdjldffRWAdevWodPprK/Vq1d39Fci3ExkSCzD48dxb8Iknkz/A8uf3UFewSHe+efz1m28tT4szFzPR9+s4Hxx84nIDzlbOXj6c+Y/+b6rqu40xibYdDiAgz/7tgoci3qDmv3n/PhndjdMZoUrKJymS4dObm4uo0aNYs2aNVy9epUBAwZgMBh49913mTt3LufOnQNatkwswTF48GCb+6ytreXcuXNoNBoSEhKsy6uqqigoKECr1bJ3714efvhhsrKyiIyMBODQoUNMnTqVffv2tdhfeXk5er2egIAA+vfvb11eU1NDamoqPj4+ACQnJ5Oammp9jRgx4o5/P8I9Dep3H2OHz+Db7I84dfGgdXlc1HCeSl/IGx8/zdWKQlZ9NpcXH1tDaPfeLqytc3yR689PZV5AW2liJlfvzbdnfJWolugEXTZ0ysrKyMzM5MqVK7z00kucPn2affv2kZ+fz5IlS9ixYwcnT55ErVYzcOBAaznLYAB73Vk5OTk0NTURGxuLr++ND35ubi5mc/MfzNtvv83atWs5deoU+/fvJycnh7S0NIxGI4sXL26xP0vIDRo0CNVNzw+eNm0aO3bsQKVSoVKp2L59O7t27bK+UlNTnfOLEm5p+rilqNUaPvxyaYvl0x5cglbjzfOrhpEck86YoZkuqqHzVNWpyC70/uWntvrNmtf/+LMvDYZOrZboJF02dBYtWkRRUREvvPACy5YtIyAgwLpuwYIFxMXFYTQaiYmJwc/vRt95Wy0dy/pbr9tYlhuNRtatW8cTTzxhvfDfo0cPVq1aBUB+fj6XLl2ylrOEnK3jnTlzhvr6evr3739XDZU2NtZSV11q83W3iAyNZUxyJkfP7uHkTze6ZTUaLUnR91NZU8rElGdcWEPnybrkg7nNsGmpsUnFiWKfTqqR6ExdMnTy8vLYsmULPXv2ZMmSJa3Wq1Qqhg4dCrQOj7ZaOpYL+/bKZWRkMGHChFblYmNjCQ0NBaC4uNi63DL4wNaIt/YMTLh48SLTpk2jb9++REdH8/zzz1NeXm53e0/w49blvPd8T5svQ0ONq6unmN+M/S/UKjUffvWqdVnOhR/Y/eP7PDrqP3l3++9oMNS5sIbOce6qVwfLyTgoT9Ql/9U+/fRTTCYTTz75JP7+/ja38fZubs7f/IVeWlqKXq8nKCiIfv362Sx34sQJoHVIWELnmWfsn30GBgZSWlraotVlr+V08zp7ra7q6moeeeQRevTowd///nfq6upYtmwZmZmZ7N69u0NDrB988EGH76ag8fJj6grnzZxPHD2b+JG2u422vzXZKcdISUmhyUlf2N5aP9a95Pj7T45J5+uV9q9h9AsbyJdvNFl/rmusYeUns3g24zUmj3yeBWtHs+6LRcx79B2Hj52SkkKj0T0CK2Ph9wT2jHG43A8Hj/GnWY91Qo1EW8LCwvjmm286VLZLhs7+/fsBeOCBB+xuY2lt2BpEMGTIkBbXVywMBgN5eXmtyjU1NZGXl4dWqyUtLc3m8RobG9Hr9ahUKuvgAoPBwJkzZ1Cr1TZHy92u6w3gww8/RK/Xs3PnTqKiogCIiIggIyODXbt28dBDD9l9//aUlJSg1+sdKqP1sR3sHdU9LJa+SeNsrlOrnTNR43LJZYwNtU7Zl6+Xc9+/PX/bPp+wHv15JO0FVCoVf3zqA55bNZT7kx4jOSbdoX2VXL5MvcE57/9O1dVUEdiB28vVVJc7/FkVrtclQ6ewsBCAPn362Fzf0NBAVlYW0LLFcrtWB8CBAwdobGwkNDSU8PBw63LLtZeIiAi7LasDBw5QX19PcnKy9VY3eXl5GAwG4uLibJZrq3vtq6++4r777rMGDkBqaip9+/Zl9+7dHQodR27fY6G5aT6JpwgPC3dqS6ezHc7bzb7jn/De/BPWE6LeoTHMznidNz95hr/NP4G/b/uv+4WFh7tNS6f6cg69+g9zuFzNldNERER0Qo1EWzryPWHRJUOnpqa537+hocHm+s2bN1NVVYVOp6N37xvDTc+cOQNAfHy8zXJbtmwBWnetWcLB3vEAPvjgAwAef/xx6zJLS8ZWqJSUlHDlyhV0Op21ZXSr/Px8Hn300VbLBwwYQH5+vt263E5HmsyNRnjtqw4dzmWOHDmCt5M+/U0GyF7f9nZ34t6ESWxdXtFq+aOj5vHoqHkO7+/IkSNoOnYpxekuV2n427+gebh0+wYUqFRm1q14lqD/0zUGU9xNuuRAAksK3zp5E5pbQcuXN99y5NbwqKqqsrvPAwcOsGHDBsD+yLXy8nIuXrzYqux3333H9u3b6dWrF7Nnz7Yuv13onD/ffI0gOjrabp0qKiro3r17q+XBwcFyt2rhMcKDmuinM9DewAEYFG4gyE9miHqiLhk6o0ePBprny1gmgAIcPnyYKVOmUFlZCbQOHUt33IYNG6xf2iaTia1btzJz5kzrRE17I9e8vLxYsGAB1dXVAJjNZnbs2MGsWbNQqVSsWbOmRTfa7ULHsl1xcbG15dZelvlCQniKqUNr6O5nGTRh7/PbvLxXoJGHk9zjepRwXJcMnZdffpng4GCKiopIS0tj1KhR3HPPPUycOJH4+Hjuu+8+oPWXfWZmJhqNhqNHj5KYmEhqaioxMTHMmTOHF198kV69etksZ+lee/PNN9m3bx+JiYmMGzeOpKQknn76aaqrq1m5ciVjx461Wc5W6CQkJBAVFYVer2fIkCFMmDCBjIwMa2sLmls0lgC9WWVlpc1HJAjhrgJ9zTw7spqoYCP2WzwqYkIN/Md91/H1khMrT9UlQycqKoqdO3cyfvx4fH19uXTpEiEhIbzzzjts3LiRs2fPAq2/7AcPHsymTZsYNmwYarWaiooK0tPT2b17N3PmzOHixYt4e3u3uOZz87WXmTNnsmnTJuLj4zl9+jSNjY1MnjyZPXv2tBpKXVRURHl5OSEhITYvhvr6+rJ582YyMjLQarVkZWVx6NChFpNE4+PjbV67yc/Pt3tdyp1FDUrndxvMdm/2CfDC+9e71M0+xQ1BvwTPsyOrGNK7AZWqOVhUKjPD+zQw9/4qZoy4jp8EjkdTlZeX31X/gteuXSMmJgatVsulS5esXWaeaPXq1fzpT38iKyvLOoLt8OHDTJw4kfXr1/Pwww8rUo/mgQQ9FDmWsyyecM3JAwk86/0Pffqa2wwksOftb7pTXa8m0NfE/Adbt+iFZ+qSo9du59SpUwDExcV5dOAAzJo1i7///e/MnDmTRYsWUV9fz7Jlyxg+fDj/9m//5urqiTvwP96bwLXqy6hUavx9A5n36GpiI4e6ulpC3LG7NnSc+cwbVwkKCmLbtm0sXryYOXPmoNFomDhxIn/+85/lgW8ebunMzQT4BQPNjzB46x/P8teXj7q2UkI4wV0bOo4+3dNdRUdH8/HHH7u6GsLJLIEDUFNfiUolJxGia5DQEcJN/e+Pnub4+W8BWDFnt4trI4Rz3HWh8+WXX7q6CkK0y//4TfNtDr468iHv7fwjK2Z/4eIaCXHnpM0uhJubkDKL4+e+paqmzNVVEeKOSegI4WZq6qsorbzxzKV/ndxCULcQAv11LqyVEM5x13WvCeHuauor+V/rp9JgqEOtUtO9W0+WP7PD5uM2hPA0EjpCuJlewX34y0s/uroaQnQK6V4TQgihGAkdIYQQipHQEUIIoRgJHSGEEIqR0BFCCKEYGb0m7piXpvlRAZ7ES+O8fam1zY8K8CRq+csXLiIfPXHHVCqc9mwaT6RS4fbPphHCXUj3mhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxUjoCCGEUIyEjhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxUjoCCGEUIyEjhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxdzFz3sUzmI2g6HJ1bVwjJem+YmfzmA2g8nonH0pRa113vsXwhESOuKOGZrgta96uLoaDlk84ZrTHrFtMkL2es96/0OfviaP2BYuId1rQgghFCOhI4QQQjESOkIIIRQjoSOEEEIxEjpCCLdkNrf8r+gaZPSaEMLlzGa4UKblp1It+iot+koNdYbmc+LrDWre3NOd3t2biOhuJLangajgJhny7aEkdIQQLtNghGOXfDhS4ENZjcbudjWNas5eVXP2qhffnfMjLNBISr8GhkY2orVfTLghCR0hhEv8VKpl+wl/KusdT42Sai07c7Qc+tmXKUNqiAz2sNnJdzEJHSFc5Pj5ffxh7ZgWy3y9uxHVM55xw2cyZdSLaDRd70+0yQRfnvbj8EXfO95X6XUN7//fQO6PrWdMXL10uXmArveJFsLDpCf/O6kDH8aMmWvVl/k6az1rP59PwZXT/P6J91xdPacyNsGnx7qRf8Xbafs0o+L7c35U16t5ZHCtBI+bk9FrThYdHY1Op6OkpMShcv369UOn01FRUdE5FRNuK6b3UMbdM4Px98zkqfQ/8v++eJCewX3Y9eM6Kq5fdXX1nMZshi3HnRs4N8su9OGLXD8Z7ebmJHScqKCggMrKSkJDQwkLC3OoXHV1NeHh4QQHB7dav3r1al5//XWqq6udWFvhrvy8u5HQNxWz2Uxx2XlXV8dpDv3sw6nLnRM4FkcKfMnVy03l3Jl0rzlRTk4OAImJiQ6VKywsJC4ujpSUlFbrqqqqWLZsGf7+/ixcuNAp9RTuT/9L2AT5h7i4Js5RVqNmb76fQ2XmT4IgP6iqg7d3t7/cF7n+9A+pIsBHmjzuSELHiU6ePAk4HjppaWkcOnTI5rrjx49jNptJTExErZaGaVdUb6ilsqYUs7n5ms7nB9ZyrugYA/rcS1TPOFdXzym+yPHHaHLsYkuQHwT7O36sOoOar0/78djQWscLuwmTGYorNNQ0qlGrzIR0M6HrZnJ1tZxCQseJcnNzAUhKSnLaPo8fPw7AkCFDnLZPd1V4ah+frRhD2lOvce8ji2xu8+7sAHpFp/DEK/uUrVwn2rhnORv3LG+xbFTiFF56/K8uqpFzXalW81OZsl1eOXpvxg+s87jWTp1BRVaBN1kFPlTUtRxK3j/EwL19GxgYbvDowRJd/tS5rKyMpUuXMnz4cCIiIkhKSuKVV16hrq6OuXPnotPpWL9+vXX78+fPo9PpGDRokN19jhw5Ep1OR3Z2dovlN7d0Dh48yPTp04mNjSUyMpKMjAy+//57m/tLTExEp9Nx4cIF67Jt27ah0+l49dVXAVi3bh06nc76Wr16dUd/JcLNTBoxm//9269ZMXsX/89DKwnyD+Ha9RJ8vG50RzUaG/jtm0ls2ruiRdk3Pv4PlqzLULrKDjlS4KP4MU1mFUcvKX/cO3GtVs26HwLZm+/fKnDAzM9lXvzjWABbT/jT5MGNni7d0snNzWXq1KlcuXKFbt26MWDAAPR6Pe+++y4FBQUUFRUBLVsmluAYPHiwzX3W1tZy7tw5NBoNCQkJ1uVVVVUUFBSg1WrZu3cvf/rTnwgNDSUyMpJz585x6NAhpk6dyubNm0lPT7eWKy8vR6/XExAQQP/+/a3La2pqSE1NJTs7m4aGBpKTk/H1vTGvYcSIEc74FQk3EBkSy/D4cQDcmzCJxOj7+f2aUbzzz+dZMn0TAN5aHxZmrmf+X39N6sCHiOmdzA85Wzl4+nPem3/SldW/LbMZThZ17uABe44XevPr2HqXHNtRNQ0q/vvHAK7V2psoa2namDlR5INahccOD++yLZ2ysjIyMzO5cuUKL730EqdPn2bfvn3k5+ezZMkSduzYwcmTJ1Gr1QwcONBazjIYwF53Vk5ODk1NTcTGxrYIgdzcXMy/jNV8++23Wbt2LadOnWL//v3k5OSQlpaG0Whk8eLFLfZnCblBgwahuukTNG3aNHbs2IFKpUKlUrF9+3Z27dplfaWmpjrnFyXczqB+9zF2+Ay+zf6IUxcPWpfHRQ3nqfSFvPHx01ytKGTVZ3N58bE1hHbv7cLa3l5ZjZp6o2u+ZsprNdQZPONb+V/nfW8TODdTAWayC30orPDM+/902dBZtGgRRUVFvPDCCyxbtoyAgADrugULFhAXF4fRaCQmJgY/vxvdGG21dCzrb71uY1luNBpZt24dTzzxhPXCf48ePVi1ahUA+fn5XLp0yVrOEnK2jnfmzBnq6+vp378/gYGBDr1/T2ZsrKWuutTm624xfdxS1GoNH365tMXyaQ8uQavx5vlVw0iOSWfM0EwX1bB9iitd25mir3T/L2ZDE2QXOtIabA7SIxc9q/vQokt2r+Xl5bFlyxZ69uzJkiVLWq1XqVQMHTqUs2fPtgqPtlo6lgv79splZGQwYcKEVuViY2MJDQ2ltLSU4uJi+vTpA9wYfGBrxFtbAxOKiopYvXo1x44dIycnh7q6OrKzs+nbt6/N7T3Fj1uX8+PW5W1v2IVFhsYyJjmTvcc2cvKn7xn8qwcA0Gi0JEXfz5nCI0xMecbFtWzb1euuPa+9el3Dr0KNLq1DW/JLvDrUGszVe/NQUi3eHvYt7mHVbZ9PP/0Uk8nEk08+ib+/7TGX3t7NZxY3f6GXlpai1+sJCgqiX79+NsudOHECaB0SltB55hn7XwSBgYGUlpa2aHXZazndvM5eq+vChQts2bKF5ORk0tLS2Lt3r91jt9eDDz7o8N0UNF5+TF3hvEmMiaNnEz/S9hn89rcmO+UYKSkpNBnqnLIvb60f615y/iTO34z9L77N/ogPv3qVN5/7FoCcCz+w+8f3eXTUf/Lu9t+xNia7xYCD9kpJSaHR6Jz3fzvDHl1O3P2zba6zzMOxJ8j3xn+XPXb749iby7PyrXc4/Y17D7oZMPp5kh9e2vaGt2gyqxiVPpHaa4WdUKvbCwsL45tvvulQ2S4ZOvv37wfggQcesLtNcXExYHsQwZAhQ1pcX7EwGAzk5eW1KtfU1EReXh5arZa0tDSbx2tsbESv16NSqYiMjLTu78yZM6jVapuj5W7X9QbN83vy8/MB2LRpk1NCp6SkBL1e71AZrU8HJlPcRvewWPomjbO5Tq12TnfJ5ZLLGBucM4/D16tj7z85Jp2vV9of0tsvbCBfvnHj7sl1jTWs/GQWz2a8xuSRz7Ng7WjWfbGIeY++4/CxSy5fpt7Q+fNY4mqu213X3nk4anXH5utA8wAfRz/PSouoquxw2SslJVSXuff7u1WXDJ3Cwubkt3Rh3aqhoYGsrCygZYvldq0OgAMHDtDY2EhoaCjh4eHW5ZZrLxEREXZbVgcOHKC+vp7k5GTrrW7y8vIwGAzExcXZLNdW91pnTBZ15PY9FpoOnGm7WnhYuFNbOkr42/b5hPXozyNpL6BSqfjjUx/w3Kqh3J/0GMkx6Q7tKyw8XJGWjs9tvmGq2jh8kG9z4JhMUNXGIDR7+/L30RIREXH7wi6mNdkP5ttpMtTTvZuWAG/l319HvicsumTo1NTUAM3hYsvmzZupqqpCp9PRu/eNkT9nzpwBID4+3ma5LVu2AK271izhYO94AB988AEAjz/+uHWZpSVjK1RKSkq4cuUKOp3O2jJSQkeazI1GeO2rTqhMJzpy5IjT+sKbDJC9vu3t7sThvN3sO/4J780/YW2F9w6NYXbG67z5yTP8bf4J/H3bP9jkyJEjaBSYr3myyIt/Hre9rq1b2yx7rLmFU1UPy7Z07Pj/Z8VCokPnd6ywQgxN8PY3JuoNjp1EDu+v4n9lH+mkWnWeLjl6zZLCt07ehOZW0PLlzRepbw2Pqqoqu/s8cOAAGzZsAOyPXCsvL+fixYutyn733Xds376dXr16MXv2jf7t24XO+fPN1wiio6Pt1kncPe5NmMTW5RX06tFykMijo+bx30suOBQ4Soro7tqHq7n6+O3hpYFhUY0OlGjukk3pZ/8k1511ydAZPXo00Dxf5ty5c9blhw8fZsqUKVRWNveh3ho6lu64DRs2WB8xYDKZ2Lp1KzNnzsTHp3mIor2Ra15eXixYsMB6N2iz2cyOHTuYNWsWKpWKNWvWtOhGu13oWLYrLi62ttyE8DQh3Uz4al0zfT6kWxO+Xp5xG5z7Y+rR+bcnIM2AiuF9Goj0gEC1pUuGzssvv0xwcDBFRUWkpaUxatQo7rnnHiZOnEh8fDz33Xcf0PrLPjMzE41Gw9GjR0lMTCQ1NZWYmBjmzJnDiy++SK9evWyWs3Svvfnmm+zbt4/ExETGjRtHUlISTz/9NNXV1axcuZKxY8faLGcrdBISEoiKikKv1zNkyBAmTJhARkaGtbUlhCdQqWBIpCNn8c6T7KLjdoS/t5mZqdcJ7XZzkJht/L+KoVENPJTomXcjgC4aOlFRUezcuZPx48fj6+vLpUuXCAkJ4Z133mHjxo2cPXsWaP1lP3jwYDZt2sSwYcNQq9VUVFSQnp7O7t27mTNnDhcvXsTb27vFNZ+br73MnDmTTZs2ER8fz+nTp2lsbGTy5Mns2bOn1VDqoqIiysvLCQkJsXmh09fXl82bN5ORkYFWqyUrK4tDhw516UmiUYPS+d0Gs92bfQK88P71LnWzz7uBK7qB1Cozw/p4VvdTsJ+JOWlVTEio/aXVc3OqqIgJNZB5z3UeGVyLJ99wvksOJAAYOHAgn3zySavl165d4/Lly2i1WgYMGNBq/fjx4xk/frzNfZaVlbVaFhYWRnl5ufXnCRMm2JwceqvIyMgW5WxJSEhg48aNbe5LCHfWM8BETKiB86XK3Wl6cO9Gj7vDNICPF4z8VQP3RTegr9Sw4XAAdQY13bxNzBjRsVFu7saD87JjTp06BUBcXJz1Go0n27ZtG9u2bbMOmtizZw/btm3j2LFjrq2YcIr//up/Mv6PKi5cznF1Ve7IQ0m1eGmUCQF/bxPjEzp/OHhnUqmgd3AT2l+mpXlyy+ZWXbalY48ldJz5zBtXurXb7g9/+AMAv/nNb1izZo0rqiSc5GzhUU4XHKRXsGff1gigh7+JcQPq2HWq/bM8LXNv2prPc6uHEmvp5oGtnLvFXRs6jj7d01211UUnPFOjsYHVW+axePom/rh2jKur4xT39mvg0jUtOfr23dzSkUdUW4zoX8+gCIPjBYViulCjrX26WuiIrunDL19l7PAZROi6zjwtlQqmJNeQENY5o8qG92lg0kDP7la7G9x1LZ0vv/zS1VUQ4rZO/XyAM5cOM+ffXnd1VZxOo4Ynh9XwVZ6JQz/7tl2gHVQqM6Nj6/l1bL3HDiO+m9x1oSOEuzvx034KruYx87XmVs7VykIW/30i859cx4gE9340dXuo1TBpUB0JYQa2n/Rv58PLbOsVaGTKkFqPuPOAaCahI4SbyXxwEZkP3pirNGNFf5Y/u4Po8K4x+MWif4iR5+6vIrvQhyMFPly93v7wiQgycm+/Bgb3brSO8BKeQUJHCOEy3loY0b+Be/s1UHBNy0+lWvSVWvRVGq43WC45mwnyNRPR3UhEUBOxPQ1EBkvLxlNJ6Ajh5jYs+dnVVeh0KhX00xnpp7vxlE+zGUxmUKuQazVdiISOEMItqVSgkbDpcu66IdNCCCFcR0JHCCGEYiR0hBBCKEZCRwghhGJkIIG4Y14aWDzhmqur4RAvJ87tUGth6NOe9f7V8pcvXEQ+euKOqVTN8y3uVioVaJR7VIwQHk2614QQQihGQkcIIYRiJHSEEEIoRkJHCCGEYiR0hBBCKEZCRwghhGIkdIQQQihGQkcIIYRiJHSEEEIoRkJHCCGEYiR0hBBCKEZCRwghhGIkdIQQQihGQkcIIYRiJHSEEEIoRkJHCCGEYiR0hBBCKOYuft6jcBazGQxNrq6FY7w0zU/8dAazGUxG5+xLKWqt896/EI6Q0BF3zNAEr33Vw9XVcMjiCdec9ohtkxGy13vW+x/69DV5xLZwCeleE0IIoRgJHSGEEIqR0BFCCKEYCR0hhBCKkdARQgihGBm9JoQQbqKuUUVxpQZ9lYayGg11jc3j2usNKo4UeNM7qIlegU1oNS6u6B2Q0BFCCBcymeDMFS8OF/jwU6ntceyGJhU7c7oB4KUxMySykXv71hMWZFKyqk4hoSOEEC5y5oqWL3L9qaxrf9PF0KQiq8CHrAIfYkINPDy4lmA/zwkfCR0hXOT4+X38Ye2YFst8vbsR1TOeccNnMmXUi2g08ifaFdUbVOw+5cfxIp872s/5Ui/++l0Q4wfWck+fRo+4y4R8ooVwsfTkfyd14MOYMXOt+jJfZ61n7efzKbhymt8/8Z6rqyecrKpexX//GEjpdedcmGn8petNX6nloaRa1G4ePBI6QrhYTO+hjLtnhvXnyWkvMHvlQHb9uI5nJv2Z4ICeLqydcKbrDSo+PBhIea3zRwIcveSDyQyPDK516xaPDJl2sujoaHQ6HSUlJQ6V69evHzqdjoqKis6pmPAYft7dSOibitlsprjsvKurI5zEZIKPswI6JXAssgt9+OGnO+uy62zS0nGigoICKisrCQ0NJSwszKFy1dXVhIeHExwc3Gr96tWrqampYd68eQQGBjqxxsJd6X8JmyD/EBfXRDjL/73gQ1GFY1+58ydBkB9U1cHbu9tXZt9ZP+J7GegV6J6DCyR0nCgnJweAxMREh8oVFhYSFxdHSkpKq3VVVVUsW7YMf39/Fi5c6JR6CvdSb6ilsqYUs7n5ms7nB9ZyrugYA/rcS1TPOFdXTzjB1etq9p31c7hckB8E+ztWpsmkYtuJbsxOq3bL6zsSOk508uRJwPHQSUtL49ChQzbXHT9+HLPZTGJiImp11+4NLTy1j89WjCHtqde495FFNrd5d3YAvaJTeOKVfcpWrhNt3LOcjXuWt1g2KnEKLz3+VxfVSDjbD+d9aTIplwDFlVrOXdUS38v9HvQkoeNEubm5ACQlJTltn8ePHwdgyJAhTtuncC+TRsxmTHImTSYjP1/O4eNvX+fa9RJ8vG6cGTcaG5i36h7GDJvGtLFLrMvf+Pg/qLhewoo5u1xRddEOtY0qcvTeih/3yEVf4ntdV/y4benap85AWVkZS5cuZfjw4URERJCUlMQrr7xCXV0dc+fORafTsX79euv258+fR6fTMWjQILv7HDlyJDqdjuzs7BbLb27pHDx4kOnTpxMbG0tkZCQZGRl8//33NveXmJiITqfjwoUL1mXbtm1Dp9Px6quvArBu3Tp0Op31tXr16o7+SoSbiQyJZXj8OO5NmMST6X9g+bM7yCs4xDv/fN66jbfWh4WZ6/nomxWcL24+EfkhZysHT3/O/Cffd1XVRTscL/RWtJVjcfaqlopa9/uKd78aOVFubi6jRo1izZo1XL16lQEDBmAwGHj33XeZO3cu586dA1q2TCzBMXjwYJv7rK2t5dy5c2g0GhISEqzLq6qqKCgoQKvVsnfvXh5++GGysrKIjIwE4NChQ0ydOpV9+/a12F95eTl6vZ6AgAD69+9vXV5TU0Nqaio+Ps0jUZKTk0lNTbW+RowYcce/H+GeBvW7j7HDZ/Bt9kecunjQujwuajhPpS/kjY+f5mpFIas+m8uLj60htHtvF9ZWtOXncld1KKm46LJj29dlQ6esrIzMzEyuXLnCSy+9xOnTp9m3bx/5+fksWbKEHTt2cPLkSdRqNQMHDrSWswwGsNedlZOTQ1NTE7Gxsfj6+lqX5+bmYjabAXj77bdZu3Ytp06dYv/+/eTk5JCWlobRaGTx4sUt9mcJuUGDBqG6aXD9tGnT2LFjByqVCpVKxfbt29m1a5f1lZqa6pxflBsyNtZSV11q83W3mD5uKWq1hg+/XNpi+bQHl6DVePP8qmEkx6QzZmimi2oo2qu40nVf/MVV7ndnUPeLQSdZtGgRRUVFvPDCCyxbtqzFugULFvCPf/yDs2fPEhcXh5/fjb7ztlo6lvW3XrexLDcajaxbt44JEyZY1/Xo0YNVq1YxYsQI8vPzuXTpEn369AFuhJyt4505c4b6+nqio6PvqqHSP25dzo9bl7e9YRcWGRrLmORM9h7byMmfvmfwrx4AQKPRkhR9P2cKjzAx5RkX11K05XqDiusNrju317sw8Oxxvxo5QV5eHlu2bKFnz54sWbKk1XqVSsXQoUM5e/Zsq/Boq6VjubBvr1xGRkaLwLGIjY0lNDSU0tJSiouLraFjGXxga8RbWwMTtm3bxmeffUZ2djZlZWVERUUxefJkXn75ZQICAmyWacuDDz7o8MRWjZcfU1c4bxJj4ujZxI+0fQa//a3JTjlGSkoKTYY6p+zLW+vHupecP4nzN2P/i2+zP+LDr17lzee+BSDnwg/s/vF9Hh31n7y7/XesjcluMeCgvVJSUmg0Ouf9C/u6hycwccE3NtdZ5uDcTpDvjf8ue8z+dvbm8eTm/0zinF+3s7btFxYWxjff2H5fbemSofPpp59iMpl48skn8fe3Pcjd27t5NMnNX+ilpaXo9XqCgoLo16+fzXInTpwAWoeEJXSeecb+2WdgYCClpaUtAsFey+nmdfZaXX/5y1+Iiopi6dKl9O7dmxMnTvDGG2/wr3/9iy+++KJDQ6xLSkrQ6/UOldH6ODiRoA3dw2LpmzTO5jq12jndBZdLLmNsqHXKvny9Ovb+k2PS+Xql2e76fmED+fKNJuvPdY01rPxkFs9mvMbkkc+zYO1o1n2xiHmPvuPwsUsuX6be4Jz3L+wz+oTbXefIHBy12vH5OgAms8rhv+fO1iVDZ//+/QA88MADdrcpLi4GbA8iGDJkSIvrKxYGg4G8vLxW5ZqamsjLy0Or1ZKWlmbzeI2Njej1elQqlXVwgcFg4MyZM6jVapuj5W7X9Qbw0UcfERoaav151KhRhISE8Nxzz3Hw4EG7dbkdR+6kYKHpwJm2q4WHhTu1paOEv22fT1iP/jyS9gIqlYo/PvUBz60ayv1Jj5Eck+7QvsLCw6Wlo4Cg7va7xava8esP8m0OHJMJqurtb2dvXyqaiIiIaPtADurI94RFlwydwsJCAGsX1q0aGhrIysoCWrZYbtfqADhw4ACNjY2EhoYSHn7jDMZy7SUiIsJuy+rAgQPU19eTnJxsvdVNXl4eBoOBuLg4m+Xa6l67OXAskpOTATp8dtORJnOjEV77qkOHc5kjR47g7aRPf5MBste3vd2dOJy3m33HP+G9+SesJ0S9Q2OYnfE6b37yDH+bfwJ/3/Zf9zty5Aga288LE07UYIDXv7a9rj23tVn2WHMLp6oelm1x/Pj3JEXz9i/fI+6iS4ZOTU0N0BwutmzevJmqqip0Oh29e98YbnrmzBkA4uPjbZbbsqX5X/3WrjVLONg7HsAHH3wAwOOPP25dZmnJ2AqVkpISrly5gk6ns7aM2uPAgQMAxMXJ7VO6knsTJrF1eUWr5Y+Omsejo+YpXyHRLj5eENKtibIa14wiiwhyvzsSdMkh05am362TN6G5FbR8efPIqFvDo6qqyu4+Dxw4wIYNGwD7I9fKy8u5ePFiq7Lfffcd27dvp1evXsyePdu6/Hahc/5884Xp6Ohou3W6VXFxMa+99hpjxoyROxgI4SYigpra3qizjt3ddce2p0uGzujRo4Hm+TKWCaAAhw8fZsqUKVRWVgKtQ8fSHbdhwwbrIwZMJhNbt25l5syZ1oma9kaueXl5sWDBAqqrqwEwm83s2LGDWbNmoVKpWLNmTYtutNuFjmW74uJia8vtdq5fv86MGTPQarX85S9/aXN7IYQy4sMaXXJcL42Z6BD3a+l0ye61l19+mX/+858UFRWRlpZGXFwc9fX1XLhwgUmTJhEZGcn333/f6ss+MzOT9957j6NHj5KYmEhUVBRXrlyhurqapUuX8uGHH/Lzzz+3KmfpXnvzzTf5/e9/T2JiIvHx8ej1evR6PWq1mpUrVzJ27Fib5WyFTkJCAlFRURQWFjJkyBBiYmLQaDRMnz6dGTNmtNi2vr6eGTNmcPHiRXbu3NkpFw6VEDUond9tsD+aC+CF993vXlJC3M7AMAPdvE3UNCp7jj+4dyO+Xrf/e3KFLtnSiYqKYufOnYwfPx5fX18uXbpESEgI77zzDhs3buTs2bNA6y/7wYMHs2nTJoYNG4ZaraaiooL09HR2797NnDlzuHjxIt7e3i2u+dx87WXmzJls2rSJ+Ph4Tp8+TWNjI5MnT2bPnj2thlIXFRVRXl5OSEiIzZDw9fVl8+bNZGRkoNVqycrK4tChQ60miRoMBp599lmOHj3K5s2bW9yaRwjheloNDOtj/3pvZ0npq/wx20NVXl7uflHYia5du0ZMTAxarZZLly5Zu8w8kclk4re//S27du3ik08+ue0Q8c7UPHqth0uO3VGLJ1xz8ug1z3r/Q5++JqPXFFRnUPHud0EO353AMnqtotax0WtDIht4LNk952F1ye612zl16hTQPLrLkwMHYOHChWzZsoUFCxbg6+vL4cOHret69+7t0Kg34V5mrOiPt9YXL23zlPTfPLiY9KH/7uJaiY7y8zLzcFItH2d17E4hjgjwMTFpkPvOwbprQ8eZz7xxla+/bp4A8NZbb/HWW2+1WLdw4UIWLbL9IDThGZY+/SnR4Z7/ORXNBoQZGN6ngaOX2n+ya5n02Z6JpAAqzDwyuAY/N7yWY3HXho6jT/d0R5b7wAkhPMNDibXUNqrIK2nfQ93aM4H0BjOTB9cS54ZPC72ZhI4Qbur1TdMxmU0k9E1ldsZrBAf0dHWVxB1Sq+GJYTVsP2HmRLHzuvfVKjNThtQwONLgtH12lrsudL788ktXV0GINr39/Hf06tEXY5OB/2/3K7zxySxWzP7C1dUSTqBRw5TkWn7V08juXD/qjXc2iDgiyMiU5Bp6BZqcVMPOddeFjhCeoFePvgBoNV48/sDLPPOG7VszCc+kUkFyZCO/CjGwN9+PHL3jj7QO8DFxX3Q9I/s30IEbyruMhI4QbqausYamJgMBfsEAfHvsI2J7D3NtpUSnCPQ1MyW5lvEJdRwr9CZX782Vag0ms+0A8tGaiQo2MrxPAwPCDGg8KGwsJHSEcDMV1SX8z/VTMZmaMGMmQvcrFmZ28m2shUt18zFzf0wD98c0YGyCkmoNZTUaDE2gVjWHTVhQEzp/EzaeuuJRJHSEcDMRIb9i7e+PuboawkW0GogMbiIy2P1u1ukMHtg4E0II4akkdIQQQihGQkcIIYRiJHSEEEIo5q67y7RwPrMZDB52zdNLg9NGAZnNYHLvO4+0otY67/0L4QgZvSbumEqF0x4T4IlUKuQxAUK0k3SvCSGEUIyEjhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxUjoCCGEUIyEjhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxUjoCCGEUIyEjhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxUjoCCGEUIyEjhBCCMVI6AghhFCMhI4QQgjFSOgIIYRQjISOEEIIxUjoCCGEUMz/DwfcQze/RiBrAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def build_circ(_circuit, _register, _params, _n_qubits, _barrier = False):\n", " \"\"\"\n", " Implementación de un circuito parametrizado\n", " \"\"\"\n", "\n", " for index in range(_n_qubits):\n", " # Añadimos una puerta de Hadamrd\n", " _circuit.h(index)\n", " # Implementamos una rotación sobre el je x\n", " _circuit.rx(_params[index], _register[index])\n", "\n", " # Añadimo puertas CNOT\n", " for k in range(_n_qubits - 1):\n", " # .cnot está deprecated desde la versión 0.45.0 de qiskit\n", " #_circuit.cnot(_register[k], _register[k+1])\n", " _circuit.cx(_register[k], _register[k+1])\n", "\n", " if _barrier:\n", " _circuit.barrier()\n", "\n", " return _circuit\n", "\n", "# Ahora construimos los circuitos para |psi> and |phi>\n", "nqubits = 3\n", "nb_params = nqubits\n", "\n", "# circuito para |psi>\n", "q = QuantumRegister(nqubits, 'qubit')\n", "circ_psi = QuantumCircuit(q)\n", "params_psi = [el for el in range( nb_params )]\n", "circ_psi = build_circ(circ_psi, q, params_psi, nqubits)\n", "\n", "# circuito para |phi>\n", "p = QuantumRegister(nqubits, 'qubit')\n", "circ_phi = QuantumCircuit(p)\n", "params_phi = [el for el in range( nb_params, 2*nb_params)]\n", "circ_phi = build_circ(circ_phi, p, params_phi, nqubits)\n", "\n", "# Comentar esta línea si no se quiere dibujar el circuito\n", "circuit_drawer(circ_phi, output='mpl', style={'backgroundcolor': '#EEEEEE'})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A continuación, construimos una función que medirá el qubit auxiliar 1000 veces y los promediará como se describe anteriormente (NOTA: Se ha tenido que hacer transpile inicialmente para eliminar error de ejecución):\n", "\n", "```{index} transpile\n", "```" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [], "source": [ "def sigma_z(_circuit):\n", " \"\"\"\n", " Takes in a circuit with an ancilla;\n", " returns the of the measurements on the ancilla alone.\n", " \"\"\"\n", " circuit_copy = _circuit.copy()\n", " c_reg = ClassicalRegister(1, \"c_bit\")\n", " circuit_copy.add_register(c_reg)\n", "\n", " circuit_copy.measure(0, c_reg[0])\n", " nb_shots = 10000\n", "\n", " simulator = Aer.get_backend(\"qasm_simulator\")\n", " # esta instrucción está deprecated\n", " #job = execute(circuit_copy, backend=simulator, shots = nb_shots)\n", " transpiled =transpile(circuit_copy,simulator)\n", " job= simulator.run(transpiled, shots=nb_shots)\n", " result = job.result()\n", " counts = result.get_counts()\n", "\n", " return (counts['0'] - counts['1'])/nb_shots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ahora podemos construir el operador U (la composición de $U_{\\varphi}^{\\dagger}U_{\\Psi}$ que se muestra en los diagramas de circuito anteriores):" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [], "source": [ "# para el circuito phi obtenemos U_phi^dagger\n", "U_phi_dagger = circ_phi.to_gate(label = \"U_phi^dagger\").inverse()\n", "definition = [ q[index] for index in range(nqubits) ]\n", "# para el circuito psi\n", "U_circ = circ_psi.copy()\n", "# Añado ahora los dos circuitos\n", "U_circ.append(U_phi_dagger, definition)\n", "\n", "# Ahora construyo un control U\n", "U_controlled_gate = (U_circ.to_gate(label = \"U\")).control(1)" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-0.2046" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "U_controlled_gate = (U_circ.to_gate(label = \"U\")).control(1)\n", "\n", "anc = QuantumRegister(1, 'ancilla')\n", "q = QuantumRegister(nqubits, 'qubit')\n", "circ_Hadamard = QuantumCircuit(anc, q)\n", "definition = [anc[0]] + [q[index] for index in range(nqubits)]\n", "\n", "\n", "evaluate_complex_part = False # cambiar a True si se quiere evaluar la parte imaginaria\n", "\n", "circ_Hadamard.h(anc[0])\n", "if evaluate_complex_part:\n", " circ_Hadamard.sdg(anc[0])\n", "\n", "circ_Hadamard.append(U_controlled_gate, definition)\n", "circ_Hadamard.h(anc[0])\n", "\n", "# visualizo el circuito\n", "circuit_drawer(circ_Hadamard, output='mpl', style={'backgroundcolor': '#EEEEEE'})\n", "\n", "# mido el circuito auxiliar (anzila)\n", "avg_Z = sigma_z(circ_Hadamard)\n", "avg_Z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NOTA: el valor anterior puede cambiar pero estar cerca del mismo, ya que existe un factor de aleatoriedad que hay que tener en cuenta.\n", "\n", "A continuación se muestra el ´código que sirve para evaluar de una forma analítica esta superposición" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-0.2107957994307797-0.9775301176650976j)" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "simulator = Aer.get_backend('aer_simulator')\n", "circ_psi.save_statevector()\n", "#job = execute(circ_psi, simulator)\n", "job = simulator.run(transpile(circ_psi, simulator))\n", "result = job.result()\n", "psi_state = result.get_statevector()\n", "psi_vector = psi_state.data\n", "\n", "circ_phi.save_statevector()\n", "#job = execute(circ_phi, simulator)\n", "job = simulator.run(transpile(circ_phi, simulator))\n", "result = job.result()\n", "phi_state = result.get_statevector()\n", "phi_vector = phi_state.data\n", "\n", "\n", "phi_vector_dagger = phi_state.conjugate()\n", "overlap = np.dot(phi_vector_dagger, psi_vector)\n", "overlap" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Swap test" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, Aer\n", "from qiskit.visualization import plot_histogram\n", "\n", "q = QuantumRegister(3,'q')\n", "c = ClassicalRegister(1, 'c')\n", "\n", "circuit = QuantumCircuit(q,c)\n", "\n", "circuit.h(q[0])\n", "circuit.x(q[1]) #comentar para hacer ambos estados no ortogonales\n", "circuit.cswap(q[0],q[1],q[2]) #puerta controlada swap\n", "circuit.h(q[0])\n", "circuit.measure(q[0],c[0])\n", "\n", "circuit.draw('mpl',style='iqp')\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'1': 4086, '0': 4106}" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend = Aer.get_backend('aer_simulator')\n", "nShots = 8192\n", "counts = backend.run(circuit,shots=nShots).result().get_counts()\n", "counts" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot_histogram(counts)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "módulo producto interno al cuadrado: 0.00244140625\n", "Conteo: {'1': 4086, '0': 4106}\n" ] } ], "source": [ "if '1' in counts:\n", " b = counts['1']\n", "else:\n", " b = 0\n", "\n", "\n", "s = 1-(2/nShots)*(b)\n", "\n", "print(\"módulo producto interno al cuadrado:\",str(s))\n", "print(\"Conteo: \",counts)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Apéndice\n", "```{index} density matrix, matriz de densidad\n", "```\n", "\n", "\n", "* Matriz de densidad " ] } ], "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.11.4" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": true }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }