iQuHack-challenge-2023-task1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "# MIT iQuHack Microsoft Challenge: Optimizing Quantum Oracles, Task 1\n",
    "\n",
    "To work on this task,\n",
    "1. Use the notebook for this task. Each of the notebooks in the repository has the code of the corresponding task.\n",
    "2. Update your team name and Slack ID variables in the next code cell (you can use different Slack IDs for different tasks if different team members work on them, but make sure to use the same team name throughout the Hackathon). Do not change the task variable!\n",
    "3. Work on your task in the cell that contains operation `Task1`! Your goal is to rewrite the code so that it maintains its correctness, but requires as few resources as possible. See `evaluate_results` function for details on how your absolute score for the task is calculated.\n",
    "4. Submit your task using qBraid. Use the Share Notebook feature on qBraid (See File > Share Notebook) and enter the email rickyyoung@qbraid.com.   Once you click submit, if the share notebook feature works correctly, it should show that you receive no errors and the email you entered will disappear. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "Log in to Azure (once per session, don't need to do it if running from Azure workspace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "!az login"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "## Step 1. Write the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# Run this code cell to import the modules required to work with Q# and Azure\n",
    "import qsharp\n",
    "from qsharp import azure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "teamname=\"msft_is_the_best\"  # Update this field with your team name\n",
    "task=[\"task1\"]\n",
    "slack_id=\"myslackid\"         # Update this field with Slack ID of the person who worked on this task as the troubleshooting contact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# You don't need to run this cell, it defines Q# operations as Python types to keep IntelliSense happy\n",
    "Task1_DumpMachineWrapper : qsharp.QSharpCallable = None\n",
    "Task1_ResourceEstimationWrapper : qsharp.QSharpCallable = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "**The complete code for Task 1 should be in this cell.**   \n",
    "This cell can include additional open statements and helper operations and functions if your solution needs them.  \n",
    "If you define helper operations in other cells, they will not be picked up by the grader!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "microsoft": {
     "language": "qsharp"
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "%%qsharp\n",
    "open Microsoft.Quantum.Canon;\n",
    "open Microsoft.Quantum.Diagnostics;\n",
    "\n",
    "// Task 1. Warm up with simple bit manipulation\n",
    "// (input will contain 3 qubits)\n",
    "operation Task1(input : Qubit[], target : Qubit) : Unit is Adj {\n",
    "    let N = Length(input);\n",
    "    use aux = Qubit[N - 1];\n",
    "    within {\n",
    "        for i in 0 .. N - 2 {\n",
    "            CNOT(input[i], aux[i]);\n",
    "            CNOT(input[i + 1], aux[i]);\n",
    "        }\n",
    "    } apply {\n",
    "        Controlled X(aux, target);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "microsoft": {
     "language": "qsharp"
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "%%qsharp\n",
    "// Wrapper operation that allows you to observe the effects of the marking oracle by running it on a simulator.\n",
    "operation Task1_DumpMachineWrapper() : Unit {\n",
    "    let N = 3;\n",
    "    use (input, target) = (Qubit[N], Qubit());\n",
    "    // Prepare an equal superposition of all input states in the input register.\n",
    "    ApplyToEach(H, input);\n",
    "    // Apply the oracle.\n",
    "    Task1(input, target);\n",
    "    // Print the state of the system after the oracle application.\n",
    "    DumpMachine();\n",
    "    ResetAll(input + [target]);\n",
    "}\n",
    "\n",
    "// Wrapper operation that allows to run resource estimation for the task.\n",
    "// This operation only allocates the qubits and applies the oracle once, not using any additional gates or measurements.\n",
    "operation Task1_ResourceEstimationWrapper() : Unit {\n",
    "    let N = 3;\n",
    "    use (input, target) = (Qubit[N], Qubit());\n",
    "    Task1(input, target);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "## Step 2. Run the code on a simulator to see what it does\n",
    "You can also write your own code to explore the effects of the oracle (for example, applying it to different basis states and measuring the results)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# Note that in the output of this cell the target qubit corresponds to the rightmost bit\n",
    "qsharp.config[\"dump.basisStateLabelingConvention\"]=\"Bitstring\"\n",
    "qsharp.config[\"dump.phaseDisplayStyle\"]=\"None\"\n",
    "# Uncomment the following line if you want to see only the entries with non-zero amplitudes\n",
    "# qsharp.config[\"dump.truncateSmallAmplitudes\"]=True\n",
    "Task1_DumpMachineWrapper.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "## Step 3. Evaluate the code using resource estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# If you're using this notebook in Azure Quantum hosted notebooks, remove the credential=\"CLI\" parameter!\n",
    "# If you're using this notebook in qBraid, keep it\n",
    "qsharp.azure.connect(\n",
    "    resourceId=\"...\",\n",
    "    location=\"...\",\n",
    "    credential=\"CLI\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "qsharp.azure.target(\"microsoft.estimator\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# Update job name to a more descriptive string to make it easier to find it in Job Management tab later\n",
    "result = qsharp.azure.execute(Task1_ResourceEstimationWrapper, jobName=\"RE for the task 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# If you need to pull up the results of an old job, use its job ID with qsharp.azure.output command\n",
    "# result = qsharp.azure.output(\"...\")\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# The function that extracts the relevant resource information from the resource estimation job results and produces your absolute score.\n",
    "def evaluate_results(res) : \n",
    "    width = res['physicalCounts']['breakdown']['algorithmicLogicalQubits']\n",
    "    depth = res['physicalCounts']['breakdown']['algorithmicLogicalDepth']\n",
    "    print(f\"Logical algorithmic qubits = {width}\")\n",
    "    print(f\"Algorithmic depth = {depth}\")\n",
    "    print(f\"Score = {width * depth}\")\n",
    "    return width * depth\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "evaluate_results(result)"
   ]
  }
 ],
 "metadata": {
  "kernel_info": {
   "name": "python3"
  },
  "kernelspec": {
   "display_name": "Python 3 [Default]",
   "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.9.10"
  },
  "nteract": {
   "version": "nteract-front-end@1.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}