Solving 2D Black Scholes Equation via Hermitian Block Embedding and Generalised Quantum Signal Processing

This paper proposes and numerically validates a method for solving the two-dimensional Black-Scholes equation by combining Hermitian block embedding with Generalised Quantum Signal Processing to accurately approximate the inverse of non-Hermitian time-step matrices, demonstrating the feasibility of applying modern quantum linear algebra techniques to multi-asset option pricing.

The Gist

The Big Picture: Pricing a "Basket" of Options

Imagine you are a financial trader trying to figure out the price of a special "basket" option. This isn't just a bet on one stock (like Apple); it's a bet on a mix of two different stocks (like Apple and Microsoft) moving together.

In the real world, calculating the fair price of this basket is like solving a massive, complex maze. You have to work backward from the day the bet ends (maturity) to today, figuring out how the price changes at every single step along the way.

For a long time, computers have done this using a method called "finite differences." Think of this as turning the smooth, continuous movement of stock prices into a giant grid of dots. To find the price today, the computer has to solve a giant math puzzle: it needs to invert a massive matrix (a grid of numbers) to step backward in time.

The Problem: The "Non-Symmetric" Puzzle

The math puzzle the computer faces is tricky. The grid of numbers (the matrix) it has to invert is "non-Hermitian." In plain English, this means the grid is lopsided and doesn't have a neat, symmetrical structure.

In a simpler, one-stock scenario, scientists found a clever trick to make this lopsided grid symmetrical (Hermitian) so they could use a powerful new tool called Generalised Quantum Signal Processing (GQSP). GQSP is like a super-efficient quantum machine that can solve specific types of math puzzles very fast, but it only works on symmetrical, well-behaved grids.

However, when you add a second stock, the grid becomes a complex 2D block. The old trick for making it symmetrical breaks down because the two stocks are tangled together in a way that creates "loops" in the math that can't be fixed with a simple adjustment.

The Solution: The "Hermitian Block Embedding"

The authors of this paper came up with a new way to trick the quantum machine into solving the 2D problem. They used a technique called Hermitian Block Embedding.

The Analogy: The Mirror Box
Imagine you have a lopsided, messy object (the 2D time-step matrix) that you can't put inside a special "Symmetry Machine" (GQSP).

1. The Trick: Instead of trying to fix the object itself, you build a special box around it.
2. The Construction: You place the messy object in the top-right corner of the box and its "mirror image" (the transpose) in the bottom-left corner. The top-left and bottom-right corners are empty (zeros).
3. The Result: Even though the inside is messy, the entire box is now perfectly symmetrical. It is now "Hermitian."

Now, the quantum machine can look at this big box. When the machine performs its magic (polynomial transformation) on the box, it creates a result where the "messy" part (the inverse of the original matrix) pops out in a specific corner of the box.

How They Did It: The "Odd" Polynomial

To get the answer out of this box, the authors used a special kind of math function called an odd polynomial.

• Think of an "even" function as a mirror image on both sides of a line (like a smiley face).
• Think of an "odd" function as a rotation (like a seesaw).

Because of how they built their box (with the messy part in the corner), they needed a "seesaw" type of math function. If they used a "smiley face" function, the answer would get lost. By using an "odd" function, the math naturally cancels out the empty corners and leaves the correct answer (the inverse matrix) in the bottom-left corner of the result.

The Test: Did It Work?

The team ran simulations to see if this new method actually worked for a two-stock "basket" option.

• The Setup: They simulated a basket option with two assets, using a grid of 32x32 points (1,024 total points).
• The Comparison: They compared their quantum-style solution (using the new embedding method) against a standard, trusted classical computer method (Backward Euler).
• The Result: The two methods agreed very closely. The "quantum" solution looked almost exactly like the "classical" solution.

This proved that their "Mirror Box" trick successfully captured the dynamics of the complex 2D problem. The method accurately reproduced the backward-time evolution of the option price.

The Catch: Discretisation Error

The paper notes one major limitation. Because they are simulating this on a computer, they have to take "steps" backward in time. In their simulation, they had to take a very large step (one big jump) because of the complexity.

• The Issue: Taking a giant step in a math simulation introduces "discretisation error" (roughly like trying to draw a smooth curve using only a few giant Lego bricks).
• The Finding: The error in their results was mostly due to this large step size, not a flaw in their quantum method. In fact, the error was similar to what you would get if you ran the classical method with the same giant step.

Summary

The paper demonstrates a new way to solve complex 2D financial pricing problems using quantum algorithms.

1. They couldn't use the old trick to make the math symmetrical.
2. They built a "Mirror Box" (Hermitian Block Embedding) to force the math into a symmetrical shape.
3. They used a special "Odd Polynomial" to extract the answer from the box.
4. Their simulations showed that this method works and produces results that match standard classical computers, paving the way for solving even more complex, multi-asset problems in the future.

Technical Summary

Technical Summary: Solving 2D Black–Scholes Equations via Hermitian Block Embedding and Generalised Quantum Signal Processing

1. Problem Statement

The pricing of European financial derivatives, such as options, is fundamentally modeled by the Black–Scholes partial differential equation (PDE). For multi-asset options (e.g., basket options depending on two underlying assets), the problem becomes a two-dimensional PDE. Under the standard no-arbitrage framework, pricing requires evolving the terminal payoff backward in time.

Upon discretization using finite differences and an implicit time-stepping scheme (specifically backward Euler), the continuous PDE is transformed into a sequence of linear algebra problems. The core computational task is the application of the inverse of a time-step matrix, $\tilde{M}^{-1}$, to a vector representing the option value.

• Challenge: In the two-dimensional case, the discretized matrix $\tilde{M}$ is real but generally non-Hermitian and non-unitary due to drift terms, mixed derivatives, and boundary conditions.
• Quantum Context: While quantum linear algebra algorithms like Quantum Signal Processing (QSP) and Generalised Quantum Signal Processing (GQSP) offer powerful methods for implementing matrix functions (like inversion) via polynomial transformations, they typically require the input operator to be unitary or Hermitian. Standard approaches for non-Hermitian matrices often rely on "block-encoding," which introduces significant overhead in terms of ancilla registers, circuit depth, and state preparation. Previous work [13] successfully applied a Hermitian-GQSP approach to the one-dimensional Black–Scholes equation by using a diagonal similarity transformation to convert the tridiagonal time-step matrix into a Hermitian form. However, this method fails in two dimensions because the block structure of the 2D matrix (arising from tensor-product discretization and mixed derivatives) prevents the existence of a diagonal similarity transformation that preserves Hermiticity.

2. Methodology

The authors propose a Hermitian block embedding strategy to extend the GQSP framework to the two-dimensional Black–Scholes equation without requiring a diagonal similarity transform or conventional block-encoding overheads.

A. Hermitian Block Embedding
Instead of attempting to symmetrize the non-Hermitian matrix $\tilde{M}$ directly, the authors embed it into a larger Hermitian matrix $H$ of dimension $2N \times 2N$ (where $N$ is the dimension of the discretized grid):
$$H = \begin{pmatrix} 0 & \tilde{M} \\ \tilde{M}^T & 0 \end{pmatrix}$$
Since $\tilde{M}$ is real, $H$ is real symmetric and thus Hermitian. The inverse of this embedded matrix is:
$$H^{-1} = \begin{pmatrix} 0 & \tilde{M}^{-T} \\ \tilde{M}^{-1} & 0 \end{pmatrix}$$
Crucially, the desired inverse time-step operator $\tilde{M}^{-1}$ appears in the lower-left off-diagonal block of $H^{-1}$.

B. Odd Polynomial Approximation
The structure of $H$ imposes a parity property on its powers: even powers of $H$ are block-diagonal, while odd powers are block off-diagonal.

• The authors construct an odd polynomial $p(x) = \sum c_{2m+1} x^{2m+1}$ to approximate the inverse function $f(x) = 1/(\gamma x)$ on the spectrum of $H$.
• Because $p(x)$ is odd, $p(H)$ remains block off-diagonal. Consequently, the lower-left block of $p(H)$ approximates $\tilde{M}^{-1}$.
• This allows the recovery of the backward-time evolution step by applying the polynomial transformation to an embedded input state $\begin{pmatrix} V^n \\ 0 \end{pmatrix}$ and extracting the lower half of the resulting vector.

C. Spectral Scaling and GQSP Implementation

• Scaling: The matrix $H$ is rescaled by a factor $\gamma = \max |\lambda_i(H)|$ to define $A = H/\gamma$, ensuring the spectrum lies within $[-1, 1]$. The spectrum is symmetric about zero, lying in $[-1, -\delta] \cup [\delta, 1]$, where $\delta$ is determined by the condition number of $\tilde{M}$.
• GQSP: The rescaled Hermitian matrix $A$ is embedded into a unitary operator $U = A + i\sqrt{I-A^2}$. The GQSP algorithm is then used to implement the odd polynomial transformation $p(A)$ on $U$.
• Output: The quantum circuit outputs a state where the lower register contains the approximated solution $V^{n+1} = \tilde{M}^{-1}V^n$.

3. Key Contributions

• Extension to 2D: The paper extends the Hermitian-GQSP framework from one-dimensional to two-dimensional Black–Scholes equations, overcoming the structural obstruction that prevents the use of diagonal similarity transformations in higher dimensions.
• Block-Embedding-Free Approach: The authors demonstrate a method to solve the inverse problem for non-Hermitian matrices using GQSP without the heavy overhead of standard block-encoding techniques, relying instead on a specific Hermitian dilation and odd-polynomial structure.
• Proof of Principle: The work provides a proof of principle that modern quantum linear algebra techniques can be applied to multidimensional option pricing problems.

4. Numerical Results

The authors performed numerical simulations for two-asset European basket call options using Python and PennyLane.

• Setup: Two simulations were conducted with varying financial parameters (volatility, correlation, strike price, etc.) and grid sizes ($32 \times 32$ grid points, embedded into $2048$ dimensions).
• Comparison: The GQSP-based solutions were benchmarked against:
  1. A classical backward Euler finite-difference method.
  2. A classical polynomial approximation applied directly to the Hermitianized matrix.
• Findings:
  • The GQSP solutions showed close agreement with both the classical polynomial approximation and the backward Euler benchmark.
  • The results confirmed that the Hermitian block embedding accurately captures the dynamics of the original non-Hermitian operator.
  • Error Sources: The analysis identified two primary error sources:
    1. Polynomial Approximation Error: Dependent on the spectral gap $\delta$. In the second simulation, a larger spectral gap resulted in lower approximation errors.
    2. Discretization Error: Due to the necessity of using a single large time-step (as the method was implemented as a single-step solver), the discretization error was significant (up to \approx \0.09$ in the first simulation and $\approx 60\%$ larger in the second). This error is inherent to the classical benchmark as well.
  • Noise: The quantum simulation exhibited a noise floor (observed around $10^{-2}$ in the second simulation), which was not present in the classical polynomial approximation.

5. Significance and Claims

The paper claims that the proposed method demonstrates the feasibility of combining Hermitian block embeddings with GQSP for solving multidimensional Black–Scholes problems.

• Modest Scope: The authors explicitly state that the current implementation is a "single-step inverse solver." They do not claim a full quantum advantage yet, noting that the method is limited by the need for higher-degree polynomials when the spectral gap is small and by the discretization errors of large time-steps.
• Future Potential: The significance lies in providing a pathway to quantum algorithms for multi-asset derivatives where classical computers face the "curse of dimensionality." The authors suggest that the true potential for quantum advantage may emerge in 3+ dimensions, where classical finite-difference methods become computationally intractable.
• Limitations: The paper acknowledges that future work is required to develop efficient multi-step time-evolution schemes, reduce the noise floor, and minimize discretization errors through better grid strategies or multi-step GQSP implementations.

In summary, the paper establishes a theoretical and numerical foundation for applying GQSP to 2D option pricing by introducing a Hermitian block embedding that bypasses the need for diagonal similarity transforms, offering a viable route toward quantum algorithms for high-dimensional financial derivatives.