challenge.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qnumerics Mitiq coding challenge\n",
    "\n",
    "Welcome to the Mitiq coding challenge.\n",
    "This notebook is designed to get you familiar with some of the tools that Mitiq can offer.\n",
    "While Mitiq is predominantly a tool for error mitigation (and these challenges will show you that), it also has lots of other helpful tools which you can use to help other challenges you may face when programming quantum devices.\n",
    "\n",
    "Almost all of the challenges will require you to peruse Mitiq's [API-doc](https://mitiq.readthedocs.io/en/stable/apidoc.html) or [Users Guide](https://mitiq.readthedocs.io/en/stable/guide/guide.html) and most solutions require a single call to a function in Mitiq.\n",
    "If you find yourself writing more than 5 lines of code for a single challenge (with the exception of the last one), try checking the documentation again ;)\n",
    "\n",
    "### Set up\n",
    "\n",
    "In order to successfully complete the challenges below, you'll need a few packages installed.\n",
    "Install using the following command in the terminal.\n",
    "\n",
    "```\n",
    "pip install -r requirements.txt\n",
    "```\n",
    "\n",
    "If you have any questions please grab our attention so we can help you out!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mitiq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 1: in the beginning, there were circuits\n",
    "\n",
    "Often when testing error mitigation strategies it's important to understand the stratagies performance across a wide-array of different circuit types and structures.\n",
    "The `mitiq.benchmarks` module contains a plethora of functions which create benchmarking circuits with given parameters such as number of qubits and depth.\n",
    "\n",
    "To get things started, create a Clifford+T circuit using the `mitiq.benchmarks` module.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ct = ...\n",
    "print(ct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 2: making friends\n",
    "\n",
    "Mitiq supports circuits written in different Python software libraries, such as Google Cirq, IBM Qiskit, Xanadu Pennylane, etc.\n",
    "\n",
    "By default, benchmarking circuits are instantiated as `cirq.Circuit` objects from Google Cirq.\n",
    "In this challenge you'll need to convert the circuit created in Challenge 1 to a `qiskit.QuantumCircuit` object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qiskit_ct = ...\n",
    "print(qiskit_ct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 3: pauli ~~matrix~~ string\n",
    "\n",
    "Now that we have a circuit, we'll want to create an observable.\n",
    "Observables in Mitiq are represented as a linear combination of Pauli strings.\n",
    "Browse Mitiq's API-doc to find how to define a Pauli string.\n",
    "Play around with the three arguments to learn how they work!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ps = ...\n",
    "print(ps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 4: overlapping paulis\n",
    "\n",
    "Suppose we have a circuit and we'd like to measure two Pauli strings in said circuit.\n",
    "One way to accomplish this would be to measure Pauli string 1 in the circuit, and then later measure Pauli string 2 in the circuit.\n",
    "There can be a faster way if Pauli string 1 and 2 are \"compatible\" in some sense.\n",
    "In this case the two Pauli strings can be measure simultaneously, meaning one less circuit execution.\n",
    "\n",
    "Using the Pauli string you've defined above, define a new Pauli string that would allow you to measure both at the same time.\n",
    "Check your answer using [`can_be_measured_with`](https://mitiq.readthedocs.io/en/stable/apidoc.html#mitiq.observable.pauli.PauliString.can_be_measured_with).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ps2 = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 5: measuring Mr. Pauli\n",
    "\n",
    "Nice job creating simultaneously measurable Paulis!\n",
    "You're now tasked with using these Paulis to create a `mitiq.Observable` representing the two of them (perhaps with coefficients) together.\n",
    "Use the observable to add measurements to the Clifford+T circuit defined in challenge 1.\n",
    "\n",
    "⚠️ **This function is missing from our API-doc!**\n",
    "I'll save you digging through the code to let you know that `mitiq.Observable` objects have a `measure_in` method which takes a circuit as argument.\n",
    "\n",
    "Ensure that only one circuit is returned from the `measure_in` call.\n",
    "If you have more than one, are you sure the Pauli strings are simultaneously measurable?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paulis = [...]\n",
    "\n",
    "obs = mitiq.Observable(*paulis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 6: unfriendly paulis\n",
    "\n",
    "Define two pauli strings that refuse to be measured at the same time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paulis = [...]\n",
    "\n",
    "obs = mitiq.Observable(*paulis)\n",
    "\n",
    "obs.measure_in(ct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 7: advisor delight\n",
    "\n",
    "Suppose you are given the following matrix by your advisor and they task you with measuring it after your circuit is run.\n",
    "Can you determine the Pauli string which is equivalent?\n",
    "Check your answer with the `matrix` method of your `PauliString` object.\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "    0 & 0  & 0 & -i \\\\\n",
    "    0 & 0  & i & 0  \\\\\n",
    "    0 & -i & 0 & 0  \\\\\n",
    "    i & 0  & 0 & 0  \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ps = ...\n",
    "ps.matrix()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 8: keeping results safe\n",
    "\n",
    "You've run an experiment on a quantum device, and received the following dictionary with the counts of the bitstrings that were measured, along with the number of times they were encountered.\n",
    "Convert the dictionary to a `mitiq.MeasurementResult` object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bitstring_counts = {\n",
    "    \"0001\": 70,\n",
    "    \"0010\": 51,\n",
    "    \"0100\": 68,\n",
    "    \"1001\": 437,\n",
    "    \"0110\": 374\n",
    "}\n",
    "mr = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 9: probability > counts\n",
    "\n",
    "Often, raw counts aren't as useful as probabilities.\n",
    "Instead of a dictionary mapping bitstrings to counts, create a dictionary mapping bitstrings to probabilities of measuring said bitstring.\n",
    "Test your answer by comparing your answer to the `prob_distribution` method of your `MeasurementResult` object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob = dict()\n",
    "\n",
    "prob == mr.prob_distribution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 10: throwaway the bad\n",
    "\n",
    "You've got a probability distribution now, but you know from some feature of your experiment that the only possible (logical) outcomes are bitstrings that read the same forward and backward.\n",
    "Hence, you can throw away all the data that is **not** a palindrome.\n",
    "\n",
    "Use the `post_select` function from Mitiq's Readout Error Mitigation module to filter your data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mitiq.rem import post_select # can remove"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 11: ~~total variation distance~~ math\n",
    "\n",
    "Since we've thrown away some data, it might be useful to have an understanding of _how much_ we've changed the data.\n",
    "Compute the [total variation distance](https://en.wikipedia.org/wiki/Total_variation_distance_of_probability_measures) between the pre and post-selected measurement results.\n",
    "\n",
    "A utility function to generate all the bitstrings of a given length is provided :)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "def generate_bitstrings(length):\n",
    "    return [''.join(bits) for bits in itertools.product('01', repeat=length)]\n",
    "\n",
    "\n",
    "tvd = 0\n",
    "# compute\n",
    "print(tvd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 12: twirling\n",
    "\n",
    "Great work on the above experiment and making results more accurate by post-selection.\n",
    "Only thing is, the results aren't giving close enough predictions when compared with ideal simulation 😭.\n",
    "In order to further improve our results, we'll start testing some quantum error mitigation (QEM) strategies.\n",
    "\n",
    "Stricly speaking, Pauli twirling is not always considered a an error mitigation strategy.\n",
    "It is often referred to as a noise tailoring technique that transforms coherent noise into incoherent noise.\n",
    "For details about how the mathematics of this technique works, check out the [theory section](https://mitiq.readthedocs.io/en/stable/guide/pt-5-theory.html) of the user guide, along with the references therein.\n",
    "\n",
    "To try it out, generate 100 Pauli twirled variants of a GHZ circuit on 3 qubits.\n",
    "How many of them are unique?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = mitiq.benchmarks.generate_ghz_circuit(3)\n",
    "\n",
    "from mitiq.pt import generate_pauli_twirl_variants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 13: twirling overhead\n",
    "\n",
    "Overhead refers to the amount of resources required for a technique to run.\n",
    "In the instance of Pauli twirling we have two types of overhead:\n",
    "\n",
    "1. The number of unique circuits (computed above), and\n",
    "2. the number of additional gates in each circuit.\n",
    "\n",
    "Let's continue down this line by understanding #2.\n",
    "How many more gates do the Pauli twirled variants contain than the original circuit?\n",
    "Are they all the same length?\n",
    "Did you count the identity as a gate?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 14: dddddddddddddd: $XX$\n",
    "\n",
    "Another technique that introduces relatively limited overhead is digital dynamical decoupling.\n",
    "Since you've already seen some of this technique earlier, I won't belabor the explanation.\n",
    "\n",
    "Insert an $XX$ sequence in a circuit that you define.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 15: make your own rules\n",
    "\n",
    "Define a custom rule, and insert it into a circuit.\n",
    "What happens when the gate sequence doesn't equal the identity?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mitiq.ddd.rules import general_rule\n",
    "\n",
    "import cirq\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 16: rules don't apply\n",
    "\n",
    "Define a circuit on 3 qubits with depth > 4 where you cannot insert a 4-gate DDD sequence.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 17: compute; uncompute; compute\n",
    "\n",
    "In order to apply a technique like Zero-Noise Extrapolation you need to have a method to scale noise up.\n",
    "This is most commonly done using some version of folding.\n",
    "Mitiq has many ways to achieve this through the `mitiq.zne.scaling` module.\n",
    "To start using it, fold the following circuit globally.\n",
    "That is, if your circuit of interst defines a unitary $U$, construct a new circuit whose operation is $UU^\\dag U$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = mitiq.benchmarks.generate_rb_circuits(2, 1)[0]\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 18: same thing, but different\n",
    "\n",
    "Now of course you can always fold more times resulting in a deeper circuit by repeating the identity portion: $U(U^\\dag U)^n$.\n",
    "Using these circuits means only using odd integer scale factors, but it's possible to use other values as well.\n",
    "\n",
    "We cannot use `fold_global` anymore, but find a way to increase the circuits depth by 2 using a different folding technique.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 19: same thing; but smarter\n",
    "\n",
    "In many instances, it is advantageous to keep circuit depth as low as possible and the unitary folding is introducing a lot of gates!\n",
    "If you know a majority of your noise is coming from two-qubit gates it's possible to _just_ fold those gates to leave single qubit gates unfolded.\n",
    "Can you find a way in Mitiq to do this?\n",
    "Does `scale_factor` still retain its meaning as in the equation below?\n",
    "\n",
    "```\n",
    "folded_depth = scale_factor * len(circuit)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 20: use it!\n",
    "\n",
    "Using the following circuit, and function which runs circuits, apply zero-noise extrapolation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = mitiq.benchmarks.generate_rb_circuits(2, 2)[0]\n",
    "\n",
    "def execute(circuit, noise_level=0.01):\n",
    "    \"\"\"Returns Tr[ρ |0⟩⟨0|] where ρ is the state prepared by the circuit\n",
    "    with depolarizing noise.\"\"\"\n",
    "    noisy_circuit = circuit.with_noise(cirq.depolarize(p=noise_level))\n",
    "    return (\n",
    "        cirq.DensityMatrixSimulator()\n",
    "        .simulate(noisy_circuit)\n",
    "        .final_density_matrix[0, 0]\n",
    "        .real\n",
    "    )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 21: the last part of ZN**E**\n",
    "\n",
    "Define what is called a `Factory`. This is an object that will handle the classical portion of ZNE: extrapolation. Pass it into `execute_with_zne` and then inspect the fit by calling `factory.plot_fit()`. Can you use this plot to modify the scale factors to obtain more accurate expectation values?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 22: do it all\n",
    "\n",
    "You're now ready to apply ZNE in your own (real) workflow!\n",
    "Use everything you've learned thus far to apply ZNE with a custom observable, and extrapolation factory to a circuit of interest.\n",
    "If you're running on a simulator, you'll have to make some considerations:\n",
    "\n",
    "- What noise model will I use?\n",
    "- What noise strength is realistic?\n",
    "\n",
    "Running on a simulated noise model is often the best way to \"practice\" tuning the error mitigation strategy before taking it to hardware.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}