Year 1: Foundations & Classical Roots (12 books)

Year 2: Grand Strategy, Operational Art & Frameworks (19 books)

Year 3: Contemporary Challenges, Critique & Synthesis (17 books)

Conclusion: Is it worth it?

After spending two months with MathAcademy, accumulating 2,000 experience points over about 40 hours of learning, I can confidently say that the $50 monthly subscription fee is well worth the investment. Here’s why:

1. A Tireless Expert Tutor: For less than the cost of a single hour with a private math tutor, MathAcademy provides you with 24/7 access to what is essentially a tireless, expert math tutor. This AI-driven platform doesn’t get fatigued, lose patience, or have scheduling conflicts.
2. Personalized Learning Path: MathAcademy excels at identifying exactly what you need to work on, zeroing in on your weak spots and areas for improvement.
3. Mastery Through Practice: The platform provides a seemingly endless supply of practice problems tailored to your skill level, challenging you until you demonstrate true mastery of a concept.
4. Structured Progression: It creates a clear path forward, eliminating the guesswork and potential gaps in knowledge that can occur with self-directed study.
5. Long-Term Retention Focus: The platform’s use of spaced repetition and adaptive review ensures that you’re building lasting mathematical knowledge and skills.

MathAcademy has not only helped me relearn and solidify mathematical concepts, but it’s also changed my perspective on what effective learning can look like. It addresses the question of knowledge retention in a way that balances efficiency and thoroughness, making it possible to maintain a high level of skill with manageable daily practice.

When you consider the depth of content, the adaptive technology, and the personalized attention you receive, MathAcademy offers exceptional value. For anyone serious about improving their math skills - whether you’re a student looking to excel in your classes, a professional aiming to enhance your quantitative abilities, or simply someone who wants to reconnect with mathematics - MathAcademy provides a level of instruction and practice that would cost hundreds or even thousands of dollars per month to replicate with traditional tutoring.

Returning to our initial question about the cost of maintaining knowledge, MathAcademy seems to offer a solution that leans towards the optimistic end of the spectrum. While it may not be as quick as “5 minutes a day,” the efficiency and effectiveness of the platform make the time investment highly worthwhile. It transforms the daunting tasks of learning and retaining complex mathematical knowledge into a manageable, even enjoyable, daily practice.

As I continue my journey with MathAcademy, I’m excited to see how much further I can progress and how well I’ll retain this knowledge in the long term. For anyone looking to learn or relearn mathematics, I can’t recommend MathAcademy highly enough. It’s not just a learning tool; it’s a new paradigm in education that makes mathematical mastery achievable for everyone.

Acknowledgements

Thank you to Julija Whitmore for reading early drafts of this.

Reference Links

The Setup

I used Quarto and nbdev to create my website and a blog on a custom URL.

The whole process went rather smoothly. I had my website up and running, and I changed my hosting to point to the right place. My website appeared, and the DNS checks on GitHub’s side all passed. I had my website on the custom URL and enforced HTTPS.

The Problem

Whenever I made an update to my website, however, my URL broke. The GitHub Pages page (github.io/jbwhit/…) worked, but the custom URL (jonathanwhitmore.com) no longer pointed to the right spot.

The Start of a Solution

When I first added my Custom Domain, GitHub helpfully created a CNAME (Canonical Name) file in the top-level directory of the repo on the gh-pages branch (if that’s what you’re using, and I was).

The Fix

Simply move the CNAME file from the top level directory and place it in the nbs directory, and then run nbdev_prepare and update as usual. I found that this completely solved the problem that occurred every single time I pushed a commit to GitHub.

# Directory structure of the GitHub website repo when using nbdev
1├── ❌ CNAME
2├── nbs
│  ├── _quarto.yml
3│  ├── ✅ CNAME
│  ├── sidebar.yml
│  └── styles.css
├── README.md
├── settings.ini
├── setup.py

1

❌ This CNAME file is created by GitHub and placed in the root directory of your git repo (one level above the nbs directory that nbdev uses). The red X indicates this is not the correct location.

2

nbdev uses the nbs directory as the top-level of the website repo (this differs from what GitHub expects).

3

✅ The correct place to put the CNAME file: under the nbs directory. The green checkmark indicates this is the proper location.

The Why

Long story short: GitHub assumes that the git repository that you are turning into a website is using the top level directory as the directory for the website, and suggests the CNAME to be in the top level directory for that reason.

In contrast, Nbdev uses the nbs directory as the top-level of the website repo. This is why the fix is very simple – move the CNAME to the top-level directory of the website, which for nbdev projects is the nbs directory.

Resources

• Nbdev issue: push to main branch removes custom domain from GitHub Pages settings
• Configuring a custom domain for your GitHub Pages site
• Nbdev Documentation
• Quarto Documentation
• Understanding CNAME records

The TvL Model

A high-level description of the model from the paper:

• people are placed uniformly at random in a square environment and stay fixed.
• events are also placed uniformly at random, each classified as Lucky or Unlucky (50/50).
• The events randomly walk the environment each timestep.
• At each timestep, capital is updated:
  • No overlap with an event: capital unchanged.
  • Overlap with an Unlucky event: capital halved.
  • Overlap with a Lucky event: if a uniform random draw is less than the person’s talent score, capital doubles; otherwise unchanged.

Talent is drawn from , truncated to . Everyone starts with 10 units of capital and the simulation runs for 80 timesteps.

The one parameter the paper does not give explicitly is — the probability that a given person overlaps an event at a given timestep. We estimate it in the appendix; our best estimate is 0.16.

Setup

import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as ss

rng = np.random.default_rng(seed=20180312)

# Paper's parameters
N_PEOPLE = 1000
N_TIMESTEPS = 80
STARTING_CAPITAL = 10.0
TALENT_MEAN = 0.6
TALENT_SD = 0.1
P_LUCKY = 0.5

# Our estimate of p_event (derived in appendix)
P_EVENT = 0.16

Simulating the TvL model

def run_tvl_simulation(n_people=N_PEOPLE, n_timesteps=N_TIMESTEPS,
                       starting_capital=STARTING_CAPITAL,
                       talent_mean=TALENT_MEAN, talent_sd=TALENT_SD,
                       p_event=P_EVENT, p_lucky=P_LUCKY, rng=rng):
    """Run the TvL simulation; returns (talent array, final_capital array)."""
    talent = np.clip(rng.normal(talent_mean, talent_sd, n_people), 0, 1)

    # Pre-draw all random numbers: shape (n_people, n_timesteps)
    event_roll   = rng.random((n_people, n_timesteps))
    lucky_roll   = rng.random((n_people, n_timesteps))
    capital_roll = rng.random((n_people, n_timesteps))

    event_happens = event_roll < p_event
    is_lucky      = lucky_roll < p_lucky
    capitalizes   = capital_roll < talent[:, np.newaxis]

    # multiplier per (person, timestep)
    multiplier = np.where(
        event_happens & is_lucky & capitalizes, 2.0,
        np.where(event_happens & ~is_lucky, 0.5, 1.0)
    )

    final_capital = starting_capital * multiplier.prod(axis=1)
    return talent, final_capital

talent, final_capital = run_tvl_simulation()
print(f"Median final capital:  {np.median(final_capital):.3f}")
print(f"Mean final capital:    {np.mean(final_capital):.3f}")
print(f"Max final capital:     {np.max(final_capital):.1f}")
print(f"Fraction who grew:     {(final_capital > STARTING_CAPITAL).mean():.1%}")

Median final capital:  1.250
Mean final capital:    26.164
Max final capital:     5120.0
Fraction who grew:     17.4%

What Does Talent Actually Do?

Because the probability of each outcome is determined analytically (not just by simulation), we can compute it directly for any talent quantile.

def tvl_probabilities(quantile, talent_mean=TALENT_MEAN, talent_sd=TALENT_SD,
                      p_event=P_EVENT, p_lucky=P_LUCKY):
    """Return (p_halve, p_same, p_double) for a person at a given talent quantile."""
    p_halve  = p_event * (1.0 - p_lucky)
    talent   = np.clip(ss.norm.ppf(quantile, loc=talent_mean, scale=talent_sd), 0, 1)
    p_double = p_event * p_lucky * talent
    p_same   = 1.0 - p_halve - p_double
    return p_halve, p_same, p_double

# Compare extremes
for q, label in [(0.05, "5th percentile"), (0.50, "50th percentile"), (0.95, "95th percentile")]:
    ph, ps, pd = tvl_probabilities(q)
    print(f"{label:20s}  p_double={pd:.4f}  p_same={ps:.4f}  p_halve={ph:.4f}")

ph_95, _, pd_95 = tvl_probabilities(0.95)
ph_05, _, pd_05 = tvl_probabilities(0.05)
print(f"\nDifference in p_double (95th − 5th): {pd_95 - pd_05:.4f}  ({(pd_95 - pd_05)*100:.2f} pp)")

5th percentile        p_double=0.0348  p_same=0.8852  p_halve=0.0800
50th percentile       p_double=0.0480  p_same=0.8720  p_halve=0.0800
95th percentile       p_double=0.0612  p_same=0.8588  p_halve=0.0800

Difference in p_double (95th − 5th): 0.0263  (2.63 pp)

The difference in the probability of doubling between the 95th and 5th percentile is only ~2.6 percentage points. The probability of halving is identical for everyone — talent offers no protection from bad luck at all.

Code

quantiles = np.linspace(0.001, 0.999, 300)
probs = np.array([tvl_probabilities(q) for q in quantiles])
p_halve, p_same, p_double = probs[:, 0], probs[:, 1], probs[:, 2]

fig, ax = plt.subplots(figsize=(7, 3))
ax.fill_between(quantiles, p_halve + p_same, 1.0,   color="#076678", alpha=0.8, label="Doubles")
ax.fill_between(quantiles, p_halve,           p_halve + p_same, color="#a89984", alpha=0.35, label="Stays the same")
ax.fill_between(quantiles, 0,                 p_halve,          color="#cc241d", alpha=0.8, label="Halves")

for q in (0.05, 0.95):
    ax.axvline(q, color="black", lw=1.0, ls="--", alpha=0.6)

ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.set_xlabel("Talent quantile")
ax.set_ylabel("Probability per timestep")
ax.legend(loc="center", framealpha=0.9)
plt.tight_layout()
plt.show()

Mean vs Geometric Mean: The Multiplicative Trap

Because we have analytical probabilities, we can compute both the expected (mean) final capital and the geometric-mean growth rate for any talent quantile. No simulation needed.

The expected value of each timestep multiplier is , which is above 1 for talent > 0.5. But capital is a multiplicative process — the long-run growth rate is governed by the geometric mean of the per-step multiplier: . This geometric mean is below 1 for all talent < 1, meaning capital shrinks on a typical path even though the arithmetic mean grows.

def expected_value(quantile, starting_capital=STARTING_CAPITAL, n_timesteps=N_TIMESTEPS):
    p_halve, p_same, p_double = tvl_probabilities(quantile)
    per_step_ev_multiplier = p_double * 2.0 + p_same * 1.0 + p_halve * 0.5
    return starting_capital * per_step_ev_multiplier ** n_timesteps

def geometric_mean_value(quantile, starting_capital=STARTING_CAPITAL, n_timesteps=N_TIMESTEPS):
    """Capital implied by the geometric-mean growth rate (typical-path estimate)."""
    p_halve, p_same, p_double = tvl_probabilities(quantile)
    geo_multiplier = np.exp(p_double * np.log(2) + p_halve * np.log(0.5))
    return starting_capital * geo_multiplier ** n_timesteps

for q, label in [(0.5, "50th"), (0.95, "95th"), (0.999, "99.9th"), (0.99999, "99.999th")]:
    ev = expected_value(q)
    gm = geometric_mean_value(q)
    print(f"{label:10s} percentile → mean: {ev:8.2f}   geo-mean path: {gm:7.4f}  (started at {STARTING_CAPITAL})")

50th       percentile → mean:    18.92   geo-mean path:  1.6958  (started at 10.0)
95th       percentile → mean:    53.39   geo-mean path:  3.5177  (started at 10.0)
99.9th     percentile → mean:   131.42   geo-mean path:  6.6792  (started at 10.0)
99.999th   percentile → mean:   230.50   geo-mean path: 10.0000  (started at 10.0)

The mean and the geometric-mean path tell completely different stories. The mean grows — a 95th-percentile person has an expected final capital over 50. But the geometric-mean path shrinks for every talent level below perfect: a 95th-percentile person’s typical-path capital is about 3.5, down from 10. Only someone with literally perfect talent () has a non-shrinking geometric mean.

This is the signature of a multiplicative process. A few people get lucky runs — several doublings without any halvings — and their enormous gains pull the arithmetic mean far above what most people actually experience. The mean is dominated by rare winners; the geometric mean reflects typical long-run growth.

A caveat: over a finite horizon like 80 steps, variance is high enough that extremely talented individuals still have a meaningful chance of coming out ahead. The geometric mean governs the long-run typical path, but at 80 steps we’re not yet in the long run — the distribution of outcomes is wide, and luck can easily overcome the downward drift for any individual. This doesn’t rescue the model’s claim, though: it just means that which talented people succeed is still driven by luck.

Code

quantiles = np.linspace(0.001, 0.999, 300)

fig, ax = plt.subplots(figsize=(7, 5))
evs = [expected_value(q) for q in quantiles]
gms = [geometric_mean_value(q) for q in quantiles]
ax.plot(quantiles, evs, ls="--", lw=2, color="#076678", label="Mean (expected value)")
ax.plot(quantiles, gms, ls="-", lw=2, color="#cc241d", label="Geometric-mean path")
ax.axhline(STARTING_CAPITAL, color="black", lw=0.8, ls=":", alpha=0.5, label="Starting capital")

for q in (0.05, 0.95):
    ax.axvline(q, color="black", lw=0.8, ls="--", alpha=0.4)

ax.set_xlim(0, 1)
ax.set_xlabel("Talent quantile")
ax.set_ylabel("Final capital after 80 timesteps")
ax.set_yscale("log")
ax.legend()
plt.tight_layout()
plt.show()

Concluding Thoughts

The TvL paper’s conclusion — that luck dominates talent — is essentially a restatement of its inputs. Two design choices do most of the work:

1. Tiny talent bandwidth. The difference in doubling probability between the 5th and 95th percentile of talent is only ~2.6 percentage points. With such narrow dynamic range, talent can barely move the needle.

2. Asymmetric multipliers. Unlucky events halve your capital regardless of talent, but lucky events only help if you’re talented enough to capitalize. In a multiplicative process, this asymmetry means the typical person loses capital over time even though the average grows — the gains are concentrated in a lucky few.

These are modeling choices, not discoveries about the world. The simulation doesn’t demonstrate that luck dominates talent — it assumes a structure where that outcome is nearly inevitable. This is not to say luck is unimportant in real life; it may well dominate. But this particular model can’t tell us that.

Further Reading

• ArcheoThoughts: “Luck is very important, but just how insignificant is talent?” — another critique identifying the downward pressure on capital in the TvL model.
• Ergodicity Economics by Ole Peters — the formal mathematical framework for why geometric means diverge from arithmetic means in multiplicative processes.
• The Kelly Criterion — the classic solution for maximizing geometric growth under uncertainty.
• The Success Equation by Michael Mauboussin — on how luck becomes dominant when skill levels converge (“the Paradox of Skill”).
• Naval Ravikant on the four kinds of luck — challenges the assumption that luck is purely external by explaining how talent and agency can increase the frequency of lucky events.

Appendix: Estimating p_event

The paper does not state directly. We infer it by finding values that reproduce the maximum number of unlucky events seen in the paper’s Figure 5b (approximately 15 events across 1,000 people). The plot below sweeps p_event over 50 simulation trials; our best estimate of 0.16 sits in the center of the plausible range.

Estimating p_event from paper Figure 5b

p_event_low      = 0.11
p_event_estimate = 0.16
p_event_high     = 0.21

p_events = np.linspace(0.0, 0.5, 250)
trial_rng = np.random.default_rng(seed=42)

fig, ax = plt.subplots(figsize=(7, 4))
for trial in range(50):
    max_unlucky = []
    for pe in p_events:
        n_events = (trial_rng.random((N_PEOPLE, N_TIMESTEPS)) < pe).sum(axis=1)
        n_lucky  = np.array([trial_rng.binomial(n, P_LUCKY) for n in n_events])
        max_unlucky.append((n_events - n_lucky).max())
    ax.plot(p_events, max_unlucky, lw=0.4, color="#076678", alpha=0.5)

ax.axhline(15, color="#cc241d", lw=2, label="Observed max unlucky events (paper Fig. 5b)")
ax.axvline(p_event_low,      color="black", lw=1.5, ls=":",  label="Our estimated range")
ax.axvline(p_event_high,     color="black", lw=1.5, ls=":")
ax.axvline(p_event_estimate, color="black", lw=2.0, ls="--", label="Best estimate (0.16)")
ax.set_xlim(0, 0.5)
ax.set_ylim(0, 40)
ax.set_xlabel("p_event")
ax.set_ylabel("Max unlucky events across 1,000 people")
ax.legend(fontsize=9)
plt.tight_layout()
plt.show()

The simulation

ROUNDS = 10_000_000
SWITCH_BET = 1.08  # switcher pays this when staying wins
STAY_BET = 1.00    # stayer pays this when switching wins
DOORS = np.array([1, 2, 3])

STAY_DOOR = 1

# Randomly place the prize behind a door each round
winning_doors = rng.choice(DOORS, size=ROUNDS)

# Staying wins when the prize is behind Door 1
stay_wins = winning_doors == STAY_DOOR

# Switching wins whenever staying loses (the revealed door is never the prize)
switch_wins = ~stay_wins

stay_win_count = stay_wins.sum()
switch_win_count = switch_wins.sum()

# Net payouts
switch_net = switch_win_count * STAY_BET - stay_win_count * SWITCH_BET
stay_net = -switch_net

print(f"Rounds:              {ROUNDS:>12,}")
print(f"Stay wins:           {stay_win_count:>12,}  ({stay_win_count / ROUNDS:.2%})")
print(f"Switch wins:         {switch_win_count:>12,}  ({switch_win_count / ROUNDS:.2%})")
print(f"Stayer nets:         ${stay_net:>12,.2f}")
print(f"Switcher nets:       ${switch_net:>12,.2f}")

Rounds:                10,000,000
Stay wins:              3,333,698  (33.34%)
Switch wins:            6,666,302  (66.66%)
Stayer nets:         $-3,065,908.16
Switcher nets:       $3,065,908.16

Switching wins about 2/3 of the time — exactly as the math predicts. Even with the switcher paying an 8% premium on losses, the edge is overwhelming over millions of rounds.

Convergence plot

As the number of rounds grows, the win ratios converge to their true probabilities: 1/3 for staying, 2/3 for switching.

Code

cumulative_stay = np.cumsum(stay_wins)
cumulative_switch = np.cumsum(switch_wins)
rounds = np.arange(1, ROUNDS + 1)

# Sample points for plotting (log-spaced to keep the plot manageable)
idx = np.unique(np.geomspace(1, ROUNDS, num=2000).astype(int)) - 1

fig, ax = plt.subplots(figsize=(9, 5))
ax.semilogx(rounds[idx], cumulative_stay[idx] / rounds[idx], label="Stay", color="#e74c3c")
ax.semilogx(rounds[idx], cumulative_switch[idx] / rounds[idx], label="Switch", color="#2ecc71")
ax.axhline(1 / 3, color="#e74c3c", linestyle="--", alpha=0.4, label="1/3")
ax.axhline(2 / 3, color="#2ecc71", linestyle="--", alpha=0.4, label="2/3")
ax.set_xlabel("Rounds played")
ax.set_ylabel("Win ratio")
ax.set_title("Monty Hall Monte Carlo — Win Ratio Convergence")
ax.legend()
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()

Try it yourself

Want to run this locally? With uv installed:

uv run --with numpy --with matplotlib monty_hall.py

Or copy the code blocks above into a Jupyter notebook and experiment — try changing the number of doors, the bet amounts, or the number of rounds.

The YouTube Argument

There’s a YouTube video that mentions the Monty Hall problem and the correct solution. A commenter insisted the real odds are 50-50 — and confronted with the possibility that someone is wrong on the internet — I engaged.

After a lot of back and forth, the last volley was:

So: wrong, impervious to correction, and publicly proclaiming he’s right at my expense. The way I deal with these situations is to make a bet. Even if he won’t change his mind, he’ll get punished monetarily for holding false and uncorrectable beliefs. It’s win-win as far as I’m concerned.

The Bet

Since this commenter thinks the odds are 50-50 whether you switch or stay, and I think they’re 2/3 vs. 1/3 for switching, we pay each other depending on whose strategy wins each round:

That’s an 8% payout difference on what he thinks is a coin flip — and if he’s got conviction, he should really want to play as many times as possible.