Code Examples & Deep Dives

Signal from Noise

Quantum creates uncertainty, uncertainty creates risk, and code turns that risk into random variables you can measure and simulate. At the fundamental level we rely on random number generators for encryption and trustworthy sampling, including physical entropy sources like lava-lamp RNGs.

See the conceptual chain in Quantum vs Classical and Plain Language Guide.

Portfolio as a wave function: density matrices instead of variance–covariance matrices

Below is a compact, code-adjacent sketch of the idea: in a quantum-flavored actuarial / MPT model, the classical variance–covariance matrix \(\Sigma\) is upgraded to a density matrix \(\rho\), and a portfolio is treated as a wave function \(|\psi\rangle\). This mirrors what you might simulate with Stan, but in linear-algebra form.

Classical MPT / actuarial notation

// n assets, vector of random returns R
// mean vector μ, variance–covariance matrix Σ

E[R]   = μ               // n×1
Cov(R) = Σ               // n×n (symmetric, PSD)

// portfolio weights (deterministic)
vector[n] w;
real R_p = dot_product(w, R);     // portfolio return

real mean_p   = dot_product(w, μ);
real var_p    = quad_form(Σ, w);  // w^T Σ w

LaTeX form: \( \mathbb{E}[R] = \mu \), \( \operatorname{Cov}(R) = \Sigma \), \( R_p = w^\top R \), \( \mathbb{E}[R_p] = w^\top \mu \), \( \operatorname{Var}(R_p) = w^\top \Sigma w \).

\( \mathbb{E}[R] = \mu \), \( \operatorname{Cov}(R) = \Sigma \), \( R_p = w^\top R \), \( \mathbb{E}[R_p] = w^\top \mu \), \( \operatorname{Var}(R_p) = w^\top \Sigma w \).

Quantum-style upgrade

We now re-interpret these same objects in a Hilbert-space way:

• Basis states \(|e_i\rangle\): one-hot exposure to asset \(i\).
• Portfolio wave function \(|\psi\rangle = \sum_i \psi_i |e_i\rangle\) with \(\sum_i |\psi_i|^2 = 1\).
• Density matrix (pure state) \(\rho = |\psi\rangle\langle\psi|\).
• Return operator \(\hat R\) with components \(\hat R |e_i\rangle = R_i |e_i\rangle\) in the simplest diagonal case.

In code-flavored pseudomath:

// amplitudes ψ (complex allowed), normalized
complex psi[n];

// density matrix ρ_ij = ψ_i ψ*_j
complex rho[n, n] = outer_product(psi, conj(psi));

// return operator R̂ (for illustration, take it diagonal)

real R_vals[n];    // possible asset returns
complex R_op[n, n];
for (i in 1:n) {
  for (j in 1:n) R_op[i,j] = (i == j) ? R_vals[i] : 0;
}

// quantum expectation of portfolio return

real R_vals[n];                    // possible asset returns
complex R_op[n, n];

for (i in 1:n) {
  for (j in 1:n) {
    R_op[i,j] = (i == j) ? R_vals[i] : 0;
  }
}

// quantum expectation of portfolio return
complex mean_p_q = trace(rho * R_op);  // ≈ classical w^T μ

Mathematically,

ρ = |ψ><ψ|
<R̂>_ψ = <ψ| R̂ |ψ> = Tr(ρ R̂)

LaTeX form: \( \rho = |\psi\rangle\langle\psi| \), \( \langle \hat R \rangle_\psi = \langle \psi|\hat R|\psi\rangle = \operatorname{Tr}(\rho \hat R) \).

\( \rho = |\psi\rangle\langle\psi| \), \( \langle \hat R \rangle_\psi = \langle \psi|\hat R|\psi\rangle = \operatorname{Tr}(\rho \hat R) \).

If \(\hat R\) is diagonal in the \(|e_i\rangle\) basis and we ignore phases, \(|\psi_i|^2\) plays the same role as classical weights \(w_i\). But once off-diagonal elements are allowed, \(\rho\) carries richer cross-asset structure than \(\Sigma\) alone.

Stan-style simulation vs Schrödinger-style evolution

Stan would typically simulate posterior draws of parameters \(\theta\) (e.g., drifts, vols, correlations) and then simulate returns:

// very schematic Stan pseudo-flow
for (m in 1:M) {
  θ[m] ~ posterior(· | data);      // parameters: μ[m], Σ[m], etc.
  R[m] ~ mvnormal(μ[m], Σ[m]);     // draw returns
  R_p[m] = dot_product(w, R[m]);
}
// compute empirical mean/var/VaR of R_p from samples

In the wave-function view, instead of sampling many \(\theta\), we evolve the state itself under a Hamiltonian \(\hat H\) that encodes drift/volatility/market structure:

// time evolution of portfolio state ψ_t
// i ℏ d|ψ_t>/dt = Ĥ |ψ_t>

psi_t+Δt ≈ exp(-i Δt Ĥ / ℏ) * psi_t;

// at horizon T, density matrix ρ_T = |ψ_T><ψ_T|
// expected payoff under operator Π̂
price_0 ≈ discount * trace(ρ_T * Π̂);

This is the code-level version of “instead of running Stan simulations over parameter space, we let the whole portfolio turn into a wave function and flow under \(\hat H\).”

Black–Scholes as the one-asset limit

For a single risky asset in Black–Scholes, under the risk-neutral measure we have

dS_t = r S_t dt + σ S_t dW_t

The price \(V(S,t)\) of a European claim satisfies

∂V/∂t + (1/2) σ^2 S^2 ∂^2V/∂S^2 + r S ∂V/∂S - r V = 0

After changing variables \(x = \ln S\) and switching to forward time \(τ = T - t\), this maps to a heat equation which can be written in imaginary time as

∂φ/∂τ = (1/2) σ^2 ∂^2φ/∂x^2 - V_eff(x) φ

Under a Wick rotation \(τ → i t\), this resembles a Schrödinger equation

i ℏ ∂ψ/∂t = Ĥ ψ

with \(\hat H\) containing a kinetic term (diffusion from \(σ\)) plus an effective potential. In this limit:

• Classical risk-neutral density \(f_{S_T}(s)\) ↔ \(|\psi(s,T)|^2\).
• Option price \(V_0\) ↔ expectation \(\langle \psi_T| \hat \Pi |\psi_T\rangle\).

So Black–Scholes is already half-way to the quantum formalism: it evolves distributions through a linear PDE. The density-matrix formulation just generalizes this to multiple coupled assets and richer dependence than a single \(\Sigma\) can conveniently express.

Classical vs Quantum Computer: pseudo-code views

This section strips away hardware details and shows, in pseudo‑code, how a conventional laptop and a quantum processor “feel” different as machines.

Conventional computer (motherboard + CPU + RAM)

// physical picture
// --------------------------------------------------
// motherboard: connects CPU, RAM, storage, peripherals
// CPU: executes instructions sequentially (with some parallelism)
// RAM: holds bits (0 or 1) for active programs

machine ClassicalComputer {
  Motherboard board;
  CPU         cpu;
  RAM         ram;
  Storage     disk;
}

// run a program
function run_classical(program P, input bits_in[]):
  // 1. load code and data into RAM
  ram.load(P.code)
  ram.load(bits_in)

  // 2. CPU executes instructions one by one
  while cpu.instruction_pointer not at END(P):
    instr = ram.fetch(cpu.instruction_pointer)
    cpu.execute(instr, ram)
    cpu.instruction_pointer++

  // 3. read out output bits from RAM
  bits_out = ram.read(P.output_region)
  return bits_out

Quantum processor (QPU + classical control computer)

// physical picture
// --------------------------------------------------
// classical control computer: compiles code, sends pulses
// quantum processing unit (QPU): array of qubits on a chip
// cryostat: keeps QPU near absolute zero

machine QuantumComputer {
  ClassicalControl ctrl;     // compiler, schedulers
  QuantumProcessingUnit qpu; // qubits + control lines
}

// high-level quantum run
function run_quantum(circuit C, classical_input bits_in[]):
  // 1. classical pre-processing
  //    e.g., encode bits_in into initial qubit states
  compiled_pulses = ctrl.compile(C, bits_in)

  // 2. upload pulse schedule to QPU
  qpu.load(compiled_pulses)

  // 3. apply quantum operations (unitaries)
  qpu.apply_pulses()
  // internally, each gate is a unitary U on |ψ>:
  //    |ψ_new> = U |ψ_old>

  // 4. measure qubits
  measurement_record = qpu.measure_all() // collapses |ψ> → classical bits

  // 5. classical post-processing
  result = ctrl.post_process(measurement_record)
  return result

Conceptually:

• The classical CPU walks through a list of instructions, flipping bits in RAM.
• The QPU evolves a joint quantum state \(|\psi\rangle\) of many qubits by applying gates (unitaries), then collapses that state to classical bits via measurement.

Same abstract computation, two execution models

Imagine we want to compute the parity (even/odd) of \(N\) bits.

Classical laptop parity

function parity_classical(bits[]):
  acc = 0
  for b in bits:
    acc = acc XOR b
  return acc  // 0 = even, 1 = odd

Quantum parity sketch (conceptual)

function parity_quantum(bits[]):
  // 1. encode bits into computational basis states
  //    |b_1 b_2 ... b_N>
  |ψ> = |b_1 b_2 ... b_N>

  // 2. use a circuit of CNOTs to copy global parity into an ancilla qubit
  //    |ψ, 0>  →  |ψ, parity(bits)>
  for i in 1..N:
    CNOT(control = qubit_i, target = ancilla)

  // 3. measure only the ancilla qubit
  result = measure(ancilla)
  return result  // 0 = even, 1 = odd

On such a small task, the quantum route is not “better” than the classical one—it is just a different physical implementation of the same logical function. Real quantum advantage typically appears in problems that exploit superposition and interference over huge state spaces.

Hardware analogy table: consumer laptop vs quantum processor

The numbers below are intentionally rounded, order-of-magnitude style, to give intuition. Real devices vary wildly; treat these as cartoon benchmarks, not spec sheets.

"How many laptops equal one quantum processor?" (cartoon answers)

The trick is: you cannot fairly compare them just by counting operations per second, because a quantum gate on \(N\) qubits simultaneously transforms amplitudes across \(2^N\) basis states. Still, you can get a feeling by asking:

Example 1: simulating 30 qubits on laptops

• State vector size: \(2^{30} \approx 10^9\) complex amplitudes.
• One layer of single‑qubit gates might touch all \(10^9\) amplitudes.
• A single good laptop GPU at ~10¹² FLOP/s can simulate ~10³ such layers per second in theory, but memory bandwidth and overhead reduce this a lot.

A small physical QPU with 30–40 qubits applies the same logical layer directly in hardware; it is as if you had a cluster of hundreds to thousands of laptops working together to update all amplitudes every gate.

Example 2: 50‑qubit state

• State vector size: \(2^{50} \approx 10^{15}\) complex amplitudes.
• Storing this naively (16 bytes per complex) needs ~16 petabytes of RAM.
• Even a supercomputer cluster of millions of consumer‑class laptops would struggle to hold and update this in full generality.

So for generic 50‑qubit circuits, one real QPU is morally comparable to an enormous classical cluster. For structured problems, clever classical algorithms can do much better—that’s why the “how many laptops” question has no single honest number.

Very rough equivalence table (for mental models only)

This table only matches memory capacity, not speed. But it gives a rough intuition: once you pass ~40–50 entangled qubits in a generic circuit, brute‑force classical simulation starts looking like “you’d need an absurd number of consumer laptops.”