Lecture-5-Sympy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sympy - Symbolic algebra in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/\n",
    "\n",
    "The latest version of this [IPython notebook](http://ipython.org/notebook.html) lecture is available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "\n",
    "The other notebooks in this lecture series are indexed at [http://jrjohansson.github.com](http://jrjohansson.github.com)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.kernel.zmq.pylab.backend_inline].\n",
      "For more information, type 'help(pylab)'.\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two notable Computer Algebra Systems (CAS) for Python:\n",
    "\n",
    "* [SymPy](http://sympy.org/en/index.html) - A python module that can be used in any Python program, or in an IPython session, that provides powerful CAS features. \n",
    "* [Sage](http://www.sagemath.org/) - Sage is a full-featured and very powerful CAS enviroment that aims to provide an open source system that competes with Mathematica and Maple. Sage is not a regular Python module, but rather a CAS environment that uses Python as its programming language.\n",
    "\n",
    "Sage is in some aspects more powerful than SymPy, but both offer very comprehensive CAS functionality. The advantage of SymPy is that it is a regular Python module and integrates well with the IPython notebook. \n",
    "\n",
    "In this lecture we will therefore look at how to use SymPy with IPython notebooks. If you are interested in an open source CAS environment I also recommend to read more about Sage.\n",
    "\n",
    "To get started using SymPy in a Python program or notebook, import the module `sympy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sympy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get nice-looking $\\LaTeX$ formatted output run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "init_printing()\n",
    "\n",
    "# or with older versions of sympy/ipython, load the IPython extension\n",
    "#%load_ext sympy.interactive.ipythonprinting\n",
    "# or\n",
    "#%load_ext sympyprinting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Symbolic variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In SymPy we need to create symbols for the variables we want to work with. We can create a new symbol using the `Symbol` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = Symbol('x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + \\pi\\right)^{2}$$"
      ],
      "text/plain": [
       "       2\n",
       "(x + π) "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pi + x)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# alternative way of defining symbols\n",
    "a, b, c = symbols(\"a, b, c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.symbol.Symbol"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add assumptions to symbols when we create them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = Symbol('x', real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$False$$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.is_imaginary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = Symbol('x', positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$True$$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x > 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The imaginary unit is denoted `I` in Sympy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1 + i$$"
      ],
      "text/plain": [
       "1 + ⅈ"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1*I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$-1$$"
      ],
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(i x + 1\\right)^{2}$$"
      ],
      "text/plain": [
       "         2\n",
       "(ⅈ⋅x + 1) "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x * I + 1)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rational numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three different numerical types in SymPy: `Real`, `Rational`, `Integer`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "r1 = Rational(4,5)\n",
    "r2 = Rational(5,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{4}{5}$$"
      ],
      "text/plain": [
       "4/5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{41}{20}$$"
      ],
      "text/plain": [
       "41\n",
       "──\n",
       "20"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r1+r2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{16}{25}$$"
      ],
      "text/plain": [
       "16\n",
       "──\n",
       "25"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r1/r2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy uses a library for artitrary precision as numerical backend, and has predefined SymPy expressions for a number of mathematical constants, such as: `pi`, `e`, `oo` for infinity.\n",
    "\n",
    "To evaluate an expression numerically we can use the `evalf` function (or `N`). It takes an argument `n` which specifies the number of significant digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$3.1415926535897932384626433832795028841971693993751$$"
      ],
      "text/plain": [
       "3.1415926535897932384626433832795028841971693993751"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi.evalf(n=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = (x + pi)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + 3.1416\\right)^{2}$$"
      ],
      "text/plain": [
       "            2\n",
       "(x + 3.1416) "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(y, 5) # same as evalf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we numerically evaluate algebraic expressions we often want to substitute a symbol with a numerical value. In SymPy we do that using the `subs` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(1.5 + \\pi\\right)^{2}$$"
      ],
      "text/plain": [
       "         2\n",
       "(1.5 + π) "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.subs(x, 1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$21.5443823618587$$"
      ],
      "text/plain": [
       "21.5443823618587"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(y.subs(x, 1.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `subs` function can of course also be used to substitute Symbols and expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(a + 2 \\pi\\right)^{2}$$"
      ],
      "text/plain": [
       "         2\n",
       "(a + 2⋅π) "
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.subs(x, a+pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also combine numerical evolution of expressions with NumPy arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x_vec = numpy.arange(0, 10, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": [
       "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
       "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3X9YVGXex/H3mJRtVprmoKAPrUg4iqkllRs1ptBqaWYu\n",
       "K7YrC1o9a7b92rLaH2G7CWa7qfVYa6XZjxWtLTHXyEyHNDU027SwIIMEFDYl3EUTVM7zx12kpeQM\n",
       "A2dm+Lyua64LjzPnfJtr/ezN99znvh2WZVmIiEhIaWN3ASIi4n8KdxGREKRwFxEJQQp3EZEQpHAX\n",
       "EQlBCncRkRDUaLinp6fjdDqJi4trOJafn098fDwDBgxg0KBBbNq0qeHvMjMz6dWrF7GxsaxcubL5\n",
       "qhYRkUY5GpvnvnbtWtq3b8+ECRPYtm0bAG63m/vuu4+rrrqK119/nYcffpg1a9ZQUFDA+PHj2bRp\n",
       "E+Xl5QwbNozCwkLatNEvByIiLa3R5E1ISKBjx47HHOvatSv79u0DoLq6moiICABycnJISUkhLCyM\n",
       "qKgooqOjyc/Pb6ayRUSkMW29/UBWVhaXXXYZv/3tb6mvr2fDhg0A7Nq1i0suuaThfZGRkZSXl/uv\n",
       "UhEROWle90wmTpzInDlz2LlzJ48++ijp6eknfK/D4WhScSIi4huvR+75+fmsWrUKgLFjxzJp0iQA\n",
       "IiIiKC0tbXhfWVlZQ8vmaNHR0ezYscPXekVEWqWePXvy6aefnvT7vR65R0dHk5eXB8Dq1auJiYkB\n",
       "YNSoUWRnZ1NXV0dxcTFFRUXEx8d/7/M7duzAsiy9LIsHHnjA9hoC5aXvQt+FvovGX94Oihsduaek\n",
       "pJCXl8eePXvo3r07Dz74IPPmzeOWW26htraW008/nXnz5gHgcrlITk7G5XLRtm1b5s6dq7aMiIhN\n",
       "Gg33RYsWHff4u+++e9zj999/P/fff3/TqxIRkSbRJHQbud1uu0sIGPouvqXv4lv6LnzX6ENMzXJB\n",
       "h4MWvqSISNDzNjs1chcRCUEKdxGREKRwFxEJQQp3EZEQpHAXEQlBCncRkQD0xBPw9WIAPlG4i4gE\n",
       "mEcegZkzoUcP38/h9cJhIiLSPCwL/vQnePFFePttiIz0/VwKdxGRAGBZcP/9sHy5CXans2nnU7iL\n",
       "iNisvh7uuAPWrYM1a6Bz56afU+EuImKjI0fg5pth+3ZYvRrOPts/51W4i4jY5NAhSE2Fykp44w1o\n",
       "395/51a4i4jY4OBBGDfOBPzy5XD66f49v6ZCioi0sP37YeRIOPVUePVV/wc7/EC4p6en43Q6iYuL\n",
       "O+b4Y489Ru/evenbty9Tp05tOJ6ZmUmvXr2IjY1l5cqV/q9WRCTIVVdDUhJ07w6LFpmAbw6NtmXS\n",
       "0tK49dZbmTBhQsOxNWvWsGzZMrZu3UpYWBhffPEFAAUFBSxevJiCggLKy8sZNmwYhYWFtGmjXw5E\n",
       "RAD+/W/46U/hsstg1ixoznhs9NQJCQl07NjxmGNPPPEE9913H2FhYQCce+65AOTk5JCSkkJYWBhR\n",
       "UVFER0eTn5/fTGWLiASX0lK4/HK4+mqYPbt5gx186LkXFRXx9ttvc8kll+B2u9m8eTMAu3btIvKo\n",
       "x6kiIyMpLy/3X6UiIkGqqAgSEmDSJPMEqsPR/Nf0erbM4cOH+fLLL9m4cSObNm0iOTmZzz777Ljv\n",
       "dZzgvyAjI6PhZ7fbrX0SRSRkbd0Kw4dDRgbceOPJf87j8eDxeHy+rtfhHhkZyZgxYwAYNGgQbdq0\n",
       "Yc+ePURERFBaWtrwvrKyMiIiIo57jqPDXUQkVK1fD9ddB3PmwM9/7t1nvzvwnTZtmlef97otM3r0\n",
       "aFavXg1AYWEhdXV1dO7cmVGjRpGdnU1dXR3FxcUUFRURHx/v7elFRELCypVw7bWwcKH3we4PjY7c\n",
       "U1JSyMvLY+/evXTv3p0HH3yQ9PR00tPTiYuL49RTT+W5554DwOVykZycjMvlom3btsydO/eEbRkR\n",
       "kVD28sswebKZw37ZZfbU4LAsy2rRCzoctPAlRURazFNPwQMPwIoV0L+//87rbXZq+QERET+ZMQOe\n",
       "fNLsoNSrl721KNxFRJrIsmDqVDNaX7cOTjCXpEUp3EVEmuDwYbjpJrNkb14edOpkd0WGwl1ExEdf\n",
       "fWVWdqythVWr4Iwz7K7oW1r4RUTEB/v2mXVizjgDli0LrGAHhbuIiNd274YrroB+/eCFF5pvZcem\n",
       "ULiLiHjh00/N3PWxY82Tp4G68K167iIiJ2nLFrjmGpg2zbt1YuygcBcROQmrVsH48fC3v5n1YgJd\n",
       "gP5CISISOLKzTbC//HJwBDto5C4i0qjZs2HmTHjrLfjOjqMBTeEuInIc9fVw771mmuO6dRAVZXdF\n",
       "3lG4i4h8R10dpKfDjh3wzjuB89SpNxTuIiJH+e9/4frroV0704r50Y/srsg3uqEqIvK1bx5OioqC\n",
       "V14J3mAHhbuICAAffwyDB8OYMWa6Y9sg72s0Gu7p6ek4nU7ijnOL+C9/+Qtt2rShqqqq4VhmZia9\n",
       "evUiNjaWlStX+r9aEZFmsH49uN3wxz/C738PobCJXKPhnpaWRm5u7veOl5aW8uabb/I///M/DccK\n",
       "CgpYvHgxBQUF5ObmMnnyZOrr6/1fsYiIH73yitnrdMECSEuzuxr/aTTcExIS6Nix4/eO33nnnTz8\n",
       "8MPHHMvJySElJYWwsDCioqKIjo4mPz/fv9WKiPjR7Nlw663wxhswfLjd1fiX112lnJwcIiMj6dev\n",
       "3zHHd+3axSWXXNLw58jISMrLy5teoYiIn9XXw913m52T3nkn+Oawnwyvwv3AgQNMnz6dN998s+FY\n",
       "Yxu2Ok7QuMrIyGj42e1243a7vSlDRMRnX30FEyZAZaUJ9nPOsbui4/N4PHg8Hp8/71W479ixg5KS\n",
       "Ei644AIAysrKuPDCC3n33XeJiIigtLS04b1lZWVEnGAjwaPDXUSkpezZY/rrPXrAypVmLnug+u7A\n",
       "d9q0aV593qupkHFxcVRWVlJcXExxcTGRkZFs2bIFp9PJqFGjyM7Opq6ujuLiYoqKioiPj/eqGBGR\n",
       "5vLpp2aqY0ICvPhiYAe7PzQa7ikpKQwePJjCwkK6d+/OggULjvn7o9suLpeL5ORkXC4Xw4cPZ+7c\n",
       "uSdsy4iItKT1680GG3feCVlZgbvBhj85rMaa5s1xQYej0T69iIg/vfQSTJ4Mzz0X3DNivM3OIH8G\n",
       "S0Tk+CzLLNX72GPw5pvQv7/dFbUshbuIhJxDh+CWWyA/HzZsgMhIuytqeQp3EQkp+/bBz34GYWGw\n",
       "di2ceabdFdmjFdxWEJHWoqQEfvITiImBnJzWG+ygcBeRELFxo5nqeNNNps8e7Ks6NlUr/88XkVCw\n",
       "ZInpsS9YANdcY3c1gUHhLiJBy7LgoYdg3jxYtQq+fnheULiLSJCqrYVJk+CTT+Ddd6FrV7srCizq\n",
       "uYtI0PniCxg6FA4eBI9HwX48CncRCSoffgjx8WbnpMWLg3uf0+aktoyIBI1//tPslvToo3DDDXZX\n",
       "E9gU7iIS8CzLBPojj5j565deandFgU/hLiIBrbYWfv1reO89s5TAUVs3SyMU7iISsL74AsaMgc6d\n",
       "za5J7dvbXVHw0A1VEQlI27aZG6dXXAH/+IeC3VsauYtIwFm61CwjMGsWjB9vdzXBqdGRe3p6Ok6n\n",
       "k7i4uIZjd999N7179+aCCy5gzJgx7Nu3r+HvMjMz6dWrF7GxsaxcubL5qhaRkGRZ8Oc/w623mpkx\n",
       "CnbfNRruaWlp5ObmHnMsKSmJjz76iA8++ICYmBgyMzMBKCgoYPHixRQUFJCbm8vkyZOpr69vvspF\n",
       "JKTs3w8//zksX27WYR80yO6Kgluj4Z6QkEDHjh2POZaYmEibrzcgvPjiiykrKwMgJyeHlJQUwsLC\n",
       "iIqKIjo6mvz8/GYqW0RCyeefm6V6Tz9dT5z6S5NuqM6fP58RI0YAsGvXLiKP2u4kMjKS8vLyplUn\n",
       "IiEvLw8uuQRSU+HZZ6FdO7srCg0+31B96KGHOPXUUxnfSFPM4XAc93hGRkbDz263G7fb7WsZIhKk\n",
       "LAvmzoUHH4Tnn4ekJLsrCiwejwePx+Pz530K92effZYVK1bw1ltvNRyLiIigtLS04c9lZWVEREQc\n",
       "9/NHh7uItD61tWb99Y0bYf166NnT7ooCz3cHvtOmTfPq8163ZXJzc5k5cyY5OTm0O+r3p1GjRpGd\n",
       "nU1dXR3FxcUUFRURHx/v7elFJMTt3g1DhkBVlXniVMHePBoN95SUFAYPHswnn3xC9+7dmT9/Prfe\n",
       "eis1NTUkJiYyYMAAJk+eDIDL5SI5ORmXy8Xw4cOZO3fuCdsyItI6rV9vZsEMHw4vv9y69zhtbg7L\n",
       "sqwWvaDDQQtfUkQCwLx58Pvfw/z52grPF95mp55QFZFmVVtrHkpat868YmLsrqh10NoyItJsysrM\n",
       "2jB795qt8BTsLUfhLiLN4u23zcJfo0erv24HtWVExK8sC2bPhsxMzV+3k8JdRPympgZuvBE++cS0\n",
       "YaKi7K6o9VJbRkT8oqjILCPQrp3ZWEPBbi+Fu4g02auvmoW/pkwxUx1PP93uikRtGRHx2eHD8Lvf\n",
       "QXa2WapXD6UHDoW7iPikshJSUuCUU8zm1Z07212RHE1tGRHx2rp1cOGFphWTm6tgD0QauYvISbMs\n",
       "ePRRmDHDrL0+fLjdFcmJKNxF5KRUV0N6OpSWappjMFBbRkR+0Pvvw0UXQbdupiWjYA98CncROSHL\n",
       "Mqs5JiXBQw/B44/DaafZXZWcDLVlROS4amrg5pth61ZYuxZiY+2uSLzR6Mg9PT0dp9NJXFxcw7Gq\n",
       "qioSExOJiYkhKSmJ6urqhr/LzMykV69exMbGsnLlyuarWkSa1bZtpg3Trp3pryvYg0+j4Z6WlkZu\n",
       "bu4xx7KyskhMTKSwsJChQ4eSlZUFQEFBAYsXL6agoIDc3FwmT55MfX1981UuIn5nWfDMM3DllXDf\n",
       "febnH/3I7qrEF42Ge0JCAh07djzm2LJly0hNTQUgNTWVpUuXApCTk0NKSgphYWFERUURHR1Nfn5+\n",
       "M5UtIv5WUwO//KWZ6piXB1//M5cg5fUN1crKSpxOJwBOp5PKykoAdu3aRWRkZMP7IiMjKS8v91OZ\n",
       "ItKcPvjAtGFOOw3y88HlsrsiaaomzZZxOByNboKtDbJFAptlwRNPwNChZo0YtWFCh9ezZZxOJxUV\n",
       "FYSHh7N79266dOkCQEREBKWlpQ3vKysrIyIi4rjnyMjIaPjZ7Xbjdru9LUNEmqi62qy9XlRklug9\n",
       "/3y7K5KjeTwePB6Pz593WD+wnXZJSQkjR45k27ZtANxzzz106tSJqVOnkpWVRXV1NVlZWRQUFDB+\n",
       "/Hjy8/MpLy9n2LBhfPrpp98bvXu7g7eI+N/GjWbRrxEj4C9/MbNiJLB5m52NjtxTUlLIy8tjz549\n",
       "dO/enQcffJB7772X5ORknnnmGaKioliyZAkALpeL5ORkXC4Xbdu2Ze7cuWrLiASY+nqYORP++ld4\n",
       "8km47jq7K5Lm8oMjd79fUCN3EVtUVMCECXDgAPz979Cjh90ViTe8zU4tPyDSCqxYAQMGwKWXgsej\n",
       "YG8NtPyASAirrTUPI738stkt6Yor7K5IWorCXSREbd9ubpqed55Z1bFTJ7srkpaktoxIiPlmJceE\n",
       "BJg8GV55RcHeGmnkLhJC9uwxc9eLi81Kjr17212R2EUjd5EQ8eab0L8/9OxpVnJUsLduGrmLBLmD\n",
       "B83SAYsXm31Nhw2zuyIJBAp3kSC2bRvccAP06mUW/1JvXb6htoxIEKqvN0vzXnkl3HmnmeqoYJej\n",
       "aeQuEmRKS+FXv4KvvjK99R//2O6KJBBp5C4SRP7+d7jwQrNE79tvK9jlxDRyFwkCe/fCLbeYzapz\n",
       "c2HgQLsrkkCnkbtIgHv9dbjgAujaFd57T8EuJ0cjd5EAVVMDd99twv3552HIELsrkmCikbtIAFq7\n",
       "1ozWDx40UxwV7OItjdxFAshXX8Ef/mBunD75JIwaZXdFEqx8HrlnZmbSp08f4uLiGD9+PLW1tVRV\n",
       "VZGYmEhMTAxJSUlUV1f7s1aRkPbuu6afvnOnuXGqYJem8CncS0pKeOqpp9iyZQvbtm3jyJEjZGdn\n",
       "k5WVRWJiIoWFhQwdOpSsrCx/1ysScmpr4f774dprYdo0WLIEOne2uyoJdj6F+1lnnUVYWBgHDhzg\n",
       "8OHDHDhwgG7durFs2TJSU1MBSE1NZenSpX4tViTUbN5s5q1v325668nJdlckocKncD/nnHO46667\n",
       "6NGjB926daNDhw4kJiZSWVmJ0+kEwOl0UllZ6ddiRUJFba1Z7Ovqq82o/ZVX4Ot/OiJ+4VO479ix\n",
       "g1mzZlFSUsKuXbuoqanhhRdeOOY9DocDh8PhlyJFQkl+vhmtf/SRGa2PHw/6pyL+5tNsmc2bNzN4\n",
       "8GA6fb1S0ZgxY9iwYQPh4eFUVFQQHh7O7t276dKly3E/n5GR0fCz2+3G7Xb7UoZIUPnqK3jgAXju\n",
       "ObPo17hxCnU5MY/Hg8fj8fnzDsuyLG8/9MEHH3DDDTewadMm2rVrx69+9Svi4+P5/PPP6dSpE1On\n",
       "TiUrK4vq6urv3VR1OBz4cEmRoLZuHUycaDbTeOwxOMG4R+SEvM1On8Id4OGHH2bhwoW0adOGgQMH\n",
       "8vTTT/Pf//6X5ORkdu7cSVRUFEuWLKFDhw5NKlAkmNXUwH33mZ76Y4/BmDF2VyTBqsXC3VcKd2kt\n",
       "Vq6Em28Gtxv++lfo2NHuiiSYeZudekJVxM/27jUbaOTlwd/+BlddZXdF0hppbRkRP7EsyM6Gvn2h\n",
       "Qwf48EMFu9hHI3cRP9i5EyZPhpISePVVuOQSuyuS1k4jd5EmOHLE3CgdONAE+pYtCnYJDBq5i/jo\n",
       "gw/gppugXTt45x04/3y7KxL5lkbuIl7avx/uuQcSE024r1mjYJfAo3AX8cKKFeaGaXm5uWE6cSK0\n",
       "0b8iCUBqy4ichF274Lbb4P33zfTGpCS7KxJpnMYcIo04fBjmzIF+/SA2FrZtU7BLcNDIXeQE8vPh\n",
       "f/8Xzj7b7Gnau7fdFYmcPI3cRb6jqgp+/WuzM9Kdd8Lq1Qp2CT4Kd5Gv1dfDggXgcsEpp5jdkX7x\n",
       "Cy3LK8FJbRkRzJz1W26Bujr45z/NZhoiwUwjd2nVqqvhN78xN0knTIANGxTsEhoU7tIqfdOC6d3b\n",
       "7GdaUGAeSDrlFLsrE/EPtWWk1dm8GaZMMT+/9hpcdJG99Yg0B59H7tXV1YwdO5bevXvjcrl49913\n",
       "qaqqIjExkZiYGJKSkqiurvZnrSJN8u9/w403wsiRZhON9esV7BK6fA732267jREjRrB9+3a2bt1K\n",
       "bGwsWVlZJCYmUlhYyNChQ7+3f6qIHQ4dgtmzoU8fOPNMMwsmLU3LBkho82mbvX379jFgwAA+++yz\n",
       "Y47HxsaSl5eH0+mkoqICt9vNxx9/fOwFtc2etKCVK+H22yEyEmbNMtMcRYKRt9np09iluLiYc889\n",
       "l7S0NAYOHMiNN97I/v37qaysxOl0AuB0OqmsrPTl9CJNVlQEo0aZDTSysuCNNxTs0rr4dEP18OHD\n",
       "bNmyhccff5xBgwZx++23f68F43A4cJzg6Y+MjIyGn91uN26325cyRL6nuhr+/Gd49lmYOhVeeglO\n",
       "O83uqkS85/F48Hg8Pn/ep7ZMRUUFl156KcXFxQCsW7eOzMxMPvvsM9asWUN4eDi7d+9myJAhastI\n",
       "izh8GJ5+GjIyzIj9T3+Cr3+JFAkJLdKWCQ8Pp3v37hQWFgKwatUq+vTpw8iRI1m4cCEACxcuZPTo\n",
       "0b6cXsQrublwwQWweLH5ed48BbuITyN3gA8++IBJkyZRV1dHz549WbBgAUeOHCE5OZmdO3cSFRXF\n",
       "kiVL6NChw7EX1Mhd/OTDD+G3v4XPPoNHHjFTHLUOjIQqb7PT53D3lcJdmqqiAv74R1i6FH73O7OC\n",
       "46mn2l2VSPNqkbaMiB327ze99L59zRrrn3xidkdSsIt8n8JdAt43N0tjYuCjj2DTJpg5Ezp2tLsy\n",
       "kcCltWUkYFmWWX536lQ491zThhk0yO6qRIKDwl0C0vr1JtSrqsxDSNdco5ulIt5QW0YCyvbtcN11\n",
       "MG4cpKfD1q2aBSPiC4W7BISdO02YX345DB5sbpampWl9dRFfKdzFVl98YTah7t8fwsPNmjB33w2n\n",
       "n253ZSLBTeEutti3z8xVj401+5Z+9BFMnw7feeZNRHykcJcWtX8/zJgBvXrB55+bXZEefxy6drW7\n",
       "MpHQotky0iIOHoSnnoLMTLjsMsjLM/uXikjzULhLs6qrg/nz4aGHzOJe//wnDBhgd1UioU/hLs3i\n",
       "0CF47jmztvr558M//gHx8XZXJdJ6KNzFrw4dguefN6Hesye88AL85Cd2VyXS+ijcxS++Gak/9BBE\n",
       "RcHChZCQYHdVIq2Xwl2apK7OBPn06WakrlAXCQwKd/HJwYPwzDNmWmPv3mq/iASaJs1zP3LkCAMG\n",
       "DGDkyJEAVFVVkZiYSExMDElJSVRXV/ulSAkc+/fDX/9qRum5ufDyy/DGGwp2kUDTpHCfPXs2LpcL\n",
       "x9erOmVlZZGYmEhhYSFDhw4lKyvLL0WK/aqrzU3S886DDRtg+XJ47TXNgBEJVD6He1lZGStWrGDS\n",
       "pEkNWz8tW7aM1NRUAFJTU1m6dKl/qhTbVFbCvfeakXpREbz9Nrz0kuaqiwQ6n8P9jjvuYObMmbRp\n",
       "8+0pKisrcX697bzT6aSysrLpFYotPvsMbrnF9NNrauC998zN0thYuysTkZPh0w3V5cuX06VLFwYM\n",
       "GIDH4znuexwOR0O75rsyMjIafna73bjdbl/KkGbwr3+Zm6Rvvgk33WTWV//6/69FpAV5PJ4T5uvJ\n",
       "cFjebKf9tfvvv5/nn3+etm3bcvDgQf7zn/8wZswYNm3ahMfjITw8nN27dzNkyBA+/vjjYy/o5Q7e\n",
       "0vwsC1avhocfhg8/hDvuMMF+1ll2VyYi3/A2O30K96Pl5eXxyCOP8Nprr3HPPffQqVMnpk6dSlZW\n",
       "FtXV1d+7qapwDxyHDpnZLjNnmqmNd98N48fDaafZXZmIfJe32emXee7ftF/uvfdekpOTeeaZZ4iK\n",
       "imLJkiX+OL342X/+A08/DbNmmdkv06bB1VdDGy0ALRIymjxy9/qCGrnb5vPPYc4cePZZSEyEu+6C\n",
       "QYPsrkpEToa32amxWoizLDMv/ec/h4EDzUbTW7ZAdraCXSSUafmBEPVNP33WLLNP6W9+YzbL0E1S\n",
       "kdZBbZkQ8+9/w7x58OSTZiu722+Ha66BU06xuzIRaQq1ZVqpzZshNdVsjPH557BiBaxZA9deq2AX\n",
       "aY00cg9itbVmKYDHH4eKCvj1r2HSJOjUye7KRMTfWnyeu7cU7k1XUgJ/+5vZm7RfP5gyRa0XkVCn\n",
       "tkyIOnLEbC49ciRceKF56Ojtt80yAWq9iMh3abZMgNu924zQ580za7zcfDMsXgw/+pHdlYlIIFO4\n",
       "B6D6eli50gT6mjXws5/BK6+YEbuIyMlQuAeQsjIzSp8/39wUvflms8zumWfaXZmIBBuFu83q6syO\n",
       "RvPnw8aNMG4cvPqqNsMQkaZRuNtk2zZYsMBsLO1yQXq6mdaoXrqI+IPCvQXt3QuLFplQr6yECRNg\n",
       "/XqIjra7MhEJNZrn3swOHTJPiy5cCG+9BSNGQFoaDB2q6YsicvL0EFMAsCzIzzctl8WLzZIAqalm\n",
       "1svZZ9tdnYgEI1s26xDj00/hxRfNC+CXvzQ3SX/8Y3vrEpHWx6cnVEtLSxkyZAh9+vShb9++zJkz\n",
       "B4CqqioSExOJiYkhKSmJ6upqvxYbiHbvhtmz4eKL4Sc/MX3155+HTz6BP/xBwS4i9vCpLVNRUUFF\n",
       "RQX9+/enpqaGCy+8kKVLl7JgwQI6d+7MPffcw4wZM/jyyy9Dcg/VqiozXXHRInjvPbMkwPjxMGwY\n",
       "tNXvQiLSDGzpuY8ePZopU6YwZcoU8vLycDqdVFRU4Ha7+fjjj5tUYKCoroZly0wPfd06s01dSoq5\n",
       "QXr66XZXJyKhrsXDvaSkhCuuuIIPP/yQHj168OWXXwJgWRbnnHNOw599LdBO3wT6Sy9BXh4MGWK2\n",
       "qxs5Uk+NikjLatEbqjU1NVx//fXMnj2bM7+Tdg6HA4fDcdzPZWRkNPzsdrtxu91NKcOv9uyBnByz\n",
       "Rd0778CVV5qnRl98UVvUiUjL8Xg8eDwenz/v88j90KFDXHPNNQwfPpzbb78dgNjYWDweD+Hh4eze\n",
       "vZshQ4YERVumtBSWLjV99Pfeg6QkGDvWtFw0QheRQNAi67lblsXEiRNxuVwNwQ4watQoFi5cCMDC\n",
       "hQsZPXq0L6dvdpZlHv//859h0CDo39+E+m23mR2NXnrJtF8U7CISrHwaua9bt47LL7+cfv36NbRe\n",
       "MjMziY+PJzk5mZ07dxIVFcWSJUvo0KHDsRe0aeR+6BCsXWt66MuWmWV1r73WvBISICysxUsSETlp\n",
       "ekL1KHv2wOuvw/LlZsei6GgYNcrcEO3XD05wS0BEJOC06nCvr4f33zdruaxYAQUFZg2Xq682/fOu\n",
       "XZvlsiIiza7VhfsXX5hReW4uvPEGdOxognzECNNuOe00v11KRMQ2IR/utbWwYYPZhm7lSigqMvPP\n",
       "f/pTuOoqOO88PxYrIhIgQi7c6+th61azXO6qVWbu+fnnmyBPSoJLL9XNUBEJfUEf7pZlFt3yeEyg\n",
       "r1kD55xj1m0ZNgzcbvNnEZHWJOjC3bLg44/N4/15eSbUTz3VhPjQoabl0r17S1YoIhJ4giLcN22y\n",
       "WLvWLMC1di20bw+XXw5XXGHCPCqqJSsSEQl8QRHuffpYJCTAZZeZUNfIXESkcUER7oG2toyISKBr\n",
       "kbVlREQksCncRURCkMJdRCQEKdxFREKQwl1EJAQp3EVEQpDfwz03N5fY2Fh69erFjBkz/H16ERE5\n",
       "CX4N9yNHjjBlyhRyc3MpKChg0aJFbN++3Z+XCClN2fw21Oi7+Ja+i2/pu/CdX8M9Pz+f6OhooqKi\n",
       "CAsLY9y4ceTk5PjzEiFF/8P9lr6Lb+m7+Ja+C9/5NdzLy8vpftRaApGRkZSXl/vzEiIichL8Gu4O\n",
       "bUoqIhKh55+5AAAEZ0lEQVQYLD/asGGDddVVVzX8efr06VZWVtYx7+nZs6cF6KWXXnrp5cWrZ8+e\n",
       "XuWxXxcOO3z4MOeffz5vvfUW3bp1Iz4+nkWLFtG7d29/XUJERE5CW7+erG1bHn/8ca666iqOHDnC\n",
       "xIkTFewiIjZo8SV/RUSk+bXoE6p6wMkoLS1lyJAh9OnTh759+zJnzhy7S7LdkSNHGDBgACNHjrS7\n",
       "FFtVV1czduxYevfujcvlYuPGjXaXZJvMzEz69OlDXFwc48ePp7a21u6SWkx6ejpOp5O4uLiGY1VV\n",
       "VSQmJhITE0NSUhLV1dWNnqPFwl0POH0rLCyMRx99lI8++oiNGzfyf//3f632u/jG7NmzcblcrX7G\n",
       "1W233caIESPYvn07W7dubbVtzZKSEp566im2bNnCtm3bOHLkCNnZ2XaX1WLS0tLIzc095lhWVhaJ\n",
       "iYkUFhYydOhQsrKyGj1Hi4W7HnD6Vnh4OP379wegffv29O7dm127dtlclX3KyspYsWIFkyZNatW7\n",
       "dO3bt4+1a9eSnp4OmHtYZ599ts1V2eOss84iLCyMAwcOcPjwYQ4cOEBERITdZbWYhIQEOnbseMyx\n",
       "ZcuWkZqaCkBqaipLly5t9BwtFu56wOn4SkpKeP/997n44ovtLsU2d9xxBzNnzqRNm9a9jl1xcTHn\n",
       "nnsuaWlpDBw4kBtvvJEDBw7YXZYtzjnnHO666y569OhBt27d6NChA8OGDbO7LFtVVlbidDoBcDqd\n",
       "VFZWNvr+FvvX1Np/3T6empoaxo4dy+zZs2nfvr3d5dhi+fLldOnShQEDBrTqUTuYqcRbtmxh8uTJ\n",
       "bNmyhTPOOOMHf/UOVTt27GDWrFmUlJSwa9cuampqePHFF+0uK2A4HI4fzNQWC/eIiAhKS0sb/lxa\n",
       "WkpkZGRLXT7gHDp0iOuvv55f/OIXjB492u5ybLN+/XqWLVvGeeedR0pKCqtXr2bChAl2l2WLyMhI\n",
       "IiMjGTRoEABjx45ly5YtNldlj82bNzN48GA6depE27ZtGTNmDOvXr7e7LFs5nU4qKioA2L17N126\n",
       "dGn0/S0W7hdddBFFRUWUlJRQV1fH4sWLGTVqVEtdPqBYlsXEiRNxuVzcfvvtdpdjq+nTp1NaWkpx\n",
       "cTHZ2dlceeWVPPfcc3aXZYvw8HC6d+9OYWEhAKtWraJPnz42V2WP2NhYNm7cyFdffYVlWaxatQqX\n",
       "y2V3WbYaNWoUCxcuBGDhwoU/PChs0noDXlqxYoUVExNj9ezZ05o+fXpLXjqgrF271nI4HNYFF1xg\n",
       "9e/f3+rfv7/1+uuv212W7TwejzVy5Ei7y7DVv/71L+uiiy6y+vXrZ1133XVWdXW13SXZZsaMGZbL\n",
       "5bL69u1rTZgwwaqrq7O7pBYzbtw4q2vXrlZYWJgVGRlpzZ8/39q7d681dOhQq1evXlZiYqL15Zdf\n",
       "NnoOPcQkIhKCWvf0BBGREKVwFxEJQQp3EZEQpHAXEQlBCncRkRCkcBcRCUEKdxGREKRwFxEJQf8P\n",
       "aFlJKJFyhJ8AAAAASUVORK5CYII=\n"
      ],
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f54fafc4a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = subplots()\n",
    "ax.plot(x_vec, y_vec);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this kind of numerical evolution can be very slow, and there is a much more efficient way to do it: Use the function `lambdify` to \"compile\" a Sympy expression into a function that is much more efficient to evaluate numerically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f = lambdify([x], (x + pi)**2, 'numpy')  # the first argument is a list of variables that\n",
    "                                         # f will be a function of: in this case only x -> f(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y_vec = f(x_vec)  # now we can directly pass a numpy array and f(x) is efficiently evaluated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The speedup when using \"lambdified\" functions instead of direct numerical evaluation can be significant, often several orders of magnitude. Even in this simple example we get a significant speed up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 loops, best of 3: 20.4 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "\n",
    "y_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000 loops, best of 3: 3.67 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "\n",
    "y_vec = f(x_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algebraic manipulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the main uses of an CAS is to perform algebraic manipulations of expressions. For example, we might want to expand a product, factor an expression, or simply an expression. The functions for doing these basic operations in SymPy are demonstrated in this section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expand and factor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first steps in an algebraic manipulation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + 1\\right) \\left(x + 2\\right) \\left(x + 3\\right)$$"
      ],
      "text/plain": [
       "(x + 1)⋅(x + 2)⋅(x + 3)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x+1)*(x+2)*(x+3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$x^{3} + 6 x^{2} + 11 x + 6$$"
      ],
      "text/plain": [
       " 3      2           \n",
       "x  + 6⋅x  + 11⋅x + 6"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((x+1)*(x+2)*(x+3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `expand` function takes a number of keywords arguments which we can tell the functions what kind of expansions we want to have performed. For example, to expand trigonometric expressions, use the `trig=True` keyword argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\sin{\\left (a + b \\right )}$$"
      ],
      "text/plain": [
       "sin(a + b)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\sin{\\left (a \\right )} \\cos{\\left (b \\right )} + \\sin{\\left (b \\right )} \\cos{\\left (a \\right )}$$"
      ],
      "text/plain": [
       "sin(a)⋅cos(b) + sin(b)⋅cos(a)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(sin(a+b), trig=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See `help(expand)` for a detailed explanation of the various types of expansions the `expand` functions can perform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The opposite a product expansion is of course factoring. The factor an expression in SymPy use the `factor` function: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + 1\\right) \\left(x + 2\\right) \\left(x + 3\\right)$$"
      ],
      "text/plain": [
       "(x + 1)⋅(x + 2)⋅(x + 3)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(x**3 + 6 * x**2 + 11*x + 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simplify"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `simplify` tries to simplify an expression into a nice looking expression, using various techniques. More specific alternatives to the `simplify` functions also exists: `trigsimp`, `powsimp`, `logcombine`, etc. \n",
    "\n",
    "The basic usages of these functions are as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + 1\\right) \\left(x + 2\\right) \\left(x + 3\\right)$$"
      ],
      "text/plain": [
       "(x + 1)⋅(x + 2)⋅(x + 3)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# simplify expands a product\n",
    "simplify((x+1)*(x+2)*(x+3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1$$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# simplify uses trigonometric identities\n",
    "simplify(sin(a)**2 + cos(a)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{\\tan{\\left (x \\right )}}$$"
      ],
      "text/plain": [
       "  1   \n",
       "──────\n",
       "tan(x)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(cos(x)/sin(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### apart and together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To manipulate symbolic expressions of fractions, we can use the `apart` and `together` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f1 = 1/((a+1)*(a+2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{\\left(a + 1\\right) \\left(a + 2\\right)}$$"
      ],
      "text/plain": [
       "       1       \n",
       "───────────────\n",
       "(a + 1)⋅(a + 2)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- \\frac{1}{a + 2} + \\frac{1}{a + 1}$$"
      ],
      "text/plain": [
       "    1       1  \n",
       "- ───── + ─────\n",
       "  a + 2   a + 1"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apart(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f2 = 1/(a+2) + 1/(a+3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{a + 3} + \\frac{1}{a + 2}$$"
      ],
      "text/plain": [
       "  1       1  \n",
       "───── + ─────\n",
       "a + 3   a + 2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{2 a + 5}{\\left(a + 2\\right) \\left(a + 3\\right)}$$"
      ],
      "text/plain": [
       "    2⋅a + 5    \n",
       "───────────────\n",
       "(a + 2)⋅(a + 3)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "together(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simplify usually combines fractions but does not factor: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{2 a + 5}{\\left(a + 2\\right) \\left(a + 3\\right)}$$"
      ],
      "text/plain": [
       "    2⋅a + 5    \n",
       "───────────────\n",
       "(a + 2)⋅(a + 3)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to algebraic manipulations, the other main use of CAS is to do calculus, like derivatives and integrals of algebraic expressions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Differentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Differentiation is usually simple. Use the `diff` function. The first argument is the expression to take the derivative of, and the second argument is the symbol by which to take the derivative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(x + \\pi\\right)^{2}$$"
      ],
      "text/plain": [
       "       2\n",
       "(x + π) "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$4 \\left(x + \\pi\\right)^{3}$$"
      ],
      "text/plain": [
       "         3\n",
       "4⋅(x + π) "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(y**2, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For higher order derivatives we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$12 \\left(x + \\pi\\right)^{2}$$"
      ],
      "text/plain": [
       "          2\n",
       "12⋅(x + π) "
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(y**2, x, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$12 \\left(x + \\pi\\right)^{2}$$"
      ],
      "text/plain": [
       "          2\n",
       "12⋅(x + π) "
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(y**2, x, 2) # same as above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To calculate the derivative of a multivariate expression, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x, y, z = symbols(\"x,y,z\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f = sin(x*y) + cos(y*z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\frac{d^3f}{dxdy^2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- x \\left(x y \\cos{\\left (x y \\right )} + 2 \\sin{\\left (x y \\right )}\\right)$$"
      ],
      "text/plain": [
       "-x⋅(x⋅y⋅cos(x⋅y) + 2⋅sin(x⋅y))"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(f, x, 1, y, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integration is done in a similar fashion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\sin{\\left (x y \\right )} + \\cos{\\left (y z \\right )}$$"
      ],
      "text/plain": [
       "sin(x⋅y) + cos(y⋅z)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$x \\cos{\\left (y z \\right )} + \\begin{cases} 0 & \\text{for}\\: y = 0 \\\\- \\frac{\\cos{\\left (x y \\right )}}{y} & \\text{otherwise} \\end{cases}$$"
      ],
      "text/plain": [
       "             ⎛⎧    0      for y = 0⎞\n",
       "             ⎜⎪                    ⎟\n",
       "x⋅cos(y⋅z) + ⎜⎨-cos(x⋅y)           ⎟\n",
       "             ⎜⎪─────────  otherwise⎟\n",
       "             ⎝⎩    y               ⎠"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(f, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By providing limits for the integration variable we can evaluate definite integrals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$2 \\cos{\\left (y z \\right )}$$"
      ],
      "text/plain": [
       "2⋅cos(y⋅z)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(f, (x, -1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and also improper integrals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\sqrt{\\pi}$$"
      ],
      "text/plain": [
       "  ___\n",
       "╲╱ π "
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(exp(-x**2), (x, -oo, oo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, `oo` is the SymPy notation for inifinity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sums and products"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can evaluate sums and products using the functions: 'Sum'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n = Symbol(\"n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\sum_{n=1}^{10} n^{-2}$$"
      ],
      "text/plain": [
       "  10    \n",
       " ____   \n",
       " ╲      \n",
       "  ╲   1 \n",
       "   ╲  ──\n",
       "   ╱   2\n",
       "  ╱   n \n",
       " ╱      \n",
       " ‾‾‾‾   \n",
       "n = 1   "
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sum(1/n**2, (n, 1, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1.54976773116654$$"
      ],
      "text/plain": [
       "1.54976773116654"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sum(1/n**2, (n,1, 10)).evalf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1.64493406684823$$"
      ],
      "text/plain": [
       "1.64493406684823"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sum(1/n**2, (n, 1, oo)).evalf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Products work much the same way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\prod_{n=1}^{10} n$$"
      ],
      "text/plain": [
       "  10   \n",
       "┬───┬  \n",
       "│   │ n\n",
       "│   │  \n",
       "n = 1  "
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Product(n, (n, 1, 10)) # 10!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Limits can be evaluated using the `limit` function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1$$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(sin(x)/x, x, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use 'limit' to check the result of derivation using the `diff` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\sin{\\left (x y \\right )} + \\cos{\\left (y z \\right )}$$"
      ],
      "text/plain": [
       "sin(x⋅y) + cos(y⋅z)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$y \\cos{\\left (x y \\right )}$$"
      ],
      "text/plain": [
       "y⋅cos(x⋅y)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(f, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\displaystyle \\frac{\\mathrm{d}f(x,y)}{\\mathrm{d}x} = \\frac{f(x+h,y)-f(x,y)}{h}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "h = Symbol(\"h\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$y \\cos{\\left (x y \\right )}$$"
      ],
      "text/plain": [
       "y⋅cos(x⋅y)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit((f.subs(x, x+h) - f)/h, h, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the direction from which we approach the limiting point using the `dir` keywork argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\infty$$"
      ],
      "text/plain": [
       "∞"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(1/x, x, 0, dir=\"+\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$-\\infty$$"
      ],
      "text/plain": [
       "-∞"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(1/x, x, 0, dir=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series expansion is also one of the most useful features of a CAS. In SymPy we can perform a series expansion of an expression using the `series` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1 + x + \\frac{1}{2} x^{2} + \\frac{1}{6} x^{3} + \\frac{1}{24} x^{4} + \\frac{1}{120} x^{5} + \\mathcal{O}\\left(x^{6}\\right)$$"
      ],
      "text/plain": [
       "         2    3    4     5        \n",
       "        x    x    x     x     ⎛ 6⎞\n",
       "1 + x + ── + ── + ── + ─── + O⎝x ⎠\n",
       "        2    6    24   120        "
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series(exp(x), x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default it expands the expression around $x=0$, but we can expand around any value of $x$ by explicitly include a value in the function call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$e + e x + \\frac{1}{2} e x^{2} + \\frac{1}{6} e x^{3} + \\frac{1}{24} e x^{4} + \\frac{1}{120} e x^{5} + \\mathcal{O}\\left(x^{6}\\right)$$"
      ],
      "text/plain": [
       "             2      3      4      5        \n",
       "          ℯ⋅x    ℯ⋅x    ℯ⋅x    ℯ⋅x     ⎛ 6⎞\n",
       "ℯ + ℯ⋅x + ──── + ──── + ──── + ──── + O⎝x ⎠\n",
       "           2      6      24    120         "
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series(exp(x), x, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can explicitly define to which order the series expansion should be carried out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$e + e x + \\frac{1}{2} e x^{2} + \\frac{1}{6} e x^{3} + \\frac{1}{24} e x^{4} + \\frac{1}{120} e x^{5} + \\frac{1}{720} e x^{6} + \\frac{1}{5040} e x^{7} + \\frac{1}{40320} e x^{8} + \\frac{1}{362880} e x^{9} + \\mathcal{O}\\left(x^{10}\\right)$$"
      ],
      "text/plain": [
       "             2      3      4      5      6      7       8       9          \n",
       "          ℯ⋅x    ℯ⋅x    ℯ⋅x    ℯ⋅x    ℯ⋅x    ℯ⋅x     ℯ⋅x     ℯ⋅x      ⎛ 10⎞\n",
       "ℯ + ℯ⋅x + ──── + ──── + ──── + ──── + ──── + ──── + ───── + ────── + O⎝x  ⎠\n",
       "           2      6      24    120    720    5040   40320   362880         "
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "series(exp(x), x, 1, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The series expansion includes the order of the approximation, which is very useful for keeping track of the order of validity when we do calculations with series expansions of different order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$1 - \\frac{1}{2} x^{2} + \\frac{1}{24} x^{4} + \\mathcal{O}\\left(x^{5}\\right)$$"
      ],
      "text/plain": [
       "     2    4        \n",
       "    x    x     ⎛ 5⎞\n",
       "1 - ── + ── + O⎝x ⎠\n",
       "    2    24        "
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = cos(x).series(x, 0, 5)\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$x + \\mathcal{O}\\left(x^{2}\\right)$$"
      ],
      "text/plain": [
       "     ⎛ 2⎞\n",
       "x + O⎝x ⎠"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = sin(x).series(x, 0, 2)\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$x + \\mathcal{O}\\left(x^{2}\\right)$$"
      ],
      "text/plain": [
       "     ⎛ 2⎞\n",
       "x + O⎝x ⎠"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(s1 * s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to get rid of the order information we can use the `removeO` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{24} x^{5} - \\frac{1}{2} x^{3} + x$$"
      ],
      "text/plain": [
       " 5    3    \n",
       "x    x     \n",
       "── - ── + x\n",
       "24   2     "
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(s1.removeO() * s2.removeO())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But note that this is not the correct expansion of $\\cos(x)\\sin(x)$ to $5$th order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$x - \\frac{2}{3} x^{3} + \\frac{2}{15} x^{5} + \\mathcal{O}\\left(x^{6}\\right)$$"
      ],
      "text/plain": [
       "       3      5        \n",
       "    2⋅x    2⋅x     ⎛ 6⎞\n",
       "x - ──── + ──── + O⎝x ⎠\n",
       "     3      15         "
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cos(x)*sin(x)).series(x, 0, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices are defined using the `Matrix` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "m11, m12, m21, m22 = symbols(\"m11, m12, m21, m22\")\n",
    "b1, b2 = symbols(\"b1, b2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{smallmatrix}m_{11} & m_{12}\\\\m_{21} & m_{22}\\end{smallmatrix}\\right]$$"
      ],
      "text/plain": [
       "⎡m₁₁  m₁₂⎤\n",
       "⎢        ⎥\n",
       "⎣m₂₁  m₂₂⎦"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = Matrix([[m11, m12],[m21, m22]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{smallmatrix}b_{1}\\\\b_{2}\\end{smallmatrix}\\right]$$"
      ],
      "text/plain": [
       "⎡b₁⎤\n",
       "⎢  ⎥\n",
       "⎣b₂⎦"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = Matrix([[b1], [b2]])\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `Matrix` class instances we can do the usual matrix algebra operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{smallmatrix}m_{11}^{2} + m_{12} m_{21} & m_{11} m_{12} + m_{12} m_{22}\\\\m_{11} m_{21} + m_{21} m_{22} & m_{12} m_{21} + m_{22}^{2}\\end{smallmatrix}\\right]$$"
      ],
      "text/plain": [
       "⎡    2                               ⎤\n",
       "⎢ m₁₁  + m₁₂⋅m₂₁    m₁₁⋅m₁₂ + m₁₂⋅m₂₂⎥\n",
       "⎢                                    ⎥\n",
       "⎢                                 2  ⎥\n",
       "⎣m₁₁⋅m₂₁ + m₂₁⋅m₂₂   m₁₂⋅m₂₁ + m₂₂   ⎦"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{smallmatrix}b_{1} m_{11} + b_{2} m_{12}\\\\b_{1} m_{21} + b_{2} m_{22}\\end{smallmatrix}\\right]$$"
      ],
      "text/plain": [
       "⎡b₁⋅m₁₁ + b₂⋅m₁₂⎤\n",
       "⎢               ⎥\n",
       "⎣b₁⋅m₂₁ + b₂⋅m₂₂⎦"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And calculate determinants and inverses, and the like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$m_{11} m_{22} - m_{12} m_{21}$$"
      ],
      "text/plain": [
       "m₁₁⋅m₂₂ - m₁₂⋅m₂₁"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.det()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{smallmatrix}\\frac{1}{m_{11}} + \\frac{m_{12} m_{21}}{m_{11}^{2} \\left(m_{22} - \\frac{m_{12} m_{21}}{m_{11}}\\right)} & - \\frac{m_{12}}{m_{11} \\left(m_{22} - \\frac{m_{12} m_{21}}{m_{11}}\\right)}\\\\- \\frac{m_{21}}{m_{11} \\left(m_{22} - \\frac{m_{12} m_{21}}{m_{11}}\\right)} & \\frac{1}{m_{22} - \\frac{m_{12} m_{21}}{m_{11}}}\\end{smallmatrix}\\right]$$"
      ],
      "text/plain": [
       "⎡ 1          m₁₂⋅m₂₁                 -m₁₂       ⎤\n",
       "⎢─── + ────────────────────  ───────────────────⎥\n",
       "⎢m₁₁      2 ⎛      m₁₂⋅m₂₁⎞      ⎛      m₁₂⋅m₂₁⎞⎥\n",
       "⎢      m₁₁ ⋅⎜m₂₂ - ───────⎟  m₁₁⋅⎜m₂₂ - ───────⎟⎥\n",
       "⎢           ⎝        m₁₁  ⎠      ⎝        m₁₁  ⎠⎥\n",
       "⎢                                               ⎥\n",
       "⎢           -m₂₁                      1         ⎥\n",
       "⎢   ───────────────────         ─────────────   ⎥\n",
       "⎢       ⎛      m₁₂⋅m₂₁⎞               m₁₂⋅m₂₁   ⎥\n",
       "⎢   m₁₁⋅⎜m₂₂ - ───────⎟         m₂₂ - ───────   ⎥\n",
       "⎣       ⎝        m₁₁  ⎠                 m₁₁     ⎦"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.inv()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For solving equations and systems of equations we can use the `solve` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\begin{bmatrix}-1, & 1\\end{bmatrix}$$"
      ],
      "text/plain": [
       "[-1, 1]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(x**2 - 1, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\begin{bmatrix}- i \\sqrt{- \\frac{1}{2} + \\frac{1}{2} \\sqrt{5}}, & i \\sqrt{- \\frac{1}{2} + \\frac{1}{2} \\sqrt{5}}, & - \\sqrt{\\frac{1}{2} + \\frac{1}{2} \\sqrt{5}}, & \\sqrt{\\frac{1}{2} + \\frac{1}{2} \\sqrt{5}}\\end{bmatrix}$$"
      ],
      "text/plain": [
       "⎡        _____________         _____________        ___________       ________\n",
       "⎢       ╱         ___         ╱         ___        ╱       ___       ╱       _\n",
       "⎢      ╱    1   ╲╱ 5         ╱    1   ╲╱ 5        ╱  1   ╲╱ 5       ╱  1   ╲╱ \n",
       "⎢-ⅈ⋅  ╱   - ─ + ───── , ⅈ⋅  ╱   - ─ + ───── , -  ╱   ─ + ───── ,   ╱   ─ + ───\n",
       "⎣   ╲╱      2     2       ╲╱      2     2      ╲╱    2     2     ╲╱    2     2\n",
       "\n",
       "___⎤\n",
       "__ ⎥\n",
       "5  ⎥\n",
       "── ⎥\n",
       "   ⎦"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(x**4 - x**2 - 1, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "System of equations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\begin{Bmatrix}x : 1, & y : 0\\end{Bmatrix}$$"
      ],
      "text/plain": [
       "{x: 1, y: 0}"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve([x + y - 1, x - y - 1], [x,y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In terms of other symbolic expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\begin{Bmatrix}x : \\frac{1}{2} a + \\frac{1}{2} c, & y : \\frac{1}{2} a - \\frac{1}{2} c\\end{Bmatrix}$$"
      ],
      "text/plain": [
       "⎧   a   c     a   c⎫\n",
       "⎨x: ─ + ─, y: ─ - ─⎬\n",
       "⎩   2   2     2   2⎭"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve([x + y - a, x - y - c], [x,y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum mechanics: noncommuting variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about non-commuting symbols? In quantum mechanics we need to work with noncommuting operators, and SymPy has a nice support for noncommuting symbols and even a subpackage for quantum mechanics related calculations!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from sympy.physics.quantum import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## States"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define symbol states, kets and bras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$${\\left|\\psi\\right\\rangle }$$"
      ],
      "text/plain": [
       "❘ψ⟩"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ket('psi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$${\\left\\langle \\psi\\right|}$$"
      ],
      "text/plain": [
       "⟨ψ❘"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bra('psi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "u = Ket('0')\n",
    "d = Ket('1')\n",
    "\n",
    "a, b = symbols('alpha beta', complex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\alpha {\\left|0\\right\\rangle } + \\sqrt{- \\left\\lvert{\\alpha}\\right\\rvert^{2} + 1} {\\left|1\\right\\rangle }$$"
      ],
      "text/plain": [
       "           ____________    \n",
       "          ╱      2         \n",
       "α⋅❘0⟩ + ╲╱  - │α│  + 1 ⋅❘1⟩"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phi = a * u + sqrt(1-abs(a)**2) * d; phi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\overline{\\alpha} {\\left\\langle 0\\right|} + \\overline{\\sqrt{- \\left\\lvert{\\alpha}\\right\\rvert^{2} + 1}} {\\left\\langle 1\\right|}$$"
      ],
      "text/plain": [
       "        _______________    \n",
       "           ____________    \n",
       "_         ╱      2         \n",
       "α⋅⟨0❘ + ╲╱  - │α│  + 1 ⋅⟨1❘"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dagger(phi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left(\\overline{\\alpha} {\\left\\langle 0\\right|} + \\overline{\\sqrt{- \\left\\lvert{\\alpha}\\right\\rvert^{2} + 1}} {\\left\\langle 1\\right|}\\right) {\\left|1\\right\\rangle }$$"
      ],
      "text/plain": [
       "⎛        _______________    ⎞    \n",
       "⎜           ____________    ⎟    \n",
       "⎜_         ╱      2         ⎟    \n",
       "⎝α⋅⟨0❘ + ╲╱  - │α│  + 1 ⋅⟨1❘⎠⋅❘1⟩"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dagger(phi) * d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `qapply` to distribute a mutiplication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\overline{\\alpha} \\left\\langle 0 \\right. {\\left|1\\right\\rangle } + \\overline{\\sqrt{- \\left\\lvert{\\alpha}\\right\\rvert^{2} + 1}} \\left\\langle 1 \\right. {\\left|1\\right\\rangle }$$"
      ],
      "text/plain": [
       "          _______________      \n",
       "             ____________      \n",
       "_           ╱      2           \n",
       "α⋅⟨0❘1⟩ + ╲╱  - │α│  + 1 ⋅⟨1❘1⟩"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qapply(Dagger(phi) * d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\overline{\\alpha} \\left\\langle 0 \\right. {\\left|0\\right\\rangle } + \\overline{\\sqrt{- \\left\\lvert{\\alpha}\\right\\rvert^{2} + 1}} \\left\\langle 1 \\right. {\\left|0\\right\\rangle }$$"
      ],
      "text/plain": [
       "          _______________      \n",
       "             ____________      \n",
       "_           ╱      2           \n",
       "α⋅⟨0❘0⟩ + ╲╱  - │α│  + 1 ⋅⟨1❘0⟩"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qapply(Dagger(phi) * u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = Operator('A')\n",
    "B = Operator('B')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if they are commuting!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$False$$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * B == B * A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$A B A + A \\left(B\\right)^{2} + \\left(A\\right)^{2} B + \\left(A\\right)^{3} + B A B + B \\left(A\\right)^{2} + \\left(B\\right)^{2} A + \\left(B\\right)^{3}$$"
      ],
      "text/plain": [
       "           2    2      3              2    2      3\n",
       "A⋅B⋅A + A⋅B  + A ⋅B + A  + B⋅A⋅B + B⋅A  + B ⋅A + B "
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((A+B)**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[A,B\\right]$$"
      ],
      "text/plain": [
       "[A,B]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = Commutator(A,B)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the `doit` method to evaluate the commutator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$A B - B A$$"
      ],
      "text/plain": [
       "A⋅B - B⋅A"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.doit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can mix quantum operators with C-numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\alpha \\beta \\left[A,B\\right]$$"
      ],
      "text/plain": [
       "α⋅β⋅[A,B]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = Commutator(a * A, b * B)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To expand the commutator, use the `expand` method with the `commutator=True` keyword argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- \\left[A,B\\right] B + A \\left[A,B\\right]$$"
      ],
      "text/plain": [
       "-[A,B]⋅B + A⋅[A,B]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = Commutator(A+B, A*B)\n",
    "c.expand(commutator=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- \\left[A^{\\dagger},B^{\\dagger}\\right]$$"
      ],
      "text/plain": [
       " ⎡ †  †⎤\n",
       "-⎣A ,B ⎦"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dagger(Commutator(A, B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ac = AntiCommutator(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$A B + B A$$"
      ],
      "text/plain": [
       "A⋅B + B⋅A"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ac.doit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Quadrature commutator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the commutator of the electromagnetic field quadatures $x$ and $p$. We can write the quadrature operators in terms of the creation and annihilation operators as:\n",
    "\n",
    "$\\displaystyle x = (a + a^\\dagger)/\\sqrt{2}$\n",
    "\n",
    "$\\displaystyle p = -i(a - a^\\dagger)/\\sqrt{2}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\frac{1}{2} \\sqrt{2} \\left(A^{\\dagger} + A\\right)$$"
      ],
      "text/plain": [
       "  ___ ⎛ †    ⎞\n",
       "╲╱ 2 ⋅⎝A  + A⎠\n",
       "──────────────\n",
       "      2       "
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = (A + Dagger(A))/sqrt(2)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- \\frac{1}{2} \\sqrt{2} i \\left(- A^{\\dagger} + A\\right)$$"
      ],
      "text/plain": [
       "   ___   ⎛   †    ⎞\n",
       "-╲╱ 2 ⋅ⅈ⋅⎝- A  + A⎠\n",
       "───────────────────\n",
       "         2         "
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = -I * (A - Dagger(A))/sqrt(2)\n",
    "P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's expand the commutator $[x,p]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$- i \\left[A^{\\dagger},A\\right]$$"
      ],
      "text/plain": [
       "   ⎡ †  ⎤\n",
       "-ⅈ⋅⎣A ,A⎦"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Commutator(X, P).expand(commutator=True).expand(commutator=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see directly that the well known commutation relation for the quadratures\n",
    "\n",
    "$[x,p]=i$\n",
    "\n",
    "is a directly related to\n",
    "\n",
    "$[A, A^\\dagger]=1$ \n",
    "\n",
    "(which SymPy does not know about, and does not simplify)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more details on the quantum module in SymPy, see:\n",
    "\n",
    "* http://docs.sympy.org/0.7.2/modules/physics/quantum/index.html\n",
    "* http://nbviewer.ipython.org/urls/raw.github.com/ipython/ipython/master/docs/examples/notebooks/sympy_quantum_computing.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://sympy.org/en/index.html - The SymPy projects web page.\n",
    "* https://github.com/sympy/sympy - The source code of SymPy.\n",
    "* http://live.sympy.org - Online version of SymPy for testing and demonstrations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Versions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/json": {
       "Software versions": [
        {
         "module": "Python",
         "version": "3.3.2+ (default, Feb 28 2014, 00:52:16) [GCC 4.8.1]"
        },
        {
         "module": "IPython",
         "version": "2.2.0"
        },
        {
         "module": "OS",
         "version": "posix [linux]"
        },
        {
         "module": "numpy",
         "version": "1.8.2"
        },
        {
         "module": "sympy",
         "version": "0.7.5"
        }
       ]
      },
      "text/html": [
       "<table><tr><th>Software</th><th>Version</th></tr><tr><td>Python</td><td>3.3.2+ (default, Feb 28 2014, 00:52:16) [GCC 4.8.1]</td></tr><tr><td>IPython</td><td>2.2.0</td></tr><tr><td>OS</td><td>posix [linux]</td></tr><tr><td>numpy</td><td>1.8.2</td></tr><tr><td>sympy</td><td>0.7.5</td></tr><tr><td colspan='2'>Tue Aug 26 22:57:37 2014 JST</td></tr></table>"
      ],
      "text/latex": [
       "\\begin{table}\n",
       "\\begin{tabular}{|l|l|}\\hline\n",
       "{\\bf Software} & {\\bf Version} \\\\ \\hline\\hline\n",
       "Python & 3.3.2+ (default, Feb 28 2014, 00:52:16) [GCC 4.8.1] \\\\ \\hline\n",
       "IPython & 2.2.0 \\\\ \\hline\n",
       "OS & posix [linux] \\\\ \\hline\n",
       "numpy & 1.8.2 \\\\ \\hline\n",
       "sympy & 0.7.5 \\\\ \\hline\n",
       "\\hline \\multicolumn{2}{|l|}{Tue Aug 26 22:57:37 2014 JST} \\\\ \\hline\n",
       "\\end{tabular}\n",
       "\\end{table}\n"
      ],
      "text/plain": [
       "Software versions\n",
       "Python 3.3.2+ (default, Feb 28 2014, 00:52:16) [GCC 4.8.1]\n",
       "IPython 2.2.0\n",
       "OS posix [linux]\n",
       "numpy 1.8.2\n",
       "sympy 0.7.5\n",
       "\n",
       "Tue Aug 26 22:57:37 2014 JST"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%reload_ext version_information\n",
    "\n",
    "%version_information numpy, sympy"
   ]
  }
 ],
 "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.3.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}