Spaces:
Running
Running
| # /// script | |
| # requires-python = ">=3.11" | |
| # dependencies = [ | |
| # "marimo", | |
| # "altair==5.5.0", | |
| # "matplotlib==3.10.1", | |
| # "numpy==2.2.4", | |
| # "scipy==1.15.2", | |
| # "sympy==1.13.3", | |
| # "wigglystuff==0.1.10", | |
| # "polars==1.26.0", | |
| # ] | |
| # /// | |
| import marimo | |
| __generated_with = "0.11.26" | |
| app = marimo.App(width="medium") | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| # Continuous Distributions | |
| _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/continuous/), by Stanford professor Chris Piech._ | |
| So far, all the random variables we've explored have been discrete, taking on only specific values (usually integers). Now we'll move into the world of **continuous random variables**, which can take on any real number value. Continuous random variables are used to model measurements with arbitrary precision like height, weight, time, and many natural phenomena. | |
| """ | |
| ) | |
| return | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## From Discrete to Continuous | |
| To make the transition from discrete to continuous random variables, let's start with a thought experiment: | |
| > Imagine you're running to catch a bus. You know you'll arrive at 2:15pm, but you don't know exactly when the bus will arrive. You want to model the bus arrival time (in minutes past 2pm) as a random variable $T$ so you can calculate the probability that you'll wait more than five minutes: $P(15 < T < 20)$. | |
| This immediately highlights a key difference from discrete distributions. For discrete distributions, we described the probability that a random variable takes on exact values. But this doesn't make sense for continuous values like time. | |
| For example: | |
| - What's the probability the bus arrives at exactly 2:17pm and 12.12333911102389234 seconds? | |
| - What's the probability of a child being born weighing exactly 3.523112342234 kilograms? | |
| These questions don't have meaningful answers because real-world measurements can have infinite precision. The probability of a continuous random variable taking on any specific exact value is actually zero! | |
| ### Visualizing the Transition | |
| Let's visualize this transition from discrete to continuous: | |
| """ | |
| ) | |
| return | |
| def _(fig_to_image, mo, np, plt): | |
| def create_discretization_plot(): | |
| fig, axs = plt.subplots(1, 3, figsize=(15, 5)) | |
| # values from 0 to 30 minutes | |
| x = np.linspace(0, 30, 1000) | |
| # Triangular distribution peaked at 15 minutes) | |
| y = np.where(x <= 15, x/15, (30-x)/15) | |
| y = y / np.trapezoid(y, x) # Normalize | |
| # 5-minute chunks (first plot) | |
| bins = np.arange(0, 31, 5) | |
| hist, _ = np.histogram(x, bins=bins, weights=y) | |
| width = bins[1] - bins[0] | |
| axs[0].bar(bins[:-1], hist * width, width=width, alpha=0.7, | |
| color='royalblue', edgecolor='black') | |
| axs[0].set_xlim(0, 30) | |
| axs[0].set_title('5-Minute Intervals') | |
| axs[0].set_xlabel('Minutes past 2pm') | |
| axs[0].set_ylabel('Probability') | |
| # 15-20 minute range more prominent | |
| axs[0].bar([15], hist[3] * width, width=width, alpha=0.7, | |
| color='darkorange', edgecolor='black') | |
| # 2.5-minute chunks (second plot) | |
| bins = np.arange(0, 31, 2.5) | |
| hist, _ = np.histogram(x, bins=bins, weights=y) | |
| width = bins[1] - bins[0] | |
| axs[1].bar(bins[:-1], hist * width, width=width, alpha=0.7, | |
| color='royalblue', edgecolor='black') | |
| axs[1].set_xlim(0, 30) | |
| axs[1].set_title('2.5-Minute Intervals') | |
| axs[1].set_xlabel('Minutes past 2pm') | |
| # Make 15-20 minute range more prominent | |
| highlight_indices = [6, 7] | |
| for idx in highlight_indices: | |
| axs[1].bar([bins[idx]], hist[idx] * width, width=width, alpha=0.7, | |
| color='darkorange', edgecolor='black') | |
| # Continuous distribution (third plot) | |
| axs[2].plot(x, y, 'royalblue', linewidth=2) | |
| axs[2].set_xlim(0, 30) | |
| axs[2].set_title('Continuous Distribution') | |
| axs[2].set_xlabel('Minutes past 2pm') | |
| axs[2].set_ylabel('Probability Density') | |
| # Highlight the AUC between 15 and 20 | |
| mask = (x >= 15) & (x <= 20) | |
| axs[2].fill_between(x[mask], y[mask], color='darkorange', alpha=0.7) | |
| # Mark 15-20 minute interval | |
| for ax in axs: | |
| ax.axvline(x=15, color='red', linestyle='--', alpha=0.5) | |
| ax.axvline(x=20, color='red', linestyle='--', alpha=0.5) | |
| ax.set_xticks([0, 5, 10, 15, 20, 25, 30]) | |
| ax.grid(alpha=0.3) | |
| plt.tight_layout() | |
| plt.gca() | |
| return fig | |
| # Plot creation & conversion | |
| _fig = create_discretization_plot() | |
| _img = mo.image(fig_to_image(_fig), width="100%") | |
| _explanation = mo.md( | |
| r""" | |
| The figure above illustrates our transition from discrete to continuous thinking: | |
| - **Left**: Time divided into 5-minute chunks, where the probability of the bus arriving between 15-20 minutes (highlighted in orange) is a single value. | |
| - **Center**: Time divided into finer 2.5-minute chunks, where the 15-20 minute range consists of two chunks. | |
| - **Right**: In the limit, we get a continuous probability density function where the probability is the area under the curve between 15 and 20 minutes. | |
| As we make our chunks smaller and smaller, we eventually arrive at a smooth function that gives us the probability density at each point. | |
| """ | |
| ) | |
| mo.vstack([_img, _explanation]) | |
| return (create_discretization_plot,) | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## Probability Density Functions | |
| In the world of discrete random variables, we used **Probability Mass Functions (PMFs)** to describe the probability of a random variable taking on specific values. In the continuous world, we need a different approach. | |
| For continuous random variables, we use a **Probability Density Function (PDF)** which defines the relative likelihood that a random variable takes on a particular value. We traditionally denote the PDF with the symbol $f$ and write it as: | |
| $$f(X=x) \quad \text{or simply} \quad f(x)$$ | |
| Where the lowercase $x$ implies that we're talking about the relative likelihood of a continuous random variable which is the uppercase $X$. | |
| ### Key Properties of PDFs | |
| A **Probability Density Function (PDF)** $f(x)$ for a continuous random variable $X$ has these key properties: | |
| 1. The probability that $X$ takes a value in the interval $[a, b]$ is: | |
| $$P(a \leq X \leq b) = \int_a^b f(x) \, dx$$ | |
| 2. The PDF must be non-negative everywhere: | |
| $$f(x) \geq 0 \text{ for all } x$$ | |
| 3. The total probability must sum to 1: | |
| $$\int_{-\infty}^{\infty} f(x) \, dx = 1$$ | |
| 4. The probability that $X$ takes any specific exact value is 0: | |
| $$P(X = a) = \int_a^a f(x) \, dx = 0$$ | |
| This last property highlights a key difference from discrete distributions: the probability of a continuous random variable taking on an exact value is always 0. Probabilities only make sense when talking about ranges of values. | |
| ### Caution: Density ≠ Probability | |
| A common misconception is to think of $f(x)$ as a probability. It is instead a **probability density**, representing probability per unit of $x$. The values of $f(x)$ can actually exceed 1, as long as the total area under the curve equals 1. | |
| The interpretation of $f(x)$ is only meaningful when: | |
| 1. We integrate over a range to get a probability, or | |
| 2. We compare densities at different points to determine relative likelihoods. | |
| """ | |
| ) | |
| return | |
| def _(TangleSlider, mo): | |
| # Create sliders for a and b | |
| a_slider = mo.ui.anywidget(TangleSlider( | |
| amount=1, | |
| min_value=0, | |
| max_value=5, | |
| step=0.1, | |
| digits=1 | |
| )) | |
| b_slider = mo.ui.anywidget(TangleSlider( | |
| amount=3, | |
| min_value=0, | |
| max_value=5, | |
| step=0.1, | |
| digits=1 | |
| )) | |
| # Distribution selector | |
| distribution_radio = mo.ui.radio( | |
| options=["uniform", "triangular", "exponential"], | |
| value="uniform", | |
| label="Distribution Type" | |
| ) | |
| # Controls layout | |
| _controls = mo.vstack([ | |
| mo.md("### Visualizing Probability as Area Under the PDF Curve"), | |
| mo.md("Adjust sliders to change the interval $[a, b]$ and see how the probability changes:"), | |
| mo.hstack([ | |
| mo.md("Lower bound (a):"), | |
| a_slider, | |
| mo.md("Upper bound (b):"), | |
| b_slider | |
| ], justify="start"), | |
| distribution_radio | |
| ]) | |
| _controls | |
| return a_slider, b_slider, distribution_radio | |
| def _( | |
| a_slider, | |
| b_slider, | |
| create_pdf_visualization, | |
| distribution_radio, | |
| fig_to_image, | |
| mo, | |
| ): | |
| a = a_slider.amount | |
| b = b_slider.amount | |
| distribution = distribution_radio.value | |
| # Ensure a < b | |
| if a > b: | |
| a, b = b, a | |
| # visualization | |
| _fig, _probability = create_pdf_visualization(a, b, distribution) | |
| # Display visualization | |
| _img = mo.image(fig_to_image(_fig), width="100%") | |
| # Add appropriate explanation | |
| if distribution == "uniform": | |
| _explanation = mo.md( | |
| f""" | |
| In the **uniform distribution**, all values between 0 and 5 are equally likely. | |
| The probability density is constant at 0.2 (which is 1/5, ensuring the total area is 1). | |
| For a uniform distribution, the probability that $X$ is in the interval $[{a:.1f}, {b:.1f}]$ | |
| is simply proportional to the width of the interval: $P({a:.1f} \leq X \leq {b:.1f}) = {_probability:.4f}$ | |
| Note that while the PDF has a constant value of 0.2, this is not a probability but a density! | |
| """ | |
| ) | |
| elif distribution == "triangular": | |
| _explanation = mo.md( | |
| f""" | |
| In this **triangular distribution**, the probability density increases linearly from 0 to 2.5, | |
| then decreases linearly from 2.5 to 5. | |
| The distribution's peak is at x = 2.5, where the value is highest. | |
| The orange shaded area representing $P({a:.1f} \leq X \leq {b:.1f}) = {_probability:.4f}$ | |
| is calculated by integrating the PDF over the interval. | |
| """ | |
| ) | |
| else: | |
| _explanation = mo.md( | |
| f""" | |
| The **exponential distribution** (with λ = 0.5) models the time between events in a Poisson process. | |
| Unlike the uniform and triangular distributions, the exponential distribution has infinite support | |
| (extends from 0 to infinity). The probability density decreases exponentially as x increases. | |
| The orange shaded area representing $P({a:.1f} \leq X \leq {b:.1f}) = {_probability:.4f}$ | |
| is calculated by integrating $f(x) = 0.5e^{{-0.5x}}$ over the interval. | |
| """ | |
| ) | |
| mo.vstack([_img, _explanation]) | |
| return a, b, distribution | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## Cumulative Distribution Function | |
| Since working with PDFs requires solving integrals to find probabilities, we often use the **Cumulative Distribution Function (CDF)** as a more convenient tool. | |
| The CDF $F(x)$ for a continuous random variable $X$ is defined as: | |
| $$F(x) = P(X \leq x) = \int_{-\infty}^{x} f(t)\,dt$$ | |
| where $f(t)$ is the PDF of $X$. | |
| ### Properties of CDFs | |
| A CDF $F(x)$ has these key properties: | |
| 1. $F(x)$ is always non-decreasing: if $a < b$, then $F(a) \leq F(b)$ | |
| 2. $\lim_{x \to -\infty} F(x) = 0$ and $\lim_{x \to \infty} F(x) = 1$ | |
| 3. $F(x)$ is right-continuous: $\lim_{h \to 0^+} F(x+h) = F(x)$ | |
| ### Using the CDF to Calculate Probabilities | |
| The CDF is extremely useful because it allows us to calculate various probabilities without having to perform integrals each time: | |
| | Probability Query | Solution | Explanation | | |
| |-------------------|----------|-------------| | |
| | $P(X < a)$ | $F(a)$ | Definition of the CDF | | |
| | $P(X \leq a)$ | $F(a)$ | For continuous distributions, $P(X = a) = 0$ | | |
| | $P(X > a)$ | $1 - F(a)$ | Since $P(X \leq a) + P(X > a) = 1$ | | |
| | $P(a < X < b)$ | $F(b) - F(a)$ | Since $F(a) + P(a < X < b) = F(b)$ | | |
| | $P(a \leq X \leq b)$ | $F(b) - F(a)$ | Since $P(X = a) = P(X = b) = 0$ | | |
| For discrete random variables, the CDF is also defined but it's less commonly used: | |
| $$F_X(a) = \sum_{i \leq a} P(X = i)$$ | |
| The CDF for discrete distributions is a step function, increasing at each point in the support of the random variable. | |
| """ | |
| ) | |
| return | |
| def _(fig_to_image, mo, np, plt): | |
| def create_pdf_cdf_comparison(): | |
| fig, axs = plt.subplots(3, 2, figsize=(12, 10)) | |
| # x-values | |
| x = np.linspace(-1, 6, 1000) | |
| # 1. Uniform Distribution | |
| pdf_uniform = np.where((x >= 0) & (x <= 5), 0.2, 0) | |
| axs[0, 0].plot(x, pdf_uniform, 'b-', linewidth=2) | |
| axs[0, 0].set_title('Uniform PDF') | |
| axs[0, 0].set_ylabel('Density') | |
| axs[0, 0].grid(alpha=0.3) | |
| # CDF | |
| cdf_uniform = np.zeros_like(x) | |
| for i, val in enumerate(x): | |
| if val < 0: | |
| cdf_uniform[i] = 0 | |
| elif val > 5: | |
| cdf_uniform[i] = 1 | |
| else: | |
| cdf_uniform[i] = val / 5 | |
| axs[0, 1].plot(x, cdf_uniform, 'r-', linewidth=2) | |
| axs[0, 1].set_title('Uniform CDF') | |
| axs[0, 1].set_ylabel('Probability') | |
| axs[0, 1].grid(alpha=0.3) | |
| # 2. Triangular Distribution | |
| pdf_triangular = np.where(x <= 2.5, x/6.25, (5-x)/6.25) | |
| pdf_triangular = np.where((x < 0) | (x > 5), 0, pdf_triangular) | |
| axs[1, 0].plot(x, pdf_triangular, 'b-', linewidth=2) | |
| axs[1, 0].set_title('Triangular PDF') | |
| axs[1, 0].set_ylabel('Density') | |
| axs[1, 0].grid(alpha=0.3) | |
| # CDF | |
| cdf_triangular = np.zeros_like(x) | |
| for i, val in enumerate(x): | |
| if val <= 0: | |
| cdf_triangular[i] = 0 | |
| elif val >= 5: | |
| cdf_triangular[i] = 1 | |
| else: | |
| # For x ≤ 2.5: CDF = x²/(2 *6 .25) | |
| # For x > 2.5: CDF = 1 - (5 - x)²/(2 * 6.25) | |
| if val <= 2.5: | |
| cdf_triangular[i] = (val**2) / (2 * 6.25) | |
| else: | |
| cdf_triangular[i] = 1 - ((5 - val)**2) / (2 * 6.25) | |
| axs[1, 1].plot(x, cdf_triangular, 'r-', linewidth=2) | |
| axs[1, 1].set_title('Triangular CDF') | |
| axs[1, 1].set_ylabel('Probability') | |
| axs[1, 1].grid(alpha=0.3) | |
| # 3. Exponential Distribution | |
| lambda_param = 0.5 | |
| pdf_exponential = np.where(x >= 0, lambda_param * np.exp(-lambda_param * x), 0) | |
| axs[2, 0].plot(x, pdf_exponential, 'b-', linewidth=2) | |
| axs[2, 0].set_title('Exponential PDF (λ=0.5)') | |
| axs[2, 0].set_xlabel('x') | |
| axs[2, 0].set_ylabel('Density') | |
| axs[2, 0].grid(alpha=0.3) | |
| # CDF | |
| cdf_exponential = np.where(x < 0, 0, 1 - np.exp(-lambda_param * x)) | |
| axs[2, 1].plot(x, cdf_exponential, 'r-', linewidth=2) | |
| axs[2, 1].set_title('Exponential CDF (λ=0.5)') | |
| axs[2, 1].set_xlabel('x') | |
| axs[2, 1].set_ylabel('Probability') | |
| axs[2, 1].grid(alpha=0.3) | |
| # Common x-limits | |
| for ax in axs.flatten(): | |
| ax.set_xlim(-0.5, 5.5) | |
| if ax in axs[:, 0]: # PDF plots | |
| ax.set_ylim(-0.05, max(0.5, max(pdf_triangular)*1.1)) | |
| else: # CDF plots | |
| ax.set_ylim(-0.05, 1.05) | |
| plt.tight_layout() | |
| plt.gca() | |
| return fig | |
| # Create visualization | |
| _fig = create_pdf_cdf_comparison() | |
| _img = mo.image(fig_to_image(_fig), width="100%") | |
| _explanation = mo.md( | |
| r""" | |
| The figure above compares the Probability Density Functions (PDFs) on the left with their corresponding Cumulative Distribution Functions (CDFs) on the right for three common distributions: | |
| 1. **Uniform Distribution**: | |
| - PDF: Constant value (0.2) across the support range [0, 5] | |
| - CDF: Linear increase from 0 to 1 across the support range | |
| 2. **Triangular Distribution**: | |
| - PDF: Linearly increases then decreases, forming a triangle shape | |
| - CDF: Increases quadratically up to the peak, then approaches 1 quadratically | |
| 3. **Exponential Distribution**: | |
| - PDF: Starts at λ=0.5 and decreases exponentially | |
| - CDF: Starts at 0 and approaches 1 exponentially (never quite reaching 1) | |
| /// NOTE | |
| The common properties of all CDFs: | |
| - They are non-decreasing functions | |
| - They start at 0 (for x = -∞) and approach or reach 1 (for x = ∞) | |
| - The slope of the CDF at any point equals the PDF value at that point | |
| """ | |
| ) | |
| mo.vstack([_img, _explanation]) | |
| return (create_pdf_cdf_comparison,) | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## Solving for Constants in PDFs | |
| Many PDFs contain a constant that needs to be determined to ensure the total probability equals 1. Let's work through an example to understand how to solve for these constants. | |
| ### Example: Finding the Constant $C$ | |
| Let $X$ be a continuous random variable with PDF: | |
| $$f(x) = \begin{cases} | |
| C(4x - 2x^2) & \text{when } 0 < x < 2 \\ | |
| 0 & \text{otherwise} | |
| \end{cases}$$ | |
| In this function, $C$ is a constant we need to determine. Since we know the PDF must integrate to 1: | |
| \begin{align} | |
| &\int_0^2 C(4x - 2x^2) \, dx = 1 \\ | |
| &C\left(2x^2 - \frac{2x^3}{3}\right)\bigg|_0^2 = 1 \\ | |
| &C\left[\left(8 - \frac{16}{3}\right) - 0 \right] = 1 \\ | |
| &C\left(\frac{24 - 16}{3}\right) = 1 \\ | |
| &C\left(\frac{8}{3}\right) = 1 \\ | |
| &C = \frac{3}{8} | |
| \end{align} | |
| Now that we know $C = \frac{3}{8}$, we can compute probabilities. For example, what is $P(X > 1)$? | |
| \begin{align} | |
| P(X > 1) | |
| &= \int_1^{\infty}f(x) \, dx \\ | |
| &= \int_1^2 \frac{3}{8}(4x - 2x^2) \, dx \\ | |
| &= \frac{3}{8}\left(2x^2 - \frac{2x^3}{3}\right)\bigg|_1^2 \\ | |
| &= \frac{3}{8}\left[\left(8 - \frac{16}{3}\right) - \left(2 - \frac{2}{3}\right)\right] \\ | |
| &= \frac{3}{8}\left[\left(8 - \frac{16}{3}\right) - \left(\frac{6 - 2}{3}\right)\right] \\ | |
| &= \frac{3}{8}\left[\left(\frac{24 - 16}{3}\right) - \left(\frac{4}{3}\right)\right] \\ | |
| &= \frac{3}{8}\left[\left(\frac{8}{3}\right) - \left(\frac{4}{3}\right)\right] \\ | |
| &= \frac{3}{8} \cdot \frac{4}{3} \\ | |
| &= \frac{1}{2} | |
| \end{align} | |
| Let's visualize this distribution and verify our results: | |
| """ | |
| ) | |
| return | |
| def _( | |
| create_example_pdf_visualization, | |
| fig_to_image, | |
| mo, | |
| symbolic_calculation, | |
| ): | |
| # Create visualization | |
| _fig = create_example_pdf_visualization() | |
| _img = mo.image(fig_to_image(_fig), width="100%") | |
| # Symbolic calculation | |
| _sympy_verification = mo.md(symbolic_calculation()) | |
| _explanation = mo.md( | |
| r""" | |
| The figure above shows: | |
| 1. **Left**: The PDF $f(x) = \frac{3}{8}(4x - 2x^2)$ for $0 < x < 2$, with the area representing P(X > 1) shaded in orange. | |
| 2. **Right**: The corresponding CDF, showing F(1) = 0.5 and thus P(X > 1) = 1 - F(1) = 0.5. | |
| Notice how we: | |
| 1. First determined the constant C = 3/8 by ensuring the total area under the PDF equals 1 | |
| 2. Used this value to calculate specific probabilities like P(X > 1) | |
| 3. Verified our results both graphically and symbolically | |
| """ | |
| ) | |
| mo.vstack([_img, _sympy_verification, _explanation]) | |
| return | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## Expectation and Variance of Continuous Random Variables | |
| Just as with discrete random variables, we can calculate the expectation and variance of continuous random variables. The main difference is that we use integrals instead of sums. | |
| ### Expectation (Mean) | |
| For a continuous random variable $X$ with PDF $f(x)$, the expectation is: | |
| $$E[X] = \int_{-\infty}^{\infty} x \cdot f(x) \, dx$$ | |
| More generally, for any function $g(X)$: | |
| $$E[g(X)] = \int_{-\infty}^{\infty} g(x) \cdot f(x) \, dx$$ | |
| ### Variance | |
| The variance is defined the same way as for discrete random variables: | |
| $$\text{Var}(X) = E[(X - \mu)^2] = E[X^2] - (E[X])^2$$ | |
| where $\mu = E[X]$ is the mean of $X$. | |
| To calculate $E[X^2]$, we use: | |
| $$E[X^2] = \int_{-\infty}^{\infty} x^2 \cdot f(x) \, dx$$ | |
| ### Properties | |
| The following properties hold for both continuous and discrete random variables: | |
| 1. $E[aX + b] = aE[X] + b$ for constants $a$ and $b$ | |
| 2. $\text{Var}(aX + b) = a^2 \text{Var}(X)$ for constants $a$ and $b$ | |
| Let's calculate the expectation and variance for our example PDF: | |
| """ | |
| ) | |
| return | |
| def _(fig_to_image, mo, np, plt, sympy): | |
| # Symbolic calculation of expectation and variance | |
| def symbolic_stats_calc(): | |
| x = sympy.symbols('x') | |
| C = sympy.Rational(3, 8) | |
| # Define the PDF | |
| pdf_expr = C * (4*x - 2*x**2) | |
| # Calculate expectation | |
| E_X = sympy.integrate(x * pdf_expr, (x, 0, 2)) | |
| # Calculate E[X²] | |
| E_X2 = sympy.integrate(x**2 * pdf_expr, (x, 0, 2)) | |
| # Calculate variance | |
| Var_X = E_X2 - E_X**2 | |
| # Calculate standard deviation | |
| Std_X = sympy.sqrt(Var_X) | |
| return E_X, E_X2, Var_X, Std_X | |
| # Get symbolic results | |
| E_X, E_X2, Var_X, Std_X = symbolic_stats_calc() | |
| # Numerical values for plotting | |
| E_X_val = float(E_X) | |
| Var_X_val = float(Var_X) | |
| Std_X_val = float(Std_X) | |
| def create_expectation_variance_vis(): | |
| """Create visualization showing mean and variance for the example PDF.""" | |
| fig, ax = plt.subplots(figsize=(10, 6)) | |
| # x-values | |
| x = np.linspace(-0.5, 2.5, 1000) | |
| # PDF function | |
| C = 3/8 | |
| pdf = np.where((x > 0) & (x < 2), C * (4*x - 2*x**2), 0) | |
| # Plot the PDF | |
| ax.plot(x, pdf, 'b-', linewidth=2, label='PDF') | |
| ax.fill_between(x, pdf, where=(x > 0) & (x < 2), alpha=0.3, color='blue') | |
| # Mark the mean | |
| ax.axvline(x=E_X_val, color='r', linestyle='--', linewidth=2, | |
| label=f'Mean (E[X] = {E_X_val:.3f})') | |
| # Mark the standard deviation range | |
| ax.axvspan(E_X_val - Std_X_val, E_X_val + Std_X_val, alpha=0.2, color='green', | |
| label=f'±1 Std Dev ({Std_X_val:.3f})') | |
| # Add labels and title | |
| ax.set_xlabel('x') | |
| ax.set_ylabel('Probability Density') | |
| ax.set_title('PDF with Mean and Variance') | |
| ax.legend() | |
| ax.grid(alpha=0.3) | |
| # Set x-limits | |
| ax.set_xlim(-0.25, 2.25) | |
| plt.tight_layout() | |
| return fig | |
| # Create the visualization | |
| _fig = create_expectation_variance_vis() | |
| _img = mo.image(fig_to_image(_fig), width="100%") | |
| # Detailed calculations for our example | |
| _calculations = mo.md( | |
| f""" | |
| ### Calculating Expectation and Variance for Our Example | |
| Let's calculate the expectation and variance for the PDF: | |
| $$f(x) = \\begin{{cases}} | |
| \\frac{{3}}{{8}}(4x - 2x^2) & \\text{{when }} 0 < x < 2 \\\\ | |
| 0 & \\text{{otherwise}} | |
| \\end{{cases}}$$ | |
| #### Expectation Calculation | |
| $$E[X] = \\int_{{-\\infty}}^{{\\infty}} x \\cdot f(x) \\, dx = \\int_0^2 x \\cdot \\frac{{3}}{{8}}(4x - 2x^2) \\, dx$$ | |
| $$E[X] = \\frac{{3}}{{8}} \\int_0^2 (4x^2 - 2x^3) \\, dx = \\frac{{3}}{{8}} \\left[ \\frac{{4x^3}}{{3}} - \\frac{{2x^4}}{{4}} \\right]_0^2$$ | |
| $$E[X] = \\frac{{3}}{{8}} \\left[ \\frac{{4 \\cdot 2^3}}{{3}} - \\frac{{2 \\cdot 2^4}}{{4}} - 0 \\right] = \\frac{{3}}{{8}} \\left[ \\frac{{32}}{{3}} - 4 \\right]$$ | |
| $$E[X] = \\frac{{3}}{{8}} \\cdot \\frac{{32 - 12}}{{3}} = \\frac{{3}}{{8}} \\cdot \\frac{{20}}{{3}} = \\frac{{20}}{{8}} = {E_X}$$ | |
| #### Variance Calculation | |
| First, we need $E[X^2]$: | |
| $$E[X^2] = \\int_{{-\\infty}}^{{\\infty}} x^2 \\cdot f(x) \\, dx = \\int_0^2 x^2 \\cdot \\frac{{3}}{{8}}(4x - 2x^2) \\, dx$$ | |
| $$E[X^2] = \\frac{{3}}{{8}} \\int_0^2 (4x^3 - 2x^4) \\, dx = \\frac{{3}}{{8}} \\left[ \\frac{{4x^4}}{{4}} - \\frac{{2x^5}}{{5}} \\right]_0^2$$ | |
| $$E[X^2] = \\frac{{3}}{{8}} \\left[ 4 - \\frac{{2 \\cdot 32}}{{5}} - 0 \\right] = \\frac{{3}}{{8}} \\left[ 4 - \\frac{{64}}{{5}} \\right]$$ | |
| $$E[X^2] = \\frac{{3}}{{8}} \\cdot \\frac{{20 - 64/5}}{{1}} = {E_X2}$$ | |
| Now we can calculate the variance: | |
| $$\\text{{Var}}(X) = E[X^2] - (E[X])^2 = {E_X2} - ({E_X})^2 = {Var_X}$$ | |
| Therefore, the standard deviation is $\\sqrt{{\\text{{Var}}(X)}} = {Std_X}$. | |
| """ | |
| ) | |
| mo.vstack([_img, _calculations]) | |
| return ( | |
| E_X, | |
| E_X2, | |
| E_X_val, | |
| Std_X, | |
| Std_X_val, | |
| Var_X, | |
| Var_X_val, | |
| create_expectation_variance_vis, | |
| symbolic_stats_calc, | |
| ) | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## 🤔 Test Your Understanding | |
| Select which of these statements about continuous distributions you think are correct: | |
| /// details | The PDF of a continuous random variable can have values greater than 1 | |
| ✅ Correct! Since the PDF represents density (not probability), it can exceed 1 as long as the total area under the curve equals 1. | |
| /// | |
| /// details | For a continuous distribution, $P(X = a) > 0$ for any value $a$ in the support | |
| ❌ Incorrect! For continuous random variables, the probability of the random variable taking any specific exact value is always 0. That is, $P(X = a) = 0$ for any value $a$. | |
| /// | |
| /// details | The area under a PDF curve between $a$ and $b$ equals the probability $P(a \leq X \leq b)$ | |
| ✅ Correct! The area under the PDF curve over an interval gives the probability that the random variable falls within that interval. | |
| /// | |
| /// details | The CDF function $F(x)$ is always equal to $\int_{-\infty}^{x} f(t) \, dt$ | |
| ✅ Correct! The CDF at point $x$ is the integral of the PDF from negative infinity to $x$. | |
| /// | |
| /// details | For a continuous random variable, $F(x)$ ranges from 0 to the maximum value in the support of the random variable | |
| ❌ Incorrect! The CDF $F(x)$ ranges from 0 to 1, representing probabilities. It approaches 1 (not the maximum value in the support) as $x$ approaches infinity. | |
| /// | |
| /// details | To calculate the variance of a continuous random variable, we use the formula $\text{Var}(X) = E[X^2] - (E[X])^2$ | |
| ✅ Correct! This formula applies to both discrete and continuous random variables. | |
| /// | |
| """ | |
| ) | |
| return | |
| def _(mo): | |
| mo.md( | |
| r""" | |
| ## Summary | |
| Moving from discrete to continuous thinking is a big conceptual leap, but it opens up powerful ways to model real-world phenomena. | |
| In this notebook, we've seen how continuous random variables let us model quantities that can take any real value. Instead of dealing with probabilities at specific points (which are actually zero!), we work with probability density functions (PDFs) and find probabilities by calculating areas under curves. | |
| Some key points to remember: | |
| • PDFs give us relative likelihood, not actual probabilities - that's why they can exceed 1 | |
| • The probability between two points is the area under the PDF curve | |
| • CDFs offer a convenient shortcut to find probabilities without integrating | |
| • Expectation and variance work similarly to discrete variables, just with integrals instead of sums | |
| • Constants in PDFs are determined by ensuring the total probability equals 1 | |
| This foundation will serve you well as we explore specific continuous distributions like normal, exponential, and beta in future notebooks. These distributions are the workhorses of probability theory and statistics, appearing everywhere from quality control to financial modeling. | |
| One final thought: continuous distributions are beautiful mathematical objects, but remember they're just models. Real-world data is often discrete at some level, but continuous distributions provide elegant approximations that make calculations more tractable. | |
| """ | |
| ) | |
| return | |
| def _(mo): | |
| mo.md(r"""Appendix code (helper functions, variables, etc.):""") | |
| return | |
| def _(): | |
| import marimo as mo | |
| return (mo,) | |
| def _(): | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import scipy.stats as stats | |
| import sympy | |
| from scipy import integrate as scipy | |
| import polars as pl | |
| import altair as alt | |
| from wigglystuff import TangleSlider | |
| return TangleSlider, alt, np, pl, plt, scipy, stats, sympy | |
| def _(): | |
| import io | |
| import base64 | |
| from matplotlib.figure import Figure | |
| # Helper function to convert mpl figure to an image format mo.image can handle | |
| def fig_to_image(fig): | |
| buf = io.BytesIO() | |
| fig.savefig(buf, format='png') | |
| buf.seek(0) | |
| data = f"data:image/png;base64,{base64.b64encode(buf.read()).decode('utf-8')}" | |
| return data | |
| return Figure, base64, fig_to_image, io | |
| def _(np, plt): | |
| def create_pdf_visualization(a, b, distribution='uniform'): | |
| fig, ax = plt.subplots(figsize=(10, 6)) | |
| # x-values | |
| x = np.linspace(-0.5, 5.5, 1000) | |
| # Various PDFs to visualize | |
| if distribution == 'uniform': | |
| # Uniform distribution from 0 to 5 | |
| y = np.where((x >= 0) & (x <= 5), 0.2, 0) | |
| title = f"Uniform PDF from 0 to 5" | |
| elif distribution == 'triangular': | |
| # Triangular distribution peaked at 2.5 | |
| y = np.where(x <= 2.5, x/6.25, (5-x)/6.25) # peak at 2.5 | |
| y = np.where((x < 0) | (x > 5), 0, y) | |
| title = f"Triangular PDF from 0 to 5" | |
| elif distribution == 'exponential': | |
| lambda_param = 0.5 | |
| y = np.where(x >= 0, lambda_param * np.exp(-lambda_param * x), 0) | |
| title = f"Exponential PDF with λ = {lambda_param}" | |
| # Plot PDF | |
| ax.plot(x, y, 'b-', linewidth=2, label='PDF $f(x)$') | |
| # Shade the area for the probability P(a ≤ X ≤ b) | |
| mask = (x >= a) & (x <= b) | |
| ax.fill_between(x[mask], y[mask], color='orange', alpha=0.5) | |
| # Calculate the probability | |
| dx = x[1] - x[0] | |
| probability = np.sum(y[mask]) * dx | |
| # vertical lines at a and b | |
| ax.axvline(x=a, color='r', linestyle='--', alpha=0.7, | |
| label=f'a = {a:.1f}') | |
| ax.axvline(x=b, color='g', linestyle='--', alpha=0.7, | |
| label=f'b = {b:.1f}') | |
| # horizontal line at y=0 | |
| ax.axhline(y=0, color='black', linestyle='-', alpha=0.3) | |
| # labels and title | |
| ax.set_xlabel('x') | |
| ax.set_ylabel('Probability Density $f(x)$') | |
| ax.set_title(title) | |
| ax.legend(loc='upper right') | |
| # relevant annotations | |
| ax.annotate(f'$P({a:.1f} \leq X \leq {b:.1f}) = {probability:.4f}$', | |
| xy=(0.5, 0.9), xycoords='axes fraction', | |
| bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.8), | |
| horizontalalignment='center', fontsize=12) | |
| plt.grid(alpha=0.3) | |
| plt.tight_layout() | |
| plt.gca() | |
| return fig, probability | |
| return (create_pdf_visualization,) | |
| def _(np, plt, sympy): | |
| def create_example_pdf_visualization(): | |
| fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) | |
| # x-values | |
| x = np.linspace(-0.5, 2.5, 1000) | |
| # PDF function | |
| C = 3/8 | |
| pdf = np.where((x > 0) & (x < 2), C * (4*x - 2*x**2), 0) | |
| # CDF | |
| cdf = np.zeros_like(x) | |
| for i, val in enumerate(x): | |
| if val <= 0: | |
| cdf[i] = 0 | |
| elif val >= 2: | |
| cdf[i] = 1 | |
| else: | |
| # Analytical form: C*(2x^2 - 2x^3/3) | |
| cdf[i] = C * (2*val**2 - (2*val**3)/3) | |
| # PDF Plot | |
| ax1.plot(x, pdf, 'b-', linewidth=2) | |
| ax1.set_title('PDF: $f(x) = \\frac{3}{8}(4x - 2x^2)$ for $0 < x < 2$') | |
| ax1.set_xlabel('x') | |
| ax1.set_ylabel('Probability Density') | |
| ax1.grid(alpha=0.3) | |
| # Highlight the area for P(X > 1) | |
| mask = (x > 1) & (x < 2) | |
| ax1.fill_between(x[mask], pdf[mask], color='orange', alpha=0.5, | |
| label='P(X > 1) = 0.5') | |
| # Add vertical line at x=1 | |
| ax1.axvline(x=1, color='r', linestyle='--', alpha=0.7) | |
| ax1.legend() | |
| # CDF Plot | |
| ax2.plot(x, cdf, 'r-', linewidth=2) | |
| ax2.set_title('CDF: $F(x)$ for the Example Distribution') | |
| ax2.set_xlabel('x') | |
| ax2.set_ylabel('Cumulative Probability') | |
| ax2.grid(alpha=0.3) | |
| # Mark appropriate (F(1) & F(2)) points) | |
| ax2.plot(1, cdf[np.abs(x-1).argmin()], 'ro', markersize=8) | |
| ax2.plot(2, cdf[np.abs(x-2).argmin()], 'ro', markersize=8) | |
| # annotations | |
| F_1 = C * (2*1**2 - (2*1**3)/3) # F(1) | |
| ax2.annotate(f'F(1) = {F_1:.3f}', xy=(1, F_1), xytext=(1.1, 0.4), | |
| arrowprops=dict(facecolor='black', shrink=0.05, width=1)) | |
| ax2.annotate(f'F(2) = 1', xy=(2, 1), xytext=(1.7, 0.8), | |
| arrowprops=dict(facecolor='black', shrink=0.05, width=1)) | |
| ax2.annotate(f'P(X > 1) = 1 - F(1) = {1-F_1:.3f}', xy=(1.5, 0.7), | |
| bbox=dict(boxstyle='round,pad=0.5', facecolor='orange', alpha=0.2)) | |
| # common x-limits | |
| for ax in [ax1, ax2]: | |
| ax.set_xlim(-0.25, 2.25) | |
| plt.tight_layout() | |
| plt.gca() | |
| return fig | |
| def symbolic_calculation(): | |
| x = sympy.symbols('x') | |
| C = sympy.Rational(3, 8) | |
| # PDF defn | |
| pdf_expr = C * (4*x - 2*x**2) | |
| # Verify PDF integrates to 1 | |
| total_prob = sympy.integrate(pdf_expr, (x, 0, 2)) | |
| # Calculate P(X > 1) | |
| prob_gt_1 = sympy.integrate(pdf_expr, (x, 1, 2)) | |
| return f"""Symbolic calculation verification: | |
| 1. Total probability: ∫₀² {C}(4x - 2x²) dx = {total_prob} | |
| 2. P(X > 1): ∫₁² {C}(4x - 2x²) dx = {prob_gt_1} | |
| """ | |
| return create_example_pdf_visualization, symbolic_calculation | |
| if __name__ == "__main__": | |
| app.run() | |