Quantum-Inspired Classical Methods

Five lessons ago you arrived expecting quantum computers to vaporize your option-pricing grid. Then this course walked you through the sober map: one clean quadratic speedup (amplitude estimation), an optimization detour that might matter for discrete constraints, a machine-learning story that mostly doesn’t, and a wall of noise, qubit-count, and data-loading problems that keeps nearly all of it parked in “someday.”

So here is the question that actually pays your rent: what can you run on Monday morning?

The answer is delightful and a little subversive. The most reliable “quantum” wins in finance today require no qubits at all. They are classical algorithms — running on the same CPUs and GPUs you already own — that borrowed their core structure from quantum information theory. No decoherence. No state-preparation wall. No three-hour queue for a 127-qubit machine that loses coherence before your circuit finishes. Just clever linear algebra that quantum research inspired, deployed on ordinary hardware.

This is the payoff lesson. After all the reality checks, here is the part of the field that genuinely ships.

What “quantum-inspired” actually means

Analogy. Bird flight inspired the airplane, but a Boeing 747 has no feathers and never flaps. Engineers stole the principle — a curved surface generating lift — and implemented it in aluminum and jet fuel. Quantum-inspired algorithms are the 747: they took a principle from quantum mechanics (how to represent enormous, highly correlated states compactly) and built it out of plain floating-point arithmetic.

Definition. A quantum-inspired classical algorithm is a classical algorithm whose design borrows mathematical structure from quantum information theory — most often the compact representation of high-dimensional states and correlations — but which runs entirely on conventional hardware with no quantum processor in the loop.

The structure most worth stealing is this: a quantum state of $n$ qubits lives in a space of dimension $2^n$, yet the physically relevant states (low-entanglement ones) can be described with far fewer numbers. Quantum physicists built decades of machinery to exploit that. It turns out many classical problems have the same low-rank structure, so the same machinery compresses them too — on a laptop.

Worked example — the size of the prize. Suppose you want to represent a joint state or correlation structure over $n = 40$ assets, with two states each (“up/down”). The naive representation needs $2^{40} \approx 1.1 \times 10^{12}$ numbers — over a trillion. At 8 bytes each that is roughly 8 terabytes; you cannot even hold it in memory. A quantum-inspired representation (a tensor network, next section) with a modest compression parameter can describe the same object in around $10^5$ numbers — under a megabyte. The catch, always, is when that compression is faithful.

When to use it

Reach for the quantum-inspired toolbox first whenever a problem looks quantum (huge state spaces, correlation structure, optimization over many binary choices) but you need an answer this quarter, not this decade. It is the highest-expected-value place to start because it ships today and the downside is bounded: worst case, it reduces to a classical method you already understand.

Tensor networks — the headline technique

Analogy. You already know that a big matrix can often be written as the product of two skinny ones — that is a low-rank factorization (an SVD truncated to its top components). A tensor network is the same trick generalized to objects with many indices at once. If a low-rank matrix is a hammock strung between two posts, a tensor network is a whole suspension bridge: a chain of small tensors, each connected to its neighbors, that together reconstruct an object far too large to write down directly.

Definition. A tensor network represents a high-dimensional tensor (an array with many indices) as a set of smaller tensors contracted together. The most common form for a one-dimensional chain of $n$ sites is a Matrix Product State (MPS), known in applied math as a tensor train. Each site holds a small tensor, and adjacent tensors are linked by a bond whose width $D$ — the bond dimension — controls how much correlation (in physics terms, entanglement) the representation can capture.

The storage cost tells the whole story. A dense tensor over $n$ sites of local dimension $d$ costs $d^{\,n}$ numbers. An MPS with bond dimension $D$ costs roughly

$\text{cost}_{\text{MPS}} \approx n \cdot d \cdot D^2,$

which is linear in $n$ instead of exponential. The exponential wall becomes a gentle slope — if and only if the true object has low enough bond dimension to be captured by a modest $D$.

Worked example — the compression factor. Take $n = 40$ assets, local dimension $d = 2$, and a bond dimension $D = 50$.

• Dense cost: $d^{\,n} = 2^{40} \approx 1.1 \times 10^{12}$ numbers.
• MPS cost: $n \cdot d \cdot D^2 = 40 \times 2 \times 50^2 = 40 \times 2 \times 2500 = 200{,}000$ numbers.

The compression factor is about $1.1 \times 10^{12} / 2.0 \times 10^5 \approx 5.5 \times 10^6$ — roughly five million to one. A trillion-number object squeezed into a couple hundred thousand. That is the headline, and it is real arithmetic, not a metaphor.

When to use it

Tensor networks earn their keep when your object is enormous and its correlations are local or rapidly decaying — so a small bond dimension reconstructs it within tolerance. Before deploying one, measure: truncate at several bond dimensions and watch the reconstruction error fall. If it plateaus low at modest $D$, you have a genuine win. If the error stays stubborn until $D$ explodes, your problem is high-entanglement and a tensor network is the wrong tool — no amount of cleverness compresses incompressible correlation.

Tensor networks in finance — sober applications

Analogy. Tensor networks in finance are like a very good compression codec. A codec will not invent detail that is not in the source, but on the right kind of content it shrinks the file dramatically with little visible loss. Point it at random static and it helps nothing. The art is matching the codec to content with exploitable redundancy.

Definition / where the structure appears. Several finance problems carry the kind of low-rank correlation structure tensor networks were built for:

Worked example — beating the curse of dimensionality on a basket option. Price a basket option on $n = 30$ underlyings on a grid with $m = 50$ points per dimension. A naive grid has $m^{\,n} = 50^{30}$ cells — a number with 51 digits, utterly hopeless. If the solution tensor has bond dimension $D = 30$, a tensor-train representation costs about $n \cdot m \cdot D^2 = 30 \times 50 \times 900 = 1{,}350{,}000$ cells — about a million, which fits comfortably in memory. The high-dimensional PDE becomes solvable on a laptop, precisely because the smooth, factor-driven solution is low-rank. (Compare: classical Monte Carlo also tames this dimension, with $1/\sqrt{N}$ error — so the honest comparison is tensor-train accuracy and runtime against your best MC implementation, not against the impossible dense grid.)

When to use it

Use tensor-network methods on a finance problem when (1) the naive representation is exponentially large, (2) you have evidence of factor/low-rank structure (a scree plot, a few dominant principal components, smooth payoffs), and (3) a careful benchmark shows the tensor approach beats your best classical baseline on accuracy-per-second at the precision you actually need. Skip them when a handful of factors or a plain Monte Carlo already nails the problem — adding tensor machinery then is complexity for its own sake.

Other quantum-inspired threads

Tensor networks are the headline, but two other quantum-inspired threads matter for the finance practitioner.

Simulated and digital annealing for QUBO. Recall from QUBO and Portfolio Optimization that we can recast portfolio selection — with cardinality and lot constraints — as a binary optimization problem (a QUBO). Quantum annealers (D-Wave-style) promise to solve these. But the quantum-inspired classical response is the digital annealer: a special-purpose classical chip (Fujitsu built a famous one) that runs annealing-style search at enormous speed in plain silicon. Today these classical annealers frequently match or beat their quantum cousins on real QUBO instances, with none of the qubit-count, connectivity, or noise limits. The annealing metaphor — slowly cooling a system toward its lowest-energy state — came from physics; the winning implementation is classical.

The Tang dequantization story. In 2018, a then-undergraduate named Ewin Tang did something that should be tattooed on every quantum-finance pitch deck. A quantum recommendation algorithm had been celebrated as an exponential speedup over the best known classical method — a flagship example of quantum advantage. Tang produced a classical algorithm, inspired by the quantum one’s sampling structure, that ran in polynomial time too — matching the quantum speedup on a classical computer. The claimed exponential advantage simply evaporated. A wave of similar “dequantization” results followed for other linear-algebra speedups.

Definition. Dequantization is the discovery of a classical algorithm whose runtime matches a previously claimed quantum speedup, removing the need for quantum hardware. It is the field’s most humbling pattern: an “advantage” can vanish the moment a clever classical researcher studies the quantum algorithm’s structure closely enough.

When to use it

Reach for a classical or digital annealer before you queue for a quantum annealer on any QUBO — it is faster to access, has no connectivity limits, and on today’s hardware usually wins. And treat every “exponential quantum advantage” claim as provisional until you have checked it against the current best classical algorithm (post-dequantization), not the one the original paper happened to compare against.

The capstone discipline — beat the best classical baseline

This is the creed the whole course has been building toward, so say it plainly: a theoretical speedup is not a PnL edge until the entire end-to-end pipeline beats the best classical baseline on the same problem at the same precision.

Analogy. A sprinter who runs the middle 50 meters faster than anyone alive still loses the 100-meter race if the start blocks jam and the finish-line camera takes an hour to read the result. The race is timed end to end. So is every algorithm that wants your capital. The quantum circuit might be the fast middle 50 meters — but data loading is the jammed blocks (the state-preparation wall from lesson 5), and readout plus repetitions is the slow camera.

The end-to-end accounting. Total cost of any candidate method, classical or quantum, is the sum of all stages, not the headline of one:

$\text{Cost}_{\text{total}} = \text{Cost}_{\text{load}} + \text{Cost}_{\text{compute}} + \text{Cost}_{\text{readout}} \times \text{repetitions} + \text{Cost}_{\text{access}}.$

A quadratic speedup in $\text{Cost}_{\text{compute}}$ is worthless if $\text{Cost}_{\text{load}}$ is exponential (the data-loading wall), or if you must repeat the run thousands of times for a stable estimate, or if hardware access costs dwarf the saving. The honest comparison holds precision fixed and compares the whole sum against the best classical method.

Worked example — when a quadratic speedup loses. Amplitude estimation promises to turn Monte Carlo’s $N$ samples into about $\sqrt{N}$ — for a target where classical MC needs $N = 10^6$ samples, the quantum core needs on the order of $10^3$ oracle calls. Looks like a thousand-fold win. Now add the rest of the race:

The thousand-fold core speedup is genuine — and it can be entirely eaten by a state-preparation step that costs as much as the samples you were trying to avoid. That is why lesson 5 called data loading the wall that quietly cancels most advantages. The discipline is to add up the whole table before believing the headline.

The decision checklist. Before you commit capital or engineering time to any “advanced” method — quantum, quantum-inspired, or exotic classical — run this gate:

1. Define the exact problem and target precision. Vague benchmarks hide losses.
2. Build the strongest classical baseline you can. Not a strawman — the actual best method, well-tuned. (Remember dequantization: the baseline keeps improving.)
3. Account for the full pipeline. Loading, compute, readout, repetitions, access cost — every stage, summed.
4. Match precision on both sides. A faster wrong answer is not a win.
5. Compare end-to-end cost at that precision. Only a total-cost win counts.
6. Stress the assumption that made it look good. Is the structure really low-rank? Is loading really cheap? Is the speedup still there against the current best classical algorithm?

If a method survives all six, you have something real. Most do not — and knowing which fail and where is the expertise this course was built to give you.

The three-way map — what to use today

The sober synthesis of the whole course. Quantum computing in finance splits cleanly into two timelines. Eventually — when fault-tolerant, error-corrected hardware exists and the data-loading problem is solved for your specific use case — Quantum Amplitude Estimation is the genuine long-term bet: a provable quadratic speedup for option pricing and VaR/CVaR risk, the one clean win this course endorsed. Today, what pays rent is the unglamorous pair: quantum-inspired classical methods (tensor networks for low-rank structure, digital annealers for QUBO) and good old classical methods (Monte Carlo, factor models, convex optimization) that, run well, still beat almost everything. The expert’s stance is to hold both truths at once — invest curiosity in the someday, deploy capital on the today, and judge every candidate with the same end-to-end gate.

When to use it

Apply the six-step checklist to every method that claims an edge, not just quantum ones — it is equally lethal to overhyped classical ML, exotic data vendors, and “alpha” that never cleared a strong baseline. The moment you skip step 2 (building the strongest classical baseline) you have lost the ability to know whether your fancy method does anything at all.

Recap

You came into this course braced for either hype or dismissal, and you leave with a map. The reliable wins in quantum finance today wear no qubits: quantum-inspired classical methods — tensor networks that compress low-rank correlation structure by millions to one, and digital annealers that often out-run their quantum cousins on QUBO — running on the hardware you already own. The cautionary spine is dequantization: a claimed quantum advantage is only ever a conjecture about the best classical algorithm, and that baseline keeps improving. And the discipline that outlasts every hardware generation is the end-to-end gate: a speedup is not an edge until the whole pipeline beats the best classical baseline at matched precision. Someday, fault-tolerant QAE may earn its place in pricing and risk. Until then, what pays rent is quantum-inspired classical work and plain, well-executed classical methods.