content/ex5/ex5-es.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.6"},"colab":{"name":"ex5-es.ipynb","provenance":[],"collapsed_sections":[]}},"cells":[{"cell_type":"markdown","metadata":{"id":"4AL7WjaKA84S"},"source":["# Ejercicio 5 - Algoritmo VQE\n","\n","\n","## Contexto histórico\n","\n","Durante la última década, las computadoras cuánticas han madurado rápidamente y han comenzado a hacer realidad el sueño inicial de Feynman de tener un sistema de cómputo que pudiese simular las leyes de la naturaleza de manera cuántica. Un artículo de 2014 con Alberto Peruzzo como primer autor introdujo el **algoritmo VQE** (de sus iniciales en inglés **Variational Quantum Eigensolver**, o *Solución cuántica variacional al problema de autoestados y autovalores*), un algoritmo con la intención de conseguir el estado fundamental (de mínima energía) de una molécula, con circuitos mucho más superficiales que los de otros enfoques. [1] Y, en 2017, el equipo IBM Quantum utilizó el algoritmo VQE para simular la energía fundamental de una molécula de hidruro de litio.[2]\n","\n","La magia del algoritmo VQE viene dejarle a cargo una parte del esfuerzo de procesar el problema a una computadora clásica. El algoritmo comienza con un circuito cuántico parametrizado llamado ansatz (la conjetura) que busca el parámetro óptimo para este circuito usando un optimizador clásico. La ventaja del algoritmo VQE sobre los algoritmos clásicos viene del hecho de que una unidad cuántica de procesamiento puede representar y almacenar la función de onda exacta del problema, un problema exponencialmente difícil para una computadora clásica.\n","\n","Este ejercicio 5 te permitirá a ti mismo hacer realidad el sueño de Feynman armando un VQE para determinar el estado fundamental y la energía de una molécula. Esto es interesante porque el estado fundamental puede ser utilizado para calcular varias propiedades moleculares, por ejemplo, las fuerzas exactas sobre los núcleos pueden servir para ejecutar simulaciones de dinámica molecular para explorar cómo evoluciona un sistema químico en el tiempo.[3]\n","\n","\n","\n","\n","### Referencias\n","\n","1. Peruzzo, Alberto, et al. \"A variational eigenvalue solver on a photonic quantum processor.\" Nature communications 5.1 (2014): 1-7.\n","2. Kandala, Abhinav, et al. \"Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets.\" Nature 549.7671 (2017): 242-246.\n","3. Sokolov, Igor O., et al. \"Microcanonical and finite-temperature ab initio molecular dynamics simulations on quantum computers.\" Physical Review Research 3.1 (2021): 013125.\n","\n","## Introducción\n","Para la implementación del VQE, tú deberás ser capaz de tomar decisiones de cómo quieres componer tu simulación, en particular concentrándote en los circuitos cuánticos del ansatz.\n","El motivo de esto es el hecho de que una de las tareas importantes cuando se ejecuta el algoritmo VQE en computadoras cuánticas ruidosas es la de reducir la pérdida de fidelidad (que introduce errores) encontrando el circuito cuántico más compacto posible capaz de representar el estado fundamental.\n","De manera práctica, esto conlleva a minimizar el número de compuertas a dos qubits (e.g. CNOTS) sin perder precisión.\n","\n","<div class=\"alert alert-block alert-success\">\n","\n","<b>Objetivo</b> \n","\n","Encontrar los circuitos del ansatz para representar con precisión el estado fundamental de los problemas dados. ¡Sé creativo!\n","    \n","<b>Plan</b> \n","\n","Primero aprenderás cómo componer una simulación VQE para la molécula más pequeña y luego aplica lo que aprendiste para el caso de una más grande.\n","\n","    \n","**1. Tutorial -  VQE para H$_2$:** familiarízate con VQE y escoge la mejor combinación de ansatz/optimizadores clásicos ejecutando las simulaciones de autovectores.\n","\n","**2. Desafío final - VQE para LiH:** desempeña una investigación similar a la primera parte pero limitada al simulador de autovectores solamente. Emplea los esquemas de reducción del número de qubits disponibles en Qiskit y encuentra el circuito óptimo para este sistema más grande. Optimiza el circuito y utiliza tu imaginación para encontrar maneras de escoger los mejores componentes esenciales de los circuitos parametrizados y ensamblarlos para construir el circuito de un ansatz lo más compacto posible para el estado fundamental, incluso mejor que los que ya están disponibles en Qiskit.\n","\n","</div>\n","\n","\n","<div class=\"alert alert-block alert-danger\">\n","\n","A continuación, hay una introducción a la teoría detrás de las simulaciones VQE. No tienes que entender todo antes de continuar. ¡No tengas miedo!\n","\n","\n","</div>\n","\n"]},{"cell_type":"markdown","metadata":{"id":"H6ipKydiA84W"},"source":["## Teoría\n","\n","Aquí representamos el diagrama de flujo sobre cómo se llevan a cabo las simulaciones VQE en las computadoras cuánticas.\n","\n","\n","<img src=\"resources/workflow.png\" width=800 height= 1400/>\n","\n","La idea de base del enfoque híbrido cuántico-clásico es dejar a cargo al **CPU (en inglés classical processing unit, unidad clásica de procesamiento)** y al **QPU (unidad cuántica de procesamiento)** de las partes que saben hacer mejor. La CPU se ocupa de enumerar los términos que hay que medir para calcular la energía y también de optimizar los parámetros del circuito. La QPU implementa un circuito cuántico que representa el estado cuántico del sistema y mide la energía. Más detalles a continuación: \n","\n","**CPU** calcula eficientemente las energías asociadas a los brincos electrónicos (integrales a un/dos cuerpo/s por medios de el método de Hartree-Fock) que representan el hamiltoniano, el operador energía total. El [método de Hartree-Fock (HF)](https://es.wikipedia.org/wiki/M%C3%A9todo_de_Hartree-Fock) calcula eficientemente una función de onda aproximada del estado fundamental suponiendo que esta última puede ser representada por un solo determinante de Slater (e.g. para la molécula H$_2$ en la base STO-3G con 4 espín-orbitales y qubits, $|\\Psi_{HF} \\rangle = |0101 \\rangle$ donde los electrones ocupan el espín-orbital de mínima energía). Lo que hace la QPU luego en el VQE es encontrar un estado cuántico (correspondiente al circuito y a sus parámetros) que puede representar también otros estados asociados a las correlaciones electrónicas faltantes (i.e.  estados $\\sum_i c_i |i\\rangle$ en  $|\\Psi \\rangle = c_{HF}|\\Psi_{HF} \\rangle + \\sum_i c_i |i\\rangle $ dónde $i$ es un código binario). \n","\n","Después del cálculo de HF, se le asigna a cada operador en el hamiltoniano una medición en la QPU usando transformaciones fermión-a-qubit (ver la sección Hamiltoniano más abajo). Uno puede analizar aún más las propiedades del sistema y reducir el número de qubits o recortar el circuito del ansatz:\n","\n","\n","- Para simetrías Z2 y reducción de dos qubits, ver [Bravyi *et al*, 2017](https://arxiv.org/abs/1701.08213v1).\n","\n","- Para la forja de entrelazamiento (*entanglement forging*), ver [Eddins *et al.*, 2021](https://arxiv.org/abs/2104.10220v1).\n","\n","- Para ansatz adaptativos, ver [Grimsley *et al.*,2018](https://arxiv.org/abs/1812.11173v2), [Rattew *et al.*,2019](https://arxiv.org/abs/1910.09694), [Tang *et al.*,2019](https://arxiv.org/abs/1911.10205). Puedes utilizar ideas de estos artículos para encontrar maneras de recortar los circuitos cuánticos.\n","\n","**QPU** implementa circuitos cuánticos (ver la sección Ansatz más abajo), parametrizados por ángulos $\\vec\\theta$, que representan la función de onda del estado fundamental al colocar varias rotaciones de un qubit y entrelazadores (e.g. compuertas a dos qubits). La ventaja cuántica reposa sobre el hecho de que las QPU pueden eficientemente representar y almacenar la función de onda exacta, cosa que se vuelve intratable para sistemas de cómputo clásicos cuando hay más de unos cuantos átomos. Finalmente, la QPU mide los operadores escogidos (e.g. aquellos que representan el hamiltoniano).\n","\n","A continuación, vamos un poco más en los detalles matemáticos de cada componente del algoritmo VQE. También puede ser de ayuda ver nuestro video [episodio en video sobre VQE](https://www.youtube.com/watch?v=Z-A6G0WVI9w).\n","\n","\n","\n","### Hamiltoniano \n","Aquí explicamos cómo obtener los operadores que necesitamos medir para obtener la energía de un sistema dado.\n","Estos términos están incluidos en el hamiltoniano molecular definido así:\n","\n","$$\n","\\begin{aligned}\n","\\hat{H} &=\\sum_{r s} h_{r s} \\hat{a}_{r}^{\\dagger} \\hat{a}_{s} \\\\\n","&+\\frac{1}{2} \\sum_{p q r s} g_{p q r s} \\hat{a}_{p}^{\\dagger} \\hat{a}_{q}^{\\dagger} \\hat{a}_{r} \\hat{a}_{s}+E_{N N}\n","\\end{aligned}\n","$$\n","con\n","$$\n","h_{p q}=\\int \\phi_{p}^{*}(r)\\left(-\\frac{1}{2} \\nabla^{2}-\\sum_{I} \\frac{Z_{I}}{R_{I}-r}\\right) \\phi_{q}(r)\n","$$\n","$$\n","g_{p q r s}=\\int \\frac{\\phi_{p}^{*}\\left(r_{1}\\right) \\phi_{q}^{*}\\left(r_{2}\\right) \\phi_{r}\\left(r_{2}\\right) \\phi_{s}\\left(r_{1}\\right)}{\\left|r_{1}-r_{2}\\right|} \n","$$\n","\n","donde $h_{r s}$ y $g_{p q r s}$ son las integrales a uno/dos cuerpo/s (usando el método de Hartree-Fock) y  $E_{N N}$ la energía de repulsión nuclear.\n","La integral a un cuerpo representa la energía cinética de los electrones y su interacción con el núcleo.\n","Las integrales a dos cuerpos representan la interacción electrón-electrón.\n","Los operadores $\\hat{a}_{r}^{\\dagger}, \\hat{a}_{r}$ representan la creación y destrucción de un electrón en el espín-orbital $r$ y requieren ser asignados a operadores, de manera que podamos medirlos en una computadora cuántica.\n","Nótese que el VQE minimiza la energía electrónica, así que tendrás que recuperar y añadir la energía de repulsión nuclear $E_{NN}$ para calcular la energía total.\n","\n","Así que para cada elemento de matriz no nulo en los tensores $ h_{r s}$ y $g_{p q r s}$, podemos construir cadenas de Pauli (producto tensorial de operadores de Pauli) con la transformación fermión-a-qubit siguiente.\n","Por ejemplo, en la transformación de Jordan-Wigner para un orbital $r = 3$, obtenemos la siguiente cadena de Pauli:\n","$$\n","\\hat a_{3}^{\\dagger}= \\hat \\sigma_z \\otimes \\hat \\sigma_z \\otimes\\left(\\frac{ \\hat \\sigma_x-i \\hat \\sigma_y}{2}\\right) \\otimes 1 \\otimes \\cdots \\otimes 1\n","$$\n","\n","donde $\\hat \\sigma_x, \\hat \\sigma_y, \\hat \\sigma_z$ son los célebres operadores de Pauli. Los productos tensoriales de operadores $\\hat \\sigma_z$ se deben colocar para imponer las relaciones de anti-conmutación.\n","Aquí está una representación de la transformación Jordan-Wigner entre los 14 orbitales de la molécula de agua con 14 qubits:\n","\n","\n","<img src=\"resources/mapping.png\" width=600 height= 1200/>\n","\n","Entonces, uno simplemente reemplaza las excitaciones a uno/dos cuerpo/s (e.g. $\\hat{a}_{r}^{\\dagger} \\hat{a}_{s}$, $\\hat{a}_{p}^{\\dagger} \\hat{a}_{q}^{\\dagger} \\hat{a}_{r} \\hat{a}_{s}$) en el hamiltoniano por las cadenas de Pauli correspondientes (i.e. $\\hat{P}_i$, ver la imagen de arriba). La serie de operadores resultante está lista para ser medida con la QPU.\n","Para detalles adicionales ver [Seeley *et al.*, 2012](https://arxiv.org/abs/1208.5986v1).\n","\n","### Ansatz\n","\n","Hay dos tipos principales de ansatz que se pueden usar en problemas de química. \n","\n","- **Ansatz q-UCC** están inspirados en la física, y aproximadamente transforman las excitaciones electrónicas en circuitos cuánticos. Los ansatz q-UCCSD (`UCCSD`en Qiskit) contienen todas las posibles excitaciones a uno y dos electrones. El doble apareado q-pUCCD (`PUCCD`) y singlete q-UCCD0 (`SUCCD`) solo consideran subconjuntos de esas excitaciones (lo que implica circuitos significativamente más cortos) y han demostrado que proveen buenos resultados para perfiles de disociación. Por ejemplo, q-pUCCD no tiene excitaciones individuales y las excitaciones dobles se aparean como lo muestra la imagen de más abajo.\n","\n","- **Ansatz heurístico (`TwoLocal`)** fueron creados para acortar la profundidad del circuito pero son todavía capaces de representar el estado fundamental.\n","En la figura de abajo, las compuertas R representan rotaciones parametrizadas de qubits individuales y $U_{CNOT}$ los entrelazadores (compuertas a dos qubits). La idea es que después de repetir un mismo bloque unas ciertas $D$-veces (con parámetros independientes) se puede alcanzar el estado fundamental.\n","\n","Para detalles adicionales referirse a [Sokolov *et al.* (ansatz q-UCC)](https://arxiv.org/abs/1911.10864v2) y [Barkoutsos *et al.* (ansatz heurístico)](https://arxiv.org/pdf/1805.04340.pdf).\n","\n","<img src=\"resources/ansatz.png\" width=700 height= 1200/>\n","\n","\n","\n","### VQE\n","\n","Dado un operador hermítico $\\hat H$ con $E_{min}$ un autovalor mínimo desconocido, asociado con el autoestado $|\\psi_{min}\\rangle$, VQE proporciona una estimación $E_{\\theta}$ acotada por $E_{min}$:\n","\n","\n","\\begin{align*}\n","    E_{min} \\le E_{\\theta} \\equiv \\langle \\psi(\\theta) |\\hat H|\\psi(\\theta) \\rangle\n","\\end{align*}  \n","\n","donde $|\\psi(\\theta)\\rangle$ es el estado de ensayo asociado con $E_{\\theta}$. Al aplicar un circuito parametrizado, representado por $U(\\theta)$ a un estado inicial arbitrario $|\\psi\\rangle$, el algoritmo obtiene una estimación $U(\\theta)|\\psi\\rangle \\equiv |\\psi(\\theta)\\rangle$ aplicada sobre $|\\psi_{min}\\rangle$. La estimación es optimizada de manera iterativa a través de optimizador clásico cambiando el parámetro $\\theta$ y minimizando el valor esperado de $\\langle \\psi(\\theta) |\\hat H|\\psi(\\theta) \\rangle$. \n","\n","Aplicaciones de VQE, son posibles en simulaciones de dinámica molecular, ver [Sokolov *et al.*, 2021](https://arxiv.org/abs/2008.08144v1), y cálculos de estados excitados, ver [Ollitrault *et al.*, 2019](https://arxiv.org/abs/1910.12890), solo por mencionar algunos casos.\n","\n","\n","<div class=\"alert alert-block alert-danger\">\n"," \n","<b> Referencias para detalles adicionales</b> \n","\n","Para el tutorial de qiskit-nature que implementa este algoritmo ir [aquí](https://qiskit.org/documentation/nature/tutorials/01_electronic_structure.html) pero esto no será suficiente y puede que quieras buscar en la [primera página del repositorio de github](https://github.com/Qiskit/qiskit-nature) y la  [carpeta test](https://github.com/Qiskit/qiskit-nature/tree/main/test) que contiene casos de prueba que están escritos para cada componente, suministrando el código de base para cada funcionalidad.\n","\n","</div>"]},{"cell_type":"markdown","metadata":{"id":"CuWLX8mRA84b"},"source":["## Parte 1: Tutorial - VQE para la molécula de H$_2$ \n","\n","En esta parte, harás una simulación de la molécula de H2 usando la base STO-3G junto con el driver PySCF y la transformación de Jordan-Wigner.\n","Te guiaremos a través de las secciones a continuación de manera que así podrás abordar luego problemas más difíciles.\n","\n","\n","#### 1. Driver\n","\n","Las interfaces para acceder a los códigos clásicos de química en Qiskit se llaman drivers.\n","Tenemos por ejemplo `PSI4Driver`, `PyQuanteDriver` y `PySCFDriver` disponibles.\n","\n","Al correr un driver (cálculo de Hartree-Fock para una serie de bases y de geometrías moleculares), en la celda siguiente, obtenemos toda la información necesaria sobre nuestra molécula para aplicar luego el algoritmo cuántico.\n"]},{"cell_type":"code","metadata":{"id":"H9Bwr43jA84c"},"source":["from qiskit_nature.drivers import PySCFDriver\n","\n","molecule = \"H .0 .0 .0; H .0 .0 0.739\"\n","driver = PySCFDriver(atom=molecule)\n","qmolecule = driver.run()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"kjQ_p8ZiA84d"},"source":["<div class=\"alert alert-block alert-danger\">\n","    \n","<b> Tutorial 1 preguntas </b> \n","\n","Revisa los atributos de `qmolecule` y responde las preguntas siguientes.\n","\n","1. Necesitamos saber cuáles son las características básicas de nuestra molécula. ¿Cuál es el número de electrones en tu sistema?\n","2. ¿Cuál es el número de orbitales moleculares? \n","3. ¿Cuál es el número de espín-orbitales?\n","4. ¿Cuántos qubits son necesarios para simular esta molécula con la transformación de Jordan-Wigner?\n","5. ¿Cuál es el valor de la energía de repulsión nuclear?\n","\n","Puedes encontrar las respuestas al final de este documento.\n","</div>"]},{"cell_type":"code","metadata":{"id":"-NIwM89qA84e"},"source":["# ESCRIBE TU CÓDIGO ENTRE ESTAS LÍNEAS - INICIO\n","\n","\n","\n","\n","# ESCRIBE TU CÓDIGO ENTRE ESTAS LÍNEAS - FIN"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"8D_a7kMqA84e"},"source":["#### 2. Problema de la estructura electrónica\n","\n","Puedes luego crear un objeto llamado `ElectronicStructureProblem` que puede producir la lista de operadores fermiónicos antes de transformarlos a qubits (cadenas de Pauli).\n"]},{"cell_type":"code","metadata":{"id":"WC7Nxoy6A84e"},"source":["from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem\n","problem = ElectronicStructureProblem(driver)\n","\n","# Genera los operadores en segunda cuantización\n","second_q_ops = problem.second_q_ops()\n","\n","# Hamiltoniano\n","main_op = second_q_ops[0]"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Sifhec_sA84f"},"source":["#### 3. QubitConverter\n","\n","Definamos la transformación que vas a utilizar en esta simulación. Puedes intentar una transformación diferente pero nos enfocaremos en la transformación de Jordan-Wigner o `JordanWignerMapper` ya que nos permite una correspondencia simple: 1 qubit representa un espín-orbital en la molécula."]},{"cell_type":"code","metadata":{"id":"d2S8i76gA84f"},"source":["from qiskit_nature.mappers.second_quantization import ParityMapper, BravyiKitaevMapper, JordanWignerMapper\n","from qiskit_nature.converters.second_quantization.qubit_converter import QubitConverter\n","\n","# Establece la transformación y el qubitconverter\n","mapper_type = 'JordanWignerMapper'\n","\n","if mapper_type == 'ParityMapper':\n","    mapper = ParityMapper()\n","elif mapper_type == 'JordanWignerMapper':\n","    mapper = JordanWignerMapper()\n","elif mapper_type == 'BravyiKitaevMapper':\n","    mapper = BravyiKitaevMapper()\n","\n","converter = QubitConverter(mapper=mapper, two_qubit_reduction=False)\n","\n","# Los operadores fermiónicos se transforman en operadores de qubits\n","num_particles = (problem.molecule_data_transformed.num_alpha,\n","             problem.molecule_data_transformed.num_beta)\n","qubit_op = converter.convert(main_op, num_particles=num_particles)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"5JUf2q6PA84g"},"source":["#### 4. Estado inicial\n","Como ya describimos en la sección Teoría, un buen estado inicial en química es el estado de HF (i.e. $|\\Psi_{HF} \\rangle = |0101 \\rangle$). Lo podemos preparar de la siguiente manera:"]},{"cell_type":"code","metadata":{"id":"Yj_Zj1TYA84g"},"source":["from qiskit_nature.circuit.library import HartreeFock\n","\n","num_particles = (problem.molecule_data_transformed.num_alpha,\n","             problem.molecule_data_transformed.num_beta)\n","num_spin_orbitals = 2 * problem.molecule_data_transformed.num_molecular_orbitals\n","init_state = HartreeFock(num_spin_orbitals, num_particles, converter)\n","print(init_state)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"6w7WHCd8A84h"},"source":["#### 5. Ansatz\n","Una de las decisiones más importantes es el circuito cuántico que vas a escoger para aproximar el estado fundamental.\n","Aquí hay un ejemplo de la biblioteca de circuitos de qiskit que contiene muchas posibilidades para componer tu propio circuito.\n"]},{"cell_type":"code","metadata":{"id":"uVfE5QAzA84h"},"source":["from qiskit.circuit.library import TwoLocal\n","from qiskit_nature.circuit.library import UCCSD, PUCCD, SUCCD\n","\n","# Escoge el ansatz\n","ansatz_type = \"TwoLocal\"\n","\n","# Parámetros para el ansatz q-UCC\n","num_particles = (problem.molecule_data_transformed.num_alpha,\n","             problem.molecule_data_transformed.num_beta)\n","num_spin_orbitals = 2 * problem.molecule_data_transformed.num_molecular_orbitals\n","\n","# Establece argumentos para 'twolocal'\n","if ansatz_type == \"TwoLocal\":\n","    # Rotaciones de un qubit que son aplicadas sobre todos los qubit con parámetros independientes\n","    rotation_blocks = ['ry', 'rz']\n","    # Compuertas entrelazantes\n","    entanglement_blocks = 'cx'\n","    # La manera en cómo están entrelazados los qubits\n","    entanglement = 'full'\n","    # Repeticiones de 'rotation_blocks + entanglement_blocks' con parámetros independientes\n","    repetitions = 3\n","    # Se salta la creación de la última capa de 'rotation_blocks'\n","    skip_final_rotation_layer = True\n","    ansatz = TwoLocal(qubit_op.num_qubits, rotation_blocks, entanglement_blocks, reps=repetitions, \n","                      entanglement=entanglement, skip_final_rotation_layer=skip_final_rotation_layer)\n","    # Añade el estado inicial\n","    ansatz.compose(init_state, front=True, inplace=True)\n","elif ansatz_type == \"UCCSD\":\n","    ansatz = UCCSD(converter,num_particles,num_spin_orbitals,initial_state = init_state)\n","elif ansatz_type == \"PUCCD\":\n","    ansatz = PUCCD(converter,num_particles,num_spin_orbitals,initial_state = init_state)\n","elif ansatz_type == \"SUCCD\":\n","    ansatz = SUCCD(converter,num_particles,num_spin_orbitals,initial_state = init_state)\n","elif ansatz_type == \"Custom\":\n","    # Ejemplo de cómo escribir tu propio circuito\n","    from qiskit.circuit import Parameter, QuantumCircuit, QuantumRegister\n","    # Define el parámetro variacional\n","    theta = Parameter('a')\n","    n = qubit_op.num_qubits\n","    # Crea un circuito cuántico vacío\n","    qc = QuantumCircuit(qubit_op.num_qubits)\n","    qubit_label = 0\n","    # Coloca una compuerta Hadamard\n","    qc.h(qubit_label)\n","    # Colocal una escalera de CNOTs\n","    for i in range(n-1):\n","        qc.cx(i, i+1)\n","    # Separador visual\n","    qc.barrier()\n","    # Rotaciones rz sobre todos los qubits\n","    qc.rz(theta, range(n))\n","    ansatz = qc\n","    ansatz.compose(init_state, front=True, inplace=True)\n","\n","print(ansatz)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"9foWLWdkA84i"},"source":["#### 6. Backend\n","Aquí es donde especificas el simulador o el dispositivo donde quieres que se ejecute tu algoritmo.\n","Para este desafío, nos enfocaremos en el simulador `statevector_simulator`.\n"]},{"cell_type":"code","metadata":{"id":"CLNOvNeEA84j"},"source":["from qiskit import Aer\n","backend = Aer.get_backend('statevector_simulator')"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"2F8rq0arA84j"},"source":["#### 7. Optimizador\n","El optimizador sirve de guía para la evolución de los parámetros del ansatz así que es importante investigar la convergencia de la energía ya que podría definir el número de medidas que tendrán que ser llevadas a cabo por la QPU.\n","Una desición inteligente podría reducir drásticamente el número de evaluaciones necesarias para obtener la energía. "]},{"cell_type":"code","metadata":{"id":"SWnKyNdqA84j"},"source":["from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA, SLSQP\n","\n","optimizer_type = 'COBYLA'\n","\n","# Podrías querer ajustar los parámetros\n","# de cada optimizador, aquí están los valores usados por defecto\n","if optimizer_type == 'COBYLA':\n","    optimizer = COBYLA(maxiter=500)\n","elif optimizer_type == 'L_BFGS_B':\n","    optimizer = L_BFGS_B(maxfun=500)\n","elif optimizer_type == 'SPSA':\n","    optimizer = SPSA(maxiter=500)\n","elif optimizer_type == 'SLSQP':\n","    optimizer = SLSQP(maxiter=500)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Q5LiZ8ihA84k"},"source":["#### 8. Solución exacta\n","Para propósitos educativos, podemos resolver exactamente el problema con una diagonalización exacta de la matriz hamiltoniana para saber hacia donde apuntar con el algoritmo VQE. \n","Por supuesto, las dimesiones de la matriz crecen exponencialmente con el número de orbitales moleculares, puedes intentar hacer esto con una molécula grande para ver que tan lento se vuelve el proceso.\n","Para sistemas muy grandes, te quedarías sin memoria disponible intentando almacenar la función de onda."]},{"cell_type":"code","metadata":{"id":"J1KjXOE_A84k"},"source":["from qiskit_nature.algorithms.ground_state_solvers.minimum_eigensolver_factories import NumPyMinimumEigensolverFactory\n","from qiskit_nature.algorithms.ground_state_solvers import GroundStateEigensolver\n","import numpy as np \n","\n","def exact_diagonalizer(problem, converter):\n","    solver = NumPyMinimumEigensolverFactory()\n","    calc = GroundStateEigensolver(converter, solver)\n","    result = calc.solve(problem)\n","    return result\n","\n","result_exact = exact_diagonalizer(problem, converter)\n","exact_energy = np.real(result_exact.eigenenergies[0])\n","print(\"Energía electrónica exacta\", exact_energy)\n","print(result_exact)\n","\n","# La energía electrónica de referencia para la molécula de H2 es -1.85336 Ha\n","# Verifícalo con el resultado tu VQE."],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"q1d2mQNCA84k"},"source":["#### 9. VQE y los parámetros iniciales para el ansatz\n","Ahora podemos importar la clase VQE y ejecutar el algoritmo."]},{"cell_type":"code","metadata":{"id":"sGfcR4mXA84l"},"source":["from qiskit.algorithms import VQE\n","from IPython.display import display, clear_output\n","\n","# Imprime y guarda los datos en listas\n","def callback(eval_count, parameters, mean, std):  \n","    # Sobrescribe la misma línea al imprimir\n","    display(\"Evaluación: {}, Energía: {}, Std: {}\".format(eval_count, mean, std))\n","    clear_output(wait=True)\n","    counts.append(eval_count)\n","    values.append(mean)\n","    params.append(parameters)\n","    deviation.append(std)\n","\n","counts = []\n","values = []\n","params = []\n","deviation = []\n","\n","# Prepara los parámetros iniciales del ansatz\n","# Escogemos un pequeño paso fijo de desplazamiento \n","# para que todos los participantes comiencen con un punto de partida similar\n","try:\n","    initial_point = [0.01] * len(ansatz.ordered_parameters)\n","except:\n","    initial_point = [0.01] * ansatz.num_parameters\n","\n","algorithm = VQE(ansatz,\n","                optimizer=optimizer,\n","                quantum_instance=backend,\n","                callback=callback,\n","                initial_point=initial_point)\n","\n","result = algorithm.compute_minimum_eigenvalue(qubit_op)\n","\n","print(result)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"fLm89TphA84l"},"source":["#### 9. Puntaje\n","Necesitamos juzgar cuán buena es tu simulación VQE, el ansatz y optimizadores escogidos. \n","Para ello, implementamos la siguiente función simple de puntaje:\n","\n","$$ puntaje = N_{CNOT}$$\n","\n","donde $N_{CNOT}$ es el número de CNOTs.\n","Sin embargo, tienes que alcanzar una precisión química de $\\delta E_{chem} = 0.004$ mHa, que puede ser difícil de alcanzar dependiendo del problema.\n","Tienes que alcanzar la precisión que escogimos con un número mínimo de CNOTs para superar el desafío. ¡Mientras menor sea el puntaje, mejor!\n"]},{"cell_type":"code","metadata":{"id":"bpr3pVqtA84l"},"source":["# Almacena el resultado en un diccionario\n","from qiskit.transpiler import PassManager\n","from qiskit.transpiler.passes import Unroller\n","\n","# ''Unroller'' transpila tu circuito en CNOTs y compuertas U\n","pass_ = Unroller(['u', 'cx'])\n","pm = PassManager(pass_)\n","ansatz_tp = pm.run(ansatz)\n","cnots = ansatz_tp.count_ops()['cx']\n","score = cnots\n","\n","accuracy_threshold = 4.0 # in mHa\n","energy = result.optimal_value\n","\n","if ansatz_type == \"TwoLocal\":\n","    result_dict = {\n","        'optimizer': optimizer.__class__.__name__,\n","        'mapping': converter.mapper.__class__.__name__,\n","        'ansatz': ansatz.__class__.__name__,\n","        'rotation blocks': rotation_blocks,\n","        'entanglement_blocks': entanglement_blocks,\n","        'entanglement': entanglement,\n","        'repetitions': repetitions,\n","        'skip_final_rotation_layer': skip_final_rotation_layer,\n","        'energy (Ha)': energy,\n","        'error (mHa)': (energy-exact_energy)*1000,\n","        'pass': (energy-exact_energy)*1000 <= accuracy_threshold,\n","        '# of parameters': len(result.optimal_point),\n","        'final parameters': result.optimal_point,\n","        '# of evaluations': result.optimizer_evals,\n","        'optimizer time': result.optimizer_time,\n","        '# of qubits': int(qubit_op.num_qubits),\n","        '# of CNOTs': cnots,\n","        'score': score}\n","else:\n","    result_dict = {\n","        'optimizer': optimizer.__class__.__name__,\n","        'mapping': converter.mapper.__class__.__name__,\n","        'ansatz': ansatz.__class__.__name__,\n","        'rotation blocks': None,\n","        'entanglement_blocks': None,\n","        'entanglement': None,\n","        'repetitions': None,\n","        'skip_final_rotation_layer': None,\n","        'energy (Ha)': energy,\n","        'error (mHa)': (energy-exact_energy)*1000,\n","        'pass': (energy-exact_energy)*1000 <= accuracy_threshold,\n","        '# of parameters': len(result.optimal_point),\n","        'final parameters': result.optimal_point,\n","        '# of evaluations': result.optimizer_evals,\n","        'optimizer time': result.optimizer_time,\n","        '# of qubits': int(qubit_op.num_qubits),\n","        '# of CNOTs': cnots,\n","        'score': score}\n","\n","# Gráfica los resultados\n","import matplotlib.pyplot as plt\n","\n","fig, ax = plt.subplots(1, 1)\n","ax.set_xlabel('Iteraciones')\n","ax.set_ylabel('Energía')\n","ax.grid()\n","fig.text(0.7, 0.75, f'Energía: {result.optimal_value:.3f}\\nPuntaje: {score:.0f}')\n","plt.title(f\"{result_dict['optimizer']}-{result_dict['mapping']}\\n{result_dict['ansatz']}\")\n","ax.plot(counts, values)\n","ax.axhline(exact_energy, linestyle='--')\n","fig_title = f\"\\\n","{result_dict['optimizer']}-\\\n","{result_dict['mapping']}-\\\n","{result_dict['ansatz']}-\\\n","Energy({result_dict['energy (Ha)']:.3f})-\\\n","Score({result_dict['score']:.0f})\\\n",".png\"\n","fig.savefig(fig_title, dpi=300)\n","\n","# Display and save the data\n","import pandas as pd\n","import os.path\n","filename = 'results_h2.csv'\n","if os.path.isfile(filename):\n","    result_df = pd.read_csv(filename)\n","    result_df = result_df.append([result_dict])\n","else:\n","    result_df = pd.DataFrame.from_dict([result_dict])\n","result_df.to_csv(filename)\n","result_df[['optimizer','ansatz', '# of qubits', '# of parameters','rotation blocks', 'entanglement_blocks',\n","    'entanglement', 'repetitions', 'error (mHa)', 'pass', 'score']]"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"aViHFVAQA84m"},"source":["<div class=\"alert alert-block alert-danger\">\n","    \n","<b>Tutorial 2 preguntas</b> \n","\n","Experimenta con todos los parámetros y luego:\n","\n","1. ¿Puedes conseguir tu mejor ansatz heurístico (mejor puntaje, modificando los parámetros del ansatz `TwoLocal`) y tu mejor optimizador?\n","2. ¿Puedes conseguir tu mejor ansatz q-UCC (escoge entre los ansatz `UCCSD, PUCCD or SUCCD`) y tu mejor optimizador?\n","3. En la celda donde definimos el ansatz ¿puedes modificar el ansatz `Custom` colocando tu mismo las compuertas para escribir un circuito mejor que tu circuito `TwoLocal`?\n","\n","Para cada pregunta, provee los objetos `ansatz`. \n","Recuerda, tienes que alcanzar la precisión química necesaria$|E_{exact} - E_{VQE}| \\leq 0.004 $ Ha $= 4$ mHa.\n","    \n","</div>\n","\n"]},{"cell_type":"code","metadata":{"id":"c5LN5A_5A84n"},"source":["# ESCRIBE TU CÓDIGO ENTRE ESTAS LÍNEAS - INICIO\n","\n","\n","\n","\n","# ESCRIBE TU CÓDIGO ENTRE ESTAS LÍNEAS - FIN"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"TiRS7IwmA84n"},"source":["## Parte 2: Desafío final - VQE para la molécula de LiH \n","\n","En esta parte, harás una simulación de la molécula de LiH usando la base STO-3G con el driver PySCF.\n","\n","</div>\n","    \n","<div class=\"alert alert-block alert-success\">\n","\n","<b>Objetivo</b> \n","\n","\n","Experimenta con todos los parámetros y luego encuentra el mejor ansatz. ¡Puedes ser tan creativo como quieras!\n","\n","Para cada pregunta, provee los objetos `ansatz` como en la Parte 1. Tu puntaje final estará basado solamente en la Parte 2.\n","    \n","</div>\n","Ten en cuenta que el sistema ahora es más grande. Deduce cuántos qubits necesitarías para este sistema recuperando el número de espín-orbitales.\n","\n","\n","### Reduciendo el tamaño del problema\n","\n","Tal vez querrás reducir el número de qubits de tu simulación:\n","- podrías congelar los electrones internos ya que no contribuyen significativamente en química y considerar solo los electrones de valencia. Esta funcionalidad ya está implementada en Qiskit. Así que inspecciona los diferentes transformadores en `qiskit_nature.transformers` y consigue aquel que implenta la aproximación de congelamiento interno.\n","- puedes usar `ParityMapper` junto con `two_qubit_reduction=True` para eliminar 2 qubits.\n","- puedes reducir el número de qubits si inspeccionas las simetrías de tu hamiltoniano. Busca una manera de utilizar `Z2Symmetries` de Qiskit.\n","\n","###  Ansatz personalizado\n","\n","Tal vez querrás explorar las ideas propuestas en [Grimsley *et al.*,2018](https://arxiv.org/abs/1812.11173v2), [H. L. Tang *et al.*,2019](https://arxiv.org/abs/1911.10205), [Rattew *et al.*,2019](https://arxiv.org/abs/1910.09694), [Tang *et al.*,2019](https://arxiv.org/abs/1911.10205).  Puedes incluso intentar algoritmos de aprendizaje automatizados (*machine learning*) para generar un mejor circuito ansatz.\n","\n","### Montaje y la simulación\n","\n","¡Ejecutemos ahora el circuito del cálculo de Hartree-Fock y el resto te lo dejamos a ti!\n","\n","<div class=\"alert alert-block alert-danger\">\n","\n","<b>Atención</b> \n","\n","A continuación, proveemos el `driver`, el punto de partida `initial_point`, el estado inicial `initial_state` que deberán permanecer como se indica.\n","Eres libre entonces de explorar todo lo demás disponible en Qiskit.\n","Así que comienza con este punto de partida (todos los parámetros ajustados a  0.01):\n","`initial_point = [0.01] * len(ansatz.ordered_parameters)`\n","    o\n","`initial_point = [0.01] * ansatz.num_parameters`\n","\n","y tu estado inicial tiene que ser el estado Hartree-Fock:\n","    \n","`init_state = HartreeFock(num_spin_orbitals, num_particles, converter)`\n","    \n","Para cada pregunta, provee un objeto tipo `ansatz`. Recuerda, tienes que alcanzar la precisión química necesaria$|E_{exact} - E_{VQE}| \\leq 0.004 $ Ha $= 4$ mHa.\n","\n","</div>"]},{"cell_type":"code","metadata":{"id":"KLJaUZ-YA84o"},"source":["from qiskit_nature.drivers import PySCFDriver\n","\n","molecule = 'Li 0.0 0.0 0.0; H 0.0 0.0 1.5474'\n","driver = PySCFDriver(atom=molecule)\n","qmolecule = driver.run()"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"Ypa4nkT1A84o"},"source":["# ESCRIBE TU CÓDIGO ENTRE ESTAS LÍNEAS - INICIO\n","\n","\n","\n","\n","# ESCRIBE TU CÓDIGO ENTRE ESTAS LÍNEAS - FIN"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"BN5VZXtnA84o"},"source":["# Verifica tu respuesta usando el código siguiente\n","from qc_grader import grade_ex5\n","freeze_core = False # cambiar a 'True' si congelaste los electrones internos\n","grade_ex5(ansatz,qubit_op,result,freeze_core)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"oULzT_fkA84p"},"source":["# Envía tu respuesta. Puedes volver a enviar tu respuesta en todo momento.\n","from qc_grader import submit_ex5\n","submit_ex5(ansatz,qubit_op,result,freeze_core)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"cIetkvGzA84p"},"source":["## Respuestas de la parte 1\n","\n","<div class=\"alert alert-block alert-danger\">\n","\n","<b>Preguntas</b> \n","    \n","Revisa los atributos de `qmolecule` y responde las preguntas siguientes.\n","\n","1. Necesitamos saber cuáles son las características básicas de nuestra molécula. ¿Cuál es el número de electrones en tu sistema?\n","2. ¿Cuál es el número de orbitales moleculares? \n","3. ¿Cuál es el número de espín-orbitales?\n","4. ¿Cuántos qubits son necesarios para simular esta molécula con la transformación de Jordan-Wigner?\n","5. ¿Cuál es el valor de la energía de repulsión nuclear?\n","    \n","</div>\n","\n","<div class=\"alert alert-block alert-success\">\n","\n","<b>Respuestas </b> \n","\n","1. `n_el = qmolecule.num_alpha + qmolecule.num_beta`\n","    \n","2. `n_mo = qmolecule.num_molecular_orbitals`\n","    \n","3. `n_so = 2 * qmolecule.num_molecular_orbitals`\n","    \n","4. `n_q = 2* qmolecule.num_molecular_orbitals`\n","    \n","5. `e_nn = qmolecule.nuclear_repulsion_energy`\n","    \n","    \n","</div>"]},{"cell_type":"markdown","metadata":{"id":"i2Fj5L1LA84q"},"source":["## Additional information\n","\n","**Created by:** Igor Sokolov, Junye Huang, Rahul Pratap Singh\n","\n","**Latin American Spanish translation**: Mauricio Gómez Viloria, Manuel Morgado\n","\n","**Version:** 1.0.1"]}]}