{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Solving Common Introductory Quantum Mechanics Problems using Sympy\n", "\n", "Adapted from work of E. Harvey [JCE Symmath](http://www.chemeddl.org/alfresco/service/org/chemeddl/symmath/frameset?guest=true) (accessed 2019-09).\n", "\n", "\n", "This notebook show basic examples for quantum calculations encountered in undergraduate physical chemistry course. The purpose of this notebook is not to explain the theory behind the calculations, bur rather show how python can be used for solving typical problems.\n", "\n", "This notebook assumes [sympy](http://sympy.org) is available and some familiarity with python lists and functions. The [sympy tutorial](http://docs.sympy.org/latest/tutorial/index.html) describes all of the functions used in the notebook." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Objectives\n", "\n", "After completing this work you should be able to use python and sympy to\n", "1. calculate a normalization constant\n", "2. calculate an expectation value and its variance\n", "2. determine whether a function is an eigenvalue of an operator\n", "3. determine if functions are orthogonal" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## Prerequisites\n", "- basic knowledge of python and sympy\n", "- the python [SciPy](http://www.scipy.org) stack\n", "- the python [sympy](http://www.sympy.org) symbolic computation library\n", "- basic understanding of eigenfuctions, normalization, orthogonality, and expectation values\n", "\n", "## Python environment\n", "First, import libaries and initialize sympy's 'pretty' printing." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# import and initialize libraries\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "import numpy as np\n", "from sympy import *\n", "\n", "# uncomment one of these and comment the other\n", "init_printing() # jupyter, cocalc\n", "#init_printing(use_latex=False) # colaboratory" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## General properties of wavefunctions\n", "\n", "Remind yourself of some key properties of wavefunctions. These properties (sometimes call Born's conditions) are generally found in a discussion on the postulates of quantum mechanics. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Your Turn\n", "List as many properties of wavefunctions as you can and give a brief summary of the meaning of the property (one is given as an example)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "(double click this cell to add answers...)\n", "\n", "1. A wavefunction must be single-valued. This means that $\\psi(x)$ must have a unique value for any value of x. \n", "\n", "2. \n", "\n", "3. \n", "\n", "4. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Normalizing functions\n", "One of the postulates of quantum mechanics states we can calculate the probability of finding an electron in space if the wavefunction is known. The *normalization condition* must be satisfied:\n", "$$ \\int_{0}^a \\psi(x)^* \\psi(x)\\; dx = 1 $$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start with a simple function representing the wavefunction of a particle\n", "\n", "$$ f(x) = N_0 e^{-ax^2/2} $$\n", "\n", "where $N_0$ and $a_0$ are constants.\n", "\n", "Start by identifying the variables in the function. We also include sensible assumptions about certain variables if they are known. This is not necessary, but allows us to disregard physically impossible results (and speed up some computations)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEAAAAAbCAYAAADMIInqAAAABHNCSVQICAgIfAhkiAAAAq1JREFUWIXt2EtoVFccx/FPoqKoK2t8INFFShel0YUVqUbQKCJIkbZ0V1sjxZ07kaogKS4UVHzgAx+IutEWQUVKKSi0pbpJQWPAUNqVD9T4QMQHGjVd/O/AdZirM4nJjDpfuDD3f84953fO+Z//+Z/h7aIev+MS2vFlWdWUgfGYkvwegysYXj455eciJvalgdo3JKQcfIohwgveOz4QcWBGRvl+bMEqtOE+buEUPhkIgf3JUPyJxRnltbiB2fgNLWLQjTielI3qd5UZrBX79oFYkQMYlir/Gk8wKWXbhn9RhxocQesr+vgMdzC4QNlIPMfnvVLfR2rwI2aKAc7DNfyQV+dv7EveV+AmGpL3JrzAhdTTmNfPBhzO0DAePYmGimAvDubZ5qNbTMx9EexKoVN2fvATzmNQiW1m0ipm9FXP7KRuPbajA3fFNujGugLtnsMzLChRz0d4jBEFyjbiOj5MGwvtk1LYgaOvqXNZRO02EbxW4Kpw5TaR0aVpFslOLbpK1LMIZ/Awz74Z32AO/iumoa/wK27jqQhCq/Xedb7FPbHHcywRHtKQsk1J6n2HE4mGUvgL3+fZtos48nExDQwSUbZHDHo3tuKfxHaoREE5FgqX/kK44HLhjulJmSSC4prkfbLwkllF9lEnttTYlG2XiCPNGJd6RmY1skMMdL2Xt8cQnE3KiprJPGqwMxHTJVZlk7jYEOdyJ/bkffezWNViWCpiR5qsuNRaqIHpYsZPZHSwLPm4pUhBA81JrCz1o/QqLxcr9UjhGcqlkDUFyiqBs2L79pourz/SekQC884xTAzuj3ILGWhy1+GcW48ul5BKoF14QVYa2eQNppCVQjqgzccvIjCeFre2WkzAVHEU9unfl7eBaTgm7szdIhPsEOfz3DLqqlKlSpUq/cH/L5idbSWuYgMAAAAASUVORK5CYII=\n", "text/latex": [ "$\\displaystyle e^{- \\frac{a x^{2}}{2}}$" ], "text/plain": [ " 2 \n", " -a⋅x \n", " ──────\n", " 2 \n", "ℯ " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, x, N0 = symbols('a x N0', positive=True)\n", "\n", "f = E**(-a * x**2 / 2)\n", "f" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define a wavefunction $\\psi(x)$ using `f` and a normalization constant." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFgAAAAeCAYAAAColNlFAAAABHNCSVQICAgIfAhkiAAABA9JREFUaIHt2VuoVkUUwPHfOWVKCYG3PIX5YEinUiEjKzVEooLowS6eh6hUrAfD6iGjC4nSQ9IFTcsoo9uLpFhKRWRBVyXTMJOKOkQXsYtpiJVRll8PazZut9/+PN9ROxe+P2y+PbPWzF579qw1a+ajQZ5heAefYwuu6lJreiEtGJPuh2AbTuw6c3o/n+L0I+mg+SgZ0hs5D33ELG5wlBko4vBFJfKnsTDd342N2INf8ArOOdYG9mT64j1cXyJvxk+YlMpvYLoY1FF4OckHHFMru5C5Inb+LmbUM+iXZNfiLwzP6T+KdgxGE5ZjXo3+L8QuHF8i749/cWWnrO/mNGE+xotBvATbcVdOvgnLUvkO/IwRqTwB+/FJ7hpVeMYCvFDDhhZUkg1VeTMpVHBuic6yJJ9S40HdhafwXK58KfaJQd8jFrN6+ELt/PhFbMZxZQq7HBjgBSU6m5N8WJ3G1cu8nC1l16Sc/jAsxlb8KsLEPtxf6Hc9/sHlddozEn/ipBL5Q/gRZ5R1MCIZvVG41tdVdPrib+Fax5pBOPMwV7YRGCgWlxW4DGejVQzyNbk+J+MPEQrKPLSMOXi1RPaIGJOzanXQJgZ4qZgJFYe60LhU/1qdxuW5Gq9jp/hY7bhHDbfqADdgt4izGdOErVmMHZN0bsTqZEM9fICZVeoX68DgElO8ghmYmO4fLOjckurn12kcMYDLU/t2PIFF+DLVPd+JPjOuEG4/RbjobOGu2aAPF155b9IfLWbxxA72P1iEm1MK9UtFLJ+Mobmrf7VO3hYvOlrke9vxTUHn2aTTmTTksdT2AQenOX2wLskOOwtKaMLj4mV3iFn1sDi8GSAWpycLbVaIWdkRZojYXaRsbZhXzcDd2OvAy2dh4vyc3tZU19JBwzLGiRmzukR+c+p3ep39/l+swZ31NsrPopE4GR8KV4OVwtWm4iOxoLTiB+F+GbPEAtCCz3A73i88a7b4iHtVT+Sz7WVTFVl3YJ0Ib53mOjGDluTqmsVgfidefHzSWZPTaROx6SYx+IvFyl08hdrh8ClXRWwOeiULxQtOK9QvSfUX4LZ0f19OvsGBnVFGu4izGf1Su3ePnrk9g/xxZZaObSrorEy/U6vonICxWFtos9bBJ1GZ2w/qtKU9nGb8JhLwYi6ahYltYiWuiJQFTk3liwtt5orUK8+WpFu2zZxQ5dk9nmyRaxV523pxEpRnP14S+S98L06p8lQK5aYqdXPE5mQV3hInXs04TXhBH0f470F3JAsRY9NvMTxkrMzd53V2ig8ytKA/xKFb6SxsrBInVLeKM9dWMeDdNT3rcjaIE6s8Xzl4kWtwBLSJ84SZYjYuEmna8FqNGtTHLHwr/i342KGLXoMGDRo0aNCgt/EfmQH+5UUlaa4AAAAASUVORK5CYII=\n", "text/latex": [ "$\\displaystyle N_{0} e^{- \\frac{a x^{2}}{2}}$" ], "text/plain": [ " 2 \n", " -a⋅x \n", " ──────\n", " 2 \n", "N₀⋅ℯ " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "psi = N0 * f\n", "psi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "sympy's `conjugate()` gives the complex conjugate. Because `psi(x)` is real, its complex conjugate is the same function." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle \\left( N_{0} e^{- \\frac{a x^{2}}{2}}, \\ N_{0} e^{- \\frac{a x^{2}}{2}}\\right)$" ], "text/plain": [ "⎛ 2 2 ⎞\n", "⎜ -a⋅x -a⋅x ⎟\n", "⎜ ────── ──────⎟\n", "⎜ 2 2 ⎟\n", "⎝N₀⋅ℯ , N₀⋅ℯ ⎠" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# sympy conjugate() gives the complex conjugate of a function\n", "psi_star = conjugate(psi)\n", "psi, psi_star" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### python interlude: complex numbers in sympy and python\n", "In python, complex numbers (those related to $\\sqrt{-1}$, the [imaginary unit](https://en.wikipedia.org/wiki/Imaginary_unit)) and $e^x$ can be entered in different ways. If `sympy` is loaded, `I` is the imaginary unit and `E` is the Euler $e$. In 'plain' python these are `1j` and `exp()`. For example $e^{ix}$ can be entered as:\n", "\n", "- `E**(I*x)` or `exp(I*x)` if sympy has been loaded\n", "\n", "- `exp((1j * x))` if using 'plain' python\n", "\n", "If in doubt, use the `type()` function to see what the computer thinks you're using:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sympy.core.numbers.ImaginaryUnit" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(I)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "complex" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(1j)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Your Turn\n", "Enter an expression for a complex function. Use the `conjugate()` function to compute the complex conjugate. Then multiply the expression and its conjugate. Print all three." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle \\left( x^{2} e^{1.0 i x}, \\ x^{2} e^{- 1.0 i x}, \\ x^{4}\\right)$" ], "text/plain": [ "⎛ 2 1.0⋅ⅈ⋅x 2 -1.0⋅ⅈ⋅x 4⎞\n", "⎝x ⋅ℯ , x ⋅ℯ , x ⎠" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# solution\n", "psij = x**2 * E**(1j*x)\n", "psijc = conjugate(psij)\n", "psij, psijc, psij*psijc" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To determine $N_0$, integrate over the domain space. In this case, $-\\infty$ to $\\infty$, represented in sympy by `-oo` and `oo` (two lowercase letter o ; which look similar to the infinity glyph)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAF8AAAAcCAYAAAAHgGM3AAAABHNCSVQICAgIfAhkiAAABJdJREFUaIHtmWuIVVUUx393rHGyKTUZdUSLtCx7iD0VsikDI5AMoRxSGIpM0IgwLOiDvehhWVROWVA2TA9NTCUqLEVK7SXTlJZljZSJqD2mrHxQ1nT9sNbmntl373P2zL3Xq3T+cOCe/15r7bX2Y+119oUUKQrAXUAL8CfwC/AmcE5ZPSoRrgL+BrJFfArFu8CNyICfC6wAfgROKoJtAxP3W5Qx9kXAzMLiKDmqgQ7g6iLaLHvcJwJ7KO6KMlhNbjWc75F5XtsnJdiqVblLPO0DkMmZH+hbKeMOxjRgWYls/0pu8Od6ZD7X9iEJtpaobA9P+3S1My7Qt1LGHYz1wMQS2B2GDEYLsBP4ziHTEzgI/JRgax6wGzgtRmYl0I5/cmyUKu5gDAV+Bo71tE8g/JAZZenWK78ASQVZ4EJLZrTyb8f4+DgyOWfFyPRGDs6mGJkokuI2mAK8CrQBe5E01YIUAl4cY70fj+S43RbfACwG/vHY+QN4FpgBfAW8Hmk7ExngD5Dc/oWlawb6U2ArcCswWd9dMi7M1z7GAV97ZEAWSSWw3OK7GzfACUCz+rYemaz+wDXAi/r7kRh9hmsn+5EZjCIDfI//IDSYhKzOByz+TuVv8ui9p+0jgQok9WyzZJpUxlXBLEBq/CuAgZGn2iG7FNgHVOl7MeKu1v5s1CK74JsEfQYiq2udOhJ1vA7YnGQAuA8ZoGst/jXlL3DoZIDfgQPkdqFJPRdH5L5UrtZhw5fe7rXkqpDBWBrhihF3HL5FdkIQTCXQEOEWAncE6L6huqdbfBuybXs6dM5QnY8j3KXKPabvvYB/kR1RCCaq3SmOtkLi7gvMAT5Bcn0HnRfBZ6EO9gH+Albp+3FqcFCA7nZkZWUiXDXwH7JyXZiqDjZGuApgl9rLIPV6FpncQtCEHLa9HW3djXsk8jWdBTYg596DyK5rVj70cAekpu3QjqcC7wTo9NWOPrR4s4pf9ug9oe03WHyj8mOA2/T3nAA/fOiBlJcrY2S6E/cmZNIud7Tdj/h9i0+5wsG9ovz1yDZsDnDClI+bLN4cVhs9er4qxuTlyTEyIJ/825ABaEUm24U6oB9y7+NDV+Megqz89/WJog+5MrM1wU4nVAK/ISf9HmQLJmEWMsvTLd5cCVzp0KlA0tR+8j94TOrZAWxRGzWWTD1yltwMjEAO6n3AyY6+GpFVPSAmhq7GXaN+tdH5O6AfctmXVf+q8lXj8ZwqvxAob/LbaItfpvwsYLDVdjbuVGXwNLlDa7ujfQMyuVFsBR52yO5AavAkdDXuNeQO1UeR9NqO7NwO8jNBEMaq0bpA+Y3aWS+Lr1dnDgCzrbYG7eMpj83LyA2+fbdSiVRA11n8M8Bai7tIbdweG4Ggq3HXAC8h/yPsBT5C4jpP7SwMtNMJGeSeJJMkWCYMwj1IdyO1dRQPqeypAXaP9LiPCJjBtw/Ye8j/otyC/8AvK+y7naMF7Uiasz/r+5N/8znisHjUDbhKzaMBB5ESbrzFj0fybooSox6ZhGnI6n4SKTVPKadT/yfMBH5Arg1aCa9SUqRIkSJFisOKQ24NaLrhHpw7AAAAAElFTkSuQmCC\n", "text/latex": [ "$\\displaystyle \\frac{\\sqrt{\\pi} N_{0}^{2}}{\\sqrt{a}}$" ], "text/plain": [ " 2\n", "√π⋅N₀ \n", "──────\n", " √a " ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 'prob' is short for 'probability'\n", "prob = integrate(psi * psi_star, (x, -oo, oo))\n", "prob" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Solve the equation \n", "\n", "$$ \\int_{-\\infty} ^{\\infty} \\psi(x)^* \\psi(x) dx = 1$$ \n", "\n", "for $N_0$. The symbolic solver in sympy equates an expression to zero, and then solves for a variable. We need to rearrange the equation to\n", "\n", "$$ \\int_{-\\infty} ^{\\infty} \\psi(x)^* \\psi(x) dx - 1 = 0$$" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFMAAAAYCAYAAACGLcGvAAAABHNCSVQICAgIfAhkiAAAA4lJREFUWIXt2FuIVWUUB/CfY4mapWZm2g2DpAiiBnqJGo49SCCl9ZDUgxFBUPRSRPQSTFFBRS/10EOU2BW6+VJIRXGgiEILs1ITEoMyM6nMcbqYTg9rH2bPnn07ztZjNH84nHPW9631/fc66/YdJtET9GEDXu81kRSOK059Xey9Hd+WrF+Nv/AWRhp8/dc4gVZGYVtq7XS8j6sUR8HLuKPOQQ2hV5xOU8O5rWShjUHcmVpbi8uTPXnET8GvOLURuvlYgEN4ssecZgr/DGKnlDNPyNncTjZ2MJAofCyI5+EGfIBfJkSzHCtEWVrXY07DRv3Twrl5m1qC4GBGfh9+EL/CbhzAs5k9H+LaifMsxXrsxdTjiFNbRZoPlii3jE+p87AHJ1YcfBNewnbsFym4AbdU6MFs0UjWNMRpufrN5pISXm0VaV6Ek7AwR74ar+Bgie7JosZtFBGzRzSQFXgu+fxoif5yTMObDXHah6fFNPC1sT/GBViFj/AeNpfwKkRLfmQuSYgdEJGVxhTsQH+F7Vk4I0e+UETptpy1NF7DEKY3yOk68bwPZeT3JvJbK/Q5gsj8HU/gTKwUjhlK1q4UBfnzChtDKZ00fsQu5R13upgX1+PPBjl10ndTRt5fIK9EnaF9t0jPF8VYcH1q7WaRvlWYi/vxiaiVh4zWpCX4vkR3mXDWuoY5dZz5RUbej3/wVQ0bhWgpb0BzRGS8m3yfIRyzqMLuxeLhR/CpqFUPJ+esTeR5jaWDNaL5zG6QE3wnSsyUlGwWDuPLGvpMoAH9hrdFWi3CUuGcXRV6L4iHXpocnsaDyfvGAt2puEbMi/sa5DQX54g5NT3aXCqc23WK093dnEirPtwoOmZVOp0tIrNtvCPnGB2LPivQH8A8Y1N8opwoT3GO0JlptFTPmdPEjWKHSKcZFTbnJza3GzvzzcM7ydpBo106i6dEfV3QICe4Kzn7toz8mUS+rIYNMmnebWT+jVexGG/gj4r9P4sUPV+k32Mi7b8RHfkwthjt0lmsFKn4U4OcKI7MzlRxEc6qYacQLdWRCVck+wZq2p2P54Vj9wvnrBb1acT4a2AHlyXrd9c4o1tOm0TEz8zIV4kr6zDuqWGnbQLXSaJAP25sFzwaeCThs7jG3mPFKYu2Cmfm/Z/ZC2zVQCM4Cij8PzM9Gu3EA6nve48FsxJc2OPzizBsrJ8mMYlJ/H/wL2e/QJavQ1bNAAAAAElFTkSuQmCC\n", "text/latex": [ "$\\displaystyle \\left[ \\frac{\\sqrt[4]{a}}{\\sqrt[4]{\\pi}}\\right]$" ], "text/plain": [ "⎡4 ___⎤\n", "⎢╲╱ a ⎥\n", "⎢─────⎥\n", "⎢4 ___⎥\n", "⎣╲╱ π ⎦" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "solve(prob - 1, N0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Although there is only one solution, the brackets tell us sympy returned a list. This is handy if more than one solution exists. To use the normalization constant later, assign the name `norm` to the first (and only) entry in the solution list. Remember, python lists are zero-indexed." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEUAAAAYCAYAAACsnTAAAAAABHNCSVQICAgIfAhkiAAAAw1JREFUWIXt11uoVFUcx/GPl7zkMTXxSj0YGIEgXV+iDoceIgi0IJIUDkQgVE9KSS+BRgXVWz30EBZaWWQXgsAuFNFFCi3UrPRAkg9BWRRpViZ2evivOe7Z7JlZHvbMIZgfDMz81v6v9V1r/9d/raGvjpqMPXh1okGSJoRncun33fiuxbM34RTewmiNn3Zqx9MTpoV4HzeofjM7cE+HSdSpTjz0gGkbrsVQBcQF+A0XdnH8RTiDJzN4usrU2D6DIm12t3judnyAX+sGKGh14nkjg6cnTA/gB3yPH3ESWwvtH2NVtwZP2oVfMCWDp1dMYxrSnK6X4BjOy4hdixcxghMivffgzg5xc0TBfC6DJ4fpZvlF9fJy8NTC91lin5Y1jJdwugVAQ7NFHdgr3uIxUSxX49n0/bE2k5iG10v+LCwZB9PveFqcXl9rXtTLsAaf4D0cqOrg0jTASfGWi5qEI7iyxeBFDWBxhb9EZM2hNrE78Qdm1Mh0q8iEh0v+puTf1S54Ma7GRwlioNA2iIMdBs/RYZE5VZohFm1nzUxbxORvK/kvJ/+qjD6sTw8PF7ytuD8nGPPwID4TteSM5r37ZYu4Val9bc1Mb6bY5SV/RGy76Rl9mIu/8W76PVNMbmlG7EpxSozic7GfH8FmUWdGVRdRyT8lim2dTEdFBk4qeAP4F19lxI/pNfGGl2Id3s6M2y/ghyraHhKLcm9F2xRxDO+qmWleGvPTkn998p9vF1z+7/NC8u4QKbstA+BikSkfpk9Rc509jr+oiB3EfHFha6XxMDWO2f0lv1Gc92X0MaZp4oZ4RKTpzIyYBWL1RzTfG+bjndR22tmTpainRBYsqplpQxp3fcl/Jvk3tgsuZ8o/eAXLRNr+lQHws7huLxf15HGRnodxXOzhb8T2KusWcZX/qU3/42FqlSmN/0krcFFGP2O6Tqzm4DnELMB2sUAnxESHcUXqq3xFh2tS28YuMO0TGXh+yV8jatifuC+zL0S1fkJz1e6GHhUTXZbxbK+YJlzfOseC11dfffX1f9R/F5QFhYZqX+kAAAAASUVORK5CYII=\n", "text/latex": [ "$\\displaystyle \\frac{\\sqrt[4]{a}}{\\sqrt[4]{\\pi}}$" ], "text/plain": [ "4 ___\n", "╲╱ a \n", "─────\n", "4 ___\n", "╲╱ π " ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "norm = solve(prob -1, N0)[0]\n", "norm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Verify that the normlization constant is correct by substituting `norm` for $N_0$ in the expression for `prob`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAABHNCSVQICAgIfAhkiAAAAHZJREFUKJFjYKACCGFgYJjMwMBwmIGB4RMDA8N/BgaGJYQ0XYAq/MzAwHCdWE2ODAwMqgwMDIwMDAwOuDSxoPH3EzKVgYGBgYkYRaOaBlwTeuQGQDEDAwODBJS2ZGBgWABlv2FgYChBN6SBAZJ0cOEH5LiMzgAA6XoX52TB9a4AAAAASUVORK5CYII=\n", "text/latex": [ "$\\displaystyle 1$" ], "text/plain": [ "1" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "prob.subs(N0,norm)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is useful to use 'actual' numbers and verify the symbolic result.\n", "\n", "Assign a numeric value to $a$ (let's use 3), and repeat the process. Use `.evalf()` method, or the `N()` function to get numeric results from symbolic expressions. (Recall, $f$ was the unormalized function.)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEAAAAAbCAYAAADMIInqAAAABHNCSVQICAgIfAhkiAAAAq1JREFUWIXt2EtoVFccx/FPoqKoK2t8INFFShel0YUVqUbQKCJIkbZ0V1sjxZ07kaogKS4UVHzgAx+IutEWQUVKKSi0pbpJQWPAUNqVD9T4QMQHGjVd/O/AdZirM4nJjDpfuDD3f84953fO+Z//+Z/h7aIev+MS2vFlWdWUgfGYkvwegysYXj455eciJvalgdo3JKQcfIohwgveOz4QcWBGRvl+bMEqtOE+buEUPhkIgf3JUPyJxRnltbiB2fgNLWLQjTielI3qd5UZrBX79oFYkQMYlir/Gk8wKWXbhn9RhxocQesr+vgMdzC4QNlIPMfnvVLfR2rwI2aKAc7DNfyQV+dv7EveV+AmGpL3JrzAhdTTmNfPBhzO0DAePYmGimAvDubZ5qNbTMx9EexKoVN2fvATzmNQiW1m0ipm9FXP7KRuPbajA3fFNujGugLtnsMzLChRz0d4jBEFyjbiOj5MGwvtk1LYgaOvqXNZRO02EbxW4Kpw5TaR0aVpFslOLbpK1LMIZ/Awz74Z32AO/iumoa/wK27jqQhCq/Xedb7FPbHHcywRHtKQsk1J6n2HE4mGUvgL3+fZtos48nExDQwSUbZHDHo3tuKfxHaoREE5FgqX/kK44HLhjulJmSSC4prkfbLwkllF9lEnttTYlG2XiCPNGJd6RmY1skMMdL2Xt8cQnE3KiprJPGqwMxHTJVZlk7jYEOdyJ/bkffezWNViWCpiR5qsuNRaqIHpYsZPZHSwLPm4pUhBA81JrCz1o/QqLxcr9UjhGcqlkDUFyiqBs2L79pourz/SekQC884xTAzuj3ILGWhy1+GcW48ul5BKoF14QVYa2eQNppCVQjqgzccvIjCeFre2WkzAVHEU9unfl7eBaTgm7szdIhPsEOfz3DLqqlKlSpUq/cH/L5idbSWuYgMAAAAASUVORK5CYII=\n", "text/latex": [ "$\\displaystyle e^{- \\frac{a x^{2}}{2}}$" ], "text/plain": [ " 2 \n", " -a⋅x \n", " ──────\n", " 2 \n", "ℯ " ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA0AAAASCAYAAACAa1QyAAAABHNCSVQICAgIfAhkiAAAAHZJREFUKJFjYKACCGFgYJjMwMBwmIGB4RMDA8N/BgaGJYQ0XYAq/MzAwHCdWE2ODAwMqgwMDIwMDAwOuDSxoPH3EzKVgYGBgYkYRaOaBlwTeuQGQDEDAwODBJS2ZGBgWABlv2FgYChBN6SBAZJ0cOEH5LiMzgAA6XoX52TB9a4AAAAASUVORK5CYII=\n", "text/latex": [ "$\\displaystyle 1$" ], "text/plain": [ "1" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "psi = (norm * f).subs(a,3)\n", "psi_star = conjugate(psi)\n", "prob = integrate (psi*psi_star, (x,-oo, oo))\n", "prob" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Suppose we want the probability for $0 \\le x \\le 1$?" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle 0.492847060782285$" ], "text/plain": [ "0.492847060782285" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# N gives numeric (floating point) result\n", "N(integrate(psi*psi_star, (x, 0, 1)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Plot the wavefunction and probability amplitude\n", "\n", "Sympy takes a different approach to plotting than matplotlib/pyplot. The sympy plotting functions generally produce figures that look more like those from \"math books\". For example, axis origin is a the center of a figure rather than the lower left corner. Sympy also assumes a plot range of -1 < x < 1 unless told otherwise. \n", "\n", "Use sympy to plot $\\psi$ and $\\psi^* \\psi$, the normalized wavefunctions." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# subs = substitute values for variables\n", "# Use a dictionary or list for multiple substitutions\n", "\n", "psi = psi.subs( {a:3, N0:norm} )\n", "psi_star = psi_star.subs( [(a,3), (N0,norm)] )" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIQAAAAdCAYAAABrLcQsAAAABHNCSVQICAgIfAhkiAAABdxJREFUaIHt2X+MXFUVwPFPd2kpUAQqpZSIFfkRMEAJP0KUttkUUys/YwUJAhKBYJSQCAUDIrAmyNY0DSBY5VdLpfyw2ABqqFFoQCiYYKRFI1ECASppKaBSpGItrH+cO+7b13kzb2Znt0OZb/Ky8869796z9517zrnn0aFDhw5l6cLT+FlB+87ob/H1QWBvPIo/YzVmb1VtRpALcK9igzgFnxs5ddqGSZiSfu+BNdhx66kzMuyBRzBDsUHchDEjplH78iw+vrWVGA66Mr/n4Uq8X9C3O12bhlupFnOBeIEb0vUUjh/CeEditPASWW7Dden35SL0bsDr+AUObnCeeuF7WKgYxHQRz5+s0fczddrblb/hMhwhXuYKPIBDmxjro/gJzjU4/+nCCXgw3fdggVizGdiMhzG+gbm+jhea0LElXIZX8RLW4R3cnuvTJxZkW+Dv+Frm/lT8B5MzshvwPCak++3xW5xVZbxP401sVzDfOLyHE0vqVyZ8z0o6/9IwJ/k9BUrcUvKfaWe6cboIe4dk5KPwe9ya7i/Ba9g3034PegvGnSs8RxGTxGIfU1LPxcK79Cg2iLvxjZLjDYlqSuyPOTWe+b6w6DX4t9iBz+Bq7eFVDsG/hOv+B46r0mcm/iu85QYRXipMFbnVqsyVNajn1D6K/lSsR3eNPhOFF1mBO5KsR3WD+Ej6PxoJQS1lDg6o0b4Jv8NCsVtuFAlRvwhFe7dQl1713V5P7pkx2E+85D68oXqS96QwmlkN6HOA2AQ7FbTPw9o0fy3OF7pfrn74Pg/LGtCx5dxcp31sgfx74p9c0EJddseBda56NYKHxakgywyx+O/j8Ab0uVTE8WrMF6HnUyXGWS4MNetFelT3EI/jpPIqNkcXrsHnc/LxuLbJMacIg/hNib5fNLAom0RC92213WyzrMCSzP0U/BNnixPI8gbGekLs2Dw/UN4YdhEJ4qKcvMeWBvFJrBdH32ocr3wCeVgtpWaJPGBhTn6miKHN8J008fwafbpFwtYvjOBHuB5/SbLFTc5dYS6m4RMi7vcJL1Ax/MnCRV+R7g9N7dNKjD1B5B0Tc/IFIg+ZgT0z17iCcb4s/tfsKWQnkYzm6RUnoCKmpvn78afUv3Ldm+SP4yqD61BVOUxYX7bjD8s8mLgkTXxdmrRf1P4n1HjmptSvz+Bj22isTG1ldlkRd+BlsQPXi3BRKb+PFwlhPiQuFTu/HueoXpsp2pG9BePcJ5LesSInuUeEr7ty/UbhRfVD2hfSfNfk5N9K8nPrPD+Ilwx4hNHC9ZVlncELsNyWuyfL0WI3PlDQXkm0vtqADiPJg2KRh8JYvC2MgvAkR4qaxzsGe5XpYtfX47ti3U7JySse4oiiB6sVUn6Ok8UO6cFjJRSosGf6O1Gco+eK49YJ+EOV/hcKq9+o+u6pnARGNaDDSLJS7OahMFO89PvT/bp0LRFha7aBGsfZyoXQSm6wOic/XJyiyhjV/zkWf02/5ymOe2WYLFx1kQLrlUt+PjsEHdqdRWKNdsnJd8W7+HW630HUHvYqMebLwutkN9I44Y3/2KiC26WJD9Ka4+Iz4qXunpOPTfJGPNC2Rrc4VRWdapaJYtVeOAO/KjHmbmJdV+bk05L8zloPV0sWN+Mh8eWzYWuqQsWi38vJK9abN5QPE9NFJff+gvYl4h2djq8YerggqqwN8yVhTR8r0fdAA7lDli4Dham8tVZYndqLyr5TDU8dol24UWyUosR7jPgM8KLw2juUGPMisabn5+S3JvnMZhTdWflP3d8UZ/FHxAewPlHLeCEpsFbxsbHy/aBSvJovjqxL0/OvNKP8B4g14nheix+L9clXVotYnPofnZMvS/KLlNvoW7BbyX4Hi1rFKhEPN+Mt8S2jV/0PMEeJatw6YRxviFB1s0hwt1WOEi/o4jr9pqZ+00uOu0p4nXz5/jSxthtFvahDm3GteNH71Ok3Spz22vXo3aFFPKfJBK9Dhw4dOnTo0KHd+B+cwJmJej00XAAAAABJRU5ErkJggg==\n", "text/latex": [ "$\\displaystyle \\frac{\\sqrt[4]{3} e^{- \\frac{3 x^{2}}{2}}}{\\sqrt[4]{\\pi}}$" ], "text/plain": [ " 2 \n", " -3⋅x \n", " ──────\n", "4 ___ 2 \n", "╲╱ 3 ⋅ℯ \n", "─────────────\n", " 4 ___ \n", " ╲╱ π " ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "psi" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "p1 = plot(psi, (x, -3, 3), show=False)\n", "p1[0].label='$\\psi(x)$'\n", "p1.xlabel=''\n", "p1.ylabel=''\n", "p1.legend=True\n", "\n", "p2 = plot(psi**2, (x,-3,3), line_color='r', show=False)\n", "p2[0].label='$\\psi^2(x)$'\n", "\n", "p1.extend(p2)\n", "p1.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The probability amplitude, $\\psi^2$ has a narrower shape. Is $\\psi$ normlized?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Calculating probability of finding a particle in a specified region\n", "Calculate the probability of finding a particle described by the function in a\n", "specified region that can be easily changed. We'll start with x1 = 0 and x2 = 0.5." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle 0.389664319040077$" ], "text/plain": [ "0.389664319040077" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x1, x2 = 0, 0.5\n", "\n", "integrate(psi*psi_star,(x, x1, x2)).evalf()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This process might be repeated frequently. If so, it's probably worth defining in the form of a python function." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# default limits of infinity are provided, but can be overridden\n", "def prob_func(f, x_lower=-oo, x_upper=oo):\n", " 'integrate the normalized wavefunction f(x) from x_l to x_u'\n", " \n", " fstar = conjugate(f)\n", " prob = integrate(fstar * f, (x, x_lower, x_upper))\n", " return prob" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Print the probability over 10 intervals within the box." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Probability over intervals\n", "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\n", "0\n", "0.0967520297463300\n", "0.187896942616797\n", "0.268783636774762\n", "0.336406561104847\n", "0.389664319040077\n", "0.429177654852432\n", "0.456794633513150\n", "0.474978239375647\n", "0.486256831944245\n", "0.492847060782285\n" ] } ], "source": [ "psi = psi.subs({a:1, N0:norm})\n", "lengths = [l/10 for l in range(0, 11)]\n", "print(\"Probability over intervals\")\n", "print(lengths)\n", "for l in lengths:\n", " print(prob_func(psi, 0, l).evalf())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Calculate average values\n", "The expectation value $\\langle a \\rangle$ for an observable or property is calculated by finding the operator that describes that observable, finding a normalized wavefunction that describes the system under consideration, and using the integral definition for expectation value:\n", "\n", "$$ \\langle a \\rangle = \\int \\psi^*(x)\\, \\hat{A}\\, \\psi(x)\\ dx $$ " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The position operator is $\\hat{x} = x$; just multiplication by $x$. In our example, the range for $x$ is $-\\infty$ to $\\infty$, so the average (or *expectation*) value might be predictable looking at the symmetry of the probability plot. " ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAABHNCSVQICAgIfAhkiAAAAM5JREFUOI3N0rEyQ0EUxvEfJcMVWhoZ8Qpq75PnoDJ0Kl5BK0U67yAUiUYmpZGYoRDNuePOkXszYxS+5ps95/x3Z3c//lC7uMIz3jHCOVpNUBsTzHGDU/RjfY+dOvA2hrqpfhb1y0XQfjSHWE29DUwxw7o0cBzew2cCX3GHNRxl8DD8oeYaj+GdDBbhLzVgWd/K4DKthM8zWO5YWKzN6lwVHIR3asCD8B9v0Lb8O97Ed2T9KgDlqdXInfiO3EBD5GAP1xjjA0+4wHYT9I/1BRgnMa7SDNsAAAAAAElFTkSuQmCC\n", "text/latex": [ "$\\displaystyle 0$" ], "text/plain": [ "0" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x_avg = integrate(psi_star * x * psi, (x, -oo, oo))\n", "x_avg" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Calculate an uncertainty (standard deviation and variance) in the expectation value for position\n", "Variance in a quantity can be calculated simply as the expectation value for the quantity squared (position squared in this case, $\\langle x^2\\rangle$) minus the (expectation value for the quantity)-squared ($\\langle x \\rangle^2$ in this case.)\n", "\n", "$$\\sigma^2 = \\int \\psi^*\\, x^2\\, \\psi\\; dx - \\left ( \\int \\psi^*\\, x\\, \\psi \\;dx \\right )^2 $$" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "sigma_squared = integrate(psi_star * x**2 * psi, (x,-oo,oo)) - (integrate(psi_star*x*psi, (x,-oo,oo)))**2" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle 0.408248290463863$" ], "text/plain": [ "0.408248290463863" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sqrt(sigma_squared).evalf()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Is a wavefunction an eigenfunction of an operator?\n", "Eigenfunctions of an operator have the property\n", "\n", "$$ \\hat{A}f = a f$$\n", "\n", "where $a$ is the eigenvalue.\n", "\n", "See if the function $\\psi(x)=\\exp(-a_0 x^2/2)$ is an eigenfunction of the kinetic energy operator $$\\hat{T} = \\frac{\\hbar^2}{2m} \\frac{d^2 \\psi(x)}{dx^2} $$" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# this could be done as an expression, but seems a natural for python function\n", "def T_hat(f):\n", " \"Apply the kinetic energy operator T on function f(x)\"\n", " hbar, m = symbols('hbar m')\n", " return hbar**2 /(2*m) * diff(f, x, 2)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "psi = N0 * exp(-a*x**2/2)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle \\frac{N_{0} a \\hbar^{2} \\left(a x^{2} - 1\\right) e^{- \\frac{a x^{2}}{2}}}{2 m}$" ], "text/plain": [ " 2 \n", " -a⋅x \n", " ──────\n", " 2 ⎛ 2 ⎞ 2 \n", "N₀⋅a⋅h̅ ⋅⎝a⋅x - 1⎠⋅ℯ \n", "───────────────────────────\n", " 2⋅m " ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T_hat(psi)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`T_hat()` returned the result of operating on $\\psi$. If $\\psi$ is an eigenfunction, we should be able to factor this result into $a\\psi$ where $a$ is the eigenvalue. Another approach would be to divide both sides by the function and see if the result is a constant.\n", "$$\\frac{\\hat{A}f}{f} = a$$" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle \\frac{a \\hbar^{2} \\left(a x^{2} - 1\\right)}{2 m}$" ], "text/plain": [ " 2 ⎛ 2 ⎞\n", "a⋅h̅ ⋅⎝a⋅x - 1⎠\n", "────────────────\n", " 2⋅m " ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T_hat(psi)/psi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Because this result contains $x^2$, it is not a constant. Therefore, $\\psi$ is not an eigenfunction of the kinetic energy operator $\\hat{T}$. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "How about $\\cos(x)$?" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$\\displaystyle - \\frac{\\hbar^{2} \\cos{\\left(x \\right)}}{2 m}$" ], "text/plain": [ " 2 \n", "-h̅ ⋅cos(x) \n", "────────────\n", " 2⋅m " ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T_hat(cos(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So, $\\cos(x)$ is indeed an eigenfunction of $\\hat{T}$ and the eigenvalue is $-\\hbar^2/2m$. However, $\\cos(x)$ is not a valid wavefunction for the particle-in-a-box model. Why not?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Is a function orthogonal to another function?\n", "\n", "The functions\n", " \n", "$$\\phi_n(\\theta) = e^{in\\theta} $$\n", "\n", "where $n$ is an integer and $0 \\le \\theta \\le 2\\pi$ are orthogonal if \n", "\n", "$$\\int_0^{2\\pi} \\phi_n^*(\\theta) \\phi_m^*(\\theta)\\; d\\theta = 0 $$\n", "for $m\\ne n$." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "var('theta n', real=True)\n", "def phi(n): \n", " return exp(I*n*theta)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAABHNCSVQICAgIfAhkiAAAAM5JREFUOI3N0rEyQ0EUxvEfJcMVWhoZ8Qpq75PnoDJ0Kl5BK0U67yAUiUYmpZGYoRDNuePOkXszYxS+5ps95/x3Z3c//lC7uMIz3jHCOVpNUBsTzHGDU/RjfY+dOvA2hrqpfhb1y0XQfjSHWE29DUwxw7o0cBzew2cCX3GHNRxl8DD8oeYaj+GdDBbhLzVgWd/K4DKthM8zWO5YWKzN6lwVHIR3asCD8B9v0Lb8O97Ed2T9KgDlqdXInfiO3EBD5GAP1xjjA0+4wHYT9I/1BRgnMa7SDNsAAAAAAElFTkSuQmCC\n", "text/latex": [ "$\\displaystyle 0$" ], "text/plain": [ "0" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integrate(conjugate(phi(1)) * phi(0), (theta, 0, 2*pi))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\phi_1$ and $\\phi_2$ are orgthogonal." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Your Turn\n", "Are the $\\phi_n(\\theta)$ wavefunctions normlized? If not, how could you normalize them? Try it." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Python interlude: range() and loops\n", "Using loops can make quick work of iterating over many combinations. (NB: This is a silly example, as it only shows a pattern for a few specific cases; orthogonality is not proven in general)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "m, n, integral\n", " --------------------\n", "(0, 0, 2⋅π)\n", "(1, 0, 0)\n", "(2, 0, 0)\n", "(3, 0, 0)\n", "(0, 1, 0)\n", "(1, 1, 2⋅π)\n", "(2, 1, 0)\n", "(3, 1, 0)\n", "(0, 2, 0)\n", "(1, 2, 0)\n", "(2, 2, 2⋅π)\n", "(3, 2, 0)\n", "(0, 3, 0)\n", "(1, 3, 0)\n", "(2, 3, 0)\n", "(3, 3, 2⋅π)\n" ] } ], "source": [ "print(\"m, n, integral\\n\", 20*\"-\")\n", "for n in range(0,4):\n", " for m in range(0,4):\n", " result = integrate(conjugate(phi(m)) * phi(n), (theta, 0, 2*pi))\n", " pprint((m, n, result))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Finis" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.3" } }, "nbformat": 4, "nbformat_minor": 4 }