One of the most well known and powerful techniques to address high-dimensionality is known as Principal Component Analysis (PCA), a statistical technique used to simplify complex datasets by reducing their dimensionality while preserving the most important information. This blog post discusses PCA, focusing on the selection of the principal components, and then introduce a quantum circuit performing quantum Principal Component Analysis, a quantum algorithms providing an exponential speedup over PCA.

Principal Component Analysis

Principal Component Analysis (PCA), also known as the Karhunen-Loève transformation, the Hotelling transformation or the method of empirical orthogonal functions, aims to project \(p\)-dimensional vectors to the so-called principal components, i.e. \(q\)-dimensional vectors, where \(q

There are several equivalent ways of deriving the principal components mathematically and the following section shows that finding the projectors maximizing the variance is equivalent to minimizing the means squared distance between the original vectors and their projections on to the principal components.

Mathematics of principal components

Let a centered matrix \(X \in C^{n\times p}\) and let \(\{x_i\}_{i=1}^n\) be \(p\)-dimensional vectors (i.e. they represent the columns of \(X\)). The projection of the \(x_i\) on to a line (\(w\)) through the origin (for simplicity) is:

\[(x_i ^\dagger w) w\]

It’s relevant to note that the mean of the projections is zero being the vectors \(x_i\) centered:

\[\frac 1n \sum_i (x_i ^\dagger w) w=\frac 1n \sum_i (x_i)^\dagger w w\]

Being a projection, the projected vectors are (in general) different from the original vectors, which means there’s some error. Such error is defined as:

\[\begin{aligned}\left\|{x_i}-\left({w} ^\dagger {x_i}\right) {w}\right\|^2= & \left({x_i}-\left({w} ^\dagger {x_i}\right) {w}\right) ^\dagger\left({x_i}-\left({w} ^\dagger {x_i}\right) {w}\right) \\ = & {x_i} ^\dagger {x_i}-{x_i} ^\dagger\left({w} ^\dagger {x_i}\right) {w} \\ & -\left({w} ^\dagger {x_i}\right) {w} ^\dagger {x_i}+\left({w} ^\dagger {x_i}\right) {w} ^\dagger\left({w} ^\dagger {x_i}\right) {w} \\ = & \left\|{x_i}\right\|^2-2\left({w} ^\dagger {x_i}\right)^2+\left({w} ^\dagger {x_i}\right)^2 {w} ^\dagger {w} \\ = & {x_i} ^\dagger {x_i}-\left({w} ^\dagger {x_i}\right)^2\end{aligned}\]

Since the vector \(w\) is defined as normal, the mean squared error (MSE) is equivalent to:

\[\text {MSE}=\frac 1n \sum_{i=1}^n {x_i} ^\dagger {x_i}-\left({w} ^\dagger {x_i}\right)^2\]

Considering that the first inner product doesn’t involve \(w\) and is therefore a constant, minimizing the MSE is then equivalent to:

\[\text{max}_w \frac 1n\sum_{i=1}^n (w^\dagger x_i)^2\]

Since the mean of a square is always equal to the square of the mean plus the variance, the function to be maximized is equivalent to:

\[\text{max}_w \frac 1n\sum_{i=1}^n (w^\dagger x_i)^2 = \text{max}_w \left(\frac 1n \sum_{i=1}^n x_i ^\dagger w\right)^2 + \text{var}(w^\dagger x_i)\]

However, since that the mean of the projections is zero (see the above), minimizing the residual sum of squares turns out to be equivalent to maximizing the variance of the projections.

This is true also if we don’t want to project on to just one vector, but on to multiple principal components.

Accordingly then, the variance \(\sigma\left({{w}}^2\right) \) is defined (in matrix form) as:

\[\begin{aligned} \sigma^2 \left({{w}}\right) & =\frac{1}{n} \sum_i\left({x_i} ^\dagger {w}\right)^2 \\ & =\frac{1}{n}({x w})^\dagger({x w}) \\ & =\frac{1}{n} {w}^\dagger {x}^\dagger {x w} \\ & ={w}^\dagger \frac{{x}^\dagger {x}}{n} {w} \\ & ={w}^\dagger {V w}\end{aligned}\]

where \(V\) is the covariance matrix of \(x\).

Therefore the constrained maximization problem is:

\[\text{max}_w \space\sigma^2(w) \space \text{s.t.} \space w^\dagger w =1\]

Using the Lagrange multiplier \(\gamma\), the objective function becomes:

\[L(\gamma, w) = w^\dagger V w-\gamma(w^\dagger w-1)\]

The first order conditions are:

\[\begin{align} & \frac {\partial L}{\partial w}\ = 2Vw-2\gamma w\\ & \frac{\partial L}{\partial \gamma}\ = w^\dagger w-1\end{align}\]

Setting the derivatives to zero at optimum the system becomes:

\[\begin{align} & Vw=\gamma w\\ &w^\dagger w=1\end{align}\]

and from the top equation is clear that the \(w\) maximizing the variance are the orthonormal eigenvectors of the covariance matrix associated with the largest \(q\) eigenvalues \(\gamma\).

It’s clear that if the data are approximately \(q\)-dimensional (i.e. \(p-q\) eigenvalues are close to 0), the residual will be small and the \(R^2\) (the fraction of the original variance of the dependent variable kept by the fitted values), computed as:

\[R^2 = \frac{\sum_{i=1}^q \gamma_i}{\sum_{i=1}^p \gamma_i}\]

will be close to 1.

Complexity analysis of PCA

Assuming \(X\in C^{n\times p}\), the cost of PCA is:

• computing \(V\)is \(\mathcal O(n\times p^2)\)

• computing the eigenvalues and eigenvectors requires \(\mathcal O(p^3)\)

Hence the overall complexity is \(\mathcal O(n\times p^2 + p^3) \approx \mathcal O(p^3)\).

Quantum Principal Component Analysis

The idea behind Quantum Principal Component Analysis (qPCA) is to use quantum subroutines to perform PCA faster. In particular, the idea is to use Quantum Phase Estimation (QPE) to get information about the eigenvalues and the eigenvectors of a density matrix representing the covariance matrix. The next section is therefore about introducing QPE, while the following sections discuss qPCA.

Quantum Phase Estimation

Let \(U\) a unitary operator and let \(\ket{u_k}\) and \(e^{i\lambda_k}\) be the \(k\)-th eigenvector and eigenvalue of \(U\). Assume also a generic state \(\ket \psi\), which can always be defined as:

\[\ket \psi= \sum_{k=1}^nc_k\ket {u_k}\]

The goal of the QPE is to perform the following transformation:

\[\text{QPE}:\ket{0}^{\otimes n}\ket{\psi} \rightarrow \sum_{k=1}^nc_k\ket{\lambda_k }\ket{u_k}\]

where \(\ket {\lambda_k}\) is the quantum state \(\ket {j_1\dots j_n}\) corresponding to \(n\) digits representation of the binary fractional representing the eigenvalue phase.

The circuit of the algorithm is the following:

First, each of the nn qubits initialized to \(\ket 0\) is subjected to the Hadamard gate and control unitary operations acting on \(\ket u\), which perform the following transformation:

\[\ket 0^{\otimes n}\ket u \rightarrow \bigotimes_{k=1}^n \left(\frac{\ket 0 +e^{i2\pi0.j_1\dots j_k}\ket {1}}{\sqrt 2} \right) \otimes\ket u\]

In other words, binary decimal representation of the phase of the eigenvalue is stored in the phase of each auxiliary qubit, with digits shift one position repeatedly.

The states of the \(n\) auxiliary qubits have exactly the same form as the expression for the result of the quantum Fourier transform, therefore applying the inverse quantum Fourier transform and measuring the \(n\)ancilla bit results in \(0.j_1\dots j_n\) which the \(\lambda\).

Density matrix exponentiation

One can then imagine that if we’re able to encode the covariance matrix as a quantum gate, we can use QPE to obtain information regarding the eigenvalues and the eigenvectors. That’s indeed true, however the most important property of quantum gates is unitarity, i.e. for any quantum gate \(G\):

\[G^\dagger= G^{-1}\]

This however is not generally true for covariance matrices, however, one can make a covariance matrix unitary by using exponentiation. Assume the covariance matrix has been encoded in a density matrix \(\rho\) and assume one is presented with \(n\) copies of \(\rho\). The density matrix exponential:

\[e^{-i\rho t}\]

is unitary.

One method to perform such exponentiation up to \(n\)-th order in \(t\) is to repeat the following:

\[\text{Tr}_p \left[e^{-iS\Delta t} \otimes \sigma \otimes e^{iS\Delta t}\right] = \sigma -i\Delta t[\rho, \sigma]+\mathcal O(\Delta t^2)\]

where \(\sigma\) is any density matrix, \(S\) is the swap operator and \([A, B] = A-B\) and \(\text{Tr}_p\) is the partial trace on the first system. It’s worth to note that since \(S\) is a sparse matrix, the exponentiation of \(S\) can be computed efficiently. Applying the above formula \(n\) times leads to:

\[e^{-i\rho n\Delta t} \otimes \sigma \otimes e^{i\rho n\Delta t}\]

which, couple with the quantum matrix inversion technique of (Harrow, Hassidim, Lloyd, 2009, “Quantum algorithm for linear systems of equations“) allows to efficiently construct the exponential of \(\rho\).

So, assuming a non-sparse positive \(X\) whose trace is 1, to construct:

\[e^{-iXt}\]

requires to factor \(X\) as:

\[X=A^\dagger A=\sum_i |a_i|\ket{\hat a_i}\ket {e_i}\]

where \(A=\sum_i |a_i|\ket{\hat a_i}\ket {e_i}\) \(\hat a_i\) is the version of \(a_i\) normalized to 1, the columns of \(A\) and \(\ket {e_i}\) is an orthonormal basis. Assuming a qRAM (Giovannetti, Lloyd, Maccone, 2008, “Quantum random access memory“) that performs the following:

\[\ket i \ket 0 \ket 0 \rightarrow \ket i\ket {\hat a_i} \ket {|a_i|}\]

one can easily construct the state \(\ket \psi = \sum_i |a_i|\ket {e_i}\ket {\hat a_i}\), whose density matrix is:

\[(\sum_i |a_i|\ket {e_i}\ket {\hat a_i})\otimes (\sum_i |a_i|\bra{e_i}\bra{\hat a_i}) = X\]

So by using \(n=\mathcal O(t^2\epsilon^{-1})\) copies of \(X\) one can implement \(e^{-iXt}\) with accuracy \(\epsilon\) in \(\mathcal O(n\log d)\) time.

Obtaining the Principal Components using self-tomography

Once the exponentiation of the covariance matrix is performed, one can use QPE to find the eigenvectors and eigenvalues of the density matrix using conditional application of:

\[e^{-iXt}\]

for varying times \(t\), using \(\ket \psi\) as the initial state, resulting in the following state:

\[\sum_ir_i\ket{\chi_i}\bra {\chi_i}\ket{\tilde r_i}\bra{\tilde r_i}\]

where \(\ket {\chi_i}\) are the eigenvalues of \(X\) and \(\ket {\tilde r_i}\) are the corresponding eigenvalues.

The extraction of \(i\)-th eigenvalues are then determined by measuring the expectation value of the eigenvector with eigenvalue \(r_i\):

\[\bra{\chi_i}M \ket{\chi_i}\]

This process, called quantum self-tomography, reveals eigenvalues and eigenvectors in time \(\mathcal O(R\log d)\), where \(R\) is the rank of \(X\), resulting in an exponential speedup over classical PCA.

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources:

• Lloyd, Mohseni, Rebentrost, “Quantum principal component analysis”, 2014

• He, Li, Liu, Wang, “A Low Complexity Quantum Principal Component Analysis Algorithm”, 2021

• Nghiem, “New Quantum Algorithm for Principal Component Analysis”, 2025

• Harrow, Hassidim, Lloyd, 2009, “Quantum algorithm for linear systems of equations“

• Giovannetti, Lloyd, Maccone, 2008, “Quantum random access memory“

This blog post explores an alternative to variational quantum models, called post-variational quantum models and in particular post-variational quantum neural networks, a quantum machine learning model based on ensemble strategies which doesn’t rely on a single trainable circuit but on a classical combination of fixed circuits.

Variational Circuits

Variational quantum circuits (see the picture above, coming from [1]) are hybrid methods referring to a large class of circuits operating on pure states and are also known as quantum neural networks when applied to machine learning tasks.

Such circuit operates in the following manner:

• encoding data \(x\) into a n-qubit quantum state \(\rho(x) \in \mathcal M_{2^n\times 2^n}\)

• a parametrized circuit \(U(\theta) \) (also called ansatz) is the applied on the encoded state, with parameters \(\theta \in R^{d}\), resulting in:

$$\rho(x, \theta) = U(\theta)\rho(x)U(\theta)^\dagger$$

• an estimation of the results of such circuits is then constructed with an observable \(O\):

$$E_\theta(x)= tr(O\rho(x, \theta))$$

• the parameters \(\theta\) are optimized using a gradient based optimization relying on the gradient of the variational quantum circuit (typically computed with parameter shift rule).

The main challenges of variational quantum circuits are the following:

• despite some problem inspired ansatze exist, defining problem agnostic ansatze that are expressive enough to represent a useful function but don’t suffer of the barren plateau problem is a challenge and an open research direction

• implementing continuous parameterized rotations on real hardware is limited by the precision of control electronics.

Post-Variational Circuits

Because of the general difficulty and lack of training guarantees provided by variational algorithms, [1] has proposed a new approach, named “post-variational“. This approach (see the picture above, coming from [1]) basically replaces the parametrized quantum circuit of the variational approach with fixed circuits (parametrized only by the input data) and find an optimal combination of such the result of such circuits.

The idea is therefore to combine observable and ansatz in a single parametrized observable:

$$\mathcal D(\theta) = U(\theta)^\dagger OU (\theta)$$

Since any observable can be expressed as a linear combination of Hermitian matrices, one can express the observable \(\mathcal D(\theta)\) as linear combinations:

$$\mathcal D(\theta) = \sum_{i=1}^q a_i(\theta)\mathcal D_i$$

This comes from the fact that \(U(\theta)\) can be written as the product of unitary matrices:

\[U(\theta) = \prod_{i=1}^s U_i(\theta_i)\]

and because of Stone’s theorem, \(U(\theta)\) can be written as:

\[U(\theta) = \prod_{i=1}^s W_ie^{j\theta_iH_i}V_i\]

where \(j\) is the imaginary unit, \(W_i\) and \(V_i\) are fixed matrices and \(H_i\) are Hermitian matrices.

Thanks to the Baker–Campbell–Hausdorff identity one can represent \(U(\theta)\) as:

\[\prod_{i=1}^sV_i^\dagger\left(\sum_{k=0}^\infty \frac{[(j\theta_iH_i)^k, W_i^\dagger O W_i]} {k!} \right)V_i=\prod_{i=1}^s\sum_{k=0}^\infty\frac{\theta_i^k}{k!}V_i^\dagger[(jH_i)^k, W_i^\dagger O W_i]V_i\]

where \([(X)^n, Y) = [X, \dots, [X,[X, Y]]]\). Since \(jH_i\) is anti-Hermitian, \([(j\theta_iH_i)^k, W_i^\dagger O W_i]\) is Hermitian for all \(i\), which allows to rewrite \(U(\theta)\) as a weighted polynomial sum of Hermitian matrices against \(\theta\) which allows the following:

\[\mathcal D(\theta) = U(\theta)^\dagger OU(\theta)\sum_{i=1}^q a_i(\theta)\mathcal D_i\]

Moreover, since any Hermitian operator can be expressed in a basis of Pauli matrices:

\[H \in M_{2\times2}(C)^{\otimes n} \in \text{span}({X; Y; Z; I}^{\otimes n})\]

then \(\mathcal D(\theta)\) pertains to the same space and therefore at most \(4^n\) terms are necessary to express the optimal answer. Therefore, considering that a variational quantum circuit takes \(\mathcal O(poly(s))\)parameters to express the optimal solution, while the post-variational approach takes \(\mathcal O(4^n)\), the variational approach has an advantage, coming from the fact that it is to generate different observables on higher orders of \(\theta\), something that classical computers cannot achieve.

However, in order to get an approximate solution, one can restrict the number of Hermitian terms used in the post-variational approach to \(\mathcal O(poly(s))\), renouncing to some expressibility.

Estimation of the parameters in the post-variational setting

The estimation in the post variational setting is:

\[E_\theta = tr\left(\mathcal D(\theta) \rho(x)\right)= \sum_{i=1}^qa_i(\theta)tr\left(D_i\rho(x)\right)\]

One can consider \(\sum_{i=1}^qa_i(\theta)tr\left(D_i\rho(x)\right)\) as a function \(\mathcal H_\theta:\) \(R^q \rightarrow R\) s.t.:

\[E_\theta = \mathcal H_\theta\left(\left\{tr\left(D_i\rho(x)\right)\right\}_{i=1}^q\right)\]

and exploiting the universal approximation theorem, the function \(\mathcal H_\theta\) can be approximated by a neural network.

Design principles of post-variational quantum circuits

So far the only challenge pertaining to the post-variational design mentioned is the exponential amount of possible circuits. However the post-variational setting has another major challenge: the heuristic choice of fixed circuits and observables. the authors of [1] describe multiple strategies to decide the observables \(\mathcal D_i\).

Ansatz expansion

The first strategy outlined is to replace a problem agnostic parametrized ansatz \(U(\theta)\)coming from a variational quantum circuit with an ensemble of fixed ansatze \(\{U_\alpha\}_{\alpha=1}^p\). The authors use truncated Taylor polynomial expansions of the variational parameters to generate fixed ansatze for the model and use parameter-shift rules to find derivatives of the trace-induced measurements of parameterized quantum circuits.

Therefore the full Taylor expansion of \(U^\dagger(\theta)OU(\theta)\) can be expressed a linear combination of \(U^\dagger(\theta')OU(\theta')\) where \(\theta \in \{0,\pm\frac \pi 2\}^k\). For a truncation of order \(R\), the number of circuit required is:

\[\sum_{j=0}^R{k\choose j}2^j \in \mathcal O(2^Rk^R)\]

which scales fast if a deep ansatz is chosen. To reduce the number of circuits required, one can adopt pruning techniques.

Observable construction

The observable construction strategy decomposes the parametrized observable \(\mathcal D(\theta)\) agains the basis of quantum observables s.t.:

\[\mathcal D(\theta^*)\rightarrow \mathcal D(\alpha)= \sum_{P\in\{X; Y; Z; I\}^{\otimes n}}\alpha_P P\]

The real problem of this strategy is that it scales exponentially with the number of qubits used in the system, therefore an heuristic selection is necessary. Considering all Pauli observables withing a locality \(L\) is considered a good heuristic, being most physical Hamiltonian local as well. If the target observable is \(L\)-local, one can exploit the classical shadows method [2] to reduce the number of measurement required while obtaining the same additive error term. In the case that the observables are the complete set of L-local Paulis, the number of observables required is:

\[\sum_{j=0}^L{n\choose j}3^j \in \mathcal O(3^ln^L)\]

while if the classical shadow method us used, the number of random measurement of the circuit is:

\[\mathcal O(3^LL\log n)\]

Hybrid approach

One might want to use ansatz circuits during the construction of observables, in order to increase the expressivity of the model. A strategy might therefore combine both the ansatz expansion strategy and the observable construction strategy.

The idea is that, instead of directly expanding \(U(\theta)\) in \(\mathcal D(\theta) = U^\dagger (\theta)OU(\theta)\), the ansatz is split into two unitaries:

\[U(\theta)=U_B(\theta)U_A(\theta)\]

and therefore:

\[\mathcal D(\theta) =U_A^\dagger(\theta)U_B^\dagger(\theta)OU_B(\theta)U_A(\theta)\]

Let \(\mathcal D'(\theta) = U^\dagger_B(\theta) OU_B(\theta)\), it can be decomposed into a linear combination of Paulis using the observable construction strategy. On the other hand the remaining Ansatz \(U_A(\theta)\) can be expanded using the ansatz expansion method. Last pruning techniques can be used to reduce the number of circuits.

Numerically comparing Post-Variational and Variational Quantum Neural Network

The following example demonstrates how to employ the post-variational quantum neural network on the classical machine learning task of image classification. The example comes from the Pennylane documentation.

import pennylane as qml
from pennylane import numpy as np
import jax
from jax import numpy as jnp
import optax
from itertools import combinations
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import log_loss
import matplotlib.pyplot as plt
import matplotlib.colors
import warnings
warnings.filterwarnings("ignore")
np.random.seed(42)

# Load the digits dataset with features (X_digits) and labels (y_digits)
X_digits, y_digits = load_digits(return_X_y=True)

# Create a boolean mask to filter out only the samples where the label is 2 or 6
filter_mask = np.isin(y_digits, [2, 6])

# Apply the filter mask to the features and labels to keep only the selected digits
X_digits = X_digits[filter_mask]
y_digits = y_digits[filter_mask]

# Split the filtered dataset into training and testing sets with 10% of data reserved for testing
X_train, X_test, y_train, y_test = train_test_split(
    X_digits, y_digits, test_size=0.1, random_state=42
)

# Normalize the pixel values in the training and testing data
# Convert each image from a 1D array to an 8x8 2D array, normalize pixel values, and scale them
X_train = np.array([thing.reshape([8, 8]) / 16 * 2 * np.pi for thing in X_train])
X_test = np.array([thing.reshape([8, 8]) / 16 * 2 * np.pi for thing in X_test])

# Adjust the labels to be centered around 0 and scaled to be in the range -1 to 1
# The original labels (2 and 6) are mapped to -1 and 1 respectively
y_train = (y_train - 4) / 2
y_test = (y_test - 4) / 2

To visualize some of the digits:

fig, axes = plt.subplots(nrows=2, ncols=3, layout="constrained")
for i in range(2):
    for j in range(3):
      axes[i][j].matshow(X_train[2*(2*j+i)])
      axes[i][j].axis('off')
fig.subplots_adjust(hspace=0.0)
fig.tight_layout()
plt.show()

Now it’s time to train the QML models:

• first will embed our data through a series of rotation gates

• will then have an ansatz of rotation gates with parameters’ weights

def feature_map(features):
    # Apply Hadamard gates to all qubits to create an equal superposition state
    for i in range(len(features[0])):
        qml.Hadamard(i)

    # Apply angle embeddings based on the feature values
    for i in range(len(features)):
        # For odd-indexed features, use Z-rotation in the angle embedding
        if i % 2:
            qml.AngleEmbedding(features=features[i], wires=range(8), rotation="Z")
        # For even-indexed features, use X-rotation in the angle embedding
        else:
            qml.AngleEmbedding(features=features[i], wires=range(8), rotation="X")

# Define the ansatz (quantum circuit ansatz) for parameterized quantum operations
def ansatz(params):
    # Apply RY rotations with the first set of parameters
    for i in range(8):
        qml.RY(params[i], wires=i)

    # Apply CNOT gates with adjacent qubits (cyclically connected) to create entanglement
    for i in range(8):
        qml.CNOT(wires=[(i - 1) % 8, (i) % 8])

    # Apply RY rotations with the second set of parameters
    for i in range(8):
        qml.RY(params[i + 8], wires=i)

    # Apply CNOT gates with qubits in reverse order (cyclically connected)
    # to create additional entanglement
    for i in range(8):
        qml.CNOT(wires=[(8 - 2 - i) % 8, (8 - i - 1) % 8])

We first test the performance of a shallow variational algorithm on the digits dataset:

dev = qml.device("default.qubit", wires=8)


@qml.qnode(dev)
def circuit(params, features):
    feature_map(features)
    ansatz(params)
    return qml.expval(qml.PauliZ(0))


def variational_classifier(weights, bias, x):
    return circuit(weights, x) + bias


def square_loss(labels, predictions):
    return np.mean((labels - qml.math.stack(predictions)) ** 2)


def accuracy(labels, predictions):
    acc = sum([np.sign(l) == np.sign(p) for l, p in zip(labels, predictions)])
    acc = acc / len(labels)
    return acc


def cost(params, X, Y):
    predictions = [variational_classifier(params["weights"], params["bias"], x) for x in X]
    return square_loss(Y, predictions)


def acc(params, X, Y):
    predictions = [variational_classifier(params["weights"], params["bias"], x) for x in X]
    return accuracy(Y, predictions)


np.random.seed(0)
weights = 0.01 * np.random.randn(16)
bias = jnp.array(0.0)
params = {"weights": weights, "bias": bias}
opt = optax.adam(0.05)
batch_size = 7
num_batch = X_train.shape[0] // batch_size
opt_state = opt.init(params)
X_batched = X_train.reshape([-1, batch_size, 8, 8])
y_batched = y_train.reshape([-1, batch_size])


@jax.jit
def update_step_jit(i, args):
    params, opt_state, data, targets, batch_no = args
    _data = data[batch_no % num_batch]
    _targets = targets[batch_no % num_batch]
    _, grads = jax.value_and_grad(cost)(params, _data, _targets)
    updates, opt_state = opt.update(grads, opt_state)
    params = optax.apply_updates(params, updates)
    return (params, opt_state, data, targets, batch_no + 1)


@jax.jit
def optimization_jit(params, data, targets):
    opt_state = opt.init(params)
    args = (params, opt_state, data, targets, 0)
    (params, opt_state, _, _, _) = jax.lax.fori_loop(0, 200, update_step_jit, args)
    return params


params = optimization_jit(params, X_batched, y_batched)
var_train_acc = acc(params, X_train, y_train)
var_test_acc = acc(params, X_test, y_test)

print("Training accuracy: ", var_train_acc)
print("Testing accuracy: ", var_test_acc)

# Training accuracy:  0.7484472049689441
# Testing accuracy:  0.6944444444444444

The observable construction heuristic:

def local_pauli_group(qubits: int, locality: int):
    assert locality <= qubits, f"Locality must not exceed the number of qubits."
    return list(generate_paulis(0, 0, "", qubits, locality))

# This is a recursive generator function that constructs Pauli strings.
def generate_paulis(identities: int, paulis: int, output: str, qubits: int, locality: int):
    # Base case: if the output string's length matches the number of qubits, yield it.
    if len(output) == qubits:
        yield output
    else:
        # Recursive case: add an "I" (identity) to the output string.
        yield from generate_paulis(identities + 1, paulis, output + "I", qubits, locality)

        # If the number of Pauli operators used is less than the locality, add "X", "Y", or "Z"
        # systematically builds all possible Pauli strings that conform to the specified locality.
        if paulis < locality:
            yield from generate_paulis(identities, paulis + 1, output + "X", qubits, locality)
            yield from generate_paulis(identities, paulis + 1, output + "Y", qubits, locality)
            yield from generate_paulis(identities, paulis + 1, output + "Z", qubits, locality)

For each image sample, we measure the output of the quantum circuit using the \(k\)-local observables sequence, and perform logistic regression on these outputs:

# Initialize lists to store training and testing accuracies for different localities.
train_accuracies_O = []
test_accuracies_O = []

for locality in range(1, 4):
    print(str(locality) + "-local: ")

    # Define a quantum device with 8 qubits using the default simulator.
    dev = qml.device("default.qubit", wires=8)

    # Define a quantum node (qnode) with the quantum circuit that will be executed on the device.
    @qml.qnode(dev)
    def circuit(features):
        # Generate all possible Pauli strings for the given locality.
        measurements = local_pauli_group(8, locality)

        # Apply the feature map to encode classical data into quantum states.
        feature_map(features)

        # Measure the expectation values of the generated Pauli operators.
        return [qml.expval(qml.pauli.string_to_pauli_word(measurement)) for measurement in measurements]

    # Vectorize the quantum circuit function to apply it to multiple data points in parallel.
    vcircuit = jax.vmap(circuit)

    # Transform the training and testing datasets by applying the quantum circuit.
    new_X_train = np.asarray(vcircuit(jnp.array(X_train))).T
    new_X_test = np.asarray(vcircuit(jnp.array(X_test))).T

    # Train a Multilayer Perceptron (MLP) classifier on the transformed training data.
    clf = MLPClassifier(early_stopping=True).fit(new_X_train, y_train)

    # Print the log loss for the training data.
    print("Training loss: ", log_loss(y_train, clf.predict_proba(new_X_train)))

    # Print the log loss for the testing data.
    print("Testing loss: ", log_loss(y_test, clf.predict_proba(new_X_test)))

    # Calculate and store the training accuracy.
    acc = clf.score(new_X_train, y_train)
    train_accuracies_O.append(acc)
    print("Training accuracy: ", acc)

    # Calculate and store the testing accuracy.
    acc = clf.score(new_X_test, y_test)
    test_accuracies_O.append(acc)
    print("Testing accuracy: ", acc)
    print()

locality = ("1-local", "2-local", "3-local")
train_accuracies_O = [round(value, 2) for value in train_accuracies_O]
test_accuracies_O = [round(value, 2) for value in test_accuracies_O]
x = np.arange(3)
width = 0.25

# Create a bar plot to visualize the training and testing accuracies.
fig, ax = plt.subplots(layout="constrained")
# Training accuracy bars:
rects = ax.bar(x, train_accuracies_O, width, label="Training", color="#FF87EB")
# Testing accuracy bars:
rects = ax.bar(x + width, test_accuracies_O, width, label="Testing", color="#70CEFF")
ax.bar_label(rects, padding=3)
ax.set_xlabel("Locality")
ax.set_ylabel("Accuracy")
ax.set_title("Accuracy of different localities")
ax.set_xticks(x + width / 2, locality)
ax.legend(loc="upper left")
plt.show()

1-local:
Training loss:  0.4592314401681531
Testing loss:  0.5045886276497531
Training accuracy:  0.8074534161490683
Testing accuracy:  0.7222222222222222

2-local:
Training loss:  0.43242776810519556
Testing loss:  0.5718358099121
Training accuracy:  0.860248447204969
Testing accuracy:  0.7222222222222222

3-local:
Training loss:  0.42526261814808347
Testing loss:  0.574942133390183
Training accuracy:  0.9316770186335404
Testing accuracy:  0.75

The ansatz expansion approach:

def deriv_params(thetas: int, order: int):
    # This function generates parameter shift values for calculating derivatives
    # of a quantum circuit.
    # 'thetas' is the number of parameters in the circuit.
    # 'order' determines the order of the derivative to calculate (1st order, 2nd order, etc.).

    def generate_shifts(thetas: int, order: int):
        # Generate all possible combinations of parameters to shift for the given order.
        shift_pos = list(combinations(np.arange(thetas), order))

        # Initialize a 3D array to hold the shift values.
        # Shape: (number of combinations, 2^order, thetas)
        params = np.zeros((len(shift_pos), 2 ** order, thetas))

        # Iterate over each combination of parameter shifts.
        for i in range(len(shift_pos)):
            # Iterate over each possible binary shift pattern for the given order.
            for j in range(2 ** order):
                # Convert the index j to a binary string of length 'order'.
                for k, l in enumerate(f"{j:0{order}b}"):
                    # For each bit in the binary string:
                    if int(l) > 0:
                        # If the bit is 1, increment the corresponding parameter.
                        params[i][j][shift_pos[i][k]] += 1
                    else:
                        # If the bit is 0, decrement the corresponding parameter.
                        params[i][j][shift_pos[i][k]] -= 1

        # Reshape the parameters array to collapse the first two dimensions.
        params = np.reshape(params, (-1, thetas))
        return params

    # Start with a list containing a zero-shift array for all parameters.
    param_list = [np.zeros((1, thetas))]

    # Append the generated shift values for each order from 1 to the given order.
    for i in range(1, order + 1):
        param_list.append(generate_shifts(thetas, i))

    # Concatenate all the shift arrays along the first axis to create the final parameter array.
    params = np.concatenate(param_list, axis=0)

    # Scale the shift values by π/2.
    params *= np.pi / 2

    return params

n_wires = 8
dev = qml.device("default.qubit", wires=n_wires)

@jax.jit
@qml.qnode(dev, interface="jax")
def circuit(features, params, n_wires=8):
    feature_map(features)
    ansatz(params)
    return qml.expval(qml.PauliZ(0))

For each image sample, measure the outputs of each parameterised circuit for each feature, and feed the outputs into a multilayer perceptron:

# Initialize lists to store training and testing accuracies for different derivative orders.
train_accuracies_AE = []
test_accuracies_AE = []

# Loop through different derivative orders (1st order, 2nd order, 3rd order).
for order in range(1, 4):
    print("Order number: " + str(order))

    # Generate the parameter shifts required for the given derivative order.
    to_measure = deriv_params(16, order)

    # Transform the training dataset by applying the quantum circuit with the
    # generated parameter shifts.
    new_X_train = []
    for thing in X_train:
        result = circuit(thing, to_measure.T)
        new_X_train.append(result)

    # Transform the testing dataset similarly.
    new_X_test = []
    for thing in X_test:
        result = circuit(thing, to_measure.T)
        new_X_test.append(result)

    # Train a Multilayer Perceptron (MLP) classifier on the transformed training data.
    clf = MLPClassifier(early_stopping=True).fit(new_X_train, y_train)

    # Print the log loss for the training data.
    print("Training loss: ", log_loss(y_train, clf.predict_proba(new_X_train)))

    # Print the log loss for the testing data.
    print("Testing loss: ", log_loss(y_test, clf.predict_proba(new_X_test)))

    # Calculate and store the training accuracy.
    acc = clf.score(new_X_train, y_train)
    train_accuracies_AE.append(acc)
    print("Training accuracy: ", acc)

    # Calculate and store the testing accuracy.
    acc = clf.score(new_X_test, y_test)
    test_accuracies_AE.append(acc)
    print("Testing accuracy: ", acc)
    print()

locality = ("1-order", "2-order", "3-order")
train_accuracies_AE = [round(value, 2) for value in train_accuracies_AE]
test_accuracies_AE = [round(value, 2) for value in test_accuracies_AE]
x = np.arange(3)
width = 0.25
fig, ax = plt.subplots(layout="constrained")
rects = ax.bar(x, train_accuracies_AE, width, label="Training", color="#FF87EB")
ax.bar_label(rects, padding=3)
rects = ax.bar(x + width, test_accuracies_AE, width, label="Testing", color="#70CEFF")
ax.bar_label(rects, padding=3)
ax.set_xlabel("Order")
ax.set_ylabel("Accuracy")
ax.set_title("Accuracy of different derivative orders")
ax.set_xticks(x + width / 2, locality)
ax.legend(loc="upper left")
plt.show()

Order number: 1
Training loss:  0.6917395840118673
Testing loss:  0.6898366117810784
Training accuracy:  0.5093167701863354
Testing accuracy:  0.5555555555555556

Order number: 2
Training loss:  0.6326009058014004
Testing loss:  0.6157803899808801
Training accuracy:  0.7018633540372671
Testing accuracy:  0.6666666666666666

Order number: 3
Training loss:  0.5815839249054562
Testing loss:  0.6016181640099203
Training accuracy:  0.7142857142857143
Testing accuracy:  0.6944444444444444

Regarding the hybrid strategy:

# Initialize matrices to store training and testing accuracies for different
# combinations of locality and order.
train_accuracies = np.zeros([4, 4])
test_accuracies = np.zeros([4, 4])

# Loop through different derivative orders (1st to 3rd) and localities (1-local to 3-local).
for order in range(1, 4):
    for locality in range(1, 4):
        # Skip invalid combinations where locality + order exceeds 3 or equals 0.
        if locality + order > 3 or locality + order == 0:
            continue
        print("Locality: " + str(locality) + " Order: " + str(order))

        # Define a quantum device with 8 qubits using the default simulator.
        dev = qml.device("default.qubit", wires=8)

        # Generate the parameter shifts required for the given derivative order and transpose them.
        params = deriv_params(16, order).T

        # Define a quantum node (qnode) with the quantum circuit that will be executed on the device.
        @qml.qnode(dev)
        def circuit(features, params):
            # Generate the Pauli group for the given locality.
            measurements = local_pauli_group(8, locality)
            feature_map(features)
            ansatz(params)
            # Measure the expectation values of the generated Pauli operators.
            return [qml.expval(qml.pauli.string_to_pauli_word(measurement)) for measurement in measurements]

        # Vectorize the quantum circuit function to apply it to multiple data points in parallel.
        vcircuit = jax.vmap(circuit)

        # Transform the training dataset by applying the quantum circuit with the
        # generated parameter shifts.
        new_X_train = np.asarray(
            vcircuit(jnp.array(X_train), jnp.array([params for i in range(len(X_train))]))
        )
        # Reorder the axes and reshape the transformed data for input into the classifier.
        new_X_train = np.moveaxis(new_X_train, 0, -1).reshape(
            -1, len(local_pauli_group(8, locality)) * len(deriv_params(16, order))
        )

        # Transform the testing dataset similarly.
        new_X_test = np.asarray(
            vcircuit(jnp.array(X_test), jnp.array([params for i in range(len(X_test))]))
        )
        # Reorder the axes and reshape the transformed data for input into the classifier.
        new_X_test = np.moveaxis(new_X_test, 0, -1).reshape(
            -1, len(local_pauli_group(8, locality)) * len(deriv_params(16, order))
        )

        # Train a Multilayer Perceptron (MLP) classifier on the transformed training data.
        clf = MLPClassifier(early_stopping=True).fit(new_X_train, y_train)

        # Calculate and store the training and testing accuracies.
        train_accuracies[order][locality] = clf.score(new_X_train, y_train)
        test_accuracies[order][locality] = clf.score(new_X_test, y_test)

        print("Training loss: ", log_loss(y_train, clf.predict_proba(new_X_train)))
        print("Testing loss: ", log_loss(y_test, clf.predict_proba(new_X_test)))
        acc = clf.score(new_X_train, y_train)
        train_accuracies[locality][order] = acc
        print("Training accuracy: ", acc)
        acc = clf.score(new_X_test, y_test)
        test_accuracies[locality][order] = acc
        print("Testing accuracy: ", acc)
        print()

# Locality: 1 Order: 1
# Training loss:  0.29433122335335293
# Testing loss:  0.48158001426002656
# Training accuracy:  0.8944099378881988
# Testing accuracy:  0.7777777777777778

# Locality: 2 Order: 1
# Training loss:  0.32784353109905134
# Testing loss:  0.571967578071357
# Training accuracy:  0.8664596273291926
# Testing accuracy:  0.75

# Locality: 1 Order: 2
# Training loss:  0.20260000718215349
# Testing loss:  0.5550612230165831
# Training accuracy:  0.9409937888198758
# Testing accuracy:  0.75

Plotting all the post-variational strategies together:

for locality in range(1, 4):
    train_accuracies[locality][0] = train_accuracies_O[locality - 1]
    test_accuracies[locality][0] = test_accuracies_O[locality - 1]
for order in range(1, 4):
    train_accuracies[0][order] = train_accuracies_AE[order - 1]
    test_accuracies[0][order] = test_accuracies_AE[order - 1]

train_accuracies[3][3] = var_train_acc
test_accuracies[3][3] = var_test_acc

cvals = [0, 0.5, 0.85, 0.95, 1]
colors = ["black", "#C756B2", "#FF87EB", "#ACE3FF", "#D5F0FD"]
norm = plt.Normalize(min(cvals), max(cvals))
tuples = list(zip(map(norm, cvals), colors))
cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", tuples)


locality = ["top qubit\n Pauli-Z", "1-local", "2-local", "3-local"]
order = ["0th Order", "1st Order", "2nd Order", "3rd Order"]

fig, axes = plt.subplots(nrows=1, ncols=2, layout="constrained")
im = axes[0].imshow(train_accuracies, cmap=cmap, origin="lower")

axes[0].set_yticks(np.arange(len(locality)), labels=locality)
axes[0].set_xticks(np.arange(len(order)), labels=order)
plt.setp(axes[0].get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
for i in range(len(locality)):
    for j in range(len(order)):
        text = axes[0].text(
            j, i, np.round(train_accuracies[i, j], 2), ha="center", va="center", color="black"
        )
axes[0].text(3, 3, '\n\n(VQA)', ha="center", va="center", color="black")

axes[0].set_title("Training Accuracies")

locality = ["top qubit\n Pauli-Z", "1-local", "2-local", "3-local"]
order = ["0th Order", "1st Order", "2nd Order", "3rd Order"]

im = axes[1].imshow(test_accuracies, cmap=cmap, origin="lower")

axes[1].set_yticks(np.arange(len(locality)), labels=locality)
axes[1].set_xticks(np.arange(len(order)), labels=order)
plt.setp(axes[1].get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
for i in range(len(locality)):
    for j in range(len(order)):
        text = axes[1].text(
            j, i, np.round(test_accuracies[i, j], 2), ha="center", va="center", color="black"
        )
axes[1].text(3, 3, '\n\n(VQA)', ha="center", va="center", color="black")

axes[1].set_title("Test Accuracies")
fig.tight_layout()
plt.show()

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources:

1. https://arxiv.org/pdf/2307.10560

2. https://www.nature.com/articles/s41567-020-0932-7

3. https://www.nature.com/articles/s41467-018-07090-4

4. https://arxiv.org/pdf/2009.11001

5. https://journals.aps.org/pra/abstract/10.1103/PhysRevA.104.042418

6. https://journals.aps.org/pra/abstract/10.1103/PhysRevA.105.052445

7. https://iopscience.iop.org/article/10.1088/1367-2630/ac325f

For this reason, researchers developed a whole new family of methods which can directly learn the trajectory of the family of equations from the data, resulting in faster approximation of the solution of such PDEs.

This post discusses a specific data-driven approach to approximate parametric PDEs using a specific neural architecture called Fourier Neural Operator (FNO) and concludes presenting a quantum-enhanced version of the FNO.

Learning Neural Operators

To properly understand Fourier Neural Operator, a brief introduction to neural operators is necessary. The idea underlying neural operators is to learn mesh-free, infinite dimensional operators with neural networks which is able to transfer solution between different meshes, doesn’t need to be trained for each parameter and doesn’t require any aprioristic knowledge of the PDE.

Let \(D\) be a bounded domain in \(R^d\) and let \(U(D, R^{d_u})\) and \(\Lambda(D, R^{d_\lambda})\) be two separable Banach spaces of function where \(R^{d_u}\) and \(R^{d_\lambda}\) are the codomains.

Assume the PDE one wish to solve is:

$$\mathcal L(u, x, \lambda) = 0$$

where:

• \(\mathcal L\) is the differential operator

• \(u \in U\) is the solution function

• \(x\) is is the spatial-temporal variable

• \(\lambda \in \Lambda\) is the function parametrizing the PDE

Moreover let \(G^\dagger: \Lambda \rightarrow U\) be a map which arise as the solution operators of parametric PDEs. Also let \(\{\lambda_j, u_j\}^n_{j=1}\) be observations (potentially noisy) s.t.

$$G^\dagger(\lambda_j) = u_j$$

The goal of the neural operator is to approximate \(G^\dagger\) with

$$G_\theta: \Lambda \times \Theta \rightarrow U$$

where \(\Theta\) is a finite-dimensional space.

Similarly to a finite-dimensional setting, one can now define a cost function

$$C : U \times U\rightarrow R$$

and seek a minimizer of the problem s.a.:

$$\text{min}{\theta \in \Theta}E\lambda\left( C\left(G_\theta\left(\lambda\right), G^\dagger\left(\lambda\right)\right)\right)$$

Of course, learning a neural operators is therefore much different than learning the solution to a PDE with a fixed parameter \(\lambda\). The large majority of methods to approximate PDEs (including traditional methods and machine learning approaches) would therefore reveal impractical if the solution of the PDE is required for different instances of the parameter \(\lambda\), that’s where neural operator’s approach offers a computational advantage.

Moreover, to work numerically with the data \(\{\lambda_j, u_j\}^n_{j=1}\), since both \(\lambda_j\) and \(u_j\) are in general functions, we assume to have access to point-wise evaluations of the two functions. Therefore, let \(D_j = \{x_1, \dots, x_n\}\) be a n-point discretization of the domain \(D\) and assume one have access to point-wise evaluations of the functions \(\lambda_j\) and \(u_j\) over \(D_j\).

Defining the Neural Operator

As proposed in [Li], the neural operator is an iterative architecture which updates the function \(v_j: D \rightarrow R^{d_v}\). The idea is to:

• represent the input \(\lambda \in \Lambda\) in a higher dimensional representation with the local transformation \(P\):

$$v_0(x) = P(\lambda(x))$$

• then the function \(v_j\) is updated as follows:

$$v_{t+1}(x):=\sigma\left(W v_t(x)+\left(\mathcal{K}(\lambda , \theta) v_t\right)(x)\right), \quad \forall x \in D$$

where:

• \(\sigma\) is a non-linear activation function

• \(W: R^{d_v} \rightarrow R^{d_v}\) is the bias term applied on the spatial domain

• \(K: \Lambda \times \Theta_k \rightarrow \mathcal L\left(U\left(D, R^{d_v} \right), U\left(D, R^{d_v} \right)\right)\) is the kernel integral transformation and is parametrized by \(\theta \in \Theta_k\)

The kernel integral transformation moreover is the following:

$$\left(\mathcal{K}(\lambda , \theta) v_t\right)(x):=\int_D \kappa(x, y, \lambda(x), \lambda(y) , \theta) v_t(y) \mathrm{d} y, \quad \forall x \in D$$

where \(k\) is a neural network parametrized by \(\theta \in \Theta_k\) and represent the kernel function. It’s worth noticing that while the kernel function is linear the operator can learn non-linear operators thanks to the non-linear activation functions, analogously to standard neural networks.

Defining the Fourier Neural Operator

Let \(\mathcal F\) be the Fourier transform of a function \(f: D \rightarrow R^{d_v}\) and let \(\mathcal F^{-1}\) be the inverse of the Fourier transform. By imposing (i.e. making \(k\) a convolutional operator):

$$k(x,y,\lambda(x), \lambda(y), \theta) = k(x-y, \theta)$$

the kernel integral transformation becomes:

$$\left(\mathcal{K}(\lambda, \theta) v_t\right)(x)=\mathcal{F}^{-1}\left(\mathcal{F}\left(\kappa_\theta\right) \cdot \mathcal{F}\left(v_t\right)\right)(x), \quad \forall x \in D$$

and if the parametrization \(k_\theta\) happens directly in Fourier space:

$$\left(\mathcal{K}(\lambda, \theta) v_t\right)(x)=\mathcal{F}^{-1}\left(R_\theta \cdot \mathcal{F}\left(v_t\right)\right)(x), \quad \forall x \in D$$

as shown in the following picture (taken from [3]):

If we enforce that \(k_\theta\) is periodic, it admits a Fourier series expansion, which can be truncated at a maximum number of modes \(m_{\text{max}}\) and therefore \(R_\theta\) can be parametrized with a (\((m_{\text{max}} \times d_v \times d_v)\)-tensor.

Furthermore, once \(D \) is discretized in \(n\) points, \(v_t \in R^{n\times d_v}\). Moreover, since \(v_t\) convolves with a function with only \(m_{\text{max}}\) modes, we can truncate the the highest modes in order to have \(F(v_t) \in C^{m_{\text max} \times d_v}\).

Therefore, the multiplication for the weight tensor \(R_\theta \in C^{m_{\text{max}} \times d_v \times d_v}\) is:

$$R\cdot(\mathcal F v_t)_{m, l} = \sum_{j=1}^{d_v}R_{m, l, j}(Fv_t)_{m, j} \quad m=1,\dots, m_\text{max}, \quad j = 1, \dots, d_v$$

Invariance to discretization

It’s worth noticing that the Fourier layers are discretization-invariants since they learn from and evaluate functions which are discretized in an arbitrary way, which allows zero-shot super-resolution.

Accelerating the Fourier Neural Operator: Quantum Fourier Operator

Since the weight tensor contains \(m_{\text{max}}< n\) modes and since the complexity of inner product is \(O(m_\text{max})\), the most relevant source of computations comes from the Fourier transform and its inverse. Fourier transform complexity is in fact \(O(n^2)\) in general, but since the model deals with truncated series, the complexity is actually \(O(nm_{\text{max}})\). Therefore, substituting the Fourier transform with the fast Fourier transform (FFT), assuming a uniform discretization, can provide a speedup, being the complexity of FFT \(O(n \log n)\).

Another direction is exploit a quantum-enhanced method based on Quantum Fourier Transform to have more efficient Fourier layers.

Data encoding in the unary basis

The idea underlying Quantum Fourier Operator (QFO) is to substitute the Fourier layers defined above with a new layer exploiting quantum algorithms. Of course to make this possible the matrix \(P(\lambda(x))\) (which I’ll refer to s \(A\) from now on) has to be encoded in a quantum state to serve as the input of the new Fourier layer. The idea is to encode the data according to amplitude-encoded states, choosing as basis \(\ket {e_i}\) the quantum states with a Hamming state of 1:

$$\ket {e_i} = \ket {0\dots010\dots0}$$

Therefore given a generic \(R^{n\times m} \) matrix \(M\), it’s quantum encoding is:

$$\ket{M}=\frac 1{|M|}\sum_{i=1}^n \sum_{j=1}^m a_{i,j} \ket{e_i}\ket{e_j }$$

the circuit to load such state was developed in [7] and assuming an ideal connectivity, the circuit has depth \(O(\log(m) + 2m \log(n))\).

Unary QFT

Inspired by the butterfly-shaped diagram of the FFT, one can define a unitary matrix which performs the quantum analogue of the FFT on the unitary basis whose matrix is:

$$F_n=\frac 1 {\sqrt n}\left(\begin{array}{ccccc}1 & 1 & 1 & \cdots & 1 \\ 1 & \omega & \omega^2 & \cdots & \omega^{(n-1)} \\ 1 & \omega^2 & \omega^4 & \cdots & \omega^{2(n-1)} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & \omega^{n-1} & \omega^{2 n-2} & \cdots & \omega^{(n-1)^2}\end{array}\right)$$

where \(\omega^k = e^{i\frac{2\pi k}{n}}\).

Such transformation can be implemented using phase gates and RBS gates as shown in the following picture (picture from [1]) and the depth of the resulting circuit is \(O(\log n)\):

Trainable linear transform with Quantum Orthogonal Layers

It’s now necessary to define the quantum analogue of the learnable part of the classical Fourier layer and to perform some matrix multiplication. Quantum Orthogonal Layers (from [8]) are therefore a natural choice, being parametrized and hamming-weight preserving transformations (which is a characteristics necessary to preserve since the Inverse Unitary Fourier Transform only works on the unitary basis). Several circuits in this setting exists, the butterfly circuit (which has the same layout as the one used for the Unary-QFT and that is represented in the following picture) is chosen, having \(O(n\log n) \) parametrized gates, where \(n \) is the dimension of the input vector.

Quantum Fourier Layer

Based on the above building blocks, one can define 3 quantum circuits to substitute the classical Fourier layer:

• the sequential circuit

• the parallel circuit

• the composite circuit

The goal of all those circuit is to reproduce the result of the classical Fourier layer, which in quantum formalism is (assuming the input matrix \(A\) was normalized):

$$\ket y = \sum_i \ket{y_i}\ket{e_i} = \sum_i \sum_j y_{i j}\ket{e_i}\ket{e_j}$$

where:

$$y_{i,j} = IFT\left(\left[ w_{il}m_{il}, m_{ik}\right]\right)_j$$

with:

• \(w\) being an element of \(W\)

• \(m\) being an element of \(A\)

The sequential Quantum Fourier Layer

The sequential circuit starts by encoding the input matrix \(A\), resulting in:

$$\ket{\psi_0}= \sum_i \sum_j a_{ij}\ket{e_i}\ket{e_j }$$

Then to \(\ket{\psi_0}\) the Unary-QFT is applied on the second register:

$$\ket{\psi_1}= \sum_i \ket{e_i}\text{QFT}(\sum_j a_{ij}\ket{e_j }) =\sum_i \ket{e_i}(\sum_j \hat a_{ij}\ket{e_j })$$

where \(\hat a_{ij}\) is the row-wise Fourier transfor of \(A\).

After that, the trainable linear transform with quantum orthogonal layers made by \(K\) matrix multiplications has to be defined. Using the circuit depicted above (the butterfly circuit), in this sequential approach, the \(K\) parametrized quantum circuit \(P_1, \dots, P_k\) are applied sequentially on the first register.

After this the I-QFT is applied, resulting in the desired state.

The parallel Quantum Fourier Layer

For the sequential QFL, the depth complexity of the learnable part is linear in the number of modes, which might eventually hinder learning, because of the multiplicative noise model for NISQ machines. To reduce the depth complexity and to make the algorithm more noise-resistant, an interesting modification requires to parallelise the butterfly circuits.

The composite Quantum Fourier Layer

However the parallelized quantum circuit discussed in the above section requires \(K\times (d_v + n)\) independent qubits where \(K \) is the number of modes, which might end up being more than the available qubit resources.

However, one can replace the \(K\) parametrized circuits with a single parametrized circuit \(B\), as long as this new subcircuit is hamming-weight preserving and is built as:

$$B = \bigotimes_i B_i$$

where \(B_i\) correspond to the block diagonal unitary for subspace with hamming weigh \(i\).

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources:

1. https://arxiv.org/pdf/2306.15415

2. https://arxiv.org/pdf/2108.08481

3. https://arxiv.org/pdf/2010.08895

4. https://arxiv.org/pdf/1910.03193

5. https://arxiv.org/pdf/2005.03180

6. https://arxiv.org/pdf/2009.11992

7. https://arxiv.org/pdf/2012.04145

8. https://arxiv.org/pdf/2212.07389

In this blog post, I will explore one of the most famous quantum algorithms (called HHL) that offer a potential speedup in solving linear systems. I will delve into its complexity, underlying assumptions and describe two interesting applications.

Quantum linear system problem versus linear system problem

In order to better understand the limitations of quantum algorithms like HHL, it’s essential to distinguish between a Quantum Linear System Problem (QLSP) and a classical Linear System Problem (LSP).

A typical linear system problem (LSP) is represented as:

$$Ax=b$$

where:

• \(A\) is a matrix

• \(b\) is a known vector

• \(x\) is the unknown vector we aim to solve for

On the other hand, a QLSP deals with a quantum state version of the same concept, represented as:

$$A\ket x = \ket b$$

where:

• \(A\) is still a matrix

• \(\ket b\) is a known quantum state

• \(\ket x\) is the unknown quantum state we wish to find

Although both problems appear similar, the difference lies in how the information is represented and manipulated. In a classical system, the vector \(b\) is readily available, and solving for \(x\) gives a concrete solution that can be directly used. In contrast, in the quantum setting, \(\ket b\) is a quantum state, and the solution \(\ket x\) is also a quantum state. The main challenge here is that quantum states aren’t directly accessible (any measurement of \(\ket x\) collapses the state and only provides a probabilistic result), which means that extracting useful information from the quantum solution requires multiple measurements or sophisticated post-processing.

Understanding these differences is crucial when assessing the complexity and feasibility of quantum solvers such as HHL, particularly when applied to real-world problems where error correction and measurement limitations play a significant role.

HHL

In this section, we introduce the Harrow-Hassidim-Lloyd (HHL) algorithm, one of the most interesting applications of the quantum phase estimation algorithm, which can be used to “solve” sparse linear linear systems, i.e. a system involving a matrix in which most of the elements are zero.

$$HHL: \ket b \rightarrow \ket {A^{-1}b}$$

In the next section the following assumptions will be true:

• \(A\) is a sparse and Hermitian matrix

• the quantum state \(\ket b\) doesn’t have to be implemented from \(b\)

• the problem requires to find \(\ket x\) instead of \(x\)

and the next section deal with:

• the Quantum Phase Estimation algorithm

• the workflow of HHL

• complexity analysis of the HHL algorithm

• what happens to the quantum advantage when the above assumptions fail to hold

• a brief discussion of a couple of noteworthy applications of HHL

Please also note that many versions of the HHL algorithms have been proposed and this post only describe and deals with its simplest version.

Background: Quantum Phase Estimation

One of the most useful quantum subroutines, called Quantum Phase Estimation, aims to estimate the phase \(\phi\) of an eigenvalue \(e^{2i\pi\phi}\) of the corresponding eigenvector \(\ket \psi\)of a unitary operator \(U\).

The QPE algorithm, depicted in the circuit above, shares similarities with Shor’s algorithm because Shor's algorithm can be seen as a specific application of QPE for integer factorization and the goal of QPE is to encode an estimation of the phase \(\phi\) into a binary representation like:

$$\phi = 0.\phi_1\phi_2\dots\phi_{n-1}\phi_n$$

QPE archive the result by phase encoding the binary representation of \(\phi\) using controlled \(U\) gates in order to get the following state:

$$\left(\bigotimes_{j=1}^n \frac 1{\sqrt 2}(\ket 0 + e^{2i\pi0.\phi_j\dots \phi_n}\ket 1)\right) \otimes \ket\psi$$

and then applying the inverse of the Quantum Fourier Transform to go from the phase space to the state space and, before measuring, the result is:

$$\left(\bigotimes_{j=1}^n \ket {\phi_j}\right) \otimes \ket\psi = \ket {\hat \phi} \otimes \ket \psi$$

where \(\hat \phi\) is the estimation of \(\phi\).

HHL workflow

The above picture depicts the circuit of the HHL algorithm. One may notice that the algorithm can be broken down into 3 parts mainly:

• a QPE

• a controlled rotation

• an inverse QFE

Assuming the input state \(\ket b\) is already prepared, the first block is used to find the phase of \(\{\lambda_i\}\) the eigenvalues of the matrix \(U = e^{i tA}\), and the approximated result is stored in the middle register.

At the end of the QPE, what we have is:

$$\ket 0 \otimes\left(\sum_i a_i \ket {u_i} \otimes \ket{\hat\lambda_i}\right)$$

where \(\sum_i a_i\ket {u_i}\) is \(\ket b\) expressed in terms of \(\ket {u_i}\), the eigenvalues of \(U\) and \(\hat \lambda_i\) is the binary approximation of the phase of \(U\).

Then a controlled rotation gate is applied, which corresponds to the following transformation:

$$\ket 0 \otimes\left( \sum_i a_i \ket {u_i} \otimes \ket{\hat\lambda_i}\right) \rightarrow \left(\sqrt{1-\left(\frac c\lambda\right)^2}\ket 0 + \frac c\lambda \ket 1\right)\otimes\left(\sum_i a_i \ket {u_i} \otimes \ket{\hat\lambda_i}\right)$$

where \(c\) is a normalization constant.

The last block, the inverse QPE, is used to go from the state above to:

$$\ket q\otimes\left(\sum_i a_i \ket {u_i} \otimes \ket{\hat\lambda_i}\right) \rightarrow \ket q \otimes\left(\sum_i a_i \ket {u_i}\right)\otimes \ket{0}$$

where \(\ket q \equiv \left(\sqrt{1-\left(\frac c\lambda\right)^2}\ket 0 + \frac c\lambda \ket 1\right)\).

Notably, if the fist qubit (the top register) is measured we have two cases:

• if \(\ket q\) collapses into 1: once the middle register is measure as well, the result is:

$$∝\sum_i a_i \ket u_i \otimes \frac c{\lambda_i}$$

which is proportional to \(\ket {A^{-1}b}\) because of the spectral decomposition of \(A\).

In fact \(A = \sum_i \lambda_i u_iu_i^\dagger\) and (by the properties of spectral decomposition) \(A^{-1} = \sum_i \lambda_i^{-1} u_iu_i^\dagger\) hence \(A^{-1}b = \sum_i a_i \lambda_i^{-1} u_i\) being \(u_i^\dagger u_i =1\) (for the properties of quantum states).

• if \(\ket q\) collapses into 0, one may run again the program

Complexity analysis

Let:

• \(k \) the conditional number (ratio of the largest and smallest absolute values of eigenvalues of \(A\))

• \(\epsilon \) the error from the output state \(\ket {A^{-1}b}\)

• \(s\) the maximum number of non-zero elements in each row of the matrix \(A\)

• \(N\) the size of the matrix

In fact, simulating \(e^{-iAt}\), if \(A\) is \(s\)-sparse, can be done with error \(\epsilon\) in \(O(\log(N)s^2t\epsilon^{-1})\), which is required in the QPE process. One may then perform O(k) Quantum Amplitude Amplification repetitions to amplify the probability of measuring \(1\), since \(C=O(\frac 1k)\) and if \(\lambda \leq 1\), the probability of measuring \(1\) is \(\Omega(\frac 1{k^2})\).

Putting all together, then the computational complexity of the original HHL algorithm is:

$$O(\log(N)k^2s^2\epsilon^{-1})$$

however many improvements have been made and the computational complexity of the currently most efficient HHL algorithm is:

$$O\left(poly(\log(sk\epsilon^{-1}))sk\right )$$

and if we assume \(s = O(poly\left(\log(N)\right))\), the algorithm (focusing only on \(N\)) runs in:

$$O(poly\left(\log(N)\right))$$

which represents an exponential speedup in the matrix dimension compared to the best conjugate gradient method, whose complexity is:

$$O \left(Nsκlog\left(\frac 1\epsilon\right)\right)$$

However this holds on very specific assumptions and the next section deals with what happens if some of the assumptions are not met.

Loss of quantum advantage and near term feasibility of HHL

The computational complexity above, is based on the assumptions that:

• \(\ket b\) is already available

• doesn’t consider that \(\ket {A^{-1}b} \) should be read out

Note that if this input/output overhead takes \(O(N)\), the exponential speedup is lost.

The computational cost of encoding \(b\) in \(\ket b\) is:

$$O(N)$$

if \(b\) is a simple bitstring and in general is:

$$O\left(2^N\right)$$

for a generic superposition, which results in the loss of the exponential speedup.

Moreover, also reading out the output solution state \(\ket {A^{-1}b}\) into a classical bitstring \(A^{-1}b\) requires \(O(N)\), offsetting the exponential acceleration.

HHL in solving linear differential equations

One of the main applications of the HHL algorithm is solving linear differential equations. Quantum computers in fact can simulate quantum systems (which are described by a restricted type of linear differential equations), and using HHL it’s possible to solve general inhomogeneous sparse linear differential equations.

A first-order ordinary differential equation may be written as:

$$\frac {\delta x(t)}{\delta t}=A(t)x(t) + b(t)$$

where \(A(t)\) is a \(N\times N\) matrix we assume to be sparse and \(x(t)\) and \(b(t)\) are \(N\)-components vectors.

A similar system can be the output of a conversion process from any linear differential equation with higher-order derivatives or from the discretization of partial differential equations.

A bunch of different methods involving HHL can be used to solve the above DE, however the workflow is roughly the same:

• discretize the differential equation and get a system of algebraic equation

• use HHL to find the solution of the system

In fact, one may apply a discretization scheme to the DE, for example the Euler method, to map the DE to a difference equation:

$$\frac{x_{i+1} + x_i}h= A(t_i)x_i + b(t_i)$$

and it is straightforward to see that this methods results in the following linear system:

$$Ax=b$$

where \(x\) is the vector of blocks \(x_i\), and \(b\) also contains the value of \(x_0\).

To learn more about this please see Berry, (2014), “High-order quantum algorithm for solving linear differential equations”.

HHL in solving least-square curve fitting

Another interesting application for HHL is least squares fitting. The goal in least squares fitting is to find a continuous function to approximate a discrete set of \(N\) points \(\{x_i, y_i\}\). The function has to be linear in the parameter \(\theta \) but can be non linear in \(x\), e.g.:

$$f(\theta, x) = \sum_i \theta_if_i(x)$$

The optimal parameters can be found by minimizing an error function such as the mean squared error:

$$E = |y - f(\theta, x)|^2$$

which can be expressed in matrix for as:

$$E= |y- F\theta|^2$$

where \(F_{ij}=f_j(x_i)\). The best fitting parameter can be found using Moore– Penrose pseudoinverse as:

$$\theta^* = \left(F^\dagger F\right)^{-1}F^\dagger y$$

Finding the best \(\theta\) then involves 3 subroutines:

• performing the pseudo–inverse using the HHL algorithm and quantum matrix multiplication

• an algorithm for estimating the fit quality

• an algorithm for learning the fit-parameters \(\theta\)

To learn more about this please consider reading Wiebe, Brown, LLoyd, (2012), “Quantum Data-Fitting“.

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources

• Harrow, Hassidim, Lloyd, (2009), “Quantum algorithm for linear systems of equations“

• Childs, Kothari, Somma, (2017), “Quantum Algorithm for Systems of Linear Equations with Exponentially Improved Dependence on Precision“

• Duan, Yuan, Yu, Huang, Hsieh, (2020), “A survey on HHL algorithm: From theory to application in quantum machine learning”

• Zheng, Liu, Stein, Li, Mulmenstadt, Chen, Li, (2024), “An Early Investigation of the HHL Quantum Linear Solver for Scientific Applications”

• Berry (2014), “High-order quantum algorithm for solving linear differential equations”

• Wiebe, Brown, LLoyd (2012), “Quantum Data-Fitting“

The shift rule provides an analytical and efficient method for computing gradients of parameterized quantum circuits with respect to their parameters. These gradients are essential for guiding the classical optimizer in the search for the optimal parameters that minimize the cost function. Without an accurate and efficient gradient computation method, the optimization would either be too slow or too noisy, leading to suboptimal results. In this context, the shift rule not only enhances the accuracy of the optimization but also enables its scalability, making it a foundational tool for advancing VQA methodologies in near-term quantum computing.

This blog post briefly discuss VQAs and focuses and one of the various shift rule implementations.

Variational Quantum Algorithms

Variational Quantum Algorithms (VQAs) are hybrid quantum-classical approaches that aim to solve optimization problems by minimizing a cost function over a parameterized quantum circuit. The quantum circuit, often referred to as a parameterized quantum circuit (PQC), depends on a set of tunable parameters \({\theta} = (\theta_1, \theta_2, \dots, \theta_n)\). The goal is to find the optimal values of these parameters that minimize a given cost function \( C(\theta)\), which is typically the expectation value of a problem-specific quantum observable.

Mathematically, the cost function can be expressed as:

$$C(\theta) = \bra {\psi(\theta)} H\ket{\psi(\theta)}$$

where

• \(\ket {\psi(\theta)}\)is the quantum state produced by the PQC,

• \(H\) is the problem Hamiltonian

Two of the most famous and important VQAs are QAOA and VQEs. Next paragraph is devoted to give an introduction to both.

Variational Quantum Eigensolver

The Variational Quantum Eigensolver (VQE) is a VQA that combines the variational principle from quantum mechanics with classical optimization techniques. VQE is particularly useful for problems in quantum chemistry and materials science, where finding the ground state energy of a Hamiltonian is a central task.

In a VQE setting, the cost function is represented by the energy expectation value, formulated as:

$$E(\theta)=\bra{\psi(\theta)}H\ket{\psi(\theta)}$$

According to the variational principle, this energy is always greater than or equal to the ground state energy \(E_0\)​, meaning:

$$E(\theta)\geq E_0 ​$$

Thus, the goal is to minimize \(E(\theta)\) by adjusting the parameters \(\theta\) to find the state \(\ket{\psi(\theta)}\) that approximates the ground state.

The workflow is the following:

• define a parametrized unitary \(U(\theta)\) to prepare \(\ket{\psi(\theta)}\)

• measure the expectation value of the system’s Hamiltonian \(H\) computing \( E(\theta)=\bra{\psi(\theta)}H\ket{\psi(\theta)}\) or the gradient of the expectation value (with shift rule or with numerical methods)

• provide the measured expectation value \(E(\theta)\) or its gradient to a classical optimization algorithm and iterate until the minimum energy is found.

Quantum Approximate Optimization Algorithm

The Quantum Approximate Optimization Algorithm (QAOA) is a hybrid quantum-classical algorithm designed to solve combinatorial optimization problems, such as the Max-Cut problem. QAOA is again a VQA so it uses a parameterized quantum circuit to encode the problem and iteratively improves the solution by tuning the parameters. It has been proposed as a promising algorithm for near-term quantum devices due to its robustness against noise and hardware limitations.

QAOA aims to minimize a classical objective function, \(C(z)\) where \(z \in \{0,1\}^n\) represents the solution to the optimization problem encoded as a binary string. The goal is to find the string \(\hat z\) that minimizes the objective function.

The algorithm constructs a quantum state that approximates the solution by evolving under two Hamiltonians: a problem Hamiltonian \(H_C\)​ and a mixer Hamiltonian \(H_M\).

The former is meant to represent the cost function of the classical problem, for example for the max-cut problem the classical cost function is:

$$C(z)= \sum_{⟨i,j⟩}w_{ij}(1−z_iz_j)$$

where \(w_{ij}\) is the weight of the edge between vertices \(i\) and \(j\), \(\langle i,j⟩\)denotes the set of all pairs of vertices that are connected by an edge and \(z_i\) is the binary variable representing the partition of vertex \(i\).

The corresponding problem Hamiltonian is formulated in terms of quantum operators as:

$$H_C\sum_{ ⟨i,j⟩}w_{ij}\frac {1-Z_iZ_j} 2$$

where \(Z_i\) is Pauli-Z operator acting on qubit \(i\).

Coming to the mixer Hamiltonian, it should encourage transitions between different solutions by applying a mixing operator that typically consists of Pauli-X gates. The mixer Hamiltonian can defined as:

$${H}_M = \sum_{i} {X}_i$$

where \(X_i\) is the Pauli-X operator acting on qubit \(i\), responsible for flipping the bit \(z_i\).

QAOA workflow alternates between evolving under the problem and mixer Hamiltonians for a series of \(p\) layers, which results in the following quantum state:

$$\ket{ψ(γ,β)}=∏_{j=1}^p​e^{−iβ_j​H_M}​e^{-iγ_j​H_C}​H^{⊗n}\ket0^{⊗n}$$

where:

• \(\gamma\) are parameter controlling the controlling the evolution under the problem Hamiltonian

• \(\beta\) are the parameters controlling the evolution under the mixer Hamiltonian

• \(H^{⊗n}\ket0^{⊗n}\) is the n-fold Hadamard applied on a n-qubit register.

The goal of QAOA is to optimize the parameters \(\gamma\) and \(\beta\) such that the quantum state maximizes the expectation value of the objective function \(C(\gamma, \beta)\), which corresponds to the expectation value of the problem Hamiltonian:

$$C(\gamma, \beta)=\bra{ψ(γ,β)} H_C \ket{ψ(γ,β)}$$

And similarly to VQE, by iteratively updating \(\gamma\) and \(\beta\) using a classical optimizer, the algorithm converges to an approximate solution to the optimization problem.

Gradient Computation Using the Shift Rule

As we have seen in the above example, VQA sometimes requires the quantum circuit to evaluate the gradient of the cost function rather than the function itself. Shift rule is useful because it avoids approximations typically used in numerical differentiation (like finite differences).

The next sections describe one of the formulations proposed for shift rule.

We are interested in the expectation value of an observable \(H\) (e.g., a Hamiltonian) with respect to the quantum state \(\ket{\psi(\theta)}\), which is the state prepared by applying \(U(\theta)\) to the initial state \(\ket0^{\otimes n}\). The expectation value is:

$$C(θ)=\bra{ψ(θ)}H\ket{ψ(θ)}=\bra0U^\dagger(θ)HU(θ)\ket0$$

The goal is to compute the derivative w.r.t. \(\theta\) of \(C(θ)\), so that this information can be supplied to a classical optimizer.

The derivative is

$$\frac{∂C(θ)}{∂_i}​=\frac{\partial〈ψ| U^† ˆQU |ψ〉} {\partial \theta_i}= 〈ψ| U^† Q(\frac{\partial G}{\partial \theta_i}) |ψ〉+ 〈ψ|(\frac{\partial G}{\partial \theta_i})^\dagger QU |ψ〉$$

assuming the parameter \(\theta_i\) only affects a single gate.

Parameter-shift rule for gates with generators with two distinct eigenvalues

If we are given a parametrized quantum gate \(U \) with a parameter \(\theta\) of the form:

$$U(θ_k)=e^{−iθ_kG}$$

where \(G\) is a Hermitian operator, it’s trivial to prove that:

$$\frac{\partial U(θ_k)}{\partial \theta_k}=-iGU(\theta_k)$$

and substituting into the derivative of the circuit equation what we get is:

$$\frac{∂C(θ)}{∂θ_k}​= -i〈ψ| U^† HGU(\theta_k) |ψ〉-i 〈ψ|HU(\theta_k)^\dagger G^\dagger |ψ〉$$

If \(G\) has at most two unique eigenvalues \(\pm r\).

Moreover, one may prove with some algebra that for every operators A, B and Hermitian observable Q:

$$\bra \psi A^\dagger Q B\ket \psi + \bra \psi B^\dagger Q A\ket \psi = \frac 12(\bra \psi (A+B)^\dagger Q (A+B)\ket \psi + \bra \psi (A-B)^\dagger Q (A-B)\ket \psi)$$

therefore, using \(A = I\) and \(B = -ir^{-1}G\) in our problem:

$$\frac{∂C(θ)}{∂θ}​= \frac r2(\bra \psi (I-ir^{-1}G)^\dagger H (I-ir^{-1}G)\ket \psi + \bra \psi (I+ir^{-1}G)^\dagger H(I+ir^{-1}G)\ket \psi)$$

It is also possible to show that for such special \(G\):

$$U(\frac \pi {4r}) = \frac{I-ir^{-1}G}{\sqrt{2}}$$

Hence the partial derivative of the cost function can be estimated place either the gate \(U(\frac \pi{\sqrt 2})\) or \(U(-\frac \pi{\sqrt 2})\) after the gate to be differentiated.

However, since:

$$U(a)U(b) = G(a+b)$$

when \(G \) is a unitarily generated one parameter gate, by substitution this leads to the parameter shift rule:

$$\frac{∂C(θ)}{∂θ_k}​= r(〈ψ| U^†(\theta_k +s) HGU^†(\theta_k +s) |ψ〉- 〈ψ|HU(\theta_k-s)^\dagger U^†(\theta_k -s) |ψ)$$

which is equivalent to:

$$\frac{∂C(θ)}{∂θ_k}​= r(C(\theta +s) - C(\theta-s))$$

where \(s = \frac{\pi}{4r}\).

If the parameter \(\theta_k\) appears in more than a single gate in the circuit, the derivative is obtained using the product rule by shifting the parameter in each gate separately and summing the results.

Differentiation of general gates via linear combination of unitaries

If the \(U(\theta) \) doesn’t has the above mentioned form, we may evaluate the partial derivative of the cost function using an ancilla qubit. The idea is to express \(U(\theta)\) as a linear combination of unitary matrices \(A_j\).

The derivative then becomes:

$$\partial_{\theta_k} C(\theta) = \sum_j a_j (\bra \psi U^\dagger H A_j\ket \psi+ \bra \psi A_j^\dagger H U\ket \psi)$$

where \(a_j\) are real values.

The circuit requires to be instantiated in the:

$$\ket + \ket \psi$$

state and then the controlled \(U\) is applied upon the \(\ket \psi\) state (conditioned on \(\ket \psi\) being in \(\ket 0\) state), followed by a controlled \(A_k\) on the same state (conditioned on \(\ket \psi\) being in \(\ket 1\) state), which results in:

$$\frac 1{\sqrt{2}}(\ket 0 U\ket\psi + \ket 1 A_k\ket\psi)$$

Once another Hadamard gate is applied on the ancilla, the resulting state is:

$$\frac 14 (\ket 0 [G+A_k]\ket \psi + \ket 1 [G-A_k]\ket \psi)$$

One can than estimate \(p_0\) and \(p_1\), respectively the probability of getting the \((G+A_k) \ket\psi\) and \((G-A_k) \ket\psi\) once the ancilla is measured.

With those probabilities the following cost functions can be defined:

$$C_0 = \frac 1{4p_0} \ket \psi (U+A_k)^\dagger H (U+A_k)\ket \psi$$

and similarly:

$$C_1 = \frac 1{4p_1} \ket \psi (U-A_k)^\dagger H (U-A_k)\ket \psi$$

and therefore:

$$\bra \psi U^\dagger H A_k\ket \psi + \bra \psi A_k^\dagger H U\ket \psi = 2(p_0 C_0 - p_1C_1)$$

which means that we can repeat all the steps done for gates with generators with two distinct eigenvalues.

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources:

• Mitarai, Negoro, Kitagawa, Fujii, (2019), “Quantum Circuit Learning K“, https://arxiv.org/pdf/1803.00745

• Schuld, Bergholm, Gogolin, Izaac, Killoran, (2018) “Evaluating analytic gradients on quantum hardware Maria“, https://arxiv.org/pdf/1811.11184

• Kottmann, Killoran, “Evaluating analytic gradients of pulse programs on quantum computers”, https://arxiv.org/pdf/2309.16756

• Stein, Wiebe, Ding, Bo, Kowalski, Baker, Ang, Li, “EQC: Ensembled Quantum Computing for Variational Quantum Algorithms”, https://dl.acm.org/doi/pdf/10.1145/3470496.3527434

• He, “Computing the gradients with respect to all parameters of a quantum neural network using a single circuit”, https://arxiv.org/pdf/2307.08167

Ideally, we aim for models that are both quick to train and sophisticated enough to discover meaningful patterns and one of the most intriguing methods to achieve this balance is through kernel methods which allow for the training of simple linear models that maintain low bias and low variance, by mapping the data into a higher-dimensional feature space, making them both efficient and effective. In this post, after a brief introduction, we'll discuss the fascinating world of quantum kernels (which as the name suggests are the quantum analogue of kernel) and explore how these powerful tools can be applied to solve differential equations.

Kernel methods

Kernel methods are a cornerstone of machine learning, providing a powerful way to handle non-linear relationships between output (\(y\)) and input data(\(x\)). The core idea is to transform the data into a higher-dimensional feature space where linear models can be applied effectively. This transformation is not done explicitly, instead, the so-called kernel trick allows to compute inner products between data points as if they were in the higher-dimensional space, without ever needing to compute their actual coordinates in that space. This results in computational efficiency, even when working with very high-dimensional spaces.

We can use kernel methods in a regression context, i.e. to find a function \(f\) s.t.:

$$f(x_i) \approx y_i$$

where \(x_i\) are the input features and \(y_i\) are the corresponding output labels.

For example one may assume the \(f\) has to be linear, i.e.

$$f(x) = a+x b$$

where \(a\) and \(b\) are just vectors that can be learned by minimizing an error function, for example the mean square error:

$$MSE = \frac 1n \sum_i (f(x_i)-y_i)^2$$

Of course assuming a linear relation between the input and the output isn’t necessarily true and while such a linear model is a really simple model, it could struggle with non linear data.

To address such non-linear relationships, kernel methods extend the idea of linear models by mapping the input space \(x\) to a higher-dimensional feature space \(\phi(x)\) choosing \(\phi(\cdot)\) s.t. \(y\) is then linear in \(\phi(x)\) and linear models can be used.

However the strength of kernel methods lies in the already mentioned kernel trick: instead of explicitly calculating the new feature space, kernel methods relies on the so called kernel functions:

$$K(x_i, x_j) = \langle\phi(x_i), \phi(x_j)\rangle$$

which is the used to define the kernelized learning task, which could potentially be something like:

$$f(x) = \sum_i a_i K(x, x_i) + b$$

which is linear in the newly mapped feature space. At that point an error function can be defined to find the parameters of the model.

As you can see the essence of the kernel methods relies in their ability to handle non-linear data using linear models in a higher-dimensional space without explicitly mapping data to that space.

One last point: in functional analysis, Mercer theorem guarantees that, if some condition are met, a dot product in some Hilbert space corresponds to a kernel. This is of paramount importance as one may define a kernel function from an inner product as we will do later in the article to get a quantum kernel.

Kernel methods in Python

To make it easier for the reader to understand kernel methods, I prepared a simple python example where linear regression and a particular kernel method is applied on non-linear data:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error

# Create non-linear data
np.random.seed(42)
X = np.sort(5 * np.random.rand(50, 1), axis=0)
y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])

# Fit Linear Regression
linear_reg = LinearRegression()
linear_reg.fit(X, y)
y_pred_linear = linear_reg.predict(X)

# Fit Support Vector Regression (SVR) with RBF Kernel
svr_rbf = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
svr_rbf.fit(X, y)
y_pred_svr = svr_rbf.predict(X)

# Plot the results
plt.scatter(X, y, color='darkorange', label='Data')
plt.plot(X, y_pred_linear, color='cornflowerblue', label='Linear Regression', linewidth=2)
plt.plot(X, y_pred_svr, color='green', label='SVR with RBF Kernel', linewidth=2)
plt.legend()
plt.show()

The result of the above code is:

Quantum kernel methods

Quantum kernel methods take the idea behind classicalMkernels to the next level, using quantum mechanics to tackle more complex, high-dimensional data. The basic idea is to encode information into quantum states and calculate similarities in the new space. This section discusses quantum kernel methods, starting from the encoding of the classical variables into quantum states and then discussing the evaluation of quantum kernel functions and how to take derivatives of quantum kernel functions.

Encoding

We start introducing the concept of quantum kernel methods from that of quantum kernel function. As already mentioned, a kernel function is a function \(k\) mapping two variables \(x_i\) \(x_j\) \(\in\) \(A\) to the complex space:

$$k: A \times A\rightarrow \mathbb{C}$$

and a quantum kernel function is a kernel function that can be evaluated on a quantum computer. For example a valid quantum kernel can be:

$$k(x_i, x_j) \equiv \bra {\psi(x_i)}\ket {\psi(x_j)}$$

where the \(\psi(x_i)\) indicates a quantum states encoded by the classical variable \(x_i\).

To define quantum kernel functions properly, it's essential to understand what encoding into quantum states entails and how to do it efficiently which is equivalent to the crucial task of designing an efficient feature map. The idea is to use a parametrized quantum circuit \(U\) s.t.:

$$U(x_i)\ket 0 = \ket {\psi(x_i)}$$

A simple example of \(U\) is:

$$\bigotimes_j R_{p,j}[\phi(x_i)]$$

where \(R_{p,j}[\phi(x_i)]\) represents the rotation on qubit \(j\) of angle \(\phi(x_i)\)over about a Pauli operator \(q\). The selection of the feature map is crucial, as it must be expressive enough to capture the problem's solution while remaining trainable.

Evaluation

After mapping the classical variables into the feature space, the next step is to efficiently implement the quantum kernel function in a quantum circuit. Given that a convenient quantum kernel is defined as:

$$k(x_i,x_j) \equiv |\bra {\psi(x_i)}\ket {\psi(x_j)}|^2$$

the question becomes: which quantum circuit can perform this computation?

Naively, one can exploit the fact that:

$$k(x_i,x_j) \equiv |\bra {\psi(x_i)}\ket {\psi(x_j)}|^2= \bra 0U^\dagger(x_j)U(x_i)\ket0\bra 0U^\dagger(x_i)U(x_j)\ket0$$

which can be implemented by applying \(U(x_j)\) followed by \(U(x_i)\) on \(\ket 0 ^{\otimes n} \) , where \(n\) is the number of qubits necessary to encode \(\ket {\psi(x)}\), followed by measurements. The kernel function value is determined by measuring all qubits and calculating the probability of remaining in the zero state, which is found by taking the ratio of times \(\ket 0\) is found.

Alternatively, one may use the coherent SWAP test (while this would require \(2n +1\) qubits). This involves preparing the \(\ket {\psi(x_i)}\)and \(\ket {\psi(x_j)}\) states on two separate registers and then performing a swap controlled by an ancilla in superposition. The advantage of this method is that it only requires to measure one single ancilla qubit, however it needs more qubits than the naïve method above.

Last, it is possible to use two evaluations of the Hadamard test (which requires \(n+1\) qubits) which can be exploited to compute the real and the imaginary part of:

$$\bra 0U^\dagger(x_i)U(x_j)\ket0$$

which are then used to evaluate the kernel as:

$$Re( \bra 0U^\dagger(x_i)U(x_j)\ket0 )^2 + Im( \bra 0U^\dagger(x_i)U(x_j)\ket0 )^2$$

Computing derivatives

Since this article involves solving differential equations, we need to be able to compute the derivatives of the kernel function on a quantum computer. This will be important for the definition of the loss function and for the optimization of the parameters of the solution.

Let’s first assume that:

$$\nabla_{p,q} k(x_i,x_j) \equiv \frac{\partial^{p+q} k(x_i,x_j)}{\partial^p x_i\partial^qx_j}$$

We can consider the kernel function formulation acting on a single register defined above (the one we called naïve):

$$k(x_i, x_j)=\bra 0U^\dagger(x_j)U(x_i)\ket0\bra 0U^\dagger(x_i)U(x_j)\ket0$$

and build the following quantum model:

$$f(x) = \bra 0U^\dagger(x)MU(x)\ket0$$

where \(M\) is a measurement operator and take its derivative, which, by parameter shifting rule (a method for estimating the gradients of a parameterized quantum circuit, which will be the focus of one of the upcoming articles) is:

$$\partial_xf=\sum_{i=1}^n\frac{f(x+\frac \pi 2_i) - f(x-\frac \pi 2_i)}2$$

where \(n \) is the number of gates depending on \(x\) in \(U(x)\) and \(f(x\pm\frac \pi 2_i)\) is the evaluation of \(f(x)\) where the i-th gate depending on \(x\) is shifted by \(\pm\frac \pi 2\). Higher order derivatives can be implemented iterating the parameter shifting rule.

Alternatively the computation of derivatives is also permitted by the Hadamard test. Starting once again from:

$$k(x_i, x_j)=\bra 0U^\dagger(x_j)U(x_i)\ket0\bra 0U^\dagger(x_i)U(x_j)\ket0$$

by product rule the first derivative is:

$$\bra 0U^\dagger(x_j)\partial_{x_i}U(x_i)\ket0\bra 0U^\dagger(x_i)U(x_j)\ket0 + \bra 0U^\dagger(x_j)U(x_i)\ket0\bra 0\partial_{x_i}U^\dagger(x_i)U(x_j)\ket0$$

and the first term can be computed via Swap test while the second one via one or more Hadamard tests.

Solving differential equations

This section deals with describing how quantum kernels can be used as solvers for differential equations. The first subsection introduces a regression method and the second subsection applies it to solve differential equation.

Mixed model regression

In the context of mixed model regression, the trial function (the functional form we give to the solution) is:

$$f_a(x) = b + \sum_{j=1}^na_j k(x, y_j)$$

where \(k(\cdot)\) is the quantum kernel function, \(\{y_j\}\) is a set of evaluation points, \(a\) and \(b\)are tunable coefficients. It’s worth noticing that being \(a\) the parameter to be optimized and since \(k(x, y_j)\) is independent of \(a\), one can compute each \(k(x, y_j)\) before starting the optimization procedure. Moreover, one of the advantages of mixed model regression is that its structure remains consistent across different problems, whereas in other classes of kernel regressions (e.g. support vector regression), the model form can vary.

Differential equations

Let the following differential equation for the sake of simplicity:

$$DE(f,x, \partial _xf)= \partial_x f - g(f, x) = 0$$

with\(f(x_0) = f_0\), where \(g\) is a smooth function, we want to use mixed model regression and support vector regression to solve this DE.

Starting from mixed model regression, a proper choice for the loss function is:

$$\mathcal L(a) = \sum_i \left [ DE\left(f_a,x_i, \partial _xf_a(x_i)\right] \right ) + (f_a(x_0) - f_0)^2$$

where:

$$f_a(x) = b + \sum_{j=1}^na_j k(x, y_j)$$

Since the kernel and it’s derivatives are independent of \(a\), they can be evaluated only once and, using an appropriate optimization technique, it’s possible to find the optimal weights \(a\). Moreover in some cases such optimization problem is convex. The resulting function is then a suitable approximation to the solution of the differential equation.

In the case the differential equation is different from the one in the above example, one may rely on the same framework, just adjusting for generalized optimization (i.e. by defining a suitable loss function and by minimizing the sum of different loss functions in the case of systems of differential equations).

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources

• Paine, Annie E., Vincent E. Elfving, and Oleksandr Kyriienko. "Quantum Kernel Methods for Solving Regression Problems and Differential Equations." Physical Review, 2023

• Mengoni, Riccardo, and Alessandra Di Pierro. "Kernel Methods in Quantum Machine Learning." Springer Nature, 2019

• Schuld, Maria. "Supervised Quantum Machine Learning Models Are Kernel Methods." arXiv, 2021

In this blog post, we'll explore the core concepts behind QBMs and investigate how they leverage the distinctive features of quantum computing to advance probabilistic modelling and learning and we'll examine how QBMs build on classical methods and the potential they hold for transforming data analysis and problem-solving in machine learning.

Classical Boltzmann Machines

Before diving into Quantum Boltzmann Machines (QBMs), it's useful to understand classical Boltzmann Machines (BMs) since QBMs are inspired by and build upon the concepts of classical BMs.

The concept of Boltzmann Machines was introduced by Geoffrey Hinton and Terrence Sejnowski in the mid-1980s and the model is named after the physicist Ludwig Boltzmann, whose work on statistical mechanics inspired the probabilistic framework of the BM.

The impact of Boltzmann Machines has been broad and significant, for example in image and speech recognition, Restricted Boltzmann Machines (RBMs, an evolution of BMs) have excelled at unsupervised feature learning, improving classification accuracy. In recommendation systems, they’ve been used to predict user preferences and RMBs applications extend also to natural language processing for learning text representations and robotics for sensor fusion, combining data from multiple sources.

Classical architectures

Basically, a Boltzmann Machine consists of a collection of binary units, also known as neurons, organized into two layers: visible units and hidden units. The visible units represent the observed variables, while the hidden units capture the latent or hidden variables that explain the relationships in the data.

Due to the exponential growth in the number of connections with an increase in nodes in a classical Boltzmann Machine (BM), the Restricted Boltzmann Machine (RBM) is often preferred. The RBM simplifies the architecture by restricting connections:

• Hidden nodes are not connected to each other

• Visible nodes are also not connected to each other

In RBMs, connections exist only between visible and hidden nodes, which makes the network more manageable and easier to train compared to the fully connected structure of classical BMs.

The objective of Boltzmann Machines is to model a probability distribution over a set of binary variables (units) in a way that captures the complex relationships and dependencies between these variables. This is achieved through the concept of energy.

The idea behind the energy based learning lies in the energy function, defined as

$$E(v, h) = - \sum_{i} b_i v_i - \sum_{j} c_j h_j - \sum_{i,j} W_{ij} v_i h_j$$

where:

• \(b_i\) is the bias of the i-th visible node

• \(v_i\) is the i-th visible node

• \(c_j\) is the bias of the j-th hidden node

• \(h_j\) is the j-th hidden node

• \(W_{ij}\) is the weight of the connection between visible i-th unit and j-th hidden unit

To each configuration (\(v, \space h\)) a probability is assigned according to the following function:

$$P(v, h) = \frac{e^{-E(v, h)}}{\sum_{v, h} e^{-E(v, h)}}$$

and the goal is to minimizing the difference between the distribution defined by the BM and the true data distribution, i.e. to maximize the likelihood of the training data under the model:

$$\mathcal{L} = \sum_{v} P_{\text{data}}(v) \log P_{\text{model}}(v)$$

Training

In Boltzmann Machines, error adjustment cannot be achieved using a gradient descent process like in traditional neural networks, where weights are adjusted by backpropagating the error through the network. This is because BMs are undirected networks, meaning there is no distinction between input and output layers. As a result, BMs lack the concept of "backpropagation" since there is no directed flow of information to guide the adjustment of weights.

In fact, the algorithm typically used to train BMs is called Contrastive Divergence and is completely different in nature from backpropagation, since it approximates the gradient of the log-likelihood function by using a technique involving Gibbs sampling.

The algorithm is an iterative algorithm made by the following 2 steps:

• Perform Gibbs sampling to approximate the distribution of the hidden and visible units based on their conditional probabilities

• Compute the gradient and update the weights.

Gibbs sampling

Given a set of variables \(X=\{X_1, \dots X_n\}\) Gibbs sampling aims to sample from the joint distribution \(P(X)\) which sometimes can be challenging, Therefore Gibbs sampling uses the conditional distributions \(P(X_i|X_{/i})\) where \(X_{/i}\) denotes all the variables except \(X_{i}\).

Therefore using this technique

$$X_i^{(t+1)} \sim P(X_i \mid X_1^{(t)}, X_2^{(t)}, \ldots, X_{i-1}^{(t)}, X_{i+1}^{(t)}, \ldots, X_n^{(t)})$$

In the context of BMs this translates to sampling the hidden units as

$$P(h_j = 1 \mid v) = \sigma \left( \sum_{i} W_{ij} v_i + c_j \right)$$

and the visible units as

$$P(v_i = 1 \mid h) = \sigma \left( \sum_{j} W_{ij} h_j + b_i \right)$$

where \(\sigma(x) = \frac{1}{1 + \exp(-x)}\).

Compute the gradient and update the weights

The gradient is then computed as:

$$\frac{\partial \mathcal{L}}{\partial W_{ij}} = \frac{\partial}{\partial W_{ij}} \left( \sum_{v} P_{\text{data}}(v) \log P_{\text{model}}(v) \right)$$

which, after some calculations results in:

$$\frac{\partial \mathcal{L}}{\partial W_{ij}} = \langle v_i h_j \rangle_{\text{data}} - \langle v_i h_j \rangle_{\text{model}}$$

where:

• \(\langle v_i h_j \rangle_{\text{model}} = \sum_{v, h} P_{\text{model}}(v, h) v_i h_j\)

• \(\langle v_i h_j \rangle_{\text{data}} = \sum_{v} P_{\text{data}}(v) v_i h_j\)

And the weights are updated iteratively as:

$$W_{ij}^{t+1} = W_{ij}^{t}+\epsilon \left( \langle v_i h_j \rangle_{\text{data}} - \langle v_i h_j \rangle_{\text{model}} \right)$$

where \(\epsilon\) is the learning rate.

Quantum Boltzmann machines

The concept of leveraging quantum mechanics for machine learning tasks has seen significant advancements over the past decade, with the Quantum Boltzmann Machine (QBMs) emerging as one of the results of these studies. In particular Mohammad Amin, Evgeny Andriyash, Jason Rolfe, Bohdan Kulchytskyy, and Roger Melko, arxiv:1601.02036 (2016) has developed a quantum probabilistic model based on Boltzmann distribution of a quantum Hamiltonian, which exploits quantum effects both in the model and in the training process.

The problem QBMs is exactly the same as BMs: finding the biases and weights parameters that better approximate a sample distribution by maximizing the log-likelihood, as defined above.

Quantum architecture

As for classical Boltzmann Machines, our treatment of QBMs starts from the energy function:

$$E(\xi) = -\sum_{i} \xi_i \beta_i - \sum_{i,j} W_{ij} \xi_i \xi_j$$

where:

• \(\xi_i\) represents a node (hidden or visible) which is a \(2^n \times 2^n\) matrix defined as (\(I\)is the identity matrix, \(\sigma_z\) is Pauli Z matrix, \(N\) is the number of nodes):

$$\xi_i \equiv \overbrace{I \otimes \ldots \otimes I}^{i-1} \otimes \sigma_i^z \otimes \overbrace{I \otimes \ldots \otimes I}^{N-i}$$

• \(\beta\) represents the biases (for both hidden and visible nodes)

Using the energy function we define the Boltzmann distribution as:

$$P(\xi) = \frac{e^{-E(\xi)}}{\sum e^{-E(\xi)}}$$

where the matrix exponentiation is defined trough Taylor expansion:

$$e^{- E(\xi)}=\sum_{k=0}^{\infty} \frac{1}{k!}\left( - E(\xi) \right) ^k$$

Let also the partition function \(Z\) be:

$$Z=Tr[e^{-E(\xi)}]$$

then the density matrix is:

$$\rho = Z^{-1}e^{-E(\xi)}$$

which represents the Boltzmann probability of the \(2^N\) elements. Therefore to get the marginal probability distribution over the visible variables \(\ket v\) we just need to trace over the hidden variables, i.e.:

$$P_v = Tr[(\ket v \bra v \otimes I_h)\rho]$$

which is the analogous of:

$$P(v, h) = \frac{e^{-E(v, h)}}{\sum_{v, h} e^{-E(v, h)}}$$

At this point, if we include in the Hamiltonian a new element representing a transverse field defined as:

$$\nu_i \equiv \overbrace{I \otimes \ldots \otimes I}^{i-1} \otimes \sigma_i^x \otimes \overbrace{I \otimes \ldots \otimes I}^{N-i}$$

where \(\sigma_x\) is the Pauli X matrix, the resulting Hamiltonian is:

$$E(\xi, \nu) = -\sum_{i} \xi_i \beta_i - \sum_{i,j} W_{ij} \xi_i \xi_j -\sum_i \Gamma_i\nu_i$$

where \(\Gamma_i\) is a parameter.

This new Hamiltonian is special since every eigenstate of \( E(\xi, \nu)\) is a superposition of the classical states \(\ket{v, h}\). Hence using the following density matrix defined above with this new Hamiltonian, each measurement in the \(\sigma_z\) basis results in a classical output in \( \{1, -1\}\), and the probability of each output is given by \(P_v\).

Training

As in the classical formulation, the scope of QMBs is to find the \(W\) and \(b\) (from now on I'm referencing these parameters as \(\theta\)) so that \(P_v\) (what before was called \(P_{\text{model}}\)) is close to \(P_\text{data}\).

Again this is achieved by minimizing the negative log-likelihood \(\mathcal{L}\):

$$\mathcal{L}=-\sum_{\mathbf{v}} P_{\text {data }} \log \frac{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h) e^{-E(\xi, \nu)}\right]}{\operatorname{Tr}\left[e^{-E(\xi, \nu)}\right]}$$

whose gradient is:

$$\partial_\theta \mathcal{L}=\sum_{\mathbf{v}} P_{\text {data }}\left(\frac{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h) \partial_\theta e^{-E(\xi, \nu)}\right]}{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h) e^{-E(\xi, \nu)}\right]}-\frac{\operatorname{Tr}\left[\partial_\theta e^{-E(\xi, \nu)}\right]}{\operatorname{Tr}\left[e^{-E(\xi, \nu)}\right]}\right)$$

Ideally we would use some sampling techniques to estimate efficiently the gradient, however, since \(E(\xi, \nu)\) and \(\partial_\theta E(\xi, \nu)\) don't commute, we don't have a trivial solution.

In fact one can prove that:

$$\frac{\operatorname{Tr}\left[\partial_\theta e^{-E(\xi, \nu)}\right]}{\operatorname{Tr}\left[e^{-E(\xi, \nu)}\right]}= - \operatorname{Tr}[\rho {\partial_\theta}{E(\xi, \nu)}]$$

and that:

$$\frac{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h) \partial_\theta e^{-E(\xi, \nu)}\right]}{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h) e^{-E(\xi, \nu)}\right]}=-\int_0^1 d t \frac{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h) e^{-t E(\xi, \nu)} \partial_\theta E(\xi, \nu)e^{-(1-t) E(\xi, \nu)}\right]}{\operatorname{Tr}\left[(\ket v \bra v \otimes I_h)e^{-E(\xi, \nu)}\right]}$$

and it can be shown that, while the first term can be estimated efficiently, the second one cannot be efficiently estimated using sampling, which makes the computational cost of training QBMs impractical. Is this the end of the story? Actually no, since the introduction of an upper bound on the \(\mathcal{L} \) (which is a common practice in machine learning) results in the so-called bound-based Quantum Boltzmann Machines (BQBMs), that provides a work around to the computational impracticability of QBMs, as discussed in next section.

Bound-based Quantum Boltzmann Machines

A very famous inequality, called Golden-Thompson inequality states that for any Hermitian matrix \(A\) and \(B\) the following is true:

$$\operatorname{Tr}\left( e^Ae^B\right) \geq \operatorname{Tr}\left( e^{A+B}\right)$$

Therefore we know that:

$$P_v = \frac{\operatorname{Tr}[e^{\log{(\ket v \bra v \otimes I_h)}}e^{-E(\xi, \nu)}]}{\operatorname{Tr}[e^{-E(\xi, \nu)}]} \geq \frac{\operatorname{Tr}[e^{H_\xi}]}{\operatorname{Tr}[e^{-E(\xi, \nu)}]}$$

where \(H_\xi \equiv \log{(\ket v \bra v \otimes I_h)}-E(\xi, \nu)\) and is a peculiar Hamiltonian since it assigns an infinite energy penalty for any state s.t. the visible qubits register is different from \(\ket v\). Mathematically, this means that the probability of the system being in any state other than \(\ket v\) is zero because the Boltzmann factor approaches zero for infinite energy.

This means, in other words, that every qubits \(\xi_i\) is clamped to the corresponding classical value \(v_i\).

From the Golden-Thompson inequality we can also derive that:

$$\mathcal{L} \le \hat{\mathcal{L}} \equiv \sum P_\text{data} \log \frac{\operatorname{Tr}[e^{H_\xi}]}{\operatorname{Tr}[e^{-E(\xi, \nu)}]}$$

and we can now minimize \(\hat{\mathcal L}\), the upper bound of \({\mathcal L}\), using the gradient and we get the following rules to update the bias \(\beta_i\):

$$\beta_i^{t+1}= \beta_i^{t} + \epsilon \left(\sum P_\text{data} \frac{\operatorname{Tr}[e^{-H_\xi}]\sigma_i^z}{\operatorname{Tr}[e^{-H_\xi}]} - \operatorname{Tr}(\rho \sigma_i^z)\right)$$

and the weight \(w_{ij}\):

$$W_{ij}^{t+1}= W_{ij}^{t} + \epsilon \left(\sum P_\text{data} \frac{\operatorname{Tr}[e^{-H_\xi}]\sigma_i^z\sigma_j^z}{\operatorname{Tr}[e^{-H_\xi}]} - \operatorname{Tr}(\rho \sigma_i^z\sigma_j^z)\right)$$

One may also think about training the \(\Gamma\), however this results in vanishing \(\Gamma\)i.e. learning the transverse field is unfeasible in this upper bound setting.

Semi-restricted Quantum Boltzmann Machines

Untill now we never posed any restrictions on the structure of the QBM, and in particular we assumed a fully connected architecture. Similarly to classical RBMs, semi-restricted Quantum Boltzmann Machines (srQBMs) are quantum neural networks similar to QBMs whose hidden layer has lateral connectivity.

Note that, unlike classical RBMs, we are assuming the lateral connection in the only in the hidden layer.

A similar architecture in fact allows us to apply contrastive divergence learning algorithms since the clamped Hamiltonian is then:

$$H_\xi = - \sum_i \left(\Gamma_i \sigma_i^x + (b_i+ \sum_j W_{ij} v_j)\sigma_i^z \right)$$

as the hidden qubits are uncoupled during the parameters learning phase.

Based on the Hamiltonian one can show that expectations can be computed efficiently as:

$$\frac{\operatorname{Tr}[e^{-H_\xi}]\sigma_i^z}{\operatorname{Tr}[e^{-H_\xi}]}= \frac{b_i+ \sum_j W_{ij} v_j}{\sqrt{\Gamma_i^2 + (b_i+ \sum_j W_{ij} v_j)^2}}$$

which is equivalent to the classical RBMs expression as \(\Gamma_i \rightarrow 0\).

Conclusion

While being still experimental, Quantum Boltzmann Machines represent an exciting advancement in the field of quantum machine learning and the journey towards fully realizing the potential of Quantum Boltzmann Machines is ongoing, requiring collaboration across disciplines and continuous innovation. While it is important to temper expectations with the recognition of current limitations, the foundational work being done is not just an academic exercise but a step towards unlocking new possibilities in science and industry.

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources

• Mohammad Amin, Evgeny Andriyash, Jason Rolfe, Bohdan Kulchytskyy, and Roger Melko, arxiv:1601.02036 (2016)

• G. E. Hinton, S. Osindero, Y-W. Teh, A fast learning algorithm for deep belief nets, Neural Comput. 18, 1527– 1554 (2006)

• R. Salakhutdinov, G. E. Hinton, Deep Boltzmann machines, AISTATS 2009

• Miguel Carreira-Perpinan, Geoffrey Hinton, On Contrastive Divergence Learning (2005)

This has sparked a surge of interest in quantum computing within both academic and industrial circles and this computing paradigm, with its fundamentally different approach to processing information, is believed to offers the potential to revolutionize problem-solving in finance in both the long and near term.

This field of research is often referred to as Quantum Finance, and this blog post marks the first in a series dedicated to the topic. In particular, this article discusses the speedup quantum computers can provide to an extremely important financial task: option pricing.

Options

Options are financial derivatives that give the buyer the right, but not the obligation, to buy (call option) or sell (put option) an underlying asset at a predetermined price (called the strike price) within a specified time frame, after paying a premium for this right. The concept of options dates back to ancient Greece, where contracts resembling options were used for olive harvests by Thales of Miletus. However, the modern options market was established in 1973 with the creation of the Chicago Board Options Exchange, which standardized option contracts and brought greater transparency and accessibility to options trading.

Options play a pivotal role in financial markets for several reasons. They allow investors to hedge against potential losses in other investments, provide opportunities for speculation on the future direction of asset prices (buying a call (put) option represent a long (short) strategy), and offer ways to enhance portfolio returns through strategies like covered calls or protective puts.

There are various types of options, each with unique characteristics. The two primary categories are European and American options. European options can only be exercised at the expiration date, making their pricing models simpler and often less expensive. In contrast, American options can be exercised at any point up to and including the expiration date, offering greater flexibility but also more complex pricing models due to the additional considerations of when the option might be exercised. Options can also be categorized as vanilla or exotic. Vanilla options refer to the standard call and put options with straightforward payoff structures. These are the most common types of options traded. In contrast, exotic options, or non-vanilla options, have more complex features and payoff structures. Examples include:

• Barrier Options: Options that are activated or extinguished if the underlying asset reaches a certain price

• Asian Options: Options where the payoff depends on the average price of the underlying asset over a specific period, rather than the price at expiration

• Lookback Options: Options that allow the holder to "look back" over time to determine the optimal exercise price.

Beyond this complexity, accurate pricing of options is crucial for maintaining fair trading practices, effective risk management, and overall market stability. Inaccurate pricing can in fact introduce significant risks, as it may lead to arbitrage opportunities where traders exploit price discrepancies for guaranteed profits, potentially causing market imbalances. Additionally, mispricing can result in inadequate hedging strategies, exposing investors and financial institutions to unforeseen losses and undermining confidence in the financial system. Thus, precision in option pricing is essential to mitigate these risks and ensure the smooth functioning of financial markets.

Classical strategies for Option Pricing

Option pricing fundamentally depends on projecting the future value of the underlying asset, as the option's worth is derived from the underlying asset's price movements. To accurately price an option, it's essential to understand how the underlying security might evolve over time. Three primary factors influence the pricing of an option: the current price of the underlying asset, the time value of the option, and the implied volatility of the underlying asset:

• The price of the underlying asset is the most critical factor affecting the option's premium. The premium reflects the right to buy or sell the underlying asset, and a higher-priced asset demands a higher premium compared to a lower-priced asset. This ensures that investors have sufficient incentive to purchase options on assets with varying price levels

• The time value of an option pertains to the duration between the purchase date and the option's expiration date. The longer the time until expiration, the higher the chance that the underlying asset will reach the strike price, making longer-term options more expensive than shorter-term ones with the same strike price

• Implied volatility is another crucial component in option pricing. As the perceived volatility of the underlying asset increases, so does the option's price. This is because higher volatility means a greater potential for significant price swings, offering more opportunities for profit to the option holder but also posing higher risk to the seller. Consequently, the seller demands a higher premium to compensate for this increased risk.

Black-Scholes-Merton model

One of the most famous approach to pricing involves taking advantage of the stochastic nature of financial markets and modelling their dynamics with a formula we can analytically solve. Given the appropriate assumptions, this approach results in the famous Black-Scholes-Merton model:

$$C = S_0 N(d_1) - K e^{-rT} N(d_2)$$

where:

• \(C\) is the price of the European vanilla call option

• \(S_0\) is the price of the underlying asset

• \(K\) is the strike price of the option

• \(r\) is the risk-free interest rate

• \(T\) is the time to maturity of the option

• \(N\) is the cumulative distribution function of the standard normal distribution

• \(d_1 = \frac{\ln\left(\frac{S_0}{K}\right) + \left(r + \frac{\sigma^2}{2}\right)T}{\sigma \sqrt{T}}\)

• \(d_2 = d_1 - \sigma \sqrt{T}\)

The model however has some limitations, including assuming an arbitrage-free market, constant \(r\) over time, a constant volatility of the underlying asset over time, stocks not paying dividends, market being frictionless (no taxes and no transaction costs) to name a few. Because of these drawbacks, there are alternative analytical approaches to option pricing that address some of the unrealistic assumptions.

Monte Carlo methods

What I want to discuss a little further however are the Monte Carlo methods, as the quantum approach to option pricing discussed below is, in many ways, a quantum analogue of the Monte Carlo pricing method.

Basically, Monte Carlo methods involve simulating a large number of possible paths that the underlying asset price might take over the life of the option. These simulations use random sampling to model the stochastic processes that govern asset price movements and each simulated path is used to calculate the payoff of the option. The average of these payoffs is then discounted back to the present value to obtain the option price.

Therefore Monte Carlo method is made of 3 steps:

• Model specification: define the dynamics of the stochastic process governing the underlying asset's price dynamics

• Path simulation: generate a large number of random price paths for the underlying asset using the specified stochastic process. The idea is that each path is a possible future trajectory of the asset's price

• Payoff computation and discounting: compute the payoff of the option for each simulated path and discount the payoff to the present value using the risk-free interest rate. Than compute the average of the discounted payoffs to estimate the option price.

The strength of the Monte Carlo approach lies in its versatility as a generic methodology, making it especially valuable when the Black-Scholes-Merton model is inapplicable, such as in the pricing of path-dependent options.

It is also possible to derive the convergence rate of the method which, thanks to Central Limit Theorem, is \(O(\frac 1{\sqrt{N}})\) where \(N\) is the number of simulated paths. This means that to reduce the error by half, one must increase the number of simulations fourfold.

Quantum strategies for Option Pricing

As next section will discuss, the quantum analogue to the Monte Carlo methodology offers a convergence rate is \(O(\frac 1n)\), providing a quadratic improvement over classical methods. While this speedup may seem modest, it is particularly significant for hedge funds and institutional investors who price large portfolios of options, often overnight. Even a slight improvement in convergence rates in fact can translate into substantial computational time savings, amounting to many hours. The quantum analogue to Monte Carlo methods is, similarly to the classical counterpart, made by three steps:

• representing the probability distribution of the random variable identifying the option's underlying and any other source of uncertainty

• build a circuit that computes the payoff based on the random variable

• compute the expected value of the payoff and discount the result (this can be done classically and I am omitting this part not being particularly complicated).

Encoding the probability distribution in a quantum register

The fist step, loading the distribution of the random variable identifying the option's underlying and any other source of uncertainty (\(X\) from now on), requires a quantum circuit that given the \(\{S_i\}\) asset price and the corresponding probabilities \(\{p_i\} \) (assuming the state space is discretized into \(2^n\) states, where \(n\) is the number of qubits of the register) is able to create the following state:

$$\ket{\psi}n = \sum{i=0}^{2^n-1} \sqrt{p_i} \ket{S_i}$$

The efficiency of encoding a probability distribution into a quantum state depends on the nature of the distribution. It has been demonstrated that log-concave probability distributions, such as the log-normal distribution assumed by the Black-Scholes-Merton model, can be efficiently encoded into a quantum state if the distribution is log-normal. To load states that do not share this property, it is possible to exploit the power of quantum Generative Adversarial Networks (qGAN), which are able to load a distribution in \(O(\text{poly}(n))\) gates rather than \(O(2^n)\) gates. While the details are beyond the scope of this article, it's worth noting that qGANs (quantum Generative Adversarial Networks) are hybrid quantum-classical algorithms. They consist of a classical neural network, known as the discriminator, and a variational quantum circuit, known as the quantum generator. The training process of a qGAN involves alternating optimization of the discriminator's parameters (\(\theta\)) and the generator's parameters (\(\gamma\)). After the training process the output of the process is:

$$\ket{\psi(\gamma)}n= \sum{i=0}^{2^n-1} \sqrt{p_i(\gamma)}\ket{i}_n$$

where \(p_i(\gamma)\) approximates the underlying distribution of the training data.

Computing the payoff

Once the distribution is loaded, we need to compute the payoff function \(f\). Being an option's payoff piecewise linear (depending on whether the option is exercised or not), we only need to consider function of the form:

$$f(i) = f_0 + f_1(i)$$

and by using controlled Y-rotations it is possible to efficiently create the following operator:

$$R: \ket{i}_n\ket{0} \rightarrow \ket{i}_n\otimes(cos[f(i)]\ket{0} + sin[f(i)] \ket{1})$$

which, applied on a register representing a previously encoded distribution, results in:

$$R_\ket{\psi}n= \sum_{i=0}^{2^n-1} \sqrt{(p_i)}\ket{i}_n \otimes (cos[\tilde f(i)]\ket{0} + sin[\tilde f(i)]\ket{1})$$

where \(\tilde f(i) = 2c \frac{f(i) -f_{min}}{f_{max}-f-{min}} - c + \frac \pi 4\), with \(c \in[0, 1]\) and \(f_{min}\) (\(f_{max}\)) is \(\text{min}_if(i) \) (\(\text{max}_if(i)\)).

Consequently, the probability of measuring \(\ket{1}\) in the second register is:

$$P_1 = \sum p_i \space sin^2(\tilde f(i))$$

which can be approximate (with a third grade truncation error) by

$$P_1 \approx \sum p_i (2c \frac{f(i) -f_{min}}{f_{max}-f-{min}}-c + \frac 12) = (2c \frac{E(f(i)) -f_{min}}{f_{max}-f-{min}}-c + \frac 12)$$

all the values are known but \(E(f(i))\). To compute the expected value of the payoff function, a quantum algorithm known as quantum amplitude estimation (QAE) is required.

Quantum amplitude estimation

Quantum amplitude estimation is the algorithm responsible for providing the quadratic speedup compared to classical Monte Carlo methods. Basically, assuming an operator \(A\) s.t.

$$A\ket{0}_{n+1}: \sqrt{1-p}\ket{\psi_0}_n \otimes \ket{0}+ \sqrt{p}\ket{\psi_1}_n \otimes \ket{1}$$

where \(p\) is unknown. QAE aims to estimate \(p\), i.e. the probability of measuring \(\ket{1}\) in the second register.

The idea is to build the operator \(Q\) s.t.

$$Q = AS_0A^\dagger S_{\psi_0}$$

where:

• \(S_0= 1- 2 \ket{0}\bra{0}\)

• \(S_{\psi_0}= 1- 2 \ket{\psi_0}\ket{0}\bra{{\psi_0}}\bra{0}\), representing a rotation of \(2\theta_p\) grades w.r.t. to \(\text{span}(\ket {\psi_0}\ket{0})\)

and it can be shown that \(sin^2(\theta_p) = p\).

Therefore, applying quantum phase estimation (shown in the above picture) on \(m\) sampling qubits, i.e. applying an m-fold Hadamard gate, using the \(m\) qubits to control different powers of \(Q\), applying the inverse Quantum Fourier Transform and measuring the \(m\) qubits' state results in an integer \(k\). Also, there are other formulation of QAE that are more suitable to the NISQ era.

Then \(p\) is estimated as:

$$\hat p = \frac{k\pi}{2^m}$$

and such estimation is s.t. with probability of at least \(\frac 8{\pi^2}\) the following hold

$$|{p - \hat p}| \leq \frac \pi {2^m} - (\frac {\pi}{2^m})^2$$

with a convergence rate of \(O(\frac 1n)\) (while the convergence rate of classical Monte Carlo methods is \(O(\frac 1{\sqrt{N}})\)).

Therefore, applying the operator \(A\) to the state prepared by the qGAN results in:

$$A \ket{\psi}n= \sum{i=0}^{2^n-1} \sqrt{(1 -f(S_i)} \sqrt{p_i}\ket{S_i}n\ket{0} + \sum{i=0}^{2^n-1} \sqrt{f(S_i)} \sqrt{p_i}\ket{S_i}_n\ket{1}$$

and being the probability of measuring \(\ket 1\) (what we called \(p\) before)

$$\sum p_i f(S_i) = E[f(S_i)]$$

it is possible to recover the undiscounted expected value of the option's payoff, which allows to compute

$$P_1 \approx (2c \frac{E(f(i)) -f_{min}}{f_{max}-f-{min}}-c + \frac 12)$$

Pricing Vanilla Options

Therefore, reviewing the entire process for a vanilla option, we have that the payoff function for a call option is \(f_c\) is:

$$f_c(S_T) = max(S_T - K, 0)$$

while for a put the payoff function \(f_p\) is:

$$f_p(S_T) = max(K-S_T, 0)$$

where:

• \(S_T\) is the price at expiration date

• \(K\) is the strike price.

We already discussed hot to represent the linear part of the function, while to implement the \(max(\cdot)\) operator, it is necessary to implement a comparison circuit \(C\) between \(S_T\) and \(K\) (implemented using an ancillary register, Toffoli gates and CNOTs) performing the following transformation

$$C\ket\psi_n\ket 0 = \ket \phi_n = \sum{i < K} \sqrt{p_i}\ket i_n\otimes \ket 0 + \sum_{i \geq K} \sqrt{p_i}\ket i_n \otimes \ket 1$$

To represent the payoff function for use in QAE, another ancillary qubit is required and (for a call vanilla option), we set

$$\tilde f(i) = \begin{cases} g_0 \space \text{if} \space K>i\\ g_0 + g(i)\space \text{if} \space K\leq i\end{cases}$$

where \(g(i)\) is a linear function and \(g_0\) is to be defined.

Doing so we are able to reconstruct the following state:

$$\begin{align} R\ket{\phi}n\ket{0} &= \sum_{i < K} \sqrt{p_i} \ket{i}n \otimes \ket{0} \otimes \left( \cos[g_0]\ket{0} + \sin[g_0]\ket{1} \right) \notag \\ &\quad + \sum_{i \geq K} \sqrt{p_i} \ket{i}_n \otimes \ket{0} \otimes \left( \cos[g_0 + g(i)]\ket{0} + \sin[g_0 + g(i)]\ket{1} \right) \end{align}$$

Using QAE, the probability of measuring \(\ket 1\) in the last qubit is

$$\sum_{i < K} p_i \space sin^2(g_0) + \sum_{i \geq K} p_i \space sin^2(g_0 + g(i))$$

At this point it is necessary to define both \(g_0\) and \(g(i)\). To ensure the following

$$\begin{cases}f(i) = i - K \\ \tilde f(i) = g_0+g(i) \end{cases}$$

we get \(g(i)=\frac{2c (i-K)}{2^n-1 - K}\) and \(g_0 = \frac \pi 4 - c\).

By substitution and approximating as above

$$\begin{align} P_1 & \approx \sum_{i < K} p_i (\frac 12 - c) + \sum_{i \geq K} p_i(\frac 12-c + \frac{2c (i-K)}{2^n-1 - K})\\ &=\frac 12-c + \frac{2c}{2^n-1 - K} \sum_{i \geq K} p_i(i-K) \end{align}$$

which is exactly \(E[f(i)]\) up to a constant and a scaling factor.

Conclusion

While quantum computers and quantum finance are not yet fully realized, and the discussed quantum approaches to option pricing are not fully yet applicable, especially for complex probability distributions, it is possible to simulate these procedures using various software development kits (SDKs). For instance, Qiskit Finance offers comprehensive resources, including resources on pricing various types of options, which I highly recommend.

And that's it for this article. Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Sources:

• Fischer Black and Myron Scholes,“Thepricing of options and corporate liabilities”, Journal of Political Economy 81, 637–654 (1973)

• Robert C. Merton, “Theory of rational optionpricing”, The Bell Journal of Economics and Management Science 4, 141–183 (1973)

• Daniel S Abrams and Colin P Williams, “Fast quantum algorithms for numerical integrals and stochastic processes”, (1999)

• Lov Grover and Terry Rudolph, “Creating superpositions that correspond to efficiently integrable probability distributions”

• Christa Zoufal, Aurélien Lucchi, and Stefan Woerner, “Quantum generative adversarial networks for learning and loading random distributions”, npj Quantum Information 5, 1–9 (2019)

• Gilles Brassard, Peter Hoyer, Michele Mosca, and Alain Tapp, “Quantum Amplitude Amplification and Estimation”, Contemporary Mathematics 305 (2002), 10.1090/conm/305/05215

• Nikitas Stamatopoulos, Daniel J. Egger, Yue Sun, Christa Zoufal, Raban Iten, Ning Shen and Stefan Woerner, "Option Pricing using Quantum Computers" (2019)

Despite the grandiose name, Physics Informed Neural Networks (PINNs from now on) are simply neural networks trained to solve supervised learning tasks while adhering to any provided law of physics described by general nonlinear partial differential equations (PDEs from now on). The resulting neural network acts as a universal function approximator that inherently incorporates any underlying physical laws as prior knowledge, making them suitable for solving PDEs.

This not only signifies a stark departure from traditional numerical methods (such as finite difference, finite volume, finite elements, etc.) but also marks a shift in how we approach modeling and understanding physical systems. In fact, unlike conventional numerical techniques that depend on discretization and iterative solvers, PINNs offer a more comprehensive and data-centric approach and, by combining the capabilities of neural networks with the principles of physical laws, PINNs hold the potential to open up new pathways for exploration and innovation across various scientific fields.

In this blog post, my goal is to discuss all the essential components required to address PINNs for PDEs. Therefore, the post is composed of 4 key parts:

• Firstly, I introduce PDEs and explain the necessity of relying on numerical methods;

• Secondly, I provide a brief overview of neural networks;

• Next, I delve into discussing PINNs;

• Finally, I demonstrate how to implement PINNs using PyTorch.

About Partial Differential Equations (PDEs)

PDEs serve as fundamental tools in describing physical phenomena and natural processes across various scientific domains, from physics and engineering to biology and finance. Unlike ordinary differential equations (ODEs), which involve only one independent variable, PDEs incorporate multiple independent variables, such as space and time. For example

$$\frac{\delta f}{\delta t}+\alpha \frac{\delta f}{\delta x}=0$$

is known as the advection equation, where:

• \(f(t,x)\) is a function of two independent variables \(x\) (space) and \(t\) (time);

• \(\alpha\) is a constant;

• \(\frac{\delta f}{\delta t}\) represents the rate of change of \(f\) with respect to time;

• \(\frac{\delta f}{\delta x}\)represents the rate of change of \(f\) with respect to space.

Physically, this equation describes how a quantity \(f\) evolves over time \(t\) as it is transported by a flow with constant speed \(\alpha\) in the \(x\)-direction. In other words, it describes how \(f\) moves along the \(x\)-axis with time, where the rate of change in time is proportional to the rate of change in space multiplied by the constant \(\alpha\).

A closed form general solution to the advection function can be derived and corresponds to:

$$f(t,x)=g(x-at)$$

for any differentiable function \(g(\cdot)\).

Not every PDE however admits a closed-form solution due to several reasons:

• Complexity: many PDEs describe highly intricate physical phenomena with nonlinear behavior, making it difficult to find analytical solutions. Nonlinear PDEs, in particular, often lack closed-form solutions because of their intricate interdependence between variables;

• Boundary conditions: solution to a PDE often depends not only on the equation itself but also on the boundary and initial conditions. If these conditions are complex or not well-defined, finding a closed-form solution becomes exceedingly challenging;

• Non-standard formulation: some PDEs might be in non-standard forms that don't lend themselves easily to analytical techniques. For example, PDEs with non-constant coefficients or with terms involving higher-order derivatives may not have straightforward analytical solutions.

• Inherent nature of the problem: certain systems are inherently chaotic or exhibit behaviors that resist simple mathematical description. For such systems, closed-form solutions may not exist, or if they do, they might be highly unstable or impractical.

For all the reasons mentioned, scientists usually depend on numerical methods to estimate the solution to PDEs (like PINNs, finite elements, finite volume, finite difference, and spectral method). In this post, I am only covering PINNs, while another post about other methods is on its way.

About neural networks

Once the problem that PINNs aim to solve is clear, we will now discuss some essential topics about neural networks. Since this is a very broad subject, I will only cover the most important aspects.

Neural networks are algorithms inspired by the workings of the human brain. In our brains, neurons process incoming data, such as visual information from our eyes, to recognize and understand our surroundings. Similarly, neural networks operate by receiving input data (input layer), processing it to identify patterns (hidden layer), and producing an output based on this analysis (output layer). Therefore, a neural network is typically represented as shown in the following picture:

The basic unit of computation in a neural network is the neuron. It receives input from other nodes or an external source and calculates an output. Each input is linked with a weight (w, which the network learns), and every neuron has a unique input known as the bias (b), which is always set to 1. The output from the neuron is calculated as the weighted sum of the inputs, which is then sent to the activation function (introducing non-linearity into the output).

That said, a neural network comprises multiple interconnected neurons. While various architectures are tailored for specific issues, we will now concentrate on basic neural networks, also referred to as Feedforward neural networks (FNN).

Learning in neural networks

What is learnable in a neural networks are the weights and the bias and the learning process is divided in two parts:

• feed forward propogation;

• backward propogation.

In fact, learning occurs by adjusting connection weights after processing each piece of data, depending on the error in the output compared to the expected result.

Feedforward propagation

Feedforward propagation is the foundational process in neural networks where input data is processed through the layers to produce an output. This process is crucial for making predictions or classifications based on the given input. In feedforward propagation:

• the flows in a unidirectional manner from the input layer through the hidden layers (if any) to the output layer;

• each neuron in a layer receives inputs from all neurons in the previous layer. The inputs are combined with weights and a bias term, and the result is passed through an activation function to produce the neuron's output;

• this process is repeated for each layer until the output layer is reached.

Backward propagation

Backward propagation, also known as backpropagation, is the process by which a neural network learns from its mistakes and adjusts its parameters (weights and biases) to minimize the difference between its predictions and the true targets. In backward propagation:

• after the output is generated through feedforward propagation, the network's performance is evaluated using a loss function, which measures the difference between the predicted output and the true target values;

• the gradient of the loss function with respect to each parameter (weight and bias) in the network is computed using the chain rule of calculus. This gradient indicates the direction and magnitude of the change needed to minimize the loss function;

• the gradients are then used to update the parameters of the network in the opposite direction of the gradient, a process known as gradient descent. This update step involves adjusting the parameters by a small amount proportional to the gradient and a learning rate hyperparameter.

Neural networks as universal function approximators

Pivotal to Physics-Informed Neural Networks (PINNs) is a crucial theoretical concept concerning neural networks: their capability as universal function approximators. This fundamental property implies that neural networks can effectively approximate any continuous function with remarkable precision, given a sufficient number of neurons and an appropriate network configuration. Considering that the goal of PINNs is to estimate the solution to a Partial Differential Equation (PDE), which essentially involves approximating a function, this characteristic holds immense significance for the success and efficacy of PINNs in their predictive tasks.

About physics informed neural networks (PINNs)

Once the basics of deep learning are clear, we can delve deeper into understanding Physics Informed Neural Networks (PINNs).

Physics Informed Neural Networks (PINNs) serve as universal function approximators, with their neural network architecture representing solutions to specific Partial Differential Equations (PDEs). The core concept behind PINNs, as implied by their name, involves integrating prior knowledge about the system's dynamics into the cost function. This integration allows for penalizing any deviations from the governing PDEs by the network's solution.

Moreover, PINNs necessitate addressing the differences between the network's predictions and the actual data points within the cost function. This process is crucial for refining the network's accuracy and ensuring that it aligns closely with the observed data, thereby enhancing the model's predictive capabilities.

Therefore the loss function is:

$$\text{total loss} = \text{data loss + physics loss}$$

and (once a norm \(|\cdot|\) is chosen) becomes:

$$\text{total loss} = \frac1n\sum |y_i - \hat y(x_i|\theta)| + \frac \lambda m\sum |f(x_j, \hat y(x_j|\theta))|$$

where:

• \(\hat y(x| \theta) \) is our neural network;

• \(x_i \text{ and } y_i\) are the data;

• \(f(x, g)=0\) is the PDE;

• \(\lambda\) is an hyperparameter.

and is equivalent to means squared error (MSE) when the chosen norm is the squared L2 norm.

Once we have this, we can train our PINN as a regular neural network.

A comparison between PINNs and classical methods

Compared to the traditional numerical simulation approaches, PINNs have the following desiderable properties:

• PINNs are mesh-free, i..e they can handle complex domains, with a potential computational advantage;

• PINNs are well-suited for modeling complex and nonlinear systems, because of the universa approximation theorem.

PyTorch implementation

This final section focuses on a PyTorch example to apply the theory in practice.

While this blog post mainly discussed PDEs, before approximating a PDE with a PINN, I aim to approximate an ODE using a PINN.

Approximating an ODE using a PINN: the logistic equation

The logistic equation is a differential equation used to model population growth in situations where resources are limited. It is often represented as:

$$\frac{dP}{dt} = rP\left(1 - \frac{P}{K}\right)$$

where:

• \(P\) represents the population size at time \(t\);

• \(r\) is the intrinsic growth rate of the population;

• \(K\) is the carrying capacity of the environment, representing the maximum population size that the environment can sustain.

The analytical solution to the logistic equation is given by the logistic function:

$$P(t) = \frac{K}{1 + \left(\frac{K-P_0}{P_0}e^{-rt}\right)}$$

First of all we need a neural network architecture:

# code from https://github.com/EdgarAMO/PINN-Burgers/blob/main/burgers_LBFGS.py

import torch
import torch.nn as nn
import numpy as np
from random import uniform

class PhysicsInformedNN():
    def __init__(self, X_u, u, X_f):
        # x & t from boundary conditions:
        self.x_u = torch.tensor(X_u[:, 0].reshape(-1, 1),
                                dtype=torch.float32,
                                requires_grad=True)
        self.t_u = torch.tensor(X_u[:, 1].reshape(-1, 1),
                                dtype=torch.float32,
                                requires_grad=True)

        # x & t from collocation points:
        self.x_f = torch.tensor(X_f[:, 0].reshape(-1, 1),
                                dtype=torch.float32,
                                requires_grad=True)
        self.t_f = torch.tensor(X_f[:, 1].reshape(-1, 1),
                                dtype=torch.float32,
                                requires_grad=True)

        # boundary solution:
        self.u = torch.tensor(u, dtype=torch.float32)

        # null vector to test against f:
        self.null =  torch.zeros((self.x_f.shape[0], 1))

        # initialize net:
        self.create_net()
        #self.net.apply(self.init_weights)

        # this optimizer updates the weights and biases of the net:
        self.optimizer = torch.optim.LBFGS(self.net.parameters(),
                                    lr=1,
                                    max_iter=50000,
                                    max_eval=50000,
                                    history_size=50,
                                    tolerance_grad=1e-05,
                                    tolerance_change=0.5 * np.finfo(float).eps,
                                    line_search_fn="strong_wolfe")

        # typical MSE loss (this is a function):
        self.loss = nn.MSELoss()

        # loss :
        self.ls = 0

        # iteration number:
        self.iter = 0

    def create_net(self):
        """ net takes a batch of two inputs: (n, 2) --> (n, 1) """
        self.net = nn.Sequential(
            nn.Linear(2, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 20), nn.Tanh(),
            nn.Linear(20, 1))

    def init_weights(self, m):
        if type(m) == nn.Linear:
            torch.nn.init.xavier_normal_(m.weight, 0.1)
            m.bias.data.fill_(0.001)

    def net_u(self, x, t):
        u = self.net( torch.hstack((x, t)) )
        return u

    def net_f(self, x, t):
        u = self.net_u(x, t)

        u_t = torch.autograd.grad(
            u, t, 
            grad_outputs=torch.ones_like(u),
            retain_graph=True,
            create_graph=True)[0]

        u_x = torch.autograd.grad(
            u, x, 
            grad_outputs=torch.ones_like(u),
            retain_graph=True,
            create_graph=True)[0]

        u_xx = torch.autograd.grad(
            u_x, x, 
            grad_outputs=torch.ones_like(u_x),
            retain_graph=True,
            create_graph=True)[0]

        f = u_t + (u * u_x) - (nu * u_xx)

        return f

    def plot(self):
        """ plot the solution on new data """

        import matplotlib.pyplot as plt
        from mpl_toolkits.axes_grid1 import make_axes_locatable

        x = torch.linspace(-1, 1, 200)
        t = torch.linspace( 0, 1, 100)

        # x & t grids:
        X, T = torch.meshgrid(x, t)

        # x & t columns:
        xcol = X.reshape(-1, 1)
        tcol = T.reshape(-1, 1)

        # one large column:
        usol = self.net_u(xcol, tcol)

        # reshape solution:
        U = usol.reshape(x.numel(), t.numel())

        # transform to numpy:
        xnp = x.numpy()
        tnp = t.numpy()
        Unp = U.detach().numpy()

        # plot:
        fig = plt.figure(figsize=(9, 4.5))
        ax = fig.add_subplot(111)

        h = ax.imshow(Unp,
                      interpolation='nearest',
                      cmap='rainbow', 
                      extent=[tnp.min(), tnp.max(), xnp.min(), xnp.max()], 
                      origin='lower', aspect='auto')
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.10)
        cbar = fig.colorbar(h, cax=cax)
        cbar.ax.tick_params(labelsize=10)
        plt.show()

    def closure(self):
        # reset gradients to zero:
        self.optimizer.zero_grad()

        # u & f predictions:
        u_prediction = self.net_u(self.x_u, self.t_u)
        f_prediction = self.net_f(self.x_f, self.t_f)

        # losses:
        u_loss = self.loss(u_prediction, self.u)
        f_loss = self.loss(f_prediction, self.null)
        self.ls = u_loss + f_loss

        # derivative with respect to net's weights:
        self.ls.backward()

        # increase iteration count:
        self.iter += 1

        # print report:
        if not self.iter % 100:
            print('Epoch: {0:}, Loss: {1:6.3f}'.format(self.iter, self.ls))

        return self.ls

    def train(self):
        """ training loop """
        self.net.train()
        self.optimizer.step(self.closure)

if __name__ == '__main__' :

    nu = 0.01 / np.pi         # constant in the diff. equation
    N_u = 100                 # number of data points in the boundaries
    N_f = 10000               # number of collocation points

    # X_u_train: a set of pairs (x, t) located at:
        # x =  1, t = [0,  1]
        # x = -1, t = [0,  1]
        # t =  0, x = [-1, 1]
    x_upper = np.ones((N_u//4, 1), dtype=float)
    x_lower = np.ones((N_u//4, 1), dtype=float) * (-1)
    t_zero = np.zeros((N_u//2, 1), dtype=float)

    t_upper = np.random.rand(N_u//4, 1)
    t_lower = np.random.rand(N_u//4, 1)
    x_zero = (-1) + np.random.rand(N_u//2, 1) * (1 - (-1))

    # stack uppers, lowers and zeros:
    X_upper = np.hstack( (x_upper, t_upper) )
    X_lower = np.hstack( (x_lower, t_lower) )
    X_zero = np.hstack( (x_zero, t_zero) )

    # each one of these three arrays haS 2 columns, 
    # now we stack them vertically, the resulting array will also have 2 
    # columns and 100 rows:
    X_u_train = np.vstack( (X_upper, X_lower, X_zero) )

    # shuffle X_u_train:
    index = np.arange(0, N_u)
    np.random.shuffle(index)
    X_u_train = X_u_train[index, :]

    # make X_f_train:
    X_f_train = np.zeros((N_f, 2), dtype=float)
    for row in range(N_f):
        x = uniform(-1, 1)  # x range
        t = uniform( 0, 1)  # t range

        X_f_train[row, 0] = x 
        X_f_train[row, 1] = t

    # add the boundary points to the collocation points:
    X_f_train = np.vstack( (X_f_train, X_u_train) )

    # make u_train
    u_upper =  np.zeros((N_u//4, 1), dtype=float)
    u_lower =  np.zeros((N_u//4, 1), dtype=float) 
    u_zero = -np.sin(np.pi * x_zero)  

    # stack them in the same order as X_u_train was stacked:
    u_train = np.vstack( (u_upper, u_lower, u_zero) )

    # match indices with X_u_train
    u_train = u_train[index, :]

    # pass data sets to the PINN:
    pinn = PhysicsInformedNN(X_u_train, u_train, X_f_train)

    pinn.train()

Then we can build our loss function and define our ODE:

from typing import Callable
import argparse

import matplotlib.pyplot as plt
import torch
from torch import nn
import numpy as np
import torchopt

from pinn import make_forward_fn, LinearNN


R = 1.0  # rate of maximum population growth parameterizing the equation
X_BOUNDARY = 0.0  # boundary condition coordinate
F_BOUNDARY = 0.5  # boundary condition value


def make_loss_fn(f: Callable, dfdx: Callable) -> Callable:
    """Make a function loss evaluation function

    The loss is computed as sum of the interior MSE loss (the differential equation residual)
    and the MSE of the loss at the boundary

    Args:
        f (Callable): The functional forward pass of the model used a universal function approximator. This
            is a function with signature (x, params) where `x` is the input data and `params` the model
            parameters
        dfdx (Callable): The functional gradient calculation of the universal function approximator. This
            is a function with signature (x, params) where `x` is the input data and `params` the model
            parameters

    Returns:
        Callable: The loss function with signature (params, x) where `x` is the input data and `params` the model
            parameters. Notice that a simple call to `dloss = functorch.grad(loss_fn)` would give the gradient
            of the loss with respect to the model parameters needed by the optimizers
    """

    def loss_fn(params: torch.Tensor, x: torch.Tensor):

        # interior loss
        f_value = f(x, params)
        interior = dfdx(x, params) - R * f_value * (1 - f_value)

        # boundary loss
        x0 = X_BOUNDARY
        f0 = F_BOUNDARY
        x_boundary = torch.tensor([x0])
        f_boundary = torch.tensor([f0])
        boundary = f(x_boundary, params) - f_boundary

        loss = nn.MSELoss()
        loss_value = loss(interior, torch.zeros_like(interior)) + loss(
            boundary, torch.zeros_like(boundary)
        )

        return loss_value

    return loss_fn


if __name__ == "__main__":

    # make it reproducible
    torch.manual_seed(42)

    # parse input from user
    parser = argparse.ArgumentParser()

    parser.add_argument("-n", "--num-hidden", type=int, default=5)
    parser.add_argument("-d", "--dim-hidden", type=int, default=5)
    parser.add_argument("-b", "--batch-size", type=int, default=30)
    parser.add_argument("-lr", "--learning-rate", type=float, default=1e-1)
    parser.add_argument("-e", "--num-epochs", type=int, default=100)

    args = parser.parse_args()

    # configuration
    num_hidden = args.num_hidden
    dim_hidden = args.dim_hidden
    batch_size = args.batch_size
    num_iter = args.num_epochs
    tolerance = 1e-8
    learning_rate = args.learning_rate
    domain = (-5.0, 5.0)

    # function versions of model forward, gradient and loss
    model = LinearNN(num_layers=num_hidden, num_neurons=dim_hidden, num_inputs=1)
    funcs = make_forward_fn(model, derivative_order=1)

    f = funcs[0]
    dfdx = funcs[1]
    loss_fn = make_loss_fn(f, dfdx)

    # choose optimizer with functional API using functorch
    optimizer = torchopt.FuncOptimizer(torchopt.adam(lr=learning_rate))

    # initial parameters randomly initialized
    params = tuple(model.parameters())

    # train the model
    loss_evolution = []
    for i in range(num_iter):

        # sample points in the domain randomly for each epoch
        x = torch.FloatTensor(batch_size).uniform_(domain[0], domain[1])

        # compute the loss with the current parameters
        loss = loss_fn(params, x)

        # update the parameters with functional optimizer
        params = optimizer.step(loss, params)

        print(f"Iteration {i} with loss {float(loss)}")
        loss_evolution.append(float(loss))

    # plot solution on the given domain
    x_eval = torch.linspace(domain[0], domain[1], steps=100).reshape(-1, 1)
    f_eval = f(x_eval, params)
    analytical_sol_fn = lambda x: 1.0 / (1.0 + (1.0/F_BOUNDARY - 1.0) * np.exp(-R * x))
    x_eval_np = x_eval.detach().numpy()
    x_sample_np = torch.FloatTensor(batch_size).uniform_(domain[0], domain[1]).detach().numpy()

    fig, ax = plt.subplots()

    ax.scatter(x_sample_np, analytical_sol_fn(x_sample_np), color="red", label="Sample training points")
    ax.plot(x_eval_np, f_eval.detach().numpy(), label="PINN final solution")
    ax.plot(
        x_eval_np,
        analytical_sol_fn(x_eval_np),
        label=f"Analytic solution",
        color="green",
        alpha=0.75,
    )
    ax.set(title="Logistic equation solved with PINNs", xlabel="t", ylabel="f(t)")
    ax.legend()

    fig, ax = plt.subplots()
    ax.semilogy(loss_evolution)
    ax.set(title="Loss evolution", xlabel="# epochs", ylabel="Loss")
    ax.legend()

    plt.show()

And this is the result:

Approximating a PDE using a PINN: the heat equation

The heat equation is a classical partial differential equation that describes the diffusion of heat (or equivalently, the distribution of temperature) in a given region over time. The one-dimensional form of the heat equation is given by:

$$\frac{\partial u}{\partial t} = \alpha \frac{\partial^2 u}{\partial x^2}$$

Again, we implement the PINN:

# code from https://github.com/udemirezen/PINN-1/blob/main/solve_PDE_NN.ipynb

import torch
import torch.nn as nn
from torch.autograd import Variable
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
import numpy as np

# We consider Net as our solution u_theta(x,t)

"""
When forming the network, we have to keep in mind the number of inputs and outputs
In ur case: #inputs = 2 (x,t)
and #outputs = 1

You can add ass many hidden layers as you want with as many neurons.
More complex the network, the more prepared it is to find complex solutions, but it also requires more data.

Let us create this network:
min 5 hidden layer with 5 neurons each.
"""

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden_layer1 = nn.Linear(2,5)
        self.hidden_layer2 = nn.Linear(5,5)
        self.hidden_layer3 = nn.Linear(5,5)
        self.hidden_layer4 = nn.Linear(5,5)
        self.hidden_layer5 = nn.Linear(5,5)
        self.output_layer = nn.Linear(5,1)

    def forward(self, x,t):
        inputs = torch.cat([x,t],axis=1) # combined two arrays of 1 columns each to one array of 2 columns
        layer1_out = torch.sigmoid(self.hidden_layer1(inputs))
        layer2_out = torch.sigmoid(self.hidden_layer2(layer1_out))
        layer3_out = torch.sigmoid(self.hidden_layer3(layer2_out))
        layer4_out = torch.sigmoid(self.hidden_layer4(layer3_out))
        layer5_out = torch.sigmoid(self.hidden_layer5(layer4_out))
        output = self.output_layer(layer5_out) ## For regression, no activation is used in output layer
        return output
### (2) Model
net = Net()
net = net.to(device)
mse_cost_function = torch.nn.MSELoss() # Mean squared error
optimizer = torch.optim.Adam(net.parameters())
## PDE as loss function. Thus would use the network which we call as u_theta
def f(x,t, net):
    u = net(x,t) # the dependent variable u is given by the network based on independent variables x,t
    ## Based on our f = du/dx - 2du/dt - u, we need du/dx and du/dt
    u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]
    u_t = torch.autograd.grad(u.sum(), t, create_graph=True)[0]
    pde = u_x - 2*u_t - u
    return pde
## Data from Boundary Conditions
# u(x,0)=6e^(-3x)
## BC just gives us datapoints for training

# BC tells us that for any x in range[0,2] and time=0, the value of u is given by 6e^(-3x)
# Take say 500 random numbers of x
x_bc = np.random.uniform(low=0.0, high=2.0, size=(500,1))
t_bc = np.zeros((500,1))
# compute u based on BC
u_bc = 6*np.exp(-3*x_bc)
### (3) Training / Fitting
iterations = 20000
previous_validation_loss = 99999999.0
for epoch in range(iterations):
    optimizer.zero_grad() # to make the gradients zero

    # Loss based on boundary conditions
    pt_x_bc = Variable(torch.from_numpy(x_bc).float(), requires_grad=False).to(device)
    pt_t_bc = Variable(torch.from_numpy(t_bc).float(), requires_grad=False).to(device)
    pt_u_bc = Variable(torch.from_numpy(u_bc).float(), requires_grad=False).to(device)

    net_bc_out = net(pt_x_bc, pt_t_bc) # output of u(x,t)
    mse_u = mse_cost_function(net_bc_out, pt_u_bc)

    # Loss based on PDE
    x_collocation = np.random.uniform(low=0.0, high=2.0, size=(500,1))
    t_collocation = np.random.uniform(low=0.0, high=1.0, size=(500,1))
    all_zeros = np.zeros((500,1))


    pt_x_collocation = Variable(torch.from_numpy(x_collocation).float(), requires_grad=True).to(device)
    pt_t_collocation = Variable(torch.from_numpy(t_collocation).float(), requires_grad=True).to(device)
    pt_all_zeros = Variable(torch.from_numpy(all_zeros).float(), requires_grad=False).to(device)

    f_out = f(pt_x_collocation, pt_t_collocation, net) # output of f(x,t)
    mse_f = mse_cost_function(f_out, pt_all_zeros)

    # Combining the loss functions
    loss = mse_u + mse_f


    loss.backward() # This is for computing gradients using backward propagation
    optimizer.step() # This is equivalent to : theta_new = theta_old - alpha * derivative of J w.r.t theta

    with torch.autograd.no_grad():
        print(epoch,"Traning Loss:",loss.data)

and then plot the result:

from mpl_toolkits.mplot3d import Axes3D
Axes3D = Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import numpy as np

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x=np.arange(0,2,0.02)
t=np.arange(0,1,0.02)
ms_x, ms_t = np.meshgrid(x, t)
## Just because meshgrid is used, we need to do the following adjustment
x = np.ravel(ms_x).reshape(-1,1)
t = np.ravel(ms_t).reshape(-1,1)

pt_x = Variable(torch.from_numpy(x).float(), requires_grad=True).to(device)
pt_t = Variable(torch.from_numpy(t).float(), requires_grad=True).to(device)
pt_u = net(pt_x,pt_t)
u=pt_u.data.cpu().numpy()
ms_u = u.reshape(ms_x.shape)

surf = ax.plot_surface(ms_x,ms_t,ms_u, cmap=cm.coolwarm,linewidth=0, antialiased=False)

ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))

fig.colorbar(surf, shrink=0.5, aspect=5)

plt.show()

which returns the following:

And that's it for this article. Thanks for reading. If you have any suggestions for improvement or any further insights to share, please don't hesitate to reach out and leave a comment below. Your feedback is invaluable and greatly appreciated.

Reference

• https://link.springer.com/content/pdf/10.1007/s10915-022-01939-z.pdf

• https://acnpsearch.unibo.it/OpenURL?id=tisearch%3Ati-ex&sid=google&rft.auinit=S&rft.aulast=Cuomo&rft.atitle=Scientific+machine+learning+through+physics%E2%80%93informed+neural+networks%3A+Where+we+are+and+what%E2%80%99s+next&rft.title=Journal+of+scientific+computing+%28Dordrecht.+Online%29&rft.volume=92&rft.issue=3&rft.date=2022&rft.spage=88&rft.issn=1573-7691

Blockchain technology, epitomized by cryptocurrencies like Bitcoin and Ethereum, has redefined trust in digital transactions. Its decentralized ledger system offers immutable records, resistant to tampering and censorship, transforming industries beyond finance. Meanwhile, quantum computing, leveraging quantum mechanics, offers exponential computational power, poised to tackle problems deemed infeasible by classical computers.

While the two technologies seems unrelated, a profound connection exists between quantum computing and blockchain and this blog post intoduces you to quantum blockchain after a brief digression on fundamental concepts of quantum computing and quantum cryptography.

Quantum computing

As you may know all the information a computer store and process are just interminable strings of 0s and 1s, the so-called bits. Quantum computing is a completely different computational paradigm, relying on quantum bits (also called qubits), which can exist in a superposition of states, enabling them to represent both 0 and 1 simultaneously.

While this may seems a logical contraddiction, according to postulates of quantum mechanics, the state of a system is described as a linear combination of all possible states until measured, when the state collapse and is deterministically defined. This superposition property allows qubits to hold exponentially more information than classical bits. Furthermore, qubits can exhibit another peculiar quantum behavior called entanglement, where the state of one qubit becomes correlated with the state of another qubit. The third ingredient that makes a quantum computer faster than a classical one is quantum interference. Quantum interference occurs when the probability amplitudes of different quantum states interfere constructively or destructively, resulting in the amplification or reduction of certain outcomes. In quantum computing, this interference allows for the manipulation and processing of information in a highly efficient manner.

These phenomena enables quantum computers to outperform classical computers in solving certain types of problems, particularly those that require extensive exploration of solution spaces. Thus, superposition, entanglement, and quantum interference collectively contribute to the computational power and speed of quantum computers, offering the potential for revolutionary advancements in various fields of science and technology.

Quantum cryptography

One of the most fascinating and more important application of quantum technologies lies in quantum cryptography, a subset of quantum information science, that aims to utilize the principles of quantum mechanics to secure communication channels in a fundamentally different way than classical cryptographic methods.

In fact traditional cryptographic techniques rely on mathematical complexity, such as factorization or discrete logarithm problems, for securing data transmission. The idea here is to consider a problem that may take ages to a classical computer to solve due to its complexity and use this difficulty as the basis for encryption. Obviously having more and more powerful computers poses a threat to the security of these classical encryption methods. Moreover quantum computers will be able to efficiently solve these mathematical problems using algorithms like Shor's algorithm, rendering traditional encryption schemes obsolete.

Quantum cryptography, on the other hand, offers a solution that is fundamentally secure, regardless of the computational power of the adversary. By exploiting the properties of quantum mechanics, such as the superposition and entanglement of quantum states, quantum cryptography provides a means for two parties to communicate with absolute secrecy. Quantum Key Distribution (QKD), one of the most prominent applications of quantum cryptography, allows two parties to share a secret cryptographic key with the assurance that any attempt to intercept the key will be detected. This is achieved through the use of quantum states to encode the key information, making it impossible for an eavesdropper to gain knowledge of the key without disturbing the quantum states and revealing their presence.

As such, quantum cryptography offers a level of security that is unparalleled by classical cryptographic methods, making it an essential tool for ensuring the confidentiality and integrity of sensitive information in the digital age.

Quantum money

Before diving into quantum blockchain here I want to discuss another intriguing application of quantum technologies, somehow related to the blockchain and the cryptocurrencies: quantum money.

The concept of quantum money traces back to the early days of quantum information theory and cryptography, with theoretical proposals emerging in the 1970s and gaining momentum in subsequent decades. One of the pioneering works in this field was proposed by physicist Stephen Wiesner which was published in a scientific journal in 1983.

Wiesner's idea involved using quantum states to encode information on banknotes, making them effectively unforgeable due to the inherent properties of quantum mechanics. Specifically, Wiesner proposed a scheme where each banknote would contain a unique quantum state, which could not be precisely duplicated or measured without disturbing its state. This would make counterfeiting quantum money practically impossible, as any attempt to copy or measure the quantum state would inevitably alter it, thus revealing the counterfeit attempt.

Despite the theoretical appeal of Wiesner's proposal, the practical implementation of quantum money remains a significant challenge. Generating and manipulating quantum states with the precision and reliability required for quantum money presents formidable technical hurdles. Additionally, quantum systems are inherently fragile and susceptible to environmental noise, which could compromise the security of quantum money schemes.

Therefore, similarly to cryptocurrencies, quantum money seeks to provide an unforgeable form of currency by exploiting the fundamental principles of quantum mechanics.

Quantum blockchain

As you may already know, a blockchain functions as an immutable ledger where data is stored in the form of transactions, interconnected through a Merkle tree, and organized into blocks linked by hash functions. This network operates in a decentralized manner, with each node retaining a copy of the growing chain of blocks. Consensus protocols determine the addition of new blocks and establish agreement on the block sequence. Typically, the blockchain process begins with users broadcasting transactions, which are then verified and organized into a new block according to specific consensus rules, such as proof-of-work or proof-of-stake. Participants, often referred to as "miners" in systems like Bitcoin, compete to create the next block, with the successful miner being rewarded. The longest chain of blocks is considered definitive, providing a basis for consensus.

One of the main features of blockchain is that if any block within the chain is altered, it invalidates all subsequent blocks. Consequently, nodes in the blockchain network reject the tampered version and continue to work on the version supported by the majority.

Moreover access control in blockchains relies on public-key cryptography, where users safeguard private keys as passwords and use public keys as account identifiers. Transactions are authenticated using signatures generated with private keys, which are verified by network nodes against the corresponding public keys. Once you are familiar with the above information, you are ready to explore quantum blockchains.

Quantum blockchain typically refers to a variety of protocols, including classical blockchains with quantum-resistant cryptography, hybrid blockchains leveraging Quantum Key Distribution networks (just hybrid blockchains from now on), and fully quantum blockchains operating in the realm of quantum computing.

Hybrid blockchains aim to tackle the fact that public-key cryptography is not quantum resistant (we already mentioned Shor’s algorithm), therefore substitutig publik-key cryptography with the already mentioned Quantum Key Distribution.

Quantum blockchains on the other hand are more variegate and substitute some core block of a classical blockchain with a quantum counterpart. For example, Rajan, D., & Visser, M. (2019), whose quantum blockchain is regarded as a pioneering theoretical work, replaces the functionality of time-stamped blocks and hash functions linking them with a temporal entangled state, which offers a fairly interesting advantage: since the sensitivity towards tampering is significantly amplified, meaning that the full local copy of the blockchain is destroyed if one tampers with a single block (due to entanglement) while on a classical blockchain only the blocks following the compromised block are changed , which leaves it open to vulnerabilities. However let's dive a little more in the formulation of both the blockchain and the network as proposed in Rajan, D., & Visser, M. (2019).

Blockchain

This subsection explores the implementation of a quantum version of a block and a blockchain, utilizing temporally entangled states (a concept in quantum mechanics where the quantum states of multiple particles become correlated over time, rather than in space).

Entanglement, essentially the inseparability of distinct states, forms the basis for capturing the chain-like structure. Consequently, the blockchain can be viewed as an entangled quantum state, with a block's timestamp emerging from the immediate absorption of the first qubit of a block.

Constructing the blockchain from a series of entangled states involves amalgamating the blocks into a specialized entangled state known as a Greenberger–Horne–Zeilinger (GHZ) state.

Network

After establishing the blockchain, additional components are necessary for a functional blockchain system, notably a protocol for disseminating the blockchain's state to all network nodes. Since the blockchain's state is quantum in nature, a quantum channel must replace the classical one, with digital signatures implemented through Quantum Key Distribution (QKD) protocols.

Similar to classical blockchain systems, each node in a quantum blockchain setup must possess a copy of the blockchain, and new blocks must undergo verification before integration into each node's blockchain.

Conclusion

Quantum blockchain is still an area of research and is an author’s opinion that, given the rise of classical blockchains and the realistic development of a global quantum network, quantum blockchain can potentially open the door to a new research frontier in quantum information science as well as new business possibilities.

Thanks for reading. This article does not want to be exhaustive on the topic and is no more than an introduction to quantum blockchain. To go further there are resources online and the source section below is a good starting point.

Sources:

• Weisner, S. (1983) Conjugate Coding. ACM SIGACT News, 15, 78-88

• Rajan, D., & Visser, M. (2019)

• Ringbauer, M.; Costa, F.; Goggin, M.E.; White, A.G.; Fedrizzi, A. Multi-time quantum correlations with no spatial analog’. NPJ Quantum Inf. 2018, 4 , 37.

The reason for this difficulty is that the calculations must be deterministic in order to be replayed in a decentralized manner, and any data that can serve as random sources is also available to an attacker.

In this article, I'll review the solutions that blockchain engineers have developed in the past to address this problem and their weaknesses and conclude with the simplest and most commonly used method currently available.

Pseudo-randomness from unknowable at the time of transacting information

One of the first sources of entropy that blockchain engineers used was the block timestamp, a global variable that represents the timestamp of the current block in which the contract is executed. This timestamp is a Unix timestamp that indicates the number of seconds that have elapsed since January 1, 1970 (UTC) and provides information about when the block was mined.

The problem with block timestamps is that miners have the ability to influence them as long as the timestamp doesn't precede that of the parent block. Although timestamps are usually quite accurate, there is a potential problem if a miner benefits from inaccurate timestamps. In such cases, the miner could use his mining power to create blocks with incorrect timestamps and thus manipulate the results of the random function to his advantage.

For example, imagine a lottery in which a random bidder is selected from a set of bidders by a function that uses the timestamp of a block as the source of the randomness: a miner may enter the lottery and then modify the timestamp value to increase his chances of winning.

While these attacks may sound anachronistic, they are not beyond the realm of possibility. In fact, Feathercoin was the victim of a time-warp attack in 2013. In it, a group of miners exploited a vulnerability in Feathercoin's mining algorithm that allowed them to manipulate the timestamps of blocks, resulting in the rapid creation of new blocks. The attack undeniably caused significant damage to Feathercoin's value and reputation.

Still, one might think that using the block hash as a source of entropy or other block information that is generally unknown at the time of the transaction is a good idea. However, similar implementations have a major problem: they rely on publicly available information, which means that malicious actors can increase the probability of winning the lottery with an attack similar to the time-warp attack. This is because these quantities can be read and manipulated by any other transaction within the same mining block if the attacker is also a miner.

Even using a sophisticated combination of all information unknown at the time of the transaction is not a good idea: it makes the attack much more difficult, but does not make the protocol as secure as other methods do.

Randomness from off-chain data: oracles and APIs

I hope you have been convinced that using on-chain information is not a good practice when security is a crucial feature. What can we do to get an unpredictable random number for our lottery?

We can turn our attention to off-chain data, i.e. use the data that an API or oracle provides. For example, if we have an API that provides the temperature in a particular city, we can use it to calculate the remainder when dividing the number of tipsters and use the result as a random number. The temperature in a particular city changes frequently, and if the API's answer is updated frequently, the likelihood of a malicious agent guessing the number is very low.

Although this is a better solution than using on-chain data, it is not the best available because we centralize our random source and the smart contract is useless if the API is corrupted.

Moreover, no one would trust the lottery contract, since it can be assumed that the API is programmed to always return the same set of values and the protocol is no longer trustless.

Despite these drawbacks, oracles and APIs have been widely used to obtain data outside the chain, and are sometimes still used. It's worth noting that combining the results of different APIs and oracles can result in almost unpredictable output, which can be a good deal for small dapps or protocols that don't rely entirely on randomness. The reputation of the data provider is also important in this case.

The most important attack on APIs and oracles is so-called oracle manipulation, in which vulnerabilities in a blockchain oracle are exploited to make it report inaccurate information about events outside the chain. This attack is often part of a broader attack on a protocol, as malicious actors can cause a protocol’s smart contracts to execute based on false input or in a way that is advantageous to them.

Verifiable random functions (VRFs)

Steering clear of intricate mathematics,Verifiable Random Functions (VRFs ) can be described as public key pseudorandom functions. Put simply, these functions produce outputs that appear pseudorandom based on a given seed and mimic the behavior of true random outputs (if you want to dig deeper, read this article). The real power of VRFs is their ability to prove the correctness of their output calculations. The possessor of the secret key is the only one able to compute the output of the function (i.e., the random output) along with a corresponding proof for any input value. Conversely, anyone else who has the proof and the corresponding public key can verify the exact computation of this output. However, this information is not sufficient to derive the secret key.

One of the most commonly used VRFs is the Chainlink VRF, which relies on a decentralized oracle network (i.e., a set of oracles that receive data from multiple reliable sources) to enhance existing blockchains by providing verified off-chain data.

Chainlink VRF enables the generation of random numbers within smart contracts, enabling blockchain developers to create improved user experiences by incorporating unpredictable outcomes into their blockchain-powered applications. In addition, Chainlink VRF is immune to tampering, whether done by node operators, users, or malicious entities.

To go further

To be an outstanding blockchain developer it's not necessary to know everything about VRFs, however for the curious ones I suggest Micali, Rabin, Vadhan (1999) and the Chainlink VRF docs.

And that's it for this article.

Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Note that I assume a basic knowledge of the Solidity language and Foundry framework, however, even someone without this knowledge should be able to follow along.

Blockchain 101: smart contracts

In simple words, smart contracts are like digital agreements that automatically execute and enforce themselves when certain conditions are met. We can liken smart contracts to vending machines: once they receive the right inputs, they automatically execute the agreement.

For example, to decentralize a lottery, we will write a function that takes in input the amount paid by a particular player and a function that, once a particular condition is met (e.g. if the number of players is 10 or if one day has passed), it generates a pseudo-random number between 0 and the number of players and pays the amount to the selected winner.

These digital agreements can be used for various purposes, such as transferring money, buying and selling assets, or even voting in elections. Since smart contracts run on the blockchain, they are tamper-resistant and transparent (or at least they should be). Nevertheless, not all blockchain developers pay attention to the contract doing what it is supposed to do, and in fact, the number of hacked or tampered smart contracts is surprisingly high.

To prevent this, it is important to develop a comprehensive testing strategy that includes both unit tests and invariant tests.

Set up

First of all, we need to set up the foundry environment:

forge init

Then we need a contract to test. The following lines of code implement a lottery as the one described before. Note that for simplicity the winner should be the first player (players[0]) that joins the lottery (pseudo-random numbers on the blockchain is a big theme for an upcoming article) and that the lottery ends once there are at least 5 participants and the owner of the lottery calls the function endTheLottery.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract Lottery {
    error Lottery__notEnoughEthSent(uint256 amount);
    error Lottery__notTheOwner(address sender);
    error Lottery__notEnoughtPlayers();
    error Lottery__invalidTransaction();

    uint256 immutable i_lotteryPriceInEth;
    address owner;
    address[] players;
    address winner;

    modifier onlyOwner() {
        if (msg.sender != owner) revert Lottery__notTheOwner(msg.sender);
        _;
    }

    modifier moreThanFivePlayers() {
        if (players.length < 5) revert Lottery__notEnoughtPlayers();
        _;
    }

    constructor(uint256 lotteryPriceInEth) {
        i_lotteryPriceInEth = lotteryPriceInEth;
        owner = msg.sender;
    }

    function joinLottery() public payable {
        if (msg.value < i_lotteryPriceInEth)
            revert Lottery__notEnoughEthSent(msg.value);
        players.push(msg.sender);
    }

    function endTheLottery() public onlyOwner moreThanFivePlayers {
        if (players.length % 2 == 0) {
            winner = players[1];
        }
        if (players.length % 2 == 1) {
            winner = players[0];
        }
        (bool success, bytes memory data) = payable(winner).call{
            value: address(this).balance
        }("");
        if (!success) revert Lottery__invalidTransaction();
    }

    function transferOwnership(address newOwner) public {
        owner = newOwner;
    }

    function getNumberOfPlayer() public view returns (uint256) {
        return players.length;
    }

    function getPlayer(uint256 index) public view returns (address) {
        return players[index];
    }

    function getWinner() public view returns (address) {
        return winner;
    }
}

In this first version of the contract, a couple of things are not correct and by testing we should be able to spot them.

Unit tests

Unit tests are deterministic tests, i.e. they produce deterministic results, are easy to debut and are used to assert particular behaviors of the contract. Before we write any unit test we need a deployer script as the following one:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Script} from "../lib/forge-std/src/Script.sol";
import {Lottery} from "src/Lottery.sol";

contract DeployLottery is Script {
    Lottery lottery;

    function run() public returns (Lottery) {
        vm.startBroadcast();
        lottery = new Lottery(1 ether);
        vm.stopBroadcast();
        return lottery;
    }
}

Suppose now we want to assess that the modifier onlyOwner is doing his job (which is to prevent addresses different from the owner to call the endLotteryFunction), what we need to do is:

• deploy the contract;

• transfer the ownership of the contract calling the transferOwnership function;

• prank an address (different from the owner) and try to call the endTheLottery function;

• assert that the contract trows the Lottery__notTheOwner error.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Test} from "lib/forge-std/src/Test.sol";
import {Lottery} from "src/Lottery.sol";
import {DeployLottery} from "script/DeployLottery.s.sol";

contract LotteryTest is Test {
    address player0 = makeAddr("Alice");
    address player1 = makeAddr("Bob");
    address player2 = makeAddr("Carl");
    address player3 = makeAddr("David");
    address player4 = makeAddr("Eleonor");
    address owner = makeAddr("Owner");
    uint256 public constant BALANCE = 100 ether;

    Lottery lottery;

    function setUp() public {
        DeployLottery deployer = new DeployLottery();
        vm.deal(player0, BALANCE);
        vm.deal(player1, BALANCE);
        vm.deal(player2, BALANCE);
        vm.deal(player3, BALANCE);
        vm.deal(player4, BALANCE);
        vm.deal(owner, BALANCE);
        lottery = deployer.run();
        lottery.transferOwnership(owner);
    }

    function testOnlyOwnerCanEndTheLottery() public {
        vm.expectRevert(
            abi.encodeWithSelector(
                Lottery.Lottery__notTheOwner.selector,
                player0
            )
        );

        vm.startPrank(player0); // not the owner
        lottery.endTheLottery();
        vm.stopPrank();
    }
}

Since player0 is the caller of endTheLottery, the contract trows the Lottery__notTheOwner error, as expected:

Running 1 test for test/LotteryTest.t.sol:LotteryTest
[PASS] testOnlyOwnerCanEndTheLottery() (gas: 13825)
Test result: ok. 1 passed; 0 failed; 0 skipped; finished in 1.22ms

Another classical use of unit tests is for asserting a particular relation between two variables. For example, let's assert that the number of players is five in the following script:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Test} from "lib/forge-std/src/Test.sol";
import {Lottery} from "src/Lottery.sol";
import {DeployLottery} from "script/DeployLottery.s.sol";

contract LotteryTest is Test {
    address player0 = makeAddr("Alice");
    address player1 = makeAddr("Bob");
    address player2 = makeAddr("Carl");
    address player3 = makeAddr("David");
    address player4 = makeAddr("Eleanor");
    address owner = makeAddr("Owner");
    uint256 public constant BALANCE = 100 ether;

    Lottery lottery;

    function setUp() public {
        DeployLottery deployer = new DeployLottery();
        vm.deal(player0, BALANCE);
        vm.deal(player1, BALANCE);
        vm.deal(player2, BALANCE);
        vm.deal(player3, BALANCE);
        vm.deal(player4, BALANCE);
        vm.deal(owner, BALANCE);
        lottery = deployer.run();
        lottery.transferOwnership(owner);
    }

    function testOnlyOwnerCanEndTheLottery() public {
        vm.expectRevert(
            abi.encodeWithSelector(
                Lottery.Lottery__notTheOwner.selector,
                player0
            )
        );

        vm.startPrank(player0); // not the owner
        lottery.endTheLottery();
        vm.stopPrank();
    }

    function testAssertNumberOfPlayers() public {
        vm.startPrank(player0);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player1);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player2);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player3);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player4);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();

        uint256 expectedNumberOfPlayers = 5;
        uint256 numberOfPlayers = lottery.getNumberOfPlayer();

        assertEq(expectedNumberOfPlayers, numberOfPlayers);
    }
}

As expected, assertEq(expectedNumberOfPlayers, numberOfPlayers); is true and the test passed:

Running 2 tests for test/LotteryTest.t.sol:LotteryTest
[PASS] testAssertNumberOfPlayers() (gas: 192928)
[PASS] testOnlyOwnerCanEndTheLottery() (gas: 13880)
Test result: ok. 2 passed; 0 failed; 0 skipped; finished in 2.34ms

Note that these are only two simple cases and we haven't tested edge cases (for example the contract has undesired behavior after the first lottery concludes as the address array is never reinitialized).

As we saw, unit tests are particularly powerful tests in particular when the contract is quite simple. If the contract has some complex functions or inherits from other contracts we may want to conduct a different type of test: the invariant tests.

Invariant tests

Invariant tests are a form of stochastic testing, meaning the results may vary across test runs (unless the same seed is set). In other words, performing an invariant test means supplying random data to the contract functions trying to individuate some unexpected behavior.

The part of my reader that actually read the contract may have noticed that the function endTheLottery does something undesired. In fact, if the length of players is an even number (% is the modulus operator), the contract behaves correctly (remember that for simplicity we want the first to join the lottery to be the winner), but if the number is odd the winner is player[1] (i.e. the second one who joined the lottery).

It appears that the victory of player[0] should be an invariant property of the contract. Since many contracts have at least an invariant property and testing these properties with unit tests may be difficult or impossible (especially for complex contracts), knowing how to perform invariant tests is the conditio sine qua non to be a proficient blockchain engineer.

Note that there are two types of invariant tests:

• stateless invariant tests: tests where the states of the test are independent of one other.;

• stateful invariant tests: tests where the state of the next run is affected by all the previous states;

We can in fact find the undesired behaviour of endTheLottery just by performing the following test:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Test} from "lib/forge-std/src/Test.sol";
import {Lottery} from "src/Lottery.sol";
import {DeployLottery} from "script/DeployLottery.s.sol";
import {StdInvariant} from "lib/forge-std/src/StdInvariant.sol";

contract LotteryTest is Test {
    address player0 = makeAddr("Alice");
    address player1 = makeAddr("Bob");
    address player2 = makeAddr("Carl");
    address player3 = makeAddr("David");
    address player4 = makeAddr("Eleonor");
    address owner = makeAddr("Owner");
    uint256 public constant BALANCE = 100 ether;

    Lottery lottery;

    function setUp() public {
        DeployLottery deployer = new DeployLottery();
        vm.deal(player0, BALANCE);
        vm.deal(player1, BALANCE);
        vm.deal(player2, BALANCE);
        vm.deal(player3, BALANCE);
        vm.deal(player4, BALANCE);
        vm.deal(owner, BALANCE);
        lottery = deployer.run();
        lottery.transferOwnership(owner);
        targetContract(address(lottery));
    }

    function testOnlyOwnerCanEndTheLottery() public {
        vm.expectRevert(
            abi.encodeWithSelector(
                Lottery.Lottery__notTheOwner.selector,
                player0
            )
        );

        vm.startPrank(player0); // not the owner
        lottery.endTheLottery();
        vm.stopPrank();
    }

    function testAssertNumberOfPlayers() public {
        vm.startPrank(player0);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player1);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player2);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player3);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();
        vm.startPrank(player4);
        lottery.joinLottery{value: 1 ether}();
        vm.stopPrank();

        uint256 expectedNumberOfPlayers = 5;
        uint256 numberOfPlayers = lottery.getNumberOfPlayer();

        assertEq(expectedNumberOfPlayers, numberOfPlayers);
    }

    function testFuzz_WinnerIsAlwaysPlayers0(uint96 numPlayers) public {
        vm.startPrank(player0);
        for (uint256 i = 5; i < numPlayers; i++) {
            lottery.joinLottery{value: 1 ether}();
        }
        vm.stopPrank();

        vm.startPrank(owner);
        lottery.endTheLottery();
        vm.stopPrank();

        address expectedWinner = lottery.getPlayer(0);
        assertEq(
            lottery.getPlayer(0),
            expectedWinner
        );
    }
}

The test fails (as expected) and it returns the following logs to notify that there is at leas a situation in which endTheLottery has unexpected behavior:

Test result: FAILED. 2 passed; 1 failed; 0 skipped; finished in 4.96ms

Failing tests:
Encountered 1 failing test in test/LotteryTest.t.sol:LotteryTest
[FAIL. Reason: Lottery__notEnoughtPlayers() Counterexample: calldata=0x515cecbc0000000000000000000000000000000000000000000000000000000000000000, args=[0]] testFuzz_WinnerIsAlwaysPlayers0(uint96) (runs: 0, μ: 0, ~: 0)

Encountered a total of 1 failing tests, 2 tests succeeded

In fact 0x515cecbc0000000000000000000000000000000000000000000000000000000000000000 is the hexadecimal representation of an even number. Adding an even number to 5 (the starting point of the for loop) results in an odd number, which triggers the second if statement in the endLottery function and thus the winner is players[1].

To go further

To learn more about testing Solidity contract with the Foundry framework and discover advanced testing techniques consult the Foundry docs.

And that's it for this article.

Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Let’s take a look at a simple differential equation

$$\frac{\delta y}{\delta x}=ky$$

where \(k \in R\).

The solutions of the above equation are the functions whose derivatives are proportional to a constant factor (\(k\)) of the original function.

Bringing back some calculus, consider the function \(y = ce^{kx}\), where \(c\) is a real constant: the derivative of \(y\) with respect to \(x\) is \(\frac{dy}{dx} = ky\). Consequently, the family of solutions is represented by the expression \(y = ce^{kx}\), where q is a real number.

It is common to add an initial condition that gives the value of the unknown function at a particular point in the domain. For example:

$$\begin{equation} \begin{cases} \frac{\delta y}{\delta x}=2y\\ y(0)=2 \end{cases} \end{equation}$$

It is straightforward to prove that the solution of the above system is \(y = 2e^{2x}\).

Unfortunately, not every ODE can be directly solved explicitly, so numerical methods come to the rescue by providing an approximation to the solution.

It is worth noting that these numerical methods are not only useful for solving first-order ODEs but are equally valuable for addressing higher-order ODEs as well (i.e. ODE involving higher-order derivative) since a higher-order ODE can often be transformed into a system of first-order ODEs.

In this article, I introduce two among the multitude of available numerical methods.

Euler method

The Euler method offers a simple approach by breaking down the continuous ODE into discrete steps. The idea is to update the function's value based on its derivative at each step, effectively simulating the behavior of the ODE over a range of points. In fact, from any point \(p\) on a curve, we can find an approximation of the nearby points on the curve by moving along the line tangent to \(p\).

Let

$$\begin{equation} \begin{cases} \frac{\delta y}{\delta x}=f(x, y(x))\\ y(x_0)=y_0 \end{cases} \end{equation}$$

be our initial system.

Replacing the derivate with its discrete version and rearranging we get

$$\begin{equation} \begin{cases} y(x+h)=y(x) + h f(x, y(x))\\ y(x _0)=y_0 \end{cases} \end{equation}$$

and we can compute the following recursive scheme

$$y_{n+1}=y_n+hf(x_n,y_n)$$

Graphically:

Using the above equation, we can now compute \(y(x_n)\) \(\forall \space x_n\) with the following steps:

1. store \(y(x_0)=y_0\);

2. compute \(y(x_1)=y_0+hf(x_0, y_0)\);

3. store \(y(x_1)\);

4. compute \(y(x_2)=y_1+hf(x_1, y_1)\);

5. store \(y(x_2)\);

and so on.
We now want to approximate the solution of the initial system

$$\begin{equation} \begin{cases} \frac{\delta y}{\delta x}=2y\\ y(0)=2 \end{cases} \end{equation}$$

and visualize the exact solution and the approximation

import numpy as np
import matplotlib.pyplot as plt

# define params, ode and inital condition
k = 2
f = lambda y, x: k*np.exp(k*y)
h = 0.1
x = np.arange(0, 1 + h, h)
x_= np.arange(0, 1, 0.0001)
y0 = 2 

# initialize the y vector
y = np.zeros(len(x))
y[0] = y0

# populate the y vector
for i in range(0, len(x) - 1):
    y[i + 1] = y[i] + h*f(x[i], y[i])

# plot the results
plt.plot(x, y, 'bo--', label='Approximated solution')
plt.plot(x_, np.exp(k*x_)+1, 'g', label='Exact solution')
plt.xlabel('x')
plt.ylabel('y')
plt.grid()
plt.legend(loc='lower right')
plt.show()

Runge-Kutta methods

The Euler method is often not enough accurate. One solution is to use more than one point in the interval \([x_n, x_{n+1}]\) as the Runge-Kutta methods do. The number of points in the interval \([x_n, x_{n+1}]\) defines the order of the method.

Second-Order Runge-Kutta Method (RK2)

Starting with the Runge-Kutta method of order 2, we need the following second-order Taylor expansion:

$$y(x+h)=y(x)+h\frac{\delta y}{\delta x}(x) + \frac {h^2}2\frac{\delta^2 y}{\delta x^2}(x)+\epsilon$$

where \(\epsilon\) is the truncation error.

We can obtain \(\frac{\delta^2 y}{\delta x^2}(x)\) by differentiating the ODE \(\frac{\delta y}{\delta x}(x)=f(x, y(x))\):

$$\frac{\delta^2 y}{\delta x^2}(x)=\frac{\delta }{\delta x}f(x, y)+\frac{\delta}{\delta y}f(x, y)f(x, y)$$

and the Taylor expansion hence becomes

$$y(x+h)=y(x)+hf(x,y) + \frac {h^2}2(\frac{\delta }{\delta x}f(x, y)+\frac{\delta}{\delta y}f(x, y)f(x, y) )+\epsilon$$

After some manipulation, we obtain

$$y(x+h)=y(x)+\frac h2f(x,y) + \frac {h}2f(x+h,y+hf(x,y))+\epsilon$$

which corresponds to the following recursive scheme:

$$y_{n+1}=y_n+\frac h2(s_1+s_2)$$

with

$$s_1=f(x_n, y_n)\\$$

$$s_2 = f(x_n+\frac h2, y_n+\frac h2{s_1})$$

Note that \(s_1\) and \(s_2\) correspond to two different estimates of the slope of the solution and the method is nothing more than the average between the two.

Again using the above equation, we can compute \(y(x_n)\) \(\forall \space x_n\) with the following steps:

1. store \(y(x_0)=y_0\);

2. compute \(s_1 \) and \(s_2\);

3. compute \(y(x_1)=y_0+\frac h2(s_1+s_2)\);

4. store \(y(x_1)\);

5. update \(s_1 \) and \(s_2\);

6. \(y(x_2)=y_1+\frac h2(s_1+s_2)\);

7. store \(y(x_2)\);

and so on.

Again, we want to approximate the solution of the initial system

$$\begin{equation} \begin{cases} \frac{\delta y}{\delta x}=2y\\ y(0)=2 \end{cases} \end{equation}$$

import numpy as np
import matplotlib.pyplot as plt


# define params, the ode and the inital consition
k = 2
f = lambda y, x: k*np.exp(k*y)
h = 0.1
x = np.arange(0, 1 + h, h)
x_= np.arange(0, 1, 0.0001)
y0 = 2 

# initialize thw y vector
y = np.zeros(len(x))
y[0] = y0

# populate the y vector
for i in range(0, len(x) - 1):
    s1=f(x[i], y[i])
    s2=f(x[i] + h/2, y[i]+  h/2*s1)
    y[i + 1] = y[i] + h/2 * (s1+s2)

# plot the results
plt.plot(x, y, 'bo--', label='Approximated solution')
plt.plot(x_, np.exp(k*x_)+1, 'g', label='Exact solution')
plt.xlabel('x')
plt.ylabel('y')
plt.grid()
plt.legend(loc='lower right')
plt.show()

Fourth-Order Runge-Kutta Method (RK4)

Repeating what we did to find the recursive scheme for the Range-Kutta method of order 2, but using a fourth-order Taylor expansion, we obtain the following recursive scheme:

$$y_{n+1}=y_n+\frac h3(\frac {s_1}2 + s_2 + s_3 + \frac{s_4}2)$$

with

$$s_1 = f(x_n, y_n)$$

$$s_2 = f(x_n+\frac h2, y_n+\frac h2{s_1})$$

$$s_3 = f(x_n+\frac h2, y_n+\frac h2{s_2})$$

$$s_4 = f(x_n+h, y_n+h{s_3})$$

The steps used to approximate the system

$$\begin{equation} \begin{cases} \frac{\delta y}{\delta x}=2y\\ y(0)=2 \end{cases} \end{equation}$$

are specular to the ones used in the Runge-Kutta method of order 2.

import numpy as np
import matplotlib.pyplot as plt


# define params, the ode and the inital consition
k = 2
f = lambda y, x: k*np.exp(k*y)
h = .1
x = np.arange(0, 1 + h, h)
x_= np.arange(0, 1, 0.0001)
y0 = 2 

# initialize thw y vector
y = np.zeros(len(x))
y[0] = y0

# populate the y vector
for i in range(0, len(x) - 1):
    s1=f(x[i], y[i])
    s2=f(x[i] + h/2, y[i]+  h/2*s1)
    s3=f(x[i] + h/2, y[i]+  h/2*s2)
    s4=f(x[i] + h, y[i]+  h*s3)
    y[i + 1] = y[i] + h/3 * (s1/2+s2+s3+s4/2)

# plot the results
plt.plot(x, y, 'bo--', label='Approximated solution')
plt.plot(x_, np.exp(k*x_)+1, 'g', label='Exact solution')
plt.xlabel('x')
plt.ylabel('y')
plt.grid()
plt.legend(loc='lower right')
plt.show()

There are also higher-order Range-Kutta methods but they are relatively inefficient, so I won't cover them in this article.

Comparison between the three methods

1. Euler Method:

   • Accuracy: the Euler method is a first-order method, which means that it can accumulate a significant error over many steps or for stiff ODEs.

   • Computational Complexity: the Euler method involves a single evaluation of the derivative function per step.

2. Second-Order Runge-Kutta Method (RK2):

   • Accuracy: RK2 is a second-order method: it offers better accuracy than the Euler method and is less prone to accumulating a relevant error over many steps.

   • Computational Complexity: RK2 requires two evaluations of the derivative function per step (one at the beginning and one at the midpoint).

3. Fourth-Order Runge-Kutta Method (RK4):

   • Accuracy: RK4 is a fourth-order method, which implies that it's significantly more accurate than both Euler and RK2 methods, making it suitable for many practical applications.

   • Computational Complexity: RK4 involves four evaluations of the derivative function per step, along with weighted combinations of these evaluations.

     Despite the higher computational cost compared to Euler and RK2, RK4 still remains a popular choice due to its reliability and accuracy.

Graphically:

import numpy as np
import matplotlib.pyplot as plt

# define params, the ode and the inital consition
k = 2
f = lambda y, x: k*np.exp(k*y)
h = 0.1
x = np.arange(0, 1 + h, h)
x_= np.arange(0, 1, 0.0001)
y0 = 2 

# initialize thw y vector
y = np.zeros(len(x))
y[0] = y0

# euler method
for i in range(0, len(x) - 1):
    y[i + 1] = y[i] + h*f(x[i], y[i])
plt.plot(x, y, label='Euler', linestyle='--')


# rk2 method
for i in range(0, len(x) - 1):
    s1=f(x[i], y[i])
    s2=f(x[i] + h/2, y[i]+  h/2*s1)
    y[i + 1] = y[i] + h/2 * (s1+s2)
plt.plot(x, y, label='RK2', linestyle='--')


# rk4 method
for i in range(0, len(x) - 1):
    s1=f(x[i], y[i])
    s2=f(x[i] + h/2, y[i]+  h/2*s1)
    s3=f(x[i] + h/2, y[i]+  h/2*s2)
    s4=f(x[i] + h, y[i]+  h*s3)
    y[i + 1] = y[i] + h/3 * (s1/2+s2+s3+s4/2)
plt.plot(x, y, label='RK4', linestyle='--')


plt.plot(x_, np.exp(k*x_)+1, label='Exact solution')
plt.xlabel('x')
plt.ylabel('y')
plt.grid()
plt.legend(loc='lower right')
plt.show()

And that's it for this article.

Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

There are many different types of optimization problems, including linear programming, nonlinear programming, convex optimization, and integer programming, to name a few. Each type of optimization problem requires a different approach and a different set of algorithms to solve it.

In this post, I will talk about simulated annealing, which is a well-known algorithm but also is still exotic for noninitiated. For the sake of simplicity, I'll talk about minimization problems since seeking the maximum of a function \(f\) equals seeking the maximum of a function \(-f\).

Simulated annealing

Simulated annealing is an iterative method for solving unconstrained and bound-constrained optimization problems. The algorithm borrows inspiration from the physical process of heating a material and then slowly lowering the temperature.

At each iteration of the simulated annealing algorithm, a new point \(x_i\) is randomly generated (if you don't know how computers deal with randomicity, see this article). As we'll see in a minute, the distance of the new point \(x\_i\) from the current point \(x\_{i-1}\) is proportional to the temperature and based on a certain probability distribution. The algorithm accepts all new points \(x_i \) such that \(f(x\_i) \leq f(x\_{i-1})\) where \(f\) is the objective function (i.e. the function to be minimized), but also \(x_i \) such that \(f(x\_i) \geq f(x\_{i-1})\), with a certain probability. This property is significant and it prevents the algorithm from being trapped in local minima.

Simulated annealing with Python

First of all, we need to load some packages:

import math
import random as rd

We now define the parameters, we need:

• an objective function \(f\);

• a domain (where the algorithm should look for a solution);

• initial temperature;

• an initial point (which is usually selected randomly);

• a step size;

• a maximum number of iterations.

# 1) the objective function
def f(x):
    return x**3 - 8

# 2) the domain
domain = [-10., 10.]

# 3) initial temperature
start_temp = 100

# 4) starting value
x_0 = rd.uniform(domain[0], domain[1])

# 5) the step size
step_size = 2

# 6) maximum number of iterations
max_iter = 1000
iteration = 0

First of all, we evaluate \(x_0\) and assign \(x_0\) and \(y_0 \) to x_best and y_best (the best value since now) and x_curr and y_curr (the current solution).

y_0 = f(x_0)

x_curr, y_curr = x_0, y_0
x_best, y_best = x_0, y_0

The first step of the algorithm is to generate a new candidate solution \(f(x_1) \) from the current solution \(f(x_0)\). We count an iteration (this step is crucial, otherwise the algorithm would run forever).

x_1 = x_curr + step_size * rd.uniform(-1, 1)
y_1 = f(x_1)

iteration += 1

Since we are looking for a minimum, if y_1 is smaller than y_best, we assign y_1 and x_1 to y_best and x_best. We then calculate the difference between y_best and y_curr.

if y_1 < y_best:
    x_best, y_best = x_1, y_1

diff = y_1 - y_curr

Here comes the most exciting part: we update the temperature (using fast annealing schedule) and use this value to calculate the Metropolis criterion:

where \(\Delta y\) is diff and \(t\) is temp. The numbers represent the probability of accepting the transition from \(x\_i\) to \(x\_{i+1}\) and are what allows to escape local minima.

temp = start_temp / (iteration + 1.)
metropolis = math.exp(-diff / temp)

if diff <= 0 or rd.random() < metropolis:
    x_curr, y_curr = x_best, y_best

And this is the last step. In fact after that, the algorithm calculates \(x_3\) and \(y_3\) and evaluates them for x_best and y_best and x_curr and y_curr and repeat itself until iteration == max_iter.

Making a function for simulated annealing

Since the algorithm at some point repeats itself, we may want to wrap it up in a function.

import math
import numpy as np
import random as rd

def simulated_annealing(f, domain, step_size, start_temp, max_iter = 1000):

    x_0 = rd.uniform(domain[0], domain[1])
    y_0 = f(x_0)
    x_curr, y_curr = x_0, y_0
    x_best, y_best = x_0, y_0

    for n in range(max_iter):
        x_i = x_curr + step_size * rd.uniform(-1, 1)
        y_i = f(x_i)

        if y_i < y_best:
            x_best, y_best = x_i, y_i

        diff = y_best - y_curr

        temp = start_temp/ float(n + 1)
        metropolis = math.exp(-diff / start_temp)

        if diff <= 0 or rd.random() < metropolis:
            x_curr, y_curr = x_i, y_i

    return [y_best, x_best]

Note that we don't have to count the iterations since we are using a for loop.

If we test the function we see that for well-chosen parameters the algorithm finds the value with a good approximation.

def fun(x):
    return x**2 + np.sin(x**4)

simulated_annealing(f = fun, domain = [-3, 3], step_size = 1, start_temp = 100, max_iter = 1000)

#> [9.915548806706291e-08, -0.00031488962865622305]

Finally, we plot what we got (the red line is the real minimum while the blue one is our result):

import numpy as np
from matplotlib import pyplot as plt

def fun(x):
    return x**2 + np.sin(x**4)

x = np.linspace(-3, 3, 1000)
y = fun(x)

plt.plot(x, y)

plt.axvline(x = 0, color = "blue", label = "real minimum")
plt.axvline(x = 9.915548806706291e-08, color = "red", label = "approximate minimum")
plt.legend(bbox_to_anchor = (1.0, 1), loc = "upper left")

plt.show()

In the picture, the approximate minimum overlaps the real minimum (they are too close) and only the approximate minimum is visible.

Beyond 2D

Of course, the algorithm work also in more than one dimension, but the function needs some adjustment. In particular, we have to define a domain for y:

def simulated_annealing_3d(f, domain_x, domain_y, step_size, start_temp, max_iter = 1000):

    x_0 = rd.uniform(domain_x[0], domain_x[1])
    y_0 = rd.uniform(domain_y[0], domain_y[1])
    z_0 = f(x_0, y_0)
    x_curr, y_curr, z_curr = x_0, y_0, z_0
    x_best, y_best, z_best = x_0, y_0, z_0

    for n in range(max_iter):
        x_i = x_curr + step_size * rd.uniform(-1, 1)
        y_i = y_curr + step_size * rd.uniform(-1, 1)
        z_i = f(x_i, y_i)

        if z_i < z_best:
            x_best, y_best, z_best = x_i, y_i, z_i

        diff = z_i - z_curr

        temp = start_temp / (n + 1)       
        metropolis = math.exp(-diff / temp)

        if diff <= 0 or rd.random() < metropolis:
            x_curr, y_curr, z_curr = x_i, y_i, z_i

    return [z_best, y_best, x_best]

Let's test the function:

def fun_3d(x, y):
    return (x-y)**2 + (x+y)**2

simulated_annealing_3d(f = fun_3d, domain_x = [-5, 5], domain_y = [-5, 5], step_size = 1, start_temp = 1000, max_iter = 10000)

#> [0.0007833147844967029, 0.018319454959260906, 0.007486986192318135]

If we plot the result:

from matplotlib import pyplot as plt

x = np.linspace(-.1, .1, 20)
y = np.linspace(-.1, .1, 20)
X, Y = np.meshgrid(x, y)
Z = fun_3d(X,Y)

a = np.repeat(0, 50)
b = np.repeat(0, 50)
c = np.arange(0, .05, .001)

a_ = np.repeat(0.015536251178558613, 50) 
b_ = np.repeat(-0.014426988378332561, 50)
c_ = np.arange(0, .05, .001)

fig = plt.figure(figsize=(4,4))
ax = fig.add_subplot(111, projection='3d')
ax.plot_wireframe(X, Y, Z, color = "red", linewidth = .3)
ax.plot(a, b, c, color = "blue", label = "real minimum")
ax.plot(a_, b_, c_, color = "green", label = "approximated minimum")


ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_zlabel("z")
plt.legend(bbox_to_anchor = (1.0, 1), loc = "upper left") 

plt.show()

Zooming we can appreciate the error.

And that's it for this article.

Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

$$M x = \lambda x$$

Eigenvalues and eigenvectors are crucial in many fields of science. For example, consider a discrete-time and discrete states Markov chain, whose transition matrix \(M\) is defined as follows:

Let the initial state vector \(x_1\) be:

We know that from \(M\) and \(x\_1\) we could compute all the successive states and it's true that:

$$x\_2 = M x \_1$$

$$x\_3 = M x\_2$$

and in general

$$x\k = M x\{k-1}$$

We may want to find a vector \(x\) s.t.

$$Mx = x$$

Vectors with this property as known as steady-state vectors. It can be demonstrated that finding steady-state vectors equals finding any eigenvector \(x\) with eigenvalue 1.

For example, the steady-state vector for the matrix \(M\) is:

and one can easily show that

Finding eigenvalues and eigenvectors is not always easy to do by hand, and there are some algorithms to compute them. Unfortunately, this calculation may be expensive, especially with large matrices, and the result may be inaccurate due to approximations.

However, some algorithms perform better than others, and I want to discuss some of them in this article.

Solving characteristic equation

We can rewrite \(M x = \lambda x\) as

$$M x-\lambda x = 0$$

$$( M-\lambda I)x = 0$$

This system has a non-trivial solution (i.e. \(x \neq 0\)) only if \(det(M-\lambda I) =0\). \(det(M-\lambda I) =0\) is known as the characteristic equation.

Expanding \(det(M-\lambda I) =0\) we obtain a polynomial of degree \(n\), whose roots are the eigenvalues of \(M\). Computing eigenvectors from eigenvalues is trivial: for each eigenvalue \(\lambda\), we just need to find the null space of the matrix \(M-\lambda I\).

This is how we compute eigenvalues and eigenvectors by hand, but following this approach on a computer leads to some problems:

• it depends on the computation of the determinant, which is a time-consuming process (due to the symbolic nature of the computation);

• there is no formula for solving polynomial equations of degree higher than 4. Even though some techniques exist, like Newton's method, it's tough to find all the roots.

Therefore we need a different approach.

Iterative methods

Unfortunately, there is no simple algorithm to directly compute eigenvalues and eigenvectors for general matrices (there are special cases of matrices where it's possible, but I won't cover them in this article).

However, there are iterative algorithms that produce sequences that converge to eigenvectors or eigenvalues. There are several variations of these methods, I'll just cover two of them: the power method and the QR algorithm.

The power method

This method applies to matrices that have a dominant eigenvalue \(\lambda\_d\) (i.e. an eigenvalue that is larger in absolute value than the other eigenvalues).

Let \(M\) be an \(n \times n\) matrix, the power method approximates a dominant eigenvector in the following steps:

$$x\_1 = Mx\_0$$

$$x\_2 = Mx\_1$$

$$x\k = Mx\{k-1}$$

And the more steps we take (i.e. the bigger \(k\) is) the more accurate will be our approximation. This is expressed in the following formula

Once we have an approximation of the dominant eigenvector \(x\_d\) we find the corresponding dominant eigenvalue \(\lambda\_d\) with the Rayleigh quotient

$$\frac{(Mx)x}{xx} = \frac{(\lambda\_d x)x}{xx} = \frac{\lambda\_d (xx)}{xx}\lambda\_d$$

Once we have \(\lambda\_d\), we use the observation that if \(\lambda\) is an eigenvalue of \(M\), \(\lambda - \beta\) is an eigenvalue of \(M-\beta I\) for any scalar \(\beta\). We can then apply the power method to compute a second eigenvalue. Repeating this process will allow us to compute all of the eigenvalues.

In Python this is:

import numpy as np

def power_method(M, n_iter = 100):
    n = M.shape[0]
    x_d = np.repeat(.5, n)
    lambda_d = n

    for i in range(n_iter):
        x_0 = x_d
        x_d = np.matmul(M, x_0)
    lambda_d = np.matmul(np.matmul(M, x_d), x_d) / np.matmul(x_d, x_d)

    h = np.zeros((n, n), int)
    np.fill_diagonal(h, lambda_d)
    N = M - h 
    x_1 = np.array([1, 0])
    lambda_1 = n

    for j in range(n_iter):
        x_0 = x_1
        x_1 = np.matmul(N, x_0)
    lambda_1 = np.matmul(np.matmul(M, x_1), x_1) / np.matmul(x_1, x_1)


    return [[x_d, lambda_d], [x_1, lambda_1]]

The function above works only for \(2 \times2\) matrices, but can easily be modified to \(n\times n\) matrices. We now test the function:

Matr = np.array([[1, 3], [2, 1]])

power_method(Matr)
#> [[array([1, 0.81649658]), 3.449489742783178],
#> [array([-1.22474487, 1]), -1.449489742783178]]

We can even prove that those values represent a good approximation by checking the equation

$$Mx=\lambda x$$

Since this is an approximation, the == operator is not suited, we define instead the is_close function.

def is_close(x, y):
    if all(abs(x-y) < 1e-5):
        return True
    else:
        return False

Matr = np.array([[.7, .2], [.3, .8]])

sol = power_method(Matr)
lambda_a = sol[0][1]
lambda_b = sol[1][1]

x_a = sol[0][0]
x_b = sol[1][0]

print(is_close(np.matmul(Matr, x_a), lambda_a * x_a))
#> True

print(is_close(np.matmul(Matr, x_b), lambda_b * x_b))
#> True

Above we defined the algorithm as follows

$$x\k = Mx\{k-1}$$

We can notice that if

$$x\{k-1} = Mx\{k-2}$$

then we can substitute

$$x\k = MMx\{k-2}$$

By induction, we can prove that

$$x\k = M^kx{0}$$

We now use this formula to update the Python function above. The new function is the following:

def power_method_2(M, n_iter = 100):
    n = M.shape[0]           
    x_d = np.array([1, 0])

    M_k = np.linalg.matrix_power(M, n_iter) 
    M_k = M_k / np.max(M_k)
    x_d = np.matmul(M_k, x_d)
    x_d = x_d / np.max(x_d)     

    lambda_d = np.matmul(np.matmul(M, x_d), x_d) / np.matmul(x_d, x_d)

    D = np.zeros((n, n), float)
    np.fill_diagonal(D, lambda_d)
    N = M - D
    x_nd = np.array([1,0])

    N_k = np.linalg.matrix_power(N, n_iter) 
    N_k= N_k / np.max(N_k)
    x_nd = np.matmul(N_k, x_nd)
    x_nd = x_nd/np.max(x_nd)  

    lambda_nd = np.matmul(np.matmul(N, x_nd), x_nd) / np.matmul(x_nd, x_nd)
    lambda_nd = lambda_nd + lambda_d 

    return [[x_d, lambda_d], [x_nd, lambda_nd]]

Again we test the function:

Matr = np.array([[.7, .2], [.3, .8]])

sol_2 = power_method(Matr)
lambda_a = sol_2[0][1]
lambda_b = sol_2[1][1]

x_a = sol_2[0][0]
x_b = sol_2[1][0]

print(is_close(np.matmul(Matr, x_a), lambda_a * x_a))
#> True

print(is_close(np.matmul(Matr, x_b), lambda_b * x_b))
#> True

Once we are sure both the functions work correctly, we can now test which has a better performance.

import timeit

%timeit power_method(Matr)
#> 558 µs ± 32.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit power_method_2(Matr)
#> 144 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

And we have a winner: the second function is 3.875 times faster than the first one.

The QR algorithm

One of the best methods for approximating the eigenvalues and the eigenvectors of a matrix applies the QR factorization and for this reason is known as the QR algorithm.

Let \(M\) be an \(n\times n\) matrix, first of all, we need to factor it as

$$M = Q\_0R\_0$$

then we set

$$M\_1 = R\_0Q\_0$$

We then factor \(M\_1 = Q\_1R\_1\) and define \(M\_2 = R\_1Q\_1\) and so on.

It can be proven that \(M\) is similar to \(M\_1,M\_1, \dots, M\_k\), which means \(M \) and \(M\_1,M\_1, \dots, M\_k\) have the same eigenvalues.

It can also be shown that the matrices \(M\_k\) converge to a triangular matrix \(T\) and that the elements on the diagonal are the eigenvalues of \(M\_k\).

In Python this is:

import numpy as np

def QR_argo(M, n_iter = 100):
    n = M.shape[1]
    Q_k = np.linalg.qr(M)[0]
    R_k = np.linalg.qr(M)[1]
    e_values = []

    for i in range(n_iter):
        M_k = np.matmul(R_k, Q_k)
        Q_k = np.linalg.qr(M_k)[0]
        R_k = np.linalg.qr(M_k)[1]

    for j in range(M_k.shape[1]):
        e_values.append(M_k[j, j])

    return e_values

We can now test the function and compare it to the power method.

def is_close(x, y):
    if abs(x-y) < 1e-5:
        return True
    else:
        return False

Matr = np.array([[1, 3], [2, 1]])

pow_lambda_a = power_method(Matr)[0][1]
pow_lambda_b = power_method(Matr)[1][1]
QR_lambda_a = QR_argo(Matr)[0]
QR_lambda_b = QR_argo(Matr)[1]

is_close(QR_lambda_a, pow_lambda_a)
#> True

is_close(QR_lambda_b, pow_lambda_b)
#> True

Once we have eigenvalues \(\lambda\_i\), computing eigenvectors is easy: they are the non-trivial solution of

$$(M-\lambda\_i I) x=0$$

And that's it for this article.

Thanks for reading.

For any questions or suggestions related to what I covered in this article, please add them as a comment. In case of more specific inquiries, you can contact me here.

Life's most important questions are, for the most part, nothing but probability problems.

Pierre-Simon de Laplace

Introduction

Imagine this scenario: you and your brother want to go to the cinema. Two movies are played: Interstellar (the one you want to see) and A Clockwork Orange (that your brother wants to see).

The classic solution to this problem is flipping a coin, but since we are not unimaginative people (or we don't have a coin) we may want to find a more elegant solution.

Thus let's define a program that decides what to see in R and Python. The program will generate a number between 0 and 1. If this number is closer to 0 we watch Interstellar. Otherwise, A Clockwork Orange is chosen.

import random as rd

x = rd.uniform(0, 1)

if x < .5:
    print("Interstellar")
else:
    print("A Clockwork Orange")

We now do the same in R:

x <- runif(1)

ifelse(x < .5, "Interstellar", "A Clockwork Orange")

Fair enough, but there is something paradoxical in the previous examples: a computer, a perfectly deterministic machine, is creating something randomly.

Fair enough, but there is something paradoxical in the previous examples: a computer, a perfectly deterministic machine, is creating something randomly.

In this article, I want to introduce you to pseudorandom number generators and their application.

Determinism versus randomness

Above I wrote "computer, a perfectly deterministic machine", but what does it mean to be deterministic?

In brief, computers are deterministic because they follow a set of instructions, or a program, in a predictable manner, i.e. given some inputs they return always the same output. The paradox lies in the fact that in the above example, x = rd.uniform(0, 1) and x <- runif(1) return a different value every time the line is compiled.

Are x = rd.uniform(0, 1) and x <- runif(1) exceptions to the deterministic property of computers?

The answer is no, and in a minute I'll explain the reasons behind that.

What is randomness

Before diving into PRNGs we need to define randomicity. We usually call random a sequence of numbers with the following trait:

• lack of pattern: a random sequence should not have any discernible structure;

• independence: the numbers in a random sequence should not be affected by one another;

• unpredictability: a random sequence of numbers should not be able to be predicted or reconstructed.

It's important to notice that randomicity is a complex concept and it's hard to quantify it precisely. Therefore it's common to use statistical tests to evaluate the randomness of a sequence of numbers, but this is beyond the scope of this article.

Random number generators are mathematical algorithms or mechanical devices that produce a sequence that follows the above properties.

As you may suppose, there are two types of random number generators:

• true random number generators (TRNGs from now on)

• pseudorandom number generators (PRNGs from now on)

In this article, I'll just cover PRNGs but be aware that TRNGs exist and have important applications in many fields such as gaming, gambling and cryptography.

Pseudorandom number generators (PRNGs)

As the name suggests, pseudorandom number generators are a type of software used to generate a sequence of numbers that mimic the properties of truly random numbers. The algorithm takes an initial input (the seed) which produces a sequence. The seed is what determines the sequence of numbers, for example, if we set the 1234 seed, compiling multiple times the following lines of code, x remains the same. In Python this is:

import random as rd

rd.seed(1234)

x = rd.uniform(0, 1)

print(x)

The same is true for the following R code:

set.seed(1234)

x <- runif(1)

print(x)

Properties

The goodness of a PRNG is given by its properties. The most important properties are:

• periodicity: PRNGs will generate a sequence of numbers that repeats itself after a certain number of iterations, known as the period. A PRNG with a long period is more desirable than one with a shorter period;

• uniformity: PRNGs generate numbers that are distributed uniformly across the range of possible values;

• independence: the numbers generated by a PRNG should be independent of one another;

• randomness: the numbers generated by a PRNG should not have any discernible patterns;

• seed-ability: PRNGs should be able to be seeded with an initial value in order to produce a different sequence.

Two PRNGs algorithms

In this section, I want to present the most known PRNGs algorithms to practically show how PRNGs look like. I will present the middle square algorithm and the linear congruential generator algorithms.

Middle square algorithm

Proposed by von Neumann, the middle square algorithm takes a seed that is squared and its midterm is fetched as the random number. Let's discuss an example and then implement it in Python and R.

Usually, the algorithm is repeated more than once, i.e the random number becomes the new seed and is then squared and its midterm becomes the random number and so on.

Here is an implementation in Python:

import numpy as np

def middle_square_algo(seed):

    # first of all we square the seed
    square = str(np.square(seed))

    # then we need to take the mid-term, we have two possibilities
    # the square may have an even number of digits:
    if len(square) % 2 == 0:
        half_str = int(len(square) / 2)

    # the number has an odd number of digits:
    else:
        half_str = int(len(square) / 2 - .5)


    mid = square[half_str - 1 : half_str + 1]
    return int(mid)

# finally the testing:

print(middle_square_algo(12))

#> 14

And here is the R code:

middle_square_algo <- function(seed){

  # first of all we square the seed
  square <- seed^2

  # we now need to get the number of digits of square
  len <- nchar(square)

  # we have two possible scenarios
  # len is even:
  if(len %% 2 == 0){

    half_square <- len / 2

  # len is odd:  
  } else{

    half_square <- len / 2 + .5

  }
  square <- as.character(square)
  mid <- substr(square, half_square, half_square + 1)

  return(as.double(mid))
}

# finally the testing:
print(middle_square_algo(33))

#> 8

Assuming now that we want to loop more than one time the algorithm, the Python code is:

def middle_square_algo_deep(seed, deep):

    # we just need to repeat what we did before but more than one time

    for rep in range(deep):
        seed = int(middle_square_algo(seed))
    return seed

# finally the testing:      
middle_square_algo_deep(33, 3)

#> 9

And similarly, the R code is:

middle_square_algo_deep <- function(seed, deep=2){

  # we just need to repeat what we did before but more than one time

  for( rep in 1:deep){
    seed <- middle_square_algo(seed)
  }

  return(seed)
}

# finally the testing:
middle_square_algo_deep(33, 3)

#> 9

The most important weakness of this algorithm is that it needs an appropriate starting seed. In fact, some seeds have a really short period.

For example the seed 50 has a really short period (1) as shown in the following lines of code:

middle_square_algo_deep(50, 1)
#> 50

middle_square_algo_deep(50, 2)
#> 50

middle_square_algo_deep(50, 3)
#> 50

middle_square_algo_deep(50, 4)
#> 50

Linear congruential generators

The linear congruential generators (LCGs) are a family of PRNGs and are probably the most used approach to generate pseudorandom numbers. The algorithms are defined by a linear congruential equation as the following one:

$$x_{n+1} = ax_n + b \space \space mod(y)$$

where \(a\), \(b\) and \(c\) are positive integers and we also need a seed.

Let's now consider (and then implement) a particular LCG: the Lagged Fibonacci Generator (LFG).

$$x\_{n+1} = a\1 x\{n-1} + a\2 x\{n-j} + b \space \space mod(y)$$

We just need to provide LFG from \(x\_1\) to \(x\_{max(i, j)+1}\) and it will generate a pseudorandom sequence of numbers.

Let me make an example to clear your mind. Let the following equation be our LFG:

$$x\{n+1} = x\{n-3} + x\_{n-5} \space \space mod(10)$$

and let's say we want to generate a sequence of random numbers between 1 and 9 from the initial seed [4, 2, 9, 5, 5].

The sequence starts from \(x\_6\) (you can easily prove that the values before \(x_6\) don't exist by cause of \(max(i, j) = 5\)).

Thus the sequence is:

$$x\{6} = x\{3} + x\_{1} \space \space mod(10) = 9 + 4 \space \space mod(10) = 3$$

$$x\{7} = x\{4} + x\_{2} \space \space mod(10) = 5 + 2 \space \space mod(10) = 7$$

$$x\{8} = x\{5} + x\_{3} \space \space mod(10) = 5 + 9 \space \space mod(10) = 4$$

and so on.

We now implement the LFG in Python and R. In Python the algorithm is something like this:

def lagged_fib_gen(seed, i, j, mod, length, a_1 = 1, a_2 = 1, c = 0):
    l_f = seed

        # we suppose that i < j

    for rep in range(max([i, j]) + 1, length + 1):

        x = (a_1 * l_f[rep - i - 1] + a_2 * l_f[rep - j - 1]) % 10
        l_f.append(x)

    return l_f

# finally the testing:
lagged_fib_gen([4, 2, 9, 5, 5], 3, 5, 10, 10)

#> [4, 2, 9, 5, 5, 3, 7, 4, 8, 2]

In R the algorithm is:

lagged_fib_gen <- function(seed, i, j, mod, length, a_1 = 1, a_2 = 1, c = 0){

  l_f <- seed

  for(rep in (max(c(i, j))+1):length){

    x <- (a_1 * l_f[rep - i] + a_2 * l_f[rep - j]) %% mod
    l_f[rep] <- x
  }
  return(l_f)
}

# finally the testing:
lagged_fib_gen(c(4, 2, 9, 5, 5), 3, 5, 10, 10)

#> 4 2 9 5 5 3 7 4 8 2

As for the middle square algorithm, the efficiency of LGCs depends on the chosen parameters.

Applications of PRNGs

Now we know what PRNGs are, but what are they used for? Well they have many applications, some examples include:

• cryptography: random numbers are used to generate encryption keys (the PRNGs used in cryptography are much more complex than the two I showed before);

• modelling: many scientific simulations use random numbers to represent uncertainty;

• gaming: random numbers are used to make games less predictable and complex (e.g. biomes generation in Minecraft);

• randomized algorithms: some algorithms use randomness to solve problems more efficiently (e.g. the famous Randomized Hill Climbing algorithm).

To go further

As you may imagine, the world of PRNGs is quite vast and complex and has applications in almost every field of science. This article doesn't want to be exhaustive on the topic and is no more than a gentle introduction to PRNGs. To go further there are many resources online but The Art of Computer Programming - Seminumerical Algorithms by D. Knuth and this CRAN vignette are great starting points.

Thanks for reading.

For any question or suggestion related to what I covered in this article, please add it as a comment. For special needs, you can contact me here.

Let me take a step back and explain why I decided to start this journey in blogging. In January 2023 I wrote an article about web scraping in R (you find it here) and I discovered how useful is to share knowledge to deeply understand a topic. In fact not only it requires a deep comprehension of the topic but also great summary skills. Therefore, I decided to create my own blog and here we are.

Embark on this captivating journey with me, as we explore the boundless horizons of science. Together, we'll uncover the extraordinary in the ordinary and ignite our curiosity to new heights.