Zufallsgenerator mit Lösungen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "02422554",
   "metadata": {},
   "source": [
    "# Quantenzufallsgenerator\n",
    "In diesem Jupyter Notebook soll ein Zufallsbit mit Hilfe eines Quantenschaltkreises konstruiert werden. Zunächst soll sich dabei eine gleiche Wahrscheinlichkeit für die Zustände $|0\\rangle$ und $|1\\rangle$ ergeben. In den Variationen des Zufallsgenerators sollen einmal gleiche Wahrscheinlichkeiten für die Basiszustände eines Registeres mit $n$ Qubits auftreten und einmal eine beliebige Wahrscheinlichkeit für den Zustand $|0\\rangle$ eingestellt werden können."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db6e73e5",
   "metadata": {},
   "source": [
    "## Vorbereitungen\n",
    "Wie am Anfang eines jeden Notebook müssen die nötigen Pakete geladen werden. Siehe hierzu auch in dem Jupyter Notebook [\"Einstieg in Qiskikt\"](https://github.com/MarkEich96/QuantencomputingWiSe23-24/blob/main/Einstieg%20in%20Qiskit.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95269451",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import qiskit\n",
    "from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister)\n",
    "from qiskit import(execute, Aer, BasicAer)\n",
    "from qiskit.quantum_info.operators import Operator\n",
    "from qiskit.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92e3dd0b",
   "metadata": {},
   "source": [
    "Mit dem folgenden Befehl werden Grafiken direkt in der Ausgabe angezeigt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfe784ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2661751",
   "metadata": {},
   "source": [
    "Mit dem folgenden Befehl wird die Simulationssoftware für das Ausführen der Schaltkreise festgelegt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccc906c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "simulator = Aer.get_backend('qasm_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8872d9e6",
   "metadata": {},
   "source": [
    "## Zufallsgenerator für ein Bit\n",
    "Das erste Ziel ist es einen Quantenschaltkreis mit einem Qubit und einem klassischen Bit zu konstruieren, der nach dem Ausführen mit einer Wahrscheinlichkeit von jeweils $50 \\%$ den Zustand $|0\\rangle$ oder $|1\\rangle$ in das klassische Bit geschrieben hat. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ce1b2c",
   "metadata": {},
   "source": [
    "### Aufbau des Schaltkreises\n",
    "Überlege Dir zuerst, wie sich aus dem Zustand $|0\\rangle$ mit den in der Vorlesung besprochenen Operationen (siehe dazu auch [Operationen auf Qubits](https://de.wikiversity.org/wiki/Kurs:Quantencomputing/Qubits)) ein Zustand konstruieren lässt, bei dem $|\\alpha|^2=|\\beta|^2=\\frac{1}{2}$ ist. Implemtiere die entsprechnednen Operation(en) in das vorgefertigte Code-Gerüst und erstelle so eine Skizze des Schaltkreises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24b24ab9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quantenschaltkreis mit einem Qubit un einem klassischen Bit\n",
    "circuit = QuantumCircuit(1, 1) \n",
    "\n",
    "# Initialisiere das Qubit im Zustad |0>\n",
    "circuit.reset(0)\n",
    "\n",
    "# Füge hier Deine Operation(en) auf das Qubit ein\n",
    "circuit.h(0)\n",
    "\n",
    "# Ausführen der Messung und schreiben des Ergebnisses in das klassische Bit\n",
    "circuit.measure(0,0)\n",
    "\n",
    "# Füge hier den Code ein, um eine Skizze des Quantenschaltkreises zu erstellen\n",
    "circuit.draw(output = 'mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e69be958",
   "metadata": {},
   "source": [
    "### Erklärung des Algorithmus\n",
    "Nach dem Anwenden der Hadamard-Matrix auf den Zustand $|0\\rangle$ befindet sich das Qubit im Zustand \n",
    "$$|+\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle)$$ \n",
    "Die Wahrscheinlichkeit die beiden Zustände zu messen, kann daher zu\n",
    "$$P(|0\\rangle)=|\\langle 0|+\\rangle|^2=\\frac{1}{2}$$ und \n",
    "$$P(|1\\rangle)=|\\langle 1|+\\rangle|^2=\\frac{1}{2}$$ bestimmt werden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "848fe68e",
   "metadata": {},
   "source": [
    "### Ausführung des Algorithmus\n",
    "Simuliere den Algorithmus nun mit 1000 Versuchen und schau, ob sich die Zustände $|0\\rangle$ und $|1\\rangle$ in etwa gleich oft ergeben. (Auch hier kann das Jupyter Notebook [\"Einstieg in Qiskikt\"](https://github.com/MarkEich96/QuantencomputingWiSe23-24/blob/main/Einstieg%20in%20Qiskit.ipynb) hilfreich sein)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b1fa49e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Füge hier den Code zum Ausführen des Quantenschaltkreises ein\n",
    "\n",
    "# Erstelle den job durch ausführen den Quantenschaltkreis mit dem oben festgelegten Simulator und 1000 Versuchen\n",
    "job = execute(circuit, simulator, shots = 1000)\n",
    "\n",
    "# Lese die Ergebnisse der Simulation aus\n",
    "results = job.result()\n",
    "\n",
    "# Trage die Häufigkeit der Bitkombinationen der klassischen Bits 0, 1 und 2 auf.\n",
    "plot_histogram(results.get_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d789e279",
   "metadata": {},
   "source": [
    "## Zufallsgenerator für $n$ Bits\n",
    "Nun soll ein Register mit $n$ Qubits betrachtet werden. Dessen Zustand lässt sich in der Basis $|X\\rangle$ mit $X\\in\\{0, 1\\}^n$ angeben. Diese Basiszustände können, wenn sie als Binärzahlen gelesen werden, als die Zahlen $0$ bis $2^{n}-1$ aufgefasst werden. Ziel ist es nun einen Quantenschaltkreis zu implementieren, der eine Zufallszahl zwischen $0$ und $2^{n}-1$ bestimmt. Die jeweiligen Zahlen sollen dabei alle die gleiche Wahrscheinlichkeit haben."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036b7bf6",
   "metadata": {},
   "source": [
    "### Aufbau des Schaltkreises\n",
    "Lässt sich der zuvor gefundene Schaltkreis auf $n$ Qubits verallgemeinern? Wenn ja, implementiere ihn zunächst für $n=2$ Qubits und fertige eine Skizze an. Welche Ergebnisse sind für die Messung möglich? Wie wahrscheinlich ist es eine bestimmte Zufallszahl zu messen? Wie häufig sollte bei 1000 Ausführungen des Schaltkreis demnach jede Zufallszahl auftreten?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ea693cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Festlegen der Anzahl der Qubits\n",
    "n = 2\n",
    "\n",
    "# Verallgemeinere den vorherigen Schaltkreis\n",
    "\n",
    "# Anlegen eines Quantenschaltkreises mit n Qubits und n klassischen Bits\n",
    "circuit = QuantumCircuit(n, n)\n",
    "\n",
    "# Initialisieren der Qubits in die Zustände |0>\n",
    "circuit.reset(range(n))\n",
    "\n",
    "# Herstellen der gleichgewichtigen Superposition\n",
    "circuit.h(range(n))\n",
    "\n",
    "# Messen der Qubits und Schreiben der Ergebnisse in die klassischen Bits\n",
    "circuit.measure(range(n), range(n))\n",
    "\n",
    "# Erstellen einer Skizze des Quantenschaltkreises\n",
    "circuit.draw(output = 'mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee270303",
   "metadata": {},
   "source": [
    "### Erklärung des Schaltkreises\n",
    "Durch das Anwenden der Hadamard-Transformation $H_n$ auf den Zustand $|0\\dots 0\\rangle$ wird der Zustand\n",
    "$$H_n|0\\dots 0\\rangle=\\frac{1}{\\sqrt{2^n}}\\sum\\limits_{Y\\in\\{0, 1\\}^n}|Y\\rangle$$\n",
    "erzeugt. Demnach wird ein beliebiger Zustand $|X\\rangle$ mit $X\\in\\{0, 1\\}^n$ mit der Wahrscheinlichkeit\n",
    "$$P(|X\\rangle)=|\\langle X|Y\\rangle|^2=\\frac{1}{2^n}$$\n",
    "gemessen.\n",
    "\n",
    "Im Fall von $n=2$ sind die Zustände $|00\\rangle$, $|01\\rangle$, $|10\\rangle$ und $|11\\rangle$ möglich. Die gleichgewichtige Superposition ist dann durch\n",
    "$$H_2|00\\rangle = \\frac{1}{2}(|00\\rangle+|01\\rangle+|10\\rangle+|11\\rangle)$$\n",
    "gegeben und jede Zufallszahl sollte mit der Wahrscheinlichkeit $\\frac{1}{4}=25\\%$ auftreten. Daher ist jede Zufallszahl bei 1000 Versuchen in etwa 250 mal zu erwarten."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e03a1a39",
   "metadata": {},
   "source": [
    "### Ausführung des Algorithmus\n",
    "Simuliere den Algorithmus nun mit 1000 Versuchen und schau, ob sich die vier möglichen Zufallszahlen mit etwa der gleichen Häufigkeit einstellen. Handelt es sich um die Häufigkeit, die Du oben ermittelt hast? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1edcb9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Füge hier den Code zum Ausführen des Quantenschaltkreises ein\n",
    "\n",
    "# Erstelle den job durch ausführen den Quantenschaltkreis mit dem oben festgelegten Simulator und 1000 Versuchen\n",
    "job = execute(circuit, simulator, shots = 1000)\n",
    "\n",
    "# Lese die Ergebnisse der Simulation aus\n",
    "results = job.result()\n",
    "\n",
    "# Trage die Häufigkeit der Bitkombinationen der klassischen Bits 0, 1 und 2 auf.\n",
    "plot_histogram(results.get_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e8624c1",
   "metadata": {},
   "source": [
    "## Zufallsgenerator für ein Bit mit beliebiger Wahrscheinlichkeit\n",
    "Zuletzt soll ein Zufallsgenerator konstruiert werden, der für ein Bit beim Messen mit einer gegebenen Wahrscheinlichkeit $0\\leq p\\leq 1$ den Zustand $|0\\rangle$ ergibt."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "261dd28c",
   "metadata": {},
   "source": [
    "### Aufbau des Schaltkreises\n",
    "Überlege Dir, wie sich mit dem U-Gatter aus dem Zustand $|0\\rangle$ ein beliebiger Zustand konstruieren lässt. Wie wahrscheinlich ist es, in diesem Zustand den Zustand $|0\\rangle$ zu messen? Implementiere den Schaltkreis so, dass sich der Zustand $|0\\rangle$ mit einer Wahrscheinlichkeit von $\\frac{1}{4}$ ergibt. Dafür kömmte folgende Tabelle hilfreich sein. ($\\alpha$ ist ein Winkel in Grad und $\\phi$ der entsprechende Winkel in rad. Python nimmt nur Winkel in rad an. $\\pi$ kann mit ``np.pi`` aufgerufen werden.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46b9a504",
   "metadata": {},
   "source": [
    "| $\\alpha$ | $0^{\\circ}$ | $30^{\\circ}$ | $45^{\\circ}$ | $60^{\\circ}$ | $90^{\\circ}$ |\n",
    "| --- | --- | --- | --- | --- | --- |\n",
    "| $\\phi$ | $0$ | $\\pi/6$ | $\\pi/4$ | $\\pi/3$ | $\\pi/2$ |\n",
    "| $\\sin^2{(\\phi)}$ | $\\frac{0}{4}$ | $\\frac{1}{4}$ | $\\frac{2}{4}$ | $\\frac{3}{4}$ | $\\frac{4}{4}$ |\n",
    "| $\\cos^2{(\\phi)}$ | $\\frac{4}{4}$ | $\\frac{3}{4}$ | $\\frac{2}{4}$ | $\\frac{1}{4}$ | $\\frac{0}{4}$ |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "492028e6",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Implementiere einen Schaltkreis bei dem der Zustand |0> mit der W'keit 1/4 gemessen wird\n",
    "\n",
    "# Erstellen eines Schaltkreises mit einem Qubit und einem klassischen Bit\n",
    "circuit = QuantumCircuit(1, 1)\n",
    "\n",
    "# Initiallisieren des Qubits\n",
    "circuit.reset(0)\n",
    "\n",
    "# Anwenden des U-Gatters mit den Parametern theta = pi/3, phi = 0, lambda = 0 auf das Qubit 0\n",
    "circuit.u(2*np.pi/3, 0, 0, 0)\n",
    "\n",
    "# Messen des Qubits\n",
    "circuit.measure(0, 0)\n",
    "\n",
    "# Anfertigen der Skizze des Schaltkreises\n",
    "circuit.draw(output = 'mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c739771",
   "metadata": {},
   "source": [
    "### Erklärung des Schaltkreises\n",
    "Das U-Gatter überführt den Zustand $|0\\rangle$ in den Zustand\n",
    "$$|x\\rangle = U(\\theta, \\phi, \\lambda)|0\\rangle = \\cos{\\left(\\frac{\\theta}{2}\\right)}|0\\rangle+\\mathrm{e}^{\\mathrm{i}\\phi}\\sin{\\left(\\frac{\\theta}{2}\\right)}|1\\rangle $$\n",
    "Die Wahrscheinlichkeit den Zustand $|0\\rangle$ zu messen ist daher durch\n",
    "$$P(|0\\rangle)=|\\langle 0 |x\\rangle|^2=\\cos^2{\\left(\\frac{\\theta}{2}\\right)}$$\n",
    "gegeben. Sie hängt nur von $\\theta$ ab, weshalb der Einfachheit halber $\\phi = \\lambda = 0$ gewählt werden können. Damit diese Wahrscheinlichkeit den Wert $\\frac{1}{4}$ annimmt, muss nach der Tabelle $\\frac{\\theta}{2}=\\frac{\\pi}{3}$ und damit $\\theta = \\frac{2\\pi}{3}$ sein. \n",
    "\n",
    "Wenn eine beliebige Wahrscheinlichkeit $p$ gewählt wird, so muss der Winkel $\\theta$ gerade\n",
    "$$\\theta(p)=2\\arccos{\\left(\\sqrt{p}\\right)}$$\n",
    "betragen. Dies kann beispielsweise über die Code-Zeile \n",
    "\n",
    "``theta = 2*np.arccos(np.sqrt(p))``\n",
    "\n",
    "implementiert werden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c5da452",
   "metadata": {},
   "source": [
    "### Ausführung des Algorithmus\n",
    "Simuliere den Algorithmus nun mit 1000 Versuchen. Wie häufig sollte sich demnach der Zustand $|0\\rangle$ einstellen? Passt die Simulation zu Deinen Überlegungen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09104d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Füge hier den Code zum Ausführen des Quantenschaltkreises ein\n",
    "\n",
    "# Erstelle den job durch ausführen den Quantenschaltkreis mit dem oben festgelegten Simulator und 1000 Versuchen\n",
    "job = execute(circuit, simulator, shots = 1000)\n",
    "\n",
    "# Lese die Ergebnisse der Simulation aus\n",
    "results = job.result()\n",
    "\n",
    "# Trage die Häufigkeit der Bitkombinationen der klassischen Bits 0, 1 und 2 auf.\n",
    "plot_histogram(results.get_counts())"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}