Aula_0_introduçãoipynb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM9r6l/WF+NtqPeBxfXj7g+",
      "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/GubioGL/Simulador_quantico/blob/main/Aula_0_introdu%C3%A7%C3%A3oipynb.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nese notbook irei reescrever as notas de aula do  \n",
        "\"Quantum mechanics lectures with QuTiP\" link= https://qutip.org/qutip-tutorials/\n",
        "\n",
        "\n",
        "Com objetivo de criar meu propriio qutip iremos não apenas executar os comando das aulas mais criar classes, objetos, funções iguais.\n",
        "\n",
        "Nessa primeira versão iremos usar o numpy com base."
      ],
      "metadata": {
        "id": "S4wNoXpWk6gy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Aula 0 : introdução ao qutip"
      ],
      "metadata": {
        "id": "-a7Cw_ynlJmy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "QuTiP é um pacote python para cálculos e simulações numéricas de sistemas quânticos.\n",
        "\n",
        "Inclui recursos para representar e fazer cálculos com objetos quânticos, como vetores de estado (funções de onda), como matrizes bras/kets/densidade, operadores quânticos de sistemas simples e compostos e superoperadores (úteis para definir equações mestras).\n",
        "\n",
        "Também inclui 'solver' para uma evolução temporal de sistemas quânticos, de acordo com: equação de Schrodinger, equação de von Neuman, equações mestras, formalismo de Floquet, trajetórias quânticas de Monte-Carlo, implementações experimentais das equações mestras/de Schrodinger estocásticas.\n",
        "\n",
        "Para poder compara com o pacote do qutip temos que primeiro intalar:"
      ],
      "metadata": {
        "id": "YwvuqJ-EOUu4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install qutip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nntVdNIoN_d_",
        "outputId": "30a9be15-b516-432c-b7c4-5566276813ec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: qutip in /usr/local/lib/python3.10/dist-packages (4.7.4)\n",
            "Requirement already satisfied: numpy>=1.16.6 in /usr/local/lib/python3.10/dist-packages (from qutip) (1.23.5)\n",
            "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qutip) (1.11.4)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from qutip) (23.2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "78Wutb-Ik1xJ"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from IPython.display import Image\n",
        "from qutip import (Qobj, about, basis, coherent, coherent_dm, create, destroy,\n",
        "                   expect, fock, fock_dm, mesolve, qeye, sigmax, sigmay,\n",
        "                   sigmaz, tensor, thermal_dm)\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A estrutura mais basica do qutip é a class qobj, que eles chamaram de objto quantico.\n"
      ],
      "metadata": {
        "id": "CG9J0vsqPiqp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "q = Qobj([[1], [0]])\n",
        "q"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "id": "oSNjBw0UR14_",
        "outputId": "9aad48f7-3a71-4385-a71a-66675d230d3c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
              "Qobj data =\n",
              "[[1.]\n",
              " [0.]]"
            ],
            "text/latex": "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket $ \\\\ \\left(\\begin{matrix}1.0\\\\0.0\\\\\\end{matrix}\\right)$"
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$|ket> =  \\left(\\begin{matrix}1.0\\\\0.0\\\\\\end{matrix}\\right)$$"
      ],
      "metadata": {
        "id": "xJh3wZW5YXeg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Como essa é um biblioteca ja tem validade a classe qobj é bem complicada de ser reproduzida com todas suas caracterista então tentaremos reproduzir apenas o basico com a biblioteca numpy e scipy."
      ],
      "metadata": {
        "id": "epEQjgrDSQSh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ket(entrada_):\n",
        "\n",
        "    if entrada_ == '0':\n",
        "        entrada_  = np.array([[1], [0]])\n",
        "\n",
        "    elif entrada_ == '1':\n",
        "        entrada_  = np.array([[0], [1]])\n",
        "\n",
        "    else:\n",
        "        try:\n",
        "            entrada_  = np.array(entrada_)\n",
        "        except ValueError:\n",
        "            print(\"Entrada invalida.\")\n",
        "    return entrada_\n",
        "\n",
        "def bra(entrada_):\n",
        "    return ket(entrada_).T"
      ],
      "metadata": {
        "id": "d_8xFO99SgJI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "state = ket('0')\n",
        "state"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q2tnaFhPbd5h",
        "outputId": "4a57b650-d50d-40d9-f06e-9536526e8d6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1],\n",
              "       [0]])"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "state2 = bra('0')\n",
        "state2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qpGD_VyyohhK",
        "outputId": "08f29e45-a6f2-4f43-e197-81c9d5373edf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.dot(state,state2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w9SWGAWmo2Pp",
        "outputId": "b4b1a42b-d4c6-42d1-de8b-1833b0db97b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 0],\n",
              "       [0, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.dot(state2,state)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PP1H8CXioo6J",
        "outputId": "d93bfa0b-7c88-495d-892c-6436e818adad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1]])"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Obtemos nosso vetor desejado!\n",
        "\n",
        "$$|ket> =  \\left(\\begin{matrix}1.0\\\\0.0\\\\\\end{matrix}\\right)$$\n",
        "\n",
        "\n",
        "$$< bra | =\n",
        "\\left(\n",
        "    \\begin{matrix}\n",
        "        1.0 &  0.0\n",
        "    \\end{matrix}\n",
        "\\right)$$\n",
        "\n",
        "note que o bra é o transporto do ket:\n",
        "\n",
        "$$< bra | == (|ket>)^T  $$\n",
        "\n",
        "e como esperado, o produto interno entre o bra e ket é 1.\n",
        "$$< bra|ket> = 1  $$\n",
        "por que:\n",
        "\n",
        "$$\n",
        "\\left(\\begin{matrix}\n",
        "    1.0 &  0.0\n",
        "\\end{matrix}\\right) *\n",
        "\\left(\\begin{matrix}1.0\\\\0.0\\\\\\end{matrix}\\right)\n",
        "= 1*1 + 0*0 =1\n",
        "$$\n",
        "\n",
        "e no outro caso\n",
        "\n",
        "\\begin{equation}\n",
        "    |ket>< bra | =\n",
        "\\left(\\begin{matrix}\n",
        "        1 & 0 \\\\\n",
        "        0 & 0\n",
        "    \\end{matrix}\n",
        "\\right)\n",
        "\\end{equation}\n"
      ],
      "metadata": {
        "id": "yTVBVB30mVa5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.dot(state,state2).shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SQkyazaGm5ty",
        "outputId": "80fe0563-bbcc-469f-98d1-6cccc81f8258"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def U(entrada_):\n",
        "\n",
        "    if entrada_ == 'PauliX':\n",
        "        entrada_ = np.matrix([[ 0, 1 ],[ 1, 0 ]])\n",
        "    elif entrada_ == 'PauliY':\n",
        "        entrada_ = np.matrix([[ 0, -1j ],[ 1j, 0 ]])\n",
        "    elif entrada_ == 'PauliZ':\n",
        "        entrada_ = np.matrix([[ 1, 0 ],[ 0, -1 ]])\n",
        "    else:\n",
        "        try:\n",
        "            entrada_  = np.matrix(entrada_)\n",
        "        except ValueError:\n",
        "            print(\"Entrada invalida.\")\n",
        "    return entrada_"
      ],
      "metadata": {
        "id": "EPNOtK1fxI-b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "U('PauliY'),U('PauliX') , U('PauliZ') , U([ [-7,1+1j], [1-1j,-7] ])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wj68V5HIzbvT",
        "outputId": "829d2335-f6b2-4771-d792-61ec95f59660"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(matrix([[ 0.+0.j, -0.-1.j],\n",
              "         [ 0.+1.j,  0.+0.j]]),\n",
              " matrix([[0, 1],\n",
              "         [1, 0]]),\n",
              " matrix([[ 1,  0],\n",
              "         [ 0, -1]]),\n",
              " matrix([[-7,  0],\n",
              "         [ 0, -7]]))"
            ]
          },
          "metadata": {},
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo de hamiltoniana\n",
        "sz = U('PauliZ')\n",
        "sy = U('PauliY')\n",
        "H  = 1.0*sz + 0.1*sy\n",
        "\n",
        "print(\"Qubit Hamiltonian = \\n\")\n",
        "H"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AZSRDt3e0VJL",
        "outputId": "a52d40b2-ff74-4f71-8ad5-299e4599889d"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Qubit Hamiltonian = \n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "matrix([[ 1.+0.j ,  0.-0.1j],\n",
              "        [ 0.+0.1j, -1.+0.j ]])"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Se vc quiser obter o transpoto, deve fazer:"
      ],
      "metadata": {
        "id": "j8pnCqRv31U7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"ket (numpy):\\n\",ket('0'))\n",
        "print(\"ket^T (numpy):\\n\",ket('0').T,\"\\n\")\n",
        "\n",
        "q = Qobj([[1], [0]])\n",
        "print(\"ket :\",q)\n",
        "print(\"ket^T :\",q.trans())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v6jULTwfAEUb",
        "outputId": "72e5e189-f78b-4e9c-bb5b-2ec4f2024fc3"
      },
      "execution_count": 170,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ket (numpy):\n",
            " [[1]\n",
            " [0]]\n",
            "ket^T (numpy):\n",
            " [[1 0]] \n",
            "\n",
            "ket : Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
            "Qobj data =\n",
            "[[1.]\n",
            " [0.]]\n",
            "ket^T : Quantum object: dims = [[1], [2]], shape = (1, 2), type = bra\n",
            "Qobj data =\n",
            "[[1. 0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Parece igual"
      ],
      "metadata": {
        "id": "k5qiBTrHCYmk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"sy(numpy): \\n\",sy)\n",
        "print(\"sy(numpy)^T: \\n\",sy.T,\"\\n\")\n",
        "\n",
        "Sy = Qobj([[0, -1j], [1j, 0]])  # the sigma-y Pauli operator\n",
        "print(\"sy: \\n\",Sy)\n",
        "print(\"sy^T: \\n\",Sy.trans())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bhkbFQp49faz",
        "outputId": "f077e568-a143-46b0-e865-d89ff68b4327"
      },
      "execution_count": 173,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sy(numpy): \n",
            " [[ 0.+0.j -0.-1.j]\n",
            " [ 0.+1.j  0.+0.j]]\n",
            "sy(numpy)^T: \n",
            " [[ 0.+0.j  0.+1.j]\n",
            " [-0.-1.j  0.+0.j]] \n",
            "\n",
            "sy: \n",
            " Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
            "Qobj data =\n",
            "[[0.+0.j 0.-1.j]\n",
            " [0.+1.j 0.+0.j]]\n",
            "sy^T: \n",
            " Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
            "Qobj data =\n",
            "[[0.+0.j 0.+1.j]\n",
            " [0.-1.j 0.+0.j]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Então para tiar o transporto apenas devemos usar .T"
      ],
      "metadata": {
        "id": "hIIec6gxDG78"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Muitas vezes vamos precisa tiar o conjugado + transposto de um vetor ou matrix, no qutip temo o .dag()"
      ],
      "metadata": {
        "id": "1X7IFpCWDP9l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Sy = Qobj([[0, -1j], [1j, 0]])  # the sigma-y Pauli operator\n",
        "print(\"sy: \\n\",Sy,'\\n')\n",
        "print(\"sy^T: \\n\",Sy.dag())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tsg0zT429sT1",
        "outputId": "e8e77b40-a236-438b-cc20-d5d168c6e913"
      },
      "execution_count": 164,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sy: \n",
            " Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
            "Qobj data =\n",
            "[[0.+0.j 0.-1.j]\n",
            " [0.+1.j 0.+0.j]] \n",
            "\n",
            "sy^T: \n",
            " Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
            "Qobj data =\n",
            "[[0.+0.j 0.-1.j]\n",
            " [0.+1.j 0.+0.j]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"ket (numpy):\\n\",ket('0'))\n",
        "print(\"ket^T (numpy):\\n\",np.conjugate(ket('0').T),\"\\n\")\n",
        "\n",
        "\n",
        "print(\"sy(numpy): \\n\",sy)\n",
        "print(\"sy(numpy)^T: \\n\",np.conjugate(sy.T),\"\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-zzPTSO48pv0",
        "outputId": "877041a9-5a22-4ec8-a985-6efa45c05704"
      },
      "execution_count": 174,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ket (numpy):\n",
            " [[1]\n",
            " [0]]\n",
            "ket^T (numpy):\n",
            " [[1 0]] \n",
            "\n",
            "sy(numpy): \n",
            " [[ 0.+0.j -0.-1.j]\n",
            " [ 0.+1.j  0.+0.j]]\n",
            "sy(numpy)^T: \n",
            " [[ 0.-0.j  0.-1.j]\n",
            " [-0.+1.j  0.-0.j]] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos criar um função para isso:"
      ],
      "metadata": {
        "id": "ms2w9KEdDvgc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def dag(objeto):\n",
        "    return np.conjugate(objeto.T)\n",
        "print(\"ket (numpy):\\n\",ket('0'))\n",
        "print(\"ket^T (numpy):\\n\",dag(ket('0')),\"\\n\")\n",
        "print(\"sy(numpy): \\n\",sy)\n",
        "print(\"sy(numpy)^T: \\n\",dag(sy),\"\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dqWDDmcoD0NF",
        "outputId": "1ab6e91e-adb3-48d3-90bd-57fc53b2b591"
      },
      "execution_count": 176,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ket (numpy):\n",
            " [[1]\n",
            " [0]]\n",
            "ket^T (numpy):\n",
            " [[1 0]] \n",
            "\n",
            "sy(numpy): \n",
            " [[ 0.+0.j -0.-1.j]\n",
            " [ 0.+1.j  0.+0.j]]\n",
            "sy(numpy)^T: \n",
            " [[ 0.-0.j  0.-1.j]\n",
            " [-0.+1.j  0.-0.j]] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "OYsv2uLeEFud"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}