content/ex5/ex5-ko.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 연습문제 5 - Variational quantum eigensolver\n",
    "\n",
    "\n",
    "## 역사적 배경\n",
    "\n",
    "지난 10년간 양자 컴퓨터들은 많은 발전을 이루었고, 파인만의 초기 꿈이었던 자연의 법칙들을 양자 방식으로 시뮬레이션하는 컴퓨팅 시스템에 더 가까워졌습니다. 2014년에 제1저자 Alberto Peruzzo가 발표한 논문은 **Variational Quantum Eigensolver (VQE)**을 소개합니다. 이 알고리즘은 분자의 바닥 상태 에너지 (가장 낮은 에너지)를 찾는데에 쓰이는데, 다른 방법들보다 훨씬 더 낮은 깊이의 회로를 사용합니다.[1] 그리고 2017년에 IBM 퀀텀 팀은 이 VQE 알고리즘을 사용해 수소화리튬 분자의 바닥 상태 에너지를 시뮬레이션하였습니다.[2]\n",
    "\n",
    "VQE의 마법은 문제의 일부 프로세싱 작업 부하를 고전 컴퓨터에서 아웃소싱하는 것입니다. 이 알고리즘은 ansatz라고 (최적의 가설) 불리는 매개변수화된 양자 회로로 시작하고, 고전 최적화기(optimzer)를 사용해 이 회로에 대한 최적의 매개변수들을 찾아냅니다. 고전 알고리즘보다 VQE가 더 뛰어난 이유는 양자처리장치(QPU)가 문제의 정확한 파동 함수를 나타내고 저장할 수 있기 때문인데, 이는 고전 컴퓨터에서는 지수적으로 어려운 문제입니다. \n",
    "\n",
    "이 연습문제 5에서는 여러분이 variational quantum eigensolver를 세팅해 분자의 바닥 상태와 에너지를 알아냄으로써 파인만의 꿈을 직접 깨닫게 될 것입니다. 이는 매우 흥미로운 작업인데, 바닥 상태는 다양한 분자의 성질들을 계산하는 데에 쓰이기 때문입니다. 예를 들어, 핵에 대한 힘의 정확한 크기를 계산할 수 있는데, 이는 시간의 흐름에 따라 화학계에 무슨 일이 일어나는지를 알아내기 위해 분자 동력학 시뮬레이션을 실행하는 데에 쓰입니다.[3]\n",
    "\n",
    "\n",
    "### 참고 자료\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",
    "## 소개\n",
    "\n",
    "VQE를 실행할 때, 여러분은 시뮬레이션을 어떻게 구성할 것인지 직접 선택할 수 있을 것입니다. 이중에 특히 ansatz 양자 회로의 구성에 대해 집중해서 선택을 하게 될 것입니다.\n",
    "이는 VQE를 잡음이 많은 양자 컴퓨터에서 실행할 때에 가장 중요한 작업들 중 하나가 바닥 상태를 나타내는 가장 간결한 양자 회로를 찾아 충실도의 손실을 (오차를 초래하는 이유 중 하나입니다) 최소화시키는 것이기 때문입니다.\n",
    "사실상 이 작업은 결국 정확도를 잃지 않으면서 사용하는 이중 큐비트 게이트의 (예: 제어 반전 게이트 (CNOTs)) 수를 최소화시키는 것입니다.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "<b>목표</b> \n",
    "\n",
    "주어진 문제에 대한 바닥 상태를 정확하게 나타내는 가장 짧은 ansatz 회로를 찾아내세요. 창의력을 발휘해 보세요!\n",
    "    \n",
    "\n",
    "<b>계획</b> \n",
    "    \n",
    "먼저 가장 작은 분자에 대해 어떻게 VQE 시뮬레이션을 구성하는지 배우고, 이를 더 큰 분자에 대해 적용해 볼 것입니다.\n",
    "    \n",
    "**1. 튜토리얼 -  H$_2$에 대한 VQE:** VQE에 익숙해지고 상태 벡터(statevector) 시뮬레이션을 실행하며 최적의 ansatz/고전 최적화기 조합을 찾아보세요.\n",
    "\n",
    "**2. 최종 도전 과제 - LiH에 대한 VQE** 오로지 상태 벡터 시뮬레이터만을 사용해 첫 번째 부분과 비슷하게 조사하세요. 키스킷의 큐비트 수 축소 책략을 사용해 더 큰 두 번째 시스템에 대해 최적의 회로를 찾아보세요. 회로를 최적화하고, 상상력을 발휘해 매개변수화된 회로에 대해 가장 알맞은 구성 요소들을 찾아내고, 이들을 활용해서 키스킷에서 제공되는 것들보다 더 나은, 바닥 상태에 대한 가장 간결한 ansatz 회로를 구축해 보세요.  \n",
    "\n",
    "</div>\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "아래는 VQE 시뮬레이션에 관한 이론에 대한 소개입니다. 문제를 풀기 전에 아래의 모든 내용을 이해할 필요는 없습니다. 무서워하지 마세요!\n",
    "\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 이론\n",
    "\n",
    "아래의 이미지는 VQE를 사용한 분자 시뮬레이션이 어떻게 양자 컴퓨터에서 시행되는지를 보여주는 대략적인 작업 흐름입니다.\n",
    "\n",
    "<img src=\"resources/workflow.png\" width=800 height= 1400/>\n",
    "\n",
    "하이브리드 양자-고전 접근법의 핵심 아이디어는 **중앙처리장치 (CPU)**와 **양자처리장치 (QPU)**에 각각 가장 효율적인 부분들을 아웃소싱하는 것입니다. CPU는 에너지를 계산하기 위해 측정되어야 할 요소들을 열거하고 회로의 매개변수들을 최적화시키는 데에 쓰입니다. QPU는 시스템의 양자 상태를 나타내는 양자 회로를 실행하고 에너지를 측정하는 데에 쓰입니다. 더 자세한 내용은 아래에서 볼 수 있습니다:\n",
    "\n",
    "**CPU**는 전자 도약과 상호작용에 관련된 에너지들을 효율적으로 계산할 수 있는데 (하트리-폭 계산을 이용한 일체/이체 적분), 이 에너지들은 총 에너지 연산자, 해밀토니안을 나타냅니다. [하트리-폭 (Hartree-Fock, HF) 방법](https://en.wikipedia.org/wiki/Hartree%E2%80%93Fock_method#:~:text=In%20computational%20physics%20and%20chemistry,system%20in%20a%20stationary%20state.)은 후자를 단일 슬레이터 행렬식으로 나타낼 수 있다고 가정함으로써 대략적인 바닥 상태 파동 함수를 효율적으로 계산합니다 (예: 4개의 스핀 궤도와 큐비트를 가진 STO_3G 기저의 H$_2$ 분자에 대해서는, 전자들이 가장 낮은 에너지 스핀 궤도를 차지하는 $|\\Psi_{HF} \\rangle = |0101 \\rangle$입니다). 나중에 VQE에서 QPU가 하는 일은 빠진 전자 연관성과 관련된 다른 상태들을 (예: $i$가 비트 문자열인 $|\\Psi \\rangle = c_{HF}|\\Psi_{HF} \\rangle + \\sum_i c_i |i\\rangle $ 속의 $\\sum_i c_i |i\\rangle$ 상태들) 나타낼 수 있는 양자 상태를 (상응하는 회로와 그에 대한 매개변수들을) 찾는 일입니다. \n",
    "\n",
    "HF 계산 다음에, 해밀토니안 속의 연산자들은 페르미온에서 큐비트로의 변환을 (아래의 해밀토니안 부문을 참조하세요) 사용해 QPU의 측정들과 매핑됩니다. 시스템의 성질을 더 분석해 큐비트의 수를 줄이거나 ansatz 회로를 단축시킬 수 있습니다.:\n",
    "\n",
    "- Z2 대칭성과 2-큐빗 축소에 대해서는 [Bravyi *et al*, 2017](https://arxiv.org/abs/1701.08213v1)를 참고하세요.\n",
    "- 얽힘 구축에 대해서는 [Eddins *et al.*, 2021](https://arxiv.org/abs/2104.10220v1)를 참고하세요.\n",
    "- 적응 ansatz에 대해서는 [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)을 참고하세요. 양자 회로를 단축시킬 방법을 찾을 때 이 문헌들의 아이디어를 참고할 수 있습니다.\n",
    "\n",
    "**QPU**는 각도 $\\vec\\theta$로 매개변수화된, 각종 단일 큐비트 회전들과 entanglers(예: 이중 큐비트 게이트)를 활용해 바닥 상태 파동 함수를 나타낼 양자 회로를 실행시킵니다 (아래의 Ansatzes 부문을 참조하세요). 양자 우위는 QPU가 효율적으로 정확한 파동 함수를 나타내고 저장할 수 있다는 데에서 오는데, 고전 컴퓨터에서 이를 몇 개 이상의 원자로 이루어진 시스템에 적용할려면 훨씬 까다롭기 때문입니다. 마지막으로, QPU는 선택한 연산자를 (예: 해밀토니안을 나타내는 연산자) 측정합니다.\n",
    "\n",
    "아래에서는 VQE 알고리즘의 각 요소에 대해 더 수학적으로 자세하게 설명할 것입니다. 또한, 이 [VQE에 관한 비디오 에피소드를](https://www.youtube.com/watch?v=Z-A6G0WVI9w) 보면 도움이 될 수도 있습니다.\n",
    "\n",
    "\n",
    "### 해밀토니안 \n",
    "\n",
    "여기에서는 주어진 시스템의 에너지를 얻을 때 측정하기 위해 필요한 연산자들을 어떻게 얻을 수 있는지 설명할 것입니다.\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",
    "여기서\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",
    "$h_{r s}$와 $g_{p q r s}$는 (하트리-포크법을 사용한) 일체/이체 적분이고 $E_{N N}$는 핵척력 에너지입니다. \n",
    "일체 적분은 전자들의 운동 에너지와 핵과의 상호작용을 나타냅니다. \n",
    "이체 적분은 전자들 사이의 상호작용을 나타냅니다.\n",
    "$\\hat{a}_{r}^{\\dagger}, \\hat{a}_{r}$ 연산자들은 스핀 궤도 $r$에서 전자의 생성과 소멸을 나타내며, 양자 컴퓨터에서 측정되기 위해 연산자들과의 매핑이 필요합니다.\n",
    "VQE는 전자 에너지를 최소화시키기 때문에 여러분이 핵척력 에너지 $E_{NN}$을 검색하고 더해줘야 총 에너지를 계산할 수 있다는 것에 유의하세요. \n",
    "    \n",
    "\n",
    "\n",
    "따라서 $ h_{r s}$와 $g_{p q r s}$ 텐서들 속의 모든 0이 아닌 행렬 원소에 대해 상응하는 파울리 string(파울리 연산자들의 텐서곱)들을 다음의 페르미온에서 큐비트 변환에 따라 구축할 수 있습니다. \n",
    "예를 들어, 궤도 $r = 3$에 대한 요르단-위그너 매핑에서는 다음의 파울리 string을 얻을 수 있습니다:\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",
    "여기서 $\\hat \\sigma_x, \\hat \\sigma_y, \\hat \\sigma_z$는 잘 알려진 파울리 연산자들입니다. $\\hat \\sigma_z$ 연산자들의 텐서곱은 페르미온 반교환 관계를 집행하기 위해 사용되었습니다.\n",
    "아래의 그림은 물 분자의 14개의 스핀 궤도들과 14개의 큐비트들 사이의 요르단-위그너 매핑을 보여줍니다:\n",
    "\n",
    "<img src=\"resources/mapping.png\" width=600 height= 1200/>\n",
    "\n",
    "\n",
    "그 다음에는 해밀토니안 속의 일체/이체 들뜸을 (예: $\\hat{a}_{r}^{\\dagger} \\hat{a}_{s}$, $\\hat{a}_{p}^{\\dagger} \\hat{a}_{q}^{\\dagger} \\hat{a}_{r} \\hat{a}_{s}$) 상응하는 파울리 string들과 (예: $\\hat{P}_i$, 위의 그림을 참고하세요) 바꿔주기만 하면 됩니다. 결과로 나온 연산자 세트는 QPU에서 측정될 준비가 되었습니다.\n",
    "추가적인 정보를 위해서는 [Seeley *et al.*, 2012](https://arxiv.org/abs/1208.5986v1)를 참고하세요.\n",
    "\n",
    "### Ansatzes\n",
    "\n",
    "화학 문제를 위해 사용할 수 있는 ansatzes들에는 크게 두 종류가 있습니다. \n",
    "\n",
    "- **q-UCC ansatzes**들은 물리적으로 영감을 받아, 양자 회로에 전자의 들뜸을 대략적으로 매핑합니다. q-UCCSD ansatz는 (키스킷에서는 `UCCSD`) 가능한 모든 단일과 이중 전자 들뜸을 포함하고 있습니다. 이중 q-pUCCD (`PUCCD`)와 단일 q-UCCD0 (`SUCCD`) 짝은 그저 이러한 모든 들뜸의 부분 집합만을 포함하고 있고 (훨씬 짧은 회로를 의미합니다), 해리 프로파일에 대해 좋은 결과를 제공한다고 증명되었습니다. 예를 들어, q-pUCCD는 단일 들뜸을 포함하고 있지 않고, 이중 들뜸은 아래의 그림처럼 짝지어져 있습니다.\n",
    "- **Heuristic ansatzes (`TwoLocal`)**들은 회로 깊이를 줄이려고 발명되었으나, 여전히 바닥 상태를 나타낼 수 있습니다. \n",
    "아래의 그림과 같이, R 게이트들은 매개변수화된 단일 큐비트 회전들을 나타내며 $U_{CNOT}$ 게이트들은 entanglers(이중 큐비트 게이트)들을 나타냅니다. 여기서의 아이디어는 똑같은 블럭을 (독립된 매개변수들과 함께) $D$ 번 반복할 경우 바닥 상태에 이를 수 있다는 것입니다. \n",
    "\n",
    "추가 정보를 위해서는 [Sokolov *et al.* (q-UCC ansatzes)](https://arxiv.org/abs/1911.10864v2)와 [Barkoutsos *et al.* (Heuristic ansatzes)](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",
    "고유 상태 $|\\psi_{min}\\rangle$와 연관된 허미시안 연산자 $\\hat H$와 미지의 최소고유값 $E_{min}$가 주어졌을 때, VQE는 $E_{min}$으로 제한된 추정값 $E_{\\theta}$를 알려줍니다:\n",
    "\n",
    "\\begin{align*}\n",
    "    E_{min} \\le E_{\\theta} \\equiv \\langle \\psi(\\theta) |\\hat H|\\psi(\\theta) \\rangle\n",
    "\\end{align*}  \n",
    "\n",
    "여기서 $|\\psi(\\theta)\\rangle$는 $E_{\\theta}$와 관련된 시험 상태입니다. 어떤 임의의 시작 상태 $|\\psi\\rangle$에 매개변수화된 회로 $U(\\theta)$를 적용하면서, 알고리즘은 $|\\psi_{min}\\rangle$에 대해 추정값 $U(\\theta)|\\psi\\rangle \\equiv |\\psi(\\theta)\\rangle$를 얻을 수 있게 됩니다. 이 추정값은 고전 최적화기에게 매개변수 $\\theta$를 바꾸고, 기대값 $\\langle \\psi(\\theta) |\\hat H|\\psi(\\theta) \\rangle$를 최소화하며 반복적으로 최적화됩니다. \n",
    "\n",
    "VQE의 활용 방법에는 [Sokolov *et al.*, 2021](https://arxiv.org/abs/2008.08144v1)에서 참고할 수 있다싶이 분자 동력학 시뮬레이션, 그리고 [Ollitrault *et al.*, 2019](https://arxiv.org/abs/1910.12890)에서 볼 수 있다싶이 들뜬 상태 계산 등이 있습니다.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    " \n",
    "<b> 추가 정보를 위한 참고 자료</b> \n",
    "\n",
    "이 알고리즘을 실행하는 키스킷-네이쳐 튜토리얼은 [여기서](https://qiskit.org/documentation/nature/tutorials/01_electronic_structure.html) 확인할 수 있습니다.\n",
    "이걸로 충분하지 않다면, [깃허브 레파지토리의 첫번째 페이지](https://github.com/Qiskit/qiskit-nature)나 [테스트 폴더](https://github.com/Qiskit/qiskit-nature/tree/main/test)를 통해 각 요소에 대해 쓰여진 테스트들과 각 기능에 대한 기본 코드들을 확인할 수 있습니다.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 첫 번째 부분: 튜토리얼 - H$_2$ 분자에 대한 VQE \n",
    "\n",
    "\n",
    "\n",
    "이 부분에서는 PySCF 드라이버와 요르단-위그너 매핑을 포함한 STO-3G 기저를 사용해 H$_2$ 분자를 시뮬레이션해 볼 것입니다.\n",
    "더 어려운 문제들을 직접 풀어볼 수 있게 다음 부분들에 대해서는 저희가 안내해드릴 것입니다.\n",
    "    \n",
    "\n",
    "\n",
    "#### 1. 드라이버\n",
    "\n",
    "키스킷에서 제공되는 고전 화학에 대한 인터페이스들을 드라이버라고 부릅니다.\n",
    "예를 들어, `PSI4Driver`, `PyQuanteDriver`, 그리고 `PySCFDriver`가 제공되고 있습니다. \n",
    "\n",
    "아래 칸에서 드라이버를 실행함으로써 (주어진 기저 세트와 분자 구조에 대한 하트리-포크 계산) 우리는 양자 알고리즘을 적용시키기 위해 분자에 대해 필요한 모든 정보들을 얻을 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "<b> 튜토리얼 질문 1</b> \n",
    "    \n",
    "`qmolecule`의 속성에 대해 조사해보고 아래의 질문들에 답하세요.\n",
    "\n",
    "    \n",
    "1. 이 분자에 대한 기본 특성들을 알아야 합니다. 여러분의 시스템 속의 총 전자 수는 얼마인가요?\n",
    "2. 분자 궤도의 수는 얼마인가요?\n",
    "3. 스핀 궤도의 수는 얼마인가요?\n",
    "4. 이 분자를 요르단-위그너 매핑으로 시뮬레이션하기 위해 필요한 큐비트 수는 얼마인가요?\n",
    "5. 핵척력 에너지의 값은 얼마인가요?\n",
    "\n",
    "답은 이 노트북의 끝부분에서 확인할 수 있습니다.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 이 선들 사이에 코드를 적으십시오 - 시작\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# 이 선들 사이에 코드를 적으십시오 - 끝"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. 전자 구조 문제\n",
    "\n",
    "다음으로 페르미온 연산자들을 큐비트들과 매핑시키기 전에 (파울리 strings) 이들의 목록을 생산할 수 있는 `ElectronicStructureProblem`를 생성할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem\n",
    "problem = ElectronicStructureProblem(driver)\n",
    "\n",
    "# 두 번째 양자화된(second-quantized) 연산자들을 생성합니다\n",
    "second_q_ops = problem.second_q_ops()\n",
    "\n",
    "# 해밀토니안\n",
    "main_op = second_q_ops[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. QubitConverter\n",
    "\n",
    "시뮬레이션에서 사용할 매핑을 정의할 수 있게 합니다. 다른 매핑을 시도할 수 있긴 하지만\n",
    "우리는 간단한 연관성을 (큐비트가 분자의 스핀 궤도를 나타내는 걸) 허용하는 `JordanWignerMapper`을 사용할 것입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_nature.mappers.second_quantization import ParityMapper, BravyiKitaevMapper, JordanWignerMapper\n",
    "from qiskit_nature.converters.second_quantization.qubit_converter import QubitConverter\n",
    "\n",
    "# mapper와 qubit converter를 설정합니다\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",
    "# 페르미온 연산자들은 큐비트 연산자들에 매핑됩니다\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. 초기 상태\n",
    "이론 부분에서 설명되었던 것과 같이, 화학에서 좋은 초기 상태는 HF 상태입니다 (예: $|\\Psi_{HF} \\rangle = |0101 \\rangle$). 이는 다음과 같이 설정할 수 있습니다:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Ansatz\n",
    "가장 중요한 선택들 중 하나는 바닥 상태의 근사치를 추정하기 위해 사용할 양자 회로를 고르는 것입니다.\n",
    "아래에는 여러분이 직접 회로를 만들 수 있게 다양한 가능성들을 포함한 키스킷 회로 라이브러리의 예시가 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.circuit.library import TwoLocal\n",
    "from qiskit_nature.circuit.library import UCCSD, PUCCD, SUCCD\n",
    "\n",
    "# ansatz를 선택합니다\n",
    "ansatz_type = \"TwoLocal\"\n",
    "\n",
    "# q-UCC ansatz를 위한 매개 변수\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",
    "# twolocal을 위한 인수들\n",
    "if ansatz_type == \"TwoLocal\":\n",
    "    # 모든 큐비트에 적용될 독립적인 매개 변수들을 가진 단일 큐비트 회전들\n",
    "    rotation_blocks = ['ry', 'rz']\n",
    "    # 얽힘 게이트들\n",
    "    entanglement_blocks = 'cx'\n",
    "    # 큐비트들이 어떻게 얽힐 것인지 설정합니다\n",
    "    entanglement = 'full'\n",
    "    # 독립적인 매개 변수들을 가진 rotation_blocks들과 entanglement_blocks들을 얼마나 반복할지 설정합니다\n",
    "    repetitions = 3\n",
    "    # 최종 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",
    "    # 초기 상태를 추가합니다\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",
    "    # 직접 회로를 만드는 예시입니다\n",
    "    from qiskit.circuit import Parameter, QuantumCircuit, QuantumRegister\n",
    "    # 변분 매개 변수를 정의합니다\n",
    "    theta = Parameter('a')\n",
    "    n = qubit_op.num_qubits\n",
    "    # 빈 양자 회로를 생성합니다\n",
    "    qc = QuantumCircuit(qubit_op.num_qubits)\n",
    "    qubit_label = 0\n",
    "    # 하다마드 게이트를 추가합니다\n",
    "    qc.h(qubit_label)\n",
    "    # CNOT 사다리를 추가합니다\n",
    "    for i in range(n-1):\n",
    "        qc.cx(i, i+1)\n",
    "    # 시각적 분리기\n",
    "    qc.barrier()\n",
    "    # 모든 큐비트에 대한 rz 회전들\n",
    "    qc.rz(theta, range(n))\n",
    "    ansatz = qc\n",
    "    ansatz.compose(init_state, front=True, inplace=True)\n",
    "\n",
    "print(ansatz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6. 백엔드\n",
    "여기에서는 알고리즘을 실행할 시뮬레이터나 장치를 지정합니다.\n",
    "이번 도전 과제에서는 `statevector_simulator`에 집중할 것입니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import Aer\n",
    "backend = Aer.get_backend('statevector_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7. 최적화기 (optimzer)\n",
    "\n",
    "최적화기는 ansatz의 매개 변수들의 진화를 안내하기 때문에 QPU에서 실행될 측정의 수를 정의할 에너지의 수렴을 조사하는 것이 매우 중요합니다.\n",
    "영리한 선택은 필요한 에너지 측정의 수를 급격하게 줄일 수도 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA, SLSQP\n",
    "\n",
    "optimizer_type = 'COBYLA'\n",
    "\n",
    "# 매개 변수들을 보정해야 할 수도 있습니다 \n",
    "# 여기서는 각 최적화기에 대해 기본값들이 사용되었습니다\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8. 정확한 eigensolver\n",
    "학습의 목적에 따라, 우리는 해밀토니안 행렬의 정확한 대각선화를 사용해 문제를 정확하게 풀 수 있기 때문에 VQE로 어디를 목표로 삼아야 할지 미리 알 수 있습니다.\n",
    "당연히, 이 행렬의 크기는 분자 궤도의 수에 따라 지수적으로 커지므로 이를 더 큰 분자에 대해 실행해보고 얼마나 느려지는지 볼 수 있습니다. \n",
    "매우 큰 시스템들에 대해서는 그들의 파동 함수들을 저장하려다 메모리를 다 사용해버릴 것입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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(\"Exact electronic energy\", exact_energy)\n",
    "print(result_exact)\n",
    "\n",
    "# H2에 대한 목표 전자 에너지는 -1.85336 Ha입니다\n",
    "# 여러분의 VQE 결과와 확인해보세요."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9. VQE와 ansatz의 초기 매개 변수들\n",
    "이제 VQE 클래스를 가져오고 알고리즘을 실행해 볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.algorithms import VQE\n",
    "from IPython.display import display, clear_output\n",
    "\n",
    "# 데이터를 프린트하고 리스트에 저장합니다\n",
    "def callback(eval_count, parameters, mean, std):  \n",
    "    # Overwrites the same line when printing\n",
    "    display(\"Evaluation: {}, Energy: {}, 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",
    "# ansatz의 초기 매개 변수들을 설정합니다\n",
    "# 모든 참가자들이 비슷한 시작점에서 시작할 수 있게\n",
    "# 고정된 작은 이동 거리를 선택합니다 \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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9. 점수 계산 함수 \n",
    "여러분의 VQE 시뮬레이션들과 ansatz/최적화기의 선택이 얼마나 좋은지 심사하기 위해\n",
    "다음과 같은 간단한 점수 계산 함수를 구축하였습니다:\n",
    "\n",
    "$$ score = N_{CNOT}$$\n",
    "\n",
    "여기서 $N_{CNOT}$은 CNOTs의 수입니다. \n",
    "하지만 여러분은 $\\delta E_{chem} = 0.004$ Ha $= 4$ mHa의 화학적 정확도를 이루어야 합니다. 이는 문제에 따라 이루기 어려울 수도 있습니다. \n",
    "여러분이 이 도전 과제에서 승리하기 위해서는 최소의 CNOTs들을 가지고 설정된 정확도 이상을 보여주어야 합니다. \n",
    "점수가 더 낮을수록 더 좋습니다!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 딕셔너리에 결과들을 저장합니다\n",
    "from qiskit.transpiler import PassManager\n",
    "from qiskit.transpiler.passes import Unroller\n",
    "\n",
    "# Unroller가 여러분의 회로를 CNOTs들과 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 # 단위는 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",
    "# 결과를 그래프로 그립니다\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.set_xlabel('Iterations')\n",
    "ax.set_ylabel('Energy')\n",
    "ax.grid()\n",
    "fig.text(0.7, 0.75, f'Energy: {result.optimal_value:.3f}\\nScore: {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",
    "# 데이터를 보여주고 저장합니다\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']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "<b>튜토리얼 질문 2</b> \n",
    "\n",
    "모든 매개 변수들과 실험해보고:\n",
    "\n",
    "1. 가장 나은 (가장 높은 점수를 내는) heuristic ansatz와 (`TwoLocal` ansatz의 매개 변수들을 수정해보세요) 최적화기를 찾을 수 있나요?\n",
    "2. 가장 나은 q-UCC ansatz와 (`UCCSD, PUCCD 아니면 SUCCD` ansatzes들 사이에서 선택하세요) 최적화기를 찾을 수 있나요?\n",
    "3. ansatz를 정의하는 칸에서, \n",
    "   게이트들을 직접 추가해 `Custom` ansatz를 수정하고 여러분의 `TwoLocal` 회로보다 더 나은 회로를 만들 수 있나요? \n",
    "\n",
    "각 질문의 답을 찾으면 `ansatz` 객체에 저장하세요.\n",
    "$|E_{exact} - E_{VQE}| \\leq 0.004 $ Ha $= 4$ mHa의 화학적 정확도를 이루어야 한다는 걸 기억하세요.\n",
    "    \n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 이 선들 사이에 코드를 적으십시오 - 시작\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# 이 선들 사이에 코드를 적으십시오 - 끝"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 두 번째 부분: 최종 도전 과제 - LiH 분자에 대한 VQE \n",
    "\n",
    "\n",
    "이 부분에서는 PySCF 드라이버를 가진 STO-3G 기저를 사용해 LiH 분자를 시뮬레이션할 것입니다.\n",
    "\n",
    "</div>\n",
    "    \n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "<b>목표</b> \n",
    "\n",
    "모든 매개 변수들과 실험해보고 최적의 ansatz를 찾아보세요. 창의력을 발휘해 보세요!\n",
    "\n",
    "각 질문들에 대해 첫 번째 부분에서와 같이 `ansatz` 객체를 저장하세요. 최종 점수는 두 번째 부분에서만 매길 것입니다.\n",
    "    \n",
    "</div>\n",
    "\n",
    "시스템이 이제 커진 것에 유의하세요. 스핀 궤도의 수를 얻어 이 시스템에서는 얼마나 많은 큐비트를 써야 하는지를 계산하세요. \n",
    "\n",
    "### 문제의 크기 감소시키기\n",
    "\n",
    "시뮬레이션에 사용할 큐비트의 수를 줄일 수도 있습니다:\n",
    "- 화학에 크게 기여하지 않는 핵심부 전자를 freeze하고 원자가 전자만 계산에 넣을 수도 있습니다. 키스킷은 이 기능을 이미 포함하고 있습니다. `qiskit_nature.transformers`에서 여러 transformers들을 살펴보고 그중에서 freeze core approximation을 수행하는 것을 찾아보세요.\n",
    "- `two_qubit_reduction=True` 옵션을 가진 `ParityMapper`를 사용해 두 개의 큐비트를 없앨 수도 있습니다.\n",
    "- 여러분의 해밀토니안의 대칭성을 살펴봄으로써 사용하는 큐비트의 수를 줄일 수도 있습니다. 키스킷에서 `Z2Symmetries`를 사용할 방법을 찾아보세요.\n",
    "\n",
    "### 커스텀 ansatz \n",
    "\n",
    "[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)에서 나온 아이디어들을 탐구해보세요. \n",
    "최적의 ansatz 회로들을 생성하기 위해 머신러닝 알고리즘들을 시도해 볼 수도 있습니다.\n",
    "\n",
    "### 시뮬레이션 설정\n",
    "\n",
    "이제 하트리-포크 계산을 실행해보고 나머지는 여러분에게 달렸습니다!\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "<b>주의</b> \n",
    "\n",
    "아래에 주어진 `driver`, `initial_point`, 그리고 `initial_state`는 수정하지 마세요.\n",
    "그 외에는 키스킷에서 제공되는 다른 모든 것들을 사용해 탐구해 볼 수 있습니다.\n",
    "따라서 여러분은 다음의 시작점(모든 매개 변수들이 0.01로 설정되어있습니다)에서 시작해야 합니다:\n",
    "    \n",
    "`initial_point = [0.01] * len(ansatz.ordered_parameters)`\n",
    "    아니면\n",
    "`initial_point = [0.01] * ansatz.num_parameters`\n",
    "\n",
    "그리고 시작 상태는 하트리-포크 상태여야 합니다:\n",
    "    \n",
    "`init_state = HartreeFock(num_spin_orbitals, num_particles, converter)`\n",
    "    \n",
    "각 질문들에 대해 `ansatz` 객체를 저장하세요.\n",
    "$|E_{exact} - E_{VQE}| \\leq 0.004 $ Ha $= 4$ mHa의 화학적 정확도를 이루어야 한다는 것을 기억하세요.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 이 선들 사이에 코드를 적으십시오 - 시작\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# 이 선들 사이에 코드를 적으십시오 - 끝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 다음의 코드를 사용해 답을 확인하세요\n",
    "from qc_grader import grade_ex5\n",
    "freeze_core = False # 핵심부 전자들을 freeze하였다면 True로 바꾸세요\n",
    "grade_ex5(ansatz,qubit_op,result,freeze_core)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 답을 제출하세요. 언제든지 다시 제출할 수 있습니다.\n",
    "from qc_grader import submit_ex5\n",
    "submit_ex5(ansatz,qubit_op,result,freeze_core)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 첫 번째 부분의 답안\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "<b>질문</b> \n",
    "    \n",
    "`qmolecule`의 속성에 대해 조사해보고 아래의 질문들에 답하세요.\n",
    "\n",
    "    \n",
    "1. 이 분자에 대한 기본 특성들을 알아야 합니다. 여러분의 시스템 속의 총 전자 수는 얼마인가요?\n",
    "2. 분자 궤도의 수는 얼마인가요?\n",
    "3. 스핀 궤도의 수는 얼마인가요?\n",
    "4. 이 분자를 요르단-위그너 매핑으로 시뮬레이션하기 위해 필요한 큐비트 수는 얼마인가요?\n",
    "5. 핵척력 에너지의 값은 얼마인가요?\n",
    "    \n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "<b>답안</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": {},
   "source": [
    "## 추가 정보\n",
    "\n",
    "**출제자:** Igor Sokolov, Junye Huang, Rahul Pratap Singh\n",
    "\n",
    "**번역:** Hyun Jin Kim\n",
    "\n",
    "**버젼:** 1.0.1"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}