qiskit/aqua/generating_random_variates.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# _*Qiskit Aqua: Generating Random Variates*_ \n",
    "\n",
    "The latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorials.\n",
    "\n",
    "***\n",
    "### Contributors\n",
    "Albert Akhriev<sup>[1]</sup>, Jakub Marecek<sup>[1]</sup>\n",
    "\n",
    "### Affliation\n",
    "- <sup>[1]</sup>IBMQ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "While classical computers use only pseudo-random routines, quantum computers\n",
    "can generate true random variates.\n",
    "For example, the measurement of a quantum superposition is intrinsically random,\n",
    "as suggested by Born's rule.\n",
    "Consequently, some of the\n",
    "best random-number generators are based on such quantum-mechanical effects. (See the \n",
    "Further, with a logarithmic amount of random bits, quantum computers can produce\n",
    "linearly many more bits, which is known as \n",
    "randomness expansion protocols. \n",
    "\n",
    "In practical applications, one wishes to use random variates of well-known\n",
    "distributions, rather than random bits.\n",
    "In this notebook, we illustrate ways of generating random variates of several popular\n",
    "distributions on IBM Q.\n",
    "\n",
    "## Random Bits and the Bernoulli distribution\n",
    "\n",
    "It is clear that there are many options for generating random bits (i.e., Bernoulli-distributed scalars, taking values either 0 or 1). Starting from a simple circuit such as a Hadamard gate followed by measurement, one can progress to vectors of Bernoulli-distributed elements. By addition of such random variates, we could get binomial distributions. By multiplication we could get geometric distributions, although perhaps leading to a circuit depth that may be impratical at the moment, though.\n",
    "\n",
    "Let us start by importing the basic modules and creating a quantum circuit for generating random bits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sys, math, time\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n",
    "from qiskit import BasicAer\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute\n",
    "\n",
    "# In this example we use 'qasm_simulator' backend.\n",
    "glo_backend = BasicAer.get_backend(\"qasm_simulator\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next step we create a quantum circuit, which will be used for generation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 903x620.06 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Number of qubits utilised simultaneously.\n",
    "glo_num_qubits = 5\n",
    "\n",
    "def create_circuit(num_target_qubits: int) -> QuantumCircuit:\n",
    "    \"\"\"\n",
    "    Creates and returns quantum circuit for random variate generation.\n",
    "    :param num_target_qubits: number of qubits to be used.\n",
    "    :return: quantum curcuit.\n",
    "    \"\"\"\n",
    "    assert isinstance(num_target_qubits, int) and num_target_qubits > 0\n",
    "    q = QuantumRegister(num_target_qubits)\n",
    "    c = ClassicalRegister(num_target_qubits)\n",
    "    circuit = QuantumCircuit(q, c)\n",
    "    circuit.h(q)\n",
    "    circuit.barrier()\n",
    "    circuit.measure(q, c)\n",
    "    return circuit\n",
    "\n",
    "# Create and plot generating quantum circuit.\n",
    "circuit = create_circuit(glo_num_qubits)\n",
    "#print(circuit)\n",
    "circuit.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uniformly-distributed scalars and vectors\n",
    "\n",
    "It is clear that there are many options for approximating uniformly-distributed scalars by the choice of an integer from a finite range uniformly at random, e.g., by a binary-code construction from the Bernoulli-distributed vectors. In the following snippet, we generate random bits, which we then convert using the binary-code construction, up to the machine precision of a classical computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uniform_rand_float64(circuit: QuantumCircuit, num_target_qubits: int,\n",
    "                         size: int, vmin: float, vmax: float) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Generates a vector of random float64 values in the range [vmin, vmax].\n",
    "    :param circuit: quantum circuit for random variate generation.\n",
    "    :param num_target_qubits: number of qubits to be used.\n",
    "    :param size: length of the vector.\n",
    "    :param vmin: lower bound.\n",
    "    :param vmax: upper bound.\n",
    "    :return: vector of random values.\n",
    "    \"\"\"\n",
    "    assert sys.maxsize == np.iinfo(np.int64).max    # sizeof(int) == 64 bits\n",
    "    assert isinstance(size, int) and size > 0\n",
    "    assert isinstance(vmin, float) and isinstance(vmax, float) and vmin <= vmax\n",
    "    nbits = 7 * 8                                   # nbits > mantissa of float64\n",
    "    bit_str_len = (nbits * size + num_target_qubits - 1) // num_target_qubits\n",
    "    job = execute(circuit, glo_backend, shots=bit_str_len, memory=True)\n",
    "    bit_str = ''.join(job.result().get_memory())\n",
    "    scale = float(vmax - vmin) / float(2**nbits - 1)\n",
    "    return np.array([vmin + scale * float(int(bit_str[i:i+nbits], 2))\n",
    "                     for i in range(0, nbits * size, nbits)], dtype=np.float64)\n",
    "\n",
    "def uniform_rand_int64(circuit: QuantumCircuit, num_target_qubits: int,\n",
    "                       size: int, vmin: int, vmax: int) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Generates a vector of random int64 values in the range [vmin, vmax].\n",
    "    :param circuit: quantum circuit for random variate generation.\n",
    "    :param num_target_qubits: number of qubits to be used.\n",
    "    :param size: length of the vector.\n",
    "    :param vmin: lower bound.\n",
    "    :param vmax: upper bound.\n",
    "    :return: vector of random values.\n",
    "    \"\"\"\n",
    "    assert sys.maxsize == np.iinfo(np.int64).max        # sizeof(int) == 64 bits\n",
    "    assert isinstance(size, int) and size > 0\n",
    "    assert isinstance(vmin, int) and isinstance(vmax, int) and vmin <= vmax\n",
    "    assert abs(vmin) <= 2**52 and abs(vmax) <= 2**52    # 52 == mantissa of float64\n",
    "    return np.rint(uniform_rand_float64(circuit, num_target_qubits,\n",
    "                                        size, float(vmin), float(vmax))).astype(np.int64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uniform distribution over floating point numbers.\n",
    "In this example we draw a random vector of floating-point values uniformly distributed within some arbitrary selected interval:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uniform distribution over floating point numbers:\n",
      "  sample type: <class 'numpy.ndarray'> , element type: float64 , shape: (54321,)\n",
      "  sample min: -7.6687, max: 19.5191\n",
      "  sampling time: 6.41 secs\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Draw a sample from uniform distribution.\n",
    "start_time = time.time()\n",
    "sample = uniform_rand_float64(circuit, glo_num_qubits, size=54321, vmin=-7.67, vmax=19.52)\n",
    "sampling_time = time.time() - start_time\n",
    "\n",
    "# Print out some details.\n",
    "print(\"Uniform distribution over floating point numbers:\")\n",
    "print(\"  sample type:\", type(sample), \", element type:\", sample.dtype, \", shape:\", sample.shape)\n",
    "print(\"  sample min: {:.4f}, max: {:.4f}\".format(np.amin(sample), np.amax(sample)))\n",
    "print(\"  sampling time: {:.2f} secs\".format(sampling_time))\n",
    "\n",
    "# Plotting the distribution.\n",
    "plt.hist(sample.ravel(),\n",
    "         bins=min(int(np.ceil(np.sqrt(sample.size))), 100),\n",
    "         density=True, facecolor='b', alpha=0.75)\n",
    "plt.xlabel(\"value\", size=12)\n",
    "plt.ylabel(\"probability\", size=12)\n",
    "plt.title(\"Uniform distribution over float64 numbers in [{:.2f} ... {:.2f}]\".format(\n",
    "            np.amin(sample), np.amax(sample)), size=12)\n",
    "plt.grid(True)\n",
    "# plt.savefig(\"uniform_distrib_float.png\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uniform distribution over integers.\n",
    "Our next example is similar to the previous one, but here we generate a random vector of integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uniform distribution over bounded integer numbers:\n",
      "  sample type: <class 'numpy.ndarray'> , element type: int64 , shape: (54321,)\n",
      "  sample min: 37, max: 841\n",
      "  sampling time: 7.15 secs\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Draw a sample from uniform distribution.\n",
    "start_time = time.time()\n",
    "sample = uniform_rand_int64(circuit, glo_num_qubits, size=54321, vmin=37, vmax=841)\n",
    "sampling_time = time.time() - start_time\n",
    "\n",
    "# Print out some details.\n",
    "print(\"Uniform distribution over bounded integer numbers:\")\n",
    "print(\"  sample type:\", type(sample), \", element type:\", sample.dtype, \", shape:\", sample.shape)\n",
    "print(\"  sample min: {:d}, max: {:d}\".format(np.amin(sample), np.amax(sample)))\n",
    "print(\"  sampling time: {:.2f} secs\".format(sampling_time))\n",
    "\n",
    "# Plotting the distribution.\n",
    "plt.hist(sample.ravel(),\n",
    "         bins=min(int(np.ceil(np.sqrt(sample.size))), 100),\n",
    "         density=True, facecolor='g', alpha=0.75)\n",
    "plt.xlabel(\"value\", size=12)\n",
    "plt.ylabel(\"probability\", size=12)\n",
    "plt.title(\"Uniform distribution over int64 numbers in [{:d} ... {:d}]\".format(\n",
    "            np.amin(sample), np.amax(sample)), size=12)\n",
    "plt.grid(True)\n",
    "# plt.savefig(\"uniform_distrib_int.png\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normal distribution\n",
    "\n",
    "To generate random variates with a standard normal distribution using two independent \n",
    "samples $u_1, u_2$ of the uniform distribution on the unit interval [0, 1], one can\n",
    "consider the Box-Muller transform to obtain a 2-vector:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{bmatrix}\n",
    "%R\\cos(\\Theta )=\n",
    "{\\sqrt {-2\\ln u_{1}}}\\cos(2\\pi u_{2}) \\\\\n",
    "% R\\sin(\\Theta )=\n",
    "{\\sqrt {-2\\ln u_{1}}}\\sin(2\\pi u_{2})\n",
    "\\end{bmatrix},\n",
    "\\end{align}\n",
    "\n",
    "wherein we have two independent samples of the standard normal distribution.\n",
    "In IBM Q, this is implemented as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normal_rand_float64(circuit: QuantumCircuit, num_target_qubits: int,\n",
    "                        size: int, mu: float, sigma: float) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Draws a sample vector from the normal distribution given the mean and standard\n",
    "    deviation, using the Box-Muller method. \n",
    "    \"\"\"\n",
    "    TINY = np.sqrt(np.finfo(np.float64).tiny)\n",
    "    assert isinstance(size, int) and size > 0\n",
    "    rand_vec = np.zeros((size,), dtype=np.float64)\n",
    "\n",
    "    # Generate array of uniformly distributed samples, factor 1.5 longer that\n",
    "    # actually needed.\n",
    "    n = (3 * size) // 2\n",
    "    x = np.reshape(uniform_rand_float64(circuit, num_target_qubits,\n",
    "                                        2*n, 0.0, 1.0), (-1, 2))\n",
    "\n",
    "    x1 = 0.0                # first sample in a pair\n",
    "    c = 0                   # counter\n",
    "    for d in range(size):\n",
    "        r2 = 2.0\n",
    "        while r2 >= 1.0 or r2 < TINY:\n",
    "            # Regenerate array of uniformly distributed samples upon shortage.\n",
    "            if c >= n:\n",
    "                c = 0\n",
    "                n = max(size // 10, 1)\n",
    "                x = np.reshape(uniform_rand_float64(circuit, num_target_qubits,\n",
    "                                                    2*n, 0.0, 1.0), (-1, 2))\n",
    "\n",
    "            x1 = 2.0 * x[c, 0] - 1.0        # first sample in a pair\n",
    "            x2 = 2.0 * x[c, 1] - 1.0        # second sample in a pair\n",
    "            r2 = x1 * x1 + x2 * x2\n",
    "            c += 1\n",
    "\n",
    "        f = np.sqrt(np.abs(-2.0 * np.log(r2) / r2))\n",
    "        rand_vec[d] = f * x1\n",
    "        \n",
    "    return (rand_vec * sigma + mu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example demonstrates how to draw a random vector of normally distributed variates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normal distribution (mu=2.400, sigma=5.100):\n",
      "  sample type: <class 'numpy.ndarray'> , element type: float64 , shape: (4321,)\n",
      "  sample min: -18.0259, max: 21.2915\n",
      "  sampling time: 1.85 secs\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Mean and standard deviation.\n",
    "mu = 2.4\n",
    "sigma = 5.1\n",
    "\n",
    "# Draw a sample from the normal distribution.\n",
    "start_time = time.time()\n",
    "sample = normal_rand_float64(circuit, glo_num_qubits, size=4321, mu=mu, sigma=sigma)\n",
    "sampling_time = time.time() - start_time\n",
    "\n",
    "# Print out some details.\n",
    "print(\"Normal distribution (mu={:.3f}, sigma={:.3f}):\".format(mu, sigma))\n",
    "print(\"  sample type:\", type(sample), \", element type:\", sample.dtype, \", shape:\", sample.shape)\n",
    "print(\"  sample min: {:.4f}, max: {:.4f}\".format(np.amin(sample), np.amax(sample)))\n",
    "print(\"  sampling time: {:.2f} secs\".format(sampling_time))\n",
    "\n",
    "# Plotting the distribution.\n",
    "x = np.linspace(mu - 4.0 * sigma, mu + 4.0 * sigma, 1000)\n",
    "analyt = np.exp(-0.5 * ((x - mu) / sigma)**2) / (sigma * math.sqrt(2.0 * math.pi))\n",
    "plt.hist(sample.ravel(),\n",
    "         bins=min(int(np.ceil(np.sqrt(sample.size))), 100),\n",
    "         density=True, facecolor='r', alpha=0.75)\n",
    "plt.plot(x, analyt, '-b', lw=1)\n",
    "plt.xlabel(\"value\", size=12)\n",
    "plt.ylabel(\"probability\", size=12)\n",
    "plt.title(\"Normal distribution: empirical vs analytic\", size=12)\n",
    "plt.grid(True)\n",
    "# plt.savefig(\"normal_distrib.png\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a substantial amount of further work needed to either certify the quality of the source of random numbers (cf. NIST SP 800-90B, Recommendation for the Entropy Sources Used for Random Bit Generation) or to use random variates within quantum algorithms (cf. <a href=\"https://github.com/Qiskit/qiskit-aqua/tree/master/qiskit/aqua/components/uncertainty_models\">uncertainty_models</a> within Qiskit Aqua)."
   ]
  },
  {
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}