Computación_Cuántica.ipynb

{
    "cells": [
    {
 	    "cell_type": "markdown", 
 	    "source": [ 
 		"# Computación Cuántica" 
 	    ], 
 	    "metadata": {} 
	},
        {
            "cell_type": "markdown",
            "source": [
                "## Preliminares \n",
                "Este material presenta una introducción a la algorítmica básica en el cómputo cuántico, así como conceptos periféricos, utilizando la interfaz de programación contenida en el paquete `Yao` en Julia.\n",
                "\n",
                "La computacón cuántica es un área mucho más extensa que solo lo que se discutirá aquí, e incluso actualmente no se tiene un panorama consensuado de lo que deberían ser las **capas, arquitectura o flujo de la computación cuántica**, comenzando desde su implementación física hasta cualquier aplicación que haga uso abstracto de dicha implementación.\n",
                "\n",
                "No obstante, para ejemplificar una posible visión, mostramos la siguiente imagen:\n",
                "\n",
                "![Capas_QC](https://upload.wikimedia.org/wikipedia/commons/f/fa/Jones-2012-figure01.png)\n",
                "\n",
                "Aquí podemos apreciar que la algorítmica es una abstracción de las posibles implementaciones físicas que pueden existir y además es resultado de un conjunto de asunciones teóricas que se deben procurar garantizar en las implementaciones mediante cuidados de la capa 2: Virtual (corrección de error, desacoplamiento dinámico, ciclo de control-retroalimentación del sistema, etc.)\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Abstracción a nivel de circuito\n",
                "### Diseño de un circuito\n",
                "En la algorítmica del cómputo cuántico trabajamos con los siguientes objetos abstractos (que pueden ser implementados de diversas maneras físicamente):\n",
                "- Registros de qubits\n",
                "- compuertas lógicas cuántica\n",
                "- Aparatos de medición \n",
                "- Ligaduras de control\n",
                "\n",
                "Para proveer un ejemplo de un diagrama que contenga todos estos elementos considere el siguiente:\n",
                "\n",
                "![diagrama_circuito](https://tutorials.yaoquantum.org/dev/generated/quick-start/1.prepare-ghz-state/assets/ghz4.png)\n",
                "\n",
                "Tenemos un **registro de qubits** que consiste de los qubits $\\{Q_0, Q_1, Q_2, Q_3\\}$. Éstos están todos en el estado $|0\\rangle$, como suele ser común para muchos algoritmos cuánticos.\n",
                "\n",
                "Los cuadrados, etiquetado uno con una X y otros 7 con H, son ejemplos de compuertas lógicas. Respectivamente se les conoce como compuerta X de Pauli y compuerta de Hadamard.\n",
                "\n",
                "Éstas, matemáticamente hablando, son operadores unitarios de los cuales, como es bien conocido, tenemos infinitos para cualquier espacio de Hilbert no trivial con el que trabajemos en nuestro sistema cuántico. \n",
                "\n",
                "No obstante, elegimos darle nombres a éstas por permitir cálculos limpios en ciertas elecciones de base importantes que podemos realizar en el espacio de Hilbert. Las lineas verticales que conectan algunos de los qubits y poseen un nodo con $\\oplus$ y otro relleno son otro ejemplo de compuerta lógica, aunque más compleja\n",
                "\n",
                "Éstas son compuertas de control que pueden influir en el estado de un qubit en base al estado de otro. Estas son un ejemplo de lo que llamamos **compuertas compuestas** que, matemáticamente, son operadores del espacio producto de los espacios de estado de los qubits involucrados.\n",
                "\n",
                "Finalmente, al final de la linea de acción de cada uno de los qubits tenemos un elemento de diagrama que simboliza un aparato de medición. Éstos son necesarios para obtener la información contenida en los estados del registro, considerado el **output** o **salida** del algoritmo cuántico que este circuito representa.\n",
                "\n",
                "### Registro de estados\n",
                "#### Registros completamente activos\n",
                "\n",
                "Comencemos creando algunos registros. Primero cargamos el paquete `Yao`:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "using Pkg; Pkg.activate(\".\"); using Yao\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 2
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos crear el registro del diagrama de arriba utilizando la función `zero_state` que nos otorga con facilidad este común registro de cualquier tamaño:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "zero_state(4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 3
        },
        {
            "cell_type": "markdown",
            "source": [
                "Como la naturaleza de la medición que obtenemos de los qubits es inevitablemente probabilística, a veces es deseado tener un número de **batches** o **lotes** que representan varias realizaciones del mismo circuito para obtener estadísticas.\n",
                "\n",
                "En este siguiente comando creamos 5 lotes de un registro de 3 qubits, todos en el estado $|0\\rangle$.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "zero_state(3, nbatch = 5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 4
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos también construir un registro a partir de una cadena de bits que representa en análogo clásico del estado cuántico (respecto a alguna base):\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "product_state(bit\"101\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 5
        },
        {
            "cell_type": "markdown",
            "source": [
                "Para cualquier registro podemos extraer el estado explícito como arreglo de números complejos de la siguiente manera:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "product_state(bit\"101\").state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 6
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Notemos que este vector no tendrá $3$ elementos correspondiendo a los 3 digitos de la cadena de bits, si no que tendremos $8 = 2^3$.\n",
                "\n",
                "Por supuesto podemos también construir más de un lote, y también cambiar el tipo de número complejo utilizando para guardar en memoria el estado:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "product_state(ComplexF32, bit\"111\", nbatch = 3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 7
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "product_state(ComplexF32, bit\"111\", nbatch = 3).state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 8
        },
        {
            "cell_type": "markdown",
            "source": [
                "A veces no necesitamos especificar el estado explícito, y queremos en su lugar generar un estado aleatorio (basándonos en una distribución binormal estándar) que nos permita poner a prueba cierto circuito independiente de sus entradas:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "rand_state(2)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 9
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                " rand_state(2).state ## Estado de 2 qubits tiene 2^2 = 4 entradas.\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 10
        },
        {
            "cell_type": "markdown",
            "source": [
                "Otro registro comúnmente utilizado es el registro de estados uniformes:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "uniform_state(4).state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 11
        },
        {
            "cell_type": "markdown",
            "source": [
                "Estos tienen la forma: $\\frac{1}{n} \\sum_k |k\\rangle$ y pueden ser similarmente obtenidos tras aplicar una compuerta de hadamar multidimensional a un registro de puros estados $|0\\rangle$ (es decir, una compuerta de hadamard *sencilla* por cada qubit). \n",
                "\n",
                "Finalmente, mostramos que cualquier registro puede ser representado en su forma hiperbólica, es decir, como elemento de un espacio tensorial general. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "hypercubic(uniform_state(4))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 12
        },
        {
            "cell_type": "markdown",
            "source": [
                "Comparando dimensiones:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "uniform_state(4) |> state |> size\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 13
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                " hypercubic(uniform_state(4)) |> size\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 14
        },
        {
            "cell_type": "markdown",
            "source": [
                "El último muestra cómo el elemento del espacio vectorial de dimension 16 se entiende como un elemento de un espacio vectorial generado a partir de productos tensoriales de 4 espacios vectoriales de dimensión 2 (es decir, los espacios asociados a cada qubit individual).\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "#### Registros enfocados\n",
                "En la práctica, no todos los qubits presentes en el sistema que consideramos el 'computador cuántico' son utilizados para realizar operaciones. Muchos están presentes para asistir a procedimientos de corrección de error o flujo de control entre componentes, pero éstos no son menos importantes de preservar bajo coherencia cuántica.\n",
                "\n",
                "Estos qubits de ambiente, no obstante, deben ser considerados explícitamente ya que afectan el estado general del registro y `Yao` provee una interfaz para hacer eso. Considere el siguiente registro\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "zero_state(5) |> focus!(1,4,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 15
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notemos que el resultado nos muestra solmente $3$ de los $5$ qubits como qubits activo. Estos qubits activos son lo que conocemos como **qubits de sistema** y son sobre lso que operaremos. El resto solo funcionan como ambiente. El estado general del registro sigue siendo el mismo que si todos fueran activos:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(zero_state(5) |> focus!(1,4,5)).state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 16
        },
        {
            "cell_type": "markdown",
            "source": [
                "Pero en cualquier momento somos capaces de encontrar el número de qubits de sistema y qubits de ambiente de un registro dado:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ψ₁ = zero_state(5) |> focus!(1,4,5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 17
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "nqubits(ψ₁), nactive(ψ₁), nremain(ψ₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 18
        },
        {
            "cell_type": "markdown",
            "source": [
                "Si queremos '*relajar*' los qubits de ambiente hacia un estado de control con el cual podamos operar, se puede utilizar el comando `relax!` de las siguientes formas:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ψ₁ |> relax!()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 19
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "relax!(ψ₁)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 20
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "relax!(ψ₁, to_nactive = 4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 21
        },
        {
            "cell_type": "markdown",
            "source": [
                "En el último llamado se muestra que podemos controlar el número de qubits del sistema con el que queremos terminar. Note que no elegimos los índices de 'cuales' qubits activar (recordando que antes estaban activos los de índice `5`, `3`, y `2`).\n",
                "\n",
                "Esto es porque el índice de cierto qubit es un ordemamiento arbitrario: No importa si consideramos que el registro activo consiste de los qubits que originalmente llamamos $\\{5,2,3\\}$ o de otros, pues esas etiquetas originales fueron arbitrarias para la física.\n",
                "\n",
                "#### Aritmética de registros\n",
                "Podemos operar con la aritmética esperada sobre nuestros registros mientras sea teóricamente válida la operación. \n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tψ₂ = rand_state(5)\n",
                "\tψ₃ = rand_state(5) \n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 22
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(0.3ψ₂ + 2ψ₃)/2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 23
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(0.3ψ₂ + 2ψ₃)/2 |> state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 24
        },
        {
            "cell_type": "markdown",
            "source": [
                "No obstante..\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(0.3ψ₂ + 2ψ₃)/2 |> isnormalized\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 25
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notamos que este nuevo estado no se normaliza por defecto. La **Normalización** es una condición requerida para los estados puros del sistema finito dimensional (como es nuestro caso. En casos más generales de sistemas cuánticos, esta condición se traduce a que el mapa lineal de densidad sea tipo traza con traza igual a 1).\n",
                "\n",
                "Es decir, requerimos que la norma de la representación pura del estado (aquí denotados como $\\psi$) sea igual a 1. Debemos siempre recordar que posterior a alguna operación, debemos normalizar de nuevo el vector representante del estado.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ψ₄ = (0.3ψ₂ + 2ψ₃)/2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 26
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ψ₄ |> normalize! |> isnormalized\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 27
        },
        {
            "cell_type": "markdown",
            "source": [
                "Exploramos ahora la norma:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ψ₄' * ψ₄ ## la comilla ' representa la operación de transposición en la base selecta.\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 28
        },
        {
            "cell_type": "markdown",
            "source": [
                "### Compuertas lógicas y mediciones\n",
                "#### Mediciones\n",
                "Las compuertas lógicas son la forma en que podemos transformar los estados de los registros de qubits que hemos creados. En Yao estos se pueden definir, al igual que los aparatos de medición, en los denominados **bloques**.\n",
                "\n",
                "Primero, preparemos un registro con la suma de dos registros y lo normalizamos posteriormente:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "r = normalize!(ArrayReg(bit\"000\") + ArrayReg(bit\"111\"))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 29
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "r.state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 30
        },
        {
            "cell_type": "markdown",
            "source": [
                "Medir este registro es tan sencillo como utilizar el operador pipe, 'pasándole' el registro al bloque de medición, en este caso, de tres qubits.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "r |> Measure(3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 31
        },
        {
            "cell_type": "markdown",
            "source": [
                "Recordemos que en mecánica cuántica, el acto de permitir que el sistema cuántico aislado interactue con un ambiente de baja coherencia resulta en perder la superposición que antes teníamos y obtener un solo estado bien definido.\n",
                "\n",
                "Los detalles de cómo sucede esto es, en general, aun un problema abierto conocido como el [problema de medición](https://en.wikipedia.org/wiki/Measurement_problem), siendo aun uno de los misterios más importantes a resolver en los fundamentos teóricos de la mecánica cuántica\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "r.state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 32
        },
        {
            "cell_type": "markdown",
            "source": [
                "Notamos que el estado mostrado ha colapsado de ser uan superposición a representar un estado con análogo clásico que se puede entender como un resultado definido.\n",
                "\n",
                "Esto fue un ejemplo de un **bloque**. Los bloques consisten de operaciones generales como medición o compuertas lógicas, pero igualmente Yao nos permite realizar el proceso de medición sin tener que utilizar bloques. La mayoría de transformaciones tienen su versión fuera de bloque:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## Mostrará un resultado distinto si se sigue midiendo...\n",
                "(product_state(5, 0b10) + product_state(5, 0b11)) |> measure\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 33
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos también especificar el número de veces que quisieramos medir:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "reg = rand_state(7)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 34
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "measure(reg; nshots=5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 35
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Compuertas comunes\n",
                "Las compuertas lógicas, fuera de bloques, son representados por sus símbolos comunes para las más utilizadas:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof((X, Z, Y, H))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 36
        },
        {
            "cell_type": "markdown",
            "source": [
                "donde sus matrices unitarias asociadas en la base canónica son:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "mat(X)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 37
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                " mat(Y)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 38
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "mat(Z)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 39
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                " mat(H)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 40
        },
        {
            "cell_type": "markdown",
            "source": [
                "No obstante, nos enfocaremos en el uso dentro de bloques. Para hacer uso de ellos en bloques, debemos especificar cuántas y cuáles compuertas estarán dentro del bloque dado. Utilizamos `repeat` para repetir una compuerta `n` veces.\n",
                "\n",
                "Como ejemplo, considere el siguiente estado:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ArrayReg(bit\"0\").state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 41
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(ArrayReg(bit\"0\") |> repeat(1, X)).state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 42
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(ArrayReg(bit\"0\") |> repeat(2, X)).state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 43
        },
        {
            "cell_type": "markdown",
            "source": [
                "La compuerta $X$ de pauli se conoce como el **bit flip** que, como se muestra arriba, transforma el estado $|0\\rangle$ hacia $|1\\rangle$ y viceversa. Esto significa que al aplicarla dos veces, regresamos al estado original en este caso. \n",
                "\n",
                "Para una lista más detallada y efecto de las compuertas más utlizadas ver [aquí](https://en.wikipedia.org/wiki/Quantum_logic_gate).\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "Aquí se está operando unqubit individual con una cantidad general $n$ de compuertas secuenciales. Otra forma importante de operar es especificar la accion en un registro de $m$ qubits con compuertas presentar en solamente algunos de los qubits. Considere:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "mat(put(3, 2=>X))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 44
        },
        {
            "cell_type": "markdown",
            "source": [
                "el comando `put(m, k=>C)` coloca la compuerta `C` en el qubit `k` en el registro con `m` qubits (siendo `k<m`). Esto se representa como una matriz sobre el espacio vectorial del registro entero. Para poder enlazar varios bloques `put`, utilizamos `chain` para crear una cadena de bloques\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "chain(put(3, 2=>X), put(3, 1=>Y))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 45
        },
        {
            "cell_type": "markdown",
            "source": [
                "La cadena tiene una estructura de árbol que nos permite acceder a cada etapa como si fuese un arreglo (pues es efectivamente un subtipo de arreglo abstracto en Julia):\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "chain(put(3, 2=>X), put(3, 1=>Y))[2]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 46
        },
        {
            "cell_type": "markdown",
            "source": [
                "La matriz asociada a la cadena será, de nuevo, un operador unitario sobre el espacio vectorial asociado a todo el registro activo:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "mat(chain(put(3, 2=>X), put(3, 1=>Y)))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 47
        },
        {
            "cell_type": "markdown",
            "source": [
                "#### Compuertas de control\n",
                "El diagrama mostrado al inicio del documento tenía elementos que conectan dos lineas de evolución de qubits. Estas son **compuertas de control** que consisten de un qubit de control y otro de respuesta.\n",
                "\n",
                "El qubit de control debe estar en el estado $|1\\rangle$ para que el qubit de respuesta aplique la compuerta especificada. Es decir, tenemos versiones de las compuertas discutidas anteriormente que contienen un control: Control-$X$, control-$H$, etc.\n",
                "\n",
                "Cabe agregar que aquí es donde comienzan a surgir efectos interesantes que contrastan el cómputo cuántico de el cómputo clásico, pues puede ser el caso que un qubit *colapse* al estado $|1\\rangle$ con cierta probabilidad $\\alpha <1$.\n",
                "\n",
                "Esta propiedad se explota en algoritmos cuánticos para cargar información probabilística condicional que nos pueda garantizar encontrar lo que deseamos con menor cómputo de lo que condicionales clásicos requerirían.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "control(4, 3, 1 => X)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 48
        },
        {
            "cell_type": "markdown",
            "source": [
                "El anterior comando crea una compuerta de control $X$ en un registro de tamaño $4$, con qubit de control $3$ y qubit de respuesta $1$. Es decir, solamente si el qubit $3$ resulta tener el estado $|1\\rangle$ vamos a actuar con $X$ sobre $1$. \n",
                "\n",
                "Es importante notar que el estado de $3$ va a ser conocido hasta que realicemos la medición al final del circuito (o que se rompa la coherencia cuántica con otras interacciones con el ambiente, pero de manera ideal, sería mediante la medición controlada). Esto quiere decir que el efecto de $X$ sobre $1$ es probabilístico también, y no sabremos si se efectuó hasta medir (y a veces ni midiendo sabremos si un efecto particular se dio a cabo dentro de un circuito complejo).\n",
                "\n",
                "#### Aplicando bloques a registros\n",
                "Apliquemos todo lo anteriormente visto para crear nuestro primer circuito cuántico.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "using YaoBase: rand_unitary ## Genera matrices unitarias de manera aleatorio\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 49
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "circuit = chain(5, \n",
                "\t\t\t\tcontrol(5, 3=>Rx(0.25π)), \n",
                "\t\t\t\tput(5, (2,3)=>GeneralMatrixBlock(rand_unitary(4))), \n",
                "\t\t\t\tswap(5, 3, 4), \n",
                "\t\t\t\trepeat(5, H, 2:5), \n",
                "\t\t\t\tput(5, 2=>Ry(0.6)))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 50
        },
        {
            "cell_type": "markdown",
            "source": [
                "Aquí vemos una cadena de bloques para actuar en un registro de 5 qubits activos. En orden se describen a continuación:\n",
                "- Bloque de control de un operador de rotación (respecto al eje $x$) de fase $\\pi/4$, controlado por el qubit 5 y respondiendo hacia el qubit 3 (notemos que no le ocupamos pasar el número de registros, pues estamos utilizando un constructor especial de `control` que utiliza [lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation))\n",
                "- Una matriz general unitaria siendo ejecutada como compuerta lógica hacia los qubits $2$ y $3$. Observe que la matriz es de rango $4=2^2$, por lo que actúa en pares de qubits.\n",
                "- Una acción de intercambio de qubits. El qubit $3$ y $4$ han sido intercambiados de índice.\n",
                "- Un bloque de compuertas de Hadamard, $H$, aplicadas en los qubits $2, 3$, y $4$.\n",
                "- Una rotación de fase de 0.6 radianes respecto al eje $y$\n",
                "\n",
                "Las rotaciones aquí mencionadas son respecto a los ejes espaciales definidos con el modelo de [esfera de Block](https://en.wikipedia.org/wiki/Bloch_sphere).\n",
                "\n",
                "Para aplicar este circuito a algún registro utilizamos el comando `apply!`:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "result = apply!(zero_state(5), circuit)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 51
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "result.state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 52
        },
        {
            "cell_type": "markdown",
            "source": [
                "Podemos explorar el caso de un registro donde no todos los qubits están activos y utilizar una notación más elegante utilizando `Pipe`:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "using Pipe\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 53
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe zero_state(10) |> focus!(1:5) |> apply!(_, circuit) |> state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 54
        },
        {
            "cell_type": "markdown",
            "source": [
                "Esto muestra el flujo completo del circuito, desde el registro, hasta la medición de su estado final.\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "#### Métricas de comparación de registros\n",
                "\n",
                "Posterior a la medición u operación de compuerta lógica hacia un registro, nos puede gustar verificar la fidelidad con la cual el estado cuántico corresponde al que esperamos de manera teórica. En la práctica, dentro de una computadora cuántica, esta fidelidad se ve comprometida en cada operación que realizamos, así como la evolución natural del sistema.\n",
                "\n",
                "Algunas de estas métricas ya están implementadas en `Yao`:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "fidelity(rand_state(6), rand_state(6))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 55
        },
        {
            "cell_type": "markdown",
            "source": [
                "Ésta es calculada con la fórmula \n",
                "$ {\\displaystyle F(\\rho ,\\sigma )=\\left(\\operatorname {tr} {\\sqrt {{\\sqrt {\\rho }}\\sigma {\\sqrt {\\rho }}}}\\right)^{2}}$.\n",
                "\n",
                "Donde $\\rho$ y $\\sigma$ son los estados del sistema (pensados en generalidad como operadores de densidad y no como su forma pura como vectores). También tenemos la distancia inducida por la traza en el espacio de estos operadores tipo traza. Éste se define como $\\frac{1}{2} || \\rho- \\sigma||_{\\text{tr}}$ y se utiliza como `tracedist`:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "tracedist(rand_state(6), rand_state(6))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 56
        },
        {
            "cell_type": "markdown",
            "source": [
                "Ambos métricas mostradas utilizan el operador de densidad general del estado, pero al estar considerando solamente sistemas de dimensión finita, podemos representar sin ambigüedad esta en una matriz de densidad de la siguiente forma:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "(rand_state(1) |> ρ).state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 57
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Algorítmica\n",
                "### Transformada cuántica de Fourier\n",
                "\n",
                "Como ejemplo de un algoritmo cuántico clásico, construiremos el circuito asociado con la [transformada cuántica de Fourier](https://en.wikipedia.org/wiki/Quantum_Fourier_transform). Este es un algoritmo que equivale a realizar la transformada inversa discreta de Fourier a una cadena de bits, pero utilizando un circuito del tipo que acabamos de construir. \n",
                "\n",
                "Los detalles teóricos profundos serán omitidos dada la disponibilidad grande que hay de recursos que ya lo explican. Considere el siguiente diagrama que representa el circuito/algoritmo:\n",
                "\n",
                "![QFT](https://docs.yaoquantum.org/v0.3/assets/figures/qft.png)\n",
                "\n",
                "Este muestra el caso para un registro de $5$ qubits, no obstante, programaremos el caso general para un registro de $n$ qubits. El diagrama sugiere que una forma ordenada de programar este circuito es aprovechar su estructura repetitiva.\n",
                "\n",
                "Tenemos el bloque A definido por una compuerta de rotación controlada cuya posición en la cadena es determinada por cuál es su qubit de control y de respuesta, así como el valor de su rotación. Estos son respectivamente `i`, `j`, y `k`.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "A(i::Int, j::Int, k::Int) = control(i, j=>shift(2π/(1<<k)))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 58
        },
        {
            "cell_type": "markdown",
            "source": [
                "El bloque B que está compuesto por el patrón de $\\{H, R_2, \\dots, R_{n-i+1}\\}$ donde $i$ es el índice del qubit respuesta donde es aplicado B y $n$ es el número total de qubits.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "B(n::Int, i::Int) = chain(i==j ? kron(i=>H) : A(j, i, j-i+1) for j = i:n)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 59
        },
        {
            "cell_type": "markdown",
            "source": [
                "Finalmente, el algoritmo de QFT (Quantum Fourier Transform) es definido por una cadena sencilla de bloques B.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "QFT(n::Int) = chain(n, B(n, i) for i = 1:n)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 60
        },
        {
            "cell_type": "markdown",
            "source": [
                "Así, acabamos de programar la versión general del circuito de QFT:\n",
                "\n",
                "![QFT-general](https://upload.wikimedia.org/wikipedia/commons/6/61/Q_fourier_nqubits.png)\n",
                "\n",
                "Aquí vemos el caso con $n = 4$.\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "QFT(4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 61
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "qft = QFT(4); iqft = QFT(4)';\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 62
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe product_state(bit\"0110\") |> apply!(_, qft) |> state\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 63
        },
        {
            "cell_type": "markdown",
            "source": [
                "### Estimación de fase\n",
                "El algoritmo de transformada de Fourier se utiliza como una subrutina en muchos otros algoritmos. Uno de ellos es otro algoritmo básico famoso *phase estimation* (estimación de fase) que nos permite resolver el siguiente problema:\n",
                "\n",
                "Sea $U$ una matriz unitaria y sea $v$ un vector propio de $U$, es decir, se cumple que $Uv = e^{2\\pi i \\theta} v$ para algún $\\theta$. Queremos estimar el valor de $\\theta$ para un $U$ y $v$ fijos.\n",
                "\n",
                "El algoritmo de estimación de fase estima $\\theta$ con [alta probabilidad](https://en.wikipedia.org/wiki/With_high_probability) (un término técnico en algoritmos probabilísticos que significa que aumentando el tamaño muestral nos acercamos en el límite a probabilidad 1 de estar correctos) con un número de qubits que solo ocupa crecer como $O(\\log(1/\\epsilon))$ donde el error aditivo es $\\epsilon$.\n",
                "\n",
                "Considere el siguiente diagrama:\n",
                "![fase](https://docs.yaoquantum.org/v0.5/assets/figures/phaseest.png)\n",
                "\n",
                "Notemos que aquí tenemos dos conjuntos independientes de registros, los primeros que van a ser transformados por las compuertas de hadamard y QFT. Éstos controlan el segundo registro, que consiste en el estado $v$ y una sucesión de aplicaciones de poderes de $U$ para extraer así fases múltiple de la que estamos buscando, lo cual nos servirá para estimar correctamente $\\theta$. \n",
                "\n",
                "Definamos la cadena de bloques que define la sucesión de poderes de $U$.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "ControlU(n, m, U) = chain(n+m, \n",
                "\t\t\t\t\t\t  control(k, n+1:n+m => matblock(U^(2^(k-1)))) \n",
                "\t\t\t\t\t\t  for k in 1:n)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 64
        },
        {
            "cell_type": "markdown",
            "source": [
                "Luego, crear el algoritmo del circuito arriba mostrado es tan sencillo como:\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "PE(n, m, U) =chain(n+m, ## Número total de qubits, sumando ambos registros.\n",
                "        \t\t   concentrate(Hadamards(n), 1:n), ## H en el primer registro. \n",
                "        \t\t   ControlU(n, m, U),\n",
                "                   concentrate(QFT(n)', 1:n))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 65
        },
        {
            "cell_type": "markdown",
            "source": [
                "Este algoritmo es utilizado también como base o subrutina de otros algoritmos clásicos, por ejemplo el algoritmo de Shor para factorización de números enteros.\n"
            ],
            "metadata": {}
        }
    ],
    "nbformat_minor": 2,
    "metadata": {
        "language_info": {
            "file_extension": ".jl",
            "mimetype": "application/julia",
            "name": "julia",
            "version": "1.5.1"
        },
        "kernelspec": {
            "name": "julia-1.5",
            "display_name": "Julia 1.5.1",
            "language": "julia"
        }
    },
    "nbformat": 4
}