classiq_iQuHack_final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classiq Challenge - Quantum Arithmetics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the Classiq challenge of the 2024 MIT IQuHack hackathon!\n",
    "This Jupyter notebook is the framework for the challenge and you should follow it in order to solve it using Classiq (alongside the guidelines of the challenge).\n",
    "\n",
    "The notebook has 3 parts:\n",
    "1. A warm up session, just to get up to speed with a small example of Classiq\n",
    "2. The challenge itself, including what you need to create, what's the format, and how you can check yourself\n",
    "3. A cheat sheet with relevant Classiq functions declarations\n",
    "\n",
    "Additional resources you should use are\n",
    "- The IDE of the classiq platform at [platform.classiq.io](platform.classiq.io)\n",
    "- The [community Slack of Classiq](https://short.classiq.io/join-slack) - Classiq's team will answer any question you have over there, including implementation questions\n",
    "- [Classiq's documentation](https://docs.classiq.io/latest/user-guide/platform/) with the dedicated [Python SDK explanations](https://docs.classiq.io/latest/user-guide/platform/qmod/python/functions/)\n",
    "\n",
    "Good luck!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![MITClassiq](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAg0AAADbCAYAAADu4KKPAAAMZElEQVR4Ae3d324UV57A8d+pbjM2Jgr7BHFuRjLKaog09zFPMN47AolwngDyBIEnSOYJcDSBRdqLJE+Acx/JrCaCKDc0T7BEAezJ0nW2ysZsQv74ENzu6q7PR3LK/9pyi0j19e+cqk7/eOOvOTri/Qdfp5gAz/F4eY6vpkvPsw8m+W8J86YKAIACogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKCIaAIAiogEAKDIMmBHvP/g6RQ/05XkCs8ekAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoIhoAgCKiAQAoMgyYEfd2LuboiNWlGykm5B9v/LUzz/P9B19P7Hl26d9zno3H+YO3Tt3cDDgCJg0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQBHRAAAUEQ0AQJFhAAAzZ3vn/MrCuFpLKVZyyqcHKb3efn6c8/cpp4cp8p06Px29deq/7sQREQ0AMCP++cP5tTRI68OoLuWI0zE4+Ep6/j1NPDz7MDVfPhHfPrn4sI68Vdfx5Vunbm7GKxANANBh23n99OLuycvN9OBKTk0oNPJLPL59TIq0PhjE+r2dCx81n9qMqD9dXbo1ipdkTwMAdNTdx++uN8Gw3UwNrh4Ew6tJK+3Pak7/t795dGEjXpJoAICOaacL3z658Hmqqs/3T/RHLa0MBul6M3m4f2/n/Erpo0QDAHTId48unG2nCzml9Zi4tNJOHdqJRsl3iwYA6Ih2o2NdpduTmS78lrTSTjTuPnn3ymHfKRoAoAPaYBgOB7ePZu/Cy0up+viwcBANADBl7b6ChcHg85iyvXD4naUK0QAAU7S/EbGa2oThF1J1/bc2R4oGAJiiXLeXQKaV6IjUxEtOg8+388YvIkY0AMCUtPdKSFV1KTom5Th74smPv9jfIBoAYAraJYDBID6KjkopXX5xmUI0AMA0VMNLXVqWeFHa22NR/SxqRAMAHLO9v+DreiM6L238dNogGgDgmI3H1VqXpww/Nc7V870NogEAjtlwmC7HjKgiXTq4kkI0AMAxasf9OcfZmBHt3obFR7t7v+8wAJhbwyp9fG/nYmd36PdRyu19EGKmjAdVe5fILdEAMMee3WWwG3caZM+sBUNrkOJvzeGK5QkA4BBppd3XIBoAgEO1+xpEAwBwqHGqVkQDAHColEI0AACHazfVigYA4FCDFK+LBgCgiGgAAA5V1/FANAAARUQDAHCoFPmOaAAADpXq/FA0AACHWn3tlhesAphzo5zzg6AzUkpvNIeVmCHN/0NftUfRADDHxuN87a1TNzeDzvjm0YWNwSBdjxlSR9xpj5YnAOAYLS+f+CJmTR2b7UE0AMAxejNtPmwOWzE7Rs20yqQBAKYjXYuZkZ//rqIBAI7Z6tJnW81hFN03ijixdfBBLzZCvv/g6xQA0CntX/Ad3xBZ509XlzdHBx+aNADAFKwu7V3VshXdNdo9eeKTn35CNADAlAzG+cPorHzt7f1Nm8+JBgCYkj+funknp+hiOGw+m4T8jGgAgCk6s3ijXQLYiu4Y7S4u/GrIiAYAmLLFxYX/iG5cTTGKWDj34rLEAdEAAFO2f8OnhXMx3XAYtb/D6tL/Xy3xItEAAB2wf7KeWjiMDguGlmgAgI5oT9rNUsXbuY5P45jsv4Ll4cHQ8iqXANAhz16bYuPu7sU7KcflmOjLaKdrZ07euFr63SYNANBB+1dVLJybxNTh2XThzdWlz66+zONEAwB0VLtkcGb5xkZ7gm/jIeX08I/+rPaxdZ2/bN47d+bkzbWS5YgXWZ4AgI57doLfaN+/+/i99WZWsJ5SnI0Uf/m9x+UcDyLXW00wbO0sL3zxW5dSlhINADBDzix/9kVzaN9iO2+cXn7848p4UJ2Ocb3Sfi6n6uEw16PHyydGrxoJLxINADCjnkXBnTgm9jQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQRDQAAEVEAwBQZBgAU7C6dCMFMFNMGgCAIqIBAChieQKAmbOd108vPD65HlU+O0jp9ZzS2ZTjdPuW097xYXPce4s6j+rID6ocW6nKd1aXbo2CP0Q0ADAT/vnD+bXhsHonIm3EbqzEoP3s/taYJhL25PT8eLo5nN77fBMUg/b7Ulxuv3Zv58KoOWw9fVp/+u+v3doKiokGADrrYKIwGKRLzYdrcSTSSvOfjeFwsNEGxHgc1waDessE4nD2NADQSXefXLyytLN8vwmG63FkwfCitLL/86vbTUB8FPwu0QBAp7TLEHd3L2ynFB8/W2Y4BmmlebvahMP9bx5d2Ah+leUJADqhXYpY+tfyRznHlcgxJe3kIa438fBORH3NksXPmTQAMHX3ds6v/OlfJ2/vBUMnpI12yaKZOpwNnhMNAEzVd82JOeXBdsqpYyfovf0O23efvNuRkJk+0QDA1Nz78eKlcXNiPr69Cy8vpepjmyT3iQYApqINhhjHZsyEvU2SvQ8H0QDAsWuXJGYnGA6kq31fqhANAByrdtNjXaXbMYP2lip+OL8WPSUaADg27WWV7VUJXd7DcJg8GHzehk/0kGgA4Ni092F4dhvnmZX2gmdwPXpINABwLNo7LXbnPgyvbK2P+xtSAMCEtcsSi7snt2d9yvBTTQA9TGn8dp/uGmnSAMDELf546vI8BUOrXabIufo4esSkAYCJ2t80OLgf8+rp+Nzqa7e2ogdMGgCYqFynqzHPhoPe3PTJpAGAiWmnDO3rSszyJZZFejJtMGkAYGLG42pt7oOhMR5U69EDogGAiRkO0+XogSrSpe28MfdxJBoAmIhvfrxwNufo2MtdT0Z7JcXio925f66iAYCJqJ6mteiTYXUp5pxoAGAimr++/xY9knOa+30NogGAI3d/f31/LXqkXaL4pn3J7zkmGgA4co92n/ZiL8OLqiqvxRwTDQAcuUHOvYyGlNJfYo6JBgCOXk+umnhRzsnyBAC8jFTFG9FDKeW5vleDaADgyOUcb0YvpZWYY6IBgCOXUj8nDa39V/WcT6IBACgiGgCAIqIBACgiGgCAIqIBgCOXcjwM5o5oAODI1RHfR0+tLt0axZwSDQAcuaqK/4keynM+YRENABy5ehz/Hb2U5/p5iwYAjl6KO9FDKaX7McdEAwBHrjl59jIacq5NGgDgZSwuDnsZDXWdtmKOiQYAjtybabPdELgVPdJugnzr1M25jiXRAMBE1JG+ih5JKb6IOScaAJiIqmeThmbWMPeRlAIAJuTb3Yvbzdj+bMy5dmnizMkb/xZzzqQBgIkZ5/Rl9EAfliZaogGAiTm5OPykH69DsXAtekA0ADAx7VUU45T+HnMs5/zV6tLmKHpANAAwUfM+bUjj+mr0hGgAYKLmfNqwufrara3oCdEAwMTN77ShH3sZDogGACaunTbUOX0Q86TO1/qyl+GA+zQAcGzuPr64maq4FLNvtLp0483oGZMGAI7N0smFK81hFLNt1CxLnIseEg0AHJv9F7JaODfL+xtyVX/Yt2WJA6IBgGPVnnBndn9Dna+d+dN/9uLuj79GNABw7M4sf9acePNshUO78XH55tXoMRshAZiaezsXNppT0fXoOsGwRzQAMFV3H7+3XqV8Pac4HR2Uc3x45uSNTwLRAMD03dvZWIn439vNuyvRHaPmNPnB6tJnW8EeexoAmLp2c+Ti4sLbuY5PowPaF6Fqr/IQDD9n0gBApzzb5/BRTGHqkHJ6WEe+Zjni14kGADrpOOOhjYWc4u+7i8NP3t67lwS/RjQA0GmTjAex8HJEAwAz4d7Oe2u5zhupinfiFQJibwkij79M1WDTnoWXIxoAmDnfPbpw9mmqVupUr1URZ1Ok083bGznl55dtPtuf8H3kfKdOMaoijYZ13vrzqZt3gj/k/wAz3zbM/4zKFwAAAABJRU5ErkJggg==)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Warm Up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly, if you haven't done so far, you need to install the Classiq SDK package: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: classiq in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (0.38.0)\n",
      "Collecting classiq\n",
      "  Downloading classiq-0.39.0-py3-none-any.whl.metadata (3.0 kB)\n",
      "Requirement already satisfied: ConfigArgParse<2.0.0,>=1.5.3 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (1.7)\n",
      "Requirement already satisfied: Pyomo<6.6,>=6.5 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (6.5.0)\n",
      "Requirement already satisfied: httpx<1,>=0.23.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (0.27.0)\n",
      "Requirement already satisfied: keyring<24.0.0,>=23.5.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (23.13.1)\n",
      "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (3.8.3)\n",
      "Requirement already satisfied: networkx<3.0.0,>=2.5.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (2.8.8)\n",
      "Requirement already satisfied: numexpr<3.0.0,>=2.7.3 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (2.9.0)\n",
      "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (1.26.4)\n",
      "Requirement already satisfied: packaging<22.0,>=21.3 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (21.3)\n",
      "Requirement already satisfied: pandas<2.0.0,>=1.4.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (1.5.3)\n",
      "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (5.19.0)\n",
      "Requirement already satisfied: pydantic<2.0.0,>=1.9.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (1.10.14)\n",
      "Requirement already satisfied: scipy==1.10.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (1.10.1)\n",
      "Requirement already satisfied: sympy<1.11.0,>=1.9.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (1.10.1)\n",
      "Requirement already satisfied: tabulate<1,>=0.8.9 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from classiq) (0.9.0)\n",
      "Requirement already satisfied: anyio in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from httpx<1,>=0.23.0->classiq) (4.3.0)\n",
      "Requirement already satisfied: certifi in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n",
      "Requirement already satisfied: httpcore==1.* in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from httpx<1,>=0.23.0->classiq) (1.0.4)\n",
      "Requirement already satisfied: idna in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from httpx<1,>=0.23.0->classiq) (3.6)\n",
      "Requirement already satisfied: sniffio in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n",
      "Requirement already satisfied: h11<0.15,>=0.13 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from httpcore==1.*->httpx<1,>=0.23.0->classiq) (0.14.0)\n",
      "Requirement already satisfied: jaraco.classes in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from keyring<24.0.0,>=23.5.0->classiq) (3.3.1)\n",
      "Requirement already satisfied: importlib-metadata>=4.11.4 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from keyring<24.0.0,>=23.5.0->classiq) (7.0.1)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.0)\n",
      "Requirement already satisfied: cycler>=0.10 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.49.0)\n",
      "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n",
      "Requirement already satisfied: pillow>=8 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (10.2.0)\n",
      "Requirement already satisfied: pyparsing>=2.3.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.1)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.9.0)\n",
      "Requirement already satisfied: pytz>=2020.1 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from pandas<2.0.0,>=1.4.0->classiq) (2024.1)\n",
      "Requirement already satisfied: tenacity>=6.2.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.2.3)\n",
      "Requirement already satisfied: typing-extensions>=4.2.0 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from pydantic<2.0.0,>=1.9.1->classiq) (4.10.0)\n",
      "Requirement already satisfied: ply in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from Pyomo<6.6,>=6.5->classiq) (3.11)\n",
      "Requirement already satisfied: mpmath>=0.19 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n",
      "Requirement already satisfied: zipp>=0.5 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from importlib-metadata>=4.11.4->keyring<24.0.0,>=23.5.0->classiq) (3.17.0)\n",
      "Requirement already satisfied: six>=1.5 in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n",
      "Requirement already satisfied: more-itertools in /Users/nadavbenami/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages (from jaraco.classes->keyring<24.0.0,>=23.5.0->classiq) (10.2.0)\n",
      "Downloading classiq-0.39.0-py3-none-any.whl (388 kB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m388.6/388.6 kB\u001b[0m \u001b[31m1.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0mm\n",
      "\u001b[?25hInstalling collected packages: classiq\n",
      "  Attempting uninstall: classiq\n",
      "    Found existing installation: classiq 0.38.0\n",
      "    Uninstalling classiq-0.38.0:\n",
      "      Successfully uninstalled classiq-0.38.0\n",
      "Successfully installed classiq-0.39.0\n"
     ]
    }
   ],
   "source": [
    "# !pip install -U classiq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and to authenticate your device against the Classiq backend:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import classiq\n",
    "# classiq.authenticate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a uniform superposition of numbers in the domain $[0,1)$ with equal spacing of $\\frac{1}{2^K}$ for $K=5$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening: https://platform.classiq.io/circuit/a9461260-4969-48d9-863f-eba66e13bb6c?version=0.40.0\n"
     ]
    }
   ],
   "source": [
    "from classiq import *\n",
    "K =5\n",
    "\n",
    "@qfunc\n",
    "def main(x:Output[QNum]):\n",
    "    allocate_num(num_qubits=K, is_signed=False, fraction_digits=K,out=x)\n",
    "    hadamard_transform(x)\n",
    "\n",
    "quantum_model = create_model(main)\n",
    "quantum_program = synthesize(quantum_model)\n",
    "\n",
    "show(quantum_program) # view the circuit in the IDE\n",
    "\n",
    "job = execute(quantum_program)\n",
    "# job.open_in_ide() # view the resulted histogram in the IDE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's cool right? :)\n",
    "\n",
    "If you are more a Python person, this is how you can post-process your results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State:  {'x': 0.0} | Shots:  63\n",
      "State:  {'x': 0.03125} | Shots:  77\n",
      "State:  {'x': 0.0625} | Shots:  64\n",
      "State:  {'x': 0.09375} | Shots:  58\n",
      "State:  {'x': 0.125} | Shots:  62\n",
      "State:  {'x': 0.15625} | Shots:  60\n",
      "State:  {'x': 0.1875} | Shots:  65\n",
      "State:  {'x': 0.21875} | Shots:  49\n",
      "State:  {'x': 0.25} | Shots:  64\n",
      "State:  {'x': 0.28125} | Shots:  71\n",
      "State:  {'x': 0.3125} | Shots:  77\n",
      "State:  {'x': 0.34375} | Shots:  66\n",
      "State:  {'x': 0.375} | Shots:  61\n",
      "State:  {'x': 0.40625} | Shots:  57\n",
      "State:  {'x': 0.4375} | Shots:  69\n",
      "State:  {'x': 0.46875} | Shots:  66\n",
      "State:  {'x': 0.5} | Shots:  58\n",
      "State:  {'x': 0.53125} | Shots:  62\n",
      "State:  {'x': 0.5625} | Shots:  55\n",
      "State:  {'x': 0.59375} | Shots:  68\n",
      "State:  {'x': 0.625} | Shots:  53\n",
      "State:  {'x': 0.65625} | Shots:  70\n",
      "State:  {'x': 0.6875} | Shots:  64\n",
      "State:  {'x': 0.71875} | Shots:  77\n",
      "State:  {'x': 0.75} | Shots:  71\n",
      "State:  {'x': 0.78125} | Shots:  63\n",
      "State:  {'x': 0.8125} | Shots:  75\n",
      "State:  {'x': 0.84375} | Shots:  66\n",
      "State:  {'x': 0.875} | Shots:  60\n",
      "State:  {'x': 0.90625} | Shots:  57\n",
      "State:  {'x': 0.9375} | Shots:  58\n",
      "State:  {'x': 0.96875} | Shots:  62\n"
     ]
    }
   ],
   "source": [
    "results = job.result()\n",
    "parsed_counts = results[0].value.parsed_counts\n",
    "sorted_counts = sorted(parsed_counts, key=lambda x: x.state[\"x\"])\n",
    "for state_counts in sorted_counts: print('State: ', state_counts.state, '| Shots: ', state_counts.shots)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Challenge Itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# All the imports needed\n",
    "from classiq import *\n",
    "\n",
    "from classiq.interface.backend.backend_preferences import ClassiqBackendPreferences\n",
    "from classiq.interface.executor.execution_preferences import ExecutionPreferences\n",
    "from classiq.interface.model.model import Model as Model_Designer\n",
    "\n",
    "import numpy as np\n",
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Heart of the Code - Build Your Algorithm Here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For the subinterval [0.0,0.25], the best linear approximation to tanh(x) that minimizes the L infinity norm is: f(x) = 0.984375*x + 0.0\n",
      "The minimum cost (L infinity norm) in this subinterval is: 0.003943821850940499\n",
      "For the subinterval [0.25,0.5], the best linear approximation to tanh(x) that minimizes the L infinity norm is: f(x) = 0.875*x + 0.03125\n",
      "The minimum cost (L infinity norm) in this subinterval is: 0.0024363188062294094\n",
      "For the subinterval [0.5,0.75], the best linear approximation to tanh(x) that minimizes the L infinity norm is: f(x) = 0.6875*x + 0.125\n",
      "The minimum cost (L infinity norm) in this subinterval is: 0.0032059467163809696\n",
      "For the subinterval [0.75,1.0], the best linear approximation to tanh(x) that minimizes the L infinity norm is: f(x) = 0.5*x + 0.265625\n",
      "The minimum cost (L infinity norm) in this subinterval is: 0.002778848200664097\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "# Define the function to approximate\n",
    "def f(x):\n",
    "    return np.tanh(x)\n",
    "\n",
    "# Define the L infinity norm for a subinterval\n",
    "def linf_norm(params, x_values):\n",
    "    a, b = params\n",
    "    return np.max(np.abs(f(x_values) - (a * x_values + b)))\n",
    "\n",
    "# Define the subintervals\n",
    "k=4\n",
    "subintervals = []\n",
    "for i in range(k):\n",
    "    subintervals.append((i/k, (i+1)/k))\n",
    "#subintervals = [(0, 1/8), (1/8, 2/8), (2/8, 3/8),(3/4,1)]   #@# Gap in the last interval?\n",
    "#Edit?: subintervals = [(0, 1/4), (1/4, 2/4), (2/4, 3/4),(3/4,1)]   #@# Corrected! (?)\n",
    "\n",
    "\n",
    "# Initial guess\n",
    "initial_guess = [0, 0]\n",
    "\n",
    "# For each subinterval, find the best linear approximation\n",
    "for i, (start, end) in enumerate(subintervals):\n",
    "    x_values = np.linspace(start, end, 1000)\n",
    "    result = minimize(linf_norm, initial_guess, args=(x_values,), method='SLSQP')\n",
    "    print(f\"For the subinterval [{start},{end}], the best linear approximation to tanh(x) that minimizes the L infinity norm is: f(x) = {round(result.x[0]*2**6,0)/2**6}*x + {round(result.x[1]*2**6,0)/2**6}\")\n",
    "    print(f\"The minimum cost (L infinity norm) in this subinterval is: {result.fun}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The functions you need go here\n",
    "\n",
    "'''\n",
    "######################### Using this function, found out piecewise linear approximation ############################### \n",
    "import numpy as np\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "# Define the function to approximate\n",
    "def f(x):\n",
    "    return np.tanh(x)\n",
    "\n",
    "# Define the L infinity norm for a subinterval\n",
    "def linf_norm(params, x_values):\n",
    "    a, b = params\n",
    "    return np.max(np.abs(f(x_values) - (a * x_values + b)))\n",
    "\n",
    "# Define the subintervals\n",
    "subintervals = [(0, 1/4), (1/4, 2/4), (2/4, 3/4),(3/4,1)]\n",
    "\n",
    "# Initial guess\n",
    "initial_guess = [0, 0]\n",
    "\n",
    "# For each subinterval, find the best linear approximation\n",
    "for i, (start, end) in enumerate(subintervals):\n",
    "    x_values = np.linspace(start, end, 1000)\n",
    "    result = minimize(linf_norm, initial_guess, args=(x_values,), method='SLSQP')\n",
    "    print(f\"For the subinterval [{start},{end}], the best linear approximation to tanh(x) that minimizes the L infinity norm is: f(x) = {result.x[0]}*x + {result.x[1]}\")\n",
    "    print(f\"The minimum cost (L infinity norm) in this subinterval is: {result.fun}\")\n",
    "'''\n",
    "\n",
    "@qfunc\n",
    "def initialize_controller(x: QArray[QBit], controller: QArray[QBit]):                  \n",
    "    #repeat(controller.len, lambda i: lambda :CX(x[x.len-i-1], controller[i]))\n",
    "    #CX(x[x.len-controller.len],controller[0])\n",
    "    CX(x[x.len-1],controller[0])                                                      # Control and target are mixed !\n",
    "    CX(x[x.len-2],controller[1])                                                      # I guess it is no problem as long as it's consistent !\n",
    "\n",
    "@qfunc\n",
    "def poly_func(a:CReal, b:CReal, x:QNum, y: Output[QNum]):\n",
    "    y |= a*x + b\n",
    "@qfunc\n",
    "def inplace_poly_func(a:CReal,b:CReal,  x:QNum, y: QNum): # Placeing which \n",
    "    tmp = QNum('tmp')\n",
    "    within_apply(compute= lambda: poly_func(a,b,x,tmp),\n",
    "                action= lambda: inplace_xor(tmp,y))\n",
    "\n",
    "@qfunc\n",
    "def control_logic(a: CArray[float], b: CArray[float], x: QNum, y:QNum, controller:QNum):\n",
    "    repeat(a.len, iteration = lambda i: control(controller == i, lambda: inplace_poly_func(a[i],b[i],x,y)))\n",
    "    free(controller)\n",
    "    allocate_num(2,False,0,controller)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Your precision value\n",
    "precision = 4\n",
    "a_t = [0.984375, 0.875, 0.6875, 0.5]\n",
    "b_t = [0, 0.03125, 0.125, 0.265625]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The heart of the code - the function that calculates the hyperbolic tangent\n",
    "@qfunc\n",
    "def compute_tanh(precision: CInt,    # The precision of x and tanh_x - how many fraction digits will represent your solution\n",
    "                 x: QNum,                   # A quantum variable that represents numbers\n",
    "                 tanh_x: Output[QNum]       # The output of the function, which means it needs to be initialized within the scope of the function\n",
    "                 ):\n",
    "    \n",
    "    \n",
    "    allocate_num(precision + 2, False, precision + 2, tanh_x)\n",
    "    controller = QNum('controller')\n",
    "    allocate_num(2 , False, 0, controller)\n",
    "    initialize_controller(x,controller)\n",
    "    control_logic(a_t,b_t,x,tanh_x,controller)\n",
    "    \n",
    "    #inplace_poly_func(0.5,0.25,x,tanh_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Do not change this part of the code !\n",
    "\n",
    "@qfunc\n",
    "def main(x: Output[QNum],y: Output[QNum]):\n",
    "\n",
    "    # A quantum variable which represents numbers is initialized\n",
    "    allocate_num(num_qubits=precision,      \n",
    "                is_signed=False,            \n",
    "                fraction_digits=precision,\n",
    "                out=x)\n",
    "    \n",
    "    # Initalizing over all possible values of the quantum number with the hadamard transform\n",
    "    hadamard_transform(x)\n",
    "    \n",
    "    # Computing your compute_tanh function\n",
    "    compute_tanh(precision,x,y)\n",
    "\n",
    "# Generating the model itslef\n",
    "qmod = create_model(main)\n",
    "qmod = set_constraints(qmod, Constraints(optimization_parameter='width'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening: https://platform.classiq.io/circuit/711d5b22-2e61-4283-8de0-ed8ebb6222b4?version=0.40.0\n",
      "{'x': 0.6875, 'y': 0.375}\n",
      "{'x': 0.5, 'y': 0.46875}\n",
      "{'x': 0.75, 'y': 0.640625}\n",
      "{'x': 0.625, 'y': 0.078125}\n",
      "{'x': 0.1875, 'y': 0.171875}\n",
      "{'x': 0.25, 'y': 0.296875}\n",
      "{'x': 0.0, 'y': 0.0}\n",
      "{'x': 0.5625, 'y': 0.765625}\n",
      "{'x': 0.3125, 'y': 0.328125}\n",
      "{'x': 0.375, 'y': 0.375}\n",
      "{'x': 0.4375, 'y': 0.421875}\n",
      "{'x': 0.9375, 'y': 0.734375}\n",
      "{'x': 0.8125, 'y': 0.671875}\n",
      "{'x': 0.0625, 'y': 0.046875}\n",
      "{'x': 0.125, 'y': 0.109375}\n",
      "{'x': 0.875, 'y': 0.703125}\n",
      "{'x': 0.8125, 'y': 0.65625}\n",
      "{'x': 0.875, 'y': 0.6875}\n",
      "{'x': 0.3125, 'y': 0.34375}\n",
      "{'x': 0.375, 'y': 0.390625}\n",
      "{'x': 0.4375, 'y': 0.40625}\n",
      "{'x': 0.4375, 'y': 0.453125}\n",
      "{'x': 0.9375, 'y': 0.71875}\n",
      "{'x': 0.5625, 'y': 0.78125}\n",
      "{'x': 0.3125, 'y': 0.3125}\n",
      "{'x': 0.875, 'y': 0.734375}\n",
      "{'x': 0.9375, 'y': 0.703125}\n",
      "{'x': 0.4375, 'y': 0.4375}\n",
      "{'x': 0.4375, 'y': 0.390625}\n",
      "{'x': 0.375, 'y': 0.359375}\n",
      "{'x': 0.375, 'y': 0.40625}\n",
      "{'x': 0.3125, 'y': 0.4375}\n",
      "{'x': 0.625, 'y': 0.0625}\n",
      "{'x': 0.375, 'y': 0.3125}\n",
      "{'x': 0.8125, 'y': 0.578125}\n",
      "{'x': 0.375, 'y': 0.15625}\n",
      "{'x': 0.625, 'y': 0.1875}\n",
      "{'x': 0.875, 'y': 0.671875}\n",
      "{'x': 0.8125, 'y': 0.703125}\n"
     ]
    }
   ],
   "source": [
    "qprog = synthesize(qmod)\n",
    "def print_parsed_counts(job):\n",
    "    results = job.result()\n",
    "    parsed_counts = results[0].value.parsed_counts\n",
    "    for parsed_state in parsed_counts: print(parsed_state.state)\n",
    "show(qprog)\n",
    "job = execute(qprog)\n",
    "print_parsed_counts(job)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving the Files - What You Need To Submit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, define the precisions of your solutions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Precision values stages 1&2 - You need to enter these values in Google Form submission\n",
    "precision_value_stage_1 = 4\n",
    "precision_value_stage_2 = 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can create adapted quantum models for the two stages according to the corresponding precisions and constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_model_with_new_precision(qmod, new_precision):\n",
    "    '''\n",
    "    The function adapts the precision value in the qmod according to the new precision value given.\n",
    "    '''\n",
    "    \n",
    "    @qfunc\n",
    "    def compute_tanh(\n",
    "        precision: CInt,\n",
    "        x: QNum,\n",
    "        tanh_x: Output[QNum],\n",
    "    ):\n",
    "        # dummy implementation\n",
    "        allocate_num(precision, False, precision, tanh_x)\n",
    "\n",
    "    @qfunc\n",
    "    def main(x: Output[QNum], y: Output[QNum]):\n",
    "        allocate_num(new_precision, False, new_precision, x)\n",
    "        hadamard_transform(x)\n",
    "        compute_tanh(new_precision, x, y)\n",
    "\n",
    "    new_main = main.create_model().main_func\n",
    "    parsed_qmod = Model_Designer.parse_obj(json.loads(qmod))\n",
    "    new_model = Model_Designer(functions=[f for f in parsed_qmod.functions if f.name != \"main\"] + [new_main])\n",
    "    return new_model.get_model()\n",
    "\n",
    "\n",
    "# Adapting the qmod for the relevant constraints - stage 1\n",
    "max_width_stage_1 = 30\n",
    "max_depth_stage_1 = 3000\n",
    "synthesis_timeout_sec_stage_1 = 90\n",
    "qmod_stage_1 = get_model_with_new_precision(qmod,precision_value_stage_1)\n",
    "qmod_stage_1 = set_constraints(qmod_stage_1,Constraints(max_width=max_width_stage_1,max_depth=max_depth_stage_1))\n",
    "qmod_stage_1 = set_preferences(qmod_stage_1, Preferences(timeout_seconds=synthesis_timeout_sec_stage_1))\n",
    "\n",
    "# Adapting the qmod for the relevant constraints - stage 2\n",
    "max_width_stage_2 = 100\n",
    "max_depth_stage_2 = 30000\n",
    "synthesis_timeout_sec_stage_2 = 180\n",
    "optimization_param = \"depth\"\n",
    "qmod_stage_2 = get_model_with_new_precision(qmod,precision_value_stage_2)\n",
    "qmod_stage_2 = set_constraints(qmod_stage_2,Constraints(max_width=max_width_stage_2,max_depth=max_depth_stage_2,optimization_parameter=optimization_param))\n",
    "qmod_stage_2 = set_preferences(qmod_stage_2, Preferences(timeout_seconds=synthesis_timeout_sec_stage_2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now in order to save the deliverables files, you should adapt the following file names including their locations (no need to include the file extensions, i.e. do not add `.qprog`/`.qmod` at the end):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Files names (no extensions needed!)\n",
    "file_name_qmod = 'qmod_default' #TODO change to your file_name\n",
    "file_name_qprog_stage_1 = 'qprog_stage_1_default' #TODO change to your file_name\n",
    "file_name_qprog_stage_2 = 'qprog_stage_2_default' #TODO change to your file_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following cell to save the relevant deliverables:\n",
    "1. Your model (`.qmod` file)\n",
    "2. Your quantum program for stage 1 with the corresponding precision (`.qprog` file)\n",
    "3. Your quantum program for stage 2 with the corresponding precision (`.qprog` file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def save_new_file(program_to_save,file_name):\n",
    "    '''\n",
    "    A simple function that saves your code as a text file\n",
    "    '''\n",
    "    file = open(file_name,\"w\")\n",
    "    file.write(program_to_save)\n",
    "    file.close()\n",
    "\n",
    "\n",
    "# Saving the qmod\n",
    "save_new_file(qmod, file_name_qmod+'.qmod') # You need to submit this file\n",
    "\n",
    "# Save the qprof of stage 1\n",
    "qprog_stage_1 = synthesize(qmod_stage_1)\n",
    "save_new_file(qprog_stage_1, file_name_qprog_stage_1+'.qprog') # You need to submit this file\n",
    "\n",
    "# Save the qprog of stage 2\n",
    "qprog_stage_2 = synthesize(qmod_stage_2)\n",
    "save_new_file(qprog_stage_2, file_name_qprog_stage_2+'.qprog') # You need to submit this file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth checking out your quantum programs by viewing them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening: https://platform.classiq.io/circuit/6afb0468-4d9a-4f65-937a-0e83fd433529?version=0.36.1\n"
     ]
    }
   ],
   "source": [
    "show(qprog_stage_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening: https://platform.classiq.io/circuit/d2c1883d-1514-427c-9a44-cb779d64a902?version=0.36.1\n"
     ]
    }
   ],
   "source": [
    "show(qprog_stage_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Your Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the results of stage 1:\n",
    "\n",
    "**NOTE!** \n",
    "- With the `aer_simulator` you can simulate up to 25 qubits circuit\n",
    "- With the `nvidia_state_vector_simulator` you can simulate up to 30 qubits circuit, but you can use it up to 10 times, so make sure to use it wisely"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synthesizing quantum program stage 1 with the execution preferences\n",
      "Synthesized circuit width: 24, depth: 1038\n",
      "Executing the quantum program\n",
      "{'x': 0.0, 'y': 0.0}\n",
      "{'x': 0.0625, 'y': 0.046875}\n",
      "{'x': 0.125, 'y': 0.109375}\n",
      "{'x': 0.1875, 'y': 0.171875}\n",
      "{'x': 0.25, 'y': 0.296875}\n",
      "{'x': 0.3125, 'y': 0.328125}\n",
      "{'x': 0.375, 'y': 0.375}\n",
      "{'x': 0.4375, 'y': 0.421875}\n",
      "{'x': 0.5, 'y': 0.46875}\n",
      "{'x': 0.5625, 'y': 0.515625}\n",
      "{'x': 0.625, 'y': 0.578125}\n",
      "{'x': 0.6875, 'y': 0.625}\n",
      "{'x': 0.75, 'y': 0.640625}\n",
      "{'x': 0.8125, 'y': 0.671875}\n",
      "{'x': 0.875, 'y': 0.703125}\n",
      "{'x': 0.9375, 'y': 0.734375}\n",
      "Results of stage 1 \n",
      " Max distance =  0.07651642404404378\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def evaluate_score_stage_1(results, user_input_precision):\n",
    "\n",
    "    # The array of values the code is compared against \n",
    "    calculated_precision = 10\n",
    "    domain = np.arange(0, 1, 1/ 2**calculated_precision)\n",
    "    expected_y = np.tanh(domain)\n",
    "    \n",
    "    # Sort the results according to the values of x\n",
    "    parsed_counts = sorted(results[0].value.parsed_counts, key=lambda x: x.state[\"x\"])\n",
    "    for tuple in parsed_counts: print(tuple.state)\n",
    "\n",
    "    # Form the relevant dictionary with values of 'x' and 'y'\n",
    "    results_dict = {s.state['x']: s.state['y'] for s in parsed_counts}\n",
    "\n",
    "    # Verify all strings were sampled, also no superpositions\n",
    "    assert len(results_dict) == 2 ** user_input_precision \n",
    "\n",
    "    # Comparing to the users results\n",
    "    measured_y = []\n",
    "    for x_val in domain:\n",
    "        # The y value that is assesd at x_val is the y value of the first x the user has such that x<x_val\n",
    "        x_val_floored = int(x_val * (2**user_input_precision)) / (2**user_input_precision)\n",
    "        measured_y.append(results_dict[x_val_floored])\n",
    "\n",
    "    # The metric asseses what's the largest distancce between the expected value and the measured value, the smallest the better\n",
    "    max_distance = np.max(np.abs(expected_y - np.array(measured_y)))\n",
    "    return max_distance\n",
    "\n",
    "def print_depth_width(quantum_program):\n",
    "    generated_circuit = GeneratedCircuit.parse_obj(json.loads(quantum_program))\n",
    "    print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n",
    "\n",
    "# Execution parameters\n",
    "num_shots = 1000\n",
    "backend_name = \"aer_simulator\" # \"aer_simulator\", \"nvidia_state_vector_simulator\"\n",
    "\n",
    "qmod_stage_1 = set_execution_preferences(qmod_stage_1, \n",
    "                                        ExecutionPreferences(\n",
    "                                            num_shots=1000,  # The number of shots is a hyperparameter of the algorithm\n",
    "                                            backend_preferences=ClassiqBackendPreferences(\n",
    "                                                                    backend_name=backend_name))) #aer_simulator / nvidia_state_vector_simulator\n",
    "print('Synthesizing quantum program stage 1 with the execution preferences')\n",
    "qprog_stage_1 = synthesize(qmod_stage_1)\n",
    "print_depth_width(qprog_stage_1)\n",
    "print('Executing the quantum program')\n",
    "results = execute(qprog_stage_1).result()\n",
    "print(\"Results of stage 1 \\n Max distance = \", evaluate_score_stage_1(results, precision_value_stage_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evluate the results of stage 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Results of stage 2 \n",
      "Precision = 30, Circuit depth = 5090\n"
     ]
    }
   ],
   "source": [
    "generated_circuit = GeneratedCircuit.parse_obj(json.loads(qprog_stage_2))\n",
    "print(f'\\nResults of stage 2 \\nPrecision = {precision_value_stage_2}, Circuit depth = {generated_circuit.transpiled_circuit.depth}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cheat Sheet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_value_stage_1"
   ]
  }
 ],
 "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.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "39f2fb914d68d910e6a44db3a048977f45af665714e1ed570fe3896698105d3f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}