# /// script # requires-python = ">=3.10" # dependencies = [ # "marimo", # "matplotlib==3.10.8", # "scipy==1.17.1", # "wigglystuff==0.2.37", # "numpy==2.4.3", # ] # /// import marimo __generated_with = "0.18.4" app = marimo.App(width="medium", app_title="Normal Distribution") @app.cell(hide_code=True) def _(mo): mo.md(r""" # Normal Distribution _This notebook is a computational companion to ["Probability for Computer Scientists"](https://chrispiech.github.io/probabilityForComputerScientists/en/part2/normal/), by Stanford professor Chris Piech._ The Normal (also known as Gaussian) distribution is one of the most important probability distributions in statistics and data science. It's characterized by a symmetric bell-shaped curve and is fully defined by two parameters: mean (μ) and variance (σ²). """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## Normal Random Variable Definition The Normal (or Gaussian) random variable is denoted as: $$X \sim \mathcal{N}(\mu, \sigma^2)$$ Where: - $X$ is our random variable - $\mathcal{N}$ indicates it follows a Normal distribution - $\mu$ is the mean parameter - $\sigma^2$ is the variance parameter (sometimes written as $\sigma$ for standard deviation) ``` X ~ N(μ, σ²) ↑ ↑ ↑ ↑ | | | +-- Variance (spread) | | | of the distribution | | +-- Mean (center) | | of the distribution | +-- Indicates Normal | distribution | Our random variable ``` The Normal distribution is particularly important for many reasons: 1. It arises naturally from the sum of independent random variables (Central Limit Theorem) 2. It appears frequently in natural phenomena 3. It is the maximum entropy distribution given a fixed mean and variance 4. It simplifies many mathematical calculations in statistics and probability """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## Properties of Normal Distribution | Property | Formula | |----------|---------| | Notation | $X \sim \mathcal{N}(\mu, \sigma^2)$ | | Description | A common, naturally occurring distribution | | Parameters | $\mu \in \mathbb{R}$, the mean
$\sigma^2 \in \mathbb{R}^+$, the variance | | Support | $x \in \mathbb{R}$ | | PDF equation | $f(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{1}{2}(\frac{x-\mu}{\sigma})^2}$ | | CDF equation | $F(x) = \Phi(\frac{x-\mu}{\sigma})$ where $\Phi$ is the CDF of the standard normal | | Expectation | $E[X] = \mu$ | | Variance | $\text{Var}(X) = \sigma^2$ | The PDF (Probability Density Function) reaches its maximum value at $x = \mu$, where the exponent becomes zero and $e^0 = 1$. """) return @app.cell(hide_code=True) def _(mean_slider, mo, std_slider): mo.md( f""" The figure below shows a comparison between: - The **Standard Normal Distribution** (purple curve): N(0, 1) - A **Normal Distribution** with the parameters you selected (blue curve) Adjust the mean (μ) {mean_slider} and standard deviation (σ) {std_slider} below to see how the normal distribution changes shape. """ ) return @app.cell(hide_code=True) def _( create_distribution_comparison, fig_to_image, mean_slider, mo, std_slider, ): # values from the sliders current_mu = mean_slider.amount current_sigma = std_slider.amount # Create plot comparison_fig = create_distribution_comparison(current_mu, current_sigma) # Call, convert and display comp_image = mo.image(fig_to_image(comparison_fig), width="100%") comp_image return @app.cell(hide_code=True) def _(mean_slider, mo, std_slider): mo.md( f""" ## Interactive Normal Distribution Visualization The shape of a normal distribution is determined by two key parameters: - The **mean (μ):** {mean_slider} controls the center of the distribution. - The **standard deviation (σ):** {std_slider} controls the spread (width) of the distribution. Try adjusting these parameters to see how they affect the shape of the distribution below: """ ) return @app.cell(hide_code=True) def _(create_normal_pdf_plot, fig_to_image, mean_slider, mo, std_slider): # value from widgets _current_mu = mean_slider.amount _current_sigma = std_slider.amount # Create visualization pdf_fig = create_normal_pdf_plot(_current_mu, _current_sigma) # Display plot pdf_image = mo.image(fig_to_image(pdf_fig), width="100%") pdf_explanation = mo.md( r""" **Understanding the Normal Distribution Visualization:** - **PDF (top)**: The probability density function shows the relative likelihood of different values. The highest point occurs at the mean (μ). - **Shaded regions**: The green shaded areas represent: - μ ± 1σ: Contains approximately 68.3% of the probability - μ ± 2σ: Contains approximately 95.5% of the probability - μ ± 3σ: Contains approximately 99.7% of the probability (the "68-95-99.7 rule") - **CDF (bottom)**: The cumulative distribution function shows the probability that X is less than or equal to a given value. - At x = μ, the CDF equals 0.5 (50% probability) - At x = μ + σ, the CDF equals approximately 0.84 (84% probability) - At x = μ - σ, the CDF equals approximately 0.16 (16% probability) """ ) mo.vstack([pdf_image, pdf_explanation]) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## Standard Normal Distribution The **Standard Normal Distribution** is a special case of the normal distribution where $\mu = 0$ and $\sigma = 1$. We denote it as: $$Z \sim \mathcal{N}(0, 1)$$ This distribution is particularly important because: 1. Any normal distribution can be transformed into the standard normal 2. Statistical tables and calculations often use the standard normal as a reference ### Standardizing a Normal Random Variable For any normal random variable $X \sim \mathcal{N}(\mu, \sigma^2)$, we can transform it to the standard normal $Z$ using: $$Z = \frac{X - \mu}{\sigma}$$ Let's see the mathematical derivation: \begin{align*} W &= \frac{X -\mu}{\sigma} && \text{Subtract by $\mu$ and divide by $\sigma$} \\ &= \frac{1}{\sigma}X - \frac{\mu}{\sigma} && \text{Use algebra to rewrite the equation}\\ &= aX + b && \text{Linear transform where $a = \frac{1}{\sigma}$, $b = -\frac{\mu}{\sigma}$}\\ &\sim \mathcal{N}(a\mu + b, a^2\sigma^2) && \text{The linear transform of a Normal is another Normal}\\ &\sim \mathcal{N}\left(\frac{\mu}{\sigma} - \frac{\mu}{\sigma}, \frac{\sigma^2}{\sigma^2}\right) && \text{Substitute values for $a$ and $b$}\\ &\sim \mathcal{N}(0, 1) && \text{The standard normal} \end{align*} This transformation is the foundation for many statistical tests and probability calculations. """) return @app.cell(hide_code=True) def _(create_standardization_plot, fig_to_image, mo): # Create and display visualization stand_fig = create_standardization_plot() # Display stand_image = mo.image(fig_to_image(stand_fig), width="100%") stand_explanation = mo.md( r""" **Standardizing a Normal Distribution: A Two-Step Process** The visualization above shows the process of transforming any normal distribution to the standard normal: 1. **Shift the distribution** (left plot): First, we subtract the mean (μ) from X, centering the distribution at 0. 2. **Scale the distribution** (right plot): Next, we divide by the standard deviation (σ), which adjusts the spread to match the standard normal. The resulting standard normal distribution Z ~ N(0,1) has a mean of 0 and a variance of 1. This transformation allows us to use standardized tables and calculations for any normal distribution. """ ) mo.vstack([stand_image, stand_explanation]) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## Linear Transformations of Normal Variables One useful property of the normal distribution is that linear transformations of normal random variables remain normal. If $X \sim \mathcal{N}(\mu, \sigma^2)$ and $Y = aX + b$ (where $a$ and $b$ are constants), then: $$Y \sim \mathcal{N}(a\mu + b, a^2\sigma^2)$$ This means: - The mean is transformed by $a\mu + b$ - The variance is transformed by $a^2\sigma^2$ This property is extremely useful in statistics and probability calculations, as it allows us to easily determine the _distribution_ of transformed variables. """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## Calculating Probabilities with the Normal CDF Unlike many other distributions, the normal distribution does not have a closed-form expression for its CDF. However, we can use the standard normal CDF (denoted as $\Phi$) to calculate probabilities. For any normal random variable $X \sim \mathcal{N}(\mu, \sigma^2)$, the CDF is: $$F_X(x) = P(X \leq x) = \Phi\left(\frac{x - \mu}{\sigma}\right)$$ Where $\Phi$ is the CDF of the standard normal distribution. ### Derivation \begin{align*} F_X(x) &= P(X \leq x) \\ &= P\left(\frac{X - \mu}{\sigma} \leq \frac{x - \mu}{\sigma}\right) \\ &= P\left(Z \leq \frac{x - \mu}{\sigma}\right) \\ &= \Phi\left(\frac{x - \mu}{\sigma}\right) \end{align*} Let's look at some examples of calculating probabilities with normal distributions. """) return @app.cell(hide_code=True) def _(mo): mo.md(""" ## Examples of Normal Distributions """) return @app.cell(hide_code=True) def _(create_probability_example, fig_to_image, mo): # Create visualization default_mu = 3 default_sigma = 4 default_query = 0 prob_fig, prob_value, ex_z_score = create_probability_example(default_mu, default_sigma, default_query) # Display prob_image = mo.image(fig_to_image(prob_fig), width="100%") prob_explanation = mo.md( f""" **Example: Let X ~ N(3, 16), what is P(X > 0)?** To solve this probability question: 1. First, we standardize the query value: Z = (x - μ) / σ = (0 - 3) / 4 = -0.75 2. Then we calculate using the standard normal CDF: P(X > 0) = P(Z > -0.75) = 1 - P(Z ≤ -0.75) = 1 - Φ(-0.75) 3. Because the standard normal is symmetric: 1 - Φ(-0.75) = Φ(0.75) = {prob_value:.3f} The shaded orange area in the graph represents this probability of approximately {prob_value:.3f}. """ ) mo.vstack([prob_image, prob_explanation]) return @app.cell(hide_code=True) def _(create_range_probability_example, fig_to_image, mo, stats): # Create visualization default_range_mu = 3 default_range_sigma = 4 default_range_lower = 2 default_range_upper = 5 range_fig, range_prob, range_z_lower, range_z_upper = create_range_probability_example( default_range_mu, default_range_sigma, default_range_lower, default_range_upper) # Display range_image = mo.image(fig_to_image(range_fig), width="100%") range_explanation = mo.md( f""" **Example: Let X ~ N(3, 16), what is P(2 < X < 5)?** To solve this range probability question: 1. First, we standardize both bounds: Z_lower = (lower - μ) / σ = (2 - 3) / 4 = -0.25 Z_upper = (upper - μ) / σ = (5 - 3) / 4 = 0.5 2. Then we calculate using the standard normal CDF: P(2 < X < 5) = P(-0.25 < Z < 0.5) = Φ(0.5) - Φ(-0.25) = Φ(0.5) - (1 - Φ(0.25)) = Φ(0.5) + Φ(0.25) - 1 3. Computing these values: = {stats.norm.cdf(0.5):.3f} + {stats.norm.cdf(0.25):.3f} - 1 = {range_prob:.3f} The shaded orange area in the graph represents this probability of approximately {range_prob:.3f}. """ ) mo.vstack([range_image, range_explanation]) return @app.cell(hide_code=True) def _(create_voltage_example_visualization, fig_to_image, mo): # Create visualization voltage_fig, voltage_error_prob = create_voltage_example_visualization() # Display voltage_image = mo.image(fig_to_image(voltage_fig), width="100%") voltage_explanation = mo.md( r""" **Example: Signal Transmission with Noise** In this example, we're sending digital signals over a wire: - We send voltage 2 to represent a binary "1" - We send voltage -2 to represent a binary "0" The received signal R is the sum of the transmitted voltage (X) and random noise (Y): R = X + Y, where Y ~ N(0, 1) When decoding, we use a threshold of 0.5: - If R ≥ 0.5, we interpret it as "1" - If R < 0.5, we interpret it as "0" Let's calculate the probability of error when sending a "1" (voltage = 2): \begin{align*} P(\text{Error when sending "1"}) &= P(X + Y < 0.5) \\ &= P(2 + Y < 0.5) \\ &= P(Y < -1.5) \\ &= \Phi(-1.5) \\ &\approx 0.067 \end{align*} Therefore, the probability of incorrectly decoding a transmitted "1" as "0" is approximately 6.7%. The orange shaded area in the plot represents this error probability. """ ) mo.vstack([voltage_image, voltage_explanation]) return @app.cell(hide_code=True) def emirical_rule(mo): mo.md(r""" ## The 68-95-99.7 Rule (Empirical Rule) One of the most useful properties of the normal distribution is the "[68-95-99.7 rule](https://en.wikipedia.org/wiki/68-95-99.7_rule)," which states that: - Approximately 68% of the data falls within 1 standard deviation of the mean - Approximately 95% of the data falls within 2 standard deviations of the mean - Approximately 99.7% of the data falls within 3 standard deviations of the mean Let's verify this with a calculation for the 68% rule: \begin{align} P(\mu - \sigma < X < \mu + \sigma) &= P(X < \mu + \sigma) - P(X < \mu - \sigma) \\ &= \Phi\left(\frac{(\mu + \sigma)-\mu}{\sigma}\right) - \Phi\left(\frac{(\mu - \sigma)-\mu}{\sigma}\right) \\ &= \Phi\left(\frac{\sigma}{\sigma}\right) - \Phi\left(\frac{-\sigma}{\sigma}\right) \\ &= \Phi(1) - \Phi(-1) \\ &\approx 0.8413 - 0.1587 \\ &\approx 0.6826 \approx 68.3\% \end{align} This calculation works for any normal distribution, regardless of the values of $\mu$ and $\sigma$! """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" The Cumulative Distribution Function (CDF) gives the probability that a random variable is less than or equal to a specific value. Use the interactive calculator below to compute CDF values for a normal distribution. """) return @app.cell(hide_code=True) def _(mo, mu_slider, sigma_slider, x_slider): mo.md( f""" ## Interactive Normal CDF Calculator Use the sliders below to explore different probability calculations: **Query value (x):** {x_slider} — The value at which to evaluate F(x) = P(X ≤ x) **Mean (μ):** {mu_slider} — The center of the distribution **Standard deviation (σ):** {sigma_slider} — The spread of the distribution (larger σ means more spread) """ ) return @app.cell(hide_code=True) def _( create_cdf_calculator_plot, fig_to_image, mo, mu_slider, sigma_slider, x_slider, ): # Values from widgets calc_x = x_slider.amount calc_mu = mu_slider.amount calc_sigma = sigma_slider.amount # Create visualization calc_fig, cdf_value = create_cdf_calculator_plot(calc_x, calc_mu, calc_sigma) # Standardized z-score calc_z_score = (calc_x - calc_mu) / calc_sigma # Display calc_image = mo.image(fig_to_image(calc_fig), width="100%") calc_result = mo.md( f""" ### Results: For a Normal distribution with parameters μ = {calc_mu:.1f} and σ = {calc_sigma:.1f}: - The value x = {calc_x:.1f} corresponds to a z-score of z = {calc_z_score:.3f} - The CDF value F({calc_x:.1f}) = P(X ≤ {calc_x:.1f}) = {cdf_value:.3f} - This means the probability that X is less than or equal to {calc_x:.1f} is {cdf_value*100:.1f}% **Computing this in Python:** ```python from scipy import stats # Using the one-line method p = stats.norm.cdf({calc_x:.1f}, {calc_mu:.1f}, {calc_sigma:.1f}) # OR using the two-line method X = stats.norm({calc_mu:.1f}, {calc_sigma:.1f}) p = X.cdf({calc_x:.1f}) ``` **Note:** In SciPy's `stats.norm`, the second parameter is the standard deviation (σ), not the variance (σ²). """ ) mo.vstack([calc_image, calc_result]) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## 🤔 Test Your Understanding Test your knowledge with these true/false questions about normal distributions: /// details | For a normal random variable X ~ N(μ, σ²), the probability that X takes on exactly the value μ is highest among all possible values. **✅ True** While the PDF is indeed highest at x = μ, making this the most likely value in terms of density, remember that for continuous random variables, the probability of any exact value is zero. The statement refers to the density function being maximized at the mean. /// /// details | The probability that a normal random variable X equals any specific exact value (e.g., P(X = 3)) is always zero. **✅ True** For continuous random variables including the normal, the probability of any exact value is zero. Probabilities only make sense for ranges of values, which is why we integrate the PDF over intervals. /// /// details | If X ~ N(μ, σ²), then aX + b ~ N(aμ + b, a²σ²) for any constants a and b. **✅ True** Linear transformations of normal random variables remain normal, with the given transformation of the parameters. This is a key property that makes normal distributions particularly useful. /// /// details | If X ~ N(5, 9) and Y ~ N(3, 4) are independent, then X + Y ~ N(8, 5). **❌ False** While the mean of the sum is indeed the sum of the means (5 + 3 = 8), the variance of the sum is the sum of the variances (9 + 4 = 13), not 5. The correct distribution would be X + Y ~ N(8, 13). /// """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" ## Summary We've taken a tour of Normal distributions; probably the most famous probability distribution you'll encounter in statistics. It's that nice bell-shaped curve that shows up everywhere from heights/ weights to memes to measurement errors & stock returns. The Normal distribution isn't just pretty — it's incredibly practical. With just two parameters (mean and standard deviation), you can describe complex phenomena and make powerful predictions. Plus, thanks to the Central Limit Theorem, many random processes naturally converge to this distribution, which is why it's so prevalent. **What we covered:** - The mathematical definition and key properties of Normal random variables - How to transform any Normal distribution to the standard Normal - Calculating probabilities using the CDF (no more looking up values in those tiny tables in the back of textbooks or Clark's table!) Whether you're analyzing data, designing experiments, or building ML models, the concepts we explored provide a solid foundation for working with this fundamental distribution. """) return @app.cell(hide_code=True) def _(mo): mo.md(r""" Appendix (helper code and functions) """) return @app.cell def _(): import marimo as mo return (mo,) @app.cell(hide_code=True) def _(): from wigglystuff import TangleSlider return (TangleSlider,) @app.cell(hide_code=True) def _(np, plt, stats): def create_normal_pdf_plot(mu, sigma): # Range for x values (show μ ± 4σ) x = np.linspace(mu - 4*sigma, mu + 4*sigma, 1000) pdf = stats.norm.pdf(x, mu, sigma) # Calculate CDF values cdf = stats.norm.cdf(x, mu, sigma) # Create plot with two subplots for (PDF and CDF) pdf_fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8)) # PDF plot ax1.plot(x, pdf, color='royalblue', linewidth=2, label='PDF') ax1.fill_between(x, pdf, color='royalblue', alpha=0.2) # Vertical line at mean ax1.axvline(x=mu, color='red', linestyle='--', linewidth=1.5, label=f'Mean: μ = {mu:.1f}') # Stdev regions for i in range(1, 4): alpha = 0.1 if i > 1 else 0.2 percentage = 100*stats.norm.cdf(i) - 100*stats.norm.cdf(-i) label = f'μ ± {i}σ: {percentage:.1f}%' if i == 1 else None ax1.axvspan(mu - i*sigma, mu + i*sigma, alpha=alpha, color='green', label=label) # Annotations ax1.annotate(f'μ = {mu:.1f}', xy=(mu, max(pdf)*0.15), xytext=(mu+0.5*sigma, max(pdf)*0.4), arrowprops=dict(facecolor='black', width=1, shrink=0.05)) ax1.annotate(f'σ = {sigma:.1f}', xy=(mu+sigma, stats.norm.pdf(mu+sigma, mu, sigma)), xytext=(mu+1.5*sigma, stats.norm.pdf(mu+sigma, mu, sigma)*1.5), arrowprops=dict(facecolor='black', width=1, shrink=0.05)) # some styling ax1.set_title(f'Normal Distribution PDF: N({mu:.1f}, {sigma:.1f}²)') ax1.set_xlabel('x') ax1.set_ylabel('Probability Density: f(x)') ax1.legend(loc='upper right') ax1.grid(alpha=0.3) # CDF plot ax2.plot(x, cdf, color='darkorange', linewidth=2, label='CDF') # key CDF values mark key_points = [ (mu-sigma, stats.norm.cdf(mu-sigma, mu, sigma), "16%"), (mu, 0.5, "50%"), (mu+sigma, stats.norm.cdf(mu+sigma, mu, sigma), "84%") ] for point, value, label in key_points: ax2.plot(point, value, 'ro') ax2.annotate(f'{label}', xy=(point, value), xytext=(point+0.2*sigma, value-0.1), arrowprops=dict(facecolor='black', width=1, shrink=0.05)) # CDF styling ax2.set_title(f'Normal Distribution CDF: N({mu:.1f}, {sigma:.1f}²)') ax2.set_xlabel('x') ax2.set_ylabel('Cumulative Probability: F(x)') ax2.grid(alpha=0.3) plt.tight_layout() return pdf_fig return (create_normal_pdf_plot,) @app.cell(hide_code=True) def _(base64, io): from matplotlib.figure import Figure # convert matplotlib figures to images (helper code) def fig_to_image(fig): buf = io.BytesIO() fig.savefig(buf, format='png', bbox_inches='tight') buf.seek(0) img_str = base64.b64encode(buf.getvalue()).decode('utf-8') return f"data:image/png;base64,{img_str}" return (fig_to_image,) @app.cell(hide_code=True) def _(): # Import libraries import numpy as np import matplotlib.pyplot as plt from scipy import stats import io import base64 return base64, io, np, plt, stats @app.cell(hide_code=True) def _(TangleSlider, mo): mean_slider = mo.ui.anywidget(TangleSlider( amount=0, min_value=-5, max_value=5, step=0.1, digits=1 )) std_slider = mo.ui.anywidget(TangleSlider( amount=1, min_value=0.1, max_value=3, step=0.1, digits=1 )) return mean_slider, std_slider @app.cell(hide_code=True) def _(TangleSlider, mo): x_slider = mo.ui.anywidget(TangleSlider( amount=0, min_value=-5, max_value=5, step=0.1, digits=1 )) mu_slider = mo.ui.anywidget(TangleSlider( amount=0, min_value=-5, max_value=5, step=0.1, digits=1 )) sigma_slider = mo.ui.anywidget(TangleSlider( amount=1, min_value=0.1, max_value=3, step=0.1, digits=1 )) return mu_slider, sigma_slider, x_slider @app.cell(hide_code=True) def _(np, plt, stats): def create_distribution_comparison(mu=5, sigma=6): # Create figure and axis comparison_fig, ax = plt.subplots(figsize=(10, 6)) # X range for plotting x = np.linspace(-10, 20, 1000) # Standard normal std_normal = stats.norm.pdf(x, 0, 1) # Our example normal example_normal = stats.norm.pdf(x, mu, sigma) # Plot both distributions ax.plot(x, std_normal, 'darkviolet', linewidth=2, label='Standard Normal') ax.plot(x, example_normal, 'blue', linewidth=2, label=f'X ~ N({mu}, {sigma}²)') # format the plot ax.set_xlim(-10, 20) ax.set_ylim(0, 0.45) ax.set_xlabel('x') ax.set_ylabel('Probability Density') ax.grid(True, alpha=0.3) ax.legend() # Decorative text box for parameters props = dict(boxstyle='round', facecolor='white', alpha=0.9) textstr = '\n'.join(( r'Normal (aka Gaussian) Random Variable', r'', rf'Parameter $\mu$: {mu}', rf'Parameter $\sigma$: {sigma}' )) ax.text(0.05, 0.95, textstr, transform=ax.transAxes, fontsize=10, verticalalignment='top', bbox=props) return comparison_fig return (create_distribution_comparison,) @app.cell(hide_code=True) def _(np, plt, stats): def create_voltage_example_visualization(): # Create data for plotting x = np.linspace(-4, 4, 1000) # Signal without noise (X = 2) signal_value = 2 # Noise distribution (Y ~ N(0, 1)) noise_pdf = stats.norm.pdf(x, 0, 1) # Signal + Noise distribution (R = X + Y ~ N(2, 1)) received_pdf = stats.norm.pdf(x, signal_value, 1) # Create figure voltage_fig, ax = plt.subplots(figsize=(10, 6)) # Plot the noise distribution ax.plot(x, noise_pdf, 'blue', linewidth=1.5, alpha=0.6, label='Noise: Y ~ N(0, 1)') # received signal distribution ax.plot(x, received_pdf, 'red', linewidth=2, label=f'Received: R ~ N({signal_value}, 1)') # vertical line at the decision boundary (0.5) threshold = 0.5 ax.axvline(x=threshold, color='green', linestyle='--', linewidth=2, label=f'Decision threshold: {threshold}') # Shade the error region mask = x < threshold error_prob = stats.norm.cdf(threshold, signal_value, 1) ax.fill_between(x[mask], received_pdf[mask], color='darkorange', alpha=0.5, label=f'Error probability: {error_prob:.3f}') # Styling ax.set_title('Voltage Transmission Example: Probability of Error') ax.set_xlabel('Voltage') ax.set_ylabel('Probability Density') ax.legend(loc='upper left') ax.grid(alpha=0.3) # Add explanatory annotations ax.text(1.5, 0.1, 'When sending "1" (voltage=2),\nthis area represents\nthe error probability', bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="black", lw=1)) plt.tight_layout() plt.gca() return voltage_fig, error_prob return (create_voltage_example_visualization,) @app.cell(hide_code=True) def _(np, plt, stats): def create_cdf_calculator_plot(calc_x, calc_mu, calc_sigma): # Data range for plotting x_range = np.linspace(calc_mu - 4*calc_sigma, calc_mu + 4*calc_sigma, 1000) pdf = stats.norm.pdf(x_range, calc_mu, calc_sigma) cdf = stats.norm.cdf(x_range, calc_mu, calc_sigma) # Calculate the CDF at x cdf_at_x = stats.norm.cdf(calc_x, calc_mu, calc_sigma) # Create figure with two subplots calc_fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8)) # Plot PDF on top subplot ax1.plot(x_range, pdf, color='royalblue', linewidth=2, label='PDF') # area shade for P(X ≤ x) mask = x_range <= calc_x ax1.fill_between(x_range[mask], pdf[mask], color='darkorange', alpha=0.6) # Vertical line at x ax1.axvline(x=calc_x, color='red', linestyle='--', linewidth=1.5) # PDF labels and styling ax1.set_title(f'Normal PDF with Area P(X ≤ {calc_x:.1f}) Highlighted') ax1.set_xlabel('x') ax1.set_ylabel('Probability Density') ax1.annotate(f'x = {calc_x:.1f}', xy=(calc_x, 0), xytext=(calc_x, -0.01), horizontalalignment='center', color='red') ax1.grid(alpha=0.3) # CDF on bottom subplot ax2.plot(x_range, cdf, color='green', linewidth=2, label='CDF') # Mark the point (x, CDF(x)) ax2.plot(calc_x, cdf_at_x, 'ro', markersize=8) # CDF labels and styling ax2.set_title(f'Normal CDF: F({calc_x:.1f}) = {cdf_at_x:.3f}') ax2.set_xlabel('x') ax2.set_ylabel('Cumulative Probability') ax2.annotate(f'F({calc_x:.1f}) = {cdf_at_x:.3f}', xy=(calc_x, cdf_at_x), xytext=(calc_x + 0.5*calc_sigma, cdf_at_x - 0.1), arrowprops=dict(facecolor='black', width=1, shrink=0.05), bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="black", lw=1)) ax2.grid(alpha=0.3) plt.tight_layout() plt.gca() return calc_fig, cdf_at_x return (create_cdf_calculator_plot,) @app.cell(hide_code=True) def _(np, plt, stats): def create_standardization_plot(): x = np.linspace(-6, 6, 1000) # Original distribution N(2, 1.5²) mu_original, sigma_original = 2, 1.5 pdf_original = stats.norm.pdf(x, mu_original, sigma_original) # shifted distribution N(0, 1.5²) mu_shifted, sigma_shifted = 0, 1.5 pdf_shifted = stats.norm.pdf(x, mu_shifted, sigma_shifted) # Standard normal N(0, 1) mu_standard, sigma_standard = 0, 1 pdf_standard = stats.norm.pdf(x, mu_standard, sigma_standard) # Create visualization stand_fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) # Plot on left: Original and shifted distributions ax1.plot(x, pdf_original, 'royalblue', linewidth=2, label=f'Original: N({mu_original}, {sigma_original}²)') ax1.plot(x, pdf_shifted, 'darkorange', linewidth=2, label=f'Shifted: N({mu_shifted}, {sigma_shifted}²)') # Add arrow to show the shift shift_x1, shift_y1 = mu_original, stats.norm.pdf(mu_original, mu_original, sigma_original)*0.6 shift_x2, shift_y2 = mu_shifted, stats.norm.pdf(mu_shifted, mu_shifted, sigma_shifted)*0.6 ax1.annotate('', xy=(shift_x2, shift_y2), xytext=(shift_x1, shift_y1), arrowprops=dict(facecolor='black', width=1.5, shrink=0.05)) ax1.text(0.8, 0.28, 'Subtract μ', transform=ax1.transAxes) # Plot on right: Shifted and standard normal ax2.plot(x, pdf_shifted, 'darkorange', linewidth=2, label=f'Shifted: N({mu_shifted}, {sigma_shifted}²)') ax2.plot(x, pdf_standard, 'green', linewidth=2, label=f'Standard: N({mu_standard}, {sigma_standard}²)') # Add arrow to show the scaling scale_x1, scale_y1 = 2*sigma_shifted, stats.norm.pdf(2*sigma_shifted, mu_shifted, sigma_shifted)*0.8 scale_x2, scale_y2 = 2*sigma_standard, stats.norm.pdf(2*sigma_standard, mu_standard, sigma_standard)*0.8 ax2.annotate('', xy=(scale_x2, scale_y2), xytext=(scale_x1, scale_y1), arrowprops=dict(facecolor='black', width=1.5, shrink=0.05)) ax2.text(0.75, 0.5, 'Divide by σ', transform=ax2.transAxes) # some styling for ax in (ax1, ax2): ax.set_xlabel('x') ax.set_ylabel('Probability Density') ax.grid(alpha=0.3) ax.legend() ax1.set_title('Step 1: Shift the Distribution') ax2.set_title('Step 2: Scale the Distribution') plt.tight_layout() plt.gca() return stand_fig return (create_standardization_plot,) @app.cell(hide_code=True) def _(np, plt, stats): def create_probability_example(example_mu=3, example_sigma=4, example_query=0): # Create data range x = np.linspace(example_mu - 4*example_sigma, example_mu + 4*example_sigma, 1000) pdf = stats.norm.pdf(x, example_mu, example_sigma) # probability calc prob_value = 1 - stats.norm.cdf(example_query, example_mu, example_sigma) ex_z_score = (example_query - example_mu) / example_sigma # Create visualization prob_fig, ax = plt.subplots(figsize=(10, 6)) # Plot PDF ax.plot(x, pdf, 'royalblue', linewidth=2) # area shading representing the probability mask = x >= example_query ax.fill_between(x[mask], pdf[mask], color='darkorange', alpha=0.6) # Add vertical line at query point ax.axvline(x=example_query, color='red', linestyle='--', linewidth=1.5) # Annotations ax.annotate(f'x = {example_query}', xy=(example_query, 0), xytext=(example_query, -0.005), horizontalalignment='center') ax.annotate(f'P(X > {example_query}) = {prob_value:.3f}', xy=(example_query + example_sigma, 0.015), xytext=(example_query + 1.5*example_sigma, 0.02), arrowprops=dict(facecolor='black', width=1, shrink=0.05), bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="black", lw=1)) # Standard normal calculation annotation ax.annotate(f'= P(Z > {ex_z_score:.3f}) = {prob_value:.3f}', xy=(example_query - example_sigma, 0.01), xytext=(example_query - 2*example_sigma, 0.015), arrowprops=dict(facecolor='black', width=1, shrink=0.05), bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="black", lw=1)) # some styling ax.set_title(f'Example: P(X > {example_query}) where X ~ N({example_mu}, {example_sigma}²)') ax.set_xlabel('x') ax.set_ylabel('Probability Density') ax.grid(alpha=0.3) plt.tight_layout() plt.gca() return prob_fig, prob_value, ex_z_score return (create_probability_example,) @app.cell(hide_code=True) def _(np, plt, stats): def create_range_probability_example(range_mu=3, range_sigma=4, range_lower=2, range_upper=5): x = np.linspace(range_mu - 4*range_sigma, range_mu + 4*range_sigma, 1000) pdf = stats.norm.pdf(x, range_mu, range_sigma) # probability range_prob = stats.norm.cdf(range_upper, range_mu, range_sigma) - stats.norm.cdf(range_lower, range_mu, range_sigma) range_z_lower = (range_lower - range_mu) / range_sigma range_z_upper = (range_upper - range_mu) / range_sigma # Create visualization range_fig, ax = plt.subplots(figsize=(10, 6)) # Plot PDF ax.plot(x, pdf, 'royalblue', linewidth=2) # Shade the area representing the probability mask = (x >= range_lower) & (x <= range_upper) ax.fill_between(x[mask], pdf[mask], color='darkorange', alpha=0.6) # Add vertical lines at query points ax.axvline(x=range_lower, color='red', linestyle='--', linewidth=1.5) ax.axvline(x=range_upper, color='red', linestyle='--', linewidth=1.5) # Annotations ax.annotate(f'x = {range_lower}', xy=(range_lower, 0), xytext=(range_lower, -0.005), horizontalalignment='center') ax.annotate(f'x = {range_upper}', xy=(range_upper, 0), xytext=(range_upper, -0.005), horizontalalignment='center') ax.annotate(f'P({range_lower} < X < {range_upper}) = {range_prob:.3f}', xy=((range_lower + range_upper)/2, max(pdf[mask])/2), xytext=((range_lower + range_upper)/2, max(pdf[mask])*1.5), arrowprops=dict(facecolor='black', width=1, shrink=0.05), bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="black", lw=1), horizontalalignment='center') # Standard normal calculation annotation ax.annotate(f'= P({range_z_lower:.3f} < Z < {range_z_upper:.3f}) = {range_prob:.3f}', xy=((range_lower + range_upper)/2, max(pdf[mask])/3), xytext=(range_mu - 2*range_sigma, max(pdf[mask])/1.5), arrowprops=dict(facecolor='black', width=1, shrink=0.05), bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="black", lw=1)) ax.set_title(f'Example: P({range_lower} < X < {range_upper}) where X ~ N({range_mu}, {range_sigma}²)') ax.set_xlabel('x') ax.set_ylabel('Probability Density') ax.grid(alpha=0.3) plt.tight_layout() plt.gca() return range_fig, range_prob, range_z_lower, range_z_upper return (create_range_probability_example,) if __name__ == "__main__": app.run()