{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide_input": true,
    "scrolled": true,
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:70% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "from IPython.display import display\n",
    "\n",
    "display(HTML(\"<style>.container { width:70% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide_input": true,
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np, scipy, scipy.stats as stats, pandas as pd, matplotlib.pyplot as plt, seaborn as sns\n",
    "import statsmodels, statsmodels.api as sm\n",
    "import sympy, sympy.stats\n",
    "import pymc3 as pm\n",
    "import daft\n",
    "\n",
    "pd.set_option('display.max_columns', 500)\n",
    "pd.set_option('display.width', 1000)\n",
    "# pd.set_option('display.float_format', lambda x: '%.2f' % x)\n",
    "np.set_printoptions(edgeitems=10)\n",
    "np.set_printoptions(linewidth=1000)\n",
    "np.set_printoptions(suppress=True)\n",
    "np.core.arrayprint._line_width = 180\n",
    "\n",
    "SEED = 42\n",
    "np.random.seed(SEED)\n",
    "\n",
    "sns.set()\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This blog post is part of the [Series: Monte Carlo Methods](https://weisser-zwerg.dev/posts/series-monte-carlo-methods/).\n",
    "\n",
    "You can find this blog post on [weisser-zwerg.dev](https://weisser-zwerg.dev/posts/monte-carlo-fundamental-concepts/) or on [github](https://github.com/cs224/blog-series-monte-carlo-methods) as either [html](https://rawcdn.githack.com/cs224/blog-series-monte-carlo-methods/main/0010-fundamental-concepts.html) or via [nbviewer](https://nbviewer.jupyter.org/github/cs224/blog-series-monte-carlo-methods/blob/main/0010-fundamental-concepts.ipynb?flush_cache=true)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monte Carlo Fundamental Concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Boundary-between-statistics-and-machine-learning-/-AI\" data-toc-modified-id=\"Boundary-between-statistics-and-machine-learning-/-AI-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Boundary between statistics and machine learning / AI</a></span></li><li><span><a href=\"#Monte-Carlo-sampling-methodology\" data-toc-modified-id=\"Monte-Carlo-sampling-methodology-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Monte Carlo sampling methodology</a></span><ul class=\"toc-item\"><li><span><a href=\"#A-word-of-caution-about-the-picture-of-&quot;Bayes-updating&quot;\" data-toc-modified-id=\"A-word-of-caution-about-the-picture-of-&quot;Bayes-updating&quot;-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>A word of caution about the picture of \"Bayes updating\"</a></span></li></ul></li><li><span><a href=\"#Statistical-Models\" data-toc-modified-id=\"Statistical-Models-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Statistical Models</a></span><ul class=\"toc-item\"><li><span><a href=\"#Quality-of-a-model:--model-comparison,-model-selection,-model-averaging\" data-toc-modified-id=\"Quality-of-a-model:--model-comparison,-model-selection,-model-averaging-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Quality of a model:  model comparison, model selection, model averaging</a></span></li></ul></li><li><span><a href=\"#How-to-construct-models:-keep-the-Bayes'-theorem-and-the-law-of-total-probability-(extending-the-conversation)-always-in-mind\" data-toc-modified-id=\"How-to-construct-models:-keep-the-Bayes'-theorem-and-the-law-of-total-probability-(extending-the-conversation)-always-in-mind-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>How to construct models: keep the Bayes' theorem and the law of total probability (extending the conversation) always in mind</a></span><ul class=\"toc-item\"><li><span><a href=\"#Bayes'-theorem\" data-toc-modified-id=\"Bayes'-theorem-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Bayes' theorem</a></span></li><li><span><a href=\"#Law-of-total-probability-(extending-the-conversation)\" data-toc-modified-id=\"Law-of-total-probability-(extending-the-conversation)-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Law of total probability (extending the conversation)</a></span></li></ul></li><li><span><a href=\"#What-is-the-&quot;right&quot;-representation-of-(multi-dimensional)-probability-distributions?\" data-toc-modified-id=\"What-is-the-&quot;right&quot;-representation-of-(multi-dimensional)-probability-distributions?-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>What is the \"right\" representation of (multi-dimensional) probability distributions?</a></span></li><li><span><a href=\"#Operations-on-probability-distributions:-marginalization-and-conditional-probability\" data-toc-modified-id=\"Operations-on-probability-distributions:-marginalization-and-conditional-probability-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Operations on probability distributions: marginalization and conditional probability</a></span></li><li><span><a href=\"#Calculations-with-random-variables:-convolutions-and-other-nasty-stuff\" data-toc-modified-id=\"Calculations-with-random-variables:-convolutions-and-other-nasty-stuff-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Calculations with random variables: convolutions and other nasty stuff</a></span></li><li><span><a href=\"#Density-Estimation\" data-toc-modified-id=\"Density-Estimation-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Density Estimation</a></span></li><li><span><a href=\"#The-algorithm-has-to-always-perform-the-same-heavy-lifting:-there-is-no-ancestral-sampling\" data-toc-modified-id=\"The-algorithm-has-to-always-perform-the-same-heavy-lifting:-there-is-no-ancestral-sampling-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>The algorithm has to always perform the same heavy lifting: there is no ancestral sampling</a></span></li><li><span><a href=\"#Appendix\" data-toc-modified-id=\"Appendix-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Appendix</a></span><ul class=\"toc-item\"><li><span><a href=\"#Examples-of-mixed-discrete-continuous-probability-functions\" data-toc-modified-id=\"Examples-of-mixed-discrete-continuous-probability-functions-10.1\"><span class=\"toc-item-num\">10.1&nbsp;&nbsp;</span>Examples of mixed discrete continuous probability functions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Two-independent-coin-tosses\" data-toc-modified-id=\"Two-independent-coin-tosses-10.1.1\"><span class=\"toc-item-num\">10.1.1&nbsp;&nbsp;</span>Two independent coin tosses</a></span></li><li><span><a href=\"#Two-component-mixture-model\" data-toc-modified-id=\"Two-component-mixture-model-10.1.2\"><span class=\"toc-item-num\">10.1.2&nbsp;&nbsp;</span>Two component mixture model</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boundary between statistics and machine learning / AI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only very recently I found the work of 2010 [Turing Award](https://en.wikipedia.org/wiki/Turing_Award) winner [Leslie Valiant](https://en.wikipedia.org/wiki/Leslie_Valiant). In his book [Probably Approximately Correct](https://www.amazon.com/Probably-Approximately-Correct-Algorithms-Prospering/dp/0465060722/) he defines the two concepts **theoryful** and **theoryless**. This would be the place where I would draw the line between statistics and machine learning.\n",
    "\n",
    "Theoryful: a human has to provide a model and there may be some data that helps to tune the model. A good example would be Newtonian motion of the planets around the sun where Newton's laws provide the model and the data helps to pinpoint the [gravitational constant](https://en.wikipedia.org/wiki/Gravitational_constant).\n",
    "\n",
    "Theoryless: you take a very generic algorithm and a lot of data and the algorithm figures out the rest. A good example would be a [multilayer perceptron](https://en.wikipedia.org/wiki/Multilayer_perceptron) and pictures of objects, where the algorithm learns via data to identify the objects. The same multilayer perceptron architecture could be used to pilot a self-driving car."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monte Carlo sampling methodology"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general Monte Carlo sampling methodology relies on 2 ingredients:\n",
    "* The model (a total/joint probability density function)\n",
    "* A sampling algorithm, where there are in principle only 2 core building blocks:\n",
    "    * [Importance Sampling](https://en.wikipedia.org/wiki/Importance_sampling) and its variations / synonyms like Sequential Importance Sampling (SIS), Sequential Monte Carlo (SMC), Particle Filters, ...\n",
    "    * [Markov chain Monte Carlo (MCMC)](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo) and its variations like Metropolis-Hastings (MH), Hamiltonian (or Hybrid) Monte Carlo (HMC, NUTS), Gibbs sampling, ...\n",
    "\n",
    "The construction of sampling algorithms based on fine-grained composable abstractions\n",
    "([FCA](https://web.archive.org/web/20130117175652/http://blog.getprismatic.com/blog/2012/4/5/software-engineering-at-prismatic.html)) will be the main focus of this blog post series.\n",
    "\n",
    "In the case of Importance Sampling, you could argue that there is not only a single model, but a sequence of related models that form a \"bridge\" from something simple to the target model of interest. But we will get there in the course of this blog post series."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A word of caution about the picture of \"Bayes updating\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initially, when I started to read about the Bayesian method of statistics and its inference methodology, I often heard the term [Bayes updating](https://statswithr.github.io/book/the-basics-of-bayesian-statistics.html#bayes-updating). The picture that this terminology evoked in me was that there is a sequential process of taking a prior, a likelihood for a single event and then perform \"Bayes updating\" to receive the posterior, with that posterior becoming the new prior for the next data-point from where the process continuous until all data-items are consumed.\n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "d_i&\\in&\\{d_1, d_2, ..., d_N\\}\\\\\n",
    "p(d_1,\\theta)&=&p_0(\\theta)\\cdot p(d_1\\,|\\,\\theta)\\\\\n",
    "p(\\theta\\,|\\,d_1)&=&\\displaystyle \\frac{p(d_1,\\theta)}{\\int p(d_1,\\theta)\\,\\mathrm{d}\\theta}=p_1(\\theta)\\\\\n",
    "p(d_2,\\theta)&=&p_1(\\theta)\\cdot p(d_2\\,|\\,\\theta)\\\\\n",
    "p(\\theta\\,|\\,d_2)&=&\\displaystyle \\frac{p(d_2,\\theta)}{\\int p(d_2,\\theta)\\,\\mathrm{d}\\theta}=p_2(\\theta)\\\\\n",
    "&...&\\\\\n",
    "&=&p_N(\\theta)\n",
    "\\end{array}\n",
    "$\n",
    "\n",
    "While this picture is of course correct and is what you would do if you calculated the posterior manually by using (for example) [conjugate priors](https://en.wikipedia.org/wiki/Conjugate_prior), this picture prevented me from understanding what is going on in especially MCMC methods, but also in SMC methods and I found it much more useful to think of the model as the (immutable &ndash; without updating) total joint probability including all data-points, e.g.:\n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "p(d_1,d_2,...,d_N,\\theta)&=&p_0(\\theta)\\cdot p(d_1\\,|\\,\\theta)\\cdot p(d_2\\,|\\,\\theta)\\cdot ... \\cdot p(d_N\\,|\\,\\theta)\\\\\n",
    "\\end{array}\n",
    "$\n",
    "\n",
    "That is all you need for the main Monte Carlo sampling methods, because they only depend on an unnormalized probability density function and if you take $p(d_1=d_1,d_2=d_2,...,d_N=d_N,\\theta)$ (you simply take the total joint probability function and [partially apply](https://en.wikipedia.org/wiki/Partial_application) its data arguments so that you receive a function of the set of unknown parameters $\\theta$ alone, e.g. $f(\\theta)=p(d_1=d_1,d_2=d_2,...,d_N=d_N,\\theta)$) then you are ready to go, because $f(\\theta)\\propto p(\\theta\\,|\\,d_1=d_1,d_2=d_2,...,d_N=d_N)=\\frac{f(\\theta)}{Z}$ where $Z$ (the so called [partition function](https://en.wikipedia.org/wiki/Partition_function_(mathematics))) is independent from $\\theta$ and therefore a constant for the concrete data-set you're looking at."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistical Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In (Bayesian) statistics a model is basically a **total** [probability mass function](https://en.wikipedia.org/wiki/Probability_mass_function) (PMF; in the discrete case) or a [probability density function](https://en.wikipedia.org/wiki/Probability_density_function) (PDF; in the continuous case). It comes often in the form of a [probabilistic graphical model](https://en.wikipedia.org/wiki/Graphical_model) (PGM; also see [Bayesian hierarchical model](https://en.wikipedia.org/wiki/Bayesian_hierarchical_modeling)). As an example, you see below the graphical representation of multiple coin tosses using the same coin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 141.732x230.315 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pgm = daft.PGM(grid_unit=3.0, node_unit=1.5)\n",
    "\n",
    "pgm.add_node(\"theta\", r\"$\\theta$\", 0, 2)\n",
    "pgm.add_node(\"d\", r\"$d_i$\", 0, 1, observed=True)\n",
    "pgm.add_plate([-0.5, 0.5, 1.0, 1.0], label=r\"$i = 1, \\cdots, N$\")#, shift=-0.1\n",
    "\n",
    "pgm.add_edge(\"theta\", \"d\")\n",
    "\n",
    "pgm.render(dpi=100);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In standard mathematical notation this would be:\n",
    "\n",
    "$\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "p(\\theta) &=& \\mathrm{Beta}(\\alpha=1,\\beta=1) \\\\\n",
    "p(X_i=d_i\\,|\\,\\theta) &=& \\mathrm{Bernoulli}(X_i=d_i;p=\\theta) \\\\\n",
    "\\displaystyle p(X_1=d_1, X_2 = d_2, ..., X_n = d_n, \\theta)&=& \\displaystyle p(\\theta) \\cdot\\prod_{i=1}^N p(X_i=d_i\\,|\\,\\theta)\n",
    "\\end{array}\n",
    "$\n",
    "\n",
    "Where on the left hand side you have the total probability and on the right hand side you have the prior probability $p(\\theta)$ (here given as a [Beta distribution](https://en.wikipedia.org/wiki/Beta_distribution)) multiplied by the [conditional probabilities](https://en.wikipedia.org/wiki/Conditional_probability) $p(X_i=d_i\\,|\\,\\theta)$ (here given as a [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution)). The important point to remember is **YOU NEED THE TOTAL PROBABILITY FUNCTION**. How you get it does not matter. The total probability function is a **scalar function**, e.g. once you provide all arguments you get a scalar.\n",
    "\n",
    "For pure continuous probability density functions and pure discrete probability mass functions this is straight forward. In the pure continuous case you typically have a function like a product of Gauss/Normal:\n",
    "$f(x_1,x_2;\\mu,\\sigma)=\\frac{1}{\\sqrt{2\\pi}\\sigma}e^{-\\frac{1}{2}\\frac{(x_1-\\mu)^2}{\\sigma^2} }\\frac{1}{\\sqrt{2\\pi}\\sigma}e^{-\\frac{1}{2}\\frac{(x_2-\\mu)^2}{\\sigma^2} }$. In the pure discrete case, you get a multi-dimensional array like for two dice rolls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36}\\\\\\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36}\\\\\\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36}\\\\\\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36}\\\\\\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36}\\\\\\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36} & \\frac{1}{36}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1/36, 1/36, 1/36, 1/36, 1/36, 1/36],\n",
       "[1/36, 1/36, 1/36, 1/36, 1/36, 1/36],\n",
       "[1/36, 1/36, 1/36, 1/36, 1/36, 1/36],\n",
       "[1/36, 1/36, 1/36, 1/36, 1/36, 1/36],\n",
       "[1/36, 1/36, 1/36, 1/36, 1/36, 1/36],\n",
       "[1/36, 1/36, 1/36, 1/36, 1/36, 1/36]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = sympy.ones(6,6)/36\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For mixed cases I often got confused and therefore I elaborated two examples in painstaking detail in the appendix:\n",
    "* a model for [two independent coin tosses](#Two-independent-coin-tosses) and \n",
    "* a [two-component mixture model](#Two-component-mixture-model) with two observations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quality of a model:  model comparison, model selection, model averaging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this topic is beyond the scope of this blog post series, I nevertheless wanted to mention it. Once you have several models that are supposed to describe the same observations how do you then decide which model is actually the \"best\" model?\n",
    "\n",
    "The landmark rule is that a model is only as good as it is able to describe/predict future/unseen data-points. An approximation of that characteristic can be obtained via [cross-validation](https://en.wikipedia.org/wiki/Cross-validation_(statistics%29), where one variant is [leave-one-out cross-validation](https://en.wikipedia.org/wiki/Cross-validation_(statistics%29#Leave-one-out_cross-validation) (LOOCV). You can either apply this directly or use some approximation like an [information criterion](https://docs.displayr.com/wiki/Information_Criteria). In \"[Statistical Rethinking](https://www.amazon.com/-/de/dp/036713991X): A Bayesian Course with Examples in R and STAN\" in chapter 7. \"Ulysses' Compass\" Richard McElreath proposes to use [Pareto-Smoothed Importance Sampling Cross-Validation](https://arxiv.org/abs/1507.02646) (PSIS) or the [Widely Applicable Information Criterion](https://en.wikipedia.org/wiki/Watanabe%E2%80%93Akaike_information_criterion) (WAIC). He adds a word of caution, though: [Deviance](https://en.wikipedia.org/wiki/Deviance_(statistics%29) is an assessment of predictive accuracy, not of truth!\n",
    "\n",
    "John Kruschke proposes in \"[Doing Bayesian Data Analysis](https://www.amazon.com/-/de/dp/0124058884/): A Tutorial with R, JAGS, and Stan\" to use the [Bayes factor](https://en.wikipedia.org/wiki/Bayes_factor) (see for example my earlier blog post: [Model Comparison via Bayes Factor](https://weisser-zwerg.dev/posts/model-comparison-via-bayes-factor/)) or to create a mixture model out of the different competing (sub-)models and then simply apply the machinery of the Monte Carlo sampling methodology to get probabilities for each sub-model as $p_1, p_2, ..., p_M$. The idea then is to say that the model with the highest probability describes the data best. This approach is also the basis for [model averaging](https://en.wikipedia.org/wiki/Ensemble_learning#Bayesian_model_averaging) to create a new and better model by simply using this mixture model for your predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to construct models: keep the Bayes' theorem and the law of total probability (extending the conversation) always in mind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bayes' theorem "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "\\displaystyle\n",
    "p(x,y)=p(y|x)p(x)=p(x|y)p(y)\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how you typically construct ([generative](https://en.wikipedia.org/wiki/Generative_model)) models. You basically say: if I knew $x$ then knowing $y$ would be simple. Let's take a physical example like throwing a ball. In a vacuum the trajectory of the ball would be a parabola. Under realistic conditions you have wind and other disturbances. But if you say, if I know where the ball measured by location $x$ (a 3 dimensional vector) was at $t=t_0$ then I could tell where the ball would be at $t=t_1$: \n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "x_1& = & x_0+v(t_1-t_0)+(g/2)(t_1-t_0)^2+\\varepsilon_m;\\quad\\text{with }\\varepsilon_m\\sim\\mathcal{N}(0,\\sigma_m)\\\\\n",
    "\\Rightarrow p(x_1\\,|\\,x_0) & = &\\mathcal{N}(x_1; x_0+v(t_1-t_0)+(g/2)(t_1-t_0)^2,\\sigma_m)\n",
    "\\end{array}\n",
    "$\n",
    "\n",
    "If you then in addition say that at time $t_0$ the ball was roughly at $\\mu_0+\\varepsilon_l$ with $\\varepsilon_l\\sim\\mathcal{N}(0,\\sigma_l)$, e.g. $p(x_0) = \\mathcal{N}(x_0; \\mu_0,\\sigma_l)$ then you can tell the probability distribution of $p(x_1)$ by:\n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "p(x_0,x_1) &=& p(x_0)\\cdot p(x_1\\,|\\,x_0) = \\mathcal{N}(x_0; \\mu_0,\\sigma_l)\\cdot\\mathcal{N}(x_1; x_0+v(t_1-t_0)+(g/2)(t_1-t_0)^2,\\sigma_m)\\\\\n",
    "p(x_1)&=&\\int p(x_0,x_1)\\mathrm{d}x_0\n",
    "\\end{array}\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Law of total probability (extending the conversation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initially, when I saw the [law of total probability](https://en.wikipedia.org/wiki/Law_of_total_probability) for the first time I neglected it, because it looks like redundant to the Bayes' theorem:\n",
    "\n",
    "$\n",
    "p(x)=\\int p(x\\,|\\,y)\\cdot p(y)\\,\\mathrm{d}y\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I only learned to appreciate this law really when reading chapter 1.3.6 \"The Law of Total Probability\" in [Causal Inference in Statistics - A Primer](https://www.amazon.com/Causal-Inference-Statistics-Judea-Pearl/dp/1119186846) by Judea Pearl ([Turing Award](https://en.wikipedia.org/wiki/Turing_Award) winner 2011), Madelyn Glymour and Nicholas P. Jewell. There they also presented it under different synonymous names like \"the law of alternatives\" or \"extending the conversation\". In the book they call it \"conditionalizing on y\", but the term \"extending the conversation\" was what stuck with me.\n",
    "\n",
    "Sometimes you just don't know how to get to $p(x)$, but if you knew $y$ you also would know how to get to $x$, e.g. you know $p(x\\,|\\,y)$. You're \"extending the conversation\" to include $y$ in addition to $x$. And often getting to a $p(y)$ is also possible.\n",
    "\n",
    "It is basically the reverse idea from above in the example with the motion of the ball. If you just said I want to know $p(x_1)$ I would not know how to get there, but if you introduce $p(x_1\\,|\\,x_0)$ this opens up the path for a recursive calculation to the point where the ball was thrown and at that point you either know the position exactly, e.g. $p(x)=\\delta(x = x_\\text{start})$ (where the $\\delta$ is the [Dirac delta](https://en.wikipedia.org/wiki/Dirac_delta_function)) or you give it some uncertainty, e.g. $p(x)=\\mathcal{N}(x; x_\\text{start},\\sigma_l)$. Eitherway, you can construct a generative model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is the \"right\" representation of (multi-dimensional) probability distributions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is another point that took me some time to digest. The names like probability-density-function (PDF) or probability-mass-function (PMF) suggest a mathematical form like a function. The typical example is the Gauss bell shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x240 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 3), dpi=80, facecolor='w', edgecolor='k')\n",
    "ax = plt.subplot(1, 1, 1)\n",
    "x = np.linspace(-3.0,3.0,100)\n",
    "y = stats.norm(0,1).pdf(x)\n",
    "ax.plot(x,y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case the probability density function can be given as a mathematical function:\n",
    "\n",
    "$\\displaystyle\n",
    "\\frac{1}{\\sqrt{2\\pi}\\sigma}e^{- \\frac{\\left(x - \\mu\\right)^{2}}{2 \\sigma^{2}}}\n",
    "$\n",
    "\n",
    "But in most cases that is not possible. So what should you do then?\n",
    "\n",
    "I cannot remember anymore in which source I've read it, but the author said that for probability distributions the \"right\" representation might actually be collections of samples.\n",
    "\n",
    "Let's look at a toy example. We sample 1000 values from a normal distribution with mean 0 and standard deviation 1. Then we act as if we would only know that the samples are drawn from a normal distribution, but with unknown $\\mu$ and $\\sigma$. In PyMC3 this example looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [sigma, mu]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='8000' class='' max='8000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [8000/8000 00:01<00:00 Sampling 4 chains, 0 divergences]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 2 seconds.\n"
     ]
    }
   ],
   "source": [
    "samples = stats.norm(0,1).rvs([1000])\n",
    "\n",
    "with pm.Model() as model:\n",
    "    mu = pm.Normal(\"mu\", 0.0, 10.0)\n",
    "    sigma = pm.Gamma('sigma', alpha=3.0, beta=1.0)\n",
    "    x = pm.Normal(\"x\", mu=mu, sigma=sigma, observed=samples)\n",
    "    trace = pm.sample(return_inferencedata=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as a reminder and to make the link to what we said above (about the model) more clear, let's be explicit and give the probability density function in sympy for two data-points instead of the 1000. All that PyMC3 does is to construct such a total joint probability density function and evaluate it at the given data-points. So in our example $x_1$ and $x_2$ are given and $\\mu$ and $\\sigma$ are \"free\" variables.\n",
    "\n",
    "As another remark: the [Gamma distribution](https://en.wikipedia.org/wiki/Gamma_distribution) is sometimes parametrized via $\\alpha, \\beta$ and sometimes via $k, \\theta$: $\\alpha = k; \\beta=1/\\theta$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2} e^{- \\frac{\\mu^{2}}{200}}}{20 \\sqrt{\\pi}}\\\\\\frac{\\sigma^{2} e^{- \\sigma}}{2}\\\\\\frac{e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\pi \\sigma^{2}}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[                                                sqrt(2)*exp(-\\mu**2/200)/(20*sqrt(pi))],\n",
       "[                                                              \\sigma**2*exp(-\\sigma)/2],\n",
       "[exp(-(-\\mu + x1)**2/(2*\\sigma**2))*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*pi*\\sigma**2)]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smu, sx = sympy.symbols(r'\\mu x')\n",
    "sx1, sx2 = sympy.symbols(r'x1:3')\n",
    "ssigma = sympy.Symbol(\"\\sigma\", positive=True)\n",
    "\n",
    "prior_mu = sympy.stats.crv_types.NormalDistribution(0, 10).pdf(smu)\n",
    "prior_sigma = sympy.stats.crv_types.GammaDistribution(3, 1).pdf(ssigma)\n",
    "likelihood = sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx1)*sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx2)\n",
    "total = sympy.UnevaluatedExpr(prior_mu)*sympy.UnevaluatedExpr(prior_sigma)*sympy.UnevaluatedExpr(likelihood)\n",
    "sympy.Matrix([prior_mu, prior_sigma, likelihood])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{2} e^{- \\frac{\\mu^{2}}{200}}}{20 \\sqrt{\\pi}} \\frac{\\sigma^{2} e^{- \\sigma}}{2} \\frac{e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\pi \\sigma^{2}}$"
      ],
      "text/plain": [
       "(sqrt(2)*exp(-\\mu**2/200)/(20*sqrt(pi)))*(\\sigma**2*exp(-\\sigma)/2)*(exp(-(-\\mu + x1)**2/(2*\\sigma**2))*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*pi*\\sigma**2))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyMC3 created a trace object containing samples of the \"free\"/unknown variables. We can look at them as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>mu</th>\n",
       "      <th>sigma</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>chain</th>\n",
       "      <th>draw</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">0</th>\n",
       "      <th>0</th>\n",
       "      <td>-0.025535</td>\n",
       "      <td>0.995429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.000475</td>\n",
       "      <td>0.982951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.036382</td>\n",
       "      <td>0.960661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.069528</td>\n",
       "      <td>0.960479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.052084</td>\n",
       "      <td>0.957739</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">3</th>\n",
       "      <th>995</th>\n",
       "      <td>0.014148</td>\n",
       "      <td>1.015268</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>996</th>\n",
       "      <td>-0.010790</td>\n",
       "      <td>0.948807</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>997</th>\n",
       "      <td>0.061342</td>\n",
       "      <td>1.008478</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>998</th>\n",
       "      <td>0.041587</td>\n",
       "      <td>1.006843</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>999</th>\n",
       "      <td>0.046756</td>\n",
       "      <td>0.997424</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                  mu     sigma\n",
       "chain draw                    \n",
       "0     0    -0.025535  0.995429\n",
       "      1    -0.000475  0.982951\n",
       "      2     0.036382  0.960661\n",
       "      3     0.069528  0.960479\n",
       "      4     0.052084  0.957739\n",
       "...              ...       ...\n",
       "3     995   0.014148  1.015268\n",
       "      996  -0.010790  0.948807\n",
       "      997   0.061342  1.008478\n",
       "      998   0.041587  1.006843\n",
       "      999   0.046756  0.997424\n",
       "\n",
       "[4000 rows x 2 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace_df = trace['posterior'].to_dataframe()\n",
    "trace_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we would want to know $\\mu$ and $\\sigma$ we could take the mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mu</th>\n",
       "      <td>0.019798</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sigma</th>\n",
       "      <td>0.981421</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              0\n",
       "mu     0.019798\n",
       "sigma  0.981421"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace_df.mean().to_frame()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a built-in PyMC3 method that gives us more details in addition to the mean values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>sd</th>\n",
       "      <th>hdi_3%</th>\n",
       "      <th>hdi_97%</th>\n",
       "      <th>mcse_mean</th>\n",
       "      <th>mcse_sd</th>\n",
       "      <th>ess_bulk</th>\n",
       "      <th>ess_tail</th>\n",
       "      <th>r_hat</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mu</th>\n",
       "      <td>0.020</td>\n",
       "      <td>0.031</td>\n",
       "      <td>-0.038</td>\n",
       "      <td>0.074</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3294.0</td>\n",
       "      <td>3168.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sigma</th>\n",
       "      <td>0.981</td>\n",
       "      <td>0.023</td>\n",
       "      <td>0.941</td>\n",
       "      <td>1.024</td>\n",
       "      <td>0.000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3464.0</td>\n",
       "      <td>2734.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  ess_tail  r_hat\n",
       "mu     0.020  0.031  -0.038    0.074      0.001      0.0    3294.0    3168.0    1.0\n",
       "sigma  0.981  0.023   0.941    1.024      0.000      0.0    3464.0    2734.0    1.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pm.summary(trace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *hdi* stands for [Highest (Posterior) Density Interval](https://en.wikipedia.org/wiki/Credible_interval) and gives the range in which credible values are located. As you can see, our real values 0.0 for $\\mu$ and 1.0 for $\\sigma$ are within those hdi invervals.\n",
    "\n",
    "To get a better idea of the plausible parameter values we'll have a look at a [density plot](https://www.statsmodels.org/stable/examples/notebooks/generated/kernel_density.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list(statsmodels.nonparametric.kde.kernel_switch.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [],
   "source": [
    "def kdeplot(lds, parameter_name=None, x_min = None, x_max = None, ax=None, kernel='gau'):\n",
    "    if parameter_name is None and isinstance(lds, pd.Series):\n",
    "        parameter_name = lds.name\n",
    "    kde = sm.nonparametric.KDEUnivariate(lds)\n",
    "    kde.fit(kernel=kernel, fft=False, gridsize=2**10)\n",
    "    if x_min is None:\n",
    "        x_min = kde.support.min()\n",
    "    else:\n",
    "        x_min = min(kde.support.min(), x_min)\n",
    "    if x_max is None:\n",
    "        x_max = kde.support.max()\n",
    "    else:\n",
    "        x_max = max(kde.support.max(),  x_max)\n",
    "    x = np.linspace(x_min, x_max,100)\n",
    "    y = kde.evaluate(x)\n",
    "    if ax is None:\n",
    "        plt.figure(figsize=(6, 3), dpi=80, facecolor='w', edgecolor='k')\n",
    "        ax = plt.subplot(1, 1, 1)\n",
    "    ax.plot(x, y, lw=2)\n",
    "    ax.set_xlabel(parameter_name)\n",
    "    ax.set_ylabel('Density')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x240 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "kdeplot(trace_df['mu'], x_min=-0.5, x_max=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 480x240 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "kdeplot(trace_df['sigma'], x_min=0.75, x_max=1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will talk about it in more detail below, but what we did above is that we looked at the marginal likelihood of only $\\mu$ or only $\\sigma$. If your probability density function is given as samples then marginalizing out other parameters is trivial. You only take the parameter(s) (the columns in the sample dataframe) you're interested in.\n",
    "\n",
    "It is important to understand that the samples, e.g. each row in the sample dataframe, are **jointly plausible**, e.g. they represent the joint probability distribution. If two parameters would be correlated you would see that in the pairsplot like below. In our example the two parameters are obviously uncorrelated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.pairplot(trace_df, height=3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations on probability distributions: marginalization and conditional probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the marginalization and conditional probability operations are quite involved when you have to deal with probability distributions in their mathematical functions form these operations are *trivial* if you have samples representing the probability distributions.\n",
    "\n",
    "Let's start with marginalization. Let's assume you have a joint probability density function $p(x,y)$ for two random variables $X$ and $Y$. Then you marginalize out $y$ by integrating over all values of $y$:\n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "p(x)&=&\\displaystyle\\int p(x,y)\\,\\mathrm{d}y\n",
    "\\end{array}\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This integration may be quite involved even in simple cases like a [multi-variate normal distribution](https://en.wikipedia.org/wiki/Multivariate_normal_distribution). Have a look at [Bayes’ Theorem for Gaussians](http://web4.cs.ucl.ac.uk/staff/C.Bracegirdle/bayesTheoremForGaussians.pdf) by Chris Bracegirdle for details.\n",
    "\n",
    "In the case of samples, on the other hand, marginalization is *trivial*! You simply project (in the sense of an [SQL projection](https://en.wikipedia.org/wiki/Projection_%28relational_algebra%29)) on the column(s) you're interested in and you get the marginal distribution for that parameter set.\n",
    "\n",
    "The conditional probability is defined as:\n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "\\begin{array}{rcl}\n",
    "p(x,y)&=&\\displaystyle p(y\\,|\\, x)p(x) \\\\\n",
    "\\Rightarrow p(y\\,|\\, x=x_0)&=&\\displaystyle \\frac{p(x_0,y)}{p(x_0)}\\\\\n",
    "&=&\\displaystyle \\frac{p(x=x_0,y)}{\\int p(x=x_0,y)\\mathrm{d}y} \\text{ you simply normalize the function} f(y)=p(x=x_0,y)\n",
    "\\end{array}\n",
    "$\n",
    "\n",
    "You have to divide two distributions and often have to calculate integrals. I also show the variation where you use the marginalization $\\int p(x=x_0,y)\\mathrm{d}y$, because sometimes that's useful to remember. $p(x=x_0,y)$ is no probability distribution in $y$ any longer, because $\\int p(x=x_0,y)\\mathrm{d}y < 1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are in the world of samples then the conditional probability is calculated like an [SQL *where* clause](https://en.wikipedia.org/wiki/Relational_algebra#Selection_%28%CF%83%29), e.g. you sub-select the dataframe for values where $x=x_0$. For continuous variables this condition is nearly never true. Therefore you have to sub-select with a *where* condition like $x_0-\\delta<x<x_0+\\delta$. Finally you only keep the columns (SQL projection) of the variables that are on the left hand side of the conditional probability bar ($(\\cdot\\,|\\,\\cdot)$), e.g. $y$ in our example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculations with random variables: convolutions and other nasty stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculating with random variables when their distribution is given as mathematical functions is just painfully difficult. The book [The algebra of random variables](https://www.amazon.com/algebra-variables-probability-mathematical-statistics/dp/0471014060) by Melvine Dale Springer gives a detailed overview. But even the simplest example like adding two random variables like $X=X_1+X_2$ where $X_1\\sim p_1(x_1)$ and $X_2\\sim p_2(x_2)$ involves [convolutions](https://en.wikipedia.org/wiki/Convolution), e.g. $X\\sim p(x)= \\int p_1(x-x_2)p_2(x_2)\\,\\mathrm{d}x_2$. The library [PaCal](https://github.com/jszymon/pacal) (ProbAbilistic Calculator) or [SymPy](https://docs.sympy.org/latest/modules/stats.html) may help. Nevertheless it is just best to avoid these intricate calculations completely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luckily, in the world of samples, all of that is simple again! Imagine you have a distribution given as samples from $x_1$ and $x_2$. You then construct samples of $x_1+x_2$ by simply adding them up for every row in your samples dataframe, e.g. you create a new column $x$ by row-wise calculating $x = x_1 + x_2$. And there you are, you have samples of the random variable $X$!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example might be like above, like [when we calculated the trajectory of the ball](#Bayes'-theorem). You could also see that example as $X_1 = X_0 + \\Delta X$, where $\\Delta X$ would be a distribution depending on the time delta $t_2-t_1$, the velocity $v$ and the acceleration $g$. In such cases it is typically easiest to see one of the variables as the starting point, e.g. $X_0$ and then use the law of total probability to construct $p(x_0, x_1)=p(x_0)p(x_1\\,|\\,x_0)$ and then calculate on the \"conditional\" side of $p(x_1\\,|\\,x_0)$, e.g. \n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "p(x_1\\,|\\,x_0) = \\mathcal{N}(x_1; x_0+v(t_1-t_0)+(g/2)(t_1-t_0)^2,\\sigma_m)\n",
    "$\n",
    "\n",
    "As you can see, on the \"conditional\" side of $p(x_1\\,|\\,x_0)$ (the side involving $x_0$) we simply calculate like normal! We simply add, subtract, multiply and whatever else we want to do. We also avoid the convolution by sampling from the total joint probability distribution $p(x_0, x_1)$ and marginalizing on the samples by simply dropping the $x_0$ column if we really wanted to. **No convolutions and no other difficult operations on distributions**! Just normal math and sampling on the extended joint space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Density Estimation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the past, whenever I was dealing with machine learning methods, I always felt disappointed; disappointed about the lack of \"insight\" and \"understanding\" and that machine learning methods only give me a uni-directional way of reasoning.\n",
    "\n",
    "Let's take regression or classification for example. Even the recent really impressive success stories like [object detection](https://en.wikipedia.org/wiki/Object_detection) and [image segmentation](https://en.wikipedia.org/wiki/Image_segmentation) only give you a way from an input to an output. If you wanted to know the most distinguishing features of a dog vs. a cat you're out of luck (there may be ways, but no straight-forward ones).\n",
    "\n",
    "In my first encounter with [Bayesian networks](https://en.wikipedia.org/wiki/Bayesian_network) I was so impressed with the fact that you can not only reason forward from disease to symptoms, but also backward like given the symptoms of a patient, what are the most likely root causes, e.g. which disease might be the root cause and which actions/drugs might be the best way forward.\n",
    "\n",
    "It took me quite some time to understand \"what I really wanted\". I wanted \"all the answers\", not only partial answers. And again some more time went by until I found the \"term\" that refers to what I want: [density estimation](https://en.wikipedia.org/wiki/Density_estimation). This term is often accompanied by other terms like [unsupervised learning](https://en.wikipedia.org/wiki/Unsupervised_learning) and recent advances in machine learning are also targeting density estimation directly via [deep generative models](https://en.wikipedia.org/wiki/Generative_model#Deep_generative_models). In the end it all boils down to \"discovering\" the [causal network](https://en.wikipedia.org/wiki/Causal_model) of the world, so that in the end you can answer any question you'd come up with, not only the ones the designer of the \"system\" wanted you to ask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The algorithm has to always perform the same heavy lifting: there is no ancestral sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When I read the paper [Mixed Hamiltonian Monte Carlo for Mixed Discrete and Continuous Variables](https://arxiv.org/abs/1909.04852) by Guangyao Zhou he used an exmaple of a [24 dimensional Gaussian Mixture Model](https://github.com/StannisZhou/mixed_hmc/blob/master/momentum/potential/simple_gmm.py) **without observations** to show the power of his approach. Initially, I felt as if this was cheating, because in the end [forward/ancestral](https://ermongroup.github.io/cs228-notes/inference/sampling) sampling is trival in that case. I had to remind myself that the MCMC algorithm he invented has to perform the same heavy lifting in the given example without observations as it has to perform in a situation that involves observations and the same number of free variables. The probabilistic programming languages and frameworks like [Stan](https://mc-stan.org/) or [PyMC3](https://docs.pymc.io/) do not employ any additional intelligence to decide which method might be most appropriate in which case.\n",
    "\n",
    "> You always take a model in the form of a scalar valued function representing the (unnormalized) total joint probability function and then you always apply the same hammer like an [SMC](https://www.amazon.com/-/de/dp-0387951466/dp/0387951466/) or [MCMC](https://www.amazon.com/-/de/dp-B008GXJVF8/dp/B008GXJVF8/) algorithm.\n",
    "\n",
    "If you want to be smart on that level you have to do it yourself as a human with your own brain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of mixed discrete continuous probability functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below I am exaggerating the level of explicitness at each step of the calculation and the level to which I use [SymPy](https://www.sympy.org/en/index.html) to achieve maximum clarity. I hope that this will help you to avoid a similar level of confusion that I found myself in. In addition you might learn to appreciate to use [SymPy](https://www.sympy.org/en/index.html), which is really great for symbolic algebra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Two independent coin tosses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first example is about two independent coin tosses where we don't know $\\theta\\in[0,1]$, the probability for heads coming up. The total joint probability function (I only say \"probability function\" and avoid the terms *densite* or *mass*, because in the mixed case it is not clear in which situation we are) is then given by: $p(d_1,d_2,\\theta)=p(X_0=d_0\\,|\\,\\theta)\\cdot p(X_1=d_1\\,|\\,\\theta)\\cdot p(\\theta)$. If we take $p(\\theta)=\\mathrm{Beta}(1,1)=1$ for $\\theta\\in[0,1]$ then we get for each coin a one dimensional matrix with two entries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 - \\theta\\\\\\theta\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1 - \\theta],\n",
       "[    \\theta]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stheta = sympy.var(r'\\theta')\n",
    "D1 = sympy.Matrix([[(1-stheta)], [stheta]])\n",
    "D1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The entry with index 0 belongs to the case where we observe \"tail\" and the entry with index 1 belongs to the case where we observe \"head\". We can index into that vector like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 - \\theta$"
      ],
      "text/plain": [
       "1 - \\theta"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\theta$"
      ],
      "text/plain": [
       "\\theta"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(D1[0]),display(D1[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the indexing operation can be seen as a function that takes an integer and returns a scalar value. Exactly what we need for a probability function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the second coin we take a 2x1 matrix (a horizontal lying vector), so that when we multiply the two we will get a 2x2 matrix for the 2x2 combinations of tail and head for each coin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 - \\theta & \\theta\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[1 - \\theta, \\theta]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D2 = sympy.Matrix([[(1-stheta), stheta]])\n",
    "D2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\left(1 - \\theta\\right)^{2} & \\theta \\left(1 - \\theta\\right)\\\\\\theta \\left(1 - \\theta\\right) & \\theta^{2}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[    (1 - \\theta)**2, \\theta*(1 - \\theta)],\n",
       "[\\theta*(1 - \\theta),           \\theta**2]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = D1*D2\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We said above that a probability function needs to be a function that takes as arguments the values of all random variables and delivers a scalar. In python this would look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_coin_tosses_probability_function(theta, d1, d2):\n",
    "    v = D.subs(stheta, theta)\n",
    "    v = v[d1,d2] # we use indexing to access a concrete slot in the multi dimensional array\n",
    "    return v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we then wanted to know the probability of one head and one tail for a fair coin we would get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{4}$"
      ],
      "text/plain": [
       "1/4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta = sympy.Integer(1)/2\n",
    "display(theta)\n",
    "two_coin_tosses_probability_function(theta, 1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other way we could have done this would be to use the [Kronecker delta](https://en.wikipedia.org/wiki/Kronecker_delta) instead of vector/matrix indexing and using the fact that any number to the power of $0$ is $1$: $x^0=1 \\quad\\forall x\\in \\mathbb{R}\\setminus 0$, e.g. we receive the neutral element for our product of probability functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(d1, d2)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sd1, sd2 = sympy.symbols('d1:3') # we define two new sympy symbols for d1 and d2\n",
    "sd1, sd2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, the first $1$ is to remind us of the $p(\\theta)=\\mathrm{Beta}(1,1)=1$. In case that we used another prior this would be a different factor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\theta^{\\delta_{1 d_{1}}} \\theta^{\\delta_{1 d_{2}}} \\left(1 - \\theta\\right)^{\\delta_{0 d_{1}}} \\left(1 - \\theta\\right)^{\\delta_{0 d_{2}}}$"
      ],
      "text/plain": [
       "\\theta**KroneckerDelta(1, d1)*\\theta**KroneckerDelta(1, d2)*(1 - \\theta)**KroneckerDelta(0, d1)*(1 - \\theta)**KroneckerDelta(0, d2)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D_ = 1*(1-stheta)**sympy.KroneckerDelta(0,sd1)*stheta**sympy.KroneckerDelta(1,sd1)*(1-stheta)**sympy.KroneckerDelta(0,sd2)*stheta**sympy.KroneckerDelta(1,sd2)\n",
    "D_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_coin_tosses_probability_function_(theta, d1, d2):\n",
    "    v = D_.subs(stheta, theta)\n",
    "    v = v.subs(sd1,d1)\n",
    "    v = v.subs(sd2,d2)\n",
    "    return v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course you get the same result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{4}$"
      ],
      "text/plain": [
       "1/4"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_coin_tosses_probability_function(theta, 1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Kronecker delta variant looks more like a function, but a computer works better with an index lookup in a matrix. Finally we could use an **if-then-else** structure, but many probabilistic programming environments behave clumsy when it comes to if-then-else constructs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Two component mixture model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second example is a two component mixture model. In most cases people will show a mixture of two Gaussians, but with two Gaussians you can get away with using an array of $\\mu$ and $\\sigma$. Let's look at mixing one Gaussian with one Exponential distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\mu & \\sigma & \\lambda & x & x_{1} & x_{2} & i & j & p_{0} & p_{1}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[\\mu, \\sigma, \\lambda, x, x1, x2, i, j, p0, p1]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smu, sx = sympy.symbols(r'\\mu x')\n",
    "sx1, sx2 = sympy.symbols(r'x1:3')\n",
    "si, sj = sympy.symbols('i j', integer=True)\n",
    "sp0, sp1 = sympy.symbols(r'p:2')\n",
    "ssigma = sympy.Symbol(\"\\sigma\", positive=True)\n",
    "slambda = sympy.Symbol(\"\\lambda\", positive=True)\n",
    "sympy.Matrix([smu, ssigma, slambda, sx, sx1, sx2, si, sj, sp0, sp1]).T # just for displaying the symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{2} e^{- \\frac{\\left(- \\mu + x\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}$"
      ],
      "text/plain": [
       "sqrt(2)*exp(-(-\\mu + x)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\lambda e^{- \\lambda x}$"
      ],
      "text/plain": [
       "\\lambda*exp(-\\lambda*x)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.stats.crv_types.ExponentialDistribution(slambda).pdf(sx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the mixture to work we use a mixture indicator $i\\in\\{0,1\\}$. If $i$ is 0 then we draw from the Exponential distribution and when $i$ is 1 we draw from the normal distribution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} p_{1} & \\text{for}\\: i = 1 \\\\1 - p_{1} & \\text{for}\\: i = 0 \\\\0 & \\text{otherwise} \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((p1, Eq(i, 1)), (1 - p1, Eq(i, 0)), (0, True))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(si)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "tags": [
     "hide_input"
    ]
   },
   "outputs": [],
   "source": [
    "# print(sympy.latex(sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(sx)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle p_{1}$"
      ],
      "text/plain": [
       "p1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 - p_{1}$"
      ],
      "text/plain": [
       "1 - p1"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a single observation the total joint probability function would look as follows:\n",
    "\n",
    "$\n",
    "\\displaystyle\n",
    "p(p_1,i,\\lambda,\\mu,\\sigma,x)=p(p_1)p(i\\,|\\,p_1)\\begin{cases}p(\\lambda)p(x\\,|\\,\\lambda) & \\text{for}\\: i = 0\\\\ p(\\mu)p(\\sigma)p(x\\,|\\,\\mu,\\sigma) & \\text{for}\\: i = 1 \\\\0 & \\text{otherwise} \\end{cases}\n",
    "$\n",
    "\n",
    "Below we're using SymPy to construct the total joint probability function for two observations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(\\lambda \\left(1 - p_{1}\\right) e^{- \\lambda x_{1}}\\right)^{\\delta_{0 i}} \\left(\\lambda \\left(1 - p_{1}\\right) e^{- \\lambda x_{2}}\\right)^{\\delta_{0 j}} \\left(\\frac{\\sqrt{2} p_{1} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\right)^{\\delta_{1 i}} \\left(\\frac{\\sqrt{2} p_{1} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\right)^{\\delta_{1 j}} e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma}}{20000 \\pi}$"
      ],
      "text/plain": [
       "(\\lambda*(1 - p1)*exp(-\\lambda*x1))**KroneckerDelta(0, i)*(\\lambda*(1 - p1)*exp(-\\lambda*x2))**KroneckerDelta(0, j)*(sqrt(2)*p1*exp(-(-\\mu + x1)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma))**KroneckerDelta(1, i)*(sqrt(2)*p1*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma))**KroneckerDelta(1, j)*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)/(20000*pi)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sprior_exponential = sympy.stats.crv_types.ExponentialDistribution(1).pdf(slambda)\n",
    "sprior_normal = sympy.stats.crv_types.ExponentialDistribution(1).pdf(ssigma)*sympy.stats.crv_types.NormalDistribution(0, 100).pdf(smu)\n",
    "sprior_mixture_components = sprior_normal*sympy.stats.crv_types.BetaDistribution(1,1).pdf(sp1)\n",
    "sprior = sprior_exponential*sprior_normal*sprior_mixture_components\n",
    "smixture_likelihood = \\\n",
    "    (sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(0)*sympy.stats.crv_types.ExponentialDistribution(slambda).pdf(sx1))**sympy.KroneckerDelta(0,si) * \\\n",
    "    (sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(1)*sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx1))**sympy.KroneckerDelta(1,si) * \\\n",
    "    (sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(0)*sympy.stats.crv_types.ExponentialDistribution(slambda).pdf(sx2))**sympy.KroneckerDelta(0,sj) * \\\n",
    "    (sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(1)*sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx2))**sympy.KroneckerDelta(1,sj)\n",
    "smixture = sprior * smixture_likelihood\n",
    "smixture "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, when you ask how to model a mixture model in a probabilistic programming system like Stan or PyMC3, people will recommend that you marginalize out the discrete variables like $i$ and $j$ above. Systems like Stan cannot deal with discrete free random variables at all. PyMC3 can deal with them, but sampling will be slow and hard, so that this recommendation actually makes sense.\n",
    "\n",
    "Let's use SymPy to marginalize out the discrete variables $i$ and $j$. Marginalizing out discrete variables means summing over them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(\\lambda \\left(1 - p_{1}\\right) e^{- \\lambda x_{1}} + \\frac{\\sqrt{2} p_{1} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\right) \\left(\\lambda \\left(1 - p_{1}\\right) e^{- \\lambda x_{2}} + \\frac{\\sqrt{2} p_{1} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\right) e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma}}{20000 \\pi}$"
      ],
      "text/plain": [
       "(\\lambda*(1 - p1)*exp(-\\lambda*x1) + sqrt(2)*p1*exp(-(-\\mu + x1)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma))*(\\lambda*(1 - p1)*exp(-\\lambda*x2) + sqrt(2)*p1*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma))*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)/(20000*pi)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smixture_marginal_1 = sympy.summation(smixture, (si, 0, 1), (sj, 0, 1))\n",
    "smixture_marginal_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For clarity we may only look at the likelihood part without the prior components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\lambda \\left(1 - p_{1}\\right) e^{- \\lambda x_{1}} + \\frac{\\sqrt{2} p_{1} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\right) \\left(\\lambda \\left(1 - p_{1}\\right) e^{- \\lambda x_{2}} + \\frac{\\sqrt{2} p_{1} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\right)$"
      ],
      "text/plain": [
       "(\\lambda*(1 - p1)*exp(-\\lambda*x1) + sqrt(2)*p1*exp(-(-\\mu + x1)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma))*(\\lambda*(1 - p1)*exp(-\\lambda*x2) + sqrt(2)*p1*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma))"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.summation(smixture_likelihood, (si, 0, 1), (sj, 0, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, we can do the same in the matrix picture rather than using Kronecker deltas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma} \\left[\\begin{matrix}\\lambda^{2} \\left(1 - p_{1}\\right)^{2} e^{- \\lambda x_{1}} e^{- \\lambda x_{2}} & \\frac{\\sqrt{2} \\lambda p_{1} \\left(1 - p_{1}\\right) e^{- \\lambda x_{1}} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma}\\\\\\frac{\\sqrt{2} \\lambda p_{1} \\left(1 - p_{1}\\right) e^{- \\lambda x_{2}} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sigma} & \\frac{p_{1}^{2} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{2 \\pi \\sigma^{2}}\\end{matrix}\\right]}{20000 \\pi}$"
      ],
      "text/plain": [
       "exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)*Matrix([\n",
       "[                                           \\lambda**2*(1 - p1)**2*exp(-\\lambda*x1)*exp(-\\lambda*x2), sqrt(2)*\\lambda*p1*(1 - p1)*exp(-\\lambda*x1)*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma)],\n",
       "[sqrt(2)*\\lambda*p1*(1 - p1)*exp(-\\lambda*x2)*exp(-(-\\mu + x1)**2/(2*\\sigma**2))/(2*sqrt(pi)*\\sigma),        p1**2*exp(-(-\\mu + x1)**2/(2*\\sigma**2))*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(2*pi*\\sigma**2)]])/(20000*pi)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M1 = sympy.Matrix([\n",
    "    sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(0)*sympy.stats.crv_types.ExponentialDistribution(slambda).pdf(sx1), \n",
    "    sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(1)*sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx1)])\n",
    "M2 = sympy.Matrix([[\n",
    "    sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(0)*sympy.stats.crv_types.ExponentialDistribution(slambda).pdf(sx2), \n",
    "    sympy.stats.frv_types.BernoulliDistribution(sp1, 1, 0).pmf(1)*sympy.stats.crv_types.NormalDistribution(smu, ssigma).pdf(sx2)]])\n",
    "M = M1 * M2\n",
    "E = sprior * sympy.UnevaluatedExpr(M)\n",
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "E_ = E.doit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can receive concrete values for a situation like if we assume that both data-points are from the exponential distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\lambda^{2} \\left(1 - p_{1}\\right)^{2} e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma} e^{- \\lambda x_{1}} e^{- \\lambda x_{2}}}{20000 \\pi}$"
      ],
      "text/plain": [
       "\\lambda**2*(1 - p1)**2*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)*exp(-\\lambda*x1)*exp(-\\lambda*x2)/(20000*pi)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E_[0,0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The marginalization works again by summing over the discrete variables. This time we have to use `sympy.Add` rather than `sympy.summation`, because we don't perform a symbolic summation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\lambda^{2} \\left(1 - p_{1}\\right)^{2} e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma} e^{- \\lambda x_{1}} e^{- \\lambda x_{2}}}{20000 \\pi} + \\frac{\\sqrt{2} \\lambda p_{1} \\left(1 - p_{1}\\right) e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma} e^{- \\lambda x_{2}} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}}}{40000 \\pi^{\\frac{3}{2}} \\sigma} + \\frac{\\sqrt{2} \\lambda p_{1} \\left(1 - p_{1}\\right) e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma} e^{- \\lambda x_{1}} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{40000 \\pi^{\\frac{3}{2}} \\sigma} + \\frac{p_{1}^{2} e^{- \\lambda} e^{- \\frac{\\mu^{2}}{10000}} e^{- 2 \\sigma} e^{- \\frac{\\left(- \\mu + x_{1}\\right)^{2}}{2 \\sigma^{2}}} e^{- \\frac{\\left(- \\mu + x_{2}\\right)^{2}}{2 \\sigma^{2}}}}{40000 \\pi^{2} \\sigma^{2}}$"
      ],
      "text/plain": [
       "\\lambda**2*(1 - p1)**2*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)*exp(-\\lambda*x1)*exp(-\\lambda*x2)/(20000*pi) + sqrt(2)*\\lambda*p1*(1 - p1)*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)*exp(-\\lambda*x2)*exp(-(-\\mu + x1)**2/(2*\\sigma**2))/(40000*pi**(3/2)*\\sigma) + sqrt(2)*\\lambda*p1*(1 - p1)*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)*exp(-\\lambda*x1)*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(40000*pi**(3/2)*\\sigma) + p1**2*exp(-\\lambda)*exp(-\\mu**2/10000)*exp(-2*\\sigma)*exp(-(-\\mu + x1)**2/(2*\\sigma**2))*exp(-(-\\mu + x2)**2/(2*\\sigma**2))/(40000*pi**2*\\sigma**2)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smixture_marginal_2 = sympy.Add(*[E_[i, j] for i in range(2) for j in range(2)])\n",
    "smixture_marginal_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this form it is not immediately obvious that the two expressions are actually the same, but we can let SymPy answer that by subtracting the two terms and showing that the result is 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sympy.simplify(smixture_marginal_1 - smixture_marginal_2)"
   ]
  }
 ],
 "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.8.10"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "274px",
    "width": "800px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "688px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}