Introduction

Hello! I'm currently experimenting with more interactive notebook playgrounds to visually explore statistics and AI/ML! This is a first draft of a notebook diving into the wonders of Bayes' Theorem and conditional probability, enjoy!

Molab Notebook

• Migrate blog posts from interactive-blog to /posts.

  • Enable pretty printing + line highlighting with Shiki
  • Replace custom Pyodide implementation with Marimo notebooks (either widgets/iframes or islands 🏝️ (experimental feat))

• Upload updated resume

• Add more photos

• Update projects (and project categories to reflect topics e.g. CS+SG, etc.) and demos page with additional repos/videos

• Update bookmarks

• Add blogs for inspiration note

• Update media

• Confirm that math works (may need to fiddle with mathjax3 CSS more to fix aligns!)

• Confirm that code renders work

• Add custom art simulations (a la plum/dots)

• write up little blog on OG image generation - perhaps make a tool for it as well!

• write up a little blog on link minifier (and other projects - maybe case studies for more serious projects? or i could do multi-part blogs...)

• write up smaller blog posts on fundamentals from stats, CS, HDS, potential projects

• write paper breakdowns, dl, mi fundamentals, learnings from ai/ml in hc

• aim to write 1/week, if not faster (shorter possibly too)

• add bookmarks for visualization

Completed

• Move this code to new repo: nikhil-vytla/nikhilvytla.com
• Setup Netlify
• Remove domain name redirect from old site: nikhil-vytla.github.io

Introduction & Motivation

What is causal representation learning? It involves methods that aim not to extract low-dimensional features, but to encode the causal factors of variation underlying observed data. To move beyond distributional robustness, we seek models that can reason under interventions and support counterfactual queries. This requires mathematical tools from causal inference and practical algorithms to discover disentangled, causally-meaningful representations.

Generative Model & SCM Formalization

Let $\mathbf{x} \in \mathbb{R}^D$ be an observed datapoint. Assume that $\mathbf{x}$ is generated by underlying causal variables $\mathbf{z} = [z_1, ..., z_K]$. Under a Structural Causal Model (SCM):

$$
z_j = f_j(\mathrm{PA}_j, n_j), \quad \text{where} ~ n_j ~\text{i.i.d. noise}, ; \mathrm{PA}_j=\text{parents of }z_j
\mathbf{x} = g(\mathbf{z}, n_x)
$$

Goal: Find an encoder $E: \mathbf{x} \mapsto \mathbf{\hat{z}}$ s.t. $\mathbf{\hat{z}}$ is (approximately) causally correct and disentangled. We would like

$$
\text{do}(\hat{z}_k = c) \implies \text{systematic change in observation corresponding to } z_k
$$

Common Approaches & Algorithms

• FactorVAE, BetaVAE: Encourage disentanglement via penalizing total correlation of $q(\mathbf{z}|\mathbf{x})$.
• CausalVAE: Explicit structure priors enforce relations between $z_i$ reflecting causal graph.
• Invariant Risk Minimization (IRM): Learn features $\Phi(\mathbf{x})$ such that $\arg\min_{w} \sum_{e\in \mathcal{E}} R^e(w \circ \Phi)$ yields an invariant predictor across environments.

# Example: FactorVAE loss (PyTorch-like pseudocode)
def factor_vae_loss(x, encoder, decoder, discriminator):
    z_mu, z_logvar = encoder(x)
    z = reparameterize(z_mu, z_logvar)
    recon_x = decoder(z)
    recon_loss = F.mse_loss(recon_x, x)
    tc = total_correlation(z, discriminator)
    return recon_loss + beta * tc

Key Concepts & Equations

• Total Correlation: $\mathrm{TC}(\mathbf{z}) = \mathrm{KL}(q(\mathbf{z}) ,\Vert, \prod_j q(z_j))$ (measures independence of latent dimensions)
• Identifiability: Under certain conditions (e.g., multiple environments, known interventions), causal features are learnable.
• Structural Hamming Distance: For causal graph evaluation, $\mathrm{SHD}(G_1,G_2)$ counts mismatched edges between graphs.

Mathematical Example:

# SCM causal simulation
def scm_sim():
    x1 = np.random.normal()
    x2 = 2*x1 + np.random.normal()
    x3 = x2 - x1 + np.random.normal()
    return np.stack([x1, x2, x3])

This code simulates a simple, linear SCM. Changing ("intervening on") $x_1$ propagates through the system.

Evaluation Metrics

• Modularity: Measure sensitivity of each dimension $z_j$ to changes in data or interventions.
• Disentanglement: Metrics like DCI and Mutual Information Gap (MIG).

Open Challenges

• Proving identifiability with finite data.
• Efficient algorithms for high-dimensional, non-linear SCMs.
• Bridging deep learning and graphical model causal theory.

References

1. Locatello et al. (2019). Challenging Common Assumptions in the Unsupervised Learning of Disentangled Representations
2. Schölkopf et al. (2021). Towards Causal Representation Learning
3. Subramanian et al. (2022) Learning Latent Structural Causal Models

Here's some example Markdown syntax.

Headings

The following HTML <h1>—<h6> elements represent six levels of section headings. <h1> is the highest section level while <h6> is the lowest.

H1

H2

H3

H4

H5

H6

H7

Paragraph

Xerum, quo qui aut unt expliquam qui dolut labo. Aque venitatiusda cum, voluptionse latur sitiae dolessi aut parist aut dollo enim qui voluptate ma dolestendit peritin re plis aut quas inctum laceat est volestemque commosa as cus endigna tectur, offic to cor sequas etum rerum idem sintibus eiur? Quianimin porecus evelectur, cum que nis nust voloribus ratem aut omnimi, sitatur? Quiatem. Nam, omnis sum am facea corem alique molestrunt et eos evelece arcillit ut aut eos eos nus, sin conecerem erum fuga. Ri oditatquam, ad quibus unda veliamenimin cusam et facea ipsamus es exerum sitate dolores editium rerore eost, temped molorro ratiae volorro te reribus dolorer sperchicium faceata tiustia prat.

Itatur? Quiatae cullecum rem ent aut odis in re eossequodi nonsequ idebis ne sapicia is sinveli squiatum, core et que aut hariosam ex eat.

Images

Syntax

![Alt text](./full/or/relative/path/of/image)

Output

Blockquotes

The blockquote element represents content that is quoted from another source, optionally with citations which may be within a footer or cite element, and optionally with in-line changes such as annotations and abbreviations.

Blockquote without attribution

Syntax

> Tiam, ad mint andaepu dandae nostion secatur sequo quae.
> **Note** that you can use _Markdown syntax_ within a blockquote.

Output

Tiam, ad mint andaepu dandae nostion secatur sequo quae.
Note that you can use Markdown syntax within a blockquote.

Blockquote with attribution

Syntax

> Don't communicate by sharing memory, share memory by communicating.<br>
> — <cite>Rob Pike[^1]</cite>

Output

Don't communicate by sharing memory, share memory by communicating.

— Rob Pike[^1]

Citations/Footnotes

Syntax

[^1]: The above quote is excerpted from Rob Pike's [talk](https://www.youtube.com/watch?v=PAAkCSZUG1c) during Gopherfest, November 18, 2015.

Output

See bottom of page.

[^1]: The above quote is excerpted from Rob Pike's talk during Gopherfest, November 18, 2015.

Tables

Syntax

| Italics   | Bold     | Code   |
| --------- | -------- | ------ |
| _italics_ | **bold** | `code` |

Output

Colors

Syntax

- <span font-bold font-mono text-amber>MAJOR</span>: Increment when you make incompatible API changes.
- <span font-bold font-mono text-lime>MINOR</span>: Increment when you add functionality in a backwards-compatible manner.
- <span font-bold font-mono text-blue>PATCH</span>: Increment when you make backwards-compatible bug fixes.

Output

• MAJOR: Increment when you make incompatible API changes.
• MINOR: Increment when you add functionality in a backwards-compatible manner.
• PATCH: Increment when you make backwards-compatible bug fixes.

Math/Equation Rendering

We use MathJax for rendering LaTeX. Here are a few examples of algorithms and equations:

Merge sort

Syntax

The time complexity of merge sort is $O(n \log n)$.

The recursive relation is:

$$
T(n) = \begin{cases}
1 & \text{if } n = 1 \\
2T(n/2) + n & \text{if } n > 1
\end{cases}
$$

Big-O notation: $\textcolor{cyan}{f(n)} = O(\textcolor{magenta}{g(n)})$ means $\exists \textcolor{red}{c}, n_0$ such that $\textcolor{cyan}{f(n)} \leq \textcolor{red}{c} \cdot \textcolor{magenta}{g(n)}$ for all $n \geq n_0$.

Output

The time complexity of merge sort is $O(n \log n)$.

The recursive relation is:

$$
T(n) = \begin{cases}
1 & \text{if } n = 1 \
2T(n/2) + n & \text{if } n > 1
\end{cases}
$$

Big-O notation: $\textcolor{cyan}{f(n)} = O(\textcolor{magenta}{g(n)})$ means $\exists \textcolor{red}{c}, n_0$ such that $\textcolor{cyan}{f(n)} \leq \textcolor{red}{c} \cdot \textcolor{magenta}{g(n)}$ for all $n \geq n_0$.

Maxwell's Equations

Syntax

In table form:
| equation | description |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| $\nabla \cdot \vec{\mathbf{B}}  = 0$ | divergence of $\vec{\mathbf{B}}$ is zero |
| $\nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t}  = \vec{\mathbf{0}}$ | curl of $\vec{\mathbf{E}}$ is proportional to the rate of change of $\vec{\mathbf{B}}$ |
| $\nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} = \frac{4\pi}{c}\vec{\mathbf{j}}    \nabla \cdot \vec{\mathbf{E}} = 4 \pi \rho$ | _???_ |

In array form:

$$
\begin{array}{c}
\nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} &
= \frac{4\pi}{c}\vec{\mathbf{j}}    \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
\nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
\nabla \cdot \vec{\mathbf{B}} & = 0
\end{array}
$$

Output

In table form:

In array form:

$$
\begin{array}{c}
\nabla \times \vec{\mathbf{B}} -, \frac1c, \frac{\partial\vec{\mathbf{E}}}{\partial t} &
= \frac{4\pi}{c}\vec{\mathbf{j}} \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \
\nabla \times \vec{\mathbf{E}}, +, \frac1c, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \
\nabla \cdot \vec{\mathbf{B}} & = 0
\end{array}
$$

Homomorphism

Syntax

A homomorphism is a map between two algebraic structures of the same type (that is of the same name), that preserves the operations of the structures. This means a map $f:A \to B$ between two sets $A$, $B$ equipped with the same structure such that, if $\cdot$ is an operation of the structure (supposed here, for simplification, to be a binary operation), then

$$
\begin{equation}
f(x\cdot y)=f(x)\cdot f(y)
\end{equation}
$$

for every pair $x$, $y$ of element of $A$. One says often that $f$ preserves the operation or is compatible with the operation.

Formally, a map $f:A \to B$ preserves an operation $\mu$ of arity $\mathsf{k}$, defined on both $A$ and $B$ if

$$
\begin{equation}
f(\mu_A(a_1,\ldots,a_k))=\mu_B(f(a_1),\ldots,f(a_k))
\end{equation}
$$

for all elements $a_1,\ldots,a_k$ in $A$.

Output

A homomorphism is a map between two algebraic structures of the same type (that is of the same name), that preserves the operations of the structures. This means a map $f:A \to B$ between two sets $A$, $B$ equipped with the same structure such that, if $\cdot$ is an operation of the structure (supposed here, for simplification, to be a binary operation), then

$$
\begin{equation}
f(x\cdot y)=f(x)\cdot f(y)
\end{equation}
$$

for every pair $x$, $y$ of element of $A$. One says often that $f$ preserves the operation or is compatible with the operation.

Formally, a map $f:A \to B$ preserves an operation $\mu$ of arity $\mathsf{k}$, defined on both $A$ and $B$ if

$$
\begin{equation}
f(\mu_A(a_1,\ldots,a_k))=\mu_B(f(a_1),\ldots,f(a_k))
\end{equation}
$$

for all elements $a_1,\ldots,a_k$ in $A$.

Code Blocks

Syntax

We can use 3 backticks ``` on a new line, write our code snippet, and then close with 3 backticks on another new line. To highlight language specific syntax, we can type the language name after the first 3 backticks (e.g. html, javascript, css, markdown, typescript, txt, bash, python, etc).

```html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Example HTML5 Document</title>
  </head>
  <body>
    <p>Test</p>
  </body>
</html>
```

Output

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Example HTML5 Document</title>
  </head>
  <body>
    <p>Test</p>
  </body>
</html>

More Code Renders

Syntax

[!NOTE]
Only some transformers have been configured, see https://shiki.style/packages/transformers for more!

Output

// transformerNotationDiff
console.log('hewwo') // [!code --]
console.log('hello') // [!code ++]
console.log('goodbye')

# transformerNotationHighlight
from sklearn.linear_model import LinearRegression

model = LinearRegression().fit([[1], [2], [3]], [2, 4, 6]) # [!code hl]
print(model.predict([[4]]))  # Output: [8]

# transformerNotationWordHighlight
# [!code word:RandomForestClassifier]
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
print(RandomForestClassifier().fit(X, y).score(X, y))  # ~0.97

# transformerNotationFocus
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True) # [!code focus]
print(RandomForestClassifier().fit(X, y).score(X, y))  # ~0.97

// transformerNotationErrorLevel
console.log('No errors or warnings')
console.error('Error') // [!code error]
console.warn('Warning') // [!code warning]

// transformerMetaHighlight
console.log('2')
console.log('3')
console.log('4')
console.log('5')

// transformerMetaWordHighlight
const msg = 'Hello World'
console.log(msg)
console.log(msg) // prints Hello World

List Types

Ordered List

Syntax

1. First item
2. Second item
3. Third item

Output

1. First item
2. Second item
3. Third item

Unordered List

Syntax

- List item
- Another item
- And another item

Output

• List item
• Another item
• And another item

Nested list

Syntax

- Fruit
  - Apple
  - Orange
  - Banana
- Dairy
  - Milk
  - Cheese

Output

• Fruit
  • Apple
  • Orange
  • Banana
• Dairy
  • Milk
  • Cheese

Other Elements — abbr, sub, sup, kbd, mark

Syntax

<abbr title="Graphics Interchange Format">GIF</abbr> is a bitmap image format.

H<sub>2</sub>O

X<sup>n</sup> + Y<sup>n</sup> = Z<sup>n</sup>

Press <kbd>CTRL</kbd> + <kbd>ALT</kbd> + <kbd>Delete</kbd> to end the session.

Most <mark>salamanders</mark> are nocturnal, and hunt for insects, worms, and other small creatures.

Output

GIF is a bitmap image format.

H₂O

Xⁿ + Yⁿ = Zⁿ

Press CTRL + ALT + Delete to end the session.

Most salamanders are nocturnal, and hunt for insects, worms, and other small creatures.

Testing out Marimo

Quick Recap

New to the Central Limit Theorem? Start with Part 1 first!

For everyone else: The CLT tells us that sample means become normally distributed, regardless of the original data distribution. With samples of n ≥ 30, we can make confident statements about populations using statistics. Now let's put this power to work!

Real-World Case Study: Battery Factory Quality Control

The Scenario

You're a quality control manager at a smartphone battery factory. Your boss wants batteries that last at least 20 hours on average, but testing every single battery would be expensive and time-consuming. Plus, some tests are destructive!

The Challenge:

• 🏭 Population: Millions of batteries produced daily
• ❓ Unknown: True population mean battery life
• 🎯 Goal: Determine if a batch meets the 20-hour requirement
• 💰 Constraint: Can only test a small sample due to cost

Enter the CLT Hero

The Central Limit Theorem saves the day! Here's how:

1. Sample: Test 50 batteries from a batch (n = 50 > 30 ✓)
2. Results: Sample mean = 20.3 hours, sample std = 2.1 hours
3. Apply CLT: The sampling distribution of means is approximately normal
4. Make Decision: Use confidence intervals to assess the entire batch

The Mathematical Solution

Using the CLT, we can construct a 95% confidence interval:

$$
\bar{x} \pm t_{\alpha/2} \frac{s}{\sqrt{n}} = 20.3 \pm 2.01 \frac{2.1}{\sqrt{50}} = 20.3 \pm 0.60
$$

Result: We're 95% confident the true population mean is between 19.70 and 20.90 hours.

Decision: Since the entire confidence interval is above 20 hours, we can confidently approve this batch for shipment! 🚀

Why This Works (The CLT Magic)

1. Large Enough Sample: n = 50 is sufficient for CLT to kick in
2. Normal Distribution: Sample means follow a normal distribution regardless of how individual battery lives are distributed
3. Predictable Precision: Standard error = $\frac{\sigma}{\sqrt{n}}$ decreases as sample size increases
4. Quantified Uncertainty: We know exactly how confident we can be

Complete Code Implementation

import numpy as np
from scipy import stats
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Simulate the battery testing scenario
np.random.seed(42)

# Create a realistic battery population (slightly skewed, mean ~20.3)
true_population = np.random.gamma(shape=4, scale=5.075, size=100000)

# Sample 50 batteries for testing
sample_data = np.random.choice(true_population, 50)

# Calculate sample statistics
sample_mean = np.mean(sample_data)
sample_std = np.std(sample_data, ddof=1)  # ddof=1 for sample std
n = len(sample_data)

# 95% confidence interval using CLT
# Using t-distribution since we don't know population std
margin_of_error = stats.t.ppf(0.975, n-1) * (sample_std / np.sqrt(n))
ci_lower = sample_mean - margin_of_error
ci_upper = sample_mean + margin_of_error

# Display results
print("🔋 Battery Quality Control Results")
print("=" * 40)
print(f"Sample size: {n} batteries")
print(f"Sample mean: {sample_mean:.2f} hours")
print(f"Sample std: {sample_std:.2f} hours")
print(f"95% Confidence Interval: [{ci_lower:.2f}, {ci_upper:.2f}] hours")
print(f"Meets 20-hour requirement: {'✅ YES' if ci_lower > 20 else '❌ NO'}")
print(f"Margin of error: ±{margin_of_error:.2f} hours")

# Create visualization
fig = make_subplots(
    rows=2, cols=2,
    subplot_titles=["Population Distribution", "Sample Data",
                   "Confidence Interval", "Sampling Distribution"],
    specs=[[{"type": "histogram"}, {"type": "histogram"}],
           [{"type": "scatter"}, {"type": "histogram"}]]
)

# Population distribution
fig.add_trace(
    go.Histogram(x=true_population[:1000], name="Population",
                histnorm="probability density", showlegend=False),
    row=1, col=1
)

# Sample data
fig.add_trace(
    go.Histogram(x=sample_data, name="Sample",
                histnorm="probability density", showlegend=False),
    row=1, col=2
)

# Confidence interval visualization
ci_x = [ci_lower, ci_upper, ci_upper, ci_lower, ci_lower]
ci_y = [0, 0, 1, 1, 0]
fig.add_trace(
    go.Scatter(x=ci_x, y=ci_y, fill="toself", name="95% CI",
              fillcolor="lightblue", line=dict(color="blue")),
    row=2, col=1
)
fig.add_vline(x=sample_mean, line=dict(color="red", width=3),
              annotation_text=f"Sample Mean: {sample_mean:.2f}h",
              row=2, col=1)
fig.add_vline(x=20, line=dict(color="green", width=2, dash="dash"),
              annotation_text="Requirement: 20h",
              row=2, col=1)

# Sampling distribution (theoretical)
x_range = np.linspace(sample_mean - 3*margin_of_error,
                     sample_mean + 3*margin_of_error, 100)
sampling_dist = stats.norm.pdf(x_range, sample_mean, sample_std/np.sqrt(n))
fig.add_trace(
    go.Scatter(x=x_range, y=sampling_dist, mode="lines",
              name="Sampling Distribution", line=dict(color="purple")),
    row=2, col=2
)

fig.update_layout(height=600, title="CLT in Action: Battery Quality Control")
fig.show()

Confidence Intervals: Your Statistical Superpower

Once you understand CLT, confidence intervals become your go-to tool for making decisions with uncertainty. The general formula is:

$$
\text{Estimate} \pm \text{Margin of Error}
$$

Where the margin of error depends on:

• Confidence Level: How sure do you want to be? (90%, 95%, 99%)
• Sample Size: Larger samples = smaller margin of error
• Variability: More spread in data = larger margin of error

Confidence Level Trade-offs

# Compare different confidence levels
confidence_levels = [0.90, 0.95, 0.99]
colors = ['green', 'blue', 'red']

fig = go.Figure()

for i, conf_level in enumerate(confidence_levels):
    alpha = 1 - conf_level
    t_critical = stats.t.ppf(1 - alpha/2, n-1)
    margin = t_critical * (sample_std / np.sqrt(n))

    # Add confidence interval
    fig.add_shape(
        type="rect",
        x0=sample_mean - margin, x1=sample_mean + margin,
        y0=i*0.3, y1=(i+1)*0.3,
        fillcolor=colors[i], opacity=0.3,
        line=dict(color=colors[i], width=2)
    )

    fig.add_annotation(
        x=sample_mean, y=i*0.3 + 0.15,
        text=f"{conf_level*100:.0f}%: ±{margin:.2f}",
        showarrow=False
    )

fig.add_vline(x=sample_mean, line=dict(color="black", width=2))
fig.add_vline(x=20, line=dict(color="orange", width=2, dash="dash"))

fig.update_layout(
    title="Confidence Level Trade-offs",
    xaxis_title="Battery Life (hours)",
    yaxis_title="Confidence Level",
    height=400
)
fig.show()

Key Insight: Higher confidence = wider intervals. There's always a trade-off between certainty and precision!

Interactive Challenge: Test Your Understanding

Scenario: You're analyzing customer satisfaction scores (1-10 scale) for a new app. You survey 40 users and get a mean of 7.2 with a standard deviation of 1.8.

Questions:

1. Can you apply the CLT here? (Check: n ≥ 30? ✓)
2. What's the 95% confidence interval for the true mean satisfaction?
3. If you wanted a margin of error of only ±0.2, how many users would you need to survey?

Try it yourself, then check the solution below!

import numpy as np
from scipy import stats

# Given data
n = 40
sample_mean = 7.2
sample_std = 1.8

# 95% confidence interval
margin_of_error = stats.t.ppf(0.975, n-1) * (sample_std / np.sqrt(n))
ci_lower = sample_mean - margin_of_error
ci_upper = sample_mean + margin_of_error

print(f"95% CI: [{ci_lower:.2f}, {ci_upper:.2f}]")

# For margin of error = 0.2
desired_margin = 0.2
z_score = 1.96  # for 95% confidence
required_n = ((z_score * sample_std) / desired_margin) ** 2

print(f"Required sample size for ±0.2 margin: {int(np.ceil(required_n))} users")

# Visualization
fig = go.Figure()

# Current confidence interval
fig.add_shape(
    type="rect",
    x0=ci_lower, x1=ci_upper, y0=0, y1=1,
    fillcolor="lightblue", opacity=0.5,
    line=dict(color="blue", width=2)
)

# Desired confidence interval
desired_ci_lower = sample_mean - desired_margin
desired_ci_upper = sample_mean + desired_margin
fig.add_shape(
    type="rect",
    x0=desired_ci_lower, x1=desired_ci_upper, y0=1.2, y1=2.2,
    fillcolor="lightgreen", opacity=0.5,
    line=dict(color="green", width=2)
)

fig.add_vline(x=sample_mean, line=dict(color="red", width=3))

fig.add_annotation(x=sample_mean, y=0.5, text=f"Current: n={n}", showarrow=False)
fig.add_annotation(x=sample_mean, y=1.7, text=f"Desired: n={int(np.ceil(required_n))}", showarrow=False)

fig.update_layout(
    title="Sample Size vs. Precision Trade-off",
    xaxis_title="Satisfaction Score",
    yaxis_title="",
    height=300
)
fig.show()

What CLT Doesn't Do (Important Limitations)

While CLT is powerful, it's not magic. Here's what it can't help with:

🚫 Biased Samples

Problem: If your sample isn't representative, CLT won't fix that.
Example: Surveying only iPhone users about phone preferences won't tell you about Android users!
Solution: Focus on proper sampling methodology first.

🚫 Very Small Samples

Problem: CLT needs "sufficiently large" samples.
Example: For very skewed data, n = 5 won't cut it.
Solution: Use bootstrap methods or exact distributions for small samples.

🚫 Dependent Data

Problem: CLT assumes independence.
Example: Stock prices over time influence each other.
Solution: Use time series analysis or account for correlation structure.

🚫 Infinite Variance

Problem: Some theoretical distributions have infinite variance.
Example: Cauchy distribution (rare in practice).
Solution: Use robust statistics or different theoretical frameworks.

Case Studies Across Industries

🏥 Medical Research: Drug Trial

Scenario: Testing a new blood pressure medication.

• Population: All patients with hypertension
• Sample: 200 patients in clinical trial
• Measurement: Change in systolic blood pressure
• CLT Application: Confidence interval for mean improvement

# Simulate drug trial data
np.random.seed(123)
bp_reduction = np.random.normal(12, 8, 200)  # Mean reduction: 12 mmHg

n = len(bp_reduction)
sample_mean = np.mean(bp_reduction)
sample_std = np.std(bp_reduction, ddof=1)

# 95% confidence interval
margin_of_error = stats.t.ppf(0.975, n-1) * (sample_std / np.sqrt(n))
ci_lower = sample_mean - margin_of_error
ci_upper = sample_mean + margin_of_error

print(f"Drug Trial Results:")
print(f"Mean BP reduction: {sample_mean:.1f} mmHg")
print(f"95% CI: [{ci_lower:.1f}, {ci_upper:.1f}] mmHg")
print(f"Significant improvement: {'✅ YES' if ci_lower > 0 else '❌ NO'}")

🗳️ Political Polling: Election Prediction

Scenario: Predicting election results.

• Population: All eligible voters
• Sample: 1,000 survey respondents
• Measurement: Proportion supporting candidate A
• CLT Application: Confidence interval for vote share

# Simulate polling data
np.random.seed(456)
support_rate = 0.52  # True support rate: 52%
poll_responses = np.random.binomial(1, support_rate, 1000)

n = len(poll_responses)
sample_prop = np.mean(poll_responses)
sample_std = np.sqrt(sample_prop * (1 - sample_prop))  # Binomial std

# 95% confidence interval for proportion
margin_of_error = 1.96 * (sample_std / np.sqrt(n))
ci_lower = sample_prop - margin_of_error
ci_upper = sample_prop + margin_of_error

print(f"Polling Results:")
print(f"Support rate: {sample_prop:.1%}")
print(f"95% CI: [{ci_lower:.1%}, {ci_upper:.1%}]")
print(f"Margin of error: ±{margin_of_error:.1%}")

🌐 A/B Testing: Website Optimization

Scenario: Testing two website designs.

• Population: All website visitors
• Sample: 5,000 visitors per variant
• Measurement: Conversion rate
• CLT Application: Compare confidence intervals

# Simulate A/B test data
np.random.seed(789)
conversion_a = np.random.binomial(1, 0.08, 5000)  # Control: 8%
conversion_b = np.random.binomial(1, 0.095, 5000)  # Variant: 9.5%

def analyze_conversion(data, name):
    n = len(data)
    rate = np.mean(data)
    std = np.sqrt(rate * (1 - rate))
    margin = 1.96 * (std / np.sqrt(n))

    print(f"{name}:")
    print(f"  Conversion rate: {rate:.2%}")
    print(f"  95% CI: [{rate-margin:.2%}, {rate+margin:.2%}]")
    return rate, margin

rate_a, margin_a = analyze_conversion(conversion_a, "Control (A)")
rate_b, margin_b = analyze_conversion(conversion_b, "Variant (B)")

# Test for significant difference
diff = rate_b - rate_a
diff_std = np.sqrt(margin_a**2 + margin_b**2)
significant = abs(diff) > 1.96 * diff_std

print(f"\nDifference: {diff:.2%}")
print(f"Statistically significant: {'✅ YES' if significant else '❌ NO'}")

Advanced Topics: When CLT Gets Interesting

Sample Size Calculation

Question: How many samples do you need for a given precision?

Formula:

$$
n = \left(\frac{z_{\alpha/2} \cdot \sigma}{E}\right)^2
$$

Where:

• $z_{\alpha/2}$ = critical value (1.96 for 95% confidence)
• $\sigma$ = population standard deviation (estimated)
• $E$ = desired margin of error

def calculate_sample_size(confidence_level, margin_of_error, std_dev):
    """Calculate required sample size for given precision."""
    alpha = 1 - confidence_level
    z_critical = stats.norm.ppf(1 - alpha/2)

    n = (z_critical * std_dev / margin_of_error) ** 2
    return int(np.ceil(n))

# Example: Customer satisfaction survey
required_n = calculate_sample_size(
    confidence_level=0.95,
    margin_of_error=0.2,
    std_dev=1.8
)

print(f"Required sample size: {required_n}")

Bootstrap vs. CLT

Bootstrap: Computer-intensive alternative to CLT that works with smaller samples.

def bootstrap_ci(data, n_bootstrap=10000, confidence_level=0.95):
    """Calculate confidence interval using bootstrap."""
    bootstrap_means = []
    n = len(data)

    for _ in range(n_bootstrap):
        bootstrap_sample = np.random.choice(data, size=n, replace=True)
        bootstrap_means.append(np.mean(bootstrap_sample))

    alpha = 1 - confidence_level
    lower_percentile = (alpha/2) * 100
    upper_percentile = (1 - alpha/2) * 100

    ci_lower = np.percentile(bootstrap_means, lower_percentile)
    ci_upper = np.percentile(bootstrap_means, upper_percentile)

    return ci_lower, ci_upper

# Compare CLT vs Bootstrap
small_sample = np.random.exponential(2, 15)  # Small, skewed sample

# CLT approach
clt_mean = np.mean(small_sample)
clt_std = np.std(small_sample, ddof=1)
clt_margin = stats.t.ppf(0.975, len(small_sample)-1) * (clt_std / np.sqrt(len(small_sample)))
clt_ci = (clt_mean - clt_margin, clt_mean + clt_margin)

# Bootstrap approach
bootstrap_ci_result = bootstrap_ci(small_sample)

print(f"CLT CI: [{clt_ci[0]:.2f}, {clt_ci[1]:.2f}]")
print(f"Bootstrap CI: [{bootstrap_ci_result[0]:.2f}, {bootstrap_ci_result[1]:.2f}]")

Practice Problems with Solutions

Problem 1: Coffee Shop Revenue

Question: A coffee shop's daily revenue has a mean of $1,200 and standard deviation of $300. If you calculate the average revenue over 25 days, what's the probability this average exceeds $1,300?

# Given information
mu = 1200  # Population mean
sigma = 300  # Population std
n = 25  # Sample size
target = 1300  # Target value

# Sampling distribution parameters
sampling_mean = mu
sampling_std = sigma / np.sqrt(n)  # Standard error

# Calculate probability
z_score = (target - sampling_mean) / sampling_std
prob = 1 - stats.norm.cdf(z_score)

print(f"Sampling distribution: N({sampling_mean}, {sampling_std:.1f})")
print(f"Z-score: {z_score:.2f}")
print(f"P(sample mean > $1300) = {prob:.4f} or {prob:.2%}")

Problem 2: Manufacturing Quality

Question: Light bulbs have lifespans with mean 1000 hours and standard deviation 200 hours. In a sample of 64 bulbs, what's the probability the sample mean is between 950 and 1050 hours?

# Given information
mu = 1000
sigma = 200
n = 64
lower_bound = 950
upper_bound = 1050

# Sampling distribution
sampling_std = sigma / np.sqrt(n)

# Calculate z-scores
z_lower = (lower_bound - mu) / sampling_std
z_upper = (upper_bound - mu) / sampling_std

# Calculate probability
prob = stats.norm.cdf(z_upper) - stats.norm.cdf(z_lower)

print(f"Sampling distribution: N({mu}, {sampling_std:.1f})")
print(f"Z-scores: {z_lower:.2f} to {z_upper:.2f}")
print(f"P(950 < sample mean < 1050) = {prob:.4f} or {prob:.2%}")

Key Takeaways for Practitioners

🎯 CLT is your foundation: Most statistical inference relies on it

📊 Confidence intervals > point estimates: Always quantify uncertainty

🔍 Sample size matters: But there are diminishing returns

⚠️ Check your assumptions: Independence, sufficient sample size, representative sampling

🛠️ Multiple tools available: CLT, bootstrap, exact methods - choose appropriately

💡 Context is king: Statistical significance ≠ practical significance

What's Next?

Now that you've mastered CLT applications, you're ready to explore:

• Hypothesis Testing: Using CLT to test specific claims about populations
• Regression Analysis: How CLT underlies the assumptions in linear models
• ANOVA: Comparing multiple groups using CLT principles
• Bayesian Statistics: A different approach to uncertainty quantification

Further Reading

• Advanced: "Mathematical Statistics with Applications" by Wackerly, Mendenhall, and Scheaffer
• Practical: "Practical Statistics for Data Scientists" by Bruce & Bruce
• Online: Duke's Inferential Statistics course on Coursera
• Interactive: Try the examples in this article with your own data!

Remember: The Central Limit Theorem isn't just theory - it's the practical foundation for making confident decisions with data in the real world! 🚀

Why Should You Care?

Ever wonder how Netflix can recommend movies you'll love based on ratings from millions of users? Or how medical researchers can test a drug on 1,000 patients and confidently say it works for everyone? How can political polls survey just 1,000 people and predict the behavior of millions of voters?

The answer lies in one of statistics' most powerful and elegant theorems: the Central Limit Theorem. It's the mathematical reason why small samples can tell us big truths about the world.

The Problem We're Solving

Imagine you're trying to understand the average height of all adults in your country. Testing everyone would be impossible - that's millions of people! But somehow, measuring just a few hundred people can give you a remarkably accurate estimate.

This seems like magic, but it's actually math. The Central Limit Theorem explains why this "averaging effect" works for ANY type of data - not just heights, but everything from battery life to stock prices to exam scores.

The Big Picture (No Math Yet!)

Think of the CLT like a really good friend who always brings you back to normal after a chaotic day. Here's the intuitive idea:

Individual data points are unpredictable → One coin flip, one test score, one battery life measurement
But averages become predictable → Average of 100 coin flips, average test score of a class, average battery life of a batch

The CLT is like the Marvel multiverse - no matter how different the individual universes (data distributions), the overall story (sampling distribution) follows predictable patterns. Whether your original data is:

• Completely random and chaotic 🎲
• Heavily skewed to one side 📈
• Has multiple peaks like a camel's back 🐪

...when you start taking averages of samples, something beautiful happens: those averages cluster around the true population mean in a perfect bell curve!

A Simple Analogy

Imagine you're at a carnival with a bunch of friends, and you all decide to play different games:

• Alice plays ring toss (skill-based, consistent results)
• Bob plays the lottery wheel (completely random)
• Charlie plays basketball shots (mostly good, occasional bad shots)

If you look at their individual game results, they're all over the place. But if you average their scores over many rounds, something magical happens - all three friends end up with averages that cluster around predictable values, and those averages follow a nice, normal bell curve pattern!

That's the CLT in action: chaos becomes order through averaging.

What You Need to Know First

Before we dive deeper, make sure you're comfortable with:

• Mean (average): Add up all numbers, divide by count
• Standard deviation: How spread out your data is
• Normal distribution: That classic bell curve shape
• Sampling: Taking a subset of a larger group

Don't worry if you're rusty - the CLT is surprisingly intuitive once you see it in action!

The Formal Definition

Now for the mathematical beauty. The Central Limit Theorem states:

For a sample size $n$ that is sufficiently large, the sampling distribution of the sample mean approaches a normal distribution, regardless of the shape of the original population distribution.

In math notation:

$$
\frac{\bar{X} - \mu}{\sigma/\sqrt{n}} \xrightarrow{d} N(0,1)
$$

Translation: No matter how weird your original data looks, if you take enough samples and calculate their averages, those averages will form a beautiful normal distribution centered on the true population mean.

The "Magic" Number 30

Statisticians love to say $n \ge 30$ like it's some sacred commandment carved in statistical stone. It's not magic - it's just a decent rule of thumb for when the CLT starts working well.

(Though I admit, 30 does have a nice ring to it compared to $n \ge 27.3$...)

The truth is more nuanced:

• Normal-ish data: CLT works with samples as small as 5-10
• Moderately skewed data: Usually need 15-30 samples
• Heavily skewed data: Might need 50+ samples
• Really bizarre distributions: Sometimes need 100+ samples

Think of it like learning to ride a bike - some kids need training wheels longer than others, but eventually everyone gets there!

Visual Proof: Seeing is Believing

Let's watch the CLT work its magic. Here's a simple example with dice rolls:

import numpy as np
import matplotlib.pyplot as plt

# Set random seed for reproducibility
np.random.seed(42)

# Simulate rolling a die (uniform distribution, definitely not normal!)
die_rolls = np.random.randint(1, 7, 10000)

# Now let's see what happens when we average different numbers of rolls
sample_sizes = [1, 2, 5, 30]
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.flatten()

for i, n in enumerate(sample_sizes):
    # Generate 1000 sample means
    sample_means = []
    for _ in range(1000):
        sample = np.random.choice(die_rolls, n)
        sample_means.append(np.mean(sample))

    # Plot histogram
    axes[i].hist(sample_means, bins=30, alpha=0.7, density=True)
    axes[i].set_title(f'Sample Size n = {n}')
    axes[i].set_xlabel('Sample Mean')
    axes[i].set_ylabel('Density')

plt.tight_layout()
plt.suptitle('Central Limit Theorem: From Uniform Die Rolls to Normal Averages')
plt.show()

What to Notice:

• n=1: Flat distribution (just like individual die rolls)
• n=2: Starting to peak in the middle
• n=5: Looking more bell-shaped
• n=30: Beautiful normal distribution! 🎉

The original die rolls were completely uniform (flat), but the averages became normal. That's the CLT magic!

Common Misconceptions (Don't Fall for These!)

❌ "CLT makes the original data normal"

Wrong! CLT makes the sample means normal, not the original data. Your individual data points can still be as weird as they want.

Think of it like this: Individual people at a party might be introverts, extroverts, or somewhere in between. But if you average the "social energy" of random groups at the party, those group averages will be remarkably consistent and normally distributed.

❌ "You need normal data to start with"

Nope! That's the whole point - CLT works with ANY distribution. Exponential, uniform, bimodal, you name it.

❌ "Bigger samples are always better"

Not necessarily! Due to the $\sqrt{n}$ in the denominator, going from 100 to 400 samples only doubles your precision. There are diminishing returns, and sometimes the cost isn't worth it.

❌ "CLT works with any sample size"

Be careful! Very small samples ($n < 10$) from skewed distributions won't work well. Always check your assumptions!

Why This Matters: The Big Picture

The CLT is the foundation that makes modern statistics possible. It explains:

• Why polls work: 1,000 people can represent millions
• Why quality control works: Test a few products, understand the whole batch
• Why medical trials work: Study some patients, help everyone
• Why A/B testing works: Test with some users, apply to all users

Without the CLT, we'd be stuck testing everything and everyone. It's the mathematical principle that lets us make confident decisions with incomplete information.

A Quick Reality Check

Here's what the CLT is really saying:

"Hey, I know your data is messy and unpredictable. But if you take enough samples and average them, I promise those averages will behave nicely and predictably. Trust me on this one!"

And remarkably, math keeps this promise every single time.

Key Takeaways

🎯 The Big Idea: Sample means become normal, regardless of the original data distribution

📏 The Rule: Generally need n ≥ 30, but depends on how skewed your data is

🔍 The Power: Allows us to make confident statements about populations using small samples

⚠️ The Catch: Doesn't fix biased sampling, needs independence, requires sufficient sample size

🛠️ The Applications: Everywhere! Quality control, medical research, polling, A/B testing, finance

What's Next?

Now that you understand the intuition behind CLT, you're ready to see it in action!

Ready to put CLT to work? Explore some real world applications of CLT in Part 2 where we'll dive deep into:

• 🏭 Complete case study: Battery factory quality control
• 📊 Confidence intervals: Your statistical superpower
• 🧮 Interactive challenges: Test your understanding
• ⚠️ Limitations: When CLT doesn't work
• 💻 Full code examples: Ready-to-run implementations

The CLT isn't just a mathematical curiosity - it's the foundation that makes data-driven decisions possible in an uncertain world!

Further Reading

• Books: "The Signal and the Noise" by Nate Silver (great for intuition)
• Online: Khan Academy's Statistics course
• Interactive: Play with CLT simulations at Seeing Theory

Remember: The Central Limit Theorem is your friend who brings order to chaos. Trust in the power of averaging! 🚀

Every day, billions of people rely on software that runs the modern world. From the web browsers displaying this text to the servers hosting it, from the networks routing data packets to the cryptographic libraries securing transactions, nearly every digital interaction depends on open-source software (OSS).

Supporting open-source projects can happen in a few ways. Contributing code, fixing bugs, and discussing feature requests are great ways for folks to get involved, especially budding new software engineers.

I'd like to also bring attention to a less seen but equally as important facet of support: funding. I've had the pleasure of contributing to and maintaining open-source libraries over the years, and while I can't speak for everyone, I believe that most open-source maintainers do it for the mission, not for the money.

That being said, most projects do operate on financial life support, maintained by volunteers or small teams that still need to keep the lights on and make a living so that they can (hopefully) spend more time maintaining and building their projects. Money doesn't grow on trees, and it sure doesn't grow in GitHub issue comments.

Underappreciated Foundations

I'm not exactly sure why, but open-source software seems to operates on a paradox: the more critical a project becomes, the more invisible it often is to end users.

Consider these statistics:

• SQLite is embedded in every iPhone, Android device, and web browser, yet runs on donations
• OpenSSL secures nearly every HTTPS connection on the internet with a team smaller than most coffee shops
• curl powers data transfer for billions of applications but relies entirely on volunteer contributions
• FFmpeg processes virtually every video you watch online, and is maintained by a handful of developers

There's a famous XKCD comic that illustrates this:

A brief aside on types of open-source projects:

Some projects are more "user-facing". These projects are directly interacted with by developers and users daily, and benefit from large community forums and active discussions.

Others are "below-the-surface". These are usually projects that most devs indirectly depend on, but don't realize!

In a similar vein to project/code visibility, some project maintainers and communities are more vocal about needing funding/financial support, and others (for a variety of reasons) are perhaps less so.

Regardless of their levels of visibility, at the end of the day, both types of projects have three things in common:

1. they are vital to the OSS ecosystem,
2. they rely on small, dedicated teams of volunteers to continue building safer, scalable, more robust, and frankly kick-ass software that benefits all of us, and
3. they deserve our support. 💪

Jenga Blocks All the Way Down

Companies (many of them household names) generate trillions in revenue using free open-source software, yet most contribute a fraction back to the projects they depend on. In today's chronically online world, this funding imbalance impacts both our technical capabilities and our economic strength.

In short:

1. Without sustainable funding, critical projects depend on the goodwill of overworked volunteers who often quit, increasing attack vector space via security holes and technical debt.

2. Underfunded projects lack resources for proper security audits, testing infrastructure, and timely vulnerability responses.

3. Without funding for new features and optimizations, critical infrastructure stagnates, limiting technological innovation across the entire ecosystem.

This results in:

• Large positive externalities: One open-source project can create billions in economic value
• Tragedy of the commons: Everyone benefits from open-source but few contribute to maintenance
• Single points of failure: Key maintainers become irreplaceable bottlenecks

Some innovative organizations have begun addressing this. ESLint forwards sponsorships to dependencies, and the Open Source Security Foundation coordinates security improvements. These efforts are promising, but they're only the start!

A List of Projects to Consider Supporting

The following list contains examples of projects that form different parts of the backbone of our digital infrastructure and the open internet. Note that this is a non-exhaustive list.

Core Infrastructure & Cryptography

OpenSSL

• What it does: Provides cryptographic functionality for virtually every secure web connection
• Impact: Secures trillions of dollars in online transactions daily
• Funding: GitHub Sponsors | OpenSSL Foundation

curl

• What it does: Command-line tool and library for transferring data with URLs
• Impact: Used by virtually every programming language and application for HTTP requests
• Funding: GitHub Sponsors | Open Collective

Internet Infrastructure

Let's Encrypt

• What it does: Free, automated certificate authority providing TLS certificates
• Impact: Enabled HTTPS for 95% of all websites, securing billions of connections
• Funding: Donations | Corporate sponsorship

Wikimedia Foundation

• What it does: Operates Wikipedia and related knowledge projects
• Impact: Provides free access to human knowledge for billions of people
• Funding: Individual donations | Corporate partnerships

Internet Archive

• What it does: Digital library preserving websites, books, movies, music, and software
• Impact: Preserves digital heritage and provides free access to historical information
• Funding: Donations | Grants

Development Tools & Libraries

FFmpeg

• What it does: Multimedia framework for recording, converting, and streaming audio/video
• Impact: Powers virtually every video platform, from YouTube to Netflix
• Funding: Donations

Programming Language Foundations

Python Software Foundation

• What it does: Supports development of the Python programming language
• Impact: Python powers AI/ML, web development, and scientific computing globally
• Funding: Donations | Corporate sponsorship

The Path Forward

Broadly, I believe it's important to recognize that open-source infrastructure is a public good that deserves to be invested in, just like roads, bridges, and utilities.

It's also equally important to show appreciation for OSS, to contribute and maintain code, and, if you are able to donate, please do!

For the record, I'm not proposing a silver bullet, and I also don't believe that it's only on the general population to "foot the bill". Large companies, especially those who benefit the most from OSS, need to step up to the plate.

Just like how sidewalk curbs, initially designed to benefit vulnerable groups, have ended up benefitting all of society, the impacts of open-source projects benefit diverse, interdisciplinary communities around the world! ◡̈

The projects listed above represent just the tip of the iceberg. If you have another project you'd like for me to feature on this list, please let me know!

Prep Time

15 min

Cook Time

7 min

Shopping List

• 4 1/2 c Rice Chex™ cereal
• 4 1/2 c Corn Chex™ cereal
• 1 c packed brown sugar
• 1/2 c (1 stick) salted butter
• 1/4 c light corn syrup
• 1/4 tsp baking soda
• 2/3 c granulated sugar
• 2 tsp ground cinnamon

Instructions

1. Preheat oven to 350. Place cereal in a large, heat safe bowl. Line a large baking sheet with foil and spray with nonstick baking spray.
2. In a small bowl, combine cinnamon and sugar and set aside.
3. In a heavy saucepan over medium heat, heat brown sugar, butter, and corn syrup until the mixture comes to a boil. Let boil for one minute, stirring constantly, then remove from heat and stir in baking soda. Pour over cereal and stir until cereal is coated.
4. Spread cereal on prepared baking sheet. Sprinkle evenly with cinnamon/sugar mixture. Bake for about 5 minutes, then flip with a spatula and bake for 3 more minutes, until cereal turns golden brown. Remove from oven and let cool completely, then break up and store in an airtight container.