Building Mathematical Wonder: Engineering Outreach with Code

Watching mathematics travel from “something written on a page” to “something you can feel” is a special kind of moment. It happens when the story clicks, when a diagram stops being decoration and becomes a tool, when a tiny change in an input produces a predictable change in the output. In 2026, Hannah Fry’s Leelavati Prize is a reminder that this translation work is not fluff. It’s craft.

That craft matters because mathematics already lives inside modern life: patterns in traffic, probabilities in medical tests, models in climate forecasts, optimization in logistics. The public doesn’t need a full textbook—but they do deserve access to the ideas in a form their brains can actually use.

So what does “mathematics outreach” look like when you treat it like engineering? That’s the thread here: turning wonder into repeatable design.

Why a public-awareness prize belongs in a technical conversation

The Leelavati Prize is awarded for increasing public awareness of mathematics, and Fry’s win highlights a point worth taking seriously: communication is part of the mathematics ecosystem. A breakthrough in understanding doesn’t stay useful if it can’t be shared.

For beginners, this can be surprising. It feels like “real math” happens only in labs and proofs. But outreach is where mathematics becomes legible. And legible mathematics tends to have a few shared properties:

• It respects the structure of the idea. The goal isn’t to oversimplify; it’s to preserve the “shape” of the reasoning.
• It uses the audience’s senses. People think in pictures, comparisons, and intuition long before they think in symbols.
• It supports iteration. Viewers should be able to try, fail safely, and try again.

That last one is the technical hinge: outreach works best when it behaves like software—small experiments, quick feedback, visible cause-and-effect.

The core technical move: model-to-visual feedback

A lot of outreach fails because it jumps straight from statement to conclusion. A more effective pattern is:

1. State a simple model (a “toy” version of the real situation).
2. Turn the model into a visualization (a plot, animation, or interactive behavior).
3. Let the audience change something and watch what happens.

Here’s the language of the pattern.

• A model is a simplified representation of reality. For example, “people arrive randomly” can be modeled with probability.
• A visualization is a mapping from numbers to something you can see, like axes on a chart or pixels in an image.
• Feedback is what the audience receives after changing inputs: the new chart, the new animation frame, the new result.

Why does this feel magical? Because the brain learns by prediction. When the viewer can predict the next outcome—even imperfectly—mathematics stops being memorization and starts being understanding.

A question-shaped search term a lot of people end up needing is: “How do you explain probability without losing people?” The answer is rarely “talk slower.” It’s “build a feedback loop.”

Tooling without intimidation: Python notebooks as a bridge

To engineer this kind of outreach, a common workflow is a notebook—a file that mixes text, code, and plots. In the Python world, many people use Jupyter Notebook or JupyterLab.

• A Python notebook lets you run code in small chunks.
• Those chunks can generate plots with libraries like Matplotlib (a plotting library) or Plotly (often used for interactive plots).

If that sounds like “just tooling,” it isn’t. The notebook encourages the same structure as good outreach: explain → compute → show → iterate.

Example demo: Central Limit Theorem you can watch happen

One of the most powerful “public-friendly” ideas in probability is the Central Limit Theorem (CLT). In plain language, it says that when you average many random samples, the result tends to look bell-shaped (a normal distribution), even if the original randomness didn’t.

That sentence is hard to feel. So let’s make it feel.

The setup

We’ll do a small simulation:

• Pick a random distribution for individual samples (we’ll use something not bell-shaped).
• Draw many samples, average them, and repeat many times.
• Plot the distribution of the averages.

A simulation is a computational experiment that imitates a process by generating random data.

Python code (simulation + visualization)

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)

def demo_clt(n, trials=5000):
 # Original randomness: uniform distribution
 # (uniform means every value in an interval is equally likely)
 samples = rng.uniform(-1, 1, size=(trials, n))
 means = samples.mean(axis=1)
 return means

n_values = [1, 2, 5, 20]

plt.figure(figsize=(10, 6))
for i, n in enumerate(n_values, start=1):
 means = demo_clt(n)
 ax = plt.subplot(2, 2, i)
 ax.hist(means, bins=40, density=True, alpha=0.85)
 ax.set_title(f"Average of {n} samples")
 ax.set_xlabel("Mean")
 ax.set_ylabel("Density")

plt.tight_layout()
plt.show()

What the demo teaches

When n = 1, the averages are just the original randomness—flat-ish. As n increases (2, 5, 20), the histogram of means starts forming that bell shape.

Even if viewers don’t know the name “Central Limit Theorem,” they learn its behavior: averaging many random things creates predictable smoothness.

That’s outreach engineering in action. The audience didn’t memorize; they observed a rule.

A second example: graphs that explain “connections”

Another idea that plays well in outreach is networks, because they map onto everyday life: friendships, websites, power grids, supply chains.

In network language:

• A graph is a collection of items and connections.
• The nodes (also called vertices) are the items.
• The edges are the connections between items.
• A degree is the number of edges attached to a node.

A beginner-friendly technical trick is to use a layout algorithm that positions nodes so connected nodes tend to cluster. You’re not proving a theorem—you’re making structure visible.

Even without fancy interactivity, a static force-directed layout (where connected nodes “pull” each other and overlap is discouraged) can help viewers see what “connectedness” means.

Measuring impact without turning into a marketing machine

Engineers measure. Outreach should too—though not in a purely click-driven way.

Two practical approaches often used in educational tech are:

• Qualitative feedback: short comments about what felt confusing, what felt surprising, and what felt useful.
• A/B testing: comparing two versions of an explanation or visualization to see which produces better understanding (for example, a quiz score), where “A” is one design and “B” is another.

An important reassurance for people new to this: measurement doesn’t have to become sterile. The goal is not to reduce humans to metrics. The goal is to learn which parts of the model-to-visual pipeline actually carry understanding.

The “imagination hole” principle, made concrete

Hannah Fry’s communication style emphasizes creating motivation—a moment where someone wants the next piece of information. Translating that into engineering terms gives a useful design rule:

• Build a tiny gap between what the audience expects and what the model actually predicts.

That gap is where curiosity lives. And curiosity is a resource.

In practice, that means designing demos where:

• the first view looks familiar,
• then one parameter change makes the familiar break in a predictable way,
• then the audience can connect the behavior back to the model.

It’s not magic. It’s structure.

Conclusion: outreach is software for the mind

The real technical story behind great mathematics outreach is that it treats communication like a system. Models provide the logic, visualizations provide the intuition, and feedback loops provide learning. When the Leelavati Prize celebrates outstanding contributions to public awareness, it’s celebrating something more technical than it sounds: repeatable ways of turning abstract ideas into experiences.

Once that mindset clicks, mathematics stops being distant. It becomes something you can run—watch, adjust, and understand.