docs/source/whitepaper/6-1-conditional-measurements-post-selection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c08d9f6a",
   "metadata": {},
   "source": [
    "# Different Types of Measurement API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36b3ca73",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "TensorCircuit allows for two kinds of operations to be performed that are related to the outcomes of measurements.  These are (i) conditional measurements, the outcomes of which can be used to control downstream conditional quantum gates, and (ii) post-selection, which allows the user to select the post-measurement state corresponding to a particular measurement outcome."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c84b2c24",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5a7fe0d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorcircuit as tc\n",
    "import numpy as np\n",
    "\n",
    "K = tc.set_backend(\"tensorflow\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d7b8153",
   "metadata": {},
   "source": [
    "## Conditional Measurements\n",
    "\n",
    "\n",
    "The `cond_measure` command is used to simulate the process of performing a Z measurement on a qubit,  generating a measurement outcome with probability given by the Born rule, and then collapsing the wavefunction in accordance with the measured outcome.  The classical measurement outcome obtained can then act as a control for a subsequent quantum operation via the `conditional_gate` API and can be used, for instance, to implement the canonical teleportation circuit.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b0deeb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# quantum teleportation of state |psi> = a|0> + sqrt(1-a^2)|1>\n",
    "a = 0.3\n",
    "input_state = np.kron(np.array([a, np.sqrt(1 - a**2)]), np.array([1, 0, 0, 0]))\n",
    "\n",
    "c = tc.Circuit(3, inputs=input_state)\n",
    "c.h(2)\n",
    "c.cnot(2, 1)\n",
    "c.cnot(0, 1)\n",
    "c.h(0)\n",
    "\n",
    "# mid-circuit measurements\n",
    "z = c.cond_measure(0)\n",
    "x = c.cond_measure(1)\n",
    "\n",
    "# if x = 0 apply I, if x = 1 apply X (to qubit 2)\n",
    "c.conditional_gate(x, [tc.gates.i(), tc.gates.x()], 2)\n",
    "\n",
    "# if z = 0 apply I, if z = 1 apply Z (to qubit 2)\n",
    "c.conditional_gate(z, [tc.gates.i(), tc.gates.z()], 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8dfa278d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((<tf.Tensor: shape=(1,), dtype=float32, numpy=array([1.], dtype=float32)>,\n",
       "  <tf.Tensor: shape=(), dtype=float32, numpy=0.90999997>),\n",
       " 0.09,\n",
       " 0.91)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we indeed recover the state at the third qubit.\n",
    "\n",
    "c.measure(2, with_prob=True), a**2, 1 - a**2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1c7f52a",
   "metadata": {},
   "source": [
    "The teleportation circuit is shown below.\n",
    "![](../statics/teleportation.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06aad1d2",
   "metadata": {},
   "source": [
    "## Post Selection\n",
    "\n",
    "Post-selection is enabled in TensorCircuit via the ``post_select`` method.  This allows the user to select the post-$Z$-measurement state of a qubit via the ``keep`` argument. Unlike ``cond_measure``, the state returned by ``post_select`` is collapsed but not normalized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "83d95029",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4,), dtype=complex64, numpy=\n",
       "array([0.        +0.j, 0.        +0.j, 0.        +0.j, 0.70710677+0.j],\n",
       "      dtype=complex64)>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = tc.Circuit(2, inputs=np.array([1, 0, 0, 1] / np.sqrt(2)))\n",
    "c.post_select(0, keep=1)  # measure qubit 0, post-select on outcome 1\n",
    "c.state()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f32fa9bf",
   "metadata": {},
   "source": [
    "This example initialize a $2$-qubit maximally entangled state $\\vert{\\psi}\\rangle = \\frac{\\vert{00}\\rangle+\\vert{11}\\rangle}{\\sqrt{2}}$. The first qubit ($q_0$) is then measured in the $Z$-basis, and the unnormalized state  $\\vert{11}\\rangle/\\sqrt{2}$ corresponding to measurement outcome $1$ is post-selected.\n",
    "\n",
    "This post-selection scheme with unnormalized states is fast and can, for instance, be used to explore various quantum algorithms and nontrivial quantum physics such as measurement-induced entanglement phase transitions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f68b0e6",
   "metadata": {},
   "source": [
    "## Plain Measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "095a1483",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([1.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.5>)\n",
      "(<tf.Tensor: shape=(2,), dtype=float32, numpy=array([1., 0.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.49999997>)\n"
     ]
    }
   ],
   "source": [
    "c = tc.Circuit(3)\n",
    "c.H(0)\n",
    "print(c.measure(0, with_prob=True))\n",
    "print(c.measure(0, 1, with_prob=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4da81502",
   "metadata": {},
   "source": [
    "Note how the plain measure API is virtual in the sense that the state is not collapsed after measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6ef14570",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.49999997>)\n",
      "(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([1.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.5>)\n",
      "(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.49999997>)\n",
      "(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.49999997>)\n",
      "(<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.], dtype=float32)>, <tf.Tensor: shape=(), dtype=float32, numpy=0.49999997>)\n"
     ]
    }
   ],
   "source": [
    "for _ in range(5):\n",
    "    print(c.measure(0, with_prob=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96e803f7",
   "metadata": {},
   "source": [
    "Let's jit `measure`! (with careful random number manipulation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4f87ed82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 1.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([1. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([1. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 1.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([1. 0. 1.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 0. 0.], shape=(3,), dtype=float32)\n",
      "tf.Tensor([0. 1. 0.], shape=(3,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "key = K.get_random_state(42)\n",
    "\n",
    "\n",
    "def measure_on(param, index, key):\n",
    "    K.set_random_state(key)\n",
    "    c = tc.Circuit(n)\n",
    "    for i in range(n):\n",
    "        c.rx(i, theta=param[i])\n",
    "    return c.measure(*index)[0]\n",
    "\n",
    "\n",
    "measure_on_jit = K.jit(measure_on, static_argnums=1)\n",
    "\n",
    "key1 = key\n",
    "for _ in range(30):\n",
    "    key1, key2 = K.random_split(key1)\n",
    "    print(measure_on_jit(K.ones([n]), [0, 1, 2], key2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85fa8168",
   "metadata": {},
   "source": [
    "For a summary of the differences between plain `measure` and the two types of measurement we mentioned here, please see [FAQ documentation](../faq.html#how-to-understand-the-difference-between-different-measurement-methods-for-circuit)."
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}