Fields · an atlas

The method travels.

Here are some of the fields we work in. Mathematics does not belong to any of them, so we go wherever a problem can be stated precisely, from an option price to a delivery route or a website.

sgn (sin x) = \frac{4}{π} (sin x + \frac{sin 3 x}{3} + \frac{sin 5 x}{5} + \dots)

def square(x, n):
    odd = range(1, 2*n, 2)
    return 4/π * sum(sin(k*x)/k for k in odd)
# each term a plain sine; the sum has corners

a few terms up there; the series goes on
Gibbs: 9% over, however many terms
odd terms only
the square itself, at the back
n = 1: one term, a sine
at the jump every sum is exactly 0; so is sgn(0): the series lands halfway
at x = π/2 it reads 1 − 1/3 + 1/5 − …, Leibniz’s series for π/4; times 4/π, 1
Fourier claimed in 1807 that every periodic function is a sum of sines; Lagrange doubted

Index of plates

Each field, its own figure.

Each plate shows its figure as it passes, or when you point at it; open it to read the field.

Pl. IQuantitative financePrices, risk and time.
Pl. IIArtificial intelligenceAttention, measured.
Pl. IIIBlockchainSigned, hashed and checked.
Pl. IVQuantum computingSuperposition, without the hype.
Pl. VBusiness & strategyWhen your move depends on theirs.
Pl. VIProcess optimisationBusy is not the same as fast.
Pl. VIISoftware developmentCode that others can read.
Pl. VIIIDesign & webDrawn with the same care.

The cabinet: 90 objects, each computed from its formula.

the same specimen on About and Contact
or try the arrow keys

Pl. I — Quantitative finance

Prices, risk and time.

Written as models and tested against market data. Most of our work today is here, and our own analysis infrastructure, AION, is in development.

S_{n, j} p = S_{0} u^{j} d^{n - j}, u = e^{σ Δ t} = \frac{e ^{r Δ t} - d}{u - d}

u = exp(σ*sqrt(dt)); d = 1/u
p = (exp(r*dt) - d) / (u - d)
V = maximum(S0*u**j*d**(n-j) - K, 0)
for _ in range(n):   # folds to one price
    V = exp(-r*dt) * (p*V[1:] + (1-p)*V[:-1])

Option pricing, volatility surfaces and model calibration: fitted to quotes, free of static arbitrage
Portfolio construction and risk measurement: every mix of weights, with its risk measured
Backtests of trading and hedging strategies, out of sample: tuned on one stretch, tested on the next
Analysis software and data pipelines for research teams: aligning two series: our paper of Jan 2026

today: one price
up u, down d = 1/u
where it may end, and how likely
to price, not predict
Pl. I · Cox, Ross & Rubinstein, 1979 · σ = 30%
cf. AION
ten steps: 1,024 paths, yet only 11 ends: up then down lands where down then up does
here p ≈ 0.503: the odds under which the stock grows at r. Real odds never enter
more steps, smaller Δt: the price tends to Black–Scholes (1973), as the paper proves

Pl. II — Artificial intelligence

Attention, measured.

Models that learn from data, built on sound statistics and judged on data held back from their training.

Attention (Q, K, V) = softmax (\frac{Q K ^{T}}{d _{k}}) V

def attention(Q, K, V):
    d = K.shape[-1]
    w = softmax(Q @ K.T / sqrt(d), axis=-1)
    return w @ V
# each token asks: how much do you matter?

Forecasting and classification models, reported with their error: a forecast, and how far off it may be
Language models put to work on documents and internal processes: information, measured in bits: Shannon, 1948
Anomaly detection in transactions, sensors or logs: far from the usual cloud: worth a look
Evaluation: measuring whether a model does what it is supposed to do: false alarms and misses, counted separately

keys
queries
a thicker arch, more attention
each token’s question
the outputs, in red
Pl. II · Vaswani et al., 2017 · 12 tokens
12 tokens, 144 weights, each row summing to 1: twice the text, four times the work
why √d: across d dimensions q·k has variance d; unscaled, softmax saturates at 0s and 1s, and its gradients vanish
the 2017 title: “Attention Is All You Need”; no recurrence, no convolutions

Pl. III — Blockchain

Signed, hashed and checked.

Smart contracts and protocols checked with mathematics, cryptography used as it was designed, on-chain data analysed and tokenised products modelled.

y^{2} x_{R} y_{R} = x^{3} + 7, λ = (y_{Q} - y_{P}) / (x_{Q} - x_{P}) = λ^{2} - x_{P} - x_{Q} = λ (x_{P} - x_{R}) - y_{P}

p = 2**256 - 2**32 - 977     # Bitcoin's prime
def add(xp, yp, xq, yq):     # P ≠ ±Q
    λ = (yq - yp) * pow(xq - xp, -1, p) % p
    xr = (λ*λ - xp - xq) % p
    return xr, (λ*(xp - xr) - yp) % p

Smart contracts and protocols: reviewed, tested and checked formally: four flags, 16 states: a proof covers all
Cryptography put to work correctly: hashes, signatures and proofs: Merkle, 1979: three hashes prove tx₅
On-chain data: flows between addresses, traced and analysed: addresses grouped by how they behave
Tokenised products, and the incentives of a protocol, modelled: as in Pl. V: no one gains by deviating alone

−R: the line meets it again
R = P + Q: −R, reflected
up to the point at infinity
the slope of the line PQ
Pl. III · Koblitz & Miller, 1985 · Nakamoto, 2008
cf. our proposal: liquid networks on-chain, Jan 2025
why reflect: P, Q and −R on one line add up to the group’s zero, the point at infinity; so P + Q = R
Bitcoin works mod p = 2^256 − 2^32 − 977; there its curve has about 1.16 × 10^77 points, the one at infinity included
k to kG: some hundreds of additions. kG back to k, the discrete logarithm: about 2^128 steps by the best known attack

Pl. IV — Quantum computing

Superposition, without the hype.

Quantum information and algorithms: what quantum machines can do today, what they cannot do yet and how to prepare.

∣ ψ ⟩ = cos \frac{θ}{2} ∣0 ⟩ + e^{i φ} sin \frac{θ}{2} ∣1 ⟩

qc = QuantumCircuit(1)
qc.ry(π/3, 0)
qc.rz(π/4, 0)
# measures 0 with probability cos²(π/6) = 3/4

Assessing whether a problem can gain from a quantum algorithm, and when: spreads like t, not √t: the gain to look for
Prototypes of quantum algorithms for optimisation and simulation, run on simulators: 2,400 detections, one at a time: simulated
Quantum-inspired methods that run on ordinary hardware: ψ computed on a laptop: no qubits were harmed
Technical briefings on where the field stands: Schrödinger, 1926: where it began

ψ: θ = π/3, φ = π/4
the equator: every 50/50 state
φ: invisible if you only ask 0 or 1
Pl. IV · Bloch, 1946 · click to measure
why θ/2: states at right angles, like |0⟩ and |1⟩, land at opposite poles
why simulators run out: 50 qubits hold 2^50 amplitudes, about 18 petabytes

Pl. V — Business & strategy

When your move depends on theirs.

Decisions written as models: what can be chosen, what limits the choice and what counts as better; when others choose too, where no one gains by moving alone.

u_{1} (p, q) = 2 pq + (1 - p) (1 - q) u_{2} (p, q) = pq + 2 (1 - p) (1 - q) p^{*} \in p arg max u_{1} (p, q^{*}), q^{*} \in q arg max u_{2} (p^{*}, q)

import nashpy as nash
A, B = [[2, 0], [0, 1]], [[1, 0], [0, 2]]
game = nash.Game(A, B)
list(game.support_enumeration())
# three: two pure, one mixed paying ⅔ each

Pricing and demand models: p* = 4, Q* = 6: where the curves agree
Allocation of budgets, people and capacity under constraints: each budget an axis, each limit a face
Scenario analysis and forecasts for planning: several futures to plan for, not one forecast
Decision tools that put the model in front of the people who decide: a belief, narrowed by every result

both pick the first: (2, 1)
(1, 2)
p, q ∈ [0, 1]
mixed, (⅔, ⅓): each expects only ⅔
how often player 1 picks the first
Pl. V · Nash, 1950 · no lone move pays
Nash, 1950: every finite game has one, once players may mix their choices at random
the faint curves: level lines of each payoff, in steps of 1/6
mixed: 5 misses in 9, worse than agreeing

Pl. VI — Process optimisation

Busy is not the same as fast.

Routes, schedules and queues: the processes that run every day, made shorter, cheaper or more reliable, and measured before and after.

P (N \geq n) = ρ^{n}, ρ = \frac{λ}{μ} < 1 L = n \geq 1 \sum P (N \geq n) = \frac{ρ}{1 - ρ}

def mean_in_system(λ, μ):
    ρ = λ / μ
    assert ρ < 1, "the queue grows forever"
    return ρ / (1 - ρ)

Routing and scheduling: 40 cities, no two legs crossing
Queue and capacity models: how many resources for which waiting time: the last few per cent of load are the dear ones
Automation of repetitive work: data entry, reports, reconciliations: one rule, repeated: what machines do best
Measuring a process before it changes, and after: a process is a distribution, not an average

ρ = 0.5: one in the system
ρ = 0.9: nine
ρ → 1: the queue runs away
how busy the server is
Pl. VI · Erlang, 1909 · at 99% busy, ninety-nine
Little, 1961: L = λW. At ρ = 0.9, with one arrival a minute: nine minutes, on average
from 90% to 99% busy: 10% more served, and the queue grows elevenfold, 9 to 99
Erlang worked for the Copenhagen telephone company: how many lines for how many calls

Pl. VII — Software development

Code that others can read.

Custom tools, services and platforms, written so that someone else can read, test and maintain them.

X_{k} X_{k + N /2} = E_{k} + e^{- 2 π ik / N} O_{k} = E_{k} - e^{- 2 π ik / N} O_{k}

def fft(x):
    if len(x) == 1: return x
    E, O = fft(x[0::2]), fft(x[1::2])
    w = exp(-2j*π*arange(len(x)//2) / len(x))
    return concatenate([E + w*O, E - w*O])

Web applications and internal tools: one rule, applied all the way down
Data pipelines and APIs: stages as nodes, transfers as weighted edges
Numerical and scientific software: fast, tested, reproducible: ten zeros up to t = 50, each on the line
Reviewing, testing and speeding up existing code: where the time goes, level by level

E: evens
O: odds
a butterfly: one sum, one difference
0 4 2 6 1 5 3 7: bit-reversed
the twiddle factor (its real name)
Pl. VII · Cooley & Tukey, 1965
N = a million: N² is a trillion, N log₂ N about twenty million
8 points, 3 stages: each halves the problem, so N points take log₂ N stages
Gauss had it c. 1805, for the orbits of Pallas and Juno; printed only after his death

Pl. VIII — Design & web

Drawn with the same care.

Websites and interfaces, drawn with the same care as the models behind them. This site is one: nearly every figure here is computed from its formula, in your browser.

B (t) P_{k} = k = 0 \sum 3 (k 3) (1 - t)^{3 - k} t^{k} P_{k} \leftarrow (1 - t) P_{k} + t P_{k + 1}

/* this site's easing: the arrows ride it */
--ease: cubic-bezier(.16, 1, .3, 1);
.wd-btn span {
  transition: transform .3s var(--ease);
}

Websites: structure, typography and the code that runs them: proportion: 137.5°, ten thousand times
Interfaces for software that handles a lot of data: 600 points, none crowding another
Charts and interactive figures that explain a result: sand on a plate, explaining the plate

P₁ pulls
P₂ pulls back
B(0.4): three rounds of lerp
t runs from 0 to 1; so do the buttons’ arrows
Pl. VIII · de Casteljau, 1959 · Bézier, 1962
each point is a weighted average of P₀ … P₃: the curve never leaves their hull
the site’s easing, (.16, 1) and (.3, 1): fast, then it settles; with P₁, P₂ at height 1 it never overshoots
de Casteljau at Citroën kept it secret; Bézier at Renault published: his name stuck

Not on the list

Another field? Add a term.

These plates are examples, not the limits. If a problem can be stated precisely, or you think it could be, we would like to hear about it.

f_{9} (x) = f_{8} (x) + \frac{4}{π} \frac{sin 17 x}{17}

fields = ["finance", "ai", "blockchain",
          "quantum", "business",
          "processes", "software",
          "design"]
fields.append(yours)
# the list was never complete

Write the brief

the next term: yours
face on, ten sums fuse into one shape
sin 17x / 17: a seventeenth of the first term
small, and still it sharpens every corner
fields.append(yours): O(1), amortised
why 17: the ninth odd number, 2·9 − 1; f(x + π) = −f(x) leaves only odd terms
far from the jumps the error falls like 1/n; next to them, the 9% overshoot never does