content/ex4/ex4-ko.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 연습문제 4 - 트랜스몬 큐비트 (Transmon qubit)\n",
    "\n",
    "## 역사적 배경\n",
    "\n",
    "양자 컴퓨터에서 큐비트는 양자 정보의 기본 단위입니다. 기본적으로 2 레벨 양자역학 시스템(two-level quantum mechanical system)이며 자연계인 전자스핀 (스핀 큐비트), 원자 레벨의 이온(트랩 이온 큐비트)나 인공 시스템인 초전도 회로 (초전도 큐비트)를 포함한 많은 물리계로 구현될 수 있습니다.\n",
    "\n",
    "원조 초전도 큐비트는 1999년 출신된 쿠퍼 페어 박스(Cooper Pair Box)로[1], 이것은 잘 정의된 수의 쿠퍼 페어 (초전도체의 구속된 전자)가 조셉슨 접함(Josephson junction)에 의해 약하게 납과 결합한 초전도체 섬을 차지했습니다. 쿠퍼 페어 박스 큐비트에서 $|0\\rangle$ 상태 (쿠퍼 페어가 없음)와 $|1\\rangle$ 상태 (단일 쿠퍼 페어) 사이의 에너지 차는 시스템 내부 또는 주변의 이탈 하거나 적용된 정전하들(electrostatic charges)에게 크게 의존합니다. 전하 노이즈에 대해 이러한 민감성은 큐비트의 위상 물림(dephasing)으로 이어집니다. 쿠퍼 페어 박스 큐비트에 대해 큐비트 지연 시간 ($T_2$) 은 일반적으로 ~ 1$\\mu s$로 제한합니다.\n",
    "\n",
    "2007년에 처음 제안된 트랜스몬 큐비트의 주요 발견[2]은 전압에 대한 에너지 의존성(dispersion, 분산이라고 알려졌음)이 주기적이라는 것입니다. shunting capacitor을 도입함으로써, 조셉슨(Josephson) 에너지와 전하 에너지 $E_J/E_c$ 사이의 비율이 50 가까이 까지 매우 커져서, 평평한 전하 분산을 유도합니다. 쿠퍼 페어 박스는 전하 노이즈에 매우 민감하지만 (즉, Fig. 1a의 x축 위치의 불확실성), 트랜스몬 큐비트에서는 크게 억제됩니다 (Fig. 1d). 트랜스몬 큐비트에 대한 큐비트 지연 시간 ($T_2$)은 크게 개선됩니다. IBM Quantum system에서 $T_2$는 일반적으로 ~ 100 $\\mu s$ 입니다. 예를 들어 [`ibmq_santiago`](https://quantum-computing.ibm.com/services?skip=0&systems=all&system=ibmq_santiago)를 참조하십시오.\n",
    "\n",
    "<figure>\n",
    "    <img src=\"resources/transmon-charge-dispersion.png\" alt=\"Transmon charge dispersion\" style=\"width:50%\">\n",
    "    <center><figcaption><b>Fig. 1</b> Charge dispersion of qubit for different ratios $E_J/E_c$. (from Ref [2])</figcaption></center>\n",
    "</figure>\n",
    "\n",
    "이 연습에서는 실제 IBM Quantum 시스템을 사용하여 분광법(spectroscopy)을 수행하여 트랜스몬 큐비트의 특성 에너지를 조사할 것입니다. 조셉슨 에너지와 전하 에너지 $E_J/E_c$ 사이의 비율은 이전 버전인 쿠퍼 페어 박스 큐비트의 전하 노이즈 문제를 해결하는 열쇠입니다.\n",
    "\n",
    "### 참고자료\n",
    "\n",
    "1. Nakamura, Yasunobu, Yu A. Pashkin, and Jaw Shen Tsai. \"Coherent control of macroscopic quantum states in a single-Cooper-pair box.\" Nature 398.6730 (1999): 786-788.\n",
    "2. Koch, Jens, et al. \"Charge-insensitive qubit design derived from the Cooper pair box.\" Physical Review A 76.4 (2007): 042319.\n",
    "3. Krantz, Philip, et al. \"A quantum engineer's guide to superconducting qubits.\" Applied Physics Reviews 6.2 (2019): 021318."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 트랜스몬 큐비트의 에너지 레벨과 특성\n",
    "\n",
    "양자 조화 진동자(quantum harmonic oscillator) QHO의 해밀토니안은 선형 LC 회로의 해밀토니안을 양자화함으로써 얻을 수 있습니다. 에너지 레벨은 균일한 간격을 유지하고 있습니다 (Fig. 2c). 비선형 회로 요소를 도입함으로써 트랜스몬 큐비트의 조셉슨 접합 에너지 레벨이 변경됩니다 (Fig. 2d). 에너지 레벨이 더이상 동일한 간격으로 배치되어있지 않습니다. 높은 에너지 레벨 간격은 낮은 에너지 레벨 간격보다 작습니다. 비조화성 $\\delta$은 $|1\\rangle \\rightarrow |2\\rangle$와 $|0\\rangle \\rightarrow |1\\rangle$ 전환: $\\delta = \\hbar \\omega_{12} - \\hbar \\omega_{01}$ 또는 단순 $\\omega_{12} - \\omega_{01}$ 사이의 에너지 차로 정의됩니다. (이 실습의 남은 부분에서는  $\\hbar \\equiv 1$로 고정합니다). 마이크로파 주파수를 $\\omega_{01}$로 조정함으로써 우리는 다단계 (mult-level) 트랜스몬을 2단계 시스템, 큐비트로 효과적으로 처리할 수 있습니다.\n",
    "\n",
    "<figure>\n",
    "    <img src=\"resources/transmon-energy-levels.png\" alt=\"Transmon energy levels\" style=\"width:50%\">\n",
    "    <center><figcaption><b>Fig. 2</b> Energy potential for a quantum harmonic oscillator and a trasmon qubit. (from Ref [3])</figcaption></center>\n",
    "</figure>\n",
    "\n",
    "초전도체에서 전자는 $2e$의 유효 전하를 가진 쿠퍼 페어를 형성하며, 여기서 $e$는 단일 전자의 전하입니다.전하 에너지 $E_c$는 큐비트에 단일 쿠퍼 페어를 추가하는 에너지 비용이며 초전도 회로의 정전 용량과 관련이 있습니다. 조셉슨 에너지 $E_J$는 조셉슨 접함을 터널링 (tunneling) 하는 쿠퍼 페어의 에너지입니다. 트랜스몬 큐비트에서는 유도 에너지가 조셉슨 접함에 의해 크게 결정되지만, 다른 초전도 큐비트 스타일에서는 그렇지 않습니다 (초전도 큐비트의 설계와 분석에 대한 정보를 위해, [Qiskit Metal](https://qiskit.org/metal/)이 최근에 출시되었습니다!).\n",
    "\n",
    "쿠퍼 페어 박스 해밀토니언에서 Duffing Oscillator 해밀토니언을 도출함으로써, 이러한 에너지는 아래와 같이 적절한 트랜스몬 주파수와 관련될 수 있습니다.\n",
    "\n",
    "$$\n",
    "f_{01} = \\sqrt{8 E_c E_J} - E_c \\qquad E_c = -\\delta = f_{01} - f_{12},\n",
    "$$\n",
    "\n",
    "마이크로파에서 더 일반적으로 사용되는 기호이기 때문에, $f$를 사용하여 나머지 노트북의 주파수에 대한 기호로 $\\omega$를 대체할 것입니다. 비조화성 $\\delta$는 전적으로 전하 에너지 $E_c$에 의해 제공됩니다. 물리적으로 이는 접점에 대해 대형 *shunting* (병렬) 정전 용량으로 통합됩니다. 이러한 통합은 전하 노이즈에 대한 민감성을 억제하면서 트랜스몬 레벨을 잘 분리할 수 있게 합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 키스킷 펄스(Qiskit Pulse) 개요\n",
    "\n",
    "지금까지는 추상적인 양자 회로 수준에서 큐비트를 사용하고 있습니다. 물리적으로 회로의 양자 게이트는 마이크로파 펄스로 구현됩니다. 키스킷 펄스는 IBM Quantum System으로 전송되는 마이크로파 펄스를 조작하기 위해 펄스 레벨 접근권을 제공합니다.\n",
    "\n",
    "간략한 개요로 키스킷 펄스 스케줄 (실험)은 채널(예: 드라이브 채널)에서 작동하는 지시(예: 재생)으로 구성되어 있습니다. 다음은 사용 가능한 지시 및 채널들을 요약한 표입니다.\n",
    "\n",
    "![image](resources/pulse-instr.png)\n",
    "\n",
    "자세한 내용은 이 표에 실제 양자 하드웨어와 채널의 상호 작용이 요약되어 있습니다.\n",
    "\n",
    "![image](resources/pulse-user-device-layers.png)\n",
    "\n",
    "키스킷 펄스에 대한 자세한 내용은 [Qiskit documentation](https://qiskit.org/documentation/apidoc/pulse.html)에서 확인하실 수 있습니다. 그러나 우리는 펄스에서 가이드 프로그래밍으로부터 시작하는 것이 더 유익하다는 것을 알게 되었습니다. 아래에서는 펄스 생성법, 스케쥴 및 실제 양자 시스템에서 실험 실행 방법에 대해 알아볼 것입니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 시작해 봅시다!\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**목표**\n",
    "    \n",
    "$|1\\rangle \\rightarrow |2\\rangle$ 전이 주파수 (transition frequency) $f_{12}$를 찾습니다.\n",
    "    \n",
    "**계획**\n",
    "    \n",
    "1. **(튜토리얼) $|0\\rangle \\rightarrow |1\\rangle$ 전이 주파수 $f_{01}$**를 분광학 (sweeping frequency)을 이용해 찾습니다.\n",
    "1. **(튜토리얼) X-180 펄스 진폭 보정**을 라비 진동 (sweeping amplitude)을 이용해 진행합니다. \n",
    "1. **(문제) $|1\\rangle \\rightarrow |2\\rangle$ 전이 주파수 $f_{12}$**를 보정된 X-180 펄스와 분광학 (sweeping frequency)를 이용해 찾습니다.\n",
    "    \n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**이 노트북에 있는 한 개의 셀만 수정하시게 될 겁니다.** 잘 맞으려면 맞춤 매개 변수(fitting parameters)을 또한 수정해야 할 수도 있습니다. 하지만 그 외의 다른 셀에서는 수정될 필요가 없습니다. 그러나 `shift+Enter`을 각 코드 블록마다 눌러서 셀들을 실행시켜줘야 합니다.\n",
    "    \n",
    "</div>\n",
    "\n",
    "키스킷 펄스의 중요한 측면에 초점을 맞추고 정리하기 위해 다음 셀은 `helper`모듈에 있는 메소드(method)를 사용하여 만들었습니다. 자세한 내용은 키스킷 텍스트북의 [Investigating Quantum Hardware Using Microwave Pulses](https://qiskit.org/textbook/ch-quantum-hardware/index-pulses.html)와 [Qiskit Global Summer School](https://qiskit.org/learn/intro-qc-qh/)의 렉쳐 16-21, 랩 6-7을 참조하세요.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 로컬 폴더에서 helper 모듈 가져오기\n",
    "import sys\n",
    "import os\n",
    "sys.path.append(os.getcwd()) \n",
    "from resources import helper\n",
    "\n",
    "# 수치와 구성 도구\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 국제 단위 변환 불러오기\n",
    "from resources.helper import GHz, MHz, kHz, us, ns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    " \n",
    "**특별 벡엔드**\n",
    "\n",
    "이번 챌린지를 위해 새로운 `ibmq_jakarta` 양자 시스템이 예약되었습니다. 참가자들은 특별 [Provider](https://quantum-computing.ibm.com/composer/docs/iqx/manage/provider/#providers)을 통해 챌린지 기간 (2021년 5월 20일 ~ 26일) 동안 시스템에 독점적으로 접근할 수 있습니다. 챌린지를 위해 특별 Provider에 배정되려면 **5가지 연습 중 하나 이상을 완료**해야 합니다. 그러면 IBM Quantum 계정과 연결된 이메일 주소에서 `IBM Quantum의 새로운 프로젝트에 추가 되었습니다 (You have been added to a new project in IBM Quantum)`라는 제목의 이메일이 수신됩니다. 모든 것이 제대로 작동한다면, [your account details page](https://quantum-computing.ibm.com/account)에서 특별 Provider의 정보를 볼 수 있을 것입니다.\n",
    "    \n",
    "IBM Quantum 계정을 IBMid와 연결해야 합니다. 그렇지 않으면 `인증된 로그인이 필요함 (Login with some authorized required)`라는 오류가 발생합니다. IBM Quantum 계정과 연결된 동일한 이메일 주소를 사용하여 [register a new IBMid](https://auth.quantum-computing.ibm.com/auth/idaas)를 등록하고 [IBM Quantum](https://quantum-computing.ibm.com)에 다시 로그인해야 합니다.\n",
    "\n",
    "**참고: 다른 연습이 완료된 후 Provider에 배정되는데 최대 12시간이 소요될 수 있습니다.** 만약 문제가 발생한다면 [#iqc2021](https://qiskit.slack.com/archives/C021UTFN9GE) 채널을 통해 연락해주세요. 아직 가입하지 않았다면 Qiskit Slack workspace [여기](https://ibm.co/joinqiskitslack)에 가입하세요.\n",
    "    \n",
    "    \n",
    "</div>\n",
    "\n",
    "아래에 있는 셀을 실행하여 특별 Provider에 배정되었는지 확인합니다. 만약 특별 Provider에 추가되었다면 `1`에서 `10`까지의 `n`과 `1`에서 `1000`까지의 `m`인 `<AccountProvider for IBMQ(hub='iqc2021-n', group='challenge-m', project='ex4')>`처럼 생긴 Provider 정보를 출력에서 볼 수 있습니다. 이 정보를 통해 `ibmq_jakarta` 챌린지를 위해 양자 시스템에 배정되어 접근할 수 있습니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 표준 키스킷 라이브러리 가져오기\n",
    "from qiskit import IBMQ\n",
    "from qiskit.tools.jupyter import *\n",
    "\n",
    "# IBM Quantum 계정 로드\n",
    "IBMQ.load_account()\n",
    "IBMQ.providers() # see a list of providers you have access to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 위의 출력 정보로 부터 배정된 특별 공급자 가져오기\n",
    "hub_name = 'YOUR_HUB_NAME' # e.g. 'iqc2021-1'\n",
    "group_name = 'YOUR_GROUP_NAME' # e.g. 'challenge-1'\n",
    "project_name = 'ex4' # Your project name should be 'ex4'\n",
    "provider = IBMQ.get_provider(hub=hub_name, group=group_name, project=project_name)\n",
    "\n",
    "# 공급자로 부터 `ibm_jakarta` 백엔드 가져오기\n",
    "Get `ibmq_jakarta` backend from the provider\n",
    "backend_name = 'ibmq_jakarta'\n",
    "backend = provider.get_backend(backend_name)\n",
    "backend # `ibmq_jakarta` 양자 시스템의 세부 정보 보기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 채널 예시와 측정 스케줄 검색\n",
    "\n",
    "드라이브 스케줄은 일정마다 다르지만 동일한 측정 스케줄을 사용합니다. 어떠한 백앤드에서 별도로 보정하는 대신 기본 측정 펄스를 요청할 수 있습니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import pulse\n",
    "from qiskit.pulse import Play, Schedule, DriveChannel\n",
    "\n",
    "# 이 노트북에서는 큐비트 0을 사용합니다\n",
    "qubit = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그런 다음, 백엔드 배열과 샘플링 시간 $dt$을 저장합니다. 명확한 구성(plotting)을 위해 `AcquireChannel`은 제외할 것입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend_config = backend.configuration()\n",
    "exc_chans = helper.get_exc_chans(globals())\n",
    "dt = backend_config.dt\n",
    "print(f\"Sampling time: {dt*1e9} ns\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`instruction_schedule_map`은 백엔드에서 사용되는 기본 보정된 펄스의 매개 변수를 제공합니다. 특히, 우리는 \"native gate set\"가 [`QuantumCircuit`](https://qiskit.org/documentation/apidoc/circuit.html#gates-and-instructions)에서 수행할 수 있는 작업의 부분집합으로 구성되며, `QuantumCircuit`가 키스킷에 의해 전송되는 게이트 세트임을 알 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend_defaults = backend.defaults()\n",
    "center_frequency = backend_defaults.qubit_freq_est\n",
    "inst_sched_map = backend_defaults.instruction_schedule_map \n",
    "inst_sched_map.instructions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "명령들은 백엔드의 native gate set, 즉 단일 큐비트 게이트 $X$의 제곱근 `sx`와 $Z$ 축에 대한 매개 변수화된 회전, `rz(θ)` 및 2 큐비트 controlled-NOT `cx`으로 구성되어 있습니다. 여기에는 여러 개의 다른 게이트가 나열되어 있으며, 특히 오일러 각에 근거하고 곧 더이상 사용되지 않을 [\"U-gates\"](https://qiskit.org/textbook/ch-states/single-qubit-gates.html#generalU3)가 완전성을 위해 아래에 요약되었습니다.\n",
    "\n",
    "Basis Gate | Operation\n",
    " --- | ---\n",
    " `u1(λ)` | `rz(λ)`\n",
    " `u2(φ,λ)` | `rz(φ+π/2) sx rz(λ-π/2)`\n",
    " `u3(θ,φ,λ)` | `rz(φ+π) sx rz(θ+π) sx rz(λ)`\n",
    " `id` | identity\n",
    " `x` | $X$ for echoes in dynamical decoupling\n",
    " `measure` | measurement\n",
    "\n",
    "한 가지 주의할 점은 각 `sx`는 하나의 물리적 펄스로 구성되며 `rz`는 [frame changes](https://arxiv.org/abs/1612.00858)에 소프트웨어에서 구현된다는 점입니다. `instruction_schedule_map`에서 처음부터 구축하는 대신 기본 측정 펄스를 검색할 수 있습니다. 이는 보정된 펄스들로부터 유용한 시작점으로 사용할 수 있고 그 이상도 조작할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 백엔드로부터 보정된 측정 펄스 검색\n",
    "meas = inst_sched_map.get('measure', qubits=[qubit])\n",
    "meas.exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## 1단계 (튜토리얼): $|0\\rangle \\rightarrow |1\\rangle$ 전이 찾기\n",
    "\n",
    "이 부분의 코드는 수정할 필요가 없습니다. 모든 셀을 살펴보고 단계들을 확실히 이해하세요. `spec01_scheds`가 어떻게 구축되는지 주의 깊게 살펴봐야 합니다. 마지막 문제에서 유사한 펄스 스케줄을 작성해야 합니다. 펄스 스케줄을 작성하는 방법에 대한 자세한 내용은 [이 튜토리얼](https://qiskit.org/documentation/tutorials/circuits_advanced/06_building_pulse_schedules.html)에서 참조하실 수 있습니다.\n",
    "    \n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'inst_sched_map' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-51c27ef46174>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# 01 및 12 spec에 대해 동일한 spec 펄스\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mdrive_amp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.25\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mdrive_duration\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minst_sched_map\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'x'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqubits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mqubit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mduration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# 보정된 백엔드 펄스는 고급 DRAG 펄스를 사용하여 |2> 상태로의 누출을 줄입니다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'inst_sched_map' is not defined"
     ]
    }
   ],
   "source": [
    "from qiskit.pulse import DriveChannel, Gaussian\n",
    "\n",
    "# 01 및 12 spec에 대해 동일한 spec 펄스\n",
    "drive_amp = 0.25\n",
    "drive_duration = inst_sched_map.get('x', qubits=[qubit]).duration\n",
    "\n",
    "# 보정된 백엔드 펄스는 고급 DRAG 펄스를 사용하여 |2> 상태로의 누출을 줄입니다.\n",
    "# 여기서는 간단한 가우시안 펄스를 사용됩니다\n",
    "\n",
    "drive_sigma = drive_duration // 4 # DRAG 펄스는 일반적으로 4*sigma 길이입니다. \n",
    "spec_pulse = Gaussian(duration=drive_duration, amp=drive_amp, \n",
    "                        sigma=drive_sigma, name=f\"Spec drive amplitude = {drive_amp}\")\n",
    "\n",
    "# 실험을 위한 주파수의 np 배열 구축\n",
    "spec_freqs_GHz = helper.get_spec01_freqs(center_frequency, qubit)\n",
    "\n",
    "# 기본 스케줄 만들기\n",
    "# 드라이브 채널에 작용하는 드라이브 펄스로 부터 시작합니다.\n",
    "spec01_scheds = []\n",
    "for freq in spec_freqs_GHz:\n",
    "    with pulse.build(name=\"Spec Pulse at %.3f GHz\" % freq) as spec01_sched:\n",
    "        with pulse.align_sequential():\n",
    "            # 마지막에서 문제를 풀기 위해서는 이부분에 주의해야 합니다.\n",
    "            pulse.set_frequency(freq*GHz, DriveChannel(qubit))\n",
    "            pulse.play(spec_pulse, DriveChannel(qubit))\n",
    "            pulse.call(meas)\n",
    "            \n",
    "    spec01_scheds.append(spec01_sched)\n",
    "\n",
    "# spec01 스케줄 그리기\n",
    "spec01_scheds[-1].exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "# 실제 백엔드에서 작업 실행\n",
    "spec01_job = backend.run(spec01_scheds, job_name=\"Spec 01\", **helper.job_params) \n",
    "\n",
    "print(spec01_job.job_id())\n",
    "job_monitor(spec01_job)\n",
    "\n",
    "# 대기열 시간이 너무 긴 경우 작업 id를 저장할 수 있습니다.\n",
    "# 작업이 완료되면 작업을 얻을 수 있습니다.\n",
    "# 'JOB_ID'를 본인의 작업 id로 바꾸시고 아래 코드를 주석 해제 해줍니다.\n",
    "#spec01_job = backend.retrieve_job('JOB_ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 분광기(Spectroscopy) 데이터 맞춤\n",
    "\n",
    "분광기 신호를 *Lorentzian* 함수의 형태로 맞춰줍니다.\n",
    "\n",
    "$$ \\frac{AB}{\\pi[(f-f_{01})^2 + B^2]} + C $$\n",
    "\n",
    "이러한 것은 큐비트 주파수 $f_{01}$를 다음 맞춤 매개 변수를 사용하여 찾습니다.\n",
    "\n",
    "\n",
    "Parameter | Corresponds to\n",
    " --- | ---\n",
    " $A$ | amplitude\n",
    " $f_{01}$ | 01 frequency guess (GHz)\n",
    " $B$ | scale\n",
    " $C$ | offset\n",
    "\n",
    " \n",
    " `qiskit.ignis.characterization.fitters` 라이브러리로 부터 맞춰주는 `helper` 모듈에 있는 `SpecFitter`을 사용하게 될것입니다.\n",
    " \n",
    " \n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**참고** 아래의 맞춤 매개변수를 수정하여 좋은 형태의 결과를 얻을 수 있습니다.\n",
    "    \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from resources.helper import SpecFitter\n",
    "\n",
    "amp_guess = 5e6\n",
    "f01_guess = 5\n",
    "B = 1\n",
    "C = 0\n",
    "fit_guess = [amp_guess, f01_guess, B, C]\n",
    "\n",
    "fit = SpecFitter(spec01_job.result(), spec_freqs_GHz, qubits=[qubit], fit_p0=fit_guess)\n",
    "fit.plot(0, series='z')\n",
    "f01 = fit.spec_freq(0, series='z')\n",
    "print(\"Spec01 frequency is %.6f GHz\" % f01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "백엔드에서 보정된 큐비트 주파수와 나온 결과를 비교해 봅시다! 제대로 작동하면 결과가 보정된 값 ($\\pm$1 MHz)에 매우 가까워야 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 백엔드 속성으로부터 큐비트 주파수 검색\n",
    "f01_calibrated = backend.properties().frequency(qubit) / GHz \n",
    "f01_error = abs(f01-f01_calibrated) * 1000 # error in MHz\n",
    "print(\"Qubit frequency error is %.6f MHz\" % f01_error) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🎉 축하합니다! 실제 양자 시스템에서 성공적으로 첫 번째 펄스 실험을 실행하고 데이터를 분석했습니다. 이는 [약 2년 전](https://www.ibm.com/blogs/research/2019/12/qiskit-openpulse/) 키스킷 펄스를 공개하고 오픈 양자 시스템 `ibmq_armonk`에서 펄스 접근을 제공했을때 고급 연구소에 접근하지 않고는 불가능했었습니다. 이제는 집에서 편안하게 노트북으로 실험 양자물리를 할 수 있습니다. 정말 대단하다!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## 2단계 (튜토리얼): 라비 진동을 사용하여 X-180 펄스 진폭 보정\n",
    "\n",
    "이 부분에서는 어떠한 코드를 수정하지 않아도 됩니다. 모든 셀을 살펴보시고 단계를 이해하도록 해야 합니다.\n",
    "    \n",
    "</div>\n",
    "\n",
    "### 측정된 주파수로 라비(Rabi) 스케줄 구축하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_rabi_amp = 0.75\n",
    "rabi_amps = helper.get_rabi_amps(max_rabi_amp)\n",
    "\n",
    "rabi_scheds = []\n",
    "for ridx, amp in enumerate(rabi_amps):\n",
    "    with pulse.build(name=\"rabisched_%d_0\" % ridx) as sched: # '0'은 라비에 해당합니다\n",
    "        with pulse.align_sequential():\n",
    "            pulse.set_frequency(f01*GHz, DriveChannel(qubit))\n",
    "            rabi_pulse = Gaussian(duration=drive_duration, amp=amp, \\\n",
    "                              sigma=drive_sigma, name=f\"Rabi drive amplitude = {amp}\")\n",
    "            pulse.play(rabi_pulse, DriveChannel(qubit))\n",
    "            pulse.call(meas)\n",
    "    rabi_scheds.append(sched)\n",
    "\n",
    "# 라비 스케줄 그리기\n",
    "rabi_scheds[-1].exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실제 장치에서 작업 실행하기\n",
    "rabi_job = backend.run(rabi_scheds, job_name=\"Rabi\", **helper.job_params)\n",
    "\n",
    "print(rabi_job.job_id())\n",
    "job_monitor(rabi_job)\n",
    "\n",
    "# 대기열 시간이 너무 긴 경우 작업 id를 저장할 수 있습니다.\n",
    "# 작업이 완료되면 작업을 얻을 수 있습니다.\n",
    "# 'JOB_ID'를 본인의 작업 id로 바꾸시고 아래 코드를 주석 해제 해줍니다.\n",
    "#rabi_job = backend.retrieve_job('JOB_ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 라비 데이터 맞추기(fit)\n",
    "\n",
    "우리는 라비 신호를 사인 함수의 형태로 맞출 것입니다.\n",
    "\n",
    "$$ a \\cos(2\\pi f x + \\phi) + c $$\n",
    "\n",
    "이는 아래와 같은 맞춤 매개 변수들을 가지고 라비 주기(period) $T = 2\\pi/f$를 찾습니다.\n",
    "\n",
    "\n",
    "Parameter | Corresponds to\n",
    " --- | ---\n",
    " $a$ | amplitude\n",
    " $f$ | Rabi drive frequency\n",
    " $\\phi$ | phase offset\n",
    " $c$ | offset\n",
    "\n",
    "`qiskit.ignis.characterization.calibration.fitters` 라이브러리에 있는 `RabiFitter`를 사용할 것입니다.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**참고:** 아래의 맞춤(fitting) 매개변수를 수정하여 좋은 형태의 결과를 얻을 수 있습니다.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.ignis.characterization.calibrations.fitters import RabiFitter\n",
    "\n",
    "amp_guess = 5e7\n",
    "fRabi_guess = 2\n",
    "phi_guess = 0.5\n",
    "c_guess = 0\n",
    "fit_guess = [amp_guess, fRabi_guess, phi_guess, c_guess]\n",
    "\n",
    "fit = RabiFitter(rabi_job.result(), rabi_amps, qubits=[qubit], fit_p0=fit_guess)\n",
    "fit.plot(qind=0, series='0')\n",
    "x180_amp = fit.pi_amplitude()\n",
    "print(\"Pi amplitude is %.3f\" % x180_amp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## 3단계 (문제): $|1\\rangle \\rightarrow |2\\rangle$ 전이 주파수 찾기\n",
    "    \n",
    "$|1\\rangle$와 $|2\\rangle$ 사이의 트랜스몬 상태 전이를 목격하기 위해는 아래와 같이 해야 합니다.\n",
    "\n",
    "1. $X_\\pi$ 펄스를 적용하여 $|0\\rangle$부터 $|1\\rangle$까지 큐비트를 전이시킵니다.\n",
    "1. $|1\\rangle \\rightarrow |2\\rangle$전이를 찾기 위해 주파수를 바꿔서 두 번째 펄스를 적용합니다.\n",
    "\n",
    "</div>\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "아래 셀만이 이 전체 노트북에서 유일하게 수정되어야 할 부분입니다.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pi 펄스 정의하기\n",
    "x_pulse = Gaussian(duration=drive_duration,\n",
    "                     amp=x180_amp, \n",
    "                     sigma=drive_sigma,\n",
    "                     name='x_pulse')\n",
    "\n",
    "def build_spec12_pulse_schedule(freq, anharm_guess_GHz):    \n",
    "    with pulse.build(name=\"Spec Pulse at %.3f GHz\" % (freq+anharm_guess_GHz)) as spec12_schedule:\n",
    "        with pulse.align_sequential():            \n",
    "            # 이 선 사이에 코드를 작성하세요 - 시작\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "    \n",
    "            # 이 선 사이에 코드를 작성하세요 - 끝\n",
    "    return spec12_schedule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "우리의 트랜스몬 큐비트의 부조화성은 일반적으로 약 $-300$ MHz이므로, 우리는 이 값을 쓸 것입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anharmonicity_guess_GHz = -0.3 # 추측한 부조화성\n",
    "freqs_GHz = helper.get_spec12_freqs(f01, qubit)\n",
    "\n",
    "# 각 spec 펄스에 측파대(sideband) 주파수를 변경합니다\n",
    "spec12_scheds = []\n",
    "for freq in freqs_GHz:\n",
    "    spec12_scheds.append(build_spec12_pulse_schedule(freq, anharmonicity_guess_GHz))\n",
    "\n",
    "# spec12 스케줄 그리기 \n",
    "spec12_scheds[-1].exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실제 장치에서 작업 실행하기\n",
    "spec12_job = backend.run(spec12_scheds, job_name=\"Spec 12\", **helper.job_params)\n",
    "\n",
    "print(spec12_job.job_id())\n",
    "job_monitor(spec12_job)\n",
    "\n",
    "# 대기열 시간이 너무 긴 경우 작업 id를 저장할 수 있습니다.\n",
    "# 작업이 완료되면 작업을 얻을 수 있습니다.\n",
    "# 'JOB_ID'를 본인의 작업 id로 바꾸시고 아래 코드를 주석 해제 해줍니다.\n",
    "#spec12_job = backend.retrieve_job('JOB_ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 분광학 데이타 맞추기\n",
    "\n",
    "<div id='fit-f12'></div>\n",
    "\n",
    "우리는 다시 분광학 신호를 Lorentzian 함수의 형태로 맞출 것입니다.\n",
    "\n",
    "$$ \\frac{AB}{\\pi[(f-f_{12})^2 + B^2]} + C $$\n",
    "\n",
    "이는 아래와 같은 맞춤 변수를 가지고 $|1\\rangle \\to |2\\rangle$ 전이 $f_{12}$의 주파수를 찾습니다.\n",
    "\n",
    "\n",
    "Parameter | Corresponds to\n",
    " --- | ---\n",
    " $A$ | amplitude\n",
    " $f_{12}$ | 12 frequency guess (GHz)\n",
    " $B$ | scale\n",
    " $C$ | offset\n",
    " \n",
    " \n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**참고:** 아래의 맞춤(fitting) 매개변수를 수정하여 좋은 형태의 결과를 얻을 수 있습니다.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amp_guess = 2e7\n",
    "f12_guess = f01 - 0.3\n",
    "B = .1\n",
    "C = 0\n",
    "fit_guess = [amp_guess, f12_guess, B, C]\n",
    "\n",
    "fit = SpecFitter(spec12_job.result(), freqs_GHz+anharmonicity_guess_GHz, qubits=[qubit], fit_p0=fit_guess)\n",
    "fit.plot(0, series='z')\n",
    "f12 = fit.spec_freq(0, series='z')\n",
    "print(\"Spec12 frequency is %.6f GHz\" % f12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 아래의 코드를 사용하여 답을 확인하세요\n",
    "from qc_grader import grade_ex4\n",
    "grade_ex4(f12,qubit,backend_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 답을 제출합니다. 언제든지 다시 제출이 가능합니다.\n",
    "from qc_grader import submit_ex4\n",
    "submit_ex4(f12,qubit,backend_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $E_J/E_c$ 계산하기\n",
    "\n",
    "도입 부분에서 있는 공식들을 수정하여 우리는 $E_c$와 $E_J$를 $f_{01}$와 $f_{12}$를 이용하여 펄스 실험으로부터 얻을 수 있습니다.\n",
    "\n",
    "\n",
    "$$\n",
    "E_c = -\\delta = f_{01} - f_{12} \\qquad E_J = \\frac{(2f_{01}-f_{12})^2}{8(f_{01}-f_{12})}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ec = f01 - f12\n",
    "Ej = (2*f01-f12)**2/(8*(f01-f12))\n",
    "print(f\"Ej/Ec: {Ej/Ec:.2f}\") # 일반적으로 값은 ~ 30 입니다 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 추가 정보\n",
    "\n",
    "**출제자:** Nick Brønn, Junye Huang\n",
    "\n",
    "**번역:** 최인호 (qiskit slack @Inho Choi)\n",
    "\n",
    "**버젼:** 1.0.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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}