Lab A - First Steps.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b45c0bcf-ee88-4b8b-bc4d-c397927e7164",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "########################################\n",
    "# ENTER YOUR NAME AND WISC EMAIL HERE: #\n",
    "########################################\n",
    "\n",
    "# Name: Kevin Li\n",
    "# Email: kjli@wisc.edu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fde84ae-2739-4fd8-ac1a-54df9a34bb0e",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Qiskit Fall Fest 2023\n",
    "\n",
    "![QFF Logo](images/QFF-logo.png)\n",
    "\n",
    "## Lab A: First Steps into Quantum Computing\n",
    "\n",
    "- Difficulty: 1/5\n",
    "\n",
    "- Estimated Time: 20 Minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c7c1be5-3273-41b7-ba50-3a894425e874",
   "metadata": {},
   "source": [
    "Hi there and welcome to the **Qiskit Fall Fest**! \n",
    "\n",
    "As part of the Qiskit Fall Fest, IBM Quantum has created a series of coding challenges for you to work through. We like to call these \"labs.\" Each lab centers on a different topic. Each lab also has a difficulty, and an estimated time, which you can find in the cell above.\n",
    "\n",
    "There are dozens of different schools participating in the Fall Fest. You're part of a global event that has thousands of students learning about quantum computing. Congrats! Whether you're a beginner or a veteran, we hope you enjoy the Qiskit Fall Fest! We're glad you're here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "993d2f10-9a27-4d8e-a14b-f45189526bc9",
   "metadata": {},
   "source": [
    "In this lab we will be teaching you how to use these challenge notebooks, how to grade your work, and the very first steps of writing a quantum circuit.\n",
    "\n",
    "To complete this lab, you should know a little bit about the coding languange Python. Each lab will contain a mixture of tutorial content, pre-written code blocks, and challenge code blocks which will require you to fill in your own Qiskit code (which is written in Python). The code required to complete the exercise should be typed under the line which has the `## Write your code below here ##` comment.\n",
    "\n",
    "If you've never used the IBM Quantum Labs before, it's important to note that you should run every code cell, even if you didn't write any new code within. This makes sure that when you submit your answers later on, everything is up to date."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b41be5a-4296-4dc8-8e16-254348c7c816",
   "metadata": {},
   "source": [
    "If you are running this lab on the [IBM Quantum Lab site](https://lab.quantum-computing.ibm.com/), you're good to continue on. If you're running in Google Colab, a local coding environment, or anywhere else, you'll need to properly install Qiskit.\n",
    "\n",
    "It's easiest if you open this jupyter notebook in the IBM Quantum Lab (which conveniently has Qiskit installed already for you), however you could use any other site or program that can open a jupyter notebook. Just make sure to follow the directions in the #Readme file that was included in the zip file of labs, to make sure you have Qiskit and the grader client properly installed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e477331b-05dd-42d1-a319-df81ba0527d0",
   "metadata": {},
   "source": [
    "Let's write some very basic code, so you can see how the labs work! \n",
    "\n",
    "In the code block below, re-write the answers for your name, age, and school next to each variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4cd2d61c-d3e9-42c3-8b8c-733374c441b8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "event = \"Qiskit Fall Fest\"\n",
    "\n",
    "## Write your code below here. Delete the current information and replace it with your own ##\n",
    "## Make sure to write your information between the quotation marks!\n",
    "\n",
    "name = \"Kevin\"\n",
    "\n",
    "age = \"20\"\n",
    "\n",
    "school = \"UW-Madison\"\n",
    "\n",
    "## Now press the \"Run\" button in the toolbar above, or press Shift + Enter while you're active in this cell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fda328c-ef67-4333-a5e4-9e3d993ab1d5",
   "metadata": {},
   "source": [
    "Make sure you pressed the \"Run\" button, or press Shift + Enter, when you were active in the cell above ^^ If you're in the IBM Quantum Lab site, you can tell which cell is active by the verticle blue line that appears on the left edge of the cell.\n",
    "\n",
    "Remember, you always should run every code cell, even ones you didn't add any new code into, to make sure things run properly.\n",
    "\n",
    "To make sure things are working properly, let's try to call those variables in the next cell!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "102ea3c6-5b72-487c-b66c-7d93250d6836",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Kevin, I am 20 years old, and I attend UW-Madison.\n"
     ]
    }
   ],
   "source": [
    "## You do not need to write any code in this cell. Simply run this cell to see your information in a sentence. ##\n",
    "\n",
    "print(f'My name is {name}, I am {age} years old, and I attend {school}.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ffa9a7a-fe9d-4e6b-bab4-b9c86bb67c33",
   "metadata": {},
   "source": [
    "When you ran the cell above, you should see a sentence appear directly below it with all your information. \n",
    "\n",
    "Does it look correct? If so, nice job! If not, go back to cell 6 and double check that you filled everything out correctly between the quotation marks. Remember to run the cell after you made your changes!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "44c807e2-c45e-483a-9676-d651d39283e6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: QC_GRADE_ONLY=true\n",
      "env: QC_GRADING_ENDPOINT=https://qac-grading.quantum-computing.ibm.com\n"
     ]
    }
   ],
   "source": [
    "## Run this cell to make sure your grader is setup correctly\n",
    "\n",
    "%set_env QC_GRADE_ONLY=true\n",
    "%set_env QC_GRADING_ENDPOINT=https://qac-grading.quantum-computing.ibm.com"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6715d89a-6566-452a-8fca-82fb126f9bed",
   "metadata": {},
   "source": [
    "## Part 1: What is Qiskit?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65fc2fc1-1e69-4805-87fd-de8c8cb7ab62",
   "metadata": {},
   "source": [
    "The Qiskit Fall Fest is an awesome event, happening on your campus, with your classmates and friends. But this is just one small part of the entire Qiskit ecosystem.\n",
    "\n",
    "**Qiskit** is open-source software for working with quantum computers at the level of circuits, pulses, and algorithms.\n",
    "\n",
    "The central goal of Qiskit is to build a software stack that makes it easy for anyone to use quantum computers, regardless of their skill level or area of interest; Qiskit allows anyone to easily design experiments and applications and run them on real quantum computers or classical simulators. Qiskit is already in use around the world by beginners, hobbyists, educators, researchers, and commercial companies.\n",
    "\n",
    "The fundamental unit of Qiskit is the **quantum circuit**, which is a series of instructions that a quantum computer can use to work with quantum bits of information, also known as **qubits**. These qubits have special properties that enable quantum computers to approach problems differently than how your laptop or iPhone might. \n",
    "\n",
    "We're breezing through this overview because, honestly, we could spend hours just explaining the basics of quantum information and computation. In fact, IBM Quantum has done this already, producing a [written course](https://learn.qiskit.org/course/basics/single-systems) and a series of [video lectures](https://www.youtube.com/playlist?list=PLOFEBzvs-VvqKKMXX4vbi4EB1uaErFMSO) devoted to the topic. If you need a refresher, check them out!\n",
    "\n",
    "So back to Qiskit. A basic workflow using Qiskit consists of two stages: **Build** and **Execute**. Build allows you to make different quantum circuits that represent the problem you are solving, and Execute allows you to run those quantum circuits on different backends, including simulators, which is what we're be using. After the jobs have been run, the data is collected for you to see.\n",
    "\n",
    "In this first part, we're going to build a simple circuit, and execute it on a simulator. We tend to use simulators during tutorials because they can run instantly. IBM has dozens of quantum computers that can be accessed via the cloud, but *because* anyone around the world can use them, there are sometimes wait times. Let's avoid that and begin!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "318b4603-2e54-467a-b2a8-213100d867ce",
   "metadata": {},
   "source": [
    "### Your First Quantum Circuit\n",
    "\n",
    "To make a quantum circuit, we first need to build it. This is the hard part. Executing that circuit is honestly really easy! So to get started, we already built the circuit for you. Let's look at what happens when you run that circuit.\n",
    "\n",
    "Below we have created a quantum circuit with 3 qubits and 3 classical bits using the `QuantumCircuit()` function. We also included the method `qc.draw()` which will create a drawing of the circuit for us to see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "263143bf-eb3c-4d1c-9795-c4f03d775966",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 162.08x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "# Create quantum circuit with 3 qubits and 3 classical bits\n",
    "# (we'll explain why we need the classical bits later)\n",
    "qc = QuantumCircuit(3,3)\n",
    "\n",
    "# return a drawing of the circuit\n",
    "qc.draw()  \n",
    "\n",
    "## You don't need to write any new code in this cell, just run it"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e25388c-5682-42e3-b3f3-67dac17040c9",
   "metadata": {},
   "source": [
    "Jupyter notebooks evaluate the last line of a code cell and display it below the cell. Since `qc.draw()` returns a drawing, that’s what we’re seeing under the code. There are no other instructions in our circuit yet, so we just see some horizontal lines. Each line next to a Q represents one of our qubits.\n",
    "\n",
    "We need a way to tell our quantum computer to measure our qubits and record the results. To do this, we add a \"measure\" operation to our quantum circuit. We can do this with the QuantumCircuit's `.measure()` method. We've put two arrays inside the method, telling qubits 0, 1, and 2 to be measured to the classical bits 0, 1, and 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "62bf6b9d-0553-445e-9190-36b749f4cce6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATEAAAEvCAYAAAAtufaDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAif0lEQVR4nO3de1SUdf4H8PcMAwwDKOClQTARBcUbKHhLDXHVRGAxXUuz0mI1TUXdBG+nPJ4t76dTarZqlmWbuZm6mprVqslqZWC4/sRSUAyQMVkvMFxEmOf3hzHryAwyw9y+w/t1zhxnnsv3+TwFb77P97mMTJIkCUREgpI7ugAioqZgiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJTOLoAMk6SJFRUVDi6jEZTqVSQyWSOLoOaIYaYk6qoqICPj4+jy2g0rVYLb29vR5dBzRAPJ4lIaAwxIhIaQ4yIhMYQIyKhMcSISGgMMSISGkOMiITGECMioTHEiEhoDDEiEhpDjBpNLuePCzkf3jvp4jw8PNCzZ09ER0dDrVbDw8MD1dXV0Gg0yMrKwtmzZ1FdXf3QdtLS0jBs2DCMGTMGd+7csUPlRI3DEHNBbm5uSEpKwowZMzB06FB4eHiYXLa6uhrHjh3Du+++i/3796O2trbeMmlpaVi9ejUAYO/evUhMTDS6HJEjNIvjg5KSEqSnp6Nz585QKpVo37495syZg/LycqSkpEAmk2HDhg2OLtMqJk+ejMuXL2PPnj0YOXJkgwEG3OupjRw5Env27MHly5cxZcoUg/n3BxgAfPvttwwwcioySZIkRxdhS9nZ2YiPj4dGo4G3tzfCw8Nx9epVXLt2DQkJCbhx4wa+++47ZGRkYPDgwY4uV6+8vNysR/G0a9cOmzdvRkJCgsH0/Px8ZGRkIDMzExcvXkRVVRWUSiXCwsIQHR2Nxx9/HCEhIQbrHDhwANOmTcOkSZMMAmzRokVYuXKl0e3zUTzkMJILu379uhQcHCwBkF555RWptLRUP2/VqlUSAEmhUEgymUy6ffu2AyutT6vVSgAa9YqJiZGuX79usP7+/fulkSNHSjKZrMF1ZTKZNHLkSGn//v31tn+/hQsXNtjOg8sT2YtLh9jEiRMlANKsWbOMzo+MjJQASB07drRzZQ/X2BCLiYkxCOCioiIpMTGx0QF4/ysxMVEqKiqqV8vDAowhRo7ksiGWk5MjyeVyqXXr1lJZWZnRZV588UUJgDRmzBiD6ZcuXZKSkpIkHx8fyc/PT3ruueekkpISe5St15gQCwoKMqjr6NGjkr+/v0UBVvd67bXX6tURFBTEECOn5bID+zt27IBOp8OkSZNMji15eXkBACIjI/XTysrKEBcXh8LCQuzYsQObN29GRkYGEhMTodPp7FJ7Y23ZsgWtWrUCABw7dgzx8fG4efOmxe2lpaVh2bJlBtO8vb2xefPmJtVJZFOOTlFbGTRokARA2rt3r8llkpOTJQDS7t279dPWrl0rKRQK6cqVK/ppJ0+elABIe/bssWXJBh7WE5syZYp+2cLCQsnPz69JPbC0tDSD7S9btszg0HLKlCnsiZFTctmzk+3bt0dhYSF++uknREVF1ZtfU1ODwMBAlJSUIC8vD6GhoQCAuLg4AMDRo0cNlu/UqROGDh2KrVu3ml1LTEwMNBqNWevodDoUFxcbnadQKJCfn4+goCAAQEJCAg4ePGh2XXUevIyi7ixkQkICvvjiCwBAYWEhQkJCTF5eERgYyCv6yWJqtRqZmZmWrezoFLWVurGhkydPGp3/8ccfSwAkX19fSafT6ae3bdtWmjlzZr3lk5KSpAEDBlhUS2PGlMx5Pfnkk/q29+3bZ9Ue2IOD+Pv27dPPGzNmjFX3gy++6l5BQUEW/W5JkiS57BX7arUaN2/exOnTpzFw4ECDecXFxUhLSwMA9OrVy+D7Em/evAk/P7967QUEBOCXX36xuBZzNdQTmzFjhv79+vXrLaoJMN0Du9+GDRuQlJQEAHj55Zexd+9eo22xJ0ZNYcnviJ7F8efkZs+eLQGQ2rdvL/3yyy/66adOnZK6dOkiubu7SwDq9brc3d2lJUuW1Gtv8uTJUnh4uM3rrmNqTMzT01Oqrq6WJOneWdSHXQdm6vWwHljdSyaTSZcuXZIkSZLu3LkjeXh4GF2OY2LkKC77pzM9PR2tWrVCQUEBunfvjp49eyIsLAz9+vVDaGgohg0bBsDwzCQA+Pv749atW/Xau3HjBgICAuxReoN69uwJd3d3AMDx48chWTCk2ZgeWB1JkpCRkQHgfzeTEzkTlw2x4OBgZGRkICEhAUqlEvn5+QgICMCmTZtw4MABXLhwAUD9EIuIiEBOTk699nJychAREWGX2hvSp08f/fusrCyz1zcnwIxtJyYmxuxtEtmSy46JAfcCqe7s2v20Wi3y8/Mhl8vRo0cPg3mJiYlYvHgxCgsLERwcDAD44YcfkJeXhzVr1til7oa0a9dO/74uiBvLkgADYDAWGBgYaNY2iWzNpUPMlHPnzkGSJISHh0OlUhnMmzZtGtavX4/k5GQsW7YMVVVVSE9PR79+/ZCcnOygiv/n6NGj0Ol0UCqVyM3NbfR6/fv3tyjAACA3NxcrVqxAVVUVvv32W7NrJrIpB4/JOcSWLVskANJTTz1ldH5ubq6UkJAgeXt7Sy1btpQmTZok/fbbb3at0ZwbwBv7WrRokSRJjbsX0twXB/bJUZplT+zs2bMA6o+H1enUqZPRw1DRrVixAkePHsX333/v6FKIrMZlB/Yb8rAQc2UMMHI1LnvbkejMfSiio/GhiOQozbInRkSugyFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQeO+kk5IkCRUVFVZpa82mT1FaXoEW3iqkvTTB5LSmUKlUBl+4QmQvzfJRPCKQyWRWu6Haw1MJj7u18PBU6ts0No1IRDycJCKhMcSISGgMMSISGkOMiITGECMioTHEiEhoDDEiEhpDjIiExhAjIqExxIhIaAwxIhIaQ4yIhMYQIyKhMcSISGgMMSISGkOMiITGECMioTHEiEhofDw1OSVrfseAvfB7BhyDIUZOqaKiAj4+Po4uwyxarZbfV+AAPJwkIqExxIhIaAwxIhIaQ4yIhMYQIyKhMcSISGgMMSISGkOMiITGECMioTHEiEhoDDFqFmQyGdRqNUJDQxESEoKAgACz1lcoFFi4cCE8PT1tVCFZivdOksvq3bs3Jk6ciJiYGPTp0wctW7Y0mH/16lVkZWXhu+++w0cffYSioiKj7SgUCuzcuRNjx45FbGwsxowZgzt37thjF6gRmkVPrKSkBOnp6ejcuTOUSiXat2+POXPmoLy8HCkpKZDJZNiwYYOjyyQrkMlkmDhxIk6ePInTp08jLS0NcXFx9QIMANq1a4ekpCQsX74c+fn5+Pzzz/HYY48ZLHN/gAFAbGwsIiMj7bIv1Dgu3xPLzs5GfHw8NBoNvL290a1bN1y9ehXr1q1DXl4ebty4AQCIiopybKHUZCEhIdi6dSuGDRtWb15hYSHOnDmDW7du6Q8t+/TpAz8/PwD3wmrs2LEYO3Ys3nnnHSxYsAB37twxCLDKykokJyfj1KlT9twtegiXDrGSkhIkJSVBo9HglVdewdKlS+Hr6wsAWL16NRYsWACFQgGZTIZevXo5uFpqigkTJmDLli0Gj+85c+YMNm7ciH/+85+4du2a0fXCwsLwzDPPYNq0aWjXrh0AYObMmRg9ejQuXbqEP/zhDwD+F2Bff/217XeGzOLSh5OpqakoLCzErFmzsHbtWn2AAUB6ejoiIyNRU1ODkJAQtGjRwoGVUlNMmzYNO3bs0AfYlStXMGrUKERFRWHz5s0mAwwALl68iGXLlqFDhw6YPXs2ysvLAQAdO3ZkgAnCZUPs/Pnz2LlzJ1q3bo0VK1YYXSY6OhoADMY46kKvX79+8PT05JM6ndyECROwadMm/edt27ahZ8+eOHz4sFnt1NTUYMOGDejTp49+iAG494TZ1NRUBpgTc9kQ27FjB3Q6HSZNmmTyCaFeXl4ADEMsNzcXn3/+OdRqNfr27WuXWskyISEh2LJli/7zqlWr8MILL6CsrMyi9hQKBVasWGFw+YVMJsOsWbPg7u7e5HrJNlw2xI4cOQIAiIuLM7lMYWEhAMMQe/zxx1FcXIx9+/Zh+PDhti2SLCaTybB161b9H6ht27Zh4cKFFrf34FnIyspKXLp0CcC9n48lS5Y0vWiyCZcNsStXrgAAOnToYHR+TU0NTpw4AcAwxORyl/1P4lImTpyoPwt55coVpKamWtyWsQBLTk7GuHHjcPfuXQDA4sWLERoa2vTCyepc9uxk3QBtZWWl0fk7d+5ESUkJfH190bFjR5vWEhMTA41GY9NtNOTJF+bC26cFijXFCA4ONjnNmeh0ugbnz549W//+pZdeatIhpLEAqxsDW716NZYsWQJ3d3e89NJLWLBggcm2wsLC+EfQQmq1GpmZmRat67IhplarcfPmTZw+fRoDBw40mFdcXIy0tDQAQK9evWw+eK/RaExeDW4Putpa/b91dRibJoo+ffpgwIABAO5dB2juIH6dhwUYALz99tuYP38+PD09kZKSgqVLl6Kqqspoe8XFxRbVQU3jsiE2fPhwnD9/HqtWrcKIESMQHh4OAPjxxx/x3HPPoaSkBIB9LnJVq9U230ZD5G5u+n+DgoJMTnMmOp3OZChMmDBB/37jxo0Wtd+YAAOA69ev47PPPsOzzz6LVq1aYcSIEdi/f7/RNgMDA9kTs1BTfkdcNsTS09PxySefoKCgAN27d0fXrl1RVVWF3NxcxMfHIyQkBIcPH7bLLSSWdpOtZfk7f0epthyB6kD9yQxj05xJeXm5ybPK95813rt3r9ltNzbA7t/Gs88+C+De0ICpELt48SK/d9IBXPbPRnBwMDIyMpCQkAClUon8/HwEBARg06ZNOHDgAC5cuAAAvA9OMDKZDH369AEAFBQU4Pr162atb26AAUBWVpb+fd21heQ8XLYnBgARERH44osv6k3XarXIz8+HXC5Hjx49HFAZWSowMFB/d8WZM2fMWteSAAOA/Px83L59Gy1btkRERIRlhZPNuHSImXLu3DlIkoTw8HCoVKp683ft2gUAyMnJMfgcEhKCmJgY+xVK9SgUCuTm5sLLywsFBQWNXk8mk+HTTz81O8DqXLp0Ca1bt+bgvRNqliF29uxZAKYPJcePH2/08+TJk7Ft2zab1kYN+/XXXxEWFmb2epIkITMzE+PGjbPoXsi6Q1hyPgwxIyRJsmc5ZCcrV65ETU0Nzpw5w3shXQhDjJqVtWvXOroEsrJmGWJ191USkfhc9hILImoeGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmuWN4CT81OpVNBqtVZrb82mT1FaXoEW3iqkvTSh3mdrMPaATbI9hhg5JZlMZtUv3fDwVMLjbi08PJXw9vau95nExcNJIhIaQ4yIhMYQIyKhMcSISGgMMSISGkOMiITGECMioTHEiEhoDDEiEhpDjIiExhAjIqExxIhIaAwxIhIaQ4yIhMYQIyKhMcSISGgMMSISGp/sSuSEJElCRUWFo8swi0qlgkwms/t2GWJETqiiogI+Pj6OLsMsWq3WIY/65uEkEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRUaO0bdsWnp6eji6jHt47SeTCAgIC0L9/f0RHR6N3797w9/eHQqFAVVUV8vLykJmZiaysLJw5cwaSJJlsR61W4+jRo8jPz8eYMWNw584dO+5FwxhiRC5oyJAhmDFjBsaNGwcPDw+jy4wYMUL/Pi8vD3/729/wwQcf4L///a/BcnUB1rVrV3Tt2hUbNmzA1KlTbVq/OZrF4WRJSQnS09PRuXNnKJVKtG/fHnPmzEF5eTlSUlIgk8mwYcMGR5dJ1GRhYWHIyMjA8ePHMXHiRJMB9qBOnTphzZo1KCgowPz58yGX34uG+wMMAC5fvozXX3/dZvVbwuV7YtnZ2YiPj4dGo4G3tze6deuGq1evYt26dcjLy8ONGzcAAFFRUY4tlKiJ5s6di+XLl8PLy0s/7bfffsOOHTvw/fffIysrCwUFBaitrYWPjw969OiB6OhoxMfHY+TIkQAALy8vrFmzBmPHjsX8+fOxdetWgwCLi4vDlStXHLJ/prh0iJWUlCApKQkajQavvPIKli5dCl9fXwDA6tWrsWDBAigUCshkMvTq1cvB1RJZRi6XY9OmTfjzn/+sn5abm4ulS5di165dqK6urrfOzZs3kZGRgYyMDLz11lvo3Lkz5s2bh+nTp0Mul2PgwIE4fvw43NzcADhvgAEufjiZmpqKwsJCzJo1C2vXrtUHGACkp6cjMjISNTU1CAkJQYsWLRxYKZHlNm/ebBBgb7/9NiIjI/HJJ58YDTBjcnNzMXPmTAwZMgR5eXkAoA+woqIipw0wwIVD7Pz589i5cydat26NFStWGF0mOjoaABAZGamftmvXLowbNw4dOnSASqVC165dsWTJEmi1WrvUTWSOefPmISUlBQBQXV2N8ePHY+7cuRY/2vrSpUuora01mKZQKFBaWtrkWm3FZUNsx44d0Ol0mDRpksnH/NaNHdwfYmvXroWbmxuWL1+OQ4cOYcaMGXj33XcxatQo6HQ6u9RO1Bjh4eF44403AED/s75r1y6L26sbxA8PDwcAVFVVAQAeeeQRvPXWW02u11ZcdkzsyJEjAIC4uDiTyxQWFgIwDLH9+/ejTZs2+s+xsbFo06YNJk2ahH//+994/PHHbVQxkXm2bt2q/0O8bt06qwTY/YP4EyZMwOHDh+Hn54fnn38en376KQ4dOmSV2q3JZUOs7vi9Q4cORufX1NTgxIkTAAxD7P4AqxMTEwPg3tiAJWJiYqDRaCxa1xqefGEuvH1aoFhTjODgYJPTXNmD++vs+/+wXv+QIUMwePBgAPfGsxYvXmzxtowFWN0Y2Ny5c7Ft2zYAwKJFixoMsbCwMP2lGZbUkJmZadG6Lhti5eXlAIDKykqj83fu3ImSkhL4+vqiY8eODbZ19OhRAEBERIRFtWg0GosD0Bp0v49x6Gpr9XUYm+bKHtxf0ff/5Zdf1r9funSpyZ/zh2kowADgww8/RFpaGrp3744hQ4agZ8+eOHv2rNG2iouLLaqhqVw2xNRqNW7evInTp09j4MCBBvOKi4uRlpYGAOjVq1eD35VXVFSEV199FaNGjbL4WjK1Wm3RetYi//0sk9zNDUFBQSanubIH99fZ91+n05kMhVatWmHcuHEA7l0HZulh5MMCrM7GjRvxzjvvAACmTp2K1NRUo+0FBgY2qSdmKZcNseHDh+P8+fNYtWoVRowYoR+s/PHHH/Hcc8+hpKQEQMMXuWq1WiQnJ8PDwwPvv/++xbVY2k22luXv/B2l2nIEqgP144DGprmyB/fX2fe/vLzc5Amp/v37w93dHQDMuozifo0NMADYvn071q1bBzc3NwwZMsRkmxcvXuT3TlpTeno6WrVqhYKCAnTv3h09e/ZEWFgY+vXrh9DQUAwbNgyA4XjY/SorK5GUlITLly/jq6++QmBgoD3LJzKp7tIgAPj+++/NXt+cAAOAsrIy5OTkAAC6d+8OpVJpQdW247IhFhwcjIyMDCQkJECpVCI/Px8BAQHYtGkTDhw4gAsXLgAwHmJ3797Fn/70J2RmZuLQoUPo1q2bvcsnMql3797691lZWWata26A1ak7mnB3d0ePHj3MrNi2XPZwErg3EP/FF1/Um67VapGfnw+5XF7vf0jd9Tb/+te/cPDgQfTr189e5RI1SkBAgP79r7/+2uj1LA0wACgoKNC/9/f3N6Na23PpEDPl3LlzkCQJ4eHhUKlUBvNmzpyJzz77DAsXLoRKpTLornfq1MnoJRhE9pSamorWrVtDqVSaNR72xz/+0eKbuT/++GOcPHkSlZWV+M9//mNR3bbSLEOs7hSxsUPJuutgVq5ciZUrVxrM++CDDzBlyhSb10fUEEtDZPPmzWjVqhWmTp1q9r2QFy9exMWLFy3arq0xxB6Qn59v52qI7GfFihXYsGEDysrKHF2K1bjswH5DGgoxIlfnSgEGNNOeWN19lUQkvmbZEyMi18EQIyKhMcSISGgMMSISGkOMiITGECMioTHEiEhoDDEiEhpDjIiExhAjIqExxIhIaM3y3kkiZ6dSqaz6rfNrNn2K0vIKtPBWIe2lCfU+W8ODz+azF4YYkROSyWRW/dIND08lPO7WwsNTCW9v73qfRcbDSSISGkOMiITGECMioTHEiEhoDDEiEhpDjIiExhAjIqExxIhIaAwxIhIaQ4yIhMYQIyKhMcSISGgMMSISGkOMiITGECMioTHEiEhoDDEiEhpDjIiExhAjIqExxIhIaAwxIhIaQ8wJbN++HdHR0fD394eXlxciIiLw5ptvQpIkR5fWoIMHDyIqKgqenp4ICQnBm2++6eiS7Or48eNITk5Ghw4dIJPJ8Prrrzu6JLtZs2YNBg4cCH9/f/j5+WHw4MH48ssvHVILv7LNCbRt2xavvvoqunTpAk9PT2RkZODll1+Gm5sb5syZ4+jyjMrMzERycjLmz5+PHTt24IcffsD06dOhUqkwffp0R5dnF1qtFt26dcMzzzyDuXPnOrocuzpy5AhefPFF9O3bFyqVCu+99x4SExPx7bffYtCgQXathSHmBJ544gmDz6Ghodi7dy+OHTvmtCH25ptvom/fvlixYgUAICIiAufOncPKlSubTYiNHj0ao0ePBgAsWLDAwdXY16FDhww+r169Gl9++SV2795t9xDj4aSTkSQJp06dwokTJxAXF+fockw6ceIERo0aZTBt1KhRuHLlCgoLCx1UFTmKTqdDaWmpQ76Ilz0xJ3H79m0EBQWhuroaOp0OS5cuRWpqqtnt/Hr1N1TdqTaYVlNbq//3wuVCk9MAQOnpgUfbtX3odoqLi6FWqw2m1X0uLi5GcHCw2bVbw+1SLa7991a96Q/ur6n9B4CQoEfg4eFu81ptQafTIe/KVTw4mmrO/vu39EGbAD+ztrt8+XLcunUL06ZNs7R0izHEnISvry+ys7NRUVGBkydPYtGiRWjXrh1SUlLMaufW7TJ8su9fRudVVFbh/X8cbHDaM8nDGxVizsrdwx27Dn6LUm250fkP7u+Dn7uEtkdYSJDN67QVuVyOnNwr+O70OaPzH7b/7u4KzHlhnFnb3LhxI5YvX459+/Y55I8XDyedhFwuR+fOndGrVy9Mnz4d6enpWLJkidnt9IrohKhunS2qIapbZ/TqGtqoZQMDA6HRaAymXbt2TT/PUVRKT4xPiLV43XHxsZDJZFauyr7ih/ZHm4CWFq2bOGwAWvs3ft21a9ciLS0N+/btw/Dhwy3aZlMxxJyUTqdDVVWVResmjxiElr7mjU209PVG8ojGD8gOGjQIhw8fNpj25ZdfokOHDg47lKwTFhKMx6J7mL3ek08MQQsflQ0qsi8PdwWeSoyD3Mww7hLaHv0iIxq9/GuvvYZly5bh4MGDDgswgCHmFJYuXYpvvvkGly5dwi+//IItW7Zg1apVmDx5skXteSk9MX70ULPWGT96KLyUno1eft68eTh16hSWLFmCn3/+GR9++CHWr1+PhQsXmlmtbcTH9jNrXKd39zD0bGQvtI5Wq0V2djays7NRXV0NjUaD7Oxs5Obmmlmt9bUPbIthj/Vp9PIqL0/8yYxe6Ny5c7FmzRps374dXbp0gUajgUajwe3bty0t2WIyydmvqGwG5s2bh/3796OoqAhKpRKhoaF48cUXMX36dLi5uVnc7v5vTuJE1v89dLlBMT2Q9IfHzG7/wIEDWLx4MX7++Weo1WrMmTMHf/nLXywp1SYKi69j48d7odM1/CPe0tcb81LGQ+npYVb7x44dM3oGOTY2FseOHTOrLVuordXhb3//JwqKrz902WfHjECPLh0b3bapsJs8eTK2bdvW6HasgSHmwu7ercH6D3fjNyNn6+q0beWH2ZPHwt3dNc/x/OvEaXz978wGl5k6IRGdOrSzU0X2df3GLaz74HPcrak1uUyfHmF4KsF5L+d5GB5OCqag+DdUVN1p1LLu7go8nTgMcrnxv5pyuQxPJw5z2QADgKEDo9A+0PTZ1sExPV02wACgTYAfRscNMDnfr4UP/jjcvhenWhtDTCA1tbX4eM/XWPXuJ/i16Fqj1glSt8bwQdFG5w0fFI0gdWtrluh03ORyPJ0YZzSo27byxxOxfR1QlX0N6N0N4R3rn2yRARifMNTsw2hnwxB7QG1tLbZv346RI0eiTZs28PT0xKOPPopRo0bhvffeQ22t6W65rWWd/QW3y8rh4eGOwLatGr1e7ICoetd+PdruEcQOiLJyhc6pdUBLJDzQG3GTy/F0UhzcFa7bC60jk8nwp/jYeiduBvfthU6Pit8LZYjdp7S0FCNGjMDzzz+Pr7/+Gh4eHoiMjIROp8NXX32FqVOnoqyszCG11dTW4sjJnwAAQ/tHmXUI6CaX46n7eiP3TsEPhZu8+fzv7x8VgS6h7fWfhw+ORtAjrt0LvV8LX288OXKw/vMjrf0x8vEYB1ZkPc3np7gRUlJScPToUQQHB+PIkSMoKirCqVOnUFhYiOLiYrzxxhtwd3fM7Sh1vTBfHxX6RXY1e/3W/i2ROOxebyRh2ECzLmh0BTKZDOPiY6FSeqJD0COI7R/p6JLsru5CaP0htov0Qnl28ndZWVmIiYmBQqHATz/9hB49zL9Y0pT1H+5GmbayCS1IKCuvhCRJUHp6wMPCIJUkCdV3a+DhrhD+qnRL3a2pgZtcDnkz6oXeT5Ik3K2psfhnyFZ8fbwwe/JYi9Z1jSi2gr179wIAEhISrBpgAFCmrTR5L5+5qu5U17vB21x3qpu2PomvqT9DzoQh9rucnBwAwMCBA63etq+PVxPWtk4vjMiZNeV3hCH2u9LSUgBAy5bWHyuytJsMAD9kn8eewxnw9VEhfdoEl76mi8gS/I34XYsWLQDAJvd+WT4mdq8XBty7+n7N5p3WLYzISXBMzAq6d++O3bt347vvvrN629YYE7PGWBiRK2KI/e7JJ5/EX//6Vxw8eBA5OTno1q2b1dq27HifY2HUfDRlTIyXWNzn6aefxj/+8Q88+uij+OijjxAb+7+H6127dg3vv/8+UlNT7fIccY6FETUOQ+w+paWlSE5O1j9GJSgoCO3atUNxcTGKioogSRJu3rwJPz8/m9ZRU1uLtZt34lapFkl/eAyDYqx7yQeRK2meV/yZ0KJFC3zzzTfYunUrhg4dioqKCpw5cwZyuRxPPPEEtm7dCl9fX5vXkXX2Am6Vai2+Op+oOWFPzAn9dO4iDh07hdj+keyFET0EQ8xJ3a2pgQwyKBSWP9mVqDlgiBGR0DgmRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQkNIYYEQmNIUZEQmOIEZHQGGJEJDSGGBEJjSFGREJjiBGR0BhiRCQ0hhgRCY0hRkRCY4gRkdAYYkQktP8HIFK2X2xtcm0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 371.107x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "qc = QuantumCircuit(3,3)\n",
    "\n",
    "# measure all the qubits\n",
    "qc.measure([0,1,2], [0,1,2])\n",
    "\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93854613-3995-4430-96bd-3c1db59ed6fe",
   "metadata": {},
   "source": [
    "Great! So when we measure the qubits, we knock them out of any unique quantum state they may be in. When we measure a qubit, we get a classical bit of data, a zero or a one. That's why we include the classical bits when we create a new `QuantumCircuit()` object. \n",
    "\n",
    "Next, let's see what the results of running this circuit would be. To do this, we'll use a quantum simulator, which is a standard computer calculating what an ideal quantum computer would do.\n",
    "\n",
    "Simulating a quantum computer is believed to be difficult for classical computers, as the best algorithms we have grow exponentially with the number of qubits. As such, these simulations are only possible for circuits with small numbers of qubits (up to ~30 qubits), or certain types of circuits for which we can use some tricks to speed up the simulation. Nevertheless, simulators are very useful tools for designing smaller quantum circuits.\n",
    "\n",
    "Let's import Qiskit’s simulator (called Aer), and make a new simulator object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "612b6ffd-1425-4488-b52e-64fed0c82ec6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit.providers.aer import AerSimulator\n",
    "\n",
    "# make a new simulator object\n",
    "sim = AerSimulator()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d618f42d-a9f2-4071-9b6f-3db20f3656be",
   "metadata": {},
   "source": [
    "To do the simulation, we can use the simulator’s `.run()` method. This returns a \"job\", which contains information about the experiment, such as whether the experiment is running or completed, the backend it ran on, and (importantly for us), the results of the experiment.\n",
    "\n",
    "To get the results from the job, we use the results method, and the most popular way to view the results is as a dictionary of \"counts\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7aacf3f4-424a-494f-9bce-9572cb02d82d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'000': 1024}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = sim.run(qc)      # run the experiment\n",
    "result = job.result()  # get the results\n",
    "\n",
    "result.get_counts()    # interpret the results as a \"counts\" dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "340bc050-60e2-4c49-ada3-e79e1732c367",
   "metadata": {},
   "source": [
    "The number on the left (000) is called a **key**, and the number on the right (1024) is a called a **value**. The key tells us what each of our three qubits got measured as, and the value is the number of times that specific result was measured. \n",
    "\n",
    "#### *Why did we measure the exact same thing - '000' - every time?* \n",
    "By convention, qubits always start in the state 0. This is their ground state. To change a qubit's state, you need to add energy to it. You can do this by adding various gates to the circuit. When you add gates to the circuit, you start changing the value of the qubit. Since we aren't adding any gates to our three qubits, the result stays zero for each.\n",
    "\n",
    "#### *Why did we run this circuit 1024 times?* \n",
    "Quantum computers are still very new, and can have randomness in their results. It's common to repeat your circuit a few times (or a few hundred) to compare your results. This circuit was repeated 1024 times, which is the default number of times to repeat a circuit in Qiskit. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa8874b0-a028-4364-88d9-51b1cd23ccd0",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "**YOUR TASK:** Using what you just learned, make a new variable called `qc` and use it to create a quantum circuit with 4 qubits and 4 classical bits. Then, measure those qubits to each classical bit. Do all of this in the cell below. \n",
    "\n",
    "After you do this, we provided code in the following cell to run your job on a simulator, get the results, and get the counts. For an extra challenge, try to do this yourself.\n",
    "\n",
    "Hint: You're just reusing the same commands we learned above, all together in one cell. You should only need to refer to the above tutorials to complete Exercise 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f3a892b3-b0c7-4a9a-b520-7da971c63a83",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 454.719x451.5 with 1 Axes>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from qiskit.providers.aer import AerSimulator\n",
    "\n",
    "\n",
    "## Write your code below here ##\n",
    "qc = QuantumCircuit(4, 4)\n",
    "qc.measure([0,1,2,3], [0,1,2,3])\n",
    "\n",
    "## Do not modify the code under this line ##\n",
    "\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50ff5dc3-82a8-4f14-b502-358e78cd341f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sim = AerSimulator()   # make a new simulator object\n",
    "job = sim.run(qc)      # run the experiment\n",
    "result = job.result()  # get the results\n",
    "\n",
    "answer1 = result.get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c84481af-fd8c-48bf-8fa0-68e50af0a8d9",
   "metadata": {},
   "source": [
    "After each exercise we'll need to figure out if what you wrote is correct. To do this, you simply run a grader cell. You don't need to add any code to the grader cell. Once you run it, a message will appear underneath it letting you know if you completed the exercise correctly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cf751fc9-56b2-4fb7-bdc2-83b6029ddf6d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading your answer. Please wait...\n",
      "\n",
      "Congratulations 🎉! Your answer is correct.\n"
     ]
    }
   ],
   "source": [
    "# Grader Cell: Run this to submit your answer\n",
    "\n",
    "from qc_grader.challenges.fall_fest23 import grade_ex1a\n",
    "\n",
    "grade_ex1a(answer1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90d340b8-95aa-4218-9864-916e3f1fd1e1",
   "metadata": {},
   "source": [
    "Nice job, you have now successfully created a quantum circuit which does absolutely nothing. Congrats! Let's get a little more ambitious..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32793200-b916-46bd-96f7-623a7b292996",
   "metadata": {},
   "source": [
    "## Part 2: Using Gates \n",
    "\n",
    "Quantum computers can use \"gates\" to send different instructions to the qubits. Let's look at three commonly used gates:\n",
    "\n",
    "First up, we have what is known as a NOT gate. This is one of the most basic operations that you can do in a computer; it simply flips the bit value. A 0 becomes 1, or a 1 becomes 0. We use a gate known as the X gate, `.x()` for this, writing the target qubit number inside the parenthesis. This is commonly referred to by either name, an X or a NOT gate. \n",
    "\n",
    "Next, let's look at something uniquely quantum, the Hadamard gate. This gate puts a qubit into a superposition, which hopefully you've already learned in one of your Fall Fest workshops! We can apply a hadamard gate simply, by using `.h()` and writing the target qubit number inside the parenthesis.\n",
    "\n",
    "The last gate we'll look at for now is the CNOT gate. There's a lot of ways to examine what this gate is or what it does. To keep it simple, let's say that this is the entanglement gate. It entangles two qubits together. We apply a CNOT gate by using `.cx()` and writing the two qubit numbers in the parenthesis. \n",
    "\n",
    "Time to see each of these in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d2bb51dd-f978-4525-97ae-22f49a261aec",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 370.906x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "qc = QuantumCircuit(2)\n",
    "\n",
    "# We start by flipping the first qubit, which is qubit 0, using an X gate\n",
    "qc.x(0)\n",
    "\n",
    "# Next we add an H gate on qubit 0, putting this qubit in superposition.\n",
    "qc.h(0)\n",
    "\n",
    "# Finally we add a CX (CNOT) gate on qubit 0 and qubit 1\n",
    "# This entangles the two qubits together\n",
    "qc.cx(0, 1)\n",
    "\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9250758-9c46-4a8c-acb3-277c4055d586",
   "metadata": {},
   "source": [
    "Pretty simple! Go back and mess around with the gates. Experiement with which qubit you target. You can even change the quantum circuit to include more qubits. Add a few extra X gates to whatever qubits you'd like. \n",
    "\n",
    "After each change, run the cell again to see a diagram of what you did.\n",
    "\n",
    "**NOTE** - See how this time we called the QuantumCircuit function and only passed through a single number? We can do this to create a new circuit that only contains qubits, with no classical bits. This is really handy when you just want to build and draw a circuit for reference. We can't measure those qubits without any classical bits, but we can experiement to see how adding different gates would affect our circuit.\n",
    "\n",
    "Once you feel like you understand how each gate works, move on to Exercise 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584d5a23-6056-40c9-8b68-4f6f4be3dd61",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "Let's use these gates to create what's called a Bell state. \n",
    "\n",
    "**YOUR TASK:** In the cell below, we have already created a new Quantum Circuit with two qubits. You need to apply a Hadamard gate to `q0`, then a CNOT gate connecting qubit 0 to qubit 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5e2112ca-510a-4937-b926-963a16c013c2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 287.294x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "qc = QuantumCircuit(2, 2)\n",
    "\n",
    "\n",
    "## Write your code below here ##\n",
    "qc.h(0)\n",
    "qc.cx(0, 1)\n",
    "    \n",
    "## Do not modify the code under this line ##\n",
    "\n",
    "\n",
    "answer2 = qc\n",
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b1d00298-60cc-473c-8ffd-d9f905c3cf9a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading your answer. Please wait...\n",
      "\n",
      "Congratulations 🎉! Your answer is correct.\n"
     ]
    }
   ],
   "source": [
    "# Grader Cell: Run this to submit your answer\n",
    "\n",
    "from qc_grader.challenges.fall_fest23 import grade_ex1b\n",
    "\n",
    "grade_ex1b(answer2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bfe88b8-59fc-4e1e-b142-38c6a39f3d50",
   "metadata": {},
   "source": [
    "## Congratulations!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e74cfe6-a31c-48b1-9ff3-e1d573341fc2",
   "metadata": {},
   "source": [
    "You've made it to the end of the first lab! Let's recap what you learned:\n",
    "\n",
    "-  The fundamental unit of Qiskit is the quantum circuit, which is a series of instructions that a quantum computer can use to work with quantum bits of information, also known as qubits.\n",
    "- The `QuantumCircuit(x, y)` function creates a new quantum circuit with (x) qubits and, optionally, (y) classical bits\n",
    "- When you measure a qubit, it falls out of it's quantum state down to a single bit of information, a 0 or a 1\n",
    "- The X gate flips a qubit from 0 to 1 (or vice versa)\n",
    "- The H gate puts a qubit into superposition\n",
    "- The CX gate entangles two qubits together"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50054d17-90c0-4919-a527-654b33e4c646",
   "metadata": {},
   "source": [
    "Now that you know a little bit about Qiskit, it is time to move onto the next lab and learn more. Enjoy the Qiskit Fall Fest. Good luck!"
   ]
  }
 ],
 "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.10.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}