02_Fun_with_algebra.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ This notebook is part of the addition lecture *An overview of key ideas* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n",
    "+ Created by me, Dr Juan H Klopper\n",
    "    + Associate Professor\n",
    "    + Department of Biostatistics and Bioinformatics\n",
    "    + Milken Institute School of Public Health\n",
    "    + The George Washington University\n",
    "    + <a href=\"mailto:juanklopper@gwu.edu\">Email me with your thoughts, comments, suggestions and corrections</a> \n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons Licence\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" href=\"http://purl.org/dc/dcmitype/InteractiveResource\" property=\"dct:title\" rel=\"dct:type\">Linear Algebra OCW MIT18.06</span> <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">Jupyter notebook study notes by Dr Juan H Klopper</span> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>.\n",
    "\n",
    "+ [1] <a href=\"http://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/index.htm\">OCW MIT 18.06</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 2.2em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0, 80, 120);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 1.9em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(245,179,64);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(94,127,192);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"PT Mono\";\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "css_file = 'style.css'\n",
    "HTML(open(css_file, 'r').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![SegmentLocal](KRG_elegant_logo_for_light_BG.png \"segment\")\n",
    "![SegmentLocal](UCT_logo.gif \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fun with algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preamble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will learn more about some keywords (function) in `sympy`, specific to common algebraic manipulations.  We begin with importing `sympy` and initializing the use of LaTex printing to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import init_printing\n",
    "init_printing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simplifying algebraic expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sympy` package has a general function called `simplify()` which is great at simplifying algebraic expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import symbols, simplify"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = symbols('x y')  # Creating more than one symbol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's simplify expression (1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\frac{x^3 + x^2 - x + 1}{x^2 + 2x + 1} \\tag{1}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAAPBAMAAABpZ+CXAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAcklEQVQYGWNgIAHwPMSqWDj5I1ZxBnZ84kLKrmoKqPpA6hkT2Js4JmCKswmwfWR1wBRnZOBaABJlnAkGG0BsiL38CiA2MoCI7werQRfnEdBnYBJAFoWYE39gPYM7qjADE9CdwkpC1wtQxXntfl5HFUHwAJCJHD96jCv6AAAAAElFTkSuQmCC",
      "text/latex": [
       "$$x - 1$$"
      ],
      "text/plain": [
       "x - 1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can factor both the numerator and the denominator using the `.factor()` method on each of the expresssions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIkAAAAbBAMAAAC6pLGyAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAImYQu82Z3XZU70SJqzJu81j5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACNUlEQVQ4Ea2UP2gUQRTGv9u9y925a3KksbBwFYylCyoJIYFE7I3F2ohyREuFSyFEbRYCIYWSSAJJbAxYWuRSxc4TUWxEUggigtdY5yAI2hjfvHmzZvZ2be6mmPfne/PbNzO7C/Q6/Du3e0XQ+jf43AfKHPZrvWMe4VSzdwrwPOwHZb4fEL9OlEJAU+Z4KtnhTJWSVT7WESVfzKvBcX327lRuxR4pXstrA9cya6ovAHeGpZKGpcuehcAlSv7YXAvh1NOyiic/HtD8gSXumD01bWjP/fadKH4MbB8eAuXsJzmKMs4r5vQ6mYUCnCeKuyXZE1ZNEjCl1KS40EiSyrEouCHaItmxJycfxxKLYQrfYaVOz1zae6W3l6K8l/LLVNNy5sszGRRHJYsBMIFz8X1dYPdyVlY9oDMK/QOvJrEY7qWqNlNeAd7iU7ijFZuyLuUvqRcUp1TkRjzaymfKYIe8Y00gxBWVxLsoehhFN9lXp4t9dgGiAEOxRImxKcAvo9i9GArtiJBtU2QsU7wGhWpHGPxjBJuyK2k63Wq4jIrq78hgSnK6q5UOFrRqU8zp0l29XrmK9BdXUW/dQIsmum7vd7FTCMinkVCW1XPvcg6gniaXxmYDCcUMfP05C5TaFNK23C8Li2dEMZR729cD4JZkc74AVkd5zvkClOY2uIKutC5OhtGv64ilXDga+bGJpo3TZeXPUKx1KSah/gx65P+lZPl//lL/OigEgusypyWTvr+k0DFd/gXLdW1z08t2LgAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\left(x - 1\\right) \\left(x + 1\\right)^{2}$$"
      ],
      "text/plain": [
       "               2\n",
       "(x - 1)⋅(x + 1) "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x**3 + x**2 - x - 1).factor()  # Factoring the numerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEYAAAAbBAMAAAAzEOSeAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAImYQu82Z3XZU70SJqzJu81j5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABTElEQVQoFWNgIACOuRkQUMHAI8AbQEgNuwDfR4JqNjD+JqSGgYHzM2E17A2E1RwDKmFUABJYwUSQKFMCkDABsbACXgGg8B6GfQwMgVjlORczMDADQ4YvcqYzxCyEshkQpu1ZkG9OMDBw/f//gYEdZCACQNUwMIHUWEHFxRHyIBaKGtYNEMk2IGXRK93TAOGiqOFJgAg6Ad12gKmCHeg+EEBRwwQVrGRg4DHg+cwNdRaKGs4CiMbVQHMYWBzAnKOhoVWhobEgNtjNfB/AwgxANQwM/A0QDppdMDVAuxgY3j/AqoYbahfQzZwG/QwcBhBVKO6BuRkYrfsn+DMIQQ2CqeEAhSHbASABBNsZGGw7LJIUwBy4e9hufU1iYGB9ABHFERdgSXOoRnD6gLKBlDGCCY5TCNcRWRSFDUobEIA7jbEIwNQwKsBY6LQiVAAAJiVCQuLeCkwAAAAASUVORK5CYII=",
      "text/latex": [
       "$$\\left(x + 1\\right)^{2}$$"
      ],
      "text/plain": [
       "       2\n",
       "(x + 1) "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x**2 + 2*x + 1).factor()  # Factoring the denominator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it's easy to see the result of the simplification as we ${\\left( x+1 \\right)}^2$ in both the numerator and the denominator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `simplify()` is a relatively slow function as it _tries_ many possible solutions.  When appropriate rather factor or expand.  We have already seen the power of the `factor()` and `expand()` functions and methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `collect()` function collects common powers.  Expression (2) has three mathematical variables with the $x$ variable being of varying degree."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$x y + x - 3 + 2 x^2 - z x^2 + x^3 \\tag{2}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to set `z` as a mathematical variable too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = symbols('z')  # Setting z as a mathematical variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `expr` computer variable is overwritten to contain expression (2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANsAAAAYBAMAAACB0ZVpAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC0ElEQVRIDbVVTWgTQRh9m+xutt1sHVvwIFjTKoKHaCge7Kl7UBQvhipeBBurVDyUFi96UUr9KV5qUAQXhFa9VcSeFE+tHqXFaA9ioaCe9KKN+AcW1s3OT2Y3k9QinUPmfe/73nu7s5sEoKt/gTAU2czF15G6thh8pBTWDsqMM+xMyjXHp9HNoXo33WRR3WnEOoXUsqp/BTOuihec5drfRbEGoL67qzicb2hi5fUfDQfqNNun1Y1XRM0LNl0W8N9B4mad2dE6vKCtjIBrAOrDhFlSeWxZfCjoQYEaA21pSjpAfUU5fVHFajkM5VkjpbwehaoNpnjK7dP6L8UIjIIhXRJe0BmHoOU9Gz+G4xSlM4ypswVf4C+8ZbmpDxzL+7O5l0SqWVzLCJLs9bfvzt2jA6vFfQJ6XOZl95/ikDF0++r7cs3imspI/qF8i+8vU7Ra3ARBT3BSrdv278jInhRrnXt6+yk0xvNPKWJxQWGV40IeR4Wtb6DXnNcNAq2QGrWK1E3+3IQLmeuU2HxuaZKialxfIS7kcVRYOIEEu23havwETGKWDVdQApzEEDlKK4JDjK7GXa4R8rhQqM++Q/OkMKPAygGaTGteuIIjBsGUmLbDt+Gs54173q2QdUpRoel5dz57XuBHhRo+YkMmcK8aAkuhtEKr1jdBHuFI3F22wkSF/O6AitAoY6Zy1dJKlMIiTrMJm717QLpy0eHicekS9iHmJ+JCoVPELq5i+zx0F2myGwkS6wTl8+BJd1B6HmCBPO4JsD0u5HFU2JzDg6ipXUDCRd/sYxyINiqVsdK8rA+HvD12ZmeeTrA4/drAwkhcyOKY0MkZsZ+pgwODe4G2zta31JY6sk+tqyN7nmIHl24zlsU1+b4/EheyOCbUurKxv90J3/8diVi94IepmuSHyXvB0/vftbGBgUbkZje2sgcgs+uGx3B/3bwVxr3ZaQWLv7XeqvHYvRKAAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$x^{3} - x^{2} z + 2 x^{2} + x y - 2$$"
      ],
      "text/plain": [
       " 3    2        2          \n",
       "x  - x ⋅z + 2⋅x  + x⋅y - 2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = x * y - 2 + 2 * x**2 - z * x**2 + x**3\n",
    "expr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `collect()` function is imported from `sympy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import collect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we use the `collect()` function with two arguments.  The first is the computer variable that contains expression (2) and the second is the mathematical variable of interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOkAAAAZBAMAAAAmixTJAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC+ElEQVRIDa2WQWgTQRSG/013k202qUsLopeaVvAWDcWDnroX0WMoIoKgMYK3YhBRL4UggniyCIJBoVUPQkHMUbxY0aNC1YMo9KAg2IukYlWwEGfmzezspJO0SgYy8973/vcmOzM7CUCt+i6UljFMP7JiQ/P/Tr6Wn7dkp6OBWQvuF8pXMi1LLT8Kflhw/5D1Wf2yu9a/KSyVRpsWCORWrbhPMHXTXsgvCH7YHtX0pTb/xbKuMDAtajjzPUo5ywtNDEQ9FMmQUMfAXY/NhJFZEs5glGCd5gjSa3C2etaFWpYYbbq/yMwVklWP4QR3Z5JM2Ur5BvgGVCVWVKk6R1IT9aPMJ7KMrODuq3scX6WY2SvlV2AywqgMKmpqtUdq8oPqmYgsI2uo3eavsVtn3YamlHMhJpsYLJNA0Q1yCUiN4d2H9hS0RmUlcYp2l0THvwQ1YSklc26ESEuNos74/qkqht/ClYuop2Bqp5K54s9qJLMMnKVphMh5WPxIalUf8H4CGVlD0e24XLiOykmkWrq4sLg6HaZXvUgHZJaB/UUdd+DOk6fqA36JXSd1k57GufCou/gBWSmnMOu52knidKNxe6XR6MRDZWBng7c7LOtpyDqtZM4y+wQtk4ZY4MU/Y1uBjSK50WQSUkNg4YoufgKulo3PGjevJM1YKbZdzMoiMcV35nmreEZzxfnykJg4zkrg5ArjhcqPla/hRvDqxGMa/GEgP4u9Si9Hoc6F+5AKdURmGTh5mnJLGCC1qh9UkIo2nKbn7BSNIVvCA12bW6Q+tfgYybtd1jKweit41pOL52/xUa/lkbPTB9hTVQRUK+ytZ1tuDfmSJ+88igKkHhkffl9TiI1yVgOr1eOypcxKmeTqWefa7d/AoNw+SZ2JseIldowmih1/C0hNFXSvamnCrJ43Iil3yITOfLazW2hOaBFZb39TqW5/kx7ELrkylqqboWy0maLLL9013N8ss3u856+6SOvyvaaKcru71+4RSZ5yq+yClXaDfwEguadFWKdn7gAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$x^{3} + x^{2} \\left(- z + 2\\right) + x y - 2$$"
      ],
      "text/plain": [
       " 3    2                   \n",
       "x  + x ⋅(-z + 2) + x⋅y - 2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(expr, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results is an expression with descending powers of $x$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cancel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `cancel()` function puts a rational function in canonical form, i.e. $\\frac{p}{q}$.  We will import the function and use it for expression (3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKsAAAAWBAMAAABNknGBAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACMUlEQVQ4EZWUzWsTURTFzxsnkzGTiY8WXJZpBXd+UATdSGcjulAsIm5cGFNwFywiqBsRd64MLtQBoem2IM0/INa1CikuXEgQd7pQU61VsDC+N+8jb9J5aZzF3Pt+59zDzWQYQFyNd1R2O0vzuV3b6TZJuBi2zbPZe/Gelnn+jz6sl/s2ux8HmzZtV27f1p93f+06bjNMdWwKUN2wa6MV59EI3Y9GiKOl4YfwhL5YUxNN1chKeiuFv03yoDvwu9uDnnff0y0FyoYtY5PwCp+25P5RNTnVcX+rXtTHs7ECl3BZtaKuA99MUo1y/LCO9ePyJ9MIaAnBszfLee0zMBcbSMUK7t7Rs0FjwfSxES2hlqZ9I4O1SxRzHQOpWMG9vXx24sCpg5Hhke3xGx+sGrM8pGTm2IWGMKvYjOMmjyX18n2/JbOMsozz8zYNKG1hP25HD4ZjGScRj/Wot1GKjTzdVu7ZNfZnX8V1elGYB9sy7iHbFpW2TiJJdnUyEG4Sq9YDKFYym5ckT78kCduQXYy/zmKBfVFG8jf20eLvZqEGOF3u/qFG9LaMk7qMfSmWUx5Ray2E7EtQqAFv4cYI/qoRHcv42ZO9j18jVOkROFQZdA0Bv2XRENThxK+cPqaFX8VmHKixB3JlbRWndZpu3C7uxhYNZ641T5S2K313MR/LOSO1NjA5M/FeqjqTN+cW1q3aUpr+IbPTh27JCbUt5+zdWv1ZFJhLH+ugYscyj28idNj7D1Wth5+7ZDvfAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$x^{3} - 5 x^{2} - 2 x + 24$$"
      ],
      "text/plain": [
       " 3      2           \n",
       "x  - 5⋅x  - 2⋅x + 24"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x-3)*(x+2)*(x-4)).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGkAAAAWBAMAAAAx2K8dAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABfklEQVQ4EWNggIDctQJQFgkUmwPzBBKUQ5VyOHB/IUNXAMtX0nUxMPB8JEcXhwI5unIxNHFfwBACCrCkZR2Ai7NjKuEwgMsiMXwZeL7DuWEM0XA2lKGHootHASKsf4DhB0wl95wzC2FsKM1SiVVXXADDT5hKvv//P8DYUJqNE6suYGiDXCik7KqmgKYDxC0B6mJUMglKgsjBXMjAIJHAwMCYwN7EMQEig0wyKgB1iTFUKHSi6XLrFWBgYBNg+8jqgKwewmZjAOpKZMgXCEHTxcD0FGgXA9cCuB7GmWCwAShwGqRLgGEVWI5t5swZL2fOhHr0HdAyBn4FsAwqwZgA0sXA8AkmDPOXCwPD+gNAwf0go9EBj+3d+28VGLh/wyRguv4LgHTxCOgzMIGsxAB8BgwHmT4wKEIkYLpeMTD0CzDEH1jP4I6hAyTAt4D1D9cHlgJUXeXg+BJWEroOlUDVy7b+c6GRom45VBRmF+vdWwGoCvHxYLrwqcGUY0T2OwAk40vVNTR6KgAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$x^{2} - 4 x + 3$$"
      ],
      "text/plain": [
       " 2          \n",
       "x  - 4⋅x + 3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x-1)*(x-3)).expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\frac{x^3 - 5x^2 - 2x +24}{x^2 - 4x + 3} \\tag{3}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import cancel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGkAAAAwBAMAAADgLUk2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB0klEQVRIDe1UPUvDUBQ9ST8sTdVHC6JbreAmFRFxUJpFdBQRQRz8GBSE0qKgboKbU7uKiroKYv+BdXJRUUScHAQFJ21FRVGM6Uub9j0fJC0oDr1Dcu459+a+vLwcwIjoHsmjMm5u1ZEsozxf6lGV5wq6Bp0v5XcBvmwlXZ4g2yVd76ZYxsikUHSwyEeLkKIA3MI11wI9ZmnNmQkNcA48cBRNj4Amkx/BmIkpuAciKkvRbBZoLNDKxvFOARv3LYKI6MXGdzCjV/hb+lqDdZqWYbv0LEGkUOfQFMs7tIU0IE3UrHiSrGJkrlc0YCm4ymmxdwK4iTvrUjmFpp52TCJGhlnNd5m402fBu23y0hqNFCWuAYJdCkv4echf+jDUB6nCX+SzHPPE0zfAQVonD4xH8/IJnCqUD46WMoAjDh8JQ86N5EKZgKweyhk0s8It4FUxnt5HPyvQbGA62u369GaccVYcJZgDAiH/FSfQsi1Ne5M6mtsW2SYovaWnlxOr6T/dAa2C0M9iNf5iB04Fv7rVXKkrUkEXsPxLXQJntzFL5OzWKxQ4u41ZBWdvooa/TjfYepbA2W3M+unsdnZe4OzWs0TOjrDVVxY5+8XjZtzq2NnSvwFfIZxaikaT1wAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\frac{x^{2} - 2 x - 8}{x - 1}$$"
      ],
      "text/plain": [
       " 2          \n",
       "x  - 2⋅x - 8\n",
       "────────────\n",
       "   x - 1    "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Instead of first creating a computer variable we can pass the expression directly as an argument\n",
    "cancel(((x - 3) * (x + 2) * (x - 4)) / ((x - 1)*(x - 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.factor()` method will accomplish the same thing, other than also factoring the polynomials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIMAAAAtBAMAAAB/pcXLAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAImYQu82Z3XZU70SJqzJu81j5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAACY0lEQVRIDe1VMYjUQBR9m+zeJm48wzVX2OwVXp3Cw0VcWMVeLYKF6B0nLBYWa6eFmEosFM9GK0FQEZSD6yxNIccVCmojXHOpbO/gEEGF9f+ZTDJDkiK7Igj3YWb+/PfmzeQnkw+g0UWFub4E5ipw4JFEjlcQvgGfBWQPyhj28GyCw3KTC2UEit0GlgTUSg9j8vrwfsE+z0FrxYTUzFkHvIhniyokRjeS06vAa2CLJ+3SPYC5y4D9jBk3uMtMSbwCdnyc5Ph8BppOTBK4RK0xMgAlsRxgJ0Frg8C71HoPjt6PDCIsnyU2qTkr1OUMJUHBOwE8Bs/QeWPrZlskhuap9cASx6g1uwYjl+j8pkzysluUtcDb7/jkaxYLiScUaa8ZjFyi/QlwR8R4Q3ugORCrl0K2K+S7iZDYJffQRs7wwvDiyzCktWRDarN71JEEcCTiXrNTMCQ0RnYKkSMhQQ8C7CbacnafDoc/rwFvyeUH0RiZxGM0fHRGhFE63eAhnICJuq3TRKVTYyiJ2RiOL9NJ7+3d2jkUr9ILkrhOjd+bxlAS8x82vwIzMcRZ+/d6q11yDXs//gJwZvmsGkNJLI/HP4BWQoyqD5z1bH7Sig+cEeAEd1XXjDEv4n6Ru8xsI2lbIn46QwuOvOxNvwCogLzsqPrlEE2q2wO1ojCm6o1uAUkDVrp98W2pFQvKORhlBsbT2t5BJv/fDLjPpz17/+P+tBKw/r1EXoWz09c8RVmdrilRVqdrSqg6bYsyHSb8NDUltCo8aS60KjyphFaFJ5XQqnAm4dT7tLQqrCRmtr+vKv+vj38AaPjDwFqGi/QAAAAASUVORK5CYII=",
      "text/latex": [
       "$$\\frac{\\left(x - 4\\right) \\left(x + 2\\right)}{x - 1}$$"
      ],
      "text/plain": [
       "(x - 4)⋅(x + 2)\n",
       "───────────────\n",
       "     x - 1     "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(((x - 3) * (x + 2) * (x - 4)) / ((x - 1)*(x - 3))).factor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `apart()` function is especially helpful.  It calculates partial fraction decomposition.  This can take a long time if done by hand.  Take a look at expression (4) and then its (one possible) partial fraction decomposition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\frac{3x^4 + 5x^3 - 3x^2 + 3x}{x^5 + 3x^4 - 9x - 27} \\tag{4}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import apart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAN4AAAAsBAMAAAD4ExuWAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC/klEQVRYCe2XPWgUQRTH3567d8fdmVsTEO0uEew0IjY2coXGSjxEbEQ9PwgqBK9LGkGCChbqgY2LFrGwESVprXJaSiCxCgRSWKTQQu9E0eDBuh8zO2923uwuZ2V0m3nz3m/+/93ZLx7AX3dUPiSfclo9ebVSHbncU3I4kVbHbKa4kOwHafVMJghK09PXh/cc21tDSkRIIHq9cL22bjQLs8U2YSJSFKLVY8u09byd71l1IU5EFKLVS/MzoDRHeOAURwwnOBb82sB+ANUaFidjFfkDv8XghEkfnlSRgf0q9jjkbC5MjhQysN+FzjwcJ22iJIXkUt53bX1kbHi1FUmTAYFsP7K5SrIsmVZPWrs1a5Va9ut6mx3Vkv/9xNb88/vpJhxdb5/yjvP4o+Mc8MJqAur6W3rNcR44ziM/1KF+Le3YCs/n1Cv9jyF2ffm19/odyfh85uvb2lqRmN8VOKxFIaNfsV7+phWJ+d2GxbqWzerXML/LGhOTL3ki5ncHTjZ4KRjNyesdnkjwwxhARf5rmiuw3GIiRvzWLsuJE1D5wf128EAdMQZQrElErg/VW1IGTWZZzC5mvAM/UVUJSWxKxqwNqLblVDTLr7CQCZ1vwGZUJAIKK3ANwUf7KVJhdJMnmJB3M6L95CU8yljYEZyBsxjxYuNuLOGlxg6dugRW01oIS5HQrqbCokZDwsKOoPx06Zm8xLyqvtU7YaZ2D14vvbNlv4n7LCEkcKPB/QIs7AiGXLcr4DDa34hnLsIN+zR8cYOPs1fkQpDbiKO40ZAw3hEEC3YHXcGTcPGQ0ifb8ELoop8BwOf4BUayKqZ2BJ6oWYdSX4jz6CsPgpGd+FGA+Y5U8CdCNoapHYFP9yi/8i9Jlgm5NuUnZCWM6gg80aE5KMpfHC/5JteFUeTIhD4BPIzvJ5aVMKoj8CQLLfE94w5Wv9Q1W3zmjUxomnj/sKyEER1BoHhu/TlSDkLj4Oi+aZxkQtb6mvIoY9kEDKulx0woDcyIpckAJPwM8GKM/QbpJit+ejHNjgAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\frac{x}{x^{2} - 3} + \\frac{x - 1}{x^{2} + 3} + \\frac{1}{x + 3}$$"
      ],
      "text/plain": [
       "  x      x - 1      1  \n",
       "────── + ────── + ─────\n",
       " 2        2       x + 3\n",
       "x  - 3   x  + 3        "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apart((1 / (x + 3)) + (x / (x**2 - 3)) + ((x - 1) / (x**2 + 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trigonometric functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sympy` package can both simplify and expand trigonometric function.  One of the most common trigonometric identity is shown in equation (5)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$${\\left( \\sin{\\theta} \\right)}^2 + {\\left( \\cos{\\theta} \\right)}^2 = 1 \\tag{5}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we have to learn how to create the mathematical variable $\\theta$.  This is done using the same `symbol()` function that we are now familiar with.  First we have to create a computer variable to hold the symbol, just as we did with the mathematical symbol $x$ being held in the computer variable `x`, i.e. `x = symbols('x')`.  It is common just to use the written word for the Greek symbols."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `symbols()` function recognizes special characters.  The Greek alphabet is included and hence we use the string `'theta'` as argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAPBAMAAAAv0UM9AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEGZURLuZMu/ddqvNiSJwwRR/AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAYElEQVQIHWNgYGBUZgACV+EEBgb2RoaPDAycCgyfGRg0GBg+MTBMY2D/zMDyhYHrCwP37907PjBwHmDgB6ILDPUGDPIGDBkMDPIODL8YGDgcuCYwMLAtePkAaGJWIgMDAFkWFM4t8HnwAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\theta$$"
      ],
      "text/plain": [
       "θ"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta = symbols('theta')\n",
    "theta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To show this identity in action, we use the `trigsimp()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import trigsimp, sin, cos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJsAAAAZBAMAAADUN0FsAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMnZUZs0Qu91E7yKJmaurDqYVAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAC6klEQVQ4EY2UXUgUURTH/7O646yjOyYE5YMOVBCUtVQQFMFib5W0EPtU1EJREpkiZZAUCxVBHzT10gdCQiH4IM1DlI8i+RC1sBj0UD0URA89mGQZW+Z2zv0YZlfd7cDce849v/ufc++duUCJ5S5kSuLKQTW6wY+nKiuEs1Vpyzf+hCdU9qvSlmcXKkuEs/9B18yFJ1Tzq9KWyxJ2EjB3Azs5qGCSxlNCjiUC2n4cTMkJ7wS1d4/mEfeDxJKOpM1eINa/K6CNeQ3X5oV3EDCGMQez8jkrOkovbck4mcX0IG6THmNWErPAhHrPFv2+kl7S6KTBy3ASAa0h48DWfvItet0e4AdwUmWWlFM0rlMBQ3CSmrZXqFn1xeIMuWP03IRB1UU9mVlSTtF2lgrIoy3BtLGmI/V8AStHmze5cirQTltbQIQ+wQZaNpuW6379BubERg/N29bJDBAh5qGHzR7TdIhZHAauunbwQ5wB4gvTX6nQ2pScpOTsR2jxV/noo8O0tFxdEvg2Pf1E0A8ycHEROC/2SiKXqPoUHJKqycoRJRdNYUfTDaBt9TAiMkNoArgC/BS09WsDWO4s8F0DI4AzzpsBY4bGJtPpa+k0rQA9eRqiLXXGb/X5mq73gHkxTLQ5Wcyz3LlSuZ4E3hEv5KhX1bW5VAJtqdN76sjfkJw5i8YhQT9DbaFcjhbb44liY1k5SckF1b3PYD8VJYwWaxbguHR+WdwBPpfL0VHUe5EswWVHQXuHxCjt3X0X8STl2fgoRrCePKLpKAZ4peHF5oBGd4w3p3GcGjJVHf3cDX5LEw7FhlHHeTb+mKZs+paZHuzY57UWv7QWP23//ZGzZPfoPpl6y160idtADqenXsH+kPNiL9a+lBmxRHS3ZyjUtM6onn8yaV2qV9Xp4dKeCxOmaR2rXt0UFOkr4HgZURJ26kjTOtb9gHIWXzmaCPd6F5el+fpk06CMlmv5+mRblraTIo+9sqvW8uVORvQ/Mm++OJzPUpIAAAAASUVORK5CYII=",
      "text/latex": [
       "$$\\sin^{2}{\\left (\\theta \\right )} + \\cos^{2}{\\left (\\theta \\right )}$$"
      ],
      "text/plain": [
       "   2         2   \n",
       "sin (θ) + cos (θ)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Expression\n",
    "(sin(theta))**2 + (cos(theta))**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAPBAMAAAArJJMAAAAAIVBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADdcGRXAAAACnRSTlMAVO8Qq4lmdpnNpXqjvAAAAAlwSFlzAAAOxAAADsQBlSsOGwAAACBJREFUCB1jYAADRmUGBpOQxUA2GykEO1Axh9PKNrAZAEESCWTnoGnkAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$1$$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Trigonometric simplification\n",
    "trigsimp((sin(theta))**2 + (cos(theta))**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trigonometric expansion is just as easy with `expand_trig()`.  We will do this for the trigonometric identity in (6)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\sin( \\theta + \\phi ) = \\sin(\\phi) \\cos(\\theta) + \\sin(\\theta) \\cos(\\phi) \\tag{6}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAAsAAAATBAMAAAC0B+rjAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIol2RDKZVBBmzbur3e/pYyZZAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAYElEQVQIHWNgYGBgBGIgYEKhmCE8VwilAKJYHRMLgVQ6xwQuAQbuCZwCTAcY5gK1sV1g2AakuA4wvGSQZJAvYFjMMBEowuDLoMCdANSWuTkVpJ1xAohk4BQAU1DbOEEcABQRDZo083dzAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\phi$$"
      ],
      "text/plain": [
       "φ"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating phi\n",
    "phi = symbols('phi')\n",
    "phi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import expand_trig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAAUBAMAAAB2RTUoAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMnZUZs0Qu91E7yKJmaurDqYVAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADbUlEQVRIDX1WTWgTQRh92ybbtEmtCl48tEEvglZzUxAxFAShFqoQUATJQVFEQcQfsCgBFQ+9RE9FBVuohyJiD0WlIIaCB9FC/bmIPUQQL2L9qVKqrfV9M5Od6WbXOcx88703732Zmd0NEG5jkkgD28OAmQt+OBcLB6sMr3E0yLhBOi8zxyY9bGH/lMQZYEX0YsGbz+2IhMM6wsNnq+1ER1Xs2HgLFk0qa4J+r006keBri23FKDisIzwccRbb8KAKY2x6FNjAfsKucCLBr6AtF8CNWQe1YcDLROGJKcWMselX4HX2x1UU7ognBtGWD+CYGgKePxiW4DyldhuOTXpVQEuXVFhhnyyrcHkneGoKHbkAdmoI6WgeDixXULPHOlfhQBtvfVfvo79Yc3/15iwzDbJJ3q33fCoyEvrTkzmcWPdc8Qx+p4wtZQ0zY2qI0NE8TEbIdDJnbXhBSzgEXMum/zDflGf3xs/z6iV6GY7nvHteP5qyiqfxrzMzD3giArOZGiJ0NA+7SArLnJGVgc3NIrK4BFwAfjKfyolPYjRTRWOJ8wIah1IVeN8VT+NXgV/0FpjN1BCho3nYRlJY5jJz1iY1txFSw1ngB4GWMrCbr4fWErxvPIpF5nj4WFA8jS/Am+VOEkamUNh/t1Cosrh6Hc1DR4TMCNdaG//Z0pTUcN7WcJE1JKvKxJO6drKuOcVTNfizaB00NRA1+1CvY3hSQ52M1GBtHiIx79QgZzGMMTzNobnk/IBFxVNn4c+jLcuXJWFppoZ6HcPDQISMnIW1uQF8dGqQO7kP3SxSX7oCTVqm4M0rnr6TI9hAidCdjNDRPHUnwzJyJ60N71KfHIQ5C3kgB1Bp4tBaIXE8jxfeEJIVxdMP7Os0X0Aa5mjvZFhH8zAdISPPq7W53bWn3L70qX3pw9bfVb3D3tvTr8hJrmTnf9k0iicv30F4nMsJnOwsMlIwR1NDhI7mYS9JYRmeD1wbTp0mP1F/WI85WRsKrloNNjXU0rUx4PmlWsoZ1bs61qaHzMSo0CecNTYUXLUa7BdNYvkQ8DLZ5YCaqW9WrE0T/flJ5fb1RqzlpVT1xcLBmhov5tvdR2KsjfxHSYhSIBLIqkBwaTGwBtnXeLzxUY2v9v/YyH8wad16qOsNHgcHfMPTGx5ka4G+C5xR5x9dczpt0NNC3AAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\sin{\\left (\\phi \\right )} \\cos{\\left (\\theta \\right )} + \\sin{\\left (\\theta \\right )} \\cos{\\left (\\phi \\right )}$$"
      ],
      "text/plain": [
       "sin(φ)⋅cos(θ) + sin(θ)⋅cos(φ)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(sin(theta + phi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Powers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The common properties of powers do not always hold.  In (7) below, are the common (non-exclusive) conditions for the properties of powers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{align}&x^a x^b = x^{a+b}, \\forall a, b, x \\in \\mathbb{C} \\\\\n",
    "&x^a y^a = \\left( xy \\right)^a, \\forall x, y > 0, \\forall a \\in \\mathbb{R} \\\\\n",
    "&\\left( x^a \\right)^b = x^{ab}, \\forall b \\in \\mathbb{Z} \\end{align}  \\tag{7}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `sympy` package will only calculate powers when they are true in general.  By default all mathematical symbols in `sympy` are complex.  When mathematical symbols are declared with the `symbols()` function, we can specify their type, i.e. real or positive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specifying the type of values that a mathematical symbol can hold\n",
    "x, y = symbols('x y',\n",
    "              positive = True)\n",
    "a, b = symbols('a b',\n",
    "              real = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use these mathematical symbols with the `powersimp()` function.  Below we import the function and look at the power properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import powsimp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAAUBAMAAADiqgm2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAtklEQVQYGWNgQAesM9FFwPxcrKJzsIp+QYjKKs+Gcrg/KQtAmYzd3B+hTKZGpgtQJu8F7gYok0uBfQKUyXeAyQDGDOCFMeUduAoFIML8AnwHYAoc9odDmRwCVVAWA6vRoetQNrdZApAlpOyqpgARQTAZE9ibOCCWIjHZBNg+sjqA1SIxGRm4FkD0MyAxGRj4FaCiKMz9G+CicCaPgD4DE8QDSMz4A+sZ3CGKkZjCSkLXCyCiCCYA/U4lQDxORC4AAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{a} x^{b}$$"
      ],
      "text/plain": [
       " a  b\n",
       "x ⋅x "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = x**a * x**b  # Overwriting the computer variable expr\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAAUBAMAAADiqgm2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAyklEQVQYGWNgQAesM9FFwPxcdFFmkMAcdFEukMAXhKis8mwgByTK/UlZACrO2M39ESrK1Mh0ASrKe4G7ASrKpcA+ASrKd4DJgMFy5ryZMwv4AngNoKLyDlyFQNNA5vIL8B2AqXXYHw5kgkQ5BKqgggysRoeuQ0W5zRKALCFlVzUFIA0CYPeCGIwJ7E0cMEvhomwCbB9ZHUDyQMACoYBqGbgWwNjINL8CMg/G3r8BxkLQPAL6DExAD6CC+APrGdxRhYA8YSWh6wXoogBHVB7WUPozhQAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$x^{a + b}$$"
      ],
      "text/plain": [
       " a + b\n",
       "x     "
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powsimp(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACoAAAAUBAMAAAAJnbK1AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA6UlEQVQYGWNggABZ5dlQFuMlyw0wZjf3RyhTYsN+ASiT9wJ3A5R5l2EHlMXAd4DJAMp+w6AME5V34CqE6GP8wrBcECrM57A/HMp8wv21AMpkNTp0HcoM1tEFigopu6opgEUYdRUY/KDmJLA3cUwAi7KxPmDQh+hgE2D7yOoAZvvwTmBYBRFlZOBaAGExCPApMHyCshn4FWCseAHu3zD2/g0w1k0GpgcQNo+APgMTxGKGxQxcBhDR+APrGdyhii8zxBdAmMJKQtehTAZhpfsOUAUo1E0UHpjDPIHxK6YoRwGXAqYoq9JtqCAAuKEtbRldVLMAAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{a} y^{a}$$"
      ],
      "text/plain": [
       " a  a\n",
       "x ⋅y "
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = x**a * y**a  # Overwriting the computer variable expr\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC4AAAAXBAMAAACG4mBhAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAImYQu82Z3XZU70SJqzJu81j5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABJ0lEQVQoFW2RPUvDUBSGnzbpl0lrcBF1uf6DCwotgqDFVYz/oAgVFz9G3TKFCpbqP6ijuLg5STuJo4t7NscqLkJBPO0NiaG+wznnfQjn5Z7ArKyjt2iWQj0a6f/4Ie+Cc0pKohuZ7uhKXU/YZKh6WJ8012A/wy0fbmtjRb6V4bzA02WoKHlZvhHbxSym8GBAKK3RXbkKrDBgWeO2DG+CNcyfl3zX6dODvARPdAGudr8cb6noswOVM8Pv5XvsLdBzAd9Q+0g4zAdiBrr2k3LZA6NISptyH5x4j+RWdI+yZhf7Nc19lgXXeyzAMQMFxSFTPcJmp3GgJu3Ug0Jk+N87tAXVDU7vVvWtsTC5m9F23EvKDuQtfmyT/+J0TgTZEmGUU/Ewbaux+QWHYzfEBCnNggAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\left(x y\\right)^{a}$$"
      ],
      "text/plain": [
       "     a\n",
       "(x⋅y) "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powsimp(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAUBAMAAABscEDKAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAnUlEQVQYGWNgQIDICQg2kMV2AYXLeQCFy+8A58oqz2bYr2QI5TN2c39k0BDQhXJ5L3A3MCxiqIRy+Q4wGTA8ZbgM5co7cBUKfGR4A5N12B/O0Mi+AMplNTp0nWFzGpAnpOyqpgAVZWBgTGBv4kA4lk2A7SOrA0KWgWsBnANi8CugcPdvQOLyCOgzMAnABeIPrGdwh/MYhJWErhfAuQC31B4Gv854bAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$x^{a b}$$"
      ],
      "text/plain": [
       " a⋅b\n",
       "x   "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = (x**a)**b  # Overwriting the computer variable expr\n",
    "expr  # Automatically simplified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAUBAMAAABscEDKAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAnUlEQVQYGWNgQIDICQg2kMV2AYXLeQCFy+8A58oqz2bYr2QI5TN2c39k0BDQhXJ5L3A3MCxiqIRy+Q4wGTA8ZbgM5co7cBUKfGR4A5N12B/O0Mi+AMplNTp0nWFzGpAnpOyqpgAVZWBgTGBv4kA4lk2A7SOrA0KWgWsBnANi8CugcPdvQOLyCOgzMAnABeIPrGdwh/MYhJWErhfAuQC31B4Gv854bAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$x^{a b}$$"
      ],
      "text/plain": [
       " a⋅b\n",
       "x   "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powsimp(expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the the complex number values that variables can hold does not allow for the use of the properties of powers, the simplification is not performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "m, n, c = symbols(' m n c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC8AAAAQBAMAAAB0JTvnAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARImrInYyuxBU793NZplSrWBsAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA8ElEQVQYGWNggAOm0AAYWzUUxgLRG9kWQLncAllQFojiK2BIgHKfM7BBWSCKawKcsxLOAjH4HeDcL3AWiMEjwPAAKnCQgQ/KAlEsT682QLl+sREMDIzKLqGmbKqGEDEhE9c4qKOZ2EsZ+gMZZkEkFMoDOKA2ZHIfYPBXYLgPlmCbsIeB5RtETUO/AMP8BgZzMI+D4yMD7weIBMN8BobXDAxLITzODwzMB6ASbxgYNjEwfuEAc/kOMPBfaIDILGIA6uc74AnmcSkAzVUAM1k+MgD18yhAeP4CDDq8CWAJxg0MrA8YON86gHnSDAzON8EsAA3jMAFqthX7AAAAAElFTkSuQmCC",
      "text/latex": [
       "$$m^{c} n^{c}$$"
      ],
      "text/plain": [
       " c  c\n",
       "m ⋅n "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr = m**c * n**c  # Overwriting the computer variable expr\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAC8AAAAQBAMAAAB0JTvnAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMARImrInYyuxBU793NZplSrWBsAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA8ElEQVQYGWNggAOm0AAYWzUUxgLRG9kWQLncAllQFojiK2BIgHKfM7BBWSCKawKcsxLOAjH4HeDcL3AWiMEjwPAAKnCQgQ/KAlEsT682QLl+sREMDIzKLqGmbKqGEDEhE9c4qKOZ2EsZ+gMZZkEkFMoDOKA2ZHIfYPBXYLgPlmCbsIeB5RtETUO/AMP8BgZzMI+D4yMD7weIBMN8BobXDAxLITzODwzMB6ASbxgYNjEwfuEAc/kOMPBfaIDILGIA6uc74AnmcSkAzVUAM1k+MgD18yhAeP4CDDq8CWAJxg0MrA8YON86gHnSDAzON8EsAA3jMAFqthX7AAAAAElFTkSuQmCC",
      "text/latex": [
       "$$m^{c} n^{c}$$"
      ],
      "text/plain": [
       " c  c\n",
       "m ⋅n "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powsimp(expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of this might be $m=n=-1, a = \\frac{1}{2}$.\n",
    "$$\\begin{align} \\left( -1 \\right)^{\\frac{1}{2}}\\left( -1 \\right)^{\\frac{1}{2}} &= \\left( -1 \\times -1 \\right)^{\\frac{1}{1}} \\\\ i \\cdot i &= 1^{\\frac{1}{2}} \\\\ -1 &\\ne \\pm 1 \\end{align}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The argument `force = True` can be added to the `powsimp()` function irrespective of having defined the type of mathematical variable.  This is useful if you know that you want to make the simplification an understand the mathematical constraints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADUAAAAXBAMAAABZrBp+AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAImYQu82Z3XZU70SJqzJu81j5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABIUlEQVQoFXWRMUjDUBCGvzS1NSSUuihOdnG1HXQuOjnGuSBFFB0cugoOolAKLm6CSx0VHbq5ZpIuDopCoYurLlodu3h5uZKUmBve++//7t473oOM6HcyABR7n5lsl5IwqyJLMpyyZLfGWU36Rj/LOjJqK8XWxGlQgFwzxbwTmD89k4HC06fDvtZ8Ydo3WUO9NrhPc51BqT804kD8R2Ub4OU3qZ9zFQm5Y1nZEXwUfZYCqpF4h0tld1Cr9+jWeDWiKv5XzOjCPtwQircEkzPZg2PckR2KHxsetE9m4R57TMFfFOH8evEsMq81xvlmJghEeP4KHGqf9LstZps4O2UR1ssFbCv7781ayjLeOqLrWhRv4R9Fkf7buNqqaNFky01+7Q+1Lzn8czuuEAAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$\\left(m n\\right)^{c}$$"
      ],
      "text/plain": [
       "     c\n",
       "(m⋅n) "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powsimp(expr,\n",
    "       force = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as an aside, the square root function, `sqrt(x)` in `sympy` is actuall shorthand syntax for `x**Rational(1,2)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import sqrt, Rational"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(x) == x**Rational(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `expand_power_exp()` and the `expand_power_base()` functions expand power expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import expand_power_exp, expand_power_base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In expression (8) and (9) we expand using the properties of powers.  If these functions fail to expand the expression that you are working on, remember the mathematical constraints  or use the `force = True` argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$x^{ a + b} \\tag{8}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACkAAAAUBAMAAADiqgm2AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAtklEQVQYGWNgQAesM9FFwPxcrKJzsIp+QYjKKs+Gcrg/KQtAmYzd3B+hTKZGpgtQJu8F7gYok0uBfQKUyXeAyQDGDOCFMeUduAoFIML8AnwHYAoc9odDmRwCVVAWA6vRoetQNrdZApAlpOyqpgARQTAZE9ibOCCWIjHZBNg+sjqA1SIxGRm4FkD0MyAxGRj4FaCiKMz9G+CicCaPgD4DE8QDSMz4A+sZ3CGKkZjCSkLXCyCiCCYA/U4lQDxORC4AAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{a} x^{b}$$"
      ],
      "text/plain": [
       " a  b\n",
       "x ⋅x "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_power_exp(x**(a + b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\left( xy \\right)^{a} \\tag{9}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACoAAAAUBAMAAAAJnbK1AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA6UlEQVQYGWNggABZ5dlQFuMlyw0wZjf3RyhTYsN+ASiT9wJ3A5R5l2EHlMXAd4DJAMp+w6AME5V34CqE6GP8wrBcECrM57A/HMp8wv21AMpkNTp0HcoM1tEFigopu6opgEUYdRUY/KDmJLA3cUwAi7KxPmDQh+hgE2D7yOoAZvvwTmBYBRFlZOBaAGExCPApMHyCshn4FWCseAHu3zD2/g0w1k0GpgcQNo+APgMTxGKGxQxcBhDR+APrGdyhii8zxBdAmMJKQtehTAZhpfsOUAUo1E0UHpjDPIHxK6YoRwGXAqYoq9JtqCAAuKEtbRldVLMAAAAASUVORK5CYII=",
      "text/latex": [
       "$$x^{a} y^{a}$$"
      ],
      "text/plain": [
       " a  a\n",
       "x ⋅y "
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_power_base((x*y)**a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logarithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `log()` function in `sympy` calculates the natural logarithm by default.  The latter uses Euler's number as base.  In general the properties shown in (10) below will hold for all positive real numbers and real exponents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{align} &\\log{ x y } = \\log{x} + \\log{y} \\\\ &\\log{x^n} = n \\log{x}, \\forall x, y \\in \\mathbb{R}, > 0 \\end{align} \\tag{10}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ovewrtiting the computer variable that hold the mathematical variables\n",
    "# Specifying the values that each can hold\n",
    "x, y = symbols('x y',\n",
    "               positive = True)\n",
    "n = symbols('n',\n",
    "           real = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `expand_log()` will expand expression according to the properties of logarithms given in (10) above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import expand_log, log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIsAAAAUBAMAAABPB9NaAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2RN1UmWaBK2/dAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACE0lEQVQ4EXWUv2sUQRTHv3uXzd7t5YLmH0jKhDSHZyE2HhiLCIdLiKZIc7GUVNuYQmQrGyNskSBbHB5WikUCgiiEkCYkVp6mS5PrNATkDoxiMMT3dmZuNrO3A7Pv1+d92Xn7AzBXoSMz+2bFjBXJ4Nh1o7qg4lygPGEzSQbth5dh3FCxXVGesJlkDPqX4dF2P56V3mdpM0kGjWIpkE3AA+llyGiSQUPmeV8F+ZbwM2Q0ySDJzEd3gdf145fU1qRtR5Nv6UaH5PkSMgZpN0M882LQh/URTuieYrtIEk9pz+MkfA+MyhlrGZMccht4JUAfpRqsXm4T06SALdp3cM97A4xscgLQMia5Wq7gsQB9jO8Av8oNIfOI+jyuAVaXLrer1Q/V6jWO06Q3HOKvAH18aQF/Cj17mVmWAdekDFl9Nylyw7N6Sobv5rywthZQS3woOiO7bupQKfIAxYYAfQy3YZ2NtLhTjHi32MX6oBGnSB/OhBqxtYR8zb15NWCZOon/c7r82ZVrnEgeyiTxDRudGBy7mMSLmUPg1sXvNvW8o9dmar35k9z8FbrQkrMZQGIuOgo0SKyzY69+IqtfcSxSyEuNWEQGeUBZBZK7R/s77QGf5n1KJ1aCzFXsM6rM6uoineAJhysqZ/4oVD5BljpOSEOoqBL5M1E9nkX/t+UEupr0EqQbfaXKQJCfUbx+SJtpFEngf3kZqjB0Fw+2AAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\log{\\left (x \\right )} + \\log{\\left (y \\right )}$$"
      ],
      "text/plain": [
       "log(x) + log(y)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_log(log(x * y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABQAAAAUBAMAAAB/pwA+AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAEHarIkSJZt3NuzJUme9mZ+xlAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAfElEQVQIHWNggIDctQJQFpsD8wQok8OB+wuMGcDyFcpkYOD5CGdyKMCZuXAW+wU4M4whGsrmnnNmIZTJ9///BwYGIWVXNQWwCGMCexMHxFI2AbaPrA4QUQauBWAGiOBXgDP3b4AyeQT0GZgEwJz4A+sZ3CHCwkpC1wvATAAiEBajWZbtCwAAAABJRU5ErkJggg==",
      "text/latex": [
       "$$x^{2}$$"
      ],
      "text/plain": [
       " 2\n",
       "x "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_log(x**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division of two positive real numbers, $\\frac{x}{y}$, is simply a special case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{align} \\log{\\frac{x}{y}} &= \\log{x \\frac{1}{y}} \\\\ &= \\log{x y^{-1}} \\\\ &= \\log{x} + \\log{y^{-1}} \\\\ &= \\log{x} - \\log{y} \\end{align}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIsAAAAUBAMAAABPB9NaAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2RN1UmWaBK2/dAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACBElEQVQ4EX2Uv0/bUBDHv04wThyCKP8AjFRdUpWh6tIMMFApwqIIBpa0Y9XJSztUyBMLVPIAqjxEREwgBpC6FAkhFkQ3Amxdmq2tKlWJ1BaBWtE7Pz//eLZ70vP73t3nnf3OfgZUK3WDyEc1o/qSZHB0UskuSr/gSCXmXJJB/XkSxkPp6zWpxJxL+qCdhIc7oT8TKiFySQaVZMUJFy+ESohckkEluRqtLbYjzSqXZJCS894TYKvx7R2xLRq6N7FDDzoQ7Y+CWaTecrFi+aAN7QMM1/yFozKxyzTm8d19DwwrPU6TA2YTmwK0UalD6xf2cY9veUhjGrPWNjC0z4HI0uRatYZXArQxdgz8rDZFmRe0zOIcoPXo8vQB233206Q16OJagDbO2sBVqa+/ZJbLgHNBGRaBZZB7ltaXZfhp/pbW1x3GeVO0R76aqU2lyEuUmwK0MdiBdjPU5pWixSflHjayWpwibRjjssXaMxTr5qM7DpdpUPE/Ro+PXbXOgcjoTSkkLrDX9cHR2wm8nfoEPL793aElu/TZ3N1o/SBZHIlKkMogMed9dhKgcayvHRAcOwxLiSqhkyQvKR4DT8n9QuM/RzMoFCMLNf2GojNBhqYl2sEbdl/LmPqjkPEYWekaLjWhJlOkp7yG34vwt2U4UTauYqTpnVMmE+R35NvXYM6dJEngP2hhn/vXejhTAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\log{\\left (x \\right )} - \\log{\\left (y \\right )}$$"
      ],
      "text/plain": [
       "log(x) - log(y)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_log(log(x / y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `logcombine()` function will simplify our expression according to the properties in (10)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import logcombine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEMAAAAUBAMAAAAkb50PAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2RN1UmWaBK2/dAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABi0lEQVQoFWVSv0tCURg9T30+ff6o/AdsDFre0BAtObgYCA+JQlysMRrCpYaoNzWUxSOEeIMorQ06JkS41Zbl1lBu1ZaQRULYuf7Klx98937nfIfv3PfuBf6HpzHK3BKE5kYZ1qs27DAAed1GAfM2LGuEGRuFYM2OY+MSn2GXrIxLjuwKOItdo2VrCTiPv52xnWcmTw9zppw3caDDReMMpEsoptrCtZftPX5BJFjxaS41jQIQ5Hkz8EUgNR1lzFKBK8Clu1qqkQ1o2Ab8ZSEJV4GPQLon2eAUKFuA7jbxDUjvQnJXBL48TXlTTKEEmDC5lHSpOZCIKT+eXM4gL4yA8CSXOrxpQC2LKe4apLa/SJbB4/r1Arw6G8r04LjSGpwRdWHKEJI4Har7OAEeUGoAgQhCnRkcRx+Bxc5njZILIGEln9hMWM8G4BSevVCqcrbCcvQC6sSpfp/bDfOFObxGhya3iWPMfqQ4cFfUO33C11BM/iOtD7nJUSvetR08KdW6J60Yf5JhZX+Yr8AvbQNe4D5f9CMAAAAASUVORK5CYII=",
      "text/latex": [
       "$$\\log{\\left (x y \\right )}$$"
      ],
      "text/plain": [
       "log(x⋅y)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logcombine(log(x) + log(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEMAAAAVBAMAAADvM06qAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMqvNiRDvuyJ2RN1UmWaBK2/dAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABiUlEQVQoFXWSPUhCURTH/89vn/ostyYbi5aGhmjJwaVAeEQU4pKN0RBODVFvaekLCSEkImlwacgxI8Km2nJoapC3VZtCFgRh57x7b4bigXfPPf/zu+ecx73AIDMaI2cDcgFbJIyy7bPwSEFsqgddlvHuKaImXBbgXe1BplU8jjKlJynMKUl4o67iLJ41YK4fCVkSCTRxcw8s9SP7koA+ioINuEtOo8XiPHCRej+hNP9o+nivkCfP5qHGOWjX8Of1Nu6CJG3TiAmjGuIx2Qza5BBKQGu5Kphg6ZYOmp62bnFAFq4wEq8BH5EVgaxRFfg3nDQvWpORpxLwFWh511kiBIjmeXVMIFzlJ1AoWKxRIyA+xKtjeoWr+OrQvsMlIdG4YfMcQVOEclwtC3dCnxm2WE0BV7UdHEkCkQRinTEcJl+A2c5nnfRLYKGYbtgKcXd7+mvegyrpfxcgmYxigQfavtLXvUaR42uUlqGCW7zfVIrjnccgFW+ymHLaqicldL8l8/+dephCewN+AVKsVpJbfXKlAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$\\log{\\left (x^{n} \\right )}$$"
      ],
      "text/plain": [
       "   ⎛ n⎞\n",
       "log⎝x ⎠"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logcombine(n * log(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Binomial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The binomial coefficient function, `binomial()` calculates the number of ways to choose $k$ items from a set of $n$ distinct items, where order does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import binomial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We choose natural numbers as the binomial function pertains to discrete objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, k = symbols('n k', positive = True, integer = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACMAAAAyBAMAAAAkfX9UAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAiUR2q1TvELuZ3WYiMs0DCV8EAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABuUlEQVQoFW2Tv0vDQBTHv/2ZNGmb+A/YuLo0mxaEFlwFM3VwSRUHEYSAHQSHdhSnTl3bwcVFXARdbEF3+x80q1upFAct+N7dJSXFG9597nP33l2SC0At5VCg1pYdxw2F6VABMo2IXiNoRgDdlqidxCpCvRcrqAQ/WClDZt6T2Tp4q7nU53552uRo37iaGPE8jC5Q8h5QXPJoxFWmDqBpc5gzVh1O7zPlZsiGDGWOp0yFENYj52SoYumHVd6GH9gERRqyBj4cbJoTJkrSWwzbwPsTA24ppSsoDhXatRePBIwmmLpJRWPfSyrKooWJZjVQHycMrC4qQVLlQwzW1RCHyUUwWv+p9URjiMrajlS+vnaufAMjJ1nf6sGX6upczXRsTB8lfypFj00LRVsoRa/BCAWnv5WiExRmglNDpehpTDld7uVexmzP6KPJIh1vr8obFb8oiE8L/zK45kXiGw6Y0Fcb60MaVB0KuNt1uYPFncHz2rw4Z4N6QEFsac60RYqVrHxMlO1iyUpeTLoydDM81HZIlblK3Alucik63YXoOES/Ao5ilZV5dCsbkXuOAPuKVj8fCo50bVH8D5PgZiQtKrDLAAAAAElFTkSuQmCC",
      "text/latex": [
       "$${\\binom{n}{k}}$$"
      ],
      "text/plain": [
       "⎛n⎞\n",
       "⎜ ⎟\n",
       "⎝k⎠"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(n, k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can substitute values using the `.evalf()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABoAAAAOBAMAAADDIxFwAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAiXYyEM1Embsi72bdVKu+2mc6AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAApUlEQVQIHT3OsQnCUBDG8f8jkgReYiROoK2NK1jYBCEBSxEcITbWdrZu4CscxAWUjBDJAipREAl4z4BXHPz4jrsD4sEYKTXqS5+uvMxqyWwPO/ytQBtUhvu2AfglYY1vfiAqcRuiebyxTnPcB+mCoBAdejiiG97RKse5E53Qr/9kkKE/ItkSNnRNm8lRXePUeEay9jpXkqLzhDOJ/KvWFVxgMqz4Amh1KHMCq7PxAAAAAElFTkSuQmCC",
      "text/latex": [
       "$$6.0$$"
      ],
      "text/plain": [
       "6.00000000000000"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(n, k).evalf(subs = {n:4, k:2})"
   ]
  },
  {
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}