Lecture1/lecture 1-1 - 다중 큐비트 게이트.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 1 - 게이트와 양자 회로\n",
    "# 1-1 다중 큐비트 상태와 다중 큐비트 게이트\n",
    "## 1. 다중 큐비트 상태\n",
    "한개의 큐비트가 두가지의 상태를 나타낼 수 있는것처럼 두개의 큐비트는 아래와 같이 4가지의 상태를 나타낼 수 있습니다. 따라서 n개의 큐비트가 있다면 $2^n$가지의 상태를 나타낼 수 있습니다.\n",
    "\n",
    "```00 01 10 11```\n",
    "\n",
    "우선 두개의 큐비트를 설명하려면 4개의 복소 진폭(complex amplitude)가 필요합니다. 이러한 진폭들은 4차원의 벡터에 아래와 같이 표현할 수 있습니다.\n",
    "\n",
    "$$ |a\\rangle = a_{00}|00\\rangle + a_{01}|01\\rangle + a_{10}|10\\rangle + a_{11}|11\\rangle = \\begin{bmatrix} a_{00} \\\\\n",
    "a_{01} \\\\ a_{10} \\\\ a_{11} \\end{bmatrix} $$\n",
    "\n",
    "만약 두개의 큐비트가 분리되서 표현이 되었을때 이 두개의 큐비트를 크로네커 곱(kronecker product)을 사용하여 표현할 수 있습니다.\n",
    "\n",
    "$$ |a\\rangle = \\begin{bmatrix} a_o \\\\ a_1 \\end{bmatrix} \\quad |b\\rangle = \\begin{bmatrix} b_0 \\\\ b_1 \\end{bmatrix} $$\n",
    "\n",
    "$$ |ba\\rangle = |b\\rangle \\otimes |a\\rangle = \\begin{bmatrix} b_0 \\times \\begin{bmatrix} a_0 \\\\ a_1 \\end{bmatrix} \\\\\n",
    "b_1 \\times \\begin{bmatrix} a_0 \\\\ a_1 \\end{bmatrix} \\end{bmatrix} = \\begin{bmatrix} b_0a_0 \\\\ b_0a_1 \\\\ b_1a_0 \\\\ b_1a_1 \\end{bmatrix} $$\n",
    "\n",
    "위의 표현과 같이 크로네커 곱을 이용하여 여러개의 큐비트를 표현할 수 있습니다. 아래는 3개의 큐비트를 설명하는 벡터입니다.\n",
    "\n",
    "$$ |cba\\rangle = \\begin{bmatrix} c_0b_0a_0 \\\\ c_0b_0a_1 \\\\ c_0b_1a_0 \\\\ c_0b_1a_1 \\\\ c_1b_0a_0 \\\\ c_1b_0a_1 \\\\ c_1b_1a_0 \\\\ c_1b_1a_1 \\end{bmatrix} $$\n",
    "\n",
    "다중 큐비트의 상태를 표현할때 Qiskit에서는 아래와 같이 표현합니다\n",
    "\n",
    "$$|MSB \\cdots LSB\\rangle, \\quad i.e. \\quad |q5,q4,q3,q2,q1,q0\\rangle, \\quad |q2,q1,q0\\rangle $$\n",
    "\n",
    "MSB = Most Significant Bit\n",
    "\n",
    "LSB = Least Significant Bit\n",
    "\n",
    "\n",
    "이번 장에서 다중 게이트의 사용과 다중 큐비트의 양자 회로을 output으로부터 개념을 이해해봅시다. \n",
    "\n",
    "게이트와 양자회로를 그리기 위해 Python 라이브러리인 Qiskit을 불러오겠습니다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import * #qiskit 전체 라이브러리 불러오기\n",
    "from qiskit.providers.aer import StatevectorSimulator #StatevectorSimulator를 사용하여 양자회로의 최종 양자 statevector을 구할수 있음\n",
    "\n",
    "from math import pi, sqrt #math 라이브러리에서 pi와 sqrt 불러오기\n",
    "from qiskit.visualization import * #양자상태를 시각화 하기 위해 qiskit.visualization 불러오기\n",
    "from qiskit.quantum_info import Statevector #Statevector를 사용하여 양자회로의 최종 양자 statevector을 구할수 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제 1 - 0번 큐비트에 $X$ 게이트 추가하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 qubit을 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state0 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state0).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제 2 - 1번 큐비트에 하다마드 게이트 추가하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 qubit을 가진 양자 회로 만들기\n",
    "qc.h(1) #1번 큐비트에 H 게이트 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "\\tfrac{1}{\\sqrt{2}} & 0 & \\tfrac{1}{\\sqrt{2}} & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state1 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state1).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2-큐비트 게이트\n",
    "### 제어 게이트 (Controlled Gates)\n",
    "### 1. $CX$ 게이트\n",
    "\n",
    "CX 게이트는 $cx(control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 X-게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### 경우 1: $q0$가 control 큐비트이며 $q1$이 target 큐비트일때"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cx(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CX 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 양자회로를 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #양자회로를 시뮬레이션하기\n",
    "result = job.result() #시뮬레이션 결과를 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #시뮬레이션 결과를 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 경우 2: $q1$가 control 큐비트이며 $q0$이 target 큐비트일때"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cx(1,0) #1번 큐비트에 control 큐비트로 지정하며 0번 큐비트를 target 큐비트로 지정하는 CX 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 양자회로를 시뮬레이션하기\n",
    " \n",
    "job = execute(qc, backend) #양자회로를 시뮬레이션하기\n",
    "result = job.result() #시뮬레이션 결과를 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #시뮬레이션 결과를 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CX$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cx(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CX 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state2 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state2).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CX-게이트 [Q-sphere]\n",
    "\n",
    "![cx-gate](./figure/q-sphere_cx-gate.png)\n",
    "\n",
    "#### target 큐비트의 상태가 $|1\\rangle$일때 $CX$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.cx(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CX 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state3 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state2).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CX-게이트 [Q-sphere]\n",
    "\n",
    "![cx-gate2](./figure/q-sphere_cx-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CX_{q_0,q_1} = I \\otimes |0\\rangle\\langle0| + X \\otimes |1\\rangle\\langle1| = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\end{pmatrix} $$\n",
    "\n",
    "$$ CX_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes X  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\end{pmatrix} $$\n",
    "\n",
    "이러한 CX 게이트의 특성은 고전 회로의 XOR 게이트와 유사합니다.\n",
    "\n",
    "### 2. $CY$ 게이트\n",
    "\n",
    "CY 게이트는 $cy(control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 Y-게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CY$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cy(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CY 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.-0.j 0.-0.j 0.-0.j 0.-1.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+1.j 0.+0.j 0.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 양자회로를 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #양자회로를 시뮬레이션하기\n",
    "result = job.result() #시뮬레이션 결과를 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #시뮬레이션 결과를 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state4 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state4).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CY-게이트 [Q-sphere]\n",
    "\n",
    "![cy-gate](./figure/q-sphere_cy-gate.png)\n",
    "\n",
    "#### target 큐비트의 상태가 $|1\\rangle$일때 $CY$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPEAAACuCAYAAADnE+srAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAAANS0lEQVR4nO3df2zU933H8ef3jh822G4wRjqIjY3BJsa/qHBQjCidXTtrBE5pG5JMjoFCyh8bhSrM12l/TEKahLyQZrWIEpMto5tU4inpIsfepqZ1pwCNkKlFY+ILJiwm+McpOXDAGEy4u+/+oNB4GIjtO3/9+fr1+Cfivj/uTeDJ93vfO3/Psm3bRkSM5XF6ABGZGEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiuBlODyB3sm2bq9GI02OMyRyPF8uynB5jWlLEU9DVaIR5re84PcaYDJRXMterv05O0Om0iOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOFcH3EoFMLv97Ns2TISEhLIyMhg9+7dDA0NsX37dizL4sCBA06PKXEWjsDZT+H98xDog4EhpyeKHVf/7NjJkyd57LHHCAaDzJ07lxUrVtDX10d9fT1nz57l4sWLAKxcudLZQeMo8tohoq//O97nfozn24+OWGbbNpHav8EOBJhxoB5rSZYzQ8bRpWtwrAve+wgGh//0uAWseBC+sRweWujYeDHh2iNxKBSiqqqKYDDInj176O/vp729nWAwSF1dHS0tLbS1tWFZFkVFRU6PGzeemmrIyiTS8Cr2Z6ERy6K/fAv7/Q48Nc+4MuCei/DCf8KvTo0MGMAGPuiFV1qhqR1s25ERY8K1Ee/atYuenh527tzJ/v37SU5Ovr3M7/dTXFxMOBwmKyuLlJQUByeNL2vmTGbU7oHhYSI//cfbj9vne4ge+lesh5bj2fR95waMk88G4eVWuDx8/3VbA/DfHfGfKV5cGXEgEKCxsZG0tDT27ds36jqrVq0CoLi4eMTjH3/8MY8//jjJycnMmzePzZs3c+HChbjPHE9WzjI8Tz+J/ft2oi3/hR2JEPmH/WDbeGv3YHm9To8Yc80nYej6V1//Vx1w4UrcxokrV0Z8+PBhotEo1dXVJCUljbpOYmIiMDLiwcFBysrK6Onp4fDhwxw8eJAjR46wYcMGotHopMweL57qv4DsbCKv/hPRl17BPt2FZ+tmrIx0p0eLuUtXoeP82Laxgd+dics4cefKC1utra0AlJWV3XWdnp4eYGTEBw8epLe3l3fffZfFixcDkJ6ezpo1a2hqamLjxo3xGzrOrBkzmFH7HOEf/ZhocwtWQT6e7210eqy4+H03RMfxGrftf6Hq6zEfJ+5cGfG5c+cAyMzMHHV5OBzm2LFjwMiIm5ubWbt27e2AAUpLS8nOzubtt98ed8QlJSUEg8GvvL49axY0vDSu57qnuXNh5kwIh7EeLsHyxO5ELDcnF+uLL2K2v4kortpLztrtY97u8jBkLM7CjobjMNW9+Xw+Tpw4Ma5tXRnx0NDNNwGvXbs26vLGxkZCoRDJycksWbLk9uOdnZ1s2rTpjvXz8/Pp7Owc9zzBYJDe3t6vvkHCbGaO+9lGZ9s2kRdehPANWJxB9Bev4/nmOqxFsXl/pa+/D4bH8CI0jpZeGRz3tr29PdiG3S7YlRH7fD4GBgZob2+ntLR0xLL+/n5qa2sBKCoqGnGv5IGBAR544IE79peamsrp06cnNM9Y2LNm8dm4n2100beasP/wPp4fbMFT+gjhv/oRkRdexLu/Lib3i160cNGUORJ7wpfHtd21y0EWLRzbn1WsjPXvyJe5MuKKigoCgQB1dXVUVlaSm5sLQFtbGzU1NYRCN98vnawPeYz1NGkoEo7pfaft3l6irx3CWp6L58knsLxePM9UE/2XnxN9qwnvd78z4efoOtM1Ze47feka7P2Psb8ufrzUR8Mfr5WYxJVXp/1+P/Pnz+f8+fPk5+dTWFhITk4Oq1evJjs7m/LycuDOt5fmzZvH559/fsf+Ll68SGpq6mSMHnN2NErk+Z9CNIq39rnbbyd5nnwCKzeH6GuHsPv6HZ4ytr6WCEUZY9vGsqB0WXzmiTdXRpyens6RI0dYv349CQkJdHd3k5qaSkNDAy0tLXR1dQF3RpyXlzfqa9/Ozk7y8vImZfZYi77xS+zOAJ4tz2B96YKd5fXi/evnIBoh8sKL2CZ/ZGkUVV+HpISvvv63CyF19HcjpzxXRgw3g2xubmZwcJDBwUGOHz/Ojh07GBoaoru7G4/HQ0FBwYhtNmzYwNGjR2+//QRw/Phxzp49S1VV1WT/FibM/uQToj//N6y8h/B8/3t3LLeyMvE8U43dcYroW00OTBg/85PgL8tvHpXvpzIfHi24/3pTlWW77Z/g+zh+/DiPPPIIy5cv58MPPxyx7PLlyxQWFpKWlsbevXsZHh7G7/ezYMEC3nvvPTwxfEvmXmL9mngyTNXvYhocvvkhjt+dufla+cuKMuAbuZDjzLWsmHHtkfhuOjpufkj2/59KA6SkpNDa2srChQt5+umnefbZZ1mzZg3Nzc2TFrDEVnIC/Hkh/N1G2P0ozJn1p8e3rTM/YHDp1el7uVfEAEuXLqW5uXkyR5JJ4PXAkgUw848fE/e46FtYp93h5X4Ri5hm2h2Jb32uWsQtpt2RWMRtFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4RSxiOEUsYjhFLGI4abdZ6dNMMfjZaC80ukxxmSOx33fImEKRTwFWZY1JX/AXqYmnU6LGE4RixhOEYsYThGLGE4RixhOEYsYThGLGE4RixhOEYsYThGLGE4RixhOEYsYThGLGE4RixhOEYsYThGLGE4RixhOt4+QKcm24YtIfPZ767/Xw7Hd9ywvWA58ebll27d+WyJTx/Uw/KTR6SnGpu4pmO3AYVGn0yKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGmxYRh0Ih/H4/y5YtIyEhgYyMDHbv3s3Q0BDbt2/HsiwOHDjg9Jgi4+L6iE+ePElhYSHPP/88wWCQFStWcOPGDerr63nqqacIBAIArFy50tlBJS5afvYE9TVeek8fHXV57+mj1Nd4afnZE5M8Wey4OuJQKERVVRXBYJA9e/bQ399Pe3s7wWCQuro6WlpaaGtrw7IsioqKnB5X4qDsBy+TkJzGOw1buTE8NGLZjetXeadhKwnJaZRve8WhCSfO1RHv2rWLnp4edu7cyf79+0lOTr69zO/3U1xcTDgcJisri5SUFAcnlXiZk7KAb21r4NKnZzn6un/EsmOv/4RLn57lW9sPkpic5tCEE+faiAOBAI2NjaSlpbFv375R11m1ahUAxcXFtx+7Ff3q1auZPXs2lhP3W5GYWlqykYfW1vD+b17mk1O/AaCn83/4w69fIm/tZpau+o7DE06MayM+fPgw0WiU6upqkpKSRl0nMTERGBnxRx99xJtvvonP5+Phhx+elFkl/v6spp6keQ/y61e3cWWgj3de3UbSvAf55uZ6p0ebMNdG3NraCkBZWdld1+np6QFGRrxu3Tr6+/tpamqioqIivkPKpJk99wEqfvjPDF74hF/8bTGXQ91U/PA1Zs/5mtOjTZhr73Z57tw5ADIzM0ddHg6HOXbsGDAyYo8n9v+ulZSUEAwGY75fN/POTOS7f38mpvvMLHyUgrIdnPrtQQrKdpBZWBnT/efm5BC5cW1c2/p8Pk6cODGubV0b8dDQzSuR166N/j+1sbGRUChEcnIyS5YsiesswWCQ3t7euD6H28yYPScu+12YU8qp3x5kYU5pzPfd199H+PrVmO/3flwbsc/nY2BggPb2dkpLR/6B9ff3U1tbC0BRUVHcL175fL647t+NvDMTnR5hzBYtXDShI/F4uTbiiooKAoEAdXV1VFZWkpubC0BbWxs1NTWEQiFgcj7kMd7TpOnMxPtOd505o/tOx5Lf72f+/PmcP3+e/Px8CgsLycnJYfXq1WRnZ1NeXg6MfD0sYiLXRpyens6RI0dYv349CQkJdHd3k5qaSkNDAy0tLXR1dQGKWMzn2tNpgLy8PJqbm+94/MqVK3R3d+PxeCgoKHBgMpHYcXXEd/PBBx9g2za5ubnMmXPnVdA33ngDgM7OzhG/zsrKoqSkZPIGlZhbsW4rK9ZtdXqMmJqWEXd0dAB3P5XetGnTqL/esmULhw4diutsImOliEehL4oUk7j2wta93C9iEZNMyyPxrc9Vi7jBtDwSi7iJIhYxnCIWMZwiFjGcIhYxnCIWMZwiFjGcIhYxnCIWMZwiFjGcIhYxnGXrR3ZkCrJt+CLi9BRjM8sLTnxhiCIWMZxOp0UMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUMp4hFDKeIRQyniEUM93+eD6s5XAqMTwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.cy(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CY 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 0 & 0 & i  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state5 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state5).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CY-게이트 [Q-sphere]\n",
    "\n",
    "![cy-gate2](./figure/q-sphere_cy-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CY_{q_0,q_1} = I \\otimes |0\\rangle\\langle0| + Y \\otimes |1\\rangle\\langle1| = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & -i \\\\ 0 & 0 & 1 & 0 \\\\ 0 & i & 0 & 0 \\end{pmatrix} $$\n",
    "\n",
    "$$ CY_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes Y  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & -i \\\\ 0 & 0 & i & 0 \\end{pmatrix} $$\n",
    "\n",
    "\n",
    "### 3. $CZ$ 게이트\n",
    "\n",
    "CZ 게이트는 $cz(control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 Z-게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "CZ 게이트는 대칭적인(symmetric) 게이트이며 사실상 control과 target이 구분되지 않습니다. 대칭적인 게이트이기 때문에 control과 target을 서로 바꿔서 입력하여도 같은 결과를 출력합니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cz(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CZ 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]\n",
      " [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]\n",
      " [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]\n",
      " [-0.+0.j -0.+0.j -0.+0.j -1.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 양자회로를 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #양자회로를 시뮬레이션하기\n",
    "result = job.result() #시뮬레이션 결과를 가져오기 \n",
    "print(result.get_unitary(qc, decimals=3)) #단위 행렬을 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state6 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state6).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CZ-게이트 [Q-sphere]\n",
    "\n",
    "![cz-gate](./figure/q-sphere_cz-gate.png)\n",
    "\n",
    "#### target 큐비트의 상태가 $|1\\rangle$일때 $CZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.cz(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CZ 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state7 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state7).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CZ-게이트 [Q-sphere]\n",
    "\n",
    "![cz-gate2](./figure/q-sphere_cz-gate2.png)\n",
    "\n",
    "#### control 큐비트와 target 큐비트를 바꾸고 초기 큐비트의 상태가 위와 동일할때 $CZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPEAAACuCAYAAADnE+srAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAAANHklEQVR4nO3df1DUd37H8ef3u6iIYhWxXQ3IDwWDyA8rscHmvNPB9Bw1tbkzk4YYezWTmbZcvImFdKYzzfiXQ5pcOsabnl6b864z5WiTa4ZAr3PXYaYxXobBY4yckJBgMCywk6xgRAJJdvfbP0hNKPhjcb8sny+vx4x/sN/vd/ftwJPvd7/73cVyHMdBRIxlJ3oAEbkziljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwiljEcIpYxHCKWMRwSYkeQCZzHIdPopFEjxGTFNuHZVmJHmNOUsSz0CfRCMuaf5XoMWIytH0Hi3z6cUoEHU6LGE4RixhOEYsYThGLGE4RixhOEYsYThGLGE4RixhOEYsYThGLGE4RixhOEYsYThGLGM7zEYdCIWpqali7di3JyclkZmZy6NAhRkZGOHjwIJZlcfz48USPKS4LR6D7QzjfC539MDSS6Inix9PvHTt37hw7d+4kGAyyaNEi1q9fT39/P8eOHaO7u5vBwUEASktLEzuoiyIvnSL6s3/D99T3sL95/4RljuMQqf4bnM5Oko4fw8rJTsyQLvp4FM50wZvvwfDYl7dbwPq74Gvr4O6VCRsvLjy7Jw6FQuzZs4dgMMjhw4cZGBigra2NYDBIbW0tTU1NtLa2YlkWxcXFiR7XNfb+SsjOInLiRzgfhSYsi/78VZzz7dj7H/VkwIFBeP4/4Ze/nRgwgANc6IMfNkNDGzhOQkaMC89G/OSTTxIIBKiqquK5554jNTX1+rKamhpKSkoIh8NkZ2ezZMmSBE7qLmvePJKqD8PYGJHv/8P1253eANFTP8W6ex32vm8lbkCXfDQM/9gMV8duvW5zJ/xXu/szucWTEXd2dlJfX096ejpHjx6dcp1NmzYBUFJSMuH2999/nwceeIDU1FSWLVvGY489xuXLl12f2U1W3lrshx/C+U0b0aZf4EQiRJ59DhwHX/VhLJ8v0SPGXeM5GPn09tf/ZTtcvubaOK7yZMR1dXVEo1EqKytZvHjxlOssXLgQmBjx8PAw27ZtIxAIUFdXx8mTJzl9+jS7d+8mGo3OyOxusSv/FHJzifzon4j+4Ic473Rh/9ljWJkZiR4t7j7+BNp7Y9vGAX79rivjuM6TJ7aam5sB2LZt2w3XCQQCwMSIT548SV9fH6+//jqrV68GICMjgy1bttDQ0MDevXvdG9plVlISSdVPEf7u94g2NmFtKMR+cG+ix3LFb3ogOo3nuK0XYc/GuI/jOk9GfOnSJQCysrKmXB4Ohzlz5gwwMeLGxkbuu+++6wEDlJeXk5uby2uvvTbtiMvKyggGg7e9vjN/Ppz4wbQe66YWLYJ58yAcxrqnDMuO34FYfl4+1mefxe3+7kTJniPk3Xcw5u2ujkHm6mycaNiFqW7O7/dz9uzZaW3ryYhHRsZfBBwdHZ1yeX19PaFQiNTUVHJycq7f3tHRwb59+yatX1hYSEdHx7TnCQaD9PX13f4GyQuYN+1Hm5rjOESefwHCn8PqTKL/+jPsr2/FWhWf11f6B/phLIYnoS5ac2142tv29QVwDPu4YE9G7Pf7GRoaoq2tjfLy8gnLBgYGqK6uBqC4uHjCZyUPDQ2xdOnSSfeXlpbGO++8c0fzxMKZP5+Ppv1oU4u+2oDz1nns7xzALr+X8F99l8jzL+B7rjYunxe9auWqWbMntsNXp7Xd6NUgq1bG9r2Kl1h/Rr7KkxFXVFTQ2dlJbW0tO3bsID8/H4DW1lb2799PKDT+eulMXeQR62HSSCQc18+ddvr6iL50CmtdPvZD38by+bAfrST6458QfbUB35/88R0/Rte7XbPmc6c/HoUj/xH78+IHyv2c+OJciUk8eXa6pqaG5cuX09vbS2FhIUVFReTl5bF582Zyc3PZvn07MPnlpWXLlnHlypVJ9zc4OEhaWtpMjB53TjRK5O+/D9Eovuqnrr+cZD/0baz8PKIvncLpH0jwlPH1OwuhODO2bSwLyte6M4/bPBlxRkYGp0+fZteuXSQnJ9PT00NaWhonTpygqamJrq4uYHLEBQUFUz737ejooKCgYEZmj7foyz/H6ejEPvAo1ldO2Fk+H76/fgqiESLPv4Bj8iVLU9izERYn3/763yyCtKlfjZz1PBkxjAfZ2NjI8PAww8PDtLS08MQTTzAyMkJPTw+2bbNhw4YJ2+zevZs33njj+stPAC0tLXR3d7Nnz56Z/i/cMeeDD4j+5F+wCu7G/taDk5Zb2VnYj1bitP+W6KsNCZjQPcsXw19uH98r38qOQrh/w63Xm60sx2u/gm+hpaWFe++9l3Xr1vH2229PWHb16lWKiopIT0/nyJEjjI2NUVNTw4oVK3jzzTex4/iSzM3E+znxTJitf4tpeGz8Io5fvzv+XPmrijPha/mQl5hzWXHj2T3xjbS3j18k+/8PpQGWLFlCc3MzK1eu5OGHH+bxxx9ny5YtNDY2zljAEl+pyfBHRfB3e+HQ/ZAy/8vb/3yr+QGDR89O38zNIgZYs2YNjY2NMzmSzACfDTkrYN4Xl4nbHvorrHNu93KriEVMM+f2xP93XbWIV8y5PbGI1yhiEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcPNuWunTZBi+xjaviPRY8QkxfbeX5EwhSKehSzLmpVvsJfZSYfTIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGU8QihlPEIoZTxCKGmxMRh0IhampqWLt2LcnJyWRmZnLo0CFGRkY4ePAglmVx/PjxRI8pMi2e/3P0586dY+fOnQSDQRYtWsT69evp7+/n2LFjdHd3Mzg4CEBpaWliBxXXhIbhzLvQ3gsfj47fNvIpnO+FwrvAZ/iuzHIcx0n0EG4JhUJs3LiRQCDA4cOHeeaZZ0hNTQXg2Wef5emnnyYpKYlIJMKVK1dYsmRJgieWeApH4N9boaX7xussS4HvbIXVy2durnjzdMSPPPIIdXV1VFVV8eKLL05aXlpayltvvUVOTg4XL15MwITilkgU/vl/oKP/1uvO80FVBWSluz+XGww/kLixzs5O6uvrSU9P5+jRo1Ous2nTJgBKSkqu3xYIBKiqqmLz5s0sWLAAy7JmZF6Jr/++cHsBA3weGQ/+s7C7M7nFsxHX1dURjUaprKxk8eLFU66zcOFCYGLE7733Hq+88gp+v5977rlnRmaV+ApH4ExXbNtcHYNzH7gzj9s8G3FzczMA27Ztu+E6gUAAmBjx1q1bGRgYoKGhgYqKCneHFFe0B8ajjNUbMYY/W3j27PSlS5cAyMrKmnJ5OBzmzJkzwMSIbTv+v9fKysoIBoNxv1+ZWtHOv2XdN/4i5u16PgyTkZEd/4Fug9/v5+zZs9Pa1rMRj4yMADA6Ojrl8vr6ekKhEKmpqeTk5Lg6SzAYpK+vz9XHkC/lfRaZ1na2L4nghyEin38a54nc5dmI/X4/Q0NDtLW1UV5ePmHZwMAA1dXVABQXF7t+8srv97t6/zLR/KTotLaLfD6G/3cTc4r6Tn5GPBtxRUUFnZ2d1NbWsmPHDvLz8wFobW1l//79hEIhYGYu8pjuYZJMz8UP4divYt9uY24yL35xnsQknj2xVVNTw/Lly+nt7aWwsJCioiLy8vLYvHkzubm5bN++HZj4fFi8IWcFrFoa+3Z/mBf3UWaEZyPOyMjg9OnT7Nq1i+TkZHp6ekhLS+PEiRM0NTXR1TV+KlIRe49lwf0bYtsmOx3yDH3W49nDaYCCggIaGxsn3X7t2jV6enqwbZsNG2L8bosRSrNg9zVoPHfrdX9vCRz8OtiGXtfj6Yhv5MKFCziOQ35+PikpKZOWv/zyywB0dHRM+Do7O5uysrKZG1TuSEUhLE2BX5yHy9cmL/fZsHE1PFgGKQtmfr54mZMRt7e3Azc+lN63b9+UXx84cIBTp065OpvEV1kO/H42vN0/fhHIJ59Ckg9WLoU/WAOpyYme8M4p4il4+D0hc5Jtwfq7xv95kWdPbN3MrSIWMYmn34ooMhfMyT2xiJcoYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHDKWIRwyliEcMpYhHD/S8czIjt/AxodAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #1번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.cz(1,0) #1번 큐비트에 control 큐비트로 지정하며 0번 큐비트를 target 큐비트로 지정하는 CZ 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state8 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state8).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### control과 target을 바꾸어도 위와 동일한 값을 출력함 [Q-sphere]\n",
    "\n",
    "![cz-gate3](./figure/q-sphere_cz-gate3.png)\n",
    "\n",
    "#### control 큐비트와 target 큐비트의 상태가 모두 $|1\\rangle$인 상태일때의 $CZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.x(1) #1번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.cz(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CZ 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 0 & 0 & -1  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state9 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state9).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트와 target 큐비트에 CZ-게이트 [Q-sphere]\n",
    "\n",
    "![cz-gate4](./figure/q-sphere_cz-gate4.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CZ_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes Z  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & -1 \\end{pmatrix} $$\n",
    "\n",
    "위의 수학적 표현에 따르면 control 큐비트가 $|1\\rangle$의 상태일때 게이트의 위상을 뒤집습니다.\n",
    "\n",
    "### 4. $CH$ 게이트 - 컨트롤 하다마드 게이트\n",
    "\n",
    "CH 게이트는 $ch(control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 하다마드 게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CH$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.ch(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CH 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.   -0.j  0.   +0.j -0.   +0.j  0.   +0.j]\n",
      " [ 0.   +0.j  0.707-0.j  0.   +0.j  0.707-0.j]\n",
      " [ 0.   -0.j  0.   +0.j  1.   -0.j  0.   +0.j]\n",
      " [ 0.   +0.j  0.707+0.j  0.   +0.j -0.707+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state10 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state10).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CH-게이트 [Q-sphere]\n",
    "\n",
    "![ch-gate](./figure/q-sphere_ch-gate.png)\n",
    "\n",
    "#### target 큐비트의 상태가 $|1\\rangle$일때 $CH$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.ch(0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CH 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & \\tfrac{1}{\\sqrt{2}} & 0 & \\tfrac{1}{\\sqrt{2}}  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state11 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state11).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CH-게이트 [Q-sphere]\n",
    "\n",
    "![ch-gate2](./figure/q-sphere_ch-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CH_{q_0,q_1} = I \\otimes |0\\rangle\\langle0| + H \\otimes |1\\rangle\\langle1| = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & \\frac{1}{\\sqrt{2}} & 0 & \\frac{1}{\\sqrt{2}} \\\\ 0 & 0 & 1 & 0 \\\\ 0 & \\frac{1}{\\sqrt{2}} & 0 & -\\frac{1}{\\sqrt{2}} \\end{pmatrix} $$\n",
    "\n",
    "$$ CH_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes H  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & \\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}} \\\\ 0 & 0 & \\frac{1}{\\sqrt{2}} & -\\frac{1}{\\sqrt{2}} \\end{pmatrix} $$\n",
    "\n",
    "### 5. $CP$ 게이트 - 컨트롤 위상 게이트\n",
    "\n",
    "CP 게이트는 $cp(theta, control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 $P$ 게이트를 $theta$ 만큼 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "CP 게이트는 대칭적인(symmetric) 게이트이며 사실상 control과 target이 구분되지 않습니다. 대칭적인 게이트이기 때문에 control과 target을 서로 바꿔서 입력하여도 같은 결과를 출력합니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CP$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cp(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CP 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 0.+1.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state12 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state12).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CP-게이트 [Q-sphere]\n",
    "\n",
    "![cp-gate](./figure/q-sphere_cp-gate.png)\n",
    "\n",
    "#### target 큐비트와 control 큐비트의 상태가 $|1\\rangle$일때 $CP$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 370.906x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.x(1) #1번 큐비트에 X 게이트 추가하여 |0> 상태 만들기\n",
    "qc.cp(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CP 게이트를 추가\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 0 & 0 & i  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state13 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state13).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트와 target 큐비트에 CP-게이트 [Q-sphere]\n",
    "\n",
    "![cp-gate2](./figure/q-sphere_cp-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CPhase = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes P  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & e^{i\\lambda} \\end{pmatrix} $$\n",
    "\n",
    "## SWAP 게이트\n",
    "\n",
    "SWAP 게이트는 $swap(qubit_0, qubit_0)$과 같은 문법으로 사용이 되며 대상의 두개 큐비트의 상태를 교환합니다. SWAP 게이트는 대칭적인(symmetric) 게이트이며 사실상 qubit_0과 qubit_1이 구분되지 않습니다. 대칭적인 게이트이기 때문에 qubit_0과 qubit_1을 서로 바꿔서 입력하여도 같은 결과를 출력합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.swap(0,1) #0번 큐비트를 qubit_0로 지정하며 1번 큐비트를 qubit_1로 지정하여 SWAP 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state14 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state14).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 0번 큐비트의 상태가 $|1\\rangle$일때의 상황"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2)\n",
    "qc.x(0)\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state15 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state15).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 0번째 큐비트를 $|1\\rangle$ 상태로 만들기[Q-sphere]\n",
    "\n",
    "![swap-gate](./figure/q-sphere_swap-gate.png)\n",
    "\n",
    "#### SWAP 게이트 추가하여 출력값 확인하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.swap(0,1) #0번 큐비트를 qubit_0로 지정하며 1번 큐비트를 qubit_1로 지정하여 SWAP 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 0 & 1 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state16 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state16).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 0번째 큐비트와 $|0\\rangle$상태의 1번째 큐비트에 SWAP-게이트 [Q-sphere]\n",
    "\n",
    "![swap-gate2](./figure/q-sphere_swap-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ SWAP =  \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\end{pmatrix} $$\n",
    "\n",
    "수학적 표현에 따르면 두개 비트의 상태를 서로 바꿔준다.\n",
    "\n",
    "$$ |a,b\\rangle \\rightarrow |b,a\\rangle $$\n",
    "\n",
    "## Controlled Rotations Gate\n",
    "### 1. CRX 게이트 - Controlled RX gate\n",
    "\n",
    "CRX 게이트는 $crx(\\theta, control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 $RX(\\theta)$ 게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CRX$ 게이트의 작동\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.crx(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CRX 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.   +0.j     0.   +0.j     0.   +0.j     0.   +0.j   ]\n",
      " [ 0.   +0.j     0.707+0.j     0.   +0.j     0.   -0.707j]\n",
      " [-0.   -0.j     0.   -0.j     1.   -0.j     0.   -0.j   ]\n",
      " [ 0.   -0.j    -0.   -0.707j  0.   -0.j     0.707-0.j   ]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state17 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state17).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CRX-게이트 [Q-sphere]\n",
    "\n",
    "![crx-gate](./figure/q-sphere_crx-gate.png)\n",
    "\n",
    "#### target 큐비트와 control 큐비트의 상태가 $|1\\rangle$일때 $CRX$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.crx(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CRX 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & \\tfrac{1}{\\sqrt{2}} & 0 & -\\tfrac{1}{\\sqrt{2}}i  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state18 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state18).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CRX-게이트 [Q-sphere]\n",
    "\n",
    "![crx-gate2](./figure/q-sphere_crx-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CRX(\\theta)_{q_0,q_1} = I \\otimes |0\\rangle\\langle0| + RX(\\theta) \\otimes |1\\rangle\\langle1| = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & \\cos{\\frac{\\theta}{2}} & 0 & -i\\sin{\\frac{\\theta}{2}} \\\\ 0 & 0 & 1 & 0 \\\\ 0 & -i\\sin{\\frac{\\theta}{2}} & 0 & \\cos{\\frac{\\theta}{2}} \\end{pmatrix} $$\n",
    "\n",
    "$$ CRX(\\theta_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes RX(\\theta)  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & \\cos{\\frac{\\theta}{2}} & -i\\sin{\\frac{\\theta}{2}} \\\\ 0 & 0 & -i\\sin{\\frac{\\theta}{2}} & \\cos{\\frac{\\theta}{2}} \\end{pmatrix} $$\n",
    "\n",
    "\n",
    "### 2. CRY 게이트 - Controlled RY gate\n",
    "\n",
    "CRY 게이트는 $cry(\\theta, control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 $RY(\\theta)$ 게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CRY$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.cry(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CRY 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.   +0.j  0.   +0.j -0.   +0.j  0.   +0.j]\n",
      " [ 0.   +0.j  0.707+0.j  0.   +0.j -0.707+0.j]\n",
      " [-0.   +0.j  0.   +0.j  1.   +0.j  0.   +0.j]\n",
      " [ 0.   +0.j  0.707+0.j  0.   +0.j  0.707+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state19 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state19).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CRY-게이트 [Q-sphere]\n",
    "\n",
    "![cry-gate](./figure/q-sphere_cry-gate.png)\n",
    "\n",
    "#### target 큐비트와 control 큐비트의 상태가 $|1\\rangle$일때 $CRY$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.cry(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CRY 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & \\tfrac{1}{\\sqrt{2}} & 0 & \\tfrac{1}{\\sqrt{2}}  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state20 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state20).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CRY-게이트 [Q-sphere]\n",
    "\n",
    "![cry-gate2](./figure/q-sphere_cry-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CRY(\\theta)_{q_0,q_1} = I \\otimes |0\\rangle\\langle0| + RY(\\theta) \\otimes |1\\rangle\\langle1| = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & \\cos{\\frac{\\theta}{2}} & 0 & -\\sin{\\frac{\\theta}{2}} \\\\ 0 & 0 & 1 & 0 \\\\ 0 & \\sin{\\frac{\\theta}{2}} & 0 & \\cos{\\frac{\\theta}{2}} \\end{pmatrix} $$\n",
    "\n",
    "$$ CRY(\\theta)_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes RY(\\theta)  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & \\cos{\\frac{\\theta}{2}} & -\\sin{\\frac{\\theta}{2}} \\\\ 0 & 0 & \\sin{\\frac{\\theta}{2}} & \\cos{\\frac{\\theta}{2}} \\end{pmatrix} $$\n",
    "\n",
    "\n",
    "### 3. CRZ 게이트 - Controlled RZ gate\n",
    "\n",
    "CRZ 게이트는 $crZ(\\theta, control, target)$과 같은 문법으로 사용이 되며 control 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control 큐비트의 상태가 $|1\\rangle$이면 target 큐비트에 $RZ(\\theta)$ 게이트를 실행합니다. 하지만 control 큐비트의 상태가 $|0\\rangle$인 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### target 큐비트의 상태가 $|0\\rangle$일때 $CRZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.683x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.crz(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CRZ 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.   +0.j    0.   +0.j    0.   +0.j    0.   +0.j   ]\n",
      " [0.   +0.j    0.707-0.707j 0.   +0.j    0.   +0.j   ]\n",
      " [0.   +0.j    0.   +0.j    1.   +0.j    0.   +0.j   ]\n",
      " [0.   +0.j    0.   +0.j    0.   +0.j    0.707+0.707j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기\n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state21 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state21).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control 큐비트에 CRZ-게이트 [Q-sphere]\n",
    "\n",
    "![crz-gate](./figure/q-sphere_crz-gate.png)\n",
    "\n",
    "#### target 큐비트와 control 큐비트의 상태가 $|1\\rangle$일때 $CRZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.294x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(2) #2개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.crz(pi/2,0,1) #0번 큐비트에 control 큐비트로 지정하며 1번 큐비트를 target 큐비트로 지정하는 CRZ 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & \\tfrac{1}{\\sqrt{2}}(1 - i) & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state22 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state22).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control 큐비트에 CRZ-게이트 [Q-sphere]\n",
    "\n",
    "![crz-gate2](./figure/q-sphere_crz-gate2.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CRZ(\\theta)_{q_0,q_1} = I \\otimes |0\\rangle\\langle0| + RZ(\\theta) \\otimes |1\\rangle\\langle1| = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & e^{-i\\frac{\\lambda}{2}} & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & e^{i\\frac{\\lambda}{2}} \\end{pmatrix} $$\n",
    "\n",
    "$$ CRZ(\\theta)_{q_1,q_0} = |0\\rangle\\langle0| \\otimes I + |1\\rangle\\langle1| \\otimes RZ(\\theta)  = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 \\\\ 0 & 0 & e^{-i\\frac{\\lambda}{2}} & 0 \\\\ 0 & 0 & 0 & e^{i\\frac{\\lambda}{2}} \\end{pmatrix} $$\n",
    "\n",
    "\n",
    "## 3-큐비트 게이트\n",
    "### Toffoli Gate - CCX 게이트\n",
    "\n",
    "Toffoli 게이트는 $ccx(control_0, control_1, target)$과 같은 문법으로 사용이 되며 control_0과 control_1 큐비트의 상태에 따라 target 큐비트의 결과값에 영향을 주는 조건부 게이트입니다. control_0 큐비트와 control_1 큐비트의 상태가 모두 $|1\\rangle$이면 target 큐비트에 $X$ 게이트를 실행합니다. 하지만 그 외의 모든 경우에는 target 큐비트에 어떠한 변화도 가하지 않습니다.\n",
    "\n",
    "#### control_0과 control_1 큐비트의 상태가 모두 $|0\\rangle$일때 $Toffoli$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 203.885x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(3) #3개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.ccx(0,1,2) #0번 큐비트에 control_0 큐비트로, 1번 큐비트에 control_1 큐비트로 지정하며 2번 큐비트를 target 큐비트로 지정하는 CCX 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "backend = Aer.get_backend('unitary_simulator') #unitary_simulator를 사용하여 시뮬레이션하기\n",
    "\n",
    "job = execute(qc, backend) #시뮬레이션 실행\n",
    "result = job.result() #시뮬레이션 결과 가져오기 \n",
    "print(result.get_unitary(qc, decimals=3)) #단일 행렬 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state23 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state23).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|0\\rangle$상태의 control_0과 control_1 큐비트에 CRZ-게이트 [Q-sphere]\n",
    "\n",
    "![ccx-gate](./figure/q-sphere_ccx-gate.png)\n",
    "\n",
    "#### control_0 큐비트와 control_1 큐비트의 상태가 $|1\\rangle$일때 $CRZ$ 게이트의 작동"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.496x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(3) #3개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.x(1) #1번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.ccx(0,1,2) #0번 큐비트에 control_0 큐비트로, 1번 큐비트에 control_1 큐비트로 지정하며 2번 큐비트를 target 큐비트로 지정하는 CCX 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state24 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state24).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### $|1\\rangle$상태의 control_0과 control_1 큐비트에 CRZ-게이트 [Q-sphere]\n",
    "\n",
    "![ccx-gate2](./figure/q-sphere_ccx-gate2.png)\n",
    "\n",
    "#### 그 외 경우의 $CCX$ 게이트의 작동\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.496x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(3) #3개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(0) #0번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.ccx(0,1,2) #0번 큐비트에 control_0 큐비트로, 1번 큐비트에 control_1 큐비트로 지정하며 2번 큐비트를 target 큐비트로 지정하는 CCX 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state25 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state25).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ccx-gate3](./figure/q-sphere_ccx-gate3.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 287.496x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc=QuantumCircuit(3) #3개의 큐비트를 가진 양자 회로 만들기\n",
    "qc.x(1) #1번 큐비트에 X 게이트 추가하여 |1> 상태 만들기\n",
    "qc.ccx(0,1,2) #0번 큐비트에 control_0 큐비트로, 1번 큐비트에 control_1 큐비트로 지정하며 2번 큐비트를 target 큐비트로 지정하는 CCX 게이트를 추가하기\n",
    "qc.draw(output=\"mpl\") #양자 회로 시각화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\n",
       "\n",
       "\\begin{bmatrix}\n",
       "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0  \\\\\n",
       " \\end{bmatrix}\n",
       "$$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state26 = execute(qc, StatevectorSimulator()).result().get_statevector() # 시뮬레이션에 양자회로를 넣어 실행시키기\n",
    "Statevector(state26).draw(output=\"latex\") #시뮬레이션 결과를 latex 형식으로 출력하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ccx-gate4](./figure/q-sphere_ccx-gate4.png)\n",
    "\n",
    "#### 수학적 표현\n",
    "\n",
    "$$ CCX_{q_0,q_1,q_2} = I \\otimes I \\otimes |0\\rangle\\langle0| + CX \\otimes |1\\rangle\\langle1| = \\begin{pmatrix}\n",
    "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n",
    "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n",
    "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\n",
    "\\end{pmatrix} $$\n",
    "\n",
    "$$ CCX_{q_2,q_1,q_0} = |0\\rangle\\langle0|  \\otimes I \\otimes I + |1\\rangle\\langle1| \\otimes CX  = \\begin{pmatrix}\n",
    "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\n",
    "\\end{pmatrix} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/quic/anaconda3/envs/qiskit-2x/lib/python3.8/site-packages/qiskit/aqua/__init__.py:86: DeprecationWarning: The package qiskit.aqua is deprecated. It was moved/refactored to qiskit-terra For more information see <https://github.com/Qiskit/qiskit-aqua/blob/main/README.md#migration-guide>\n",
      "  warn_package('aqua', 'qiskit-terra')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.18.2</td></tr><tr><td><code>qiskit-aer</code></td><td>0.8.2</td></tr><tr><td><code>qiskit-ignis</code></td><td>0.6.0</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.16.0</td></tr><tr><td><code>qiskit-aqua</code></td><td>0.9.5</td></tr><tr><td><code>qiskit</code></td><td>0.29.1</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.8.18 (default, Sep 11 2023, 13:40:15) \n",
       "[GCC 11.2.0]</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>24</td></tr><tr><td>Memory (Gb)</td><td>188.51050186157227</td></tr><tr><td colspan='2'>Thu Oct 05 22:55:06 2023 KST</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table #qiskit 버전 표시하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  },
  "vscode": {
   "interpreter": {
    "hash": "61e38d38e362baf74507d5f9568815ca017052702bd5356c9e3eea1ad7c412ff"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}