basic_quantum_theory.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPi9BcjtANXokI69xqkBVbG",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hongqin/quantum_sandbox/blob/main/basic_quantum_theory.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Chapter 4, Basic quantum theory"
      ],
      "metadata": {
        "id": "MOMjADvoY_Tz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.1 Quantum state"
      ],
      "metadata": {
        "id": "dLj4Sj1OgZQh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Modulus and probability of each state"
      ],
      "metadata": {
        "id": "Rx6TlmKMYkpj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example 4.1.1"
      ],
      "metadata": {
        "id": "lEfvAbPjOlgb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CejwosIbYihJ",
        "outputId": "a4645351-20c3-4dfe-aec6-1f42e4f3ad57"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Modulus (Norm) of the complex vector: 4.358898943540674\n",
            "Modulus of element 0: 3.1622776601683795, Probability of state 0: 0.5263157894736842\n",
            "Modulus of element 1: 2.0, Probability of state 1: 0.21052631578947364\n",
            "Modulus of element 2: 1.0, Probability of state 2: 0.05263157894736841\n",
            "Modulus of element 3: 2.0, Probability of state 3: 0.21052631578947364\n",
            "Total Probability: 0.9999999999999999\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define a 4-element complex vector\n",
        "complex_vector = np.array([-3-1j, -2j, 1j, 2]) #example 4.1.1\n",
        "\n",
        "# Calculate the modulus (norm) of the vector\n",
        "modulus_vector = np.linalg.norm(complex_vector)\n",
        "\n",
        "# Print the modulus of the vector\n",
        "print(f\"Modulus (Norm) of the complex vector: {modulus_vector}\")\n",
        "\n",
        "# Calculate the modulus of each element in the vector\n",
        "modulus_elements = np.abs(complex_vector)\n",
        "\n",
        "# Calculate the probability of each state\n",
        "prob_each_state = (modulus_elements ** 2) / (modulus_vector ** 2)\n",
        "\n",
        "# Print the modulus of each element and the corresponding probability\n",
        "for i, (modulus, prob) in enumerate(zip(modulus_elements, prob_each_state)):\n",
        "    print(f\"Modulus of element {i}: {modulus}, Probability of state {i}: {prob}\")\n",
        "\n",
        "# Confirm that total probability is 1\n",
        "total_prob = np.sum(prob_each_state)\n",
        "print(f\"Total Probability: {total_prob}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uTgJXfgkO_Dj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Exercise. Multiply $|\\psi>$ by a complex number c, check that it will not alter the probabilities."
      ],
      "metadata": {
        "id": "RdL3tsUoO_3J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define a 4-element complex vector\n",
        "complex_vector = np.array([-3-1j, -2j, 1j, 2]) #example 4.1.1\n",
        "\n",
        "# define a complex number\n",
        "c0 = 1+2j\n",
        "\n",
        "complex_vector = c0 * complex_vector\n",
        "\n",
        "# Calculate the modulus (norm) of the vector\n",
        "modulus_vector = np.linalg.norm(complex_vector)\n",
        "\n",
        "# Print the modulus of the vector\n",
        "print(f\"Modulus (Norm) of the complex vector: {modulus_vector}\")\n",
        "\n",
        "# Calculate the modulus of each element in the vector\n",
        "modulus_elements = np.abs(complex_vector)\n",
        "\n",
        "# Calculate the probability of each state\n",
        "prob_each_state = (modulus_elements ** 2) / (modulus_vector ** 2)\n",
        "\n",
        "# Print the modulus of each element and the corresponding probability\n",
        "for i, (modulus, prob) in enumerate(zip(modulus_elements, prob_each_state)):\n",
        "    print(f\"Modulus of element {i}: {modulus}, Probability of state {i}: {prob}\")\n",
        "\n",
        "# Confirm that total probability is 1\n",
        "total_prob = np.sum(prob_each_state)\n",
        "print(f\"Total Probability: {total_prob}\")\n"
      ],
      "metadata": {
        "id": "zITir4yCO_K4",
        "outputId": "596b94b8-e559-4f51-e5d5-58846ed40d27",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Modulus (Norm) of the complex vector: 9.746794344808963\n",
            "Modulus of element 0: 7.0710678118654755, Probability of state 0: 0.5263157894736844\n",
            "Modulus of element 1: 4.47213595499958, Probability of state 1: 0.21052631578947376\n",
            "Modulus of element 2: 2.23606797749979, Probability of state 2: 0.05263157894736844\n",
            "Modulus of element 3: 4.47213595499958, Probability of state 3: 0.21052631578947376\n",
            "Total Probability: 1.0000000000000004\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Q: Will normalization improve numerical precision?"
      ],
      "metadata": {
        "id": "lpJ7V-xcQtDG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define a 4-element complex vector\n",
        "#complex_vector = np.array([-3-1j, -2j, 1j, 2]) #example 4.1.1\n",
        "complex_vector = np.array([-3-1j, -3-1j, -3-1j, -3-1j]) # will this be a uniform distriubution?\n",
        "\n",
        "# Calculate the modulus (norm) of the vector\n",
        "modulus_vector = np.linalg.norm(complex_vector)\n",
        "\n",
        "# Normalize the vector\n",
        "complex_vector = complex_vector / modulus_vector\n",
        "# update the modulus of the vector\n",
        "modulus_vector = np.linalg.norm(complex_vector)\n",
        "\n",
        "# Print the modulus of the vector\n",
        "print(f\"Modulus (Norm) of the complex vector: {modulus_vector}\")\n",
        "\n",
        "# Calculate the modulus of each element in the vector\n",
        "modulus_elements = np.abs(complex_vector)\n",
        "\n",
        "# Calculate the probability of each state\n",
        "prob_each_state = (modulus_elements ** 2) / (modulus_vector ** 2)\n",
        "\n",
        "# Print the modulus of each element and the corresponding probability\n",
        "for i, (modulus, prob) in enumerate(zip(modulus_elements, prob_each_state)):\n",
        "    print(f\"Modulus of element {i}: {modulus}, Probability of state {i}: {prob}\")\n",
        "\n",
        "# Confirm that total probability is 1\n",
        "total_prob = np.sum(prob_each_state)\n",
        "print(f\"Total Probability: {total_prob}\")"
      ],
      "metadata": {
        "id": "Kv0uUt2uZrKz",
        "outputId": "84112362-0a9e-440a-f406-a8ac722f1f44",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Modulus (Norm) of the complex vector: 0.9999999999999999\n",
            "Modulus of element 0: 0.5, Probability of state 0: 0.25000000000000006\n",
            "Modulus of element 1: 0.5, Probability of state 1: 0.25000000000000006\n",
            "Modulus of element 2: 0.5, Probability of state 2: 0.25000000000000006\n",
            "Modulus of element 3: 0.5, Probability of state 3: 0.25000000000000006\n",
            "Total Probability: 1.0000000000000002\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "3QGITZ9iQtGj"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "LCghVz5FQ07l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Bra-ket transition example"
      ],
      "metadata": {
        "id": "97Z5QVwrbH15"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define the initial state |psi>\n",
        "psi = np.array([1 + 1j, 0, 2 - 1j])\n",
        "\n",
        "# Define the end state |psi'>\n",
        "psi_prime = np.array([0, 1 - 1j, 1 + 1j])\n",
        "\n",
        "# Compute the bra <psi'|\n",
        "bra_psi_prime = np.conjugate(psi_prime)\n",
        "\n",
        "# Compute the inner product <psi'|psi>\n",
        "transition_amplitude = np.dot(bra_psi_prime, psi)\n",
        "\n",
        "print(f\"Initial state |psi>: {psi}\")\n",
        "print(f\"End state |psi'>: {psi_prime}\")\n",
        "print(f\"Transition amplitude <psi'|psi>: {transition_amplitude}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1o_xUyqaZrNz",
        "outputId": "665ad6fa-b8ec-4005-c3d4-aa098dc08668"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial state |psi>: [1.+1.j 0.+0.j 2.-1.j]\n",
            "End state |psi'>: [0.+0.j 1.-1.j 1.+1.j]\n",
            "Transition amplitude <psi'|psi>: (1-3j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "B47Oy7tqZrRQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aO5TGgu5ZrUP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example 4.1.6"
      ],
      "metadata": {
        "id": "2mQtOa7FbkvZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define the starting state |psi>\n",
        "psi = np.array([np.sqrt(2)/2, 1j * np.sqrt(2)/2])\n",
        "\n",
        "# Define the end state |phi>\n",
        "phi = np.array([1j * np.sqrt(2)/2, -np.sqrt(2)/2])\n",
        "\n",
        "# Compute the bra <phi|\n",
        "bra_phi = np.conjugate(phi)\n",
        "\n",
        "# Compute the inner product <phi|psi>\n",
        "transition_amplitude = np.dot(bra_phi, psi)\n",
        "\n",
        "print(f\"Starting state |psi>: {psi}\")\n",
        "print(f\"End state |phi>: {phi}\")\n",
        "print(f\"Transition amplitude <phi|psi>: {transition_amplitude}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lq8OFrK_ZrXa",
        "outputId": "6ca5b108-bd3f-4757-bea2-c412e76057d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting state |psi>: [0.70710678+0.j         0.        +0.70710678j]\n",
            "End state |phi>: [ 0.        +0.70710678j -0.70710678+0.j        ]\n",
            "Transition amplitude <phi|psi>: -1.0000000000000002j\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Exercise 4.1.10"
      ],
      "metadata": {
        "id": "SoBFPZyHcs3a"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4vM7Qz9-cuwH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.2 Observable"
      ],
      "metadata": {
        "id": "o737q3ETgbRZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Commutator example for [Sx, Sy], Eq 4.54"
      ],
      "metadata": {
        "id": "PKZxSdbCfjQ4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define two matrices (operators) A and B\n",
        "Sx = np.array([[0, 1], [1, 0]])\n",
        "Sy = np.array([[0, -1j], [1j, 0]])\n",
        "\n",
        "A = Sx\n",
        "B = Sy\n",
        "# Compute AB\n",
        "AB = np.dot(Sx, Sy)\n",
        "\n",
        "# Compute BA\n",
        "BA = np.dot(B, A)\n",
        "\n",
        "# Compute the commutator [A, B] = AB - BA\n",
        "commutator = AB - BA\n",
        "\n",
        "print(\"A =\")\n",
        "print(A)\n",
        "print(\"\\nB =\")\n",
        "print(B)\n",
        "print(\"\\nAB =\")\n",
        "print(AB)\n",
        "print(\"\\nBA =\")\n",
        "print(BA)\n",
        "print(\"\\nCommutator [Sx, Sy] = AB - BA =\")\n",
        "print(commutator)\n"
      ],
      "metadata": {
        "id": "wXqgX4L6fiZ8",
        "outputId": "ac38e44a-fec9-4119-cac8-345b1c0bb9f8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A =\n",
            "[[0 1]\n",
            " [1 0]]\n",
            "\n",
            "B =\n",
            "[[ 0.+0.j -0.-1.j]\n",
            " [ 0.+1.j  0.+0.j]]\n",
            "\n",
            "AB =\n",
            "[[0.+1.j 0.+0.j]\n",
            " [0.+0.j 0.-1.j]]\n",
            "\n",
            "BA =\n",
            "[[0.-1.j 0.+0.j]\n",
            " [0.+0.j 0.+1.j]]\n",
            "\n",
            "Commutator [Sx, Sy] = AB - BA =\n",
            "[[0.+2.j 0.+0.j]\n",
            " [0.+0.j 0.-2.j]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Excercise 4.2.5.  The sum of two hermitian matrices is hermitian."
      ],
      "metadata": {
        "id": "jTalVVj5j2b8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define two Hermitian matrices A and B\n",
        "A = np.array([[1, 0+1j], [0-1j, 2]])\n",
        "B = np.array([[3, 2-1j], [2+1j, 4]])\n",
        "\n",
        "# Check if A and B are Hermitian\n",
        "is_A_hermitian = np.allclose(A, np.conj(A).T)\n",
        "is_B_hermitian = np.allclose(B, np.conj(B).T)\n",
        "\n",
        "print(f\"Is A Hermitian? {is_A_hermitian}\")\n",
        "print(f\"Is B Hermitian? {is_B_hermitian}\")\n",
        "\n",
        "# Calculate the sum of A and B\n",
        "C = A + B\n",
        "\n",
        "# Check if the sum C is Hermitian\n",
        "is_C_hermitian = np.allclose(C, np.conj(C).T)\n",
        "\n",
        "print(f\"Is C = A + B Hermitian? {is_C_hermitian}\")\n"
      ],
      "metadata": {
        "id": "dBJw0TWuj44y",
        "outputId": "6b265687-69a3-4f6c-de33-274dd2f4e73d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is A Hermitian? True\n",
            "Is B Hermitian? True\n",
            "Is C = A + B Hermitian? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### example 4.2.5 on expected observable"
      ],
      "metadata": {
        "id": "br6vkhaqhNb_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define the quantum state |psi>\n",
        "psi = np.array([np.sqrt(2)/2, np.sqrt(2)*1j/2])\n",
        "\n",
        "# Define a Hermitian operator A. In this example, let's use Pauli Z matrix.\n",
        "Omega = np.array([[1, -1j],\n",
        "                  [1j, 2]])\n",
        "\n",
        "observable = np.dot(Omega, psi)\n",
        "print(\"observable =\", observable )\n",
        "\n",
        "# Compute the expected value of the observable A in state |psi>\n",
        "expected_value = np.vdot(psi, np.dot(Omega, psi))\n",
        "\n",
        "print(f\"The expected value of the observable Omega in state |psi> is {expected_value.real:.2f}\")\n",
        "\n",
        "# Note: We only take the real part because the expected value of an observable should be a real number.\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O11NzPFBgfAh",
        "outputId": "2a799181-c2f1-4611-f58f-a5a29b4aff46"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "observable = [1.41421356+0.j         0.        +2.12132034j]\n",
            "The expected value of the observable Omega in state |psi> is 2.50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Define the state |psi>\n",
        "psi = np.array([0.6, 0.8])\n",
        "\n",
        "# Define the observable Omega as a Hermitian matrix\n",
        "Omega = np.array([[1, 0],\n",
        "                  [0, -1]])\n",
        "\n",
        "# Compute the expected value of Omega\n",
        "expected_value = np.vdot(psi, np.dot(Omega, psi))\n",
        "\n",
        "print(\"The expected value of Omega is:\", expected_value.real)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7H88x-iChduw",
        "outputId": "d59f51b2-c308-47b6-f584-5c6d2cb70c75"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The expected value of Omega is: -0.28000000000000014\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example 4.2.7 variance calulation"
      ],
      "metadata": {
        "id": "D6Uy2NSEpk-R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Step 1: Define the quantum state |psi>\n",
        "# The given quantum state |psi> is a complex vector\n",
        "psi = np.array([np.sqrt(2)/2, np.sqrt(2)*1j/2])\n",
        "print(\"Step 1: Quantum state |psi> =\", psi)\n",
        "\n",
        "# Step 2: Define the Hermitian operator Omega\n",
        "# In this example, we'll use a sample 2x2 Hermitian matrix\n",
        "Omega = np.array([[1, -1j],\n",
        "                  [1j, 2]])\n",
        "print(\"Step 2: Hermitian operator Omega =\", Omega)\n",
        "\n",
        "# Step 3: Compute the expected value of Omega in state |psi>\n",
        "# First, compute Omega * |psi>\n",
        "observable_vector = np.dot(Omega, psi)\n",
        "print(\"Step 3.1: Omega * |psi> =\", observable_vector)\n",
        "\n",
        "# Then, compute the inner product <psi| * (Omega * |psi>)\n",
        "# This will give us the expected value of the observable Omega\n",
        "expected_value = np.vdot(psi, observable_vector)\n",
        "print(f\"Step 3.2: Expected value of Omega = {expected_value.real:.2f}\")\n",
        "\n",
        "# Step 4: Compute Omega^2\n",
        "# This is just Omega multiplied by itself\n",
        "Omega_squared = np.dot(Omega, Omega)\n",
        "print(\"Step 4: Omega^2 =\", Omega_squared)\n",
        "\n",
        "# Step 5: Compute the expected value of Omega^2 in state |psi>\n",
        "# Similar to Step 3, but now we use Omega^2\n",
        "observable_vector_squared = np.dot(Omega_squared, psi)\n",
        "print(\"Step 5.1: Omega^2 * |psi> =\", observable_vector_squared)\n",
        "\n",
        "expected_value_squared = np.vdot(psi, observable_vector_squared)\n",
        "print(f\"Step 5.2: Expected value of Omega^2 = {expected_value_squared.real:.2f}\")\n",
        "\n",
        "# Step 6: Compute the variance of Omega in state |psi>\n",
        "# Variance = <psi|Omega^2|psi> - (<psi|Omega|psi>)^2\n",
        "# Var(X) = E[X^2] - (E[X])^2\n",
        "variance = expected_value_squared - (expected_value ** 2)\n",
        "print(f\"Step 6: Variance of Omega = {variance.real:.2f}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-oN87T6LqL2E",
        "outputId": "9218abd2-eb05-49f7-8d5d-d377181e2b21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Step 1: Quantum state |psi> = [0.70710678+0.j         0.        +0.70710678j]\n",
            "Step 2: Hermitian operator Omega = [[ 1.+0.j -0.-1.j]\n",
            " [ 0.+1.j  2.+0.j]]\n",
            "Step 3.1: Omega * |psi> = [1.41421356+0.j         0.        +2.12132034j]\n",
            "Step 3.2: Expected value of Omega = 2.50\n",
            "Step 4: Omega^2 = [[2.+0.j 0.-3.j]\n",
            " [0.+3.j 5.+0.j]]\n",
            "Step 5.1: Omega^2 * |psi> = [3.53553391+0.j         0.        +5.65685425j]\n",
            "Step 5.2: Expected value of Omega^2 = 6.50\n",
            "Step 6: Variance of Omega = 0.25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Step 1: Define the quantum state |psi>\n",
        "# The given quantum state |psi> is a complex vector\n",
        "psi = np.array([np.sqrt(2)/2, np.sqrt(2)*1j/2])\n",
        "\n",
        "# Step 2: Define the Hermitian operator Omega\n",
        "# In this example, we'll use a sample 2x2 Hermitian matrix\n",
        "Omega = np.array([[1, -1j],\n",
        "                  [1j, 2]])\n",
        "\n",
        "# Step 3: Compute the expected value of Omega in state |psi>\n",
        "# First, compute Omega * |psi>\n",
        "observable_vector = np.dot(Omega, psi)\n",
        "\n",
        "# Then, compute the inner product <psi| * (Omega * |psi>)\n",
        "# This will give us the expected value of the observable Omega\n",
        "expected_value = np.vdot(psi, observable_vector)\n",
        "print(f\"The expected value of the observable Omega in state |psi> is {expected_value.real:.2f}\")\n",
        "# Note: We extract the real part, as the expected value should be a real number\n",
        "\n",
        "# Step 4: Compute Omega^2\n",
        "# This is just Omega multiplied by itself\n",
        "Omega_squared = np.dot(Omega, Omega)\n",
        "\n",
        "# Step 5: Compute the expected value of Omega^2 in state |psi>\n",
        "# Similar to Step 3, but now we use Omega^2\n",
        "observable_vector_squared = np.dot(Omega_squared, psi)\n",
        "expected_value_squared = np.vdot(psi, observable_vector_squared)\n",
        "\n",
        "# Step 6: Compute the variance of Omega in state |psi>\n",
        "# Variance = <psi|Omega^2|psi> - (<psi|Omega|psi>)^2\n",
        "variance = expected_value_squared - (expected_value ** 2)\n",
        "print(f\"The variance of the observable Omega in state |psi> is {variance.real:.2f}\")\n",
        "# Note: We extract the real part, as the variance should also be a real number\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lUAYGY2GqLzI",
        "outputId": "0c6a79be-56b3-4ab5-a112-e8d07dbe2eb5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The expected value of the observable Omega in state |psi> is 2.50\n",
            "The variance of the observable Omega in state |psi> is 0.25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gt7cdxTdqL5D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.3 Measuring"
      ],
      "metadata": {
        "id": "YQ0hn092q0uB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Step 1: Define the initial quantum state (|psi>)\n",
        "# For demonstration, let's use a normalized state\n",
        "psi = np.array([1/np.sqrt(2), 1/np.sqrt(2)])\n",
        "print(\"Initial state |psi>:\", psi)\n",
        "\n",
        "# Step 2: Define a Hermitian operator (Omega) for measurement.\n",
        "# Let's use a Pauli Z operator as an example.\n",
        "Omega = np.array([[1, 0],\n",
        "                  [0, -1]])\n",
        "print(\"Hermitian operator Omega:\", Omega)\n",
        "\n",
        "# Step 3: Find eigenvalues and corresponding eigenstates of Omega.\n",
        "eigenvalues, eigenvectors = np.linalg.eigh(Omega)\n",
        "print(\"Eigenvalues:\", eigenvalues)\n",
        "print(\"Eigenvectors (each column is an eigenvector):\", eigenvectors)\n",
        "\n",
        "# Step 4: Perform the \"measurement\" and collapse the state.\n",
        "# In practice, you'd use quantum randomness, but here we'll directly use the eigenvector corresponding to the first eigenvalue.\n",
        "collapsed_state = eigenvectors[:, 0]\n",
        "print(\"State after measurement collapsed to the first eigenvalue's eigenstate:\", collapsed_state)\n"
      ],
      "metadata": {
        "id": "EESU7dLIq3kr",
        "outputId": "5b35ec9b-e143-4a47-afa8-83b436eaa7b1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial state |psi>: [0.70710678 0.70710678]\n",
            "Hermitian operator Omega: [[ 1  0]\n",
            " [ 0 -1]]\n",
            "Eigenvalues: [-1.  1.]\n",
            "Eigenvectors (each column is an eigenvector): [[0. 1.]\n",
            " [1. 0.]]\n",
            "State after measurement collapsed to the first eigenvalue's eigenstate: [0. 1.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.4 Dynamics"
      ],
      "metadata": {
        "id": "EoqKvF3kq4cl"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "UU7563GOq7J5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.5 Assembling quantum systems (IBM libary does not load)"
      ],
      "metadata": {
        "id": "lZPU2_3Vrpaq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install qiskit\n",
        "!pip install qiskit-ibm"
      ],
      "metadata": {
        "id": "KtaA173nvJwu",
        "outputId": "1be0795b-685a-4eeb-acb5-3e3cbae4e59f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: qiskit in /usr/local/lib/python3.10/dist-packages (0.44.1)\n",
            "Requirement already satisfied: qiskit-terra==0.25.1 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.25.1)\n",
            "Requirement already satisfied: rustworkx>=0.13.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (0.13.1)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (1.23.5)\n",
            "Requirement already satisfied: ply>=3.10 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (3.11)\n",
            "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (5.9.5)\n",
            "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (1.10.1)\n",
            "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (1.12)\n",
            "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (0.3.7)\n",
            "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (2.8.2)\n",
            "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (5.1.0)\n",
            "Requirement already satisfied: symengine<0.10,>=0.9 in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (0.9.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit-terra==0.25.1->qiskit) (4.7.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit-terra==0.25.1->qiskit) (1.16.0)\n",
            "Requirement already satisfied: pbr!=2.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit-terra==0.25.1->qiskit) (5.11.1)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit-terra==0.25.1->qiskit) (1.3.0)\n",
            "\u001b[31mERROR: Could not find a version that satisfies the requirement qiskit-ibm (from versions: none)\u001b[0m\u001b[31m\n",
            "\u001b[0m\u001b[31mERROR: No matching distribution found for qiskit-ibm\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from qiskit_ibm_runtime import QiskitRuntimeService, Sampler\n",
        "\n",
        "service = QiskitRuntimeService()\n",
        "\n",
        "# Run on the least-busy backend you have access to\n",
        "backend = service.least_busy(simulator=False,operational=True)\n",
        "\n",
        "# Create a Sampler object\n",
        "sampler = Sampler(backend)\n",
        "\n",
        "# Submit the circuit to the sampler\n",
        "job = sampler.run(qc)\n",
        "\n",
        "# Once the job is complete, get the result\n",
        "job.result()\n",
        "\n"
      ],
      "metadata": {
        "id": "V_MRzWBLruMc",
        "outputId": "9d7fe429-72e6-4c17-d953-f16f878bd997",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 784
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting qiskit==0.32.0\n",
            "  Using cached qiskit-0.32.0.tar.gz (13 kB)\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Collecting qiskit-terra==0.18.3 (from qiskit==0.32.0)\n",
            "  Using cached qiskit-terra-0.18.3.tar.gz (5.1 MB)\n",
            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  \u001b[1;31merror\u001b[0m: \u001b[1msubprocess-exited-with-error\u001b[0m\n",
            "  \n",
            "  \u001b[31m×\u001b[0m \u001b[32mGetting requirements to build wheel\u001b[0m did not run successfully.\n",
            "  \u001b[31m│\u001b[0m exit code: \u001b[1;36m1\u001b[0m\n",
            "  \u001b[31m╰─>\u001b[0m See above for output.\n",
            "  \n",
            "  \u001b[1;35mnote\u001b[0m: This error originates from a subprocess, and is likely not a problem with pip.\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25herror\n",
            "\u001b[1;31merror\u001b[0m: \u001b[1msubprocess-exited-with-error\u001b[0m\n",
            "\n",
            "\u001b[31m×\u001b[0m \u001b[32mGetting requirements to build wheel\u001b[0m did not run successfully.\n",
            "\u001b[31m│\u001b[0m exit code: \u001b[1;36m1\u001b[0m\n",
            "\u001b[31m╰─>\u001b[0m See above for output.\n",
            "\n",
            "\u001b[1;35mnote\u001b[0m: This error originates from a subprocess, and is likely not a problem with pip.\n",
            "\u001b[31mERROR: Could not find a version that satisfies the requirement qiskit-ibm (from versions: none)\u001b[0m\u001b[31m\n",
            "\u001b[0m\u001b[31mERROR: No matching distribution found for qiskit-ibm\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        },
        {
          "output_type": "error",
          "ename": "ModuleNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-1ed665b8cb5f>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pip install qiskit-ibm'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mqiskit_ibm_runtime\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mQiskitRuntimeService\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSampler\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mservice\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mQiskitRuntimeService\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'qiskit_ibm_runtime'",
            "",
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"
          ],
          "errorDetails": {
            "actions": [
              {
                "action": "open_url",
                "actionText": "Open Examples",
                "url": "/notebooks/snippets/importing_libraries.ipynb"
              }
            ]
          }
        }
      ]
    }
  ]
}