{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Manipulate quantum states via Paddle Quantum's `state` module\n", "\n", "_Copyright (c) 2023 Institute for Quantum Computing, Baidu Inc. All Rights Reserved._\n", "\n", "The `state` module is a Paddle Quantum module that supports operations related to quantum states (`paddle_quantum.state.State`), mainly including the creation of quantum states and operations. The `state` module provides a number of interfaces for the user to create and edit quantum states and to interact with quantum circuits and measurements.\n", "\n", "## Creation of states\n", "User can create quantum states from existing data, or create special states by Paddle Quantum.\n", "First we can create quantum states from existing data." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Applications/anaconda3/envs/pq/lib/python3.8/site-packages/openfermion/hamiltonians/hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated.\n", " from scipy.optimize.optimize import OptimizeResult\n", "/Applications/anaconda3/envs/pq/lib/python3.8/site-packages/paddle/tensor/creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n", "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", " if data.dtype == np.object:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[1.+0.j 0.+0.j]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Applications/anaconda3/envs/pq/lib/python3.8/site-packages/paddle/tensor/creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n", "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", " if data.dtype == np.object:\n", "/Applications/anaconda3/envs/pq/lib/python3.8/site-packages/paddle/fluid/framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", " elif dtype == np.bool:\n" ] } ], "source": [ "import paddle\n", "import paddle_quantum as pq\n", "from paddle_quantum.backend import Backend\n", "\n", "state_vec = pq.state.to_state([1, 0])\n", "print(state_vec)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The density matrix can also be created by specifying `backend`." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0.5+0.j 0. +0.j]\n", " [0. +0.j 0.5+0.j]]\n" ] } ], "source": [ "state_density = pq.state.State([[0.5, 0], [0, 0.5]], backend=Backend.DensityMatrix)\n", "print(state_density)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We can also create special types of quantum states by using the functions built into the Paddle Quantum. For example, we can create a single-qubit zero state." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1.+0.j 0.+0.j]\n" ] } ], "source": [ "print(pq.state.zero_state(num_qubits=1))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Create a 2-qubit random state." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-0.00128883+0.02999492j 0.26680315-0.47462934j -0.22390576+0.8043244j\n", " 0.00640717+0.07435807j]\n" ] } ], "source": [ "print(pq.state.random_state(num_qubits=2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition, the Paddle Quantum supports the creation of several other special quantum states. More detail can be found in [API ducument](https://qml.baidu.com/api/paddle_quantum.state.common.html). \n", "\n", "We can also set the global backend to be density matrix mode with a single line of code. Of course, we continue to use the default backend, i.e., the state vector, for this demonstration." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1.+0.j 0.+0.j]\n", " [0.+0.j 0.+0.j]]\n" ] } ], "source": [ "pq.set_backend('density_matrix') # set the global backend as density matrix\n", "print(pq.state.zero_state(num_qubits=1))\n", "pq.set_backend('state_vector') # set back to the default backend" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data of states\n", "We can read the data in `State` by accessing `data`, `ket`, `bra`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Its data is : Tensor(shape=[2], dtype=complex64, place=Place(cpu), stop_gradient=True,\n", " [(1+0j), 0j ])\n", "Its ket is : Tensor(shape=[2, 1], dtype=complex64, place=Place(cpu), stop_gradient=True,\n", " [[(1+0j)],\n", " [0j ]])\n", "Its bra is : Tensor(shape=[1, 2], dtype=complex64, place=Place(cpu), stop_gradient=True,\n", " [[(1-0j), -0j ]])\n" ] } ], "source": [ "zero_state = pq.state.zero_state(num_qubits=1)\n", "print('Its data is :', zero_state.data)\n", "print('Its ket is :', zero_state.ket)\n", "print('Its bra is :', zero_state.bra)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also use the method `numpy()` to output `numpy.ndarray` type data for `State`." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1.+0.j 0.+0.j]\n" ] } ], "source": [ "print(zero_state.numpy())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Operations of states\n", "We can get the product of two quantum states by matrix multiplication `@`, which makes calculating the overlap of two states easy." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True,\n", " [[0j, 0j],\n", " [0j, 0j]])\n", "The overlap of state_1 and state_2 is : Tensor(shape=[1], dtype=complex64, place=Place(cpu), stop_gradient=True,\n", " [0j])\n" ] } ], "source": [ "state_1 = pq.state.zero_state(num_qubits=1, backend=Backend.DensityMatrix)\n", "state_2 = pq.state.to_state([[0, 0], [0, 1]], backend=Backend.DensityMatrix)\n", "print(state_1 @ state_2)\n", "print('The overlap of state_1 and state_2 is :', paddle.trace(state_1 @ state_2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "User can also use `State.kron()` to find the tensor product $\\rho \\otimes \\sigma$ of the quantum states $\\rho$ and $\\sigma$." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n" ] } ], "source": [ "rho = pq.state.zero_state(num_qubits=1)\n", "sigma = pq.state.to_state([0, 1])\n", "product_state = rho.kron(sigma)\n", "print(product_state)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We can give partial trace on states by slicing or indexing. For example, we want to get the state of the first qubit of $|011\\rangle$ and the state of the last two qubits." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", "the state of the first qubit is : [1.+0.j 0.+0.j]\n", "the state of the second and third qubits is : [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n" ] } ], "source": [ "psi_012 = pq.state.computational_basis(num_qubits=3, index=3)\n", "print(psi_012)\n", "\n", "psi_1 = psi_012[0]\n", "psi_12 = psi_012[1:]\n", "print('the state of the first qubit is :', psi_1)\n", "print('the state of the second and third qubits is :',psi_12)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Measurement and evolution of states\n", "The method `State.evolve()` of a quantum state can give the final state of the quantum state under $e^{-iHt}$ evolution given the Hamiltonian $H$ and the evolution time $t$. Here we set the Hamiltonian to be the Pauli $Z$ matrix and the evolution time $t=1$." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.5403023-0.84147096j 0. +0.j ]\n" ] } ], "source": [ "state = pq.state.zero_state(num_qubits=1)\n", "t = 1\n", "hamiltonian = pq.hamiltonian.Hamiltonian([(1, 'Z0')])\n", "state.evolve(H=hamiltonian, t=t)\n", "print(state)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The method `State.expec_val()` of states can calculate the expectation under given observables (Hamiltonian)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.0\n" ] } ], "source": [ "state = pq.state.zero_state(num_qubits=1)\n", "observable = pq.hamiltonian.Hamiltonian([(1, 'Z0')])\n", "print(state.expec_val(hamiltonian=observable))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "`State.measure()` can give the measurement result in the computational basis. The user can set the `shots` value to simulate or make `shots=0` to calculate the expectation, or use the `plot` parameter to make a plot." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Theoretical value is : {'0': 0.5, '1': 0.5}\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEDCAYAAAA4FgP0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAARxklEQVR4nO3de7BdZX3G8e9DAK9Yq8RbEgQ11gEVxIhWbQtWWlBsUGkNUq1WRVRUpuOFdqzWS6faqlMvaEyVepsatSJNNchYr/VWk1CRiRqNCOUUHeOlIt4w8usfawHbw845O5e1D8n7/czsOWu977vX/p0zJ+fJetctVYUkqV37LXQBkqSFZRBIUuMMAklqnEEgSY0zCCSpcQaBJDVu/4UuYGcdfPDBdeihhy50GZK0V9m0adP3qmrxuL69LggOPfRQNm7cuNBlSNJeJcnlO+pzakiSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUuL3ugrLdcejZH17oEnQTdtkrH7nQJUgLwj0CSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXGDBkGSE5JsSbI1ydlj+o9N8qMkX+pfLx6yHknSjQ328Poki4BzgOOBGWBDknVV9ZVZQ/+zqk4aqg5J0tyG3CM4BthaVZdW1TXAWmDlgJ8nSdoFQwbBEuCKkfWZvm22305ycZILkhwxbkNJTk+yMcnGbdu2DVGrJDVryCDImLaatX4RcNeqOhJ4A3D+uA1V1ZqqWlFVKxYvXrxnq5Skxg0ZBDPAspH1pcCVowOq6qqqurpfXg8ckOTgAWuSJM0yZBBsAJYnOSzJgcAqYN3ogCR3SpJ++Zi+nu8PWJMkaZbBzhqqqu1JzgQuBBYB51bV5iRn9P2rgVOAZyTZDvwMWFVVs6ePJEkDGiwI4PrpnvWz2laPLL8ReOOQNUiS5uaVxZLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktS4QZ9QJmnnHXr2hxe6BN1EXfbKRw6yXfcIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcYMGQZITkmxJsjXJ2XOMe0CSXyU5Zch6JEk3NlgQJFkEnAOcCBwOnJrk8B2MexVw4VC1SJJ2bMg9gmOArVV1aVVdA6wFVo4Z92zgA8B3B6xFkrQDQwbBEuCKkfWZvu16SZYAjwZWD1iHJGkOQwZBxrTVrPV/BF5YVb+ac0PJ6Uk2Jtm4bdu2PVWfJIlhb0M9AywbWV8KXDlrzApgbRKAg4FHJNleVeePDqqqNcAagBUrVswOE0nSbhgyCDYAy5McBvwvsAp4/OiAqjrsuuUkbwc+NDsEJEnDGiwIqmp7kjPpzgZaBJxbVZuTnNH3e1xAkm4CBn1CWVWtB9bPahsbAFX1pCFrkSSN55XFktQ4g0CSGmcQSFLjDAJJapxBIEmNmygIkjwkya365T9N8tokdx22NEnSNEy6R/Bm4KdJjgReAFwOvHOwqiRJUzNpEGyvqqK7e+jrqup1wEHDlSVJmpZJLyj7cZK/BJ4A/E7/DIEDhitLkjQtk+4RPA74BfDnVfUduttJ/8NgVUmSpmaiIOj/+H8AuFnf9D3gg0MVJUmanknPGnoa8K/AW/qmJcD5A9UkSZqiSaeGngU8BLgKoKq+AdxhqKIkSdMzaRD8on/uMABJ9ufGTxuTJO2FJg2CTyX5K+AWSY4H3g/8+3BlSZKmZdIgOBvYBlwCPJ3uGQMvGqooSdL0THQdQVVdC/xT/5Ik7UPmDIIk76uqP0lyCWOOCVTVfQerTJI0FfPtETy3/3rS0IVIkhbGnMcIqurb/eIzq+ry0RfwzOHLkyQNbdKDxcePaTtxTxYiSVoY8x0jeAbd//zvluTLI10HAZ8dsjBJ0nTMd4zgX4ALgL+jO4X0Oj+uqh8MVpUkaWrmC4KqqsuSPGt2R5LbGQaStPebZI/gJGAT3emjGekr4G4D1SVJmpI5g6CqTuq/HjadciRJ0zbfweKj5+qvqov2bDmSpGmbb2roNXP0FfCwPViLJGkBzDc1dNzubDzJCcDrgEXAW6vqlbP6VwIvB64FtgNnVdVnduczJUk7Z76poYdV1ceTPGZcf1WdN8d7FwHn0F2MNgNsSLKuqr4yMuxjwLqqqiT3Bd4H3GtnvwlJ0q6bb2ro94CPA48a01fADoMAOAbYWlWXAiRZC6wErg+Cqrp6ZPyt8GE3kjR1800NvaT/+uRd2PYS4IqR9RnggbMHJXk03QVrdwAeuQufI0naDZM+vP72SV6f5KIkm5K8Lsnt53vbmLZxt7L+YFXdCziZ7njBuM8/PcnGJBu3bds2ScmSpAlNetO5tXRPKHsscEq//N553jMDLBtZXwpcuaPBVfVp4O5JDh7Tt6aqVlTVisWLF09YsiRpEpMGwe2q6uVV9a3+9QrgtvO8ZwOwPMlhSQ4EVgHrRgckuUeS9MtHAwcC39+p70CStFsmelQl8Ikkq+jO6oFur+DDc72hqrYnORO4kO700XOranOSM/r+1XR7GE9M8kvgZ8DjqsoDxpI0RfOdPvpjbrjH0F8A7+679gOuBl4y1/uraj3dg+5H21aPLL8KeNVOVy1J2mPmO2vooGkVIklaGJNODZHkN4HlwM2va+sP8EqS9mITBUGSp9I9yH4p8CXgQcDn8V5DkrTXm/SsoecCDwAu7+8/dD+6U0glSXu5SYPg51X1c4AkN6uqrwG/NVxZkqRpmfQYwUyS2wLnAx9N8kPmuDhMkrT3mCgIqurR/eLfJPkE8BvARwarSpI0NTtz1tDRwEPpriv4bFVdM1hVkqSpmfSmcy8G3gHcHjgY+OckLxqyMEnSdEy6R3AqcL+RA8avBC4CXjFUYZKk6Zj0rKHLGLmQDLgZ8M09Xo0kaermu9fQG+iOCfwC2Jzko/368YDPFpakfcB8U0Mb+6+bgA+OtH9ykGokSVM3303n3nHdcv9MgXv2q1uq6pdDFiZJmo5J7zV0LN1ZQ5fR3ZJ6WZI/86ZzkrT3m/SsodcAf1BVWwCS3BN4D3D/oQqTJE3HpGcNHXBdCABU1deBA4YpSZI0TZPuEWxK8jbgXf36aXQHkCVJe7lJg+AM4FnAc+iOEXwaeNNQRUmSpmfeIEiyH7Cpqu4NvHb4kiRJ0zTvMYKquha4OMkhU6hHkjRlk04N3ZnuyuIvAj+5rrGq/miQqiRJUzNpELx00CokSQtmvnsN3ZzuQPE9gEuAt1XV9mkUJkmajvmOEbwDWEEXAifSXVgmSdqHzDc1dHhV3Qegv47gi8OXJEmapvn2CK6/sZxTQpK0b5pvj+DIJFf1ywFu0a8HqKq6zaDVSZIGN+ceQVUtqqrb9K+Dqmr/keV5QyDJCUm2JNma5Owx/acl+XL/+lySI3fnm5Ek7bxJbzq305IsAs6hO8h8OHBqksNnDfsW8HtVdV/g5cCaoeqRJI03WBAAxwBbq+rSqroGWAusHB1QVZ+rqh/2q18Alg5YjyRpjCGDYAlwxcj6TN+2I08BLhiwHknSGJNeWbwrMqatxg5MjqMLgofuoP904HSAQw7xlkeStCcNuUcwAywbWV8KXDl7UJL7Am8FVlbV98dtqKrWVNWKqlqxePHiQYqVpFYNGQQbgOVJDusffL8KWDc6oL+j6XnAE/qnnkmSpmywqaGq2p7kTOBCYBFwblVtTnJG378aeDFwe+BNSQC2V9WKoWqSJN3YkMcIqKr1wPpZbatHlp8KPHXIGiRJcxtyakiStBcwCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxg0aBElOSLIlydYkZ4/pv1eSzyf5RZLnDVmLJGm8/YfacJJFwDnA8cAMsCHJuqr6ysiwHwDPAU4eqg5J0tyG3CM4BthaVZdW1TXAWmDl6ICq+m5VbQB+OWAdkqQ5DBkES4ArRtZn+jZJ0k3IkEGQMW21SxtKTk+yMcnGbdu27WZZkqRRQwbBDLBsZH0pcOWubKiq1lTViqpasXjx4j1SnCSpM2QQbACWJzksyYHAKmDdgJ8nSdoFg501VFXbk5wJXAgsAs6tqs1Jzuj7Vye5E7ARuA1wbZKzgMOr6qqh6pIk/brBggCgqtYD62e1rR5Z/g7dlJEkaYF4ZbEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaN2gQJDkhyZYkW5OcPaY/SV7f9385ydFD1iNJurHBgiDJIuAc4ETgcODUJIfPGnYisLx/nQ68eah6JEnjDblHcAywtaouraprgLXAylljVgLvrM4XgNsmufOANUmSZtl/wG0vAa4YWZ8BHjjBmCXAt0cHJTmdbo8B4OokW/Zsqc06GPjeQhdxU5FXLXQFGsPf0RG7+Tt61x11DBkEGdNWuzCGqloDrNkTRekGSTZW1YqFrkPaEX9Hp2PIqaEZYNnI+lLgyl0YI0ka0JBBsAFYnuSwJAcCq4B1s8asA57Ynz30IOBHVfXt2RuSJA1nsKmhqtqe5EzgQmARcG5VbU5yRt+/GlgPPALYCvwUePJQ9Wgsp9t0U+fv6BSk6kZT8pKkhnhlsSQ1ziCQpMYZBJLUuCGvI9BNTJJ70V3NvYTueo0rgXVV9dUFLUzSgnKPoBFJXkh3m48AX6Q7vTfAe8bdEFC6KUniGYUD8qyhRiT5OnBEVf1yVvuBwOaqWr4wlUnzS/I/VXXIQtexr3JqqB3XAncBLp/Vfue+T1pQSb68oy7gjtOspTUGQTvOAj6W5BvccKO/Q4B7AGcuVFHSiDsCfwj8cFZ7gM9Nv5x2GASNqKqPJLkn3e3Bl9D945oBNlTVrxa0OKnzIeDWVfWl2R1JPjn1ahriMQJJapxnDUlS4wwCSWqcQaB9WpKlSf4tyTeSXJrkjUluNsH7rt5B+8uSPLxfPivJLXcw7qQk/53k4iRfSfL0vv3kMc/uHvf+icZJe4JBoH1WkgDnAef310ksB24B/P2ubrOqXlxV/9GvngXcKAiSHEB3++RHVdWRwP2AT/bdJwOT/IGfdJy02zxYrH1Wkt8HXlJVvzvSdhu6aymWAacAK6rqzL7vQ8Crq+qT/R7BW4Dj6E5nXFVV25K8ne7slrsArwa2AN+rquNGPuN2wNeAu1bVz0baH9y/90f967HAw+iex30g3XM5ngAcNWYcwDnAYrpndzytqr62R35Qap57BNqXHQFsGm2oqquAy+iun5jLrYCLqupo4FPAS2Zt5/V092o6bjQE+r4f0D197/Ik70lyWpL9qupzffvzq+qoqvomcF5VPaDfc/gq8JQdjFsDPLuq7g88D3jTTv80pB3wOgLty0J3c71x7fO5Fnhvv/xuuimmiVXVU5PcB3g43R/u44EnjRl67ySvAG4L3JruiX6/Xmxya+DBwPu72S4A5j3OIU3KINC+bDM3TKsA108N3ZFuSufe/Ppe8c3n2NZOz6FW1SXAJUneBXyL8UHwduDkqro4yZOAY8eM2Q/4v6o6amdrkCbh1JD2ZR8DbpnkiQBJFgGvAd7Yz91fBhyVZL8ky+iuur7OfnTHEAAeD3xmzPZ/DBw0uzHJrZMcO9J0FDfc42n2ew4Cvt0fYD5t3Lb76axvJfnjfvtJcuRc37i0MwwC7bOqOxPi0cAp/T2Wvg9cW1V/2w/5LN3/1C+hO/B70cjbfwIckWQT3QHdl435iDXABUk+Mas9wAuSbEnyJeCl3LA3sBZ4fn9q6d2Bvwb+C/go3QFmdjDuNOApSS6m29NZuVM/DGkOnjWkZvRn7bwHeExVbZpvvNQKg0CSGufUkCQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjft/I1it3WO69YkAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "{'0': 0.5625, '1': 0.4375}" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "state = pq.state.to_state([[0.5, 0], [0, 0.5]], backend=Backend.DensityMatrix)\n", "print('Theoretical value is :', state.measure(shots=0)) # theoretical value\n", "state.measure(shots=16, plot=True)" ] } ], "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.13" } }, "nbformat": 4, "nbformat_minor": 2 }