{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "274f7bc6",
   "metadata": {},
   "source": [
    "\n",
    "# One-qubit operations with Qiskit\n",
    "\n",
    "This notebook is a beginner-friendly introduction to **one-qubit circuits** in **Qiskit**.\n",
    "\n",
    "We will learn how to:\n",
    "\n",
    "1. **name and define a circuit**\n",
    "2. apply single-qubit gates: **H, X, RX, RY, RZ**\n",
    "3. **draw** the circuit in different ways\n",
    "4. perform measurements using **counts** or use the exact **statevector**\n",
    "5. show measurement results with a **histogram**\n",
    "\n",
    "This notebook uses only **local simulation**, so it can run on a student laptop without any IBM Quantum account.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf2ab784",
   "metadata": {},
   "source": [
    "\n",
    "## 0. Imports\n",
    "\n",
    "We import:\n",
    "\n",
    "- `QuantumCircuit` to create circuits\n",
    "- `numpy` for angles such as $\\pi/2$\n",
    "- `Statevector` to inspect the exact quantum state\n",
    "- `StatevectorSampler` to simulate measurements and obtain counts-like results\n",
    "- `plot_histogram` to visualize outcomes\n",
    "\n",
    "> For beginners: in this notebook, a **circuit** is simply a sequence of operations applied to a qubit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4ffa0f0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for quantum circuit\n",
    "from qiskit import QuantumCircuit\n",
    "# for basic operation + plots \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "# for measurement\n",
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.primitives import StatevectorSampler\n",
    "from qiskit.visualization import plot_histogram\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432c442e",
   "metadata": {},
   "source": [
    "\n",
    "## 1. How to name and define a circuit\n",
    "\n",
    "A `QuantumCircuit` can contain:\n",
    "\n",
    "- **qubits**: the quantum wires\n",
    "- **classical bits**: where measurement results are stored\n",
    "- an optional **name**\n",
    "\n",
    "For a one-qubit example with one classical bit:\n",
    "\n",
    "```python\n",
    "qc = QuantumCircuit(1, 1, name=\"my_first_qubit_circuit\")\n",
    "```\n",
    "\n",
    "This means:\n",
    "\n",
    "- `1` quantum bit\n",
    "- `1` classical bit\n",
    "- a human-readable circuit name\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b5106d23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# one can do three types of definition qc = QuantumCircuit(1), qc = QuantumCircuit(1, 1), or qc = QuantumCircuit(1, 1, \"myqc\")\n",
    "qc = QuantumCircuit(1, 1, name=\"myfirstcircuit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3619dd73",
   "metadata": {},
   "source": [
    "\n",
    "It is often useful to inspect a few basic properties of a circuit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "92327c73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circuit name: myfirstcircuit\n",
      "Number of qubits: 1\n",
      "Number of classical bits: 1\n",
      "Circuit depth: 0\n"
     ]
    }
   ],
   "source": [
    "print(\"Circuit name:\", qc.name)\n",
    "print(\"Number of qubits:\", qc.num_qubits)\n",
    "print(\"Number of classical bits:\", qc.num_clbits)\n",
    "print(\"Circuit depth:\", qc.depth())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "759e519c",
   "metadata": {},
   "source": [
    "\n",
    "## 2. Single-qubit operations\n",
    "\n",
    "We now apply some basic one-qubit gates.\n",
    "\n",
    "We start from the default state $\\lvert 0 \\rangle$.\n",
    "\n",
    "### 2.1 The X gate\n",
    "\n",
    "The `X` gate flips $\\lvert 0 \\rangle$ into $\\lvert 1 \\rangle$.\n",
    "It is the quantum analogue of a classical NOT on basis states.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3864a980",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 185.453x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "qc_x = QuantumCircuit(1, 1, name=\"X_example\")\n",
    "qc_x.x(0)\n",
    "qc_x.draw(\"mpl\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dd2b9d5-1ce2-46cb-975c-09e96c74a14e",
   "metadata": {},
   "source": [
    "\n",
    "## 2.2 How to draw the circuit\n",
    "\n",
    "Qiskit can draw a circuit in several formats.\n",
    "\n",
    "The most common options are:\n",
    "\n",
    "- `output=\"text\"`: good for terminals\n",
    "- `output=\"mpl\"`: nice figure inside a notebook\n",
    "- `output=\"latex_source\"`: returns LaTeX code for the circuit drawing\n",
    "\n",
    "We use the same circuit and display it in several ways.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7a158c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text drawing:\n",
      "     ┌───┐\n",
      "  q: ┤ X ├\n",
      "     └───┘\n",
      "c: 1/═════\n",
      "          \n"
     ]
    }
   ],
   "source": [
    "\n",
    "qc_draw = QuantumCircuit(1, 1, name=\"drawing_demo\")\n",
    "qc_draw.x(0)\n",
    "\n",
    "print(\"Text drawing:\")\n",
    "print(qc_draw.draw(output=\"text\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3f87119c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 185.453x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "qc_draw.draw(output=\"mpl\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "123cc09a-1d80-4308-94a7-bb29282d11d3",
   "metadata": {},
   "source": [
    "\n",
    "You can also save the drawing directly to a file.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8a7bbf23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved figure as one_qubit_circuit.png\n"
     ]
    }
   ],
   "source": [
    "\n",
    "qc_draw.draw(output=\"mpl\", filename=\"one_qubit_circuit.png\")\n",
    "print(\"Saved figure as one_qubit_circuit.png\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99303be9-2eb0-4ca7-bc00-833771b7b330",
   "metadata": {},
   "source": [
    "### 2.3 The X,Y,Z,H, ... gates\n",
    "\n",
    "In qiskit (as in other packages) there is a list of primitive operations one can do one single qubit. This operation can be applied \n",
    "following the rule \n",
    "\"nameofthecircuit\".operation(qubitnumber)\". \n",
    "\n",
    "Some primitive operations are: \n",
    "\n",
    "Basic one-qubit operation\n",
    "\n",
    "- `id(0)`        (Identity gate)\n",
    "- `x(0)`         (Pauli-X gate, bit flip)\n",
    "- `y(0)`         (Pauli-Y gate)\n",
    "- `z(0)`         (Pauli-Z gate, phase flip)\n",
    "- `h(0)`         (Hadamard gate)\n",
    "\n",
    "Example: \n",
    "The Hadamard gate `H` creates an equal superposition from $\\lvert 0 \\rangle$ and $\\lvert 1 \\rangle:\n",
    "\n",
    "\n",
    "$H \\lvert 0 \\rangle = \\frac{1}{\\sqrt{2}} \\left(\\lvert 0 \\rangle + \\lvert 1 \\rangle\\right)$\n",
    "\n",
    "So after measurement (see below), we expect roughly 50% `0` and 50% `1`.\n",
    "\n",
    "Other useful primitives (see latter for $X$, $Y$) measurements:\n",
    "\n",
    "- `s(0)`         (S gate = sqrt(Z))\n",
    "- `sdg(0)`       (S dagger, inverse of S)\n",
    "- `t(0)`         (T gate = fourth root of Z)\n",
    "- `tdg(0)`       (T dagger, inverse of T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9f5d65a-da9d-49ef-a18d-712fd4d8b9c0",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "- Make a circuit that replaces `X` by another primitive gate, draw the circuit  \n",
    "- Make a circuit that make several operations and draw the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "199395d8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c917b59e",
   "metadata": {},
   "source": [
    "\n",
    "### 2.3 Rotation gates: RX, RY, RZ\n",
    "\n",
    "Some gates might have parameters as inputs. This is the case of single qubit rotation gates. \n",
    "These gates rotate the qubit state around the X, Y, or Z axis of the Bloch sphere.\n",
    "\n",
    "The syntax are \n",
    "- `rx(theta, 0)`\n",
    "- `ry(theta, 0)`\n",
    "- `rz(theta, 0)`\n",
    "if the gate is applied to qubit $0$.\n",
    "\n",
    "For beginners:\n",
    "- `RX` and `RY` usually change measurement probabilities in the computational basis\n",
    "- `RZ` changes the **phase**, so it is not always visible directly in simple Z-basis measurements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d9ecc3f9-0a1c-4771-9434-6e2e055d2ff2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RX gate:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 185.453x200.667 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Example \n",
    "theta = np.pi / 2\n",
    "\n",
    "qc_rx = QuantumCircuit(1, 1, name=\"RX_example\")\n",
    "qc_rx.rx(theta, 0)\n",
    "\n",
    "print(\"RX gate:\")\n",
    "display(qc_rx.draw(\"mpl\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8297d3d-446c-4b6d-9591-10fff1c0f033",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "- Make circuits that combines primitive operations and rotations assuming different \n",
    "angles and draw the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "905866ce-3453-4b2a-b9db-ef0c3e0231ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Here make the exercise.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7795fd8",
   "metadata": {},
   "source": [
    "\n",
    "## 4. How to perform measurements\n",
    "\n",
    "To perform measurements, one should add classical bits when defining the circuits where the measurement results \n",
    "are stored. These bits can have the standard values 0 and 1. Then the definition of the circuit become:\n",
    "\n",
    "`nameofthecircuit=QuantumCircuit(qubit number, bit number, name=\"name\")`\n",
    "\n",
    "There are two common beginner-friendly ways to study the result of a one-qubit circuit:\n",
    "\n",
    "1. **sample measurements** and count how many times each result appears\n",
    "2. inspect the exact **statevector**, then read the probabilities from it\n",
    "\n",
    "These are not the same idea:\n",
    "\n",
    "- **counts** simulate repeated experiments\n",
    "- the **statevector** gives the exact quantum state before measurement\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06a23bd7",
   "metadata": {},
   "source": [
    "\n",
    "### 4.1 Measurement by counts\n",
    "\n",
    "To sample outcomes, we add a measurement to the circuit, then use a sampler.\n",
    "\n",
    "Below, we prepare the state with an `H` gate. Since this creates an equal superposition, we expect counts close to 50% `0` and 50% `1`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5c070a28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 269.064x200.667 with 1 Axes>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "qc_counts = QuantumCircuit(1, 1, name=\"counts_demo\")\n",
    "qc_counts.h(0)\n",
    "qc_counts.measure(0, 0)\n",
    "\n",
    "qc_counts.draw(\"mpl\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0175fa02-c2f1-450b-8f82-9e99301dca99",
   "metadata": {},
   "source": [
    "### Example of syntax for measurement by count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a23080a2-7d5d-4fe5-b262-87a3c4dd8b8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'1': 513, '0': 487}\n"
     ]
    }
   ],
   "source": [
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.primitives import StatevectorSampler \n",
    "\n",
    "sampler = StatevectorSampler()\n",
    "\n",
    "job = sampler.run([qc_counts], shots=1000)\n",
    "result = job.result()\n",
    "\n",
    "# Extract the classical outcomes for the first (and only) circuit.\n",
    "counts = result[0].data.c.get_counts()\n",
    "\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c1b536b-a75d-4101-b5f0-dcb3f40e9eaf",
   "metadata": {},
   "source": [
    "Because we used a finite number of shots (`1000`), the result is usually not exactly `{'0': 500, '1': 500}`.\n",
    "It fluctuates around the ideal probabilities."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1793c9-876e-4f18-81b1-75e700f07621",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "- Make the same circuit but reduce the number of shots progressively to 500, 100, 50, 10. Perform the set of measurements several times and compare the results. What happens?   \n",
    "- Change `H`into `X` and perform the measurement. Interpret the result.\n",
    "- Do a circuit with a $R_X$ rotation with an angle $\\theta$, vary the angle $\\theta$ and perform measurements. Observe the evolution of counts.\n",
    "- Change $R_X$ to $R_Z$ and see what happens.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d030fd1b-e334-4da4-919c-e3d7e4c5552e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Here make the exercise. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "143d66cb",
   "metadata": {},
   "source": [
    "\n",
    "### 4.2 Measurement from Exact statevector\n",
    "\n",
    "The package qiskit is an emulator of quantum digital computer on classical device. This means that it essentially solves the Schrodinger equation and obtains the exact wave function during the operations in the circuit are made. The wave-function is called `statevector`. \n",
    "If we do **not** measure the qubit, we can directly get the **exact** probabilities from the state vector.\n",
    "\n",
    "Note that we can eventually directly show the component of the state vector in the computational basis (including the phases).    \n",
    "\n",
    "**The syntax to get the wave-function and associated probabilities from a state vector is shown below** (note that here the definition of classical qubit is not required in the quantum circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "75abb63d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector:\n",
      "Statevector([0.70710678+0.j, 0.70710678+0.j],\n",
      "            dims=(2,))\n",
      "Statevector as a NumPy array:\n",
      "[0.70710678+0.j 0.70710678+0.j]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "qc_sv = QuantumCircuit(1, name=\"statevector_demo\")\n",
    "qc_sv.h(0)\n",
    "\n",
    "state = Statevector.from_instruction(qc_sv)\n",
    "\n",
    "print(\"Statevector:\")\n",
    "display(state)\n",
    "\n",
    "print(\"Statevector as a NumPy array:\")\n",
    "print(state.data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306ea97d",
   "metadata": {},
   "source": [
    "\n",
    "From the exact statevector, we can also compute measurement probabilities in the computational basis.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "495209e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probabilities from the statevector:\n",
      "{np.str_('0'): np.float64(0.4999999999999999), np.str_('1'): np.float64(0.4999999999999999)}\n"
     ]
    }
   ],
   "source": [
    "probs = state.probabilities_dict()\n",
    "print(\"Probabilities from the statevector:\")\n",
    "print(probs)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d0e1b1d",
   "metadata": {},
   "source": [
    "\n",
    "### 4.3 Comparing counts and statevector on the same circuit\n",
    "\n",
    "Now let us compare:\n",
    "\n",
    "- the **sampled counts** from repeated measurements\n",
    "- the **ideal probabilities** from the exact statevector\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "a2d2564d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ideal probabilities: {np.str_('0'): np.float64(0.7500000000000001), np.str_('1'): np.float64(0.24999999999999994)}\n",
      "Sampled counts: {'1': 239, '0': 761}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "theta = np.pi / 3\n",
    "\n",
    "# Circuit for exact statevector (no measurement)\n",
    "qc_ideal = QuantumCircuit(1, name=\"ideal_probs\")\n",
    "qc_ideal.ry(theta, 0)\n",
    "\n",
    "ideal_state = Statevector.from_instruction(qc_ideal)\n",
    "ideal_probs = ideal_state.probabilities_dict()\n",
    "\n",
    "# Circuit for sampled counts (same preparation, then measurement)\n",
    "qc_sampled = QuantumCircuit(1, 1, name=\"sampled_counts\")\n",
    "qc_sampled.ry(theta, 0)\n",
    "qc_sampled.measure(0, 0)\n",
    "\n",
    "sampled_job = sampler.run([qc_sampled], shots=1000)\n",
    "sampled_result = sampled_job.result()\n",
    "sampled_counts = sampled_result[0].data.c.get_counts()\n",
    "\n",
    "print(\"Ideal probabilities:\", ideal_probs)\n",
    "print(\"Sampled counts:\", sampled_counts)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8782e92e",
   "metadata": {},
   "source": [
    "\n",
    "### 4.4 How to show the result with a histogram ###\n",
    "\n",
    "Qiskit provides `plot_histogram` to visualize count dictionaries or probability dictionaries.\n",
    "\n",
    "This is a standard way to show quantum measurement results in a notebook.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "814e14be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from qiskit.visualization import plot_histogram\n",
    "fig = plot_histogram(counts)\n",
    "display(fig)\n",
    "\n",
    "#plot_histogram(counts)\n",
    "#plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd1f4c6e",
   "metadata": {},
   "source": [
    "\n",
    "We can also plot the ideal probabilities from the statevector.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "9e14fb5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot_histogram(probs)\n",
    "#plt.show()\n",
    "\n",
    "fig1 = plot_histogram(probs)\n",
    "display(fig1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "554dabb0",
   "metadata": {},
   "source": [
    "\n",
    "And we can compare sampled counts with ideal probabilities in the same plot.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1be88655-560e-4a27-b3ee-b9016a8fc5f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig2 = plot_histogram(\n",
    "    [sampled_counts, ideal_probs],\n",
    "    legend=[\"sampled counts\", \"ideal probabilities\"]\n",
    ")\n",
    "display(fig2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff8b4ffb-1cfe-4375-90ba-7f105926b412",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "- Again, reduce the number of shots and see how histograms evolve\n",
    "- Change $\\theta$ and see what happens to the different probabilities\n",
    "- Make a more complex circuit with at least three operations, and at least one depending on angle, perform the two types of measurements and compare. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f03c655-9cfa-4170-a8ee-8f85a630de37",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Here make the solution of the exercice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09ab78ce-2567-4295-8135-baccdfb5d06f",
   "metadata": {},
   "source": [
    "## 5. Measuring $\\langle Z \\rangle$, $\\langle X \\rangle$, and $\\langle Y \\rangle$ with basis rotations\n",
    "\n",
    "This is a very important idea in quantum computing.\n",
    "\n",
    "A real measurement in most simple examples is done in the **computational basis**:\n",
    "- outcome `0`\n",
    "- outcome `1`\n",
    "\n",
    "By default, in qiskit the computational basis is the  This is naturally **Z-basis**. \n",
    "The state $|0 \\rangle$ and $|1\\rangle$ have eigenvalues $+1$ and $-1$. Assume a state given \n",
    "by $| \\psi \\rangle = c_0 | O \\rangle + c_1 | 1 \\rangle$, then the probability to measure $0$\n",
    "(resp. $1$) in the qubit is $P(0) = |c_0|^2$ (resp. $P(1) = |c_1|^2$). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81a1d3f-4a9d-49ef-b472-b537ac0b8ac4",
   "metadata": {},
   "source": [
    "***Exercice***\n",
    "Prove that \n",
    "\\langle Z \\rangle = P(0) - P(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ed1ba81-80a3-4f1b-92e9-2ce49f235ae7",
   "metadata": {},
   "source": [
    "### Measuring $\\langle X \\rangle$ or $\\langle Y \\rangle$\n",
    "But sometimes we want to measure another observable, such as:\n",
    "\n",
    "- $Z$\n",
    "- $X$\n",
    "- $Y$\n",
    "\n",
    "The trick is for a given operator $O$:\n",
    "\n",
    "1. **rotate the state in the basis where $O$ is diagonal **\n",
    "2. then perform a standard computational-basis measurement\n",
    "\n",
    "So instead of changing the hardware measurement, we change the basis **before** measuring.\n",
    "\n",
    "### Key idea\n",
    "\n",
    "- To measure **$\\langle Z \\rangle$**, do nothing before measurement\n",
    "- To measure **$\\langle X \\rangle$**, apply an **H gate** before measurement\n",
    "- To measure **$\\langle Y \\rangle$**, apply **$S^\\dagger$ then H** before measurement\n",
    "\n",
    "After that, we measure in the computational basis and compute\n",
    "\n",
    "\\[\n",
    "\\langle O \\rangle = P(0) - P(1)\n",
    "\\]\n",
    "for the observable $O \\in \\{X,Y,Z\\}$.\n",
    "\n",
    "An example is given below "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "3aa8a834-e30f-4dc6-b6d7-0411377e98b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 269.064x200.667 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts for Z-basis measurement: {'0': 2011, '1': 1989}\n",
      "<Z> from counts = 0.005500000000000005\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 269.064x200.667 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts for X-basis measurement: {'1': 2078, '0': 1922}\n",
      "<X> from counts = -0.03899999999999998\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 352.675x200.667 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts for Y-basis measurement: {'0': 1975, '1': 2025}\n",
      "<Y> from counts = -0.012499999999999956\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "theta=np.pi/3\n",
    "phi=np.pi/5\n",
    "\n",
    "# measuring <Z> - no rotation needed \n",
    "\n",
    "qc_zm = QuantumCircuit(1, 1, name=\"measure_Z\")\n",
    "\n",
    "qc_zm.h(0)\n",
    "#qc_zm.ry(theta, 0)\n",
    "#qc_zm.rz(phi, 0)\n",
    "qc_zm.measure(0, 0)\n",
    "\n",
    "display(qc_zm.draw(\"mpl\"))\n",
    "\n",
    "job_z = sampler.run([qc_zm], shots=4000)\n",
    "counts_z = job_z.result()[0].data.c.get_counts()\n",
    "\n",
    "print(\"Counts for Z-basis measurement:\", counts_z)\n",
    "\n",
    "shots = 4000\n",
    "p0_z = counts_z.get('0', 0) / shots\n",
    "p1_z = counts_z.get('1', 0) / shots\n",
    "exp_z_from_counts = p0_z - p1_z\n",
    "print(\"<Z> from counts =\", exp_z_from_counts)\n",
    "\n",
    "\n",
    "# measuring <X> --H--  needed\n",
    "\n",
    "qc_xm = QuantumCircuit(1, 1, name=\"measure_Z\")\n",
    "qc_zm.h(0)\n",
    "#qc_xm.ry(theta, 0)\n",
    "#qc_xm.rz(phi, 0)\n",
    "qc_xm.h(0)\n",
    "qc_xm.measure(0, 0)\n",
    "\n",
    "display(qc_xm.draw(\"mpl\"))\n",
    "\n",
    "job_x = sampler.run([qc_xm], shots=shots)\n",
    "counts_x = job_x.result()[0].data.c.get_counts()\n",
    "print(\"Counts for X-basis measurement:\", counts_x)\n",
    "\n",
    "p0_x = counts_x.get('0', 0) / shots\n",
    "p1_x = counts_x.get('1', 0) / shots\n",
    "exp_x_from_counts = p0_x - p1_x\n",
    "print(\"<X> from counts =\", exp_x_from_counts)\n",
    "\n",
    "# measuring <Y> --SH--  needed\n",
    "\n",
    "qc_ym = QuantumCircuit(1, 1, name=\"measure_Z\")\n",
    "qc_zm.h(0)\n",
    "#qc_ym.ry(theta, 0)\n",
    "#qc_ym.rz(phi, 0)\n",
    "qc_ym.sdg(0)\n",
    "qc_ym.h(0)\n",
    "qc_ym.measure(0, 0)\n",
    "\n",
    "display(qc_ym.draw(\"mpl\"))\n",
    "\n",
    "job_y = sampler.run([qc_ym], shots=shots)\n",
    "counts_y = job_y.result()[0].data.c.get_counts()\n",
    "print(\"Counts for Y-basis measurement:\", counts_y)\n",
    "\n",
    "p0_y = counts_y.get('0', 0) / shots\n",
    "p1_y = counts_y.get('1', 0) / shots\n",
    "exp_y_from_counts = p0_y - p1_y\n",
    "print(\"<Y> from counts =\", exp_y_from_counts)\n",
    "\n",
    "fig = plot_histogram(\n",
    "    [counts_z, counts_x, counts_y],\n",
    "    legend=[\"Z basis\", \"X basis\", \"Y basis\"]\n",
    ")\n",
    "display(fig)\n",
    "plt.close(fig)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "887df71e-77e7-4d21-8276-3d60be679275",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "- Instead of `H`make a $R_Y$ rotation with angle $\\theta$ and a $R_Z$ rotation with angle $\\phi$ and see how change the histograms with $\\theta$ and $\\phi$.  Draw it and plot the histogram.\n",
    "- Make your own circuit, measure $\\langle X\\rangle$, $\\langle Y \\rangle$ and $\\langle Z \\rangle$ from 1000 shots and print the result. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "709b8f45-3fb3-45be-bbec-e7c2cb357d30",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Here your solution. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6acbd2ba",
   "metadata": {},
   "source": [
    "\n",
    "## 7. Summary of what we have learn\n",
    "\n",
    "In this notebook, we learned how to:\n",
    "\n",
    "- create and name a one-qubit circuit with `QuantumCircuit`\n",
    "- apply single-qubit gates such as `H`, `X`, `RX`, `RY`, and `RZ`, ... \n",
    "- draw circuits using `draw()` with text and Matplotlib output\n",
    "- obtain results either by:\n",
    "  - **sampling measurements** with a sampler\n",
    "  - computing the exact **statevector**\n",
    "- visualize outcomes with `plot_histogram`\n",
    "\n",
    "Now we move on two-qubit (or more qubits) circuits. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8aa50a44-645e-4f25-af80-ac4a7544f67e",
   "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.11.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}