{
"cells": [
{
"cell_type": "markdown",
"id": "b893110e-1835-4b67-bfd9-5b9402840c2a",
"metadata": {},
"source": [
"(algrebralineal)=\n",
"# Introducción. Álgebra\n",
"\n",
"```{index} statevector, vector de estado\n",
"```\n",
"En este apartado vamos a ver diferentes forma de representar los qubits. Seguiremos trabajando, de momento, con un sólo qubit y presentaremos diferentes operaciones sobre ellos. Comprenderemos lo que es el producto interno y ciertas propiedades sobre el mismo.\n",
"\n",
"Veamos en primer cómo poder representar mediante coordenada los qubits de la base $\\{|0\\rangle , |1\\rangle \\}$.\n",
"\n",
"$$|0\\rangle={\\binom{1}{0}},\\quad|1\\rangle={\\binom{0}{1}}.$$\n",
"\n",
"Como podemos ver se han utilizado vectores columnas para representar estos vectores que vamos a denominar *statevector* o *vectores de estado*.\n",
"\n",
"De la misma manera se podría representar cualquier qubit que tuviera de amplitudes $\\alpha$ y $\\beta$. Es decir se tendría la siguiente representación:\n",
"\n",
"$$|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle=\\alpha\\binom{1}{0}+\\beta\\binom{0}{1}={\\binom{\\alpha}{0}}+{\\binom{0}{\\beta}}=$$\n",
"$$={\\binom{\\alpha}{\\beta}}.$$\n",
"\n",
"Como ya sabemos los qubits $\\{|i\\rangle, |-i\\rangle\\} forman una base por lo tanto el qubit $|i\\rangle$ se puede representar por el siguiente vector columna en esa base:\n",
"\n",
"$$\\left(\\begin{array}{c}\n",
"1\\\\\n",
"0\n",
"\\end{array}\\right)$$\n",
"\n",
"Pero en la base formada por los qubits $|0\\rangle$ y $|1\\rangle$ ( que en adelante la llamaremos la base canónica), su expresión sería de las siguiente manera:\n"
]
},
{
"cell_type": "markdown",
"id": "a9b0d2df-ddbe-4c9c-aa54-2c4fa1f663eb",
"metadata": {},
"source": [
"$$|i\\rangle=\\frac{1}{\\sqrt{2}}|0\\rangle+\\frac{i}{\\sqrt{2}}|1\\rangle=\\frac{1}{\\sqrt{2}}{\\binom{1}{0}}+\\frac{i}{\\sqrt{2}}{\\binom{0}{1}}={\\binom{1/{\\sqrt{2}}}{0}}+{\\binom{0}{i/{\\sqrt{2}}}}=$$\n",
"$$={\\binom{1/{\\sqrt{2}}}{i/{\\sqrt{2}}}}={\\frac{1}{\\sqrt{2}}}{\\binom{1}{i}}.$$\n",
"\n",
"Igualmente sabemos que $H(|0\\rangle)=|+\\rangle=\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$, por lo que en este caso el vector columna será:\n",
"\n",
"$$\\binom{\\frac{1}{\\sqrt{2}}}{\\frac{1}{\\sqrt{2}}}$$"
]
},
{
"cell_type": "markdown",
"id": "ecff47f4-4c5c-4a5e-8f1b-e0686deb3b2c",
"metadata": {},
"source": [
"En el mundo de la programación cuántica, este tipo de vectores se denominan [*statevector* o *vectores de estado*](statevector), qiskit tiene una clase específicamente diseñada para trabajar con este tipo de elementos. A continuación veamos cómo introducir esta clase.\n",
"\n",
"La forma de definir un vector de estado sería de la siguiente manera: "
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "8f7455df-796e-4b44-8f10-8fdc130c402b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"El vector de estado generado es el siguiente: Statevector([1.+0.j, 0.+0.j],\n",
" dims=(2,))\n"
]
}
],
"source": [
"from qiskit.quantum_info import Statevector\n",
"v1=Statevector([1,0])\n",
"print(\"El vector de estado generado es el siguiente: \", v1)"
]
},
{
"cell_type": "markdown",
"id": "a573cf1f-a251-45c6-b8aa-911465944ddf",
"metadata": {},
"source": [
"En el ejemplo anterior, la forma de definir ese vector de estado sería la siguiente:\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "6931300a-3be8-49bb-a1a3-af1b48280037",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Statevector([0.70710678+0.j , 0. +0.70710678j],\n",
" dims=(2,))\n"
]
}
],
"source": [
"import numpy as np\n",
"v2 = Statevector([(1/np.sqrt(2))+0j,0+1j*(1/np.sqrt(2))])\n",
"print(v2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Igualmente ya hemos dicho que se cumple lo siguiente: $H(|0\\rangle)=|+\\rangle=\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$, por lo que en este caso el vector columna será:\n",
"\n",
"$$\\binom{\\frac{1}{\\sqrt{2}}}{\\frac{1}{\\sqrt{2}}}$$\n",
"\n",
"Veamos que con quiskit también podemos obtener este resultado, y para ello definimos un circuito de un sólo qubit al que se le aplica una puerta H\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Statevector([0.707+0.j, 0.707+0.j],\n",
" dims=(2,))\n"
]
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"# Definimos el circuito de un solo qubit\n",
"circuito = QuantumCircuit(1)\n",
"\n",
"#Aplicamos un puerta H\n",
"circuito.h(0)\n",
"\n",
"# Import Aer\n",
"from qiskit import Aer\n",
"\n",
"# Ejecutamos el circuito sobre un simulador de statevector simulator backend\n",
"backend = Aer.get_backend('statevector_simulator')\n",
"\n",
"# creamos un programa cuántico para ejecución.\n",
"job = backend.run(circuito)\n",
"\n",
"# obtenemos el resultado\n",
"result = job.result()\n",
"\n",
"# Ahora ya podemos sacar el vector de estado y lo imprimimos\n",
"outputstate = result.get_statevector(circuito, decimals=3)\n",
"print(outputstate)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.7071067811865475\n"
]
}
],
"source": [
"# Comprobamos que el resultado es el correcto\n",
"print(1/np.sqrt(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Vectores fila.\n",
"```{index} bra-ket (notation)\n",
"```\n",
"Los vectores fila, no son más que el vector columna transpuesto, es decir :\n",
"\n",
"$$\\binom{\\alpha}{\\beta}^{T}=\\left(\\alpha,\\beta\\right)$$\n",
"\n",
"Sin embargo en la programación cuántica, se utiliza mucho el denominado vector transpuesto conjugado, que como su nombre indica consiste en tomar el vector transpuesto y después el conjugado. Se denota por el superíndice $\\dagger$:\n",
"\n",
"$${\\binom{\\alpha}{\\beta}}^{\\dagger}=(\\alpha^{*}\\,\\beta^{*}).$$\n",
"\n",
"De acuerdo con esta explicación, también hay que comentar que dentro de la programación cuántica se utiliza mucho la notación *bra-ket*. La parte ket ya se ha utilizado anteriormente y por y un ejemplo de la misma puede ser: $|1\\rangle$, sin embargo, con la parta bra, queremos indicar lo siguiente:\n",
"\n",
"$$\\langle\\psi|=(\\alpha^{*}\\,\\beta^{*}).$$\n",
"\n",
"## El producto interno.\n",
"\n",
"Así pues y tal como se ha presentado en el anterior apartado, la parte *bra* no es más que el transpuesto conjugado de la parte *bra*. Por ejemplo, vamos a considerar un qubit ya utilizado anteriormente en este capítulo:\n",
"\n",
"$$|i\\rangle={\\binom{1/{\\sqrt{2}}}{i/{\\sqrt{2}}}}={\\frac{1}{\\sqrt{2}}}{\\binom{1}{i}}.$$\n",
"\n",
"Por lo tanto la parte bra de la expresión anterior, sería la siguiente:\n",
"\n",
"$$|i\\rangle=(1/{\\sqrt{2}},-i/{\\sqrt{2}})$$\n",
"\n",
"Podemos tomar los transpuestos conjugados de $|0\\rangle=\\binom{1}{0}$ y $|1\\rangle=\\binom{0}{1}$, tiene las siguientes partes bra:\n",
"\n",
"$$\\langle 0| = (1 , 0) \\quad \\langle1|=(0 , 1)$$\n",
"\n",
"Y entonces podemos tener la siguiente conclusión:\n",
"\n",
"$$\\begin{array}{c}{{\\langle\\psi|=(\\alpha^{\\ast}\\beta^{\\ast})=(\\alpha^{\\ast}\\ 0)+(0\\,\\beta^{\\ast})=\\alpha^{\\ast}(1\\ 0)+\\beta^{\\ast}(0\\ 1)}}\\\\ {{=\\alpha^{\\ast}\\langle0|+\\beta^{\\ast}\\langle1|.}}\\end{array}$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notemos que en este caso tendremos amplitudes $\\alpha^*$ y $\\beta^*$ y por lo tanto cuando pasamos de $|\\psi\\rangle$ a $\\langle \\psi|$, lo que se necesita es tomar los complejos conjugados de las amplitudes y pasar de vector columna a vector fila. Por ejemplo, si sabemos que $|i\\rangle=\\frac{1}{\\sqrt{2}}|0\\rangle+\\frac{i}{\\sqrt{2}}|1\\rangle$, entonces:\n",
"\n",
"$$\\langle i|=\\frac{1}{\\sqrt{2}}\\langle0|-\\frac{i}{\\sqrt{2}}\\langle1|$$\n",
"\n",
"Resumamos todo esto a continuación\n",
"\n",
"$$|\\Psi\\rangle={\\binom{\\alpha}{\\beta}}\\Longleftrightarrow\\quad\\quad\\langle\\Psi|=(\\alpha^{*}\\,{\\beta^{*}})$$\n",
"\n",
"$$|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle\\iff\\langle\\psi|=\\alpha^{*}\\langle0|+\\beta^{*}\\langle1|$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(productointerno)=\n",
"## Productos internos o escalar.\n",
"\n",
"Supongamos que tenemos dos estados:\n",
"\n",
"$$|\\Psi\\rangle={\\binom{\\alpha}{\\beta}},\\quad y \\quad|\\phi\\rangle={\\binom{\\gamma}{\\delta}}$$\n",
"\n",
"Definiremos su producto interno y lo designaremos por $\\langle \\Psi | \\phi\\rangle$, de la siguiente manera:\n",
"\n",
"$$\\langle\\Psi|\\phi\\rangle=\\left(\\alpha^{*}\\,\\beta^{*}\\right)\\left(\\gamma, \\delta\\right) $$\n",
"\n",
"El resultado por lo tanto será un escalar complejo, y en concreto:\n",
"\n",
"$$ \\langle\\phi|\\psi\\rangle=\\alpha^{*}\\gamma+\\beta^{*}\\delta.$$\n",
"\n",
"Una propiedad muy importante del producto escalar es que el producto escalar de $\\Psi$ y $\\phi$ es igual cl complejo del producto escalar de $\\phi$ por $\\Psi$. Es decir:\n",
"\n",
"$$\\langle\\Psi|\\phi\\rangle=\\langle\\phi|\\Psi\\rangle^{*}$$\n",
"\n",
"Un conclusión del resultado anterior es que el producto interno no tiene la propiedad conmutativa.\n",
"\n",
"Vamos a demostrar el enunciado anterior.\n",
"\n",
"$$\\begin{array}{c}{{\\langle\\Psi|\\phi\\rangle=(\\gamma^{*}\\;\\delta^{*})\\binom{\\alpha}{\\beta}=\\gamma^{*}\\alpha+\\delta^{*}\\beta=(\\gamma\\alpha^{*}+\\delta\\beta^{*})^{*}=(\\alpha^{*}\\gamma+\\beta^{*}\\delta)^{*}}}\\\\ {{=\\langle\\phi\\left|\\Psi\\right\\rangle^{*}.}}\\end{array}$$\n",
"\n",
"Veamos cómo calcular el producto interno desde quiskit. Supongamos que tenemos los siguientes qubits.\n",
"\n",
"$$|a\\rangle=\\frac{3+i\\sqrt{3}}{4}|0\\rangle+\\frac{1}{2}|1\\rangle$$\n",
"\n",
"$$|b\\rangle=\\frac{1}{4}|0\\rangle+\\frac{\\sqrt{15}}{4}|1\\rangle$$\n",
"\n",
"Procedamos al cálculo del producto interno con qiskit\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"El producto interno es: \n"
]
},
{
"data": {
"text/plain": [
"(0.6716229182759271-0.10825317547305482j)"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import Statevector\n",
"import numpy as np\n",
"# definimos el primer vector de estado\n",
"v1 = Statevector([3/4+1j*(np.sqrt(3)/4),1/2])\n",
"v2 = Statevector([1/4,np.sqrt(15)/4])\n",
"\n",
"# Ahora calculamos el producto interno\n",
"print(\"El producto interno es: \")\n",
"v1.inner(v2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ortonormalidad.\n",
"\n",
"Una vez introducido el concepto de producto interno, vamos a ver que nos podemos apoyar en él para demostrar ciertas condiciones que ya sabemos deben cumplirse al trabajar con qubits.\n",
"\n",
"En este sentido, supongamos que tenemos el siguiente qubit: $\\Psi = \\alpha |0\\rangle +\\beta |1\\rangle$, como es un qubit debe estar sobre la esfera de radio unidad, y por lo tanto verifica que $|\\alpha|^2+|\\beta|^2 =1$. Pero vemos cunato vale el producto interno de ese qubit consigo mismo:\n",
"\n",
"$$\\langle\\Psi|\\Psi\\rangle=(\\alpha^{*},\\beta^{*})\\binom{\\alpha}{\\beta}=|\\alpha|^{2}+|\\beta|^{2}=1$$\n",
"\n",
"Por lo tanto una condición que debe cumplir cada elemento de una base (que esté en la esfera de radio unidad), es que el producto interno del qubit por sí mismo es la unidad.\n",
"\n",
"Otra de las condiciones que deben cumplir los dos qubits que formen una base es que sean ortonormales. Veamos que esto es cierto para la base canónica.\n",
"\n",
"$$\\langle0|1\\rangle=\\left(1~0\\right)\\!\\left(_{1}^{0}\\right)=1\\cdot0+0\\cdot1=0+0=0$$\n",
"\n",
"Igual ocurre con los qubits $|+\\rangle$ y $|-\\rangle$\n",
"\n",
"$$\\left|+\\right\\rangle\\langle-|={\\frac{1}{\\sqrt2}}\\big(1\\left.1\\right){\\frac{1}{\\sqrt2}}\\binom{1}{-1}={\\frac{1}{2}}\\big(1\\ 1\\big)\\binom{1}{-1}={\\frac{1}{2}}\\left(1-1\\right)=0$$\n",
"\n",
"Lo mismo tenemos para los estados $|i\\rangle$ y $|-i\\rangle$:\n",
"\n",
"$$\\vert i\\rangle\\langle-i\\vert=\\frac{1}{\\sqrt{2}}(1-i)\\frac{1}{\\sqrt{2}}{\\binom{1}{-i}}=\\frac{1}{2}\\left(1-i\\right){\\binom{1}{-i}}=\\frac{1}{2}\\left(1+i^{2}\\right)=0$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Siempre se va a verificar que dos puntos de la esfera de Bloch que estén en posiciones opuestas, siempre su producto interno va a ser cero, y estos dos puntos en esas condiciones, diremos que son ortogonales. Si además los dos puntos están normalizados, diremos que son ortonormales.\n",
"\n",
"(proyecciones)=\n",
"## Proyecciones, medidas y cambios de base.\n",
"\n",
"El producto interno tiene muchas aplicaciones dentro de la programación cuántica, y alguna de ellas las vamos a ver en este apartado. En concreto vamos a ver cómo podemos utilizar este producto interno o escalar para medir amplitudes de estados cuánticos. Igualmente vamos a ver cómo proceder para hacer diferentes cambios de base. Para los propósitos de este apartado, vamos a trabajar con el siguiente qubit:\n",
"\n",
"$$|\\psi\\rangle={\\frac{\\sqrt{3}}{2}}|0\\rangle+{\\frac{1}{2}}|1\\rangle$$\n",
"\n",
"Este qubit ya [fue presentado en un apartado anterior](puntoesfera), y podemos decir que su representación gráfica sobre la esfera de Bloch es la siguiente:\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Vamos a ver que gracias al producto interno de este qubit por cada elemento de la base nos da sus amplitudes. En efecto, vamos a calcular el siguiente producto interno:\n",
"\n",
"$$\\langle0|\\Psi\\rangle=\\langle0|\\left(\\frac{\\sqrt{3}}{2}|0\\rangle+\\frac{1}{2}|1\\rangle\\right)=\\frac{\\sqrt{3}}{2}\\underset{1}{\\underbrace{\\langle0|0\\rangle}}+\\frac{1}{2}\\underset{0}{\\underbrace{\\langle0|1\\rangle}}=\\frac{\\sqrt{3}}{2}$$\n",
"\n",
"Como podemos observar, lo que obtenemos es la amplitud sobre el qubit $|0\\rangle$. De forma similar podemos obtener las amplitud sobre el segundo elemento de la base:\n",
"\n",
"$$\\langle1|\\Psi\\rangle=\\langle1|\\left(\\frac{\\sqrt{3}}{2}|0\\rangle+\\frac{1}{2}|1\\rangle\\right)=\\frac{\\sqrt{3}}{2}\\underset{0}{\\underbrace{\\langle1|0\\rangle}}+\\frac{1}{2}\\underset{1}{\\underbrace{\\langle1|1\\rangle}}=\\frac{1}{2}$$\n",
"\n",
"\n",
"En vista de estos resultados, podemos concluir que el qubit anterior $\\psi$, se puede escribir de la siguiente manera:\n",
"\n",
"$$\\psi\\rangle=\\langle0|\\psi\\rangle|0\\rangle+\\langle1|\\psi\\rangle|1\\rangle$$\n",
"\n",
"Este método, es aún más interesante cuando pretendemos medir las amplitudes sobre otro tipo de bases, y así por ejemplo supongamos que queremos medir las amplitudes sobre la base X que era {$|+\\rangle , |1\\rangle$}. En este caso se tiene:\n",
"\n",
"$$\\langle+\\vert\\psi\\rangle=\\frac{1}{\\sqrt{2}}{\\big(}\\langle0\\vert+\\langle1\\vert{\\big)}\\left(\\frac{\\sqrt{3}}{2}\\vert0\\rangle+\\frac{1}{2}\\vert1\\rangle\\right)$$\n",
"\n",
"$$=\\frac{1}{\\sqrt{2}}\\left(\\frac{\\sqrt{3}}{2}\\underset{1}{\\underbrace{\\langle0|0\\rangle}}+\\frac{1}{2}\\underset{0}{\\underbrace{\\langle0|1\\rangle}+\\frac{\\sqrt{3}}{2}\\underset{0}{\\underbrace{\\langle1|0\\rangle}}}+\\frac{1}{2}\\underset{1}{\\underbrace{\\langle1|1\\rangle}}\\right)=$$\n",
"\n",
"$$={\\frac{1}{\\sqrt{2}}}\\left({\\frac{\\sqrt{3}}{2}}+{\\frac{1}{2}}\\right)={\\frac{{\\sqrt{3}}+1}{2{\\sqrt{2}}}}$$\n",
"\n",
"Por lo tanto con este procedimiento podemos hacer cambios de base de un forma rápida y práctica.\n",
"\n",
"Los resultados anteriores los podemos obtener con qiskit de la siguiente manera:\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "2eaea7ba-a20a-43ab-8693-991c58ea6ad4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"El producto interno es: \n"
]
},
{
"data": {
"text/plain": [
"(0.9659258262890682+0j)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import Statevector\n",
"import numpy as np\n",
"# definimos el primer vector de estado\n",
"v1 = Statevector([1/np.sqrt(2),1/np.sqrt(2)])\n",
"v2 = Statevector([np.sqrt(3)/2,1/2])\n",
"\n",
"# Ahora calculamos el producto interno\n",
"print(\"El producto interno es: \")\n",
"v1.inner(v2)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "0042046a-a1ec-4f83-b8ff-a0b37653c732",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.9659258262890682"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Comprobemos que coincide con el resultado manual\n",
"(np.sqrt(3)+1)/(2*np.sqrt(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Comprobemos la amplitud sobre $|-\\rangle$"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"El producto interno es: \n"
]
},
{
"data": {
"text/plain": [
"(0.25881904510252074+0j)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# definimos el primer vector de estado\n",
"v1 = Statevector([1/np.sqrt(2),-1/np.sqrt(2)])\n",
"v2 = Statevector([np.sqrt(3)/2,1/2])\n",
"\n",
"# Ahora calculamos el producto interno\n",
"print(\"El producto interno es: \")\n",
"v1.inner(v2)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.2588190451025207"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Comprobemos que coincide con el resultado manual\n",
"(np.sqrt(3)-1)/(2*np.sqrt(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Se puede mejorar ostensiblemente este resultado utilizando la matemática simbólica que nos proporciona Sympy. Por este motivo se puede acudir al capítulo dedicado a esta materia al que [se puede acceder desde este enlace](sympy) para ver un procedimiento fácil con el cual se obtiene el mismo resultado que el obtenido de una forma manual. A continuación se transcribe el resultado central de ese apartado. "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"IPython console for SymPy 1.12 (Python 3.11.4-64-bit) (ground types: python)\n",
"\n",
"These commands were executed:\n",
">>> from sympy import *\n",
">>> x, y, z, t = symbols('x y z t')\n",
">>> k, m, n = symbols('k m n', integer=True)\n",
">>> f, g, h = symbols('f g h', cls=Function)\n",
">>> init_printing()\n",
"\n",
"Documentation can be found at https://docs.sympy.org/1.12/\n",
"\n"
]
}
],
"source": [
"from sympy import init_session\n",
"init_session(use_latex=True)\n",
"\n",
"def productoInterno(x,y, simplificar=True):\n",
" \"\"\" \n",
" Con esta función calculamos el producto interno de dos qubits\n",
"\n",
" @parámteros:\n",
" x,y son dos mtarices de Sympy definidas como vectores columna. Estas matrices\n",
" son la amplitudes de los qubits\n",
"\n",
" simplificar es un valor lógico que permite obtener el resultado simplificado o no.\n",
"\n",
" \"\"\"\n",
"\n",
" resul = x.T*y\n",
"\n",
" if simplificar:\n",
" resul = simplify(resul)\n",
"\n",
" return resul"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAFsAAAAlCAYAAAAtHpUoAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAD2UlEQVRoBe2a71HbQBDF5UwKCHQQ0wG0AB3ApIKYDmDyyf7GkA4gFTChg5AKQuggdEDiDpLf86w0JxlJJ+nOPju+Gc3927vd97S3dzp7NJ1OT7Ms+8rjpvPZbHbrNuzK/gzA3Q3Sk8qIvZGR/QGBs0rnrhqIAbj9w1Tv3wSabzeNBwM7sj1ICiWyIzsUkx7zvPWQ6SxCjNKGq423MSE3ahRIqBNb/7aZ04YnONko1C78jXxrNlzDNPiEFpxsiD7DuJM2L9iw/iCYgpINyReQqDPmIlF/R+GTVceWf6R9buXksyomGUzbNdmLGT+n7vVNEpRslJ+g2PXqa+rnZlRGWS/iJ89B3rYBeQkTGGS/HOaJ55Cy6l5kBzuNoLjk1UbihPZjKyuTR4zNSKc5zWIVE3XZ/0j+JIstd52rEUgQz0apwkXJA0yrvPqx0YJEO2swafNX/FZIlFc/UH7wheDt2VLAU/3ez/UoLuutlxLytzxufBb5z7QtPKMkvIYKdnhjQlYOtXAqy0WywmQdJ0uIvMhmQoUCEXVjSouJrH5I3viG6Zcn6Ox9VAxeYwF7umLaN3N/MVbxWk50ySNO5OmtyZdsLRdNLI/MTxf55PJo9dUmM0ZyR2ZkrWxbB+OPeby9qW4+5uiECflnm6sIi7Tlq9bdl+pUZl5kO6OvKF+gRMsps1xLsTYs0Ke3fkmumK5jkuTV1jdJ90J/3wkq47pgEuG5h7vT5C/CbVsqdyIbku6ZQRPn3t3o1Uaqjntaago1CiVaBb95kkgdMQlv8WVseLQHNYbQHGif04jI+oKCO/J98lqvpl9nUHmh8iIxRvE/peSFCbu14Wtli/QXHn0veO9BnclG0b0p+96mCLk9ZJJPHTF97guoUxhxlMgTtMF4xSpnXMrF6JhaPRtCa68Wm/raWGVs4/Uq/Yr1r+3yiw2K/tdCkY5kRUytswGZtWDyIbuRlDpAQ9tryMxo11ldJ5rey5mxa8HUN4wM5fK/HB+cbLymdPLYdFZD4glKNobp5k9n6a1IofEEIxvDtJltzekkBp4gZGOYPlzk0V5fUqm7fSw8QciGvAkG9j4ddCR/jryemCkKntajXxsiSNZRTHcmK0noi7p6YuIZ5NkYNoZh3Y9sRayOjWeoZytWH2CkLmaUVM+s/oN8ZR4vvQFSVDyDyIZM3fgVt37U5em62L+iHDuuBuC2PEVsPIPCiGsqhork3MP121zr38/c8amVY+AZ5NkuQRin/054/X/CHZdqOQaeYJ6dKmkp2bUje4VvIw8jpywb94538D82V4ghOVVwqbv4pX8A/AN6HIdhdte9pgAAAABJRU5ErkJggg==",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{4} + \\frac{\\sqrt{6}}{4}\\end{matrix}\\right]$"
],
"text/plain": [
"⎡√2 √6⎤\n",
"⎢── + ──⎥\n",
"⎣4 4 ⎦"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# defino las amplitudes del primer elemento\n",
"a= Matrix([1/sqrt(2),1/sqrt(2)])\n",
"# defino las amplitudes del segundo elemento\n",
"b= Matrix([sqrt(3)/2,1/2])\n",
"\n",
"productoInterno(a,b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Como resultado de todo lo visto en este apartado podemos concluir que :\n",
"\n",
"$$|\\psi\\rangle=\\langle+|\\psi\\rangle|+\\rangle+\\langle-|\\psi\\rangle|-\\rangle$$\n",
"\n",
"En consecuencia de puede afirmar que:\n",
"\n",
"```{note}\n",
"Para una base ortonormal cualquiera $\\{|a\\rangle, |b\\rangle \\} $, el estado de un qubit se puede escribir como:\n",
"\n",
"$$|\\psi\\rangle=\\alpha|a\\rangle +\\beta |b\\rangle $$\n",
"\n",
"donde $\\alpha=\\langle a|\\psi\\rangle$ y $\\beta=\\langle b|\\psi\\rangle$\n",
"\n",
"```\n",
"\n",
"Por lo tanto $\\langle a|\\psi\\rangle$ es la amplitud de $| \\psi\\rangle$ en $|a\\rangle$. En lenguaje matemático $\\langle a|\\psi\\rangle$ es la proyección de $|\\psi\\rangle$ en $|a\\rangle$\n",
"\n",
"## Matrices de puertas cuánticas.\n",
"\n",
"Como ya se ha comentado en un apartado anterior, una puerta U lo que en el fondo hace es cambiar los estados de superposición de los qubits delas base canónica, es decir $|0\\rangle$ y $|1\\rangle$. Utilizando notación simbólica, lo anterior quiere decir lo siguiente:\n",
"\n",
"$$U|0\\rangle=a|0\\rangle+b|1\\rangle={\\binom{a}{b}},$$\n",
"\n",
"$$U|1\\rangle=c|0\\rangle+d|1\\rangle={\\binom{c}{d}}.$$\n",
"\n",
"Las expresiones anteriores se pueden expresar con un formato matricial, y en concreto en el caso anterior, la matriz de la puerta U sería la siguiente:\n",
"\n",
"$$U=\\left(\\begin{array}{cc}\n",
"\\left(\\begin{array}{c}\n",
"a\\\\\n",
"b\n",
"\\end{array}\\right) & \\left(\\begin{array}{c}\n",
"c\\\\\n",
"d\n",
"\\end{array}\\right)\\end{array}\\right)=\\left(\\begin{array}{cc}\n",
"a & c\\\\\n",
"b & d\n",
"\\end{array}\\right)$$\n",
"\n",
"Entonces si tenemos un qubit en el siguiente estado de superposición:\n",
"\n",
"$$|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle={\\binom{\\alpha}{\\beta}},$$\n",
"\n",
"Aplicar una puerta U es equivalente a hacer la siguiente multiplicación matricial.\n",
"\n",
"$$U|\\psi\\rangle={\\binom{a\\ c}{b\\ d}}{\\binom{\\alpha}{\\beta}}={\\binom{a\\alpha+c\\beta}{b\\alpha+d\\beta}}.$$\n",
"\n",
"Por lo tanto y utilizando el lenguaje de álgebra lineal, las puerta cuánticas en el fondo no son otra cosa que matrices. No obstante estas matrices deben de asegurar que la suma de probabilidades de colapsar hacia cada elemento de la base debe ser 1, es decir en el ejemplo anterior, se debe cumplir \n",
"\n",
"$$|a\\alpha+c\\beta|^{2}+|b\\alpha+d\\beta|^{2}=1$$\n",
"\n",
"Veamos un ejemplo de esta situación:\n",
"\n",
"$$U|0\\rangle=\\frac{\\sqrt{2}-i}{2}|0\\rangle-\\frac{1}{2}|1\\rangle=\\left(\\begin{array}{c}\n",
"\\frac{\\sqrt{2}-i}{2}\\\\\n",
"-\\frac{1}{2}\n",
"\\end{array}\\right),$$\n",
"\n",
"$$U|1\\rangle={\\frac{1}{2}}|0\\rangle+{\\frac{\\sqrt{2}+i}{2}}|1\\rangle=\\left(\\begin{array}{c}\n",
"\\frac{1}{2}\\\\\n",
"\\frac{\\sqrt{2}+i}{2}\n",
"\\end{array}\\right).$$\n",
"\n",
"En consecuencia la matriz asociada a esta puerta es la siguiente:\n",
"\n",
"$$U=\\left(\\begin{array}{cc}\n",
"\\frac{\\sqrt{2}-i}{2} & \\frac{1}{2}\\\\\n",
"-\\frac{1}{2} & \\frac{\\sqrt{2}+i}{2}\n",
"\\end{array}\\right)$$\n",
"\n",
"```{index} is_unitary (qiskit)\n",
"```\n",
"\n",
"Para que una puerta se válida, debe ser unitaría, es decir que conserve la propiedad de que la suma de probabilidades de colapsar hacia cada elemento de la base es 1. Con qiskit se puede comprobar si una matriz es unitaria o no utilizando la propiedad *is_unitary()*. Comprobemos esto para el ejemplo con el que estamos trabajando."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info.operators import Operator\n",
"import numpy as np\n",
"\n",
"U= np.matrix([[(np.sqrt(2)-1j)/2,1/2],[-1/2,(np.sqrt(2)+1j)/2]])\n",
"op =Operator(U)\n",
"\n",
"op.is_unitary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En la herramienta Quirk que ya se ha presentado en un apartado anterior, también se puede crear las matrices asociadas a las puertas lógicas utilizando la opción del menú principal \"*Make Gate*\". al realizar esta operación se abre un cuadro de diálogo para introducir los elementos de la matriz, como se aprecia en la siguiente imagen.\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"A esta puerta en el momento de la creación se le asigna un nombre, y esta nueva puerta aparecerá en en la pantalla de Quirk con el nombre que se le ha dado en su creación.\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Una vez creada la puerta se puede trabajar con ella, y obtener los resultados correspondientes, como se puede ver en el ejemplo de la siguiente imagen:\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"en este caso podemos ver que $HTU|0\\rangle$ tiene un 57.3% de probabilidad de colapsar a $|1\\rangle$ y 42.7% hacia $|0\\rangle$.\n",
"\n",
"```{index} matrices puertas cuánticas\n",
"```\n",
"### Matrices más comúnmente utilizadas.\n",
"\n",
"Ya se han comentado [en otro apartado anterior](puertasComunes), cómo se forman y cual es el resultado de las puertas cuánticas más usuales. En este apartado, vamos a exponer esas mismas puertas pero desde el lado algebraico, es decir viendo la matriz (tal y como se han definido anteriormente) que hay detrás de ellas. Estas matrices son las siguientes.\n",
"\n",
"| Puerta | Acción | Matriz |\n",
"|-----------|--------------------------------------------------------|--------------------------------------------------------------|\n",
"| Identidad | $I\\|0\\rangle=\\|0\\rangle$
$I\\|1\\rangle=\\|1\\rangle$ | $I=\\left(\\begin{array}{cc} 1 & 0\\\\ 0 & 1 \\end{array}\\right)$ |\n",
"| Pauli X | $X\\|0\\rangle=\\|1\\rangle$
$X\\|1\\rangle=\\|0\\rangle$ | $X=\\left(\\begin{array}{cc} 0 & 1\\\\ 1 & 0 \\end{array}\\right)$ |\n",
"| Pauli Y | $Y\\|0\\rangle=i\\|1\\rangle$
$Y\\|1\\rangle=-i\\|0\\rangle$ | $Y=\\left(\\begin{array}{cc} 0 & -i\\\\ i & 0 \\end{array}\\right)$ |\n",
"| Pauli Z | $X\\|0\\rangle=\\|0\\rangle$
$X\\|1\\rangle=\\|1\\rangle$ | $Z=\\left(\\begin{array}{cc} 1 & 0\\\\ 0 & -1 \\end{array}\\right)$ |\n",
"| Fase S | $S\\|0\\rangle=\\|0\\rangle$
$S\\|1\\rangle=i\\|1\\rangle$ | $S=\\left(\\begin{array}{cc} 1 & 0\\\\ 0 & i \\end{array}\\right)$ |\n",
"| Puerta T | $T\\|0\\rangle=\\|0\\rangle$
$T\\|1\\rangle=e^{i\\pi/4}\\|1\\rangle$ | $T=\\left(\\begin{array}{cc} 1 & 0\\\\ 0 & e^{i\\pi/4} \\end{array}\\right)$ |\n",
"| Hadamard H | $H\\|0\\rangle=\\frac{1}{\\sqrt{2}}\\left(\\|0\\rangle+\\|1\\rangle\\right)$
$H\\|1\\rangle=\\frac{1}{\\sqrt{2}}\\left(\\|0\\rangle-\\|1\\rangle\\right)$ | $H=\\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc}1 & 1\\\\1 & -1\\end{array}\\right)$ |\n",
"\n",
"### Operando con puertas secuenciales.\n",
"\n",
"Usando el álgebra lineal y la definición de las matrices dadas anteriormente, se puede calcular fácilmente el resultado de una secuencia de puertas cuánticas. Por ejemplo se puede demostrar que:\n",
"\n",
"$${HSTH|0}\\rangle={\\frac{1}{2}}\\left[\\left(1+e^{i3\\pi/4}\\right)|0\\rangle+\\left(1-e^{i3\\pi/4}\\right)|1\\rangle\\right]$$\n",
"\n",
"La operación manual se haría de la siguiente manera:\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"Mientras que si utilizamos el paquete Sympy de python, nos daría:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i e^{\\frac{i \\pi}{4}}}{2}\\\\\\frac{1}{2} - \\frac{i e^{\\frac{i \\pi}{4}}}{2}\\end{matrix}\\right]$"
],
"text/plain": [
"⎡ ⅈ⋅π⎤\n",
"⎢ ───⎥\n",
"⎢ 4 ⎥\n",
"⎢1 ⅈ⋅ℯ ⎥\n",
"⎢─ + ──────⎥\n",
"⎢2 2 ⎥\n",
"⎢ ⎥\n",
"⎢ ⅈ⋅π⎥\n",
"⎢ ───⎥\n",
"⎢ 4 ⎥\n",
"⎢1 ⅈ⋅ℯ ⎥\n",
"⎢─ - ──────⎥\n",
"⎣2 2 ⎦"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Definimos las matrices\n",
"H=(1/sqrt(2))*Matrix([[1,1],[1,-1]])\n",
"S = Matrix([[1,0],[0,1*I]])\n",
"T = Matrix([[1,0],[0,exp(pi*I/4)]])\n",
"\n",
"# Definimos el vector columna (1,0)\n",
"c = Matrix([1,0])\n",
"\n",
"# Hacemos ahora la multiplicación\n",
"\n",
"H*S*T*H*c"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(puertas_logicas)=\n",
"Observar que el resultado es el mismo que el obtenido de forma manual ya que $i=e^{i\\pi/2}$ y entonces con una simple operación aritmética se llega al mismo resultado que el obtenido de forma manual.\n",
"\n",
"Como estas matrices de puertas lógicas son utilizadas con mucha frecuencia, lo que se ha hecho es crear un fichero denominado \"puertasLogicas.py\" que contiene la definición de estas puertas. Entonces se le puede considerar que es un módulo de Python, con lo que no se tiene que hacer más que importarlo para trabajar con esas matrices de puertas lógicas.\n",
"\n",
"El código que contiene este fichero es el siguiente:\n",
"\n",
">from sympy import *\n",
">init_printing(use_unicode=True)\n",
">\n",
">I1=Matrix([[1,0],[0,1]])\n",
">\n",
">X=Matrix([[0,1],[1,0]])\n",
">\n",
">Y=Matrix([[0,-I],[I,0]])\n",
">\n",
">Z = Matrix([[1,0],[0,-1]])\n",
">\n",
">S = Matrix([[1,0],[0,I]])\n",
">\n",
">T = Matrix([[1,0],[0,exp(pi*I/4)]])\n",
">\n",
">H=(1/sqrt(2))*Matrix([[1,1],[1,-1]])\n",
"\n",
"Entonces su forma de usos sería como se indica a continuación:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i e^{\\frac{i \\pi}{4}}}{2} & \\frac{1}{2} - \\frac{i e^{\\frac{i \\pi}{4}}}{2}\\\\\\frac{1}{2} - \\frac{i e^{\\frac{i \\pi}{4}}}{2} & \\frac{1}{2} + \\frac{i e^{\\frac{i \\pi}{4}}}{2}\\end{matrix}\\right]$"
],
"text/plain": [
"⎡ ⅈ⋅π ⅈ⋅π⎤\n",
"⎢ ─── ───⎥\n",
"⎢ 4 4 ⎥\n",
"⎢1 ⅈ⋅ℯ 1 ⅈ⋅ℯ ⎥\n",
"⎢─ + ────── ─ - ──────⎥\n",
"⎢2 2 2 2 ⎥\n",
"⎢ ⎥\n",
"⎢ ⅈ⋅π ⅈ⋅π⎥\n",
"⎢ ─── ───⎥\n",
"⎢ 4 4 ⎥\n",
"⎢1 ⅈ⋅ℯ 1 ⅈ⋅ℯ ⎥\n",
"⎢─ - ────── ─ + ──────⎥\n",
"⎣2 2 2 2 ⎦"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import puertasLogicas as pl\n",
"\n",
"pl.H*pl.S*pl.T*pl.H"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Identidades entre circuitos.\n",
"\n",
"Existen algunas indentidades importantes que conviene tenerlas en cuenta cuando trabajamos en programación cuántica. A continuación se muestran algunas de estas identidades.\n",
"\n",
"Se puede comprobar que: HXH=Z, para comprobarlo vamos a ver si es cierto que HXH-Z=0"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAADUAAAAzCAYAAAA3v0BtAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACVElEQVRoBe1a0U3DMBCliAEq2CCMAExAR6BsAB2hn+lv2QBWKBvABhXdADagMALvqpxkWXeO8cWSU9mSZefi5L3nu6TXUyZt205PhLZarX4Fc1EmcBS5n4LlB/qP19dFsdfJbDzepGMzgac+MVlA9bt+7TjOQMMjmM7JU0fXzmIUYQc4HL+x/hJ9DdtXzLXWNSnYvZ7CTemZ22Jcoj9hvkR/w7yxEu67PhU7KAo3pRidYnxlApjTW5GOn9mWY7RgB0WB7Bx9J5DewjYDsPhKFdanmJKx+0TNwGYvMOLnic7nasnYqqhIL5znUGTFVkWBLBMOZRa5ws+EHRIV44SLmEWZ1qjYIVHSs8T8eCfpdytHM2GrohDXHHZSiLGNXxiDCrNiq6I6lpQPNgJj9lTOfDEZu08UZcHXgqgr2HbOjgpLzKZk7KAokH4BtT3GO6aIOYXePfoD23KMFuyYhJa8QgnsDUZ6MdB4i2Mp08CpQVsSdq8okKcXxmJQqpE3S8UOhl8kdnHLqqjiXKIQqp5SNqY4c/VUcS5RCFVPKRtTnPkoPdWbJpEbkK7UYuZQ8YjNTCqkBsMPN63FzKE81N2nFjPdDVXDD6HHxRV3vT/nWoVvNx1bsVVRYMWE6U+i1mKEa9eG7CbskKgQKJ9TC4q8IOOoYodEmQqKRjEmbFUU4prDTgoxttVi5j+9V4uZ7oap4UeLEIK1mOnu1kDzWszkjQyGHy8a21hFjcVj1VNj8RTXKBo/3XfSpGK1+JxB9JC+cfjRd0buh4xcaClWUEfM/4jxwPsPYQ0VhUUzypgAAAAASUVORK5CYII=",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\end{matrix}\\right]$"
],
"text/plain": [
"⎡0 0⎤\n",
"⎢ ⎥\n",
"⎣0 0⎦"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import puertasLogicas as pl\n",
"\n",
"pl.H*pl.X*pl.H-pl.Z"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAAAzCAYAAAAqwX72AAAACXBIWXMAAA7EAAAOxAGVKw4bAAADDUlEQVRoBe1b7U3DMBAFxAAINigbFJgA2ICyATBG+w8xAjABKhsAE6CyAWxA6Qi8V+WkKNzZrhPTJPVJlp2zY9+9nM8f126Px+O9LYUmk8lCYfeOBT1V/Xeg6Qzpp5LueoeArdC0ojuxmG7DYj5RuAFyr/a7m1MDHK6h7YgWk0lBYFfhqSwgOUQFze4I5db4H8gi0/4bsh0i3YH3hbwWOYHBAHRMj0hzpGOkAVJrCPLRP94if6ZQhbwz5OdItcBxTiV0vkAaId1g3CcO3haCTPQFe8iXoFAulGnJfL7ncx1yAlOn4394d4QxPpRx3sE7A0jqMqy0V1ldBuYMGnGKV0mmEOujqZPABFrDfjQqeLGTwEBuUdq1Om7sVPIZxIGvgau+qxaj+RbRU6yJ+5po6iQwxbJMpbXpIjxxwlHgdBKYQlOe7QaK1mIxtc5+XQaGxxPuxqt0BMZHyaqq9UHPqwAjzky+SNAAqRpB8Qf0PUd+IWOgzGl0iXQlvNjceVZipxiMX4YkG6YpeJy/L8gp3DqJ1sFD4wlyOlvmp3jWdsSoCqcQYLj1biUBgAUE4zmucVplKjU+eJs7zMAYXycDk4ExEDDY2WIyMAYCBjtbTAbGQMBgZ4vJwBgIGGzvkYDvYeudJKhlyNQ4G/IP0elKwUIvMOg0WVCrcQRKHUJunrSjg4VOH4POkwa1Sno0XoTstYKFTmAgbdKgVuNoNNihDxjewWgXz3KfyvpekglMMUd9SrfiNs8nZEy9CQw6E6V5GWQRHVwvyQVMiMJyDxzStlNtXMu15ltEObGmWkEt6UzLi6n8hrpVrJI/Wal930t5TGCK5Y5tNMGEJ06Y7Roljo8Oedm9FvJNpaRBrbVoHDioD5ikQa1AGdfSzAkMzDlpUOsfNZZFQnyjd2jTx5TeTBbUKo2RpIgPGx0s9AJTOMEkQa0kaJQ6hezRwULnVCqNsXHFDIzxyTMwGRgDAYOdLcYARlalATy4bPOXTYvVyHitP+yq3tBsiYNYDH97X/4zl1x+9wcBWxPudf7o/guU59yph7iKUwAAAABJRU5ErkJggg==",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & -1\\end{matrix}\\right]$"
],
"text/plain": [
"⎡1 0 ⎤\n",
"⎢ ⎥\n",
"⎣0 -1⎦"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# También de esta manera\n",
"pl.H*pl.X*pl.H"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Unitariedad\n",
"\n",
"Recordemos que si una puerta cuántica transforma $|0\\rangle$ y $|1\\rangle$ de la siguiente manera:\n",
"\n",
"$$U|0\\rangle=a|0\\rangle+b|1\\rangle=\\binom{a}{b}$$\n",
"\n",
"$$U|1\\rangle=c|0\\rangle+d|1\\rangle=\\binom{c}{d}$$\n",
"\n",
"Entonces podemos escribir U mediante una matriz 2x2, de la siguiente manera:\n",
"\n",
"$$U=\\left(\\begin{array}{cc}\n",
"a & c\\\\\n",
"b & d\n",
"\\end{array}\\right)$$\n",
"\n",
"En estas circunstancias, si aplicamos es puerta al estado $|\\Psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$ se obtiene lo siguiente:\n",
"\n",
"\n",
"$$U|\\psi\\rangle=\\left(\\begin{array}{cc}\n",
"a & c\\\\\n",
"b & d\n",
"\\end{array}\\right)\\left(\\begin{array}{c}\n",
"\\alpha\\\\\n",
"\\beta\n",
"\\end{array}\\right)=\\left[\\begin{array}{c}\n",
"a\\alpha+b\\beta\\\\\n",
"b\\alpha+d\\beta\n",
"\\end{array}\\right]$$\n",
"\n",
"Como puede verse, $U|\\psi\\rangle$ es un vector columna y también lo podemos escribir como un elemento ket $|U\\psi\\rangle$:\n",
"\n",
"$$U|\\psi\\rangle=|U\\psi\\rangle$$\n",
"\n",
"Ahora consideremos el conjugado transpuesto de $|U\\psi\\rangle$:\n",
"\n",
"$$\\langle U\\psi|=(a^{*}\\alpha^{*}+c^{*}\\beta^{*}\\quad b^{*}\\alpha^{*}+d^{*}\\beta^{*})=(\\alpha^{*}\\,\\beta^{*})\\left(\\begin{array}{cc}\n",
"a^{*} & b^{*}\\\\\n",
"c^{*} & d^{*}\n",
"\\end{array}\\right) = \\left(\\alpha^{`*}\\:\\beta^{*}\\right)\\left(\\begin{array}{cc}\n",
"a & c\\\\\n",
"b & d\n",
"\\end{array}\\right)^{\\dagger}= \\langle \\psi | U^{\\dagger}$$\n",
"\n",
"Resumiendo:\n",
"\n",
"$$\\begin{array}{c l c r}{{|U\\psi\\rangle=U|\\psi\\rangle,}}\\\\ {{\\langle U\\psi|=\\langle\\psi|U^{\\dagger}.}}\\end{array}$$\n",
"\n",
"Entonces, utilizando lo anterior, podemos determinar si una matriz U deja la probabilidad total igual a 1. Entonces consideremos una puerta cuántica dada por su matriz U y actúa sobre un estado $\\psi$, es decir $U|\\psi\\rangle=|U\\psi\\rangle$. Para que U sea una puerta cuántica, debe estar normalizada, es decir su producto interno consigo mismo debe ser igual a 1:\n",
"\n",
"$$\\begin{array}{c}{{\\langle U\\psi|U\\psi\\rangle=1}}\\\\ {{\\langle\\psi|U^{\\dagger}U|\\psi\\rangle=\\langle\\psi|\\psi,}}\\\\ {{U^{\\dagger}U=I.}}\\end{array}$$\n",
"\n",
"```{index} Unitary (matrix)\n",
"```\n",
"\n",
"Una matriz que verifica la condición anterior, se denomina **matriz unitaria**, y en consecuencia podemos concluir que:\n",
"\n",
":::{note}\n",
"Las puertas cuánticas son matrices unitarias, y además si una matriz es unitaria entonces es una puerta cuántica\n",
":::\n",
"\n",
"Tenemos varias formas de comprobar si una matriz es unitaria o no. Una forma es utilizar la propiedad is_unitary de qiskit. Pero también se puede utilizar la multiplicación de matrices de Sympy. Hay que tener en cuenta que la matriz transpuesta conjugada se obtiene utilizando el método *.H*. Veamos un ejemplo. Supongamos que tenemos la siguiente matriz:\n",
"\n",
"$$U=\\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc}\n",
"1 & i\\\\\n",
"-i & 1\n",
"\\end{array}\\right)$$\n",
"\n",
"Comprobemos mediante sympy si es o no unitaria"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}0.707106781186547 & 0.707106781186547 i\\\\- 0.707106781186547 i & 0.707106781186547\\end{matrix}\\right]$"
],
"text/plain": [
"⎡ 0.707106781186547 0.707106781186547⋅ⅈ⎤\n",
"⎢ ⎥\n",
"⎣-0.707106781186547⋅ⅈ 0.707106781186547 ⎦"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Definimos y presentamos la matriz\n",
"A=(1/np.sqrt(2))*Matrix([[1,I],[-I,1]])\n",
"A"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAHQAAAAzCAYAAABGxyzzAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEfUlEQVR4Ae1c0XHUMBB1GArIkA4uHSRQAUkHHB1AOmAmX3d/mdABUAFz6YBQQUg6IB0QrgN4z/HeOEayJJ9k7wntjE62JEu7+6RdWd65vcVisV8ZaLlcrg3FpUiJBoCPEbdn4O8W6XcnXSrhu7Bh18CqgxkxXO1hhf7ExRkQv7Y/W2q0awD4vQePc67QQhlp4HkqWTBjjtA3zcIxroP8MdqLyf+F5w+RLlF2j1wljSUrxvkABRwiP7MpIiqgGIiO+gvSA9JLpBlSEKEP+vQL5Fd8sOnzFvkpkhpQG77GlpVA1nqhbkwUG1CuxDkHgsCcTVyl3oRn6Af2kW+YxvW6uf+EulPvzhI3JF8YYlRZMSatVS9p86FU0J2B4xuUnUAgWoBcKIms2gA9AVo0110SU8v6XCiJrFFN7jaa9lx9L7YZQ8uzIbI2bemKaG65l/jcJ4emFSpg0TfZKBeTGyLrOUD8CIXwjUF2/zb9VJoAtTLZqjhoXed+eQAguank/oFEnyuupy4w/WgC1OQ7hWeZ0XwvzYF8Zb0HqLLjfwvBv7qEVwMoGBdTazKrUuacoS6BNdT7yirtkL8B39RBr/+kbGoAJTMgnifP6qunP7JCczpvDpH1HOq4IsBIMrmfaqi50wYoHT9PmLp0jII7mbHdyh2995K1AZC+lAcrJIJrpZSAygZGVteGCTKJ9AeJx3wbwj1NygNympiacM0ZSf/x7rFE5W9KWWuLBT1cI/GaX8esFP09FINy5pHkEGCFMvq+b8hrH4CcpoNlP9iwQ1yNPIx/hZybIOavcW86QULVdASekstKuZFobvkuWiHv9aPle+h08yHqyA3g5XtoVK0q6CylD1Ug3v/HQgE0M8wLoAXQzDSQmThlhRZAM9NAZuKUFVoAzUwDmYlTVmhmgEY/y7XpB0dT/GLAs8+kgdcYxxmMbOMxRvlYctp4TQoohOOXEnXByDZlDC2fSE4ju6kBXWNUxsJUEHqUwGuM4wxGNmpii0KMObqcNna1+1BOBtNnsxuU5xR4HU1O7YDym6opoEpii1ifA0WTM6nJ3UbTMGP0vy6qoyGatt7ByK5Ox6wPkdOHL80rVEJX6J9sJKAHBSPbOpuoPEROJ4uaAXUyjwaDgpF9OlbWRmKWnGz1mtzGHHxHL7ISnB2iwRzPmTYyPs+225h8p9TLrGbMEYORZTwGk11Iox3JfeX0EscFKM0dg7ZGJ4DEQDKOa5pMUkYwyWOF3DsYme21EPlHIjsiU5s1KZNNYLvOeK3d5CYJRjZqYtrCEDl7OdUOKI8KnYHXmOGcyUdIXsHIvRqZptJLTh/WxgRUHLv4vw1/BARpm8DrGTtDH17ByJuB01yklNPJca8PdT7t0QBK5uwjnTxmVfTAa4wRFIzc8BE1G0NOH4ZLoLWPlnagDSYUD1ZKoPUOYBXE4pg+NIix0niYBgqgw/Sm9qkCqFpohjFWAB2mN7VPyWvLDLskOWaqmcX9Wi3XhbGqixdUUuMnK5QnLO0/QXb+H07R6eQa4Pv9P5j9BT3HGo0atO41AAAAAElFTkSuQmCC",
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}1.0 & 1.0 i\\\\- 1.0 i & 1.0\\end{matrix}\\right]$"
],
"text/plain": [
"⎡ 1.0 1.0⋅ⅈ⎤\n",
"⎢ ⎥\n",
"⎣-1.0⋅ⅈ 1.0 ⎦"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Multiplicamos la transpuesta conjugada por esa matriz\n",
"A.H*A"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Como en el ejemplo anterior, no se obtiene la matriz identidad no podemos utilizar esa matriz como una puerta cuántica. Comprobemos si la matriz \n",
"\n",
"$$U=\\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc}\n",
"1 & i\\\\\n",
"i & -1\n",
"\\end{array}\\right)$$\n",
"\n",
"es unitaria:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"U=np.array([[1/np.sqrt(2),1j/np.sqrt(2)],[1j/np.sqrt(2),-1/np.sqrt(2)]])\n",
"U1=Operator(U)\n",
"U1.is_unitary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En consecuencia no sería unitaria. Probemos con \n",
"\n",
"$$U=\\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc}\n",
"1 & 1\\\\\n",
"i & -i\n",
"\\end{array}\\right)$$"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"U=np.array([[1/np.sqrt(2),1/np.sqrt(2)],[1j/np.sqrt(2),-1j/np.sqrt(2)]])\n",
"U1=Operator(U)\n",
"U1.is_unitary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Entonces la matriz anterior sería unitaria y por lo tanto se corresponde con alguna puerta cuántica. Ademas:\n",
"\n",
"$$U|0\\rangle = |i\\rangle \\qquad U|1\\rangle=-|i\\rangle$$\n",
"\n",
"```{index} reversibilidad\n",
"```\n",
"## Reversibilidad.\n",
"\n",
"Diremos que una matriz es reversible o invertible si existe una matriz, denotada por $M^{-1}$ de forma que se cumple:\n",
"\n",
"$$M\\cdot M^{-1}=M^{-1}\\cdot M=I$$\n",
"\n",
"Ahora ya sabemos que una matriz correspondiente a una puerta cuántica verifica:\n",
"\n",
"$$U^{\\dagger}U=UU^{\\dagger}=I$$\n",
"\n",
"\n",
"De la expresión anterior además se puede deducir que U también verifica que la matriz transpuesta conjugada debe ser igual a la matriz inversa, es decir:\n",
"\n",
"$$U^{-1}=U^{\\dagger}$$\n",
"\n",
"Por lo tanto, se concluye lo siguiente:\n",
"\n",
"```{note}\n",
"La matriz de una puerta cuántica también deber ser reversible y la inversa coincide con la matriz transpuesta conjugada\n",
"```\n",
"(outer)=\n",
"## Producto externo (Outer).\n",
"\n",
"En esta sección vamos a mostrar lo que se entiende por producto externo de matrices o *outer product*. El resultado que se obtiene es otra matriz, no un escalar como era el caso del producto interno ya visto en secciones anteriores.\n",
"\n",
"Consideremos dos estados cuánticos:\n",
"\n",
"$$ |\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle,\\quad|\\phi\\rangle=\\gamma|0\\rangle+\\delta|1\\rangle. $$\n",
"\n",
"En lugar de hacer el producto interno $\\langle \\psi | \\phi\\rangle$, vamos a definir el producto externo de la siguiente manera:\n",
"\n",
"$$ |\\psi\\rangle\\langle\\phi|={\\binom{\\alpha}{\\beta}}(\\gamma^{*}\\ \\delta^{*}) = \\binom{\\alpha\\gamma^{*} \\quad \\alpha\\delta^{*}}{\\beta\\gamma^{*} \\quad \\beta\\delta^{*}} $$\n",
"\n",
"Por lo tanto el resultado es una matriz 2x2, y entonces podemos utilizar este producto externo para construir otras puertas cuánticas. Por ejemplo consideremos lo siguiente:\n",
"\n",
"$$ U=|1\\rangle\\langle0|+|0\\rangle\\langle1|. $$\n",
"\n",
"\n",
"Y ahora veamos cómo actúa sobre el estado $|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$.\n",
"\n",
"$$\\begin{align*}\n",
"U|\\psi\\rangle & =\\left(|1\\rangle\\langle0|+|0\\rangle\\langle1|\\right)\\left(\\alpha|0\\rangle+\\beta|1\\rangle\\right)=\\\\\n",
"= & \\alpha|1\\rangle\\underset{1}{\\underbrace{\\langle0|0\\rangle}}+\\beta|1\\rangle\\underset{0}{\\underbrace{\\langle0|1\\rangle}+}\\alpha|0\\rangle\\underset{0}{\\underbrace{\\langle1|0\\rangle}}+\\beta|0\\rangle\\underset{1}{\\underbrace{\\langle1|1\\rangle}}=\\\\\n",
"= & \\alpha|1\\rangle+\\beta|0\\rangle=\\beta|0\\rangle+\\alpha|1\\rangle\n",
"\\end{align*}$$\n",
"\n",
"Y como $|\\alpha|^2+|\\beta|^2=1$, podemos concluir que la matriz U corresponde a una puerta cuántica válida. También hemos visto que esta puerta intercambia $|0\\rangle$ con $|1\\rangle$, por lo tanto se trata de la puerta X. Lo podemos ver igualmente de la siguiente manera:\n",
"\n",
"$$U=|1\\rangle\\langle0|+|0\\rangle\\langle1|={\\binom{0}{1}}(1\\ 0)+{\\binom{1}{0}}+(0 \\, 1)={\\binom{0 \\, 0}{1\\ 0}}+{\\binom{0\\ 1}{0}}={\\binom{0 \\ 1}{1\\ 0}}$$\n",
"\n",
"Se puede demostrar lo siguiente:\n",
"\n",
"$$\\phi\\rangle\\langle\\psi|=|\\psi\\rangle\\langle\\phi|^{\\dagger}$$\n",
"\n",
"Pues en efecto se tiene lo siguiente:\n",
"\n",
"$$|\\phi\\rangle\\langle\\psi|={\\binom{\\gamma}{\\delta}}(\\alpha^{*}\\:\\beta^{*})={\\binom{\\gamma\\alpha^{*}\\;\\gamma\\beta^{*}}{\\delta\\alpha^{*}\\;\\delta\\beta^{*}}}={\\binom{\\alpha\\gamma^{*}\\;\\alpha\\delta^{*}}{\\beta\\gamma^{*}}^{\\gamma}}=|\\psi\\rangle\\langle\\phi|^{\\dagger}$$\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Relación de completitud.\n",
"\n",
"Recordar [de un apartado anteriormente visto](proyecciones) que para cualquier base ortonormal $\\{|a\\rangle , |b\\rangle \\}$ el estado de un qubit puede ser escrito de la de la siguiente manera:\n",
"\n",
"$$|\\psi\\rangle=\\alpha|a\\rangle+\\beta|b\\rangle,$$\n",
"\n",
"de tal manera que $\\alpha=\\langle a|\\psi\\rangle\\operatorname{y}\\beta=\\langle b|\\psi\\rangle$. Sustituyendo estos valores.\n",
"\n",
"$$|\\psi\\rangle=\\underset{escalar}{\\underbrace{\\langle a|\\psi\\rangle}}|a\\rangle+\\underset{escalar}{\\underbrace{\\langle b|\\psi\\rangle}}|b\\rangle$$\n",
"\n",
"Como ya se ha dicho el producto interno es un escalar o número y por lo tanto en lugar de multiplicar por la izquierda, lo pasamos al lado derecho:\n",
"\n",
"$$|\\psi\\rangle=\\underset{escalar}{|a\\rangle\\underbrace{\\langle a|\\psi\\rangle}}+\\underset{escalar}{|b\\rangle\\underbrace{\\langle b|\\psi\\rangle}}$$\n",
"\n",
"Lo anterior lo podemos escribir de la siguiente manera con la finalidad de dejar más claro su significado:\n",
"\n",
"$$\\psi\\rangle=|a\\rangle\\langle a||\\psi\\rangle+|b\\rangle\\langle b| |{\\boldsymbol{\\psi}}\\rangle$$\n",
"\n",
"Ahora tenemos dos productos externos $|a\\rangle\\langle a|\\mathrm{\\,y\\,}|b\\rangle\\langle b|$ y podemos reducir la expresión anterior a lo siguiente:\n",
"\n",
"$$|\\psi\\rangle=(|a\\rangle\\langle a|+|b\\rangle\\langle b|)|\\psi\\rangle$$\n",
"\n",
"Commo esto es cierto para cualquier $|\\psi\\rangle$ , entonces se puede concluir que:\n",
"\n",
"$$|a\\rangle\\langle a|+|b\\rangle\\langle b|=I$$\n",
"\n",
"Esta propiedad se conoce como *relación de completitud* e indica que el esatdo de cualquier qubit en términos de $|a\\rangle \\, y \\, |b\\rangle$. En consecuencia, podemos afirmar que:\n",
"\n",
"```{note}\n",
"Una base ortonormal completa $\\{|a\\rangle,|b\\rangle\\}$ satisface la relación de completitud siguiente:\n",
"\n",
"$$|a\\rangle\\langle a|+|b\\rangle\\langle b|=I$$\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"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"
}
},
"nbformat": 4,
"nbformat_minor": 5
}