docs/operators_and_observables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WZ1G8QHhdHZR"
   },
   "source": [
    "##### Copyright 2020 The Cirq Developers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "id": "KQa9t_gadIuR"
   },
   "outputs": [],
   "source": [
    "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "# https://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xwec7FrkdFmi"
   },
   "source": [
    "# Operators and observables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5KZia7jmdJ3V"
   },
   "source": [
    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://quantumai.google/cirq/operators_and_observables\"><img src=\"https://quantumai.google/site-assets/images/buttons/quantumai_logo_1x.png\" />View on QuantumAI</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/quantumlib/Cirq/blob/master/docs/operators_and_observables.ipynb\"><img src=\"https://quantumai.google/site-assets/images/buttons/colab_logo_1x.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://github.com/quantumlib/Cirq/blob/master/docs/operators_and_observables.ipynb\"><img src=\"https://quantumai.google/site-assets/images/buttons/github_logo_1x.png\" />View source on GitHub</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a href=\"https://storage.googleapis.com/tensorflow_docs/Cirq/docs/operators_and_observables.ipynb\"><img src=\"https://quantumai.google/site-assets/images/buttons/download_icon_1x.png\" />Download notebook</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bd9529db1c0b"
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    import cirq\n",
    "except ImportError:\n",
    "    print(\"installing cirq...\")\n",
    "    !pip install --quiet cirq --pre\n",
    "    print(\"installed cirq.\")\n",
    "    import cirq\n",
    "    \n",
    "import numpy as np\n",
    "import sympy.parsing.sympy_parser as sympy_parser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "254c2d1ee631"
   },
   "source": [
    "Note: this notebook relies on unreleased Cirq features. If you want to try these features, make sure you install cirq via `pip install cirq --pre`.\n",
    "\n",
    "This guide is directed at those already familiar with quantum operations (operators) and observables who want to know how to use them in Cirq. The following table shows an overview of operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9d8dbd4b4e5c"
   },
   "source": [
    "| Operator | Cirq representation | Guides | Examples | \n",
    "|-----|-------|--------|-----|\n",
    "| Unitary operators | Any class implementing the `_unitary_` protocol | [Protocols](protocols.ipynb), [Gates and operations](gates.ipynb), [Custom gates](custom_gates.ipynb) | `cirq.Gate` <br> `cirq.X(qubit)` <br> `cirq.CNOT(q0, q1)` <br> `cirq.MatrixGate.on(qubit)` <br> `cirq.Circuit` (if it only contains unitary operations)  |\n",
    "| Measurements | `cirq.measure` and `cirq.MeasurementGate`  | [Gates and operations](gates.ipynb) | `cirq.measure(cirq.LineQubit(0))` |  \n",
    "| Quantum channels | <ul> <li>Kraus operators (any class implementing the `_kraus_` protocol)</li><li>Pauli basis (cirq.PauliSum)</li> </ul> | [Protocols](protocols.ipynb) | `cirq.DepolarizingChannel(p=0.2)(q0)` <br> `cirq.X.with_probability(0.5)`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c35a9e89ec98"
   },
   "source": [
    "Cirq also supports observables on qubits that can be used to calculate expectation values on a given state.\n",
    "\n",
    "* You can use `cirq.PauliString` to express them,\n",
    "* Or you can use `cirq.PauliSum` with real coefficients."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "71ae01d45738"
   },
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7cabbfa3ba55"
   },
   "source": [
    "Quantum operations (or just *operators*) include unitary gates, measurements, and noisy channels. Operators that act on a given set of qubits implement `cirq.Operation` which supports the Kraus operator representation\n",
    "\n",
    "$$\n",
    "\\rho \\mapsto \\sum_{k} A_k \\rho A_k^\\dagger .\n",
    "$$\n",
    "\n",
    "Here, $\\sum_{k} A_k^\\dagger A_k = I$ and $\\rho$ is a quantum state. Operators are defined in the `cirq.ops` module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "329bba1d23f2"
   },
   "source": [
    "### Unitary operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "67317e02f377"
   },
   "source": [
    "Standard unitary operators used in quantum information can be found in `cirq.ops`, for example Pauli-$X$ as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "330de6a68bb9"
   },
   "outputs": [],
   "source": [
    "qubit = cirq.LineQubit(0)\n",
    "unitary_operation = cirq.ops.X.on(qubit)  # cirq.X can also be used for cirq.ops.X\n",
    "print(unitary_operation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6771bf1c439a"
   },
   "source": [
    "Cirq makes a distinction between gates (independent of qubits) and operations (gates acting on qubits). Thus `cirq.X` is a gate where `cirq.X.on(qubit)` is an operation. See the [guide on gates](gates.ipynb) for more details and additional common unitaries defined in Cirq."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4aad9e53cc3b"
   },
   "source": [
    "> **Note**: The method `cirq.X.on_each` is a utility to apply `cirq.X` to multiple qubits. Similarly for other operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7074f82814a8"
   },
   "source": [
    "Every `cirq.Operation` supports the `cirq.channel` protocol which returns its Kraus operators. (Read more about [protocols](protocols.ipynb) in Cirq.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8690317e6bdc"
   },
   "outputs": [],
   "source": [
    "kraus_ops = cirq.kraus(unitary_operation)\n",
    "print(f\"Kraus operators of {unitary_operation.gate} are:\", *kraus_ops, sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "775d97a27450"
   },
   "source": [
    "Unitary operators also support the `cirq.unitary` protocol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "b50465b311e3"
   },
   "outputs": [],
   "source": [
    "unitary = cirq.unitary(cirq.ops.X)\n",
    "print(f\"Unitary of {unitary_operation.gate} is:\\n\", unitary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "19c518b04864"
   },
   "source": [
    "Unitary gates can be raised to powers, for example to implement a $\\sqrt{X}$ operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "96a7a994333c"
   },
   "outputs": [],
   "source": [
    "sqrt_not = cirq.X ** (1 / 2)\n",
    "print(cirq.unitary(sqrt_not))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8d9eca419bbb"
   },
   "source": [
    "Any gate can be controlled via `cirq.ControlledGate` as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "db3aadb0f0ff"
   },
   "outputs": [],
   "source": [
    "controlled_hadamard = cirq.ControlledGate(sub_gate=cirq.H, num_controls=1)\n",
    "print(cirq.unitary(controlled_hadamard).round(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0d9a466b502b"
   },
   "source": [
    "Custom gates can be defined as described in [this guide](custom_gates.ipynb). Some common subroutines which consist of several operations are pre-defined - e.g., `cirq.qft` returns the operations to implement the quantum Fourier transform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c68dc1d3ca0d"
   },
   "source": [
    "### Measurements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "43505ede0131"
   },
   "source": [
    "Cirq supports measurements in the computational basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "e9f53647a2d7"
   },
   "outputs": [],
   "source": [
    "measurement = cirq.MeasurementGate(num_qubits=1, key=\"key\")\n",
    "print(\"Measurement:\", measurement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "00e6acd6ca82"
   },
   "source": [
    "The `key` can be used to identify results of measurements when [simulating circuits](simulation.ipynb). A measurement gate acting on a qubit forms an operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "c5e87b2b60dd"
   },
   "outputs": [],
   "source": [
    "measurement_operation = measurement.on(qubit)\n",
    "print(measurement_operation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1996e9afe508"
   },
   "source": [
    "> **Note**: The function `cirq.measure` is a utility to measure a single qubit, and the function `cirq.measure_each` is a utility to measure multiple qubits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fe89f00b0aad"
   },
   "source": [
    "Again measurement operations implement `cirq.Operation` so the `cirq.channel` protocol can be used to get the Kraus operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "33cffa2ff062"
   },
   "outputs": [],
   "source": [
    "kraus_ops = cirq.kraus(measurement)\n",
    "print(f\"Kraus operators of {measurement} are:\", *kraus_ops, sep=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4bd48811b1ab"
   },
   "source": [
    "The functions `cirq.measure_state_vector` and `cirq.measure_density_matrix` can be used to perform computational basis measurements on state vectors and density matrices, respectively, represented by NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3993dbcab9cc"
   },
   "outputs": [],
   "source": [
    "psi = np.ones(shape=(2,)) / np.sqrt(2)\n",
    "print(\"Wavefunction:\\n\", psi.round(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "018ba586e9b1"
   },
   "outputs": [],
   "source": [
    "results, psi_prime = cirq.measure_state_vector(psi, indices=[0])\n",
    "\n",
    "print(\"Measured:\", results[0])\n",
    "print(\"Resultant state:\\n\", psi_prime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "59d80d14827d"
   },
   "outputs": [],
   "source": [
    "rho = np.ones(shape=(2, 2)) / 2.0\n",
    "print(\"State:\\n\", rho)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "c71ad678ed35"
   },
   "outputs": [],
   "source": [
    "measurements, rho_prime = cirq.measure_density_matrix(rho, indices=[0])\n",
    "\n",
    "print(\"Measured:\", measurements[0])\n",
    "print(\"Resultant state:\\n\", rho_prime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1051898954e3"
   },
   "source": [
    "These functions do not modify the input state (`psi` or `rho`) unless the optional argument `out` is provided as the input state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "be9296fe8291"
   },
   "source": [
    "### Noisy channels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c7240ca42a70"
   },
   "source": [
    "Like common unitary gates, Cirq defines many common noisy channels, for example the depolarizing channel below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7b38ee1528a7"
   },
   "outputs": [],
   "source": [
    "depo_channel = cirq.DepolarizingChannel(p=0.01, n_qubits=1)\n",
    "print(depo_channel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ade1f59e1323"
   },
   "source": [
    "Just like unitary gates and measurements, noisy channels implement `cirq.Operation`, and we can always use `cirq.channel` to get the Kraus operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "26639f48fec8"
   },
   "outputs": [],
   "source": [
    "kraus_ops = cirq.kraus(depo_channel)\n",
    "print(f\"Kraus operators of {depo_channel} are:\", *[op.round(2) for op in kraus_ops], sep=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "82535883b164"
   },
   "source": [
    "Some channels can be written\n",
    "\n",
    "$$\n",
    "\\rho \\mapsto \\sum_k p_k U_k \\rho U_k ^\\dagger\n",
    "$$\n",
    "\n",
    "where real numbers $p_k$ form a probability distribution and $U_k$ are unitary. Such a *probabilistic mixture* of unitaries supports the `cirq.mixture` protocol which returns $p_k$ and $U_k$. An example is shown below for the bit-flip channel $\\rho \\mapsto (1 - p) \\rho + p X \\rho X$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "14450e5ea043"
   },
   "outputs": [],
   "source": [
    "bit_flip = cirq.bit_flip(p=0.05)\n",
    "probs, unitaries = cirq.mixture(bit_flip)\n",
    "\n",
    "for prob, unitary in cirq.mixture(bit_flip):\n",
    "    print(f\"With probability {prob}, apply \\n{unitary}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "84d85d11ec0b"
   },
   "source": [
    "> **Note**: Any unitary gate/operation supports `cirq.mixture` because it can be interpreted as applying a single unitary with probability one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aa5f8ad751d3"
   },
   "source": [
    "Custom noisy channels can be defined as described in [this guide](noise.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "712d08a1aede"
   },
   "source": [
    "### In circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4797150e7c2b"
   },
   "source": [
    "Any `cirq.Operation` (pre-defined or user-defined) can be placed in a `cirq.Circuit`. An example with a unitary, noisy channel, and measurement is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4005ebd62eab"
   },
   "outputs": [],
   "source": [
    "circuit = cirq.Circuit(\n",
    "    cirq.H(qubit),\n",
    "    cirq.depolarize(p=0.01).on(qubit),\n",
    "    cirq.measure(qubit)\n",
    ")\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9eeae0d8a85e"
   },
   "source": [
    "The general input to the circuit constructor is a `cirq.OP_TREE`, i.e., an operation or nested collection of operations. Circuits can be manipulated as described in the [circuits guide](circuits.ipynb) and simulated as described in the [simulation guide](simulation.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dd466ec473bb"
   },
   "source": [
    "## Observables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b6644204cffa"
   },
   "source": [
    "Cirq supports observables which are Pauli strings or linear combinations of Pauli strings. Such objects can be used to compute expectation values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "874df4a490cc"
   },
   "source": [
    "### Pauli strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2e2b345d08f3"
   },
   "source": [
    "Pauli products or strings are supported via `cirq.PauliString`. For example, the Pauli string $Z_0 Z_1$ (where subscripts denote qubit indices) can be represented as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1e0e37ef4bfc"
   },
   "outputs": [],
   "source": [
    "# Qubit register\n",
    "qreg = cirq.NamedQubit.range(2, prefix=\"q\")\n",
    "\n",
    "# PauliString Z_0 Z_1\n",
    "zz = cirq.PauliString(cirq.Z(q) for q in qreg)\n",
    "print(zz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "497f4baf6c31"
   },
   "source": [
    "The matrix of a Pauli string can be returned via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a2dec7b949a2"
   },
   "outputs": [],
   "source": [
    "zz.matrix()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a299fb846443"
   },
   "source": [
    "Pauli strings can also have arbitrary coefficients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f0cf6bd929a9"
   },
   "outputs": [],
   "source": [
    "new = (1.0 - 0.1j) * zz\n",
    "print(new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1b071d201a6c"
   },
   "source": [
    "### Pauli sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3b8efe6c9bc9"
   },
   "source": [
    "A `cirq.PauliSum` is a linear combination of `cirq.PauliString`s and represents a Hamiltonian (or general observable) in the Pauli basis. To represent the observable $O = 1.5 Z_0 Z_1 - 0.7 X_0 X_1$, we can first define the $X_0 X_1$ Pauli string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "e8bc049b3508"
   },
   "outputs": [],
   "source": [
    "xx = cirq.PauliString(cirq.X(q) for q in qreg)\n",
    "print(xx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "390efe235648"
   },
   "source": [
    "Then form the linear combination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "53e61c1e2eea"
   },
   "outputs": [],
   "source": [
    "psum = 1.5 * zz - 0.7 * xx\n",
    "print(psum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1669204a2cde"
   },
   "source": [
    "Like Pauli strings, we can get the matrix of a `cirq.PauliSum`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ce704a902604"
   },
   "outputs": [],
   "source": [
    "psum.matrix()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ba00a12b9fbd"
   },
   "source": [
    "A Pauli sum can also be constructed from a `Sympy` Boolean expression. This is based on \"On the representation of Boolean and real functions as Hamiltonians for quantum computing\" by Stuart Hadfield (https://arxiv.org/abs/1804.09130)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8da2814b60f3"
   },
   "outputs": [],
   "source": [
    "psum = cirq.PauliSum.from_boolean_expression(\n",
    "    sympy_parser.parse_expr('x0 ^ x1'),\n",
    "    {'x0': cirq.NamedQubit('q0'), 'x1': cirq.NamedQubit('q1')})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a4b817279b9b"
   },
   "source": [
    "### Expectation values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "43c02d553f9c"
   },
   "source": [
    "Given a state $\\rho$ that is prepared by a circuit, expectation values $\\text{Tr} [ \\rho O ]$ where $O$ is an observable can be computed as follows. First, an example circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7aeb6e0f8b95"
   },
   "outputs": [],
   "source": [
    "circuit = cirq.Circuit(cirq.ops.H.on_each(qreg))\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8784427462c7"
   },
   "source": [
    "The pattern for computing $\\text{Tr} [ \\rho O ]$ is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "c117937d58b2"
   },
   "outputs": [],
   "source": [
    "# Define a PauliSumCollector.\n",
    "collector = cirq.PauliSumCollector(circuit, psum, samples_per_term=10_000)\n",
    "\n",
    "# Provide a sampler. See also: collector.collect(...).\n",
    "collector.collect_async(sampler=cirq.Simulator())\n",
    "\n",
    "# Estimate the observable.\n",
    "energy = collector.estimated_energy()\n",
    "print(\"Energy:\", energy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e2c28b67891a"
   },
   "source": [
    "Note that this method uses sampling with a number of samples given by `samples_per_term`. \n",
    "\n",
    "Expectation values can also be computed from NumPy array representations of quantum states. For example, given a state vector we can do the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6be1d68ba981"
   },
   "outputs": [],
   "source": [
    "# Get the state vector.\n",
    "psi = circuit.final_state_vector()\n",
    "\n",
    "# Compute the expectation value.\n",
    "energy = psum.expectation_from_state_vector(\n",
    "    state_vector=psi, qubit_map={q: i for i, q in enumerate(qreg)}\n",
    ")\n",
    "print(\"Energy:\", energy.real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2aa63c6a9228"
   },
   "source": [
    "And given a density matrix, we can compute the expectation via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "78b2ec696ad3"
   },
   "outputs": [],
   "source": [
    "# Get the density matrix.\n",
    "dsim = cirq.DensityMatrixSimulator()\n",
    "rho = dsim.simulate(circuit).final_density_matrix\n",
    "\n",
    "# Compute the expectation value.\n",
    "energy = psum.expectation_from_density_matrix(\n",
    "    state=rho, qubit_map={q: i for i, q in enumerate(qreg)}\n",
    ")\n",
    "print(\"Energy:\", energy.real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "704a8ad92dcd"
   },
   "source": [
    "### Pauli expansions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "519946210413"
   },
   "source": [
    "The function `cirq.pauli_expansion` can return Pauli basis representations of certain objects. For example, given the circuit $H \\otimes H$ from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3d076f652654"
   },
   "outputs": [],
   "source": [
    "circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "59556187ad67"
   },
   "source": [
    "The Pauli expansion can be obtained via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4d9691df05d9"
   },
   "outputs": [],
   "source": [
    "psum = cirq.pauli_expansion(circuit)\n",
    "print(psum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fed72813d496"
   },
   "source": [
    "Generally, the argument to `cirq.pauli_expansion` must define the `_pauli_expansion_` method or have a small unitary representation. The argument `default` can be provided to return a default value if no expansion can be computed."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "Sh9QBnKbFf_B"
   ],
   "name": "operators_and_observables.ipynb",
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}