Home | OpenVQE

Getting Started

Mon, 01 Jan 2024 00:00:00 +0000

Installation

Configure the QLM environment

Cloning the OpenVQE package

Let’s discover OpenVQE package

Project Structure Citation

Package Structure

Mon, 01 Jan 0001 00:00:00 +0000

Folder Structure

OpenVQE consists of two main modules that are inside the “openvqe” folder::

: This module includes different classes and functions to generate the fermionic cluster operators (fermionic pool) and the qubit pools, and to get the VQE optimized energies in the cases of active and non-active orbital selections.
includes two sub-modules: :
- Fermionic-ADAPT/: containing functions performing the fermionic-ADAPT-VQE algorithmic steps in the active and non-active space selections;
- Qubit-ADAPT/: containing functions that perform the qubit-ADAPT-VQE algorithmic steps calculation in the active and non-active space orbital selections.

SubFolder Structure

: stores all the internal functions needed to be imported for executing the two modules.
notebooks: allows the user to run and test the above two modules: UCC Family/ and adapt/.

Updated second version package

OpenVQE main diagram showing the folder structure of the package

OpenVQE code diagram showing the main structure of the code and their involvement when executing VQE.

The refactoring part for is collabrated amongst Nathan Vaneberg and Huy Binh Tran under the guidance of Mohammad Haidar

Nathan Vaneberg
Fullstack engineer consultant at Margo, France
LinkedIn

Citing

Mon, 01 Jan 0001 00:00:00 +0000

If OpenVQE has been helpful in your research, please consider citing our relevant software papers. Your support enables us to continue dedicating time and resources to the development of OpenVQE.

The current version of OpenVQE is described in our .

BibTeX Citation

Below are BibTeX entry for the paper:

---
@article{haidar2023open,
 title={Open source variational quantum eigensolver extension of the quantum learning machine for quantum chemistry},
 author={Haidar, Mohammad and Ran{\v{c}}i{\'c}, Marko J and Ayral, Thomas and Maday, Yvon and Piquemal, Jean-Philip},
 journal={Wiley Interdisciplinary Reviews: Computational Molecular Science},
 volume={13},
 number={5},
 pages={e1664},
 year={2023},
 publisher={Wiley Online Library}
}
---

Simulating lithium-ion batteries on quantum computers

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

Quantum computing provides a promising approach to simulate the ground state energy of battery materials, which is essential for improving battery efficiency. In this tutorial, we simulate the ground state energy of Li$_2$FeSiO$_4$, a lithium-ion battery cathode material, using Variational Quantum Eigensolver (VQE) and its variants. The structure of Li$_2$FeSiO$_4$ is shown below.

Conventional unit cell.

Crystal Structure (Monoclinic)

Methodology

We employ the following algorithms:

VQE to estimate ground state energy by minimizing the expectation value of a Hamiltonian.
Contextual Subspace VQE (CS-VQE) to reduce qubit requirements [1].
CS-ADAPT-VQE, an adaptive VQE variant that selectively includes relevant excitations [2].
Rotoselect for parameter and generator optimization [3].

Setting up Li$_2$FeSiO$_4$

Using Tangelo [4], we define the molecule in its second quantized form:

from tangelo.toolboxes.molecular_computation import SecondQuantizedMolecule

mol = SecondQuantizedMolecule(geometry="Li2FeSiO4", q=0, spin=0,
 basis="sto3g", frozen_orbitals="frozen_core")

Active Space Reduction and Qubit Tapering

To reduce qubits:

Active Space Selection: Select orbitals close to the HOMO-LUMO levels.

frozen_orbitals = get_orbitals_excluding_homo_lumo(mol, homo_minus_n=3, lumo_plus_n=3)
frozen_mol = mol.freeze_mos(frozen_orbitals, inplace=False)

Qubit Tapering: Symmetry-based reduction without affecting Hamiltonian accuracy.

from symmer.projection import QubitTapering

# Obtain hamiltonian
qu_op = fermion_to_qubit_mapping(frozen_mol.fermionic_hamiltonian,
 mapping="JW",
 n_spinorbitals=frozen_mol.n_active_sos,
 n_electrons=frozen_mol.n_active_electrons,
 spin=frozen_mol.spin, up_then_down=False)

# Convert qu_op to Symmer's PauliwordOp and store it in H_q
# Checkout full code for details

# Qubit Tapering
IndependentOp.symmetry_generators(H_q, commuting_override=True)
taper_hamiltonian = QubitTapering(H_q)
taper_hamiltonian.stabilizers.rotate_onto_single_qubit_paulis()
hf_array = qml.qchem.hf_state(frozen_mol.n_active_electrons, frozen_mol.n_active_sos)
taper_hamiltonian.stabilizers.update_sector(hf_array)
ham_tap = taper_hamiltonian.taper_it(ref_state=hf_array)

Contextual Subspace Projection

This involves partitioning $H$ into noncontextual and contextual componenents satisfying $H = H_{\text{NC}} + H_{\text{C}}$:

cs_vqe = ContextualSubspace(ham_tap,
 noncontextual_strategy='StabilizeFirst',
 noncontextual_solver='binary_relaxation',
 unitary_partitioning_method='LCU')

# Quantum Corrections
cs_vqe.update_stabilizers(n_qubits = q) # Set the desired number of qubits
H_cs = cs_vqe.project_onto_subspace()

# Hartree-Fock in contextual subspace
hf_cs = cs_vqe.project_state_onto_subspace(taper_hamiltonian.tapered_ref_state)

CS-VQE

We create a hardware-efficient ansatz (HEA) using CUDA-Q [5] and prepare the Hartree-Fock state for CS-VQE:

def ansatz(n_qubits, num_layers):
 kernel, thetas = cudaq.make_kernel(list)
 qubits = kernel.qalloc(n_qubits)
 # Prepare Hartree-Fock state
 # Define HEA with rotation and entangling layers
 for l in range(num_layers):
 for q in range(n_qubits):
 kernel.ry(thetas[l * n_qubits + q], qubits[q])
 for q in range(n_qubits - 1):
 kernel.cx(qubits[q], qubits[q + 1])\
 # Final rotation layer
 for q in range(n_qubits):
 kernel.ry(thetas[num_layers * n_qubits + q], qubits[q])
 return kernel

ccsd_energy = -3688.046308050882

# Initialize and optimize the VQE kernel
optimizer = cudaq.optimizers.NelderMead()
energy, params = cudaq.vqe(kernel, ham, optimizer,
 parameter_count=(num_layers + 1) * n_qubits)
rel_err(ccsd_energy, energy)

CS-ADAPT-VQE

CS-ADAPT-VQE adaptively selects excitations based on parameter gradients. We select excitations with the highest gradients and perform VQE with selected excitations:

# Calulate the singles and doubles excitations
singles, doubles = excitations(electrons, n_qubits)
kernel, parameters, qubits = create_kernel(n_qubits)
basis_state(kernel, qubits, hf)
for i, wires in enumerate(doubles):
 double_excitation(kernel, parameters[i], [qubits[q] for q in wires])
init_params = [0.0] * len(doubles)
grads = parameter_shift(kernel, ham, init_params)
doubles_select = []
if len(grads):
 doubles_select = doubles[np.argmax(abs(grads))]

# Perform VQE to obtain the optimized parameters for the selected double excitations.
if len(doubles_select):
 kernel, parameters, qubits = create_kernel(n_qubits)
 basis_state(kernel, qubits, hf)
 double_excitation(
 kernel, parameters[0], [qubits[q] for q in doubles_select]
 )
 optimizer = cudaq.optimizers.NelderMead()
 optimizer.max_iterations = 1000
 optimizer.initial_parameters = np.random.uniform(size=1)
 energy, params_doubles = cudaq.vqe(
 kernel, ham, optimizer, parameter_count=1
 )

# Compute gradients for all single excitations.
kernel, parameters, qubits = create_kernel(n_qubits)
basis_state(kernel, qubits, hf)
if len(doubles_select):
 double_excitation(
 kernel, params_doubles[0], [qubits[q] for q in doubles_select]
 )
for i, wires in enumerate(singles):
 single_excitation(kernel, parameters[i], [qubits[q] for q in wires])
init_params = [0.0] * len(singles)
grads = parameter_shift(kernel, ham, init_params)

# Select the single excitation with maximum absolute gradient value
singles_select = singles[np.argmax(abs(grads))]

# Perform the final VQE optimization with all the selected excitations.
kernel, parameters, qubits = create_kernel(n_qubits)
basis_state(kernel, qubits, hf)
parameter_count = 0
if len(doubles_select):
 double_excitation(
 kernel,
 parameters[parameter_count],
 [qubits[q] for q in doubles_select],
 )
 parameter_count += 1
single_excitation(
 kernel, parameters[parameter_count], [qubits[q] for q in singles_select]
)
parameter_count += 1
optimizer = cudaq.optimizers.NelderMead()
optimizer.max_iterations = 100
optimizer.initial_parameters = np.random.uniform(size=parameter_count)
energy, params = cudaq.vqe(
 kernel, ham, optimizer, parameter_count=parameter_count
)

CS-VQE with Rotoselect Optimization

Rotoselect dynamically selects the optimal rotation gates (X, Y, Z) for each parameter to minimize energy:

def rotoselect_cycle(cost, params, generators, n_qubits, hamiltonian, hf):
 for d in range(len(params)):
 params[d], generators[d] = optimal_theta_and_gen_helper(
 d, params, generators, cost_fn, n_qubits, hamiltonian, hf
 )
 return params, generators

# Perform optimization with Rotoselect cycles:

for i in range(n_steps):
 params, generators = rotoselect_cycle(cost_fn, params, generators, n_qubits, ham, hf)
energy = cost_fn(params, generators, n_qubits, ham, hf)

Conclusion and Future Directions

This tutorial demonstrated how CS-VQE, ADAPT-VQE, and Rotoselect optimize battery material simulations using quantum computing. Each approach uniquely balances qubit requirements and accuracy, and future work could explore combining these methods with error mitigation techniques to improve results further.

References

William M Kirby, Andrew Tranter, and Peter J Love. “Contextual subspace variational quantum eigensolver”. Quantum 5 (2021), p. 456.
Jonathan Romero et al. “Strategies for quantum computing molecular energies using the unitary coupled cluster ansatz”. Quantum Science and Technology 4.1 (2018), p. 014008.
Mateusz Ostaszewski, Edward Grant, and Marcello Benedetti. “Structure optimization for parameterized quantum circuits”. Quantum 5 (2021), p. 391.
Valentin Senicourt et al. “Tangelo: An Open-source Python Package for End-to-end Chemistry Workflows on Quantum Computers”. arXiv:2206.12424(2022). doi: 10.48550/arXiv.2206.12424. eprint: arXiv:2206.12424. url: .
The CUDA Quantum development team. CUDA Quantum. url: https : //github.com/NVIDIA/cuda-quantum.

About the author

Gopal Ramesh Dahale
Master's student in Quantum Science and Engineering at EPFL
LinkedIn

Maxcut by Quantum annealing

Mon, 01 Jan 0001 00:00:00 +0000

1. Graph definition

import networkx as nx
from itertools import chain, combinations
import matplotlib.pyplot as plt

import numpy as np

edgelists = [[(0, 1), (0, 2), (1, 2)],
 [(0, 1), (0, 2), (0, 3), (0, 4), (1, 4), (2, 3), (2, 4)],
 [(0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (2, 3), (2, 5), (3, 4), (3, 5)],
 [(0, 1), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (3, 4), (3, 5)]]


coordinate_list = [[(0, 0), (0, 1), (1, 1)],
 [(1, 1), (2, 0), (0, 1), (1, 2), (1, 0)],
 [(1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2)],
 [(1, 2), (1, 1), (2, 0), (1, 0), (2, 1), (0, 0), (0, 2)]]



G_set = [nx.from_edgelist(edgelist) for edgelist in edgelists]

list_matrice_J = []
for graphe in G_set:
 list_matrice_J.append(nx.to_numpy_array(graphe , dtype=int))

fig, axs = plt.subplots(2, 2)
for i, ax in enumerate(fig.axes):
 pos = {n: pos for n, pos in enumerate(coordinate_list[i])}
 nx.draw_networkx(G_set[i], pos, ax=ax)
 ax.set_title("N = {}".format(len(G_set[i].nodes())))

#fig.suptitle("Graphs of Interest")
plt.tight_layout()
plt.show()

2. Classical calculation

from itertools import combinations

def get_max_cut(G):
 """
 This function computes the max cut of a given graph.

 Input: Graph G

 Output: max_cut of the graph and associated partition
 """
 def two_partitions(lst):
 result = set()

 # Generate all possible combinations for the first subset
 for i in range(1, len(lst)):
 for part1 in combinations(lst, i):
 part1 = set(part1)
 part2 = set(lst) - part1 # The other subset is what remains
 # Add the partition to the set to avoid duplicates
 parti = frozenset([frozenset(part1), frozenset(part2)])
 result.add(parti)

 # Convert partitions to lists 
 return [list(map(list, parti)) for parti in result]

 partitions = two_partitions(range(len(G.nodes())))
 new_partitions = []

 for part in partitions:
 cut = 0
 for u in part[0]:
 for v in part[1]:
 if G.has_edge(u, v):
 cut += 1

 # Add the partition with the cut count at the beginning
 new_partitions.append([cut] + part)

 max_cut = max(partition[0] for partition in new_partitions)
 max_cut_partitions = [partition for partition in new_partitions if partition[0] == max_cut]

 return max_cut, max_cut_partitions

for graph in G_set:
 print(get_max_cut(graph))

(2, [[2, [1, 2], [0]], [2, [1], [0, 2]], [2, [0, 1], [2]]])
(5, [[5, [3, 4], [0, 1, 2]], [5, [0, 3, 4], [1, 2]], [5, [1, 2, 3], [0, 4]], [5, [0, 2], [1, 3, 4]]])
(7, [[7, [1, 2, 4, 5], [0, 3]], [7, [0, 4, 5], [1, 2, 3]], [7, [1, 2, 4], [0, 3, 5]], [7, [0, 1, 5], [2, 3, 4]]])
(9, [[9, [2, 4, 5, 6], [0, 1, 3]]])

3. Quantum annealing gate based

The method consists of starting from a Hamiltonian that does not correspond to our graph but rather to a placement of the graph's points independently of each other; this is what we represent by the Hamiltonian $H_x$. Then, we construct an interaction Hamiltonian that maps the connections between the nodes of our graph, which we call the Hamiltonian $H_c$. The Hamiltonian $H_x$ has a well-known ground state. This method involves initializing the system in the ground state of the Hamiltonian $H_x$, then using the parameters $\eta$ to slowly evolve the Hamiltonian $H_{x}$ towards the Hamiltonian $H_c$. Since the evolution is slow, this ensures that the system remains in the ground state throughout the procedure, and thus, in the end, the system is in the ground state of the Hamiltonian associated with our graph $H_c$.

The code

I create the function u_x which is the evolution operator of the Hamiltonian hx.
$$ H_x = \sum_{i}X_i $$

$$ U_x = e^{-iH_{x}dt} $$
I create the function u_c which is the evolution operator of the Hamiltonian hc.
$$ H_c = \sum_{i
$$ U_c = e^{-iH_{c}dt} $$
I create the function U_init() which creates a circuit that returns the ground state of hx.
I create the function u_n which applies the Suzuki-Trotter approximation of $U_{\eta}$.
$$ U_{\eta} = \prod_{j = 1}^{\eta}exp\left(-i\left[\frac{j - 1}{\eta -1}H_{c} + \frac{\eta - j}{\eta -1}H_{x}\right]\right) $$
With Suzuki-Trotter approximation we have:
$$ U_{\eta} \approx \prod_{j = 1}^{\eta}\left[U_{c}\left(\frac{j - 1}{m(\eta -1)}\right)U_{x}\left(\frac{\eta - j}{m(\eta -1)}\right)\right]^{m} $$

We notice that at each iteration, as $\frac{j - 1}{m(\eta -1)}$ increases, $\frac{\eta - j}{m(\eta -1)}$ decreases, which reflects the transition from the Hamiltonian hx to hc.

The function qaoa_circuit simply initializes the circuit in the ground state of $H_{x}$ before applying u_n.
The function ground_state_optimizer() in this function, I use the qaoa_circuit function with the evolve method to retrieve the state vector of our circuit after the evolution of our system:
$$\ket{\Phi_{\eta,m}} = U_{\eta , m}U_{init}\ket{0}$$
Then I calculate cost, which is the eigenvalue of this state vector:
$$C = \bra{\Phi_{\eta,m}}H_{c}\ket{\Phi_{\eta,m}}$$
then we perform optimization on C to make it as small as possible and thus obtain a good approximation of the ground state $\ket{\Phi_{\eta,m}}$. The optimization doesn't seem to work very well, probably because the increments of $\eta$ and m are integers. I could solve this problem for m by changing the way I construct the u_n circuit. I could first obtain the matrix corresponding to
$$ U_{c}(\frac{j - 1}{m(\eta - 1)})U_{x}(\frac{\eta - j}{m(\eta - 1)})$$
Then apply the power m and transform the resulting matrix into an observable, and finally add it to the u_c circuit.
The function calculate_maxcut_from_strings() executes the final task. At this stage, I already have the bit string that corresponds to the partition of the maxcut. In fact, the "0" bits form one partition and the "1" bits form the other. For example, if I have "0101" with the order "0123", then the nodes from zero, namely {0, 2}, form one partition and {1, 3} form the other partition. It only remains to determine the number of edges that connect these partitions, which is the maxcut.

Unfortunately, I couldn't find a simple Python function to estimate the maxc for quick comparisonut.

Also, I notice a small bug at the end of execution. When I perform the following execution, I don't have any convergence. It's only after a third execution that I obtain results.keep the largest one.

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorSampler

from qiskit_ibm_runtime.fake_provider import FakeMelbourneV2

from qiskit_ibm_runtime import EstimatorV2 as Estimator

3.1 Build $U_{x}$

def U_x(n, t):
 """
 input: n: nombre de qubit
 t: temps d'évolution
 ouput: QuantumCircuit
 """
 # Définir les matrices de Pauli et l'identité
 I = SparsePauliOp("I")
 X = SparsePauliOp("X")

 # Initialiser un opérateur total vide
 operator_total = None

 # Boucle pour créer les opérateurs et les additionner
 for i in range(n):
 A = [I] * n
 A[i] = X
 operator = A[0]

 for matrix in A[1:]:
 operator = operator ^ matrix
 if operator_total is None:
 operator_total = operator
 else:
 operator_total += operator

 # Construire la porte d'évolution
 evo = PauliEvolutionGate(operator_total, time=t)

 # Insérer dans un circuit
 circuit = QuantumCircuit(n) # Le nombre de qubits doit correspondre à la longueur de A
 circuit.append(evo, range(n))

 return circuit

# Exemple d'utilisation de la fonction
n = 4
t = 0.2
circuit = U_x(n, t)
circuit.decompose().draw("mpl")

def U_c(n, J, t):
 # Définir les matrices de Pauli et l'identité
 """
 input: nombre de qubit
 branches du graphes
 temps d'évolution
 ouput: QuantumCircuit
 """
 I = SparsePauliOp("I")
 Z = SparsePauliOp("Z")

 # Initialiser un opérateur total vide
 operator_total = None

 # Boucle pour créer les opérateurs et les additionner
 for (i, j) in J:
 # Créer un vecteur de matrices I
 A = [I] * n
 # Remplacer les ième et jième éléments par Z
 A[i] = Z
 A[j] = Z
 # Initialiser l'opérateur avec la première matrice du vecteur
 operator = A[0]
 # Boucle pour effectuer les produits tensoriels
 for matrix in A[1:]:
 operator = operator ^ matrix
 # Additionner les opérateurs
 if operator_total is None:
 operator_total = operator
 else:
 operator_total += operator

 # Construire la porte d'évolution
 evo = PauliEvolutionGate(operator_total, time=t)

 # Insérer dans un circuit
 circuit = QuantumCircuit(n) # Le nombre de qubits doit correspondre à la longueur de A
 circuit.append(evo, range(n))

 return circuit

# Exemple d'utilisation de la fonction
n = 5
adjence_matrix = edgelists[1]
t = 0.2
circuit = U_c(n, adjence_matrix, t)
circuit.decompose().draw("mpl")

3.3 Build $U_{\eta}$

def U_n(neta: int, m: int , nombre_de_qubit, graphe):
 circuit = QuantumCircuit(nombre_de_qubit)

 for j in range(1, neta + 1):
 t_c = (j - 1) / (m * (neta - 1))
 t_x = (neta - j) / (m * (neta - 1))


 Uc = U_c(nombre_de_qubit, graphe, t_c)
 Ux = U_x(nombre_de_qubit, t_x)

 circuit_de_base = QuantumCircuit(nombre_de_qubit)
 circuit_de_base = circuit_de_base.compose(Uc)
 circuit_de_base = circuit_de_base.compose(Ux)

 for i in range(m - 1):
 circuit_de_base = circuit_de_base.compose(Uc)
 circuit_de_base = circuit_de_base.compose(Ux)

 circuit = circuit.compose(circuit_de_base)

 return circuit

circuit = U_n(neta = 2 , m = 3 , nombre_de_qubit= 3 , graphe= edgelists[0])
circuit.draw

4 Post-processing and formatting

def remove_complementary_bits(bit_dict):
 # Dictionary to store without redundancy
 unique_bits = {}

 for bits, value in bit_dict.items():
 # Generate the complement
 complement = ''.join('1' if b == '0' else '0' for b in bits)
 # If the complement is in unique_bits, do not add bits
 if complement in unique_bits:
 continue
 # Add bits to unique_bits
 unique_bits[bits] = value

 return unique_bits

def get_bit_positions(bit_string):
 # List of positions of 0s and 1s
 pos_zeros = [i for i, bit in enumerate(bit_string) if bit == '0']
 pos_ones = [i for i, bit in enumerate(bit_string) if bit == '1']
 return pos_zeros, pos_ones

def plot_top_5_histogram(bit_dict):
 # Remove redundant and complementary strings
 unique_bits = remove_complementary_bits(bit_dict)

 # Sort items by values and keep the top 5 largest
 top_10 = sorted(unique_bits.items(), key=lambda item: item[1], reverse=True)[:5]

 # Separate bit strings and values
 bit_strings, values = zip(*top_10)

 # Get positions of 0s and 1s for each bit string
 bit_positions = [get_bit_positions(bits) for bits in bit_strings]

 # Display the positions of 0s and 1s for each bit string
 for bit_string, (pos_zeros, pos_ones) in zip(bit_strings, bit_positions):
 print(f"bits string: {bit_string}")
 print(f"Set 1: {pos_zeros}")
 print(f"Set 2: {pos_ones}\n")

 # Plot the histogram
 plt.figure(figsize=(6, 3))
 plt.bar(bit_strings, values, width=0.3)
 plt.xlabel('Bit strings')
 plt.ylabel('Values')
 plt.xticks(rotation=90)
 plt.show()


# Plot the histogram and display bit positions
for r in list_result:
 plot_top_5_histogram(r)

bits string: 011
Set 1: [0]
Set 2: [1, 2]
bits string: 110
Set 1: [2]
Set 2: [0, 1]
bits string: 010
Set 1: [0, 2]
Set 2: [1]
bits string: 000
Set 1: [0, 1, 2]
Set 2: []

bits string: 00011
Set 1: [0, 1, 2]
Set 2: [3, 4]
bits string: 10011
Set 1: [1, 2]
Set 2: [0, 3, 4]
bits string: 10100
Set 1: [1, 3, 4]
Set 2: [0, 2]
bits string: 10001
Set 1: [1, 2, 3]
Set 2: [0, 4]
bits string: 10101
Set 1: [1, 3]
Set 2: [0, 2, 4]

bits string: 100101
Set 1: [1, 2, 4]
Set 2: [0, 3, 5]
bits string: 100100
Set 1: [1, 2, 4, 5]
Set 2: [0, 3]
bits string: 011100
Set 1: [0, 4, 5]
Set 2: [1, 2, 3]
bits string: 110001
Set 1: [2, 3, 4]
Set 2: [0, 1, 5]
bits string: 001001
Set 1: [0, 1, 3, 4]
Set 2: [2, 5]

bits string: 1101000
Set 1: [2, 4, 5, 6]
Set 2: [0, 1, 3]
bits string: 0100101
Set 1: [0, 2, 3, 5]
Set 2: [1, 4, 6]
bits string: 1110010
Set 1: [3, 4, 6]
Set 2: [0, 1, 2, 5]
bits string: 1010110
Set 1: [1, 3, 6]
Set 2: [0, 2, 4, 5]
bits string: 1011011
Set 1: [1, 4]
Set 2: [0, 2, 3, 5, 6]

References

Edward Farhi, Jeffrey Goldstone,Joshua Lapan, Andrew Lundgren, Daniel Preda. "A Quantum Adiabatic Evolution Algorithm Applied to Random Instances of an NP-Complete Problem" Science. 284 (5415): 779–81.

About the author

Isaac Christ Donchi Kamga
Ing , Msc in quantum computing and quantum engineering, France
LinkedIn

Quantum Cryptography - Voting Scheme

Mon, 01 Jan 0001 00:00:00 +0000

What we need to know about Quantum Cryptography

Back in Time - The beginnings

Cyptography is the science, at the crossroads of mathematics, physics, and computer science, that tends to design protocols to prevent malicious third-party from reading private messages. Even if the development of computers during the 20th century made the research in cryptography explode, the use of cryptographic methods was common before. It is believed that Julius CAESAR used an encryption method, today known as Caesar Cipher or Alphabet Shift Cipher. The principle is very simple: imagine you want to encode the 26 letters of the Roman alphabet (A to Z), you then assign each letter a number (A is 0, B is 1, …, Z is 25). You then choose a secret key which is a non-zero integer. The encrypted message is composed of letters, the code of each letter being given by the modulo 26 addition between the code of the original letter and the secret key. Basically, the alphabet is shifted by a constant:

Like PASQAL with s=3 will be SDVTDO

# A Python program to illustrate Caesar Cipher Technique
def encrypt(text, s):
 result = ""

 # Traverse the text
 for i in range(len(text)):
 char = text[i]

 # Encrypt uppercase characters
 if char.isupper():
 result += chr((ord(char) + s - 65) % 26 + 65)

 # Encrypt lowercase characters
 else:
 result += chr((ord(char) + s - 97) % 26 + 97)

 return result

# Check the above function
text = "PASQAL" # INPUT 
s = 3
print("Text: " + text)
print("Shift: " + str(s))
print("Cipher: " + encrypt(text, s))

Results:

Text: PASQAL Shift: 3 Cipher: SDVTDO

If we note $n$ the position of the char in the string, $U_n$ the unencrypted char, En the encrypted char, and $K$ the shift:

$$E_{n}=U_{n}+K\text{mod} \left[ 26\right]$$

For instance,

This table displays the positions of each character in the message “PASQAL,” the unencrypted characters, the result of $U_n +K$ the result of $U_{n}+K\text{mod} \left[ 26\right]$, and the encrypted characters using a Caesar Cipher with a secret key of 3, with the appropriate formatting for mathematical expressions.

n	Char	Unencrypted Char	$U_{n}$	$U_{n} + K$	$U_{n} + K \mod 26$	Encrypted Char
1	P	15	15	18	18	R
2	A	0	0	3	3	D
3	S	18	18	21	21	U
4	Q	16	16	19	19	T
5	A	0	0	3	3	D
6	L	11	11	14	14	O

This code is very simple to break, as you can easily find patterns. For instance, you can compare the frequencies of each letter of the alphabet. In the English language, the most common letter is E with a frequency of 12.7%, followed by the letter T with a frequency of 9.06% . You then compute the frequencies of the encrypted message. The most common letter in the encrypted text will probably be the encrypted char corresponding to E, or T. This method can be applied to all encryption schemes were a letter is always transformed to the same letter.

For this scheme, it also just possible to test the 25 possible secret keys and stop when you have a meaningful message.

Fortunately, cryptology has evolved since them. Even before the invention of the computer, the Germans used a very secure scheme (at that time) to encrypt message during the Second World War. It was secure in two ways:

The setup has high combinatorial complexity. Germans have to choose 3 rotors in 5 possibil- ities, choose each initial positions for the rotors (26 possibilities each), and then choose 10 pairs in the plugboard, resulting in the combinatorial complexity

$$5\times 4\times 3\times 26^{3}\times \frac{26!}{6!\times 10!\times 2^{10}} =158,962,555,217,826,360,000$$

This is not possible to test all possibilities for a human, nor at that time for a machine.

Unlike the Caesar Cipher, a letter would not become the same letter every time, as the ro- tors were moving at each letter. This is important because pattern methods (to compare frequencies of the language with the ones in the encrypted text) cannot be used.

The Enigma machine was broken by a team mainly lead by Alan Turing using a machine called Bombe and some flaws of the Enigma machine. In the end, the Enigma configuration could be found in 20 minutes.

Up-to-date Cryptography

With the arrival of computers and communication networks came also a greater need for cryptography.

In our modern world, cryptography is ubiquitous. When you load a web page in a browser with a small padlock next to the URL, you are using symmetric and asymmetric encryption without knowing it. When you open some messaging app, like WhatsApp, you are using, again without knowing it (I mean without the user making anything for the cryptographic exchange to happen. It is totally transparent for the user) symmetric and asymmetric encryption, providing end-to-end encryption.

Symmetric and asymmetric encryption are different in their essence. A symmetric encryption scheme uses a secret key to encrypt and to decrypt the message. This means that the two (or more) parties that are communicating need to have the same, and secret, key. Symmetric schemes have several issues:

The key exchange must be truly secret to ensure the privacy of the encrypted message;
If you use the key to encrypt more than one time, information can be extracted from the encrypted message;
The protocol doesn’t scale well (i.e. if you want to have encrypted discussion between several users, you have to share the secret key between all the users, which mean, more chance of information leakage).

They have also some advantages: there are easier to understand and to implement and they need less computational power than asymmetric encryption.

In contrast, an asymmetric encryption scheme or public key encryption scheme is a scheme where two keys are used:

The Public key is used only to encrypt messages. It can be distributed without risk to anyone who wants to send an encrypted message to the owner of the private key. The public key can be thought of as an open padlock. Once closed only the private key can unlock it.
The secret key is used only to decrypt messages (and to generate the public key). It should be kept secret. The secret key can be seen as a key that opens every padlock closed by the public key.

One of the most used asymmetric encryption scheme today is the RSA. It is based on some mathematical observations. Let’s recall some arithmetical properties:

A prime number is a whole number with exactly 2 distinct divisors. Every integer greater or equal than 2, that is not a prime number is called a composite number.
Every whole number can be uniquely written as a product of prime numbers: $$n=p^{\alpha_{1} }_{1}p^{\alpha_{2} }_{2}\ ...\ p^{\alpha_{k} }_{k}$$
A product of two prime numbers is called a semi-prime number. It has 3 or 4 distinct divisors (3 if it is a square of a prime number).

The basic idea of the RSA scheme follows: it easy to multiply 2 prime numbers to obtain a semi-prime number but it’s difficult to factorize a semi-prime number into 2 prime numbers.

$$3\times 7=?\ \text{Easy !} $$

$$13\times 19=?\ \text{Less easy but alright } $$

$$ 187 = ? \times ? \text{difficult } $$

$$ 186797 = ? \times ? \text{Nasty af } $$

10016444466812877516651347592092877606999325867156134902126474870576401310371509197937849497 32061828879847934816861684862864326449214280155473757303841537670351486905855745788953294686653 05667852687855685298115910404311303180404287100354588108313006482467735715047743256036128648480 80027194762485965856140145864228400743999303156570382089086775865731055296724143521221327468628 21950171266360637073763193766827057457206146627252158883606266393926431447227342695628623860494 83076188549980295606990827731968687429507788792780286440882172770001367957911700000685949637652 38831914470509293382332669418868301436781248853885000370663778352581253239270257156871660127150 01725765933851378635689651151763527144099274447723857372797474452663650725422387256011846500895 56049862683135640206298862612679119720709968586034215160997260304220155673434151135668320749865 84807932093124539029156912634836160456728007753201898072897827815590459999295298908223557195231 58977763724441639028178539046224952247530731887239092769161189850803594847326119864462181341673 60716012369946975020768242661592323585459972285070236101616423672439653172724479999925676798119 71560093919447685551083829047142039685301977153590924844326332056772159786693521935447299870583

A human being cannot factorise this semi-prime number, nor can a machine at the time this paper is written. In 1991, the RSA laboratories published 50 semi-prime numbers (called the RSA numbers) from 100 to 2048 decimal digits. For some numbers, a reward was offered for the factorisation of the number. Some easy numbers were factorised quite quickly (the RSA-100 was factorised less than 2 weeks after the publication of the challenge) and some of them are still being factorised today (the example of the RSA-250 that was factorised in February 2020 is relevant) even if the challenge ended in 2007. The biggest RSA number to have ever been factorized is the RSA 768, that was factorized in 2009 using the General Number Field Sieve (GNFS).

The GNFS is the best-known algorithm for factorising integer (at least for large integers). The GNFS has an algorithmic complexity of

$$\exp \left\{ \left[ \sqrt[3]{\frac{69}{4} } +O\left( 1\right) \right] \left( \text{ln} \left( n\right) \right)^{\frac{1}{3} } \left[ ln\left( ln\left( n\right) \right) \right]^{\frac{2}{3} } \right\} $$

where $n$ is the integer to factorise. As we won’t discuss much more of how the GNFS works, the interested reader may refer to for a discussion on the algorithm and the complexity. The GNFS is one the best algorithm to factorise integer, but, nevertheless, it would take more than a billion years to factorise a 2048 digit key. In this sense, the RSA is a secure protocol.

I would like to emphasise here that the security of the RSA scheme is based on a computation- ally hard mathematical problem and the belief that we won’t find another more efficient and much quicker algorithm to solve the problem. But we are believing in the security of the RSA because it has survived 50 years of attacks.

Quantum cryptography

In the early ’80s, the idea of a quantum computer began to grow and with it, the hope to compute and simulate things that were not possible or will ever be possible on a classical computer [6, 7]. In particular, FEYNMAN proposed to simulate Physics with a quantum computer, that he didn’t assimilate to the quantum analog of a Turing machine but rather, to a universal quantum simulator. BENIOFF, in his paper, explored the possibility of a quantum Turing machine, or universal quantum computer. Without speaking more about the idea of a quantum Turing machine, we will see that we are today far from having such a computer.

One of the main advantages of quantum information is the superposition principle. The qubit, the analog of the classical bit, can take the value |0⟩ (analog of the bit 0), the value |1⟩ (analog of the bit 1), or a superposition of the two, meaning that with one qubit, we can store much more information than with one bit. We saw some vulgarisation programs that compared the classical bit to a switch. Then a qubit was compared to a switch that could be open, closed, and both at the same time. But this doesn’t feel like a good comparison, and they often don’t speak about the measurement.

The information encoded in the superposition of state, if not used correctly, will be destroyed when a measurement on the qubit is made.

There was also the hope of a quantum speedup, i.e. to compute or simulate things faster on a quantum computer than on a classical computer one even if the computation or simulation was possible in the first place.

One of the simplest examples is GROVER’s algorithm. The basic idea of GROVER’s algorithm is to find an element in a list. Supposing a list of length $N$, using a classical algorithm, the best case is to find the element in the first position, the worst case, in the $N$ th position, and on average, you need $\frac{N}{2}$ operations, which means a complexity in $O\left( N\right)$ . Using a technique called amplitude amplification, GROVER’s algorithm has a complexity of $O\left( \sqrt{N} \right) $

Another promising algorithm is SHOR’s algorithm. It was introduced in 1997 by Peter SHOR . The purpose of SHOR’s algorithm is to factorize integers and has a complexity of

$$\left( \text{ln} \left( n\right) \right)^{2} \left( \text{ln} \left( \text{ln} \left( n\right) \right) \right) \left( \text{ln} \left( ln\left( ln\left( n\right) \right) \right) \right) $$

This algorithm is much faster than the most efficient classical algorithm. I won’t explain in detail how SHOR’s algorithm works, but it’s based on a classical algorithm with a quantum subroutine, that finds a period of a function, using Quantum Fourier Transform

Then, we might break the RSA in the foreseeable future. There are however several issues. Although Google claimed to have reached Quantum Supremacy, i.e. they claimed to have computed something that is not computable on classical computers (they estimated at 10 000 years the amount of time needed on the most powerful classical computers to compute what they did in 200 seconds), they have done a task that is quite resilient to errors. SHOR’s algorithm is less error-resilient and the error rate that we have in quantum computers today is too high for factorising large integers. Today, the largest integer factorised by SHOR’s algorithm is 21.

Nevertheless, we might see the RSA broken in the near future. What must be understood is that any encrypted message saved by a malicious party could be decrypted as soon as RSA is broken. This means that any private message sent today can become a public message later. To prevent those issues, some governments and companies are working in an area called post- Quantum Cryptography.

Post-Quantum Cryptography

In 2016, the NATIONAL INSTITUTE OF STANDARDS AND TECHNOLOGY (NIST) of the US Department of Commerce issued a report on post-Quantum Cryptography. It first described what is the core of modern cryptography: public-key encryption, digital signatures, and key exchange. Some other components are required and we will talk of them later. Then the report continues by de- scribing how a potential quantum computer would be capable of breaking or at least weakening some of those algorithms. The RSA, as we saw, would become insecure and the AES (Advanced Encryption Standard) which is a widely used symmetric scheme to encrypt data would require larger keys (GROVER’s algorithm can help breaking symmetric encryption).

The issue is the fact that those algorithms use some kind of mathematical problem that is hard to solve on a classical computer (factorising whole numbers or the discrete log problem) and that we could experience a quantum speedup to solve those problems.

Then there are two approaches to solve this problem:

find mathematical problems that are impossible to solve in a reasonable amount of time even with a quantum computer
use physical constraints, using for example quantum mechanics to design unconditionally secure protocols.

The first point is more on the classical side of Quantum Cryptography and that is usually what we mean when we talk about post-Quantum Cryptography. Some problems are already good candidates for such algorithms and some of them are already implemented. Indeed, even if SHOR’s algorithm can break cryptosystems based on large integer factorisation or discrete logarithms, it can’t be applied to some other cryptosystems like

Hashed-based cryptography (for example MERKLE’s hash tree)
Code-based cryptography (MCELIECE’s hidden-Goppa-Code)
Lattice-based cryptography (NTRU)
Multivariate-quadratic-equations cryptography
Symmetric cryptography (recent symmetric cryptography schemes are considered pretty se- cure against quantum attacks)

GROVER’s algorithm can provide help to break some of those schemes, but as the algorithm has a smaller speedup, it is sufficient to use a larger key. But we may one day find a quantum algorithm that can help breaking any of these cryptosystems (even if these schemes are believed to be quantum-safe and selected by the NIST).

Quantum Voting

Overall articles

Electronic voting

Electronic voting refers to two types of voting methods:

First, when electronic devices are placed at voting locations, i.e. under the responsibility of government officials
Secondly, when internet voting is used, i.e. citizens can vote from wherever they want.

Two main requirements for voting were identified in: Why Electronic Voting Is Still A Bad Idea

Voting Requirements

A secure voting system must satisfy two fundamental requirements:

Anonymity: It must be impossible to identify how any individual voted after the election.
Trustworthiness: Each voter must be able to verify that their vote was properly counted.

These requirements are particularly challenging to meet with electronic voting systems, especially when voting is conducted over the internet.

Quantum Voting

Following by the two articles above, we are going to specify in more detail the requirements of a voting scheme. An open ballot system is a voting scheme where users sign their ballot or make them identifiable in some way. In this system, each voter can know what an other voter has voted. For instance, a “show of hands” vote in a general assembly or when MPs cry “aye” or “no” in the UK Parliament are examples of open ballot systems. Opposed to those systems are the closed ballot systems, or anonymous systems, that have 3 main requirements:

Correctness: a vote that is considered valid (i.e. with no identifying mark and from a valid voter) should be counted. A vote that is no considered valid should not be counted
Anonymity: Votes are anonymous (i.e. no identifying mark on the ballot (a system of voting secretly and in writing on a particular issue)
Receipt-free: there should not be any way to know how a voter voted or even if he has voted after the election.

A system of voting secretly and in writing on a particular issue. In the article

the authors presented a voting scheme based on conjugate coding and uses the same bases and states that the BB84 protocol which is one of the first examples of plausible Quantum Cryptography the aim is to share a secret key without any pre-shared secret (or a very small one). This voting scheme requires:

A counter, or scrutinizer $C$. He will verify and count votes. He needs to be trusted.
An administrator$ A$. He will issue blank ballots. There is no need for total trust in the administrator as he can be supervised by $C$, or even split into several parties (each party can forge a part of the ballot)
$v$ voters $V_i (i = 1,...n)$ In the beginning, the administrator A forges blank ballots for every voter. We now explain what a blank ballot is:

We denote by $n$ a security parameter which is the length of a blank piece. A blank ballot is composed of several blank pieces.

At the beginning, the administrator randomly creates a secret $K$. This secret is the choice of $n+1$bases chosen between $B_x$ and $B_z$ :

 $$K = (B_{1}, B_{2}, \ldots, B_{n+1})$$

To forge a blank piece, the administrator randomly chooses $n$ bits $b_{1},b_{2},b_{3},...b_{n}$ and $b_{n+1}$ is defined to be $b_{n+1}=b_{1}\oplus b_{2}\oplus ...b_{n}$ . The bits ( $b_{1}...b_{n+1}$ ) re encoded into quantum states using the bases of the secret $K$

For instance, if $n=2$, with $K=(B_{x},B_{z},B_{x})$. A valid blank piece would be, using $b_{1}=1$ and $b_{2}=0$

 $$(|-\rangle, |0\rangle, |-\rangle)$$

To construct a blank ballot for voter, $V_i$ , the administrator constructs $m$ blank pieces with $r^{i}_{1},...r^{i}_{m},$

 $$r^{i}_{j} = (b^{i}_{j,1}, \ldots, b^{i}_{j,n+1})$$

and $$ $b^{i}_{j,\ n+1}=b^{i}_{j,1}\oplus ...\oplus b^{i}_{j,n}$ for $j=1,...,m.$

Next, one blank ballot is sent to each voter

When the voter receives his ballot, he will first randomize the ballot. This step is here to preserve the anonymity of the voter. This is done as follows: for each state of each blank piece of the blank ballot, the voter will apply either the identity or the gate $\sigma_{x} \sigma_{z}$ . For the n first states of the blank piece, the gate to apply is chosen at random. For the last bit of the blank piece, the gate is the identity, if the gate $\sigma_{x} \sigma_{z}$ was applied an even number of times on the $n$ first states and $\sigma_{x} \sigma_{z}$ if the gate $\sigma_{x} \sigma_{z}$ was applied an odd number of times, this will make the blank piece stay valid. The gate $\sigma_{x} \sigma_{z}$ flips the state without changing its basis (the gate may change the overall phase but this cannot be measured).

$$\sigma_{x} \sigma_{z} |0\rangle = \sigma_{x} |0\rangle = |1\rangle$$

$$\sigma_{x} \sigma_{z} |1\rangle = -\sigma_{x} |0\rangle = -|0\rangle$$

$$\sigma_{x} \sigma_{z} |+\rangle = \sigma_{x} |-\rangle = -|-\rangle$$

$$\sigma_{x} \sigma_{z} |-\rangle = \sigma_{x} |+\rangle = |+\rangle$$

where

$$|\pm \rangle = \frac{1}{\sqrt{2}} (|0\rangle \pm |1\rangle)$$

By doing this step, the basis for each state remains the same, but the value if random. Also, the blank pieces remain valid.

Now that the voter has to cast his vote. We suppose that the set of all possible votes is a subset of $\left\{ 0,1\right\}^{m}$ . To write his vote, the voter applies either the identity (if he wants to encode a $0$) or the gate $\sigma_{x} \sigma_{z}$ (if he wants to encode a 1) to the last state of each blank piece.

Finally, the voter sends his vote to the counter $C$. Once the counter has received all votes, the administrator sends $K$ to the counter through a secure classical channel. For each ballot, he measures each piece using $K$. The value of the bit for the piece is retrieved by summing all the results. The counter $C$ verifies that the results are indeed a possible vote. If it is, the vote is counted, and if not, the vote is discarded.

The security of this voting scheme relies on the fact that a malicious party cannot create a ballot with a valid choice with high probability without knowing the secret $K$. In fact, the probability for a ballot that was forged without $K$ to be accecpted is $\frac{Candidates}{2^{m}}$ . As the number of candidates is constant, the probability can be made arbitrarily small by adding pieces to the ballot.

Let’s see a quick example before concluding this section. Let $n=3$ with two possible candidates: $010$ and $101$. The secret key is $K=\left( B_{z},B_{x},B_{x},B_{z}\right)$

The administrator A forges the ballot:

$$(|1\rangle, |+\rangle, |+\rangle, |1\rangle)$$

$$(|0\rangle, |-\rangle, |+\rangle, |1\rangle)$$

$$(|0\rangle, |-\rangle, |-\rangle, |0\rangle)$$$$(1,0,0,1), (0,1,0,1), (0,1,1,0)$$

The ballot is randomised by the voter:

$$(|1\rangle, |+\rangle, |+\rangle, |1\rangle)$$

$$(|0\rangle, |+\rangle, |+\rangle, -|0\rangle)$$

$$(|1\rangle, |-\rangle, |+\rangle, |0\rangle)$$

Applying the following the operators:

$$I \otimes I \otimes I \otimes I$$

$$I \otimes \sigma_{x} \sigma_{z} \otimes I \otimes \sigma_{z} \sigma_{x}$$

$$\sigma_{x} \sigma_{z} \otimes I \otimes \sigma_{x} \sigma_{z} \otimes I$$

The voter wants to vote for $101$ so he will flip the last states for the first and last pieces (the blank ballot corresponds to $000$, and the final ballot is hence

$$(|1\rangle, |+\rangle, |+\rangle, -|0\rangle)$$

$$(|0\rangle, |+\rangle, |+\rangle, -|0\rangle)$$

$$(|1\rangle, |-\rangle, |+\rangle, |0\rangle)$$

Applying the following the operators:

$$I \otimes I \otimes I \otimes \sigma_{x} \sigma_{z}$$

$$I \otimes I \otimes I \otimes I$$

$$I \otimes I \otimes I \otimes \sigma_{x} \sigma_{z}$$

The counter C then makes measurements using the bases of K and finds the following results:

$$(1,0,0,0) \oplus_{2} = 1$$

$$(0,0,0,0) \oplus_{2} = 0$$

$$(0,1,1,1) \oplus_{2} = 1$$

where, $\oplus_{2} \$ is the sum modulo $2$ over all the results of the measurements of one piece. $C$ finds the vote $101$ which is a correct vote and count it.

Evaluation

This protocol uses conjugate coding to implement a voting scheme. It is unconditionally guaranteed anonymous and has the property of correctness if the one-more unforgettability. This assumption is the following: there is no polynomial-time quantum algorithm that can create $l+1$ blank pieces out of $l$ blank pieces with high probability. However, to be implemented it requires quantum memory.

Also, the counter must be absolutely trusted. A version can remove this assumption: where a voter sends his vote to all other voters. The secret is shared with every voter after all the votes have been cast. This is however much heavier in quantum resources.

Conjugate coding is one of the most important notions of Quantum Cryptography. The term is attributed to WIESNER, who proposed the idea in an unpublished (at first) and unnoticed article written in 1970, but was published in 1983 after Quantum Cryptography became a more plausible idea .

It is also called quantum coding and quantum multiplexing. The basic idea is that we can encode our classical bits 0 or 1 in different bases, and that a measurement in one of the basis will completely randomise the result in the other.

Consider for example the bases $B_z$ and $B_x$

$$B_{z} = \{|0\rangle, |1\rangle\}$$

$$B_{x} = \{|+\rangle, |-\rangle\}$$

$$|\pm \rangle = \frac{|0\rangle \pm |1\rangle}{\sqrt{2}}$$

Now imagine you want to encode the bit. If you do so in the $B_z$ basis, you will have the state $|1\rangle$ . Now if you measure this state in the $B_z$ basis, you will always obtain $|1\rangle$ and recover the good bit as

$$|\langle 0|1\rangle|^{2} = 0$$

$$|\langle 1|1\rangle|^{2} = 1$$

But, if you make a measurement in the $B_x$ basis, you will have the state $|+\rangle$ and recover the bit $0$, so the bad one) half of the time $|-\rangle$ (and recover the good bit) the other half since

$$|\langle +|1\rangle|^{2} = \frac{1}{2}$$

$$|\langle -|1\rangle|^{2} = \frac{1}{2}$$

We say that $B_z$ and $B_x$ are conjugate to each other.

This is the code for the BB84 protocol steps by steps:

from random import randint
bits =[]
for i in range(8):
 bit = randint(0,1)
 bits.append(bit)

Output: [0, 1, 1, 1, 0, 0, 0, 0]

from random import choice
for i in range(8):
 base = choice(['X','Z'])
 basis.append(base)
basis

Output: [‘X’, ‘Z’, ‘X’, ‘X’, ‘X’, ‘Z’, ‘X’, ‘Z’] `

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
q = QuantumRegister(8)
c = ClassicalRegister(8)
qc = QuantumCircuit(q,c)

for i in range(8):
 if basis[i]=='Z':
 if bits[i]==0:
 qc.i(q[i])
 else:
 qc.x(q[i])
 else:
 if bits[i]==0:
 qc.h(q[i])
 else:
 qc.x(q[i])
 qc.h(q[i])
qc.barrier()
qc.draw('mpl')

bobs_base =[]
for i in range(8):
 base = choice(['X','Z'])
 bobs_base.append(base)
bobs_base


for i in range(8):
 if bobs_base[i]=='Z':
 qc.measure(q[i],c[i])
 else:
 qc.h(q[i])
 qc.measure(q[i],c[i])
qc.draw('mpl')

#Running on Qsasimulator
from qiskit import transpile
from qiskit.providers.aer import QasmSimulator
backend = QasmSimulator()
qc_compiled = transpile(qc,backend)
job = backend.run(qc_compiled,shots = 1)
result = job.result()
counts = result.get_counts()
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
result = list(counts.keys())[0]
result
for i in range(8):
 if bobs_base[i]==basis[i]:
 print(result[i])

A nice web for the QKD with BB84 with steps can be read from here:

Pitch sum-up

Introduction:

In our quest for a sustainable future, every decision counts. From policy choices to technological advancements, the path we take today will shape the world we leave for future generations. One crucial aspect of this journey is ensuring that our voting systems are secure, transparent, and capable of fostering trust in the democratic process. In this context, we propose a revolutionary shift from traditional electronic voting systems to quantum voting schemes to support sustainable energy initiatives.

The Current Challenge: Electronic voting systems have been the backbone of modern democracies for years. However, they come with inherent vulnerabilities, including the risk of cyberattacks and data breaches. In the subject of sustainable energy, where decisions can have profound global impacts, it is imperative that the voting process is beyond reproach and immune to manipulation. Quantum voting offers a paradigm shift in this direction.

Quantum Voting: A Game-Changer for Sustainable Energy:

Unprecedented Security: Quantum voting leverages the laws of quantum mechanics to provide an unparalleled level of security. Unlike electronic voting systems, where vulnerabilities can be exploited, quantum voting relies on the fundamental principles of quantum entanglement and superposition, making it virtually impossible for malicious actors to tamper with the process.
Transparency and Verifiability: Quantum voting ensures that each vote is transparently recorded and verified, enhancing trust in the electoral process. Quantum states, once measured, cannot be altered without detection, providing an immutable record of the vote.
Encouraging Global Collaboration: Sustainable energy initiatives often require international cooperation. Quantum voting enables secure and tamper-proof cross-border voting, fostering trust among nations and facilitating collaborative efforts in the transition to sustainable energy sources.
Protecting Minority Voices: In the pursuit of sustainable energy, it is crucial to consider the interests of all stakeholders, including minority groups. Quantum voting allows for secure and anonymous voting, ensuring that even marginalized voices are heard and respected.
Long-Term Viability: Quantum technologies are on the rise and are poised to become an integral part of our future. By adopting quantum voting now, we future-proof our electoral systems and position ourselves at the forefront of technological innovation in the pursuit of sustainable energy.

Conclusion: The transition to sustainable energy is a global imperative, and the decisions we make today will have far-reaching consequences. Quantum voting offers an innovative solution to the challenges of security, transparency, and trust in the democratic process, making it an ideal choice for shaping the future of sustainable energy initiatives. By embracing quantum voting, we not only safeguard the integrity of our elections but also demonstrate our commitment to a greener, more sustainable world. It’s time to take the quantum leap for a sustainable energy future

References

Rui-Rui Zhou, Li Yang. "Quantum election scheme based on anonymous quantum key distribution" Chinese Physics B, Volume 21, Number 8.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Quantitative Finance

Mon, 01 Jan 0001 00:00:00 +0000

What are the Different Types of Mathematics Found in Quantitative Finance?

The real-world subject of quantitative finance uses tools from many branches of mathematics. And financial modelling can be approached in a variety of different ways. For some strange reason the advocates of different branches of mathematics get quite emotional when discussing the merits and demerits of their methodologies and those of their ‘opponents.’’ Is this a territorial thing? What are the pros and cons of martingales and differential equations? What is all this fuss, and will it end in tears before bedtime? Here’s a list of the various approaches to modelling and a selection of useful tools. The distinction between a ‘modelling approach’ and a ‘tool’ will start to become clear.

Modelling approaches

Probabilistic : One of the main assumptions about the financial markets, at least as far as quantitative finance goes, is that asset prices are random. We tend to think of describing financial variables as following some random path, with parameters describing the growth of the asset and its degree of randomness. We effectively model the asset path via a specified rate of growth, on average, and its deviation from that average. This approach to modelling has had the greatest impact over the last 30 years, leading to the explosive growth of the derivatives markets.
Deterministic: The idea behind this approach is that our model will tell us everything about the future. Given enough data, and a big enough brain, we can write down some equations or an algorithm for predicting the future. Interestingly, the subjects of dynamical systems and chaos fall into this cat- egory. And, as you know, chaotic systems show such sensitivity to initial conditions that predictability is in practice impossible. This is the ‘butterfly effect,’ that a butterfly flap- ping its wings in Brazil will ‘cause’ rainfall over Manchester. (And what doesn’t!) A topic popular in the early 1990s, this has not lived up to its promises in the financial world.
Discrete: difference equations: Discrete means that asset prices and/or time can only be incremented in finite chunks, whether a dollar or a cent, a year or a day.
Continuous: differential equations: Continuous means that no such lower increment exists. The mathematics of continuous processes is often easier than that of discrete ones. But then when it comes to number crunching you have in any case to turn a continuous model into a discrete one.

For an important example: In discrete models we end up with difference equations. An example of this is the binomial model for option pricing. Time progresses in finite amounts, the time step. In continuous models we end up with differential equations. The equivalent of the binomial model in discrete space is the Black–Scholes model, which has continuous asset price and continuous time. Whether Binomial or Black–Scholes, both of these mod- els come from the probabilistic assumptions about the financial world.

Usefull tools

Simulations: If the financial world is random then we can experiment with the future by running simulations. For example, an asset price may be represented by its average growth and its risk, so let’s simulate what could happen in the future to this random asset. If we were to take such an approach we would want to run many, many simulations. There’d be little point in running just the one; we’d like to see a range of possible future scenarios. Simulations can also be used for non-probabilistic problems. Just because of the similarities between mathematical equations, a model derived in a deterministic framework may have a probabilistic interpretation.
Discretization methods: The complement to simulation methods, and there are many types of these. The best known are the finite-difference methods which are discretizations of continu- ous models such as Black–Scholes.
Approximations: In modelling we aim to come up with a solution representing something meaningful and useful, such as an option price. Unless the model is really simple, we may not be able to solve it easily. This is where approximations come in. A complicated model may have approximate solutions. And these approximate solutions might be good enough for our purposes.
Asymptotic analysis: this is an incredibly useful technique, used in most branches of applicable mathematics, but until recently almost unknown in finance. The idea is simple: find approximate solutions to a complicated problem by exploiting parameters or variables that are either large or small, or special in some way. For example, there are simple approximations for vanilla option values close to expiry.
Series solutions: If your equation is linear (and they almost all are in quantitative finance) then you might be able to solve a particular problem by adding together the solutions of other problems. Series solutions are when you decompose the solu- tion into a (potentially infinite) sum of simple functions, such as sines and cosines, or a power series. This is the case, for example, with barrier options having two barriers, one below the current asset price and the other above.
Green’s functions : Green’s functions are mathematical tools used in physics and engineering to solve differential equations that describe various physical phenomena, such as heat conduction, fluid flow, or electromagnetic fields. This is a very special technique that only works in certain situations. The idea is that solutions to some difficult problems can be built up from solutions to special cases of a similar problem.

Present value and future value of money

In finance, the present value (PV) and future value (FV) of money are essential concepts that help in evaluating the time value of money. The time value of money is the idea that money available at the present time is worth more than the same amount in the future, due to its potential earning capacity.

Present value (PV): This is the present value of $x with the consideration interest rate $r$ and the $x$ cash flow in the future with respect to the number of year. This defines how much of a future sum of money is worth today given a specific rate of interet $$\frac{x}{(1+r)^{n}} $$

Future value: is the value of a current asset at a specified date in the future based on an assumed rate of growth over time

$$x(1+r)^{n}$$

If we have to deal with the continous mode with diferential equation. The interest I receive must be proportional to the actual x(t) amount I have and the r interest rate and the dt time step

$$x(t)=x(0)e^{rt}$$

from math import exp


def future_discrete_value(x, r, n):
 return x*(1+r)**n


def present_discrete_value(x, r, n):
 return x*(1+r)**-n


def future_continuous_value(x, r, t):
 return x*exp(r*t)


def present_continuous_value(x, r, t):
 return x*exp(-r*t)


if __name__ == '__main__':

 # value of investment in dollars
 x = 100
 # define the interest rate (r)
 r = 0.05
 # duration (years)
 n = 5

 print("Future value (discrete model) of x: %s" % future_discrete_value(x, r, n))
 print("Present value (discrete model) of x: %s" % present_discrete_value(x, r, n))
 print("Future value (continuous model) of x: %s" % future_continuous_value(x, r, n))
 print("Present values (continuous model) of x: %s" % present_continuous_value(x, r, n))

Future value (discrete model) of x: 127.62815625000003
Present value (discrete model) of x: 78.35261664684589
Future value (continuous model) of x: 128.40254166877415
Present values (continuous model) of x: 77.8800783071405

Stock and shares

Stock price rise and fall due to the fluctutation of supply and demand; if more/fewer people want to buy a given stocks the market price will increase/ decrease . There may be growth in the value of the stock that can be realized if you sell a given stock
But still a risky given-so-called diividents. there are so-called dividends. These are payments paid out every quarter or every six months to the shareholders the amount of dividend usually depends on the profitability of the given company.

Meassuring the risk of stock - Volatility

Statistical measure of the dispersion of returns for a given security which is the amount of uncertainty (or risk) about the size of changes in the value of a given security (stock, bond etc.)
We can measure volatility with standard deviation or variance between return’s of the same security Higher the volality the risker the security
We can use the Capital Asset Pricing Model (CAPM) with the $\beta$ value to approximate volatility

Commodities

Commodities are raw products such as gold, oil or natural gas .

Investing into commodities is not that simple so that commodieties such as oil is extremely volatile. This is why there are future contracts

Commodities prices are usually very similar to Random walk. Commodity prices rise and fall due to the fluctuation of the supply and demand. If more people want to buy a given commodity then the market price will increase

Future contract are made in an attempt tby producers and suppliers of commodities to advoid market volality. They negociate the price of a given commodity in the future.

The commodity prices typically rise when inflation is accelerating ( Commodities such as oild or gold usually offer protection from the effect of inflation). Thus, commodities may offer protection against the negative effect of inflation .

Currencies and the Forex

In finance an exchange rate is the rate at which one national currency will be exchanged for another

It tells you how much a given currency worth in another currency

Governments and central banks can influence currencies and exchange rates

Country	Currency	Code	Exchange Rate (USD)
United States	US Dollar	USD	1.0000
European Union	Euro	EUR	0.8500
United Kingdom	British Pound	GBP	0.7300
Japan	Japanese Yen	JPY	110.0000
Canada	Canadian Dollar	CAD	1.2100
Australia	Australian Dollar	AUD	1.3000

This concise table provides a snapshot of the current exchange rates for some of the world’s major currencies, including the US Dollar (USD), Euro (EUR), British Pound (GBP), Japanese Yen (JPY), Canadian Dollar (CAD), and Australian Dollar (AUD). These currencies play a significant role in the foreign exchange (forex) market, as they are among the most traded and liquid currencies globally.The table is organized with the country, currency name, currency code, and exchange rate relative to the US Dollar. By presenting the data in a tabular format, users can quickly compare the value of one currency to another and assess the relative strength or weakness of a particular currency.It is essential to note that the forex market is constantly fluctuating due to various factors, including economic data releases, geopolitical events, and changes in monetary policy. As a result, exchange rates in this table may change over time and should be regularly updated to reflect the latest market conditions.To sum up, this table serves as a handy reference for individuals and businesses engaged in international trade, travel, or investment. Keeping track of these key exchange rates can provide valuable insights into the global economy and help inform financial decisions.

Why do exchange rates fluctuate ?

Exchange rates rise and fall due to the fluctuation of supply and demand. That is the reaon why the exchanged rates are usually very similar to a Random Walk. If more people want to buy a given currency then its market price will increase.

Factors affecting exchange rates

Interest rates: is a major factor that can be manipulated by the central bank of a country. Investors will lend money to the banks of the given country for higher returns.
Money supply; created by the central bank by printing too much currency may trigger inflation. Investors do not like inflation so they will leave the currency that can push the value of a currency down.
Fincacial stability and economic growth of a give country have a huge impact on the value of the exchange rate.

What is Arbitrage ?

Arbitrage is making a sure profit in excess of the risk-free rate of return. In the language of quantitative finance we can say that an arbitrage opportunity is a portfolio of zero value today which is of positive value in the future with positive probability, and of negative value in the future with zero probability. The assumption that there are no arbitrage opportunities in the market is fundamental to classical finance theory. This idea is popularly known as ’there’s no such thing as a free lunch.

Example: An at-the-money European call option with a strike of $100 and an expiration of six months is worth $8. A European put with the same strike and expiration is worth $6. There are no dividends on the stock and a six-month zero-coupon bond with a principal of $100 is worth $97.

Buy the call and a bond, sell the put and the stock, which will bring in $(−8−97+6+100)=$1. At expiration this portfolio will be worthless regardless of the final price of the stock. You will make a profit of $1 with no risk. This is arbitrage.

The principle of no arbitrage is one of the foundations of classical finance theory. In derivatives theory it is assumed during the derivation of the binomial model option-pricing algorithm and in the Black–Scholes model.

Long and short positions

Long Position in a security means that you owns the security. Investors maintain long positions in the expectation that the stock will increase in the value in the future. Investors can make profit by maitaining a long position

Short Position in a security means that you sell the security.Investors maintain short positions in the expectation that the stock will decrease in the value in the future. Investors can make profit by maitaining a short position. Short selling meaning that you sell something you do not actually own

What are the risks with Short and Long positions ?

Shorting is much risker than opening long positions
When you open long position then you maximum possible loss is 100% so you may lose your entire initial investment
With short selling there is no limit to how much you can lose because there is no limit for the given stock to increase in value

Bond Theory

Bond theory in finance refers to the principles and frameworks used to analyze and evaluate bonds as a form of investment. Bonds are debt securities issued by entities such as governments or corporations to raise capital. Investors who purchase bonds are essentially lending money to the issuer in exchange for periodic interest payments (known as the coupon) and the return of the principal (face value) at the end of the bond’s term (maturity date).

Yields and yield to maturity

Yield refers to the annual return on investment that an investor can expect to earn from holding a bond. It takes into account the bond’s purchase price, face value, coupon payments, and time to maturity. It defines how much money your investment is generating

$$\frac{\text{annual coupon amount} }{\text{bond price} } $$

The yield to maturity of a bond is the internal rate of return (overall interest rate) earned by an investor who buys thebond at t today at the V market price

We assume that the bond is held until T maturity.
all $C_{i}$ coupons and P principal payments are made on schedule

Therefore it is the yeild maturity y interest rate that will make the present value of the cash flows from the investment equal to the price(cost) of the investment

$$\text{v} =\sum^{N}_{i=1} C_{i}e^{-y\left( t_{i}-t\right) }\ +\ Pe^{-y(T-t)}$$

v is discounting everything back to the t present gives the current v price
$\sum^{N}_{i=1}C_{i}e^{-y\left( t_{i}-t\right) }$ : to calculate the present value of the $C_{i}$ coupon payments.
$ Pe^{-y(T-t)} $ : to calculate the $P$ present value of the pricipal amount.

Longer bonds pays investors higher interest rate- investors expect more yield in return for loaning their money for a longer period of time

Interest rates and bonds

Bonds and market interest rates are negatively correlated when the cost of borrowing money rises bond prices usually fall and vice-versa. Of course if the market interest rate is high enough than it better to lend money to the bank rather than buying bonds

Coupon bonds and zero-coupon bonds are two types of bonds that differ in their payment structures. Here’s an overview of each type and how to calculate their values:

Coupon Bond: is a debt security that pays periodic interest payments (coupons) to the bondholder throughout its term. The issuer also repays the face (par) value of the bond upon maturity.
$$\sum^{n}_{i=1} \frac{c}{(1+r)^{i}} +\frac{x}{(1+r)^{n}} $$
A zero-coupon bond is a debt security that does not pay any periodic interest payments. Instead, it is sold at a discount to its face value, and the bondholder receives the face value at maturity. The difference between the purchase price and the face value represents the interest earned on the bond:
$$\frac{x}{(1+r)^{n}} $$
c the present value of coupon payment
r interest rate
n maturity (years)

Bonds Implementation


class CouponBond:

 def __init__(self, principal, rate, maturity, interest_rate):
 self.principal = principal
 self.rate = rate / 100
 self.maturity = maturity
 self.interest_rate = interest_rate / 100

 def present_value(self, x, n):
 return x / (1+self.interest_rate)**n

 def calculate_price(self):

 price = 0

 # discount the coupon payments
 for t in range(1, self.maturity+1):
 price = price + self.present_value(self.principal * self.rate, t)

 # discount principle amount
 price = price + self.present_value(self.principal, self.maturity)

 return price


if __name__ == '__main__':

 bond = CouponBond(1000, 10, 3, 4)
 print("Bond price: %.2f" % bond.calculate_price())

Bond price: 1166.51

Markowitz-Model (Modern Portfolio Theory)

Definition

The Markowitz Model, also known as Modern Portfolio Theory (MPT) or Mean-Variance Optimization, is an investment model developed by Harry Markowitz in 1952. It is a mathematical framework that aims to maximize the expected return of a portfolio for a given level of risk, or equivalently, minimize risk for a given level of expected return. The model assumes that investors are rational and risk-averse, and that their investment decisions are solely based on the expected return and risk of the assets

Example

Should you put all your money in a stock that has low risk but also low expected return, or one with high expected return but which is far riskier? Or perhaps divide your money between the two. Modern Portfolio Theory addresses this question and provides a framework for quantifying and understanding risk and return.

Explanation

In MPT the return on individual assets are represented by normal distributions with certain mean and standard devi- ation over a specified period. So one asset might have an annualized expected return of 5% and an annualized standard deviation (volatility) of 15%. Another might have an expected return of −2% and a volatility of 10%. Before Markowitz, one would only have invested in the first stock, or perhaps sold the second stock short. Markowitz showed how it might be possible to better both of these simplistic portfolios by taking into account the correlation between the returns on these stocks.

In the MPT world of N assets there are $2N+\frac{N(N-1)}{2} $ parameters: expected return, one per stock; standard deviation, one per stock; correlations, between any two stocks (choose two from N without replacement, order unimportant). To Markowitz all investments and all portfolios should be compared and contrasted via a plot of expected return versus risk, as measured by standard deviation. If we write $\mu_{A} $ to represent the expected return from investment or portfolio A (and similarly for B, C, etc.) and $\sigma_{B}$ for its standard deviation then investment/portfolio A is at least as good as B if

$$\mu_{A} \geq \mu_{B} \ \text{and} \ \sigma_{A} \leq \sigma_{B} $$

The mathematics of risk and return is very simple. Consider a portfolio, $\prod $, of $N$ assets, with $W_i$ the fraction of wealth invested in the $i^{th}$ asset. The expected return is then

$$\mu_{\prod } =\sum^{N}_{i=1} W_{i}\mu_{i} $$

and the standard deviation of the return, the risk, is

$$\sigma_{\Pi } =\sqrt{\sum^{N}_{i=1} \sum^{N}_{j=1} W_{i}W_{j}\rho_{ij} \sigma_{i} \sigma_{j} } $$

where $\rho_{ij}$ is the correlation between the $i^{th}$ and $j^{th}$ investments, with $\rho_{ij}=1$

Markowitz showed how to optimize a portfolio by finding the $W's$ giving the portfolio the greatest expected return for a prescribed level of risk. The curve in the risk-return space with the largest expected return for each level of risk is called the efficient frontier.

Markowitz-Model Implementation

import numpy as np
import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt
import scipy.optimize as optimization

# on average there are 252 trading days in a year
NUM_TRADING_DAYS = 252
# we will generate random w (different portfolios)
NUM_PORTFOLIOS = 10000

# stocks we are going to handle
stocks = ['AAPL', 'WMT', 'TSLA', 'GE', 'AMZN', 'DB']

# historical data - define START and END dates
start_date = '2010-01-01'
end_date = '2017-01-01'


def download_data():
 # name of the stock (key) - stock values (2010-1017) as the values
 stock_data = {}

 for stock in stocks:
 # closing prices
 ticker = yf.Ticker(stock)
 stock_data[stock] = ticker.history(start=start_date, end=end_date)['Close']

 return pd.DataFrame(stock_data)


def show_data(data):
 data.plot(figsize=(10, 5))
 plt.show()


def calculate_return(data):
 # NORMALIZATION - to measure all variables in comparable metric
 log_return = np.log(data / data.shift(1))
 return log_return[1:]


def show_statistics(returns):
 # instead of daily metrics we are after annual metrics
 # mean of annual return
 print(returns.mean() * NUM_TRADING_DAYS)
 print(returns.cov() * NUM_TRADING_DAYS)


def show_mean_variance(returns, weights):
 # we are after the annual return
 portfolio_return = np.sum(returns.mean() * weights) * NUM_TRADING_DAYS
 portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov()
 * NUM_TRADING_DAYS, weights)))
 print("Expected portfolio mean (return): ", portfolio_return)
 print("Expected portfolio volatility (standard deviation): ", portfolio_volatility)


def show_portfolios(returns, volatilities):
 plt.figure(figsize=(10, 6))
 plt.scatter(volatilities, returns, c=returns / volatilities, marker='o')
 plt.grid(True)
 plt.xlabel('Expected Volatility')
 plt.ylabel('Expected Return')
 plt.colorbar(label='Sharpe Ratio')
 plt.show()


def generate_portfolios(returns):
 portfolio_means = []
 portfolio_risks = []
 portfolio_weights = []

 for _ in range(NUM_PORTFOLIOS):
 w = np.random.random(len(stocks))
 w /= np.sum(w)
 portfolio_weights.append(w)
 portfolio_means.append(np.sum(returns.mean() * w) * NUM_TRADING_DAYS)
 portfolio_risks.append(np.sqrt(np.dot(w.T, np.dot(returns.cov()
 * NUM_TRADING_DAYS, w))))

 return np.array(portfolio_weights), np.array(portfolio_means), np.array(portfolio_risks)


def statistics(weights, returns):
 portfolio_return = np.sum(returns.mean() * weights) * NUM_TRADING_DAYS
 portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov()
 * NUM_TRADING_DAYS, weights)))
 return np.array([portfolio_return, portfolio_volatility,
 portfolio_return / portfolio_volatility])


# scipy optimize module can find the minimum of a given function
# the maximum of a f(x) is the minimum of -f(x)
def min_function_sharpe(weights, returns):
 return -statistics(weights, returns)[2]


# what are the constraints? The sum of weights = 1 !!!
# f(x)=0 this is the function to minimize
def optimize_portfolio(weights, returns):
 # the sum of weights is 1
 constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
 # the weights can be 1 at most: 1 when 100% of money is invested into a single stock
 bounds = tuple((0, 1) for _ in range(len(stocks)))
 return optimization.minimize(fun=min_function_sharpe, x0=weights[0], args=returns
 , method='SLSQP', bounds=bounds, constraints=constraints)


def print_optimal_portfolio(optimum, returns):
 print("Optimal portfolio: ", optimum['x'].round(3))
 print("Expected return, volatility and Sharpe ratio: ",
 statistics(optimum['x'].round(3), returns))


def show_optimal_portfolio(opt, rets, portfolio_rets, portfolio_vols):
 plt.figure(figsize=(10, 6))
 plt.scatter(portfolio_vols, portfolio_rets, c=portfolio_rets / portfolio_vols, marker='o')
 plt.grid(True)
 plt.xlabel('Expected Volatility')
 plt.ylabel('Expected Return')
 plt.colorbar(label='Sharpe Ratio')
 plt.plot(statistics(opt['x'], rets)[1], statistics(opt['x'], rets)[0], 'g*', markersize=20.0)
 plt.show()


if __name__ == '__main__':
 dataset = download_data()
 show_data(dataset)
 log_daily_returns = calculate_return(dataset)
 # show_statistics(log_daily_returns)

 pweights, means, risks = generate_portfolios(log_daily_returns)
 show_portfolios(means, risks)
 optimum = optimize_portfolio(pweights, log_daily_returns)

The dots represent different w weights of a given portfolio containing multiple stocks (So different porfolios ).

The investor interested in

The maximum return (means) given a fixed risk level (so volatility)
Minimum risk given a fixed return

These portfolios make up the so-called ** efficient -frontier**. This is the main feature of Markowitz model the investor can decide the risk of the expected return

Capital Asset Pricing Model

Definition

The Capital Asset Pricing Model (CAPM) relates the returns on individual assets or entire portfolios to the return on the market as a whole. It introduces the concepts of specific risk and systematic risk. Specific risk is unique to an individual asset, systematic risk is that associated with the market. In CAPM investors are compensated for taking systematic risk but not for taking specific risk. This is because specific risk can be diversified away by holding many different assets.

Example

A stock has an expected return of 15% and a volatility of 20%. But how much of that risk and return are related to the market as a whole? The less that can be attributed to the behaviour of the market, the better will that stock be for diversification purposes.

Explanation

CAPM simultaneously simplified Markowitz’s Modern Portfolio Theory (MPT), made it more practical and introduced the idea of specific and systematic risk. Whereas MPT has arbitrary correlation between all investments, CAPM, in its basic form, only links investments via the market as a whole. CAPM is an example of an equilibrium model, as opposed to a no-arbitrage model such as Black–Scholes.

The mathematics of CAPM is very simple. We relate the random return on the ith investment, $R_i$, to the random return on the market as a whole (or some representative index),$R_M$ by

$$R_{i}=\alpha_{i} +\beta_{i} R_{M}+\varepsilon_{i} $$

The $\varepsilon_{i}$ is random with zero mean and standard deviation $e_i$ and uncorrelated with the market return $R_M$ and the other $e_j$. There are three parameters associated with each asset $\alpha_{i}$, $\beta_{i}$ and $e_i$. In this representation we can see that the return on an asset can be decomposed into three parts: a constant drift; a random part common with the index; a random part uncorrelated with the index,$\varepsilon_{i}$. The random part $\varepsilon_{i}$ is unique to the ith asset. Notice how all the assets are related to the index but are otherwise completely uncorrelated

import numpy as np
import pandas as p
import yfinance as yf
import matplotlib.pyplot as plt

# market interest rate
RISK_FREE_RATE = 0.05
# we will consider monthly returns - and we want to calculate the annual return
MONTHS_IN_YEAR = 12

class CAPM:

 def __init__(self, stocks, start_date, end_date):
 self.data = None
 self.stocks = stocks
 self.start_date = start_date
 self.end_date = end_date

 def download_data(self):
 data = {}

 for stock in self.stocks:
 ticker = yf.download(stock, self.start_date, self.end_date)
 data[stock] = ticker['Adj Close']

 return pd.DataFrame(data)

 def initialize(self):
 stock_data = self.download_data()
 # we use monthly returns instead of daily returns
 stock_data = stock_data.resample('M').last()

 self.data = pd.DataFrame({'s_adjclose': stock_data[self.stocks[0]],
 'm_adjclose': stock_data[self.stocks[1]]})

 # logarithmic monthly returns
 self.data[['s_returns', 'm_returns']] = np.log(self.data[['s_adjclose', 'm_adjclose']] /
 self.data[['s_adjclose', 'm_adjclose']].shift(1))

 # remove the NaN values
 self.data = self.data[1:]

 def calculate_beta(self):
 # covariance matrix: the diagonal items are the variances
 # off diagonals are the covariances
 # the matrix is symmetric: cov[0,1] = cov[1,0] !!!
 covariance_matrix = np.cov(self.data["s_returns"], self.data["m_returns"])
 # calculating beta according to the formula
 beta = covariance_matrix[0, 1] / covariance_matrix[1, 1]
 print("Beta from formula: ", beta)

 def regression(self):
 # using linear regression to fit a line to the data
 # [stock_returns, market_returns] - slope is the beta
 beta, alpha = np.polyfit(self.data['m_returns'], self.data['s_returns'], deg=1)
 print("Beta from regression: ", beta)
 # calculate the expected return according to the CAPM formula
 # we are after annual return (this is why multiply by 12)
 expected_return = RISK_FREE_RATE + beta * (self.data['m_returns'].mean()*MONTHS_IN_YEAR
 - RISK_FREE_RATE)
 print("Expected return: ", expected_return)
 self.plot_regression(alpha, beta)

 def plot_regression(self, alpha, beta):
 fig, axis = plt.subplots(1, figsize=(20, 10))
 axis.scatter(self.data["m_returns"].to_numpy(), self.data['s_returns'].to_numpy(),
 label="Data Points")
 axis.plot(self.data["m_returns"].to_numpy(), beta * self.data["m_returns"].to_numpy() + alpha,
 color='red', label="CAPM Line")
 plt.title('Capital Asset Pricing Model, finding alpha and beta')
 plt.xlabel('Market return $R_m$', fontsize=18)
 plt.ylabel('Stock return $R_a$')
 plt.text(0.08, 0.05, r'$R_a = \beta * R_m + \alpha$', fontsize=18)
 plt.legend()
 plt.grid(True)
 plt.show()


if __name__ == '__main__':
 capm = CAPM(['IBM', '^GSPC'], '2010-01-01', '2017-01-01')
 capm.initialize()
 capm.calculate_beta()
 capm.regression()

[100%**] 1 of 1 completed
[100%**] 1 of 1 completed
Beta from formula: 0.7135097171981648
Beta from regression: 0.7135097171981654
Expected return: 0.09011312101583244

Random Behavior in Finance

Types of Analysis

There are three main types of analysis which as fundamental analysis, there is technical analysis and finally, quantitative analysis.

Fundamental analysis is about the in-depth study of a given company. There are several factors to consider such as the management teams, products and services, balance sheets, income statements and …We try to predict by analyzing these factors whether the stock is undervalued or not based on the intrinsic value of the company.So, for example, if we are using machine learning approaches, for example, logistic regression or support vector classifiers or deep neural networks, basically we are analysing historical data. We are looking for patterns in the past that will repeat themselves in the future. And if we come to the conclusion that the same pattern, then we can make a prediction based on historical data what’s going to happen in the future.
Technical analysis which is the opposite of fundamental analysis. This approach doesn’t care about the company. It assumes that all the information is contained within its stock. So technical analysis is about analyzing historical data.

Quantitative analysis has an assuption: all finacial quantities such as stock price or interest rates have random behavior.We have to use randomness in our models so stochastic caculus and stochastic differential equations are needed. So, for example, the famous Black-Scholes model is a typical quantitative analysis related approach where we use stochastic differential equations and we assume random behavior of stock prices in order to calculate the value of a given option. And it is working quite fine.

Random behavior

why we have to include randomness in our model ?

By analyzing the so-called daily returns.The daily return is the stock price to day minus the stock price yesterday divided by the stock price yesterday.

$$\frac{S(t)-S(t-1)}{S(t-1)} =R(t)$$

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt

# Fetch stock data from Yahoo Finance
ticker = 'AAPL'
start_date = '2020-01-01'
end_date = '2021-12-31'

stock_data = yf.download(ticker, start=start_date, end=end_date)

# Calculate daily returns
stock_data['Daily_Return'] = (stock_data['Close'] - stock_data['Close'].shift(1)) / stock_data['Close'].shift(1)

# Drop missing values
stock_data.dropna(inplace=True)

# Plot histogram of daily returns
plt.hist(stock_data['Daily_Return'], bins=50, alpha=0.75, edgecolor='black')
plt.xlabel('Daily Return')
plt.ylabel('Frequency')
plt.title(f'Daily Return Histogram for {ticker}')

plt.show()

And as you can see, the histogram is very, very similar to a normal distribution with mean zero. And of course, we have a given standard deviation or variance. So as we have seen the daily returns and by the way, this is the case when dealing with monthly returns as well, have approximately normal distributions.

Normal distributions can be defined by two parameters,a $\mu $ mean and the $\sigma^{2} $ variance.

Therefore, the daily return can be defined with these parameters (mean and variance):

$$R(t)=\ mean\ +C\ \times \ standard\ deviation$$

Where we can see that we have a so-called deterministic part which is the mean and we have the stochastic part which is the constant times the deviation.

Thus we can define return as a random variable drawn from a normal distribution

So, for example, if we want to get the stock price tomorrow, of course, we know the stock price today $S(t)$, which means that we know capital assets.Then the asset price tomorrow $S(t+1)$ is a random variable drawn from a normal distribution.

So this is why we can use the same approach when dealing with stock prices, not just daily returns, but if we want to model the fluctuations of a given stock price so stock price can be described with the help of a so-called random walk $W(t)$ or the so-called Wiener process where $W(t)$ has continous sample path and it has independently distributued increments

Wiener Process and Random Walk

The Wiener process and random walk are both mathematical concepts used to model stochastic processes, which are random processes evolving over time. They are related but have some differences

Wiener Process:: A Wiener process, also known as Brownian motion, is a continuous-time stochastic process that has the following properties:

It starts at zero: $W(0) = 0$.
-It has independent increments: The change in the process over non-overlapping intervals is independent.
It has normally distributed increments: The change in the process over a time interval follows a normal distribution with mean 0 and variance proportional to the length of the interval $\left[ W(t)-W(s)\approx N(0,t-s)\right] $ this is the Gaussian increaments
It has continuous paths: The process is continuous in time, meaning there are no jumps or discontinuities in the path.

The Wiener process is widely used in finance, particularly in the Black-Scholes option pricing model and geometric Brownian motion for simulating stock prices.

Random Walk:: A random walk is a discrete-time stochastic process, where the value of the process at each time step is determined by a random variable. In the simplest form, a random walk can be represented as:

$$X(t+1)=X(t)+\varepsilon (t)$$

Here, $X(t)$ is the value of the process at time $t$, and $\varepsilon (t)$ is a random variable representing the change in the process from time $t$ to time $t+1$.
There are various types of random walks, such as symmetric random walks, where the probability of moving up or down is equal, and random walks with drift, where there’s a tendency to move in a particular direction.

A random walk can be seen as a discrete version of the Wiener process when the increments $\varepsilon (t)$ are independent and normally distributed. In this case, the random walk can be approximated by a Wiener process as the time steps become smaller.

And this is why we can come to the conclusion that stock prices follow a so-called normal distribution. In probability theory, a normal distribution is a continuous probability distribution of a random variable whose logarithm is normally distributed, which means that if we take the natural logarithm of stock prices, that these values are normally distributed. So if the random variable $X$ acts is normally distributed, then $Y=ln(X)$

The Stochastic Differential Equation

The stochastic differential equation (SDE) is a type of differential equation that involves one or more random variables, which represent the effects of uncertainty on the system’s evolution. In finance, SDEs are commonly used to model the behavior of stock prices, interest rates, and other financial variables.

For instance, one of the most well-known SDEs used in finance is the Geometric Brownian Motion (GBM) model, which is used to describe the evolution of stock prices. The GBM is given by the following stochastic differential equation:

$$dS=\mu S\text{dt} +\sigma S\text{dW} $$

$\text{dW}$ is a random variable drawn from a normal distribution with mean $0$ and variance $dt$

$dS$ is the $S(t+dt)-S(t)$ change the stock price
$\mu S\text{dt} $ deterministic part- the drift
$\sigma S\text{dW} $ stochastic part with Wiener-process

This is contious model of asset price ad the fundamental assumption for most of the modern financial model

Wiener-process implementation

import numpy.random as npr
import numpy as np
import matplotlib.pyplot as plt


def wiener_process(dt=0.5, x0=0, n=1000):

 # W(t=0)=0
 # initialize W(t) with zeros
 W = np.zeros(n+1)

 # we create N+1 timesteps: t=0,1,2,3...N
 t = np.linspace(x0, n, n+1)

 # we have to use cumulative sum: on every step the additional value is
 # drawn from a normal distribution with mean 0 and variance dt ... N(0,dt)
 # by the way: N(0,dt) = sqrt(dt)*N(0,1) usually this formula is used !!!
 W[1:n+1] = np.cumsum(np.random.normal(0, np.sqrt(dt), n))

 return t, W


def plot_process(t, W):
 plt.plot(t, W)
 plt.xlabel('Time(t)')
 plt.ylabel('Wiener-process W(t)')
 plt.title('Wiener-process')
 plt.show()


if __name__ == '__main__':
 time, data = wiener_process()
 plot_process(time, data)

What is Itô’s Lemma ?

Itô’s Lemma is a theorem in stochastic calculus. It tells you that if you have a random walk, in y, say, and a function of that randomly walking variable, call it $f(y, t)$, then you can easily write an expression for the random walk in $f$. A function of a random variable is itself random in general.

Example The obvious example concerns the random walk

$$dS=\mu S\text{dt} +\sigma S\text{dW} $$

commonly used to model an equity price or exchange rate, $S$. What is the stochastic differential equation for the logarithm of $S, lnS$?

$$d(lnS)=(\mu -\frac{1}{2} \sigma^{2} )dt+\sigma dX$$

Stochastic Calculus: The solution of geometric random vork stochastic differential equation

$$S(t)=S(0)e^{\left( \mu -\frac{1}{2} \sigma^{2} \right) t+\sigma W_{t}}$$

is used to model stock prices using geometric Brownian motion (GBM), which is a continuous-time stochastic process. In the equation:

$S(t)$ represents the stock price at time t.
$S(0)$ represents the initial stock price at time 0.
$\mu$ represents the drift, which is the expected return of the stock.
$\sigma$ (sigma) represents the volatility, which is the standard deviation of the stock’s returns.
$W_t$ represents the Wiener process (Brownian motion) at time t.
$exp(x)$ is the exponential function, e^x.

The GBM model is based on the assumption that the stock prices follow a log-normal distribution, and it incorporates both the drift (trend) and the random fluctuations (volatility) of the stock price. The drift term $\left( \mu -\frac{1}{2} \sigma^{2} \right) t$ captures the average growth of the stock price over time, while the stochastic term $\sigma W_{t}$ captures the random fluctuations in the price.

Geometric Brownian Motion implementation

import matplotlib.pyplot as plt
import numpy as np


def simulate_geometric_random_walk(S0, T=2, N=1000, mu=0.1, sigma=0.05):

 dt = T/N
 t = np.linspace(0, T, N)
 # standard normal distribution N(0,1)
 W = np.random.standard_normal(size=N)
 # N(0,dt) = sqrt(dt) * N(0,1)
 W = np.cumsum(W) * np.sqrt(dt)
 X = (mu - 0.5 * sigma ** 2) * t + sigma * W
 S = S0 * np.exp(X)

 return t, S


def plot_simulation(t, S):
 plt.plot(t, S)
 plt.xlabel('Time (t)')
 plt.ylabel('Stock Price S(t)')
 plt.title('Geometric Brownian Motion')
 plt.show()


if __name__ == '__main__'

 time, data = simulate_geometric_random_walk(1)
 plot_simulation(time, data)

Black-Scholes Model

The Black–Scholes equation is a differential equation for the value of an option as a function of the underlying asset and time.

The model is based on the assumption that the underlying asset’s price follows a geometric Brownian motion, which is characterized by a constant drift and volatility.

The model aims to calculate the fair value of an option, considering factors like the current stock price, the option’s strike price, the time until expiration, the risk-free interest rate, and the underlying stock’s volatility.

The key equation in the Black-Scholes model is the Black-Scholes partial differential equation, which can be solved to obtain the option price. The Black-Scholes formula for a European call option (the right to buy an asset at a specified price) is:

$$\frac{\partial V}{\partial t} +\frac{1}{2} \sigma^{2} S^{2}\frac{\partial^{2} V}{\partial S^{2}} +rS\frac{\partial V}{\partial S} -rV=0$$

where $V(S,t)$ is the option value as a function of asset price $S$ and time $t$.

Facts about the Black–Scholes equation:

The equation follows from certain assumptions and from a mathematical and financial argument that involves hedging.
The equation is linear and homogeneous (we say ’there is no right-hand side,’ i.e. no non-V terms) so that you can value a portfolio of derivatives by summing the values of the individual contracts.
It is a partial differential equation because it has more than one independent variable, here S and t.
It is of parabolic type, meaning that one of the variables, $t$, only has a first-derivative term, and the other $S$ has a second-derivative term.
It is of backward type, meaning that you specify a final condition representing the option payoff at expiry and then solve backwards in time to get the option value now. You can tell it’s backward by looking at the sign of the $t-$derivative term and the second $S-$derivative term, when on the same side of the equals sign they are both the same sign. If they were of opposite signs then it would be a forward equation. The equation is an example of a diffusion equation or heat equation. Such equations have been around for nearly two hundred years and have been used to model all sorts of physical phenomena.
The equation requires specification of two parameters, the risk-free interest rate and the asset volatility. The interest rate is easy enough to measure, and the option value isn’t so sensitive to it anyway. But the volatility is another matter, rather harder to forecast accurately.
Because the main uncertainty in the equation is the volatility one sometimes thinks of the equation less as a valuation tool and more as a way of understanding the relationship between options and volatility.
The equation is easy to solve numerically, by finite-difference or Monte Carlo methods, for example.
The equation can be generalized to allow for dividends, other payoffs, stochastic volatility, jumping stock prices, etc.

The Black–Scholes formulæ : which are solutions of the equation in special cases, such as for calls and puts. $\frac{\partial V}{\partial t} +\frac{1}{2} \sigma^{2} S^{2}\frac{\partial^{2} V}{\partial S^{2}} +rS\frac{\partial V}{\partial S} -rV=0$

The equation contains four terms:

$\frac{\partial V}{\partial t} $ time decay, how much the option value changes by if the stock price doesn’t change
$\frac{1}{2} \sigma^{2} S^{2}\frac{\partial^{2} V}{\partial S^{2}} $ : convexity term, how much a hedged position makes on average from stock moves
$ S\frac{\partial V}{\partial S} $ : drift term allowing for the growth in the stock at the risk-free rate
$rV$ the discounting term, since the payoff is received at expiration but you are valuing the option now.

Solution to The Black–Scholes equation :

Black-Scholes equation

$$\left[ \frac{\partial V}{\partial t} +\frac{1}{2} \sigma^{2} S^{2}\frac{\partial^{2} V}{\partial S^{2}} \right] dt=r\left( V-S\frac{\partial V}{\partial S} \right) dt$$

It is a parabolic partial differential equation

Linear: so the sum of the solutions is also a solution

Financial equations are usually parabolic: They are related to heat and diffusion equations of Physics

Solution to The Black–Scholes equation : no dividend yields onn the underlying

$$N(x)=\frac{1}{\sqrt{2\pi } } \int^{x}_{-\infty } e^{-\frac{z^{2}}{2} }\ dz $$

Standard normal distribution

Call option

$$S(0)N(d_{1})-Ee^{-r(T-t)}N(d_{2})$$

Put Option

$$-S(0)N(-d_{1})+Ee^{-r(T-t)}N(-d_{2})$$

Where,

$$d_{1}=\frac{log\left[ \frac{S\left( 0\right) }{E} \right] +(r+\frac{1}{2} \sigma^{2} )(T-t)}{\sigma \sqrt{T-t} } $$$$d_{2}=d_{1}-\sigma \sqrt{T-t} $$

from scipy import stats
from numpy import log, exp, sqrt


def call_option_price(S, E, T, rf, sigma):
 # first we have to calculate d1 and d2 parameters
 d1 = (log(S / E) + (rf + sigma * sigma / 2.0) * T) / (sigma * sqrt(T))
 d2 = d1 - sigma * sqrt(T)
 print("The d1 and d2 parameters: %s, %s" % (d1, d2))
 # use the N(x) to calculate the price of the option
 return S*stats.norm.cdf(d1)-E*exp(-rf*T)*stats.norm.cdf(d2)


def put_option_price(S, E, T, rf, sigma):
 # first we have to calculate d1 and d2 parameters
 d1 = (log(S / E) + (rf + sigma * sigma / 2.0) * T) / (sigma * sqrt(T))
 d2 = d1 - sigma * sqrt(T)
 print("The d1 and d2 parameters: %s, %s" % (d1, d2))
 # use the N(x) to calculate the price of the option
 return -S*stats.norm.cdf(-d1)+E*exp(-rf*T)*stats.norm.cdf(-d2)


if __name__ == '__main__':
 # underlying stock price at t=0
 S0 = 100
 # strike price
 E = 100
 # expiry 1year=365days
 T = 1
 # risk-free rate
 rf = 0.05
 # volatility of the underlying stock
 sigma = 0.2

 print("Call option price according to Black-Scholes model: ",
 call_option_price(S0, E, T, rf, sigma))
 print("Put option price according to Black-Scholes model: ",
 put_option_price(S0, E, T, rf, sigma))

The d1 and d2 parameters: 0.35000000000000003, 0.15000000000000002
Call option price according to Black-Scholes model: 10.450583572185565
The d1 and d2 parameters: 0.35000000000000003, 0.15000000000000002
Put option price according to Black-Scholes model: 5.573526022256971

Monte Carlo Simulation

Definition

Monte Carlo simulations are a way of solving probabilistic problems by numerically ‘imagining’ many possible scenarios or games so as to calculate statistical properties such as expectations, variances or probabilities of certain outcomes. In finance we use such simulations to represent the future behaviour of equities, exchange rates, interest rates, etc., so as to either study the possible future performance of a port- folio or to price derivatives.

Example

We hold a complex portfolio of investments, we would like to know the probability of losing money over the next year since our bonus depends on our making a profit. We can estimate this probability by simulating how the individual components in our portfolio might evolve over the next year. This requires us to have a model for the random behaviour of each of the assets, including the relationship or correlation between them, if any. Some problems which are completely deterministic can also be solved numerically by running simulations, most famously finding a value for $\pi$.

It is clear enough that probabilistic problems can be solved by simulations. What is the probability of tossing heads with a coin, just toss the coin often enough and you will find the answer. More on this and its relevance to finance shortly. But many deterministic problems can also be solved this way, provided you can find a probabilistic equivalent of the deterministic problem. A famous example of this is Buffon’s needle, a problem and solution dating back to 1777. Draw parallel lines on a table one inch apart. Drop a needle, also one inch long, onto this table. Simple trigonometry will show you that the probability of the needle touching one of the lines is $\frac{2}{\pi } $. So conduct many such experiments to get an approximation to $\pi$. Unfortunately because of the probabilistic nature of this method you will have to drop the needle many billions of times to find π accurate to half a dozen decimal places.

There can also be a relationship between certain types of differential equation and probabilistic methods. Stanislaw Ulam, inspired by a card game, invented this technique while working on the Manhattan Project towards the development of nuclear weapons. The name Monte Carlo was given to this idea by his colleague Nicholas Metropolis.

Monte Carlo simulations are used in financial problems for solving two types of problems:

Exploring the statistical properties of a portfolio of investments or cashflows to determine quantities such as expected returns, risk, possible downsides, probabilities of making certain profits or losses, etc.
Finding the value of derivatives by exploiting the theoretical relationship between option values and expected payoff under a risk-neutral random walk.

Exploring portfolio statistics: The most successful quantitative models represent investments as random walks. There is a whole mathematical theory behind these models, but to appreciate the role they play in portfolio analysis you just need to understand three simple concepts.

First, you need an algorithm for how the most basic investments evolve randomly. In equities this is often the lognormal random walk. (If you know about the real/risk-neutral distinction then you should know that you will be using the real random walk here.) This can be represented on a spreadsheet or in code as how a stock price changes from one period to the next by adding on a random return. In the fixed-income world you may be using the BGM model ( The BGM model, also known as the Brace-Gatarek-Musiela (BGM) model or the Libor Market Model (LMM), is a financial model used to describe the evolution of interest rates) to model how interest rates of various maturities evolve. In credit you may have a model that models the random bankruptcy of a company. If you have more than one such investment that you must model then you will also need to represent any interrelationships between them. This is often achieved by using correlations.
Once you can perform such simulations of the basic investments then you need to have models for more complicated contracts that depend on them, these are the options/derivatives/contingent claims. For this you need some theory, derivatives theory. This the second concept you must understand.
Finally, you will be able to simulate many thousands, or more, future scenarios for your portfolio and use the results to examine the statistics of this portfolio. This is, for example, how classical Value at Risk can be estimated, among other things.

Pricing derivatives We know from the results of risk-neutral pricing that in the popular derivatives theories the value of an option can be calculated as the present value of the expected payoff under a risk-neutral random walk. And calculating expectations for a single contract is just a simple example of the above-mentioned portfolio analysis, but just for a single option and using the risk-neutral instead of the real random walk. Even though the pricing models can often be written as deterministic partial differential equations they can be solved in a probabilistic way, just as Stanislaw Ulam noted for other, non-financial, problems. This pricing methodology for derivatives was first proposed by the actuarially trained Phelim Boyle in 1977. Whether you use Monte Carlo for probabilistic or deterministic problems the method is usually quite simple to implement in basic form and so is extremely popular in practice.

Application to stoke price

We know that $S(t)$ assets (such as stocks) follow lognormal random walk

$$dS=\mu S\text{dt} +\sigma S\text{dW} $$

$\mu S\text{dt} $ deterministic part- the drift that can be characterized by the mean
$\sigma S\text{dW} $ stochastic part with Wiener-process that can be characterized by the standard deviation or the so called volatility

So what do we have to do if we know the starting point? So as zero, which means that the stock price at T goes to zero and we know the given parameters the mean and the standard deviation we can calculated based on historical data then we can make multiple simulations and it is quite cheap to create a simulation like these since we know how to simulate lognormal random walks

We have to create tens of thousands of simulations in the sense that we are going to create the first simulation.Of course, the stock price are going to fluctuate. They will increase, they will decrease and so on. So the first simulation is going to yield a different path than the second simulation will yield another path. The simulation will yield another path of the underlying stock and so on. If we make tens of thousands of simulations, then we end up with this implementation

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

NUM_OF_SIMULATIONS = 10000


def stock_monte_carlo(S0, mu, sigma, N=252):

 result = []

 # number of simulations - possible S(t) realizations (of the process)
 for _ in range(NUM_OF_SIMULATIONS):
 prices = [S0]
 for _ in range(N):
 # we simulate the change day by day (t=1)
 stock_price = prices[-1] * np.exp((mu - 0.5 * sigma ** 2) +
 sigma * np.random.normal())
 prices.append(stock_price)

 result.append(prices)

 simulation_data = pd.DataFrame(result)
 # the given columns will contain the time series for a given simulation
 simulation_data = simulation_data.T

 # plt.plot(simulation_data)
 # plt.show()

 # print('Prediction for future stock price: $%.2f' % simulation_data['mean'].tail(1))

 return simulation_data


if __name__ == '__main__':
 simulation_data = stock_monte_carlo(50, 0.0002, 0.01)
 plt.plot(simulation_data)
 plt.show()

 print('Prediction for future stock price: $%.2f' % simulation_data.mean(axis=1).tail(1).values[0])

We generate a huge amount of possible $S(t)$ geometric random walk process The mean of these simulations yields the $S_{B}\left( t\right)$ path with the highest probability in the future. This is a typical Monte-Carlo simulation

Which Numerical Method should I Use and When?

Definition : The three main numerical methods in common use are Monte Carlo, finite difference and numerical quadrature. (I’m including the binomial method as just a simplistic version of finite differences.) Monte Carlo is great for complex path dependency and high dimensionality, and for problems which can not easily be written in differential equation form. Monte Carlo methods simulate the random behaviour underlying the financial models. So, in a sense they get right to the heart of the problem. Always remember, though, that when pricing you must simulate the risk-neutral random walk(s), the value of a contract is then the expected present value of all cashflows. Finite difference is best for low dimensions and contracts with decision features such as early exercise, ones which have a differential equation formulation Since we work with a mesh, not unlike the binomial method, we will find the contract value at all points is stock price-time space. In quantitative finance that differential equation is almost always of diffusion or parabolic type. Numerical quadrature is for when you can write the option value as a multiple integral. To be more detail ,occasionally one can write down the solution of an option-pricing problem in the form of a multiple integral. This is because you can interpret the option value as an expectation of a payoff, and an expectation of the payoff is mathematically just the integral of the product of that payoff function and a probability density function. This is only possible in special cases. The option has to be European, the underlying stochastic differential equation must be explicitly integrable (so the lognormal random walk is perfect for this) and the payoff shouldn’t usually be path dependent. So if this is possible then pricing is easy… you have a formula. The only difficulty comes in turning this formula into a number. And that’s the subject of numerical integration or quadrature.

Example
You want to price a fixed-income contract using the BGM model. Which numerical method should you use? BGM is geared up for solution by simulation, so you would use a Monte Carlo simulation.

You want to price an option which is paid for in instalments, and you can stop paying and lose the option at any time if you think it’s not worth keeping up the payments. This may be one for finite-difference methods since it has a decision feature.

You want to price a European, non-path-dependent contract on a basket of equities. This may be recast as a multiple inte- gral and so you would use a quadrature method.

Summary

Pros and cons of different methods: Finite Dimension(FD), Monte-Carlos(MC), Numerical quadrature (Quand)

Subject	Low dimensions	High dimensions	Path dependent Greeks	Portfolio Decisions	Non-linear
FD	Good	Slow	Depends	Excellent	Inefficient
MC	Inefficient	Excellent	Excellent	Not good	Very good
Quad.	Good	Good	Not good	Excellent	Very good

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Classical Machine Learning Tutorial 1

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

Welcome to this introductory course on Machine Learning (ML), where we will explore the fundamental concepts and techniques that are the building blocks for more advanced fields, such as Quantum Machine Learning. This course is designed with a hands-on approach, offering you the opportunity to engage with real code and solve two simple classification problems.

The purpose of this course is to provide a foundation in classical machine learning methods, using tools and libraries that are widely applied in the field. One such tool we’ll be using is the scikit-learn library, particularly the PolynomialFeatures class from sklearn.preprocessing, which allows us to easily transform input data by adding polynomial features to our models. This technique is pivotal for handling non-linear relationships in data and will help us tackle problems more effectively.

By the end of this course, you will have gained practical experience with popular ML algorithms and tools such as logistic regression, SVMs, polynomial classification, and kernel methods, and a deeper understanding of the underlying principles that power these techniques. This knowledge will serve as a stepping stone for your journey into Quantum Machine Learning, where quantum computers are used to process data in fundamentally different ways.

Throughout this course, we will guide you through intuitive, hands-on problems, where you will first see how machine learning models are built from scratch, providing a strong foundational understanding. You will then apply the powerful tools of the scikit-learn library to experiment with different models, note their performance, and observe how machine learning algorithms learn and adapt to data. We will emphasize the core philosophy of learning from data, which is central to the field of machine learning. By the end of the course, you will be equipped with the practical knowledge and skills to tackle more complex real-world challenges.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn import svm
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from mpl_toolkits.mplot3d import Axes3D

##Toxicity of plants and linear classification

Imagine biologists working in a remote research lab, deep in the heart of a dense forest. Fascinated by the plant life around, wonder if certain physical traits of plants—specifically the size of their leaves—might reveal clues about their toxicity. To investigate, they measure the width and radius of leaves from various plant species, meticulously recording the data alongside known information about each plant’s toxicity. Their hypothesis is that larger or smaller leaves may correlate with whether a plant is safe to eat or potentially harmful. Our task is to help the biologist analyze this data, using statistical techniques to classify the plants based on their measurements. By finding a predictive link, we aim to offer the biologist a useful model for distinguishing edible plants from toxic ones, guiding safer exploration of the forest’s plant diversity.

###Data vizualization

The sizes of the leaves are given in the following dataset. To upload them run the code below.

# Dataset: Width, Radius, Toxicity
data = np.array([
 [5.1, 2.0, 0],
 [4.8, 1.8, 0],
 [5.0, 2.1, 0],
 [6.5, 3.0, 1],
 [6.8, 3.2, 1],
 [6.7, 3.1, 1],
 [4.5, 1.7, 0],
 [5.4, 2.3, 0],
 [6.2, 2.8, 1],
 [6.6, 3.0, 1],
 [5.3, 2.2, 0],
 [4.7, 1.9, 0],
 [7.1, 3.4, 1],
 [5.2, 2.1, 0],
 [6.9, 3.3, 1],
 [5.6, 2.4, 0],
 [4.6, 1.6, 0],
 [7.0, 3.2, 1]
])

Before delving into deeper analysis, it’s helpful to start by visualizing the data. Here, we plot the distribution of the leaves in the (width, radius) plane, with colors indicating their toxicity.

# Separate features and labels
X = data[:, :2] # Width and Radius as features
y = data[:, 2] # Toxicity as labels

# Plot the data points
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolor='k')

# Add colorbar to indicate toxic (1) and edible (0)
cbar = plt.colorbar(scatter)
cbar.set_ticks([0, 1]) # Set ticks to represent edible (0) and toxic (1)
cbar.set_ticklabels(["Edible", "Toxic"]) # Label the colorbar ticks

plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Data visualization (Toxic vs. Edible)")
plt.savefig("1.png")

plt.show()

A construction of a machine learning algoritm by hand

We observe that the leaves are located close to the line:

$$ \frac{\textrm{Radius}}{\textrm{Width}} = \textrm{constant}. $$

Additionally, the magnitudes of the vector $(\textrm{width}, \textrm{radius})$ are small for non-toxic plants and large for toxic ones.

One way to classify the plants could be as follows:

First, draw the line of constant ratio $\textrm{radius}/\textrm{width}$.
Then, draw the perpendicular to this line such that it separates the toxic and non-toxic leaves.

Now, let’s dive into finding the line of constant ratio. What we want is a line that best fits the data points. To find this line, we perform regression.

How do we perform the regression?

A mathematical formulation of the problem is to find $\beta_0$ and $\beta_1 \neq 0$ that minimize the given loss function.

The goal of linear regression is to find the coefficients $ \beta_0 $ (intercept) and $ \beta_1$ (slope) that minimize the sum of squared errors (or residuals). The cost function is given by:

$$ J(\beta_0, \beta_1) = \frac{1}{2} \sum_{i=1}^{n} \left( y_i - \left( \beta_0 + \beta_1 x_i \right) \right)^2 $$

where:

$ y_i $ is the radius of the $ i $-th leaf,
$ x_i $ is the width of the $ i $-th leaf,
$ \beta_0 $ is the intercept,
$ \beta_1 $ is the slope.

Remark: You might wonder why we chose the sum of squared errors instead of absolute values. The reason is that the squared error gives us a convex and differentiable function, which is easier to minimize. The coefficient $\frac{1}{2}$ has no effect on the values of $ \beta_0 $ and $ \beta_1$, it is simply used to simplify the computation.

We begin by expanding the cost function:

$$ J(\beta_0, \beta_1) = \frac{1}{2} \sum_{i=1}^{n} \left( y_i - \beta_0 - \beta_1 x_i \right)^2 $$

To minimize this function with respect to $ \beta_0 $ and $ \beta_1 $, we take the partial derivatives of $ J(\beta_0, \beta_1) $ with respect to both coefficients and set them equal to zero.

First, take the derivative with respect to $ \beta_0 $:

$$ \frac{\partial J(\beta_0, \beta_1)}{\partial \beta_0} = -\sum_{i=1}^{n} \left( y_i - \beta_0 - \beta_1 x_i \right) $$

Set this equal to zero to minimize the function:

$$ \sum_{i=1}^{n} \left( y_i - \beta_0 - \beta_1 x_i \right) = 0 $$

Expanding this:

$$ \sum_{i=1}^{n} y_i - n \beta_0 - \beta_1 \sum_{i=1}^{n} x_i = 0 $$

Solving for $ \beta_0 $:

$$ n \beta_0 = \sum_{i=1}^{n} y_i - \beta_1 \sum_{i=1}^{n} x_i $$$$ \beta_0 = \frac{1}{n} \sum_{i=1}^{n} y_i - \beta_1 \frac{1}{n} \sum_{i=1}^{n} x_i $$

This gives a relationship for $ \beta_0 $ in terms of $ \beta_1 $, the mean of $ x $, and the mean of $ y $.

Now, take the derivative with respect to $ \beta_1 $:

$$ \frac{\partial J(\beta_0, \beta_1)}{\partial \beta_1} = - \sum_{i=1}^{n} x_i \left( y_i - \beta_0 - \beta_1 x_i \right) $$

Set this derivative equal to zero:

$$ \sum_{i=1}^{n} x_i \left( y_i - \beta_0 - \beta_1 x_i \right) = 0 $$

Expanding:

$$ \sum_{i=1}^{n} x_i y_i - \beta_0 \sum_{i=1}^{n} x_i - \beta_1 \sum_{i=1}^{n} x_i^2 = 0 $$

Solving for $ \beta_1 $:

$$ \beta_1 = \frac{\sum_{i=1}^{n} x_i y_i - \frac{1}{n} \sum_{i=1}^{n} x_i \sum_{i=1}^{n} y_i}{\sum_{i=1}^{n} x_i^2 - \frac{1}{n} \left( \sum_{i=1}^{n} x_i \right)^2} $$

This gives the expression for the slope $ \beta_1 $.

Conclusion The coefficients $\beta_0$ and $\beta_1$ are given by the following formulas:

$$ \beta_1 = \frac{\sum_{i=1}^{n} x_i y_i - \frac{1}{n} \sum_{i=1}^{n} x_i \sum_{i=1}^{n} y_i}{\sum_{i=1}^{n} x_i^2 - \frac{1}{n} \left( \sum_{i=1}^{n} x_i \right)^2} $$$$ \beta_0 = \frac{1}{n} \sum_{i=1}^{n} y_i - \beta_1 \frac{1}{n} \sum_{i=1}^{n} x_i $$

These formulas provide the least squares estimates for the coefficients of a simple linear regression model. We plot this regression line in the code below:

# Use Width (X[:, 0]) as the independent variable to compute β_0 and β_1
x_vals = X[:, 0]
y_vals = X[:, 1]

# Calculate beta_1
n = len(x_vals)
beta_1 = (np.sum(x_vals * y_vals) - np.mean(x_vals) * np.sum(y_vals)) / (np.sum(x_vals**2) - np.mean(x_vals) * np.sum(x_vals))

# Calculate beta_0
beta_0 = np.mean(y_vals) - beta_1 * np.mean(x_vals)

# Plot the data points
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolor='k')

# Add colorbar to indicate toxic (1) and edible (0)
cbar = plt.colorbar(scatter)
cbar.set_ticks([0, 1]) # Set ticks to represent edible (0) and toxic (1)
cbar.set_ticklabels(["Edible", "Toxic"]) # Label the colorbar ticks

# Plot the regression line based on y = beta_0 + beta_1 * x
x_line = np.linspace(np.min(x_vals), np.max(x_vals), 100)
y_line = beta_0 + beta_1 * x_line
plt.plot(x_line, y_line, color="black", linestyle="--", label=f"y = {beta_0:.2f} + {beta_1:.2f}x")

# Add labels and title
plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Data Visualization (Toxic vs. Edible) with Regression Line")
plt.legend()
plt.savefig("2.png")
plt.show()

The Python library scikit-learn (sklearn) provides the LinearRegression function, which allows you to find the best-fit line without the need to manually derive the formulas.

# Create a linear regression model
model = LinearRegression()

# Fit the model to the data
model.fit(x_vals.reshape(-1, 1), y_vals)

# Extract the coefficients
beta_0 = model.intercept_ # This is the y-intercept
beta_1 = model.coef_[0] # This is the slope

# Plot the data points
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolor='k')

# Add colorbar to indicate toxic (1) and edible (0)
cbar = plt.colorbar(scatter)
cbar.set_ticks([0, 1]) # Set ticks to represent edible (0) and toxic (1)
cbar.set_ticklabels(["Edible", "Toxic"]) # Label the colorbar ticks

# Plot the regression line based on y = beta_0 + beta_1 * x
x_line = np.linspace(np.min(x_vals), np.max(x_vals), 100)
y_line = beta_0 + beta_1 * x_line
plt.plot(x_line, y_line, color="black", linestyle="--", label=f"y = {beta_0:.2f} + {beta_1:.2f}x")

# Add labels and title
plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Data Visualization (Toxic vs. Edible) with Regression Line")
plt.legend()
plt.savefig("3.png")
plt.show()

Now, we draw a perpendicular line that effectively separates the toxic and non-toxic plants.

This perpendicular line will have the form:

$$ y = - \frac{1}{\beta_1} x + \alpha, $$

where $ \alpha \in \mathbb{R} $. The value of $ \alpha $ determines the position of the perpendicular. We can choose $ \alpha $ such that this perpendicular intersects the regression line at the midpoint between the widths of the closest toxic and non-toxic leaves.

To proceed, we first compute the midpoint, defined as:

$$ \text{midwidth} = \frac{\text{nontoxic_max_width} + \text{toxic_min_width}}{2}. $$

This enables us to solve for $ \alpha $ by setting up the following equation:

$$ \alpha = \beta_0 + \beta_1 \cdot \text{midwidth} + \frac{\text{midwidth}}{\beta_1}. $$

The code below provides a plot of this perpendicular line.

# Compute midpoint (med) for the closest toxic and non-toxic leaves
nontoxic_max_width = np.max(x_vals[y == 0]) # Max width among edible plants
toxic_min_width = np.min(x_vals[y == 1]) # Min width among toxic plants
midpoint = (nontoxic_max_width + toxic_min_width) / 2 # Midpoint in width

# Determine the y-value of the regression line at the midpoint
y_mid = beta_0 + beta_1 * midpoint

# Calculate the perpendicular line's slope and intercept
perpendicular_slope = -1 / beta_1
perpendicular_intercept = y_mid - perpendicular_slope * midpoint

# Plot the data points
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolor='k')

# Add colorbar to indicate toxic (1) and edible (0)
cbar = plt.colorbar(scatter)
cbar.set_ticks([0, 1]) # Set ticks to represent edible (0) and toxic (1)
cbar.set_ticklabels(["Edible", "Toxic"]) # Label the colorbar ticks

# Plot the regression line based on y = beta_0 + beta_1 * x
x_line = np.linspace(np.min(x_vals), np.max(x_vals), 100)
y_line = beta_0 + beta_1 * x_line
plt.plot(x_line, y_line, color="black", linestyle="--", label=f"y = {beta_0:.2f} + {beta_1:.2f}x")

# Plot the perpendicular line
y_perpendicular = perpendicular_slope * x_line + perpendicular_intercept
plt.plot(x_line, y_perpendicular, color="purple", linestyle=":", label="Perpendicular Separator")

# Add labels and title
plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Data Visualization (Toxic vs. Edible) with Regression and Perpendicular Line")
plt.legend()
plt.savefig("4.png")
plt.show()

Step by step, we have separated the plants based on their toxicity. The perpendicular separator we defined is called the decision boundary. For a new plant, it will be classified as toxic if it falls on the toxic side (to the right of the decision boundary) and non-toxic if it falls on the other side.

In the machine learning algorithm we developed manually, our approach closely resembled that of the support vector classifier (SVC).

Support vector classifier

The SVC is a powerful machine learning algorithm used for binary classification. It aims to find the optimal hyperplane that best separates the data points of two different classes. In the linear case, where the data is linearly separable, the SVC algorithm looks for the hyperplane that maximizes the margin between the two classes.

Key Concepts:

Hyperplane:
- A hyperplane is a decision boundary that separates data points of different classes.
- In a 2D space, a hyperplane is a line, while in 3D it is a plane, and in higher dimensions, it is a general hyperplane.
- The goal of SVC is to find the hyperplane that best separates the two classes in the feature space.
Margin:
- The margin is the distance between the hyperplane and the closest points from each class.
- The SVC algorithm aims to maximize this margin, which is the distance between the hyperplane and the support vectors (the closest data points to the hyperplane).
- A larger margin usually results in better generalization and classification performance.
Support Vectors:
- Support vectors are the data points that lie closest to the decision boundary (hyperplane).
- These points are critical for determining the position of the hyperplane, and removing them would change the decision boundary.
In the case of linearly separable data (where two classes can be separated by a straight line or hyperplane), the SVC algorithm tries to find the hyperplane that maximizes the margin between the two classes.
- The equation of the hyperplane is represented as:
  $$ w \cdot x + b = 0 $$
  where:
  - $w$ is the weight vector, which is perpendicular to the hyperplane.
  - $x$ is the feature vector.
  - $b$ is the bias term that helps shift the hyperplane.
The objective of the SVC is to find the values of $w$ and $b$ such that the margin between the classes is as wide as possible while ensuring that all points are correctly classified.
- The margin can be calculated as the distance between the hyperplane and the closest data points. To maximize this margin, we minimize the following objective function:
  $$ \frac{1}{2} \|w\|^2 $$
  subject to the constraints that all data points are correctly classified, which can be written as:
  $$ y_i (w \cdot x_i + b) \geq 1, \quad \forall i $$
  Here:
  - $y_i$ is the class label of the $i$-th data point (either +1 or -1),
  - $x_i$ is the feature vector of the $i$-th data point.
  These constraints ensure that each data point is correctly classified on the correct side of the hyperplane.

Solving the Optimization Problem:

To find the optimal hyperplane, we need to solve this constrained optimization problem. This involves finding the values of $w$ and $b$ that maximize the margin while satisfying the classification constraints.

The optimization problem can be solved using Quadratic Programming or other optimization techniques.

Final Decision Rule:

Once the optimal hyperplane is found, the classifier can predict the class of new data points. A new data point $x$ is classified as follows:

If $w \cdot x + b > 0$, then the point is classified as belonging to class +1.
If $w \cdot x + b < 0$, then the point is classified as belonging to class -1.

The decision rule is based on which side of the hyperplane the new point lies on.

The following code performs an SVC on the plant dataset.

# Separate features and labels
X = data[:, :2] # Width and Radius
y = data[:, 2] # Toxicity label

# Create and train the SVM model
svm_model = SVC(kernel='linear', C=1.0) # Linear kernel for linear classification
svm_model.fit(X, y)

# Calculate accuracy on training data
predictions = svm_model.predict(X)
accuracy = accuracy_score(y, predictions)
print("Training Accuracy:", accuracy)

# Plot the decision boundary and the margin
plt.figure(figsize=(8, 6))

# Plot the data points
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', edgecolor='k')
plt.colorbar(scatter, ticks=[0, 1], label="Toxicity")
plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Plant Toxicity Classification with SVM")

# Get the separating hyperplane
w = svm_model.coef_[0] # Coefficients of the decision boundary
b = svm_model.intercept_[0] # Intercept

# Calculate the slope and intercept for the line in (Width, Radius) space
slope = -w[0] / w[1]
intercept = -b / w[1]

# Plot the decision boundary (hyperplane)
x_vals = np.linspace(X[:, 0].min(), X[:, 0].max(), 100)
decision_boundary = slope * x_vals + intercept
plt.plot(x_vals, decision_boundary, 'k-', label="Decision Boundary")

# Calculate the margin lines (distance from hyperplane)
margin = 1 / np.sqrt(np.sum(w**2))
plt.plot(x_vals, decision_boundary + margin, 'k--', label="Margin +1")
plt.plot(x_vals, decision_boundary - margin, 'k--', label="Margin -1")

# Show support vectors
plt.scatter(svm_model.support_vectors_[:, 0], svm_model.support_vectors_[:, 1], s=100,
 facecolors='none', edgecolors='k', linewidths=1.5, label="Support Vectors")

plt.legend()
plt.savefig("5.png")
plt.show()

Training Accuracy: 1.0

The decision boundary we obtained is slightly different from the one generated by our custom algorithm. This algorithm is known as Support Vector Machine (SVM), as the decision boundary is determined by only a few key data points, called support vectors. These support vectors are highlighted with circles in the figure above.

Logistic Regression

A more machine learning (ML)-oriented approach involves structuring the problem as a well-defined task. This allows us to focus on setting clear objectives, while delegating the computational complexity and problem-solving effort to the algorithm.

In this example, the task is to classify plants based on their leaf dimensions. Specifically, our goal is to predict whether a new plant is toxic or not, using the measurements of its leaves. In simpler terms, we aim to build a model that can accurately assign plants to their correct category—toxic or non-toxic—with as few errors as possible.

The central question then becomes: How can we translate this classification task into a mathematical framework? A good starting point is to examine the dataset and formulate a hypothesis about the relationship between the leaf dimensions and the plant’s toxicity. By making such an assumption, we can leverage mathematical tools and techniques to derive a model capable of making these predictions.

# Separate features and labels
X = data[:, :2] # Width and Radius as features
y = data[:, 2] # Toxicity as labels

# Plot the data points
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolor='k')

# Add colorbar to indicate toxic (1) and edible (0)
cbar = plt.colorbar(scatter)
cbar.set_ticks([0, 1]) # Set ticks to represent edible (0) and toxic (1)
cbar.set_ticklabels(["Edible", "Toxic"]) # Label the colorbar ticks

plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Data visualization (Toxic vs. Edible)")
plt.savefig("6.png")
plt.show()

Because of the data distribution, a reasonable and effective hypothesis would be the following:

We assume that the toxic and non-toxic plants can be classified into two distinct categories, separated by a straight line.

Why is this hypothesis smart?

It is realistic:
By observing the data, we can see that the toxic and non-toxic plants form two clearly distinguishable groups. Importantly, there are no overlapping or intertwined data points from the two classes in the figure above. This visual cue supports the idea that a simple separation might suffice.
It proposes linear separability:
This hypothesis assumes that a straight line can separate the two categories, an approach commonly referred to in machine learning and data science as the linearly separable hypothesis. This is a smart assumption for two reasons:
- Plausibility: The hypothesis aligns with the observed data distribution, making it likely to hold true.
- Simplicity: A linear boundary represents one of the simplest models available. While it is possible to imagine more complex boundaries—such as polynomial or non-linear curves—a simpler model is generally preferable when it suffices. Simpler models are easier to train, interpret, and generalize well to unseen data, making linear separability an ideal starting point.

By starting with this hypothesis, we embrace the principle of parsimony (Occam’s Razor), which suggests opting for the simplest explanation or model that adequately explains the data.

Mathematical Formulation of the Problem

Based on the hypothesis of linear separability, we aim to find a straight line that separates toxic plants from non-toxic ones. Mathematically, the equation of the decision boundary can be written as:

$$ w_1 \cdot x_1 + w_2 \cdot x_2 + b = 0 $$

Here:

$x_1$ and $x_2$ represent the width and radius of a plant’s leaf, respectively.
$w_1$ and $w_2$ are the weights (coefficients) that determine the orientation of the decision boundary.
$b$ is the bias term, which shifts the decision boundary.

Classification Rule

Given this decision boundary, a new plant can be classified as follows:

If $w_1 \cdot x_1 + w_2 \cdot x_2 + b > 0$, the plant is classified as toxic ($y = 1$).
If $w_1 \cdot x_1 + w_2 \cdot x_2 + b \leq 0$, the plant is classified as non-toxic ($y = 0$).

To achieve perfect classification, we require that the model correctly assigns each plant in the dataset to its respective category. This can be expressed mathematically using the 0/1 loss function, which measures whether a prediction is correct ($0$ loss) or incorrect ($1$ loss). For a dataset with $n$ samples, the total loss is:

$$ L = \sum_{i=1}^n \mathbb{1}_{\{ y_i \neq \hat{y}_i \}} $$

Here:

$y_i$ is the true label (toxic or non-toxic) for the $i$-th plant.
$\hat{y}_i$ is the predicted label for the $i$-th plant.
$\mathbb{1}_{\{\cdot\}}$ is the indicator function, which equals $1$ if the condition inside is true, and $0$ otherwise.

For zero classification error, we require that:

$$ \mathbb{1}_{\{ y_i \neq \hat{y}_i \}} = 0 \quad \text{for all } i = 1, 2, \dots, n. $$

This means every prediction must match the true label. Translating this into constraints for the decision boundary, we have:

For toxic plants ($y_i = 1$), we need $w_1 \cdot x_{1i} + w_2 \cdot x_{2i} + b > 0$.
For non-toxic plants ($y_i = 0$), we need $w_1 \cdot x_{1i} + w_2 \cdot x_{2i} + b \leq 0$.

The key challenge is to find the optimal values of $w_1$, $w_2$, and $b$ that satisfy these constraints for all data points. This ensures that the decision boundary perfectly separates the two classes with zero classification error.

To solve this challenge, we need to define the loss function more precisely. The loss is a function of $w = (w_1, w_2)$, $b$, and the dataset. However, since the dataset is fixed, we omit its explicit dependence. Additionally, the event $ \mathbb{1}_{\{ y_i \neq \hat{y}_i \}} = 0$ can be rewritten using the boundary expression.

To achieve this, we note that the classification condition $y_i \neq \hat{y}_i$ depends on the sign of $w \cdot x_i + b$ (the linear score) relative to $y_i$. By rewriting $y_i$ as $2y_i - 1$ (mapping $y_i = 0$ to $-1$ and $y_i = 1$ to $1$), the condition becomes:

$$ (2y_i - 1)(w \cdot x_i + b) > 0. $$

This expression ensures that the prediction aligns with the true label:

If $y_i = 1$ (toxic), $2y_i - 1 = 1$, so the condition is $w \cdot x_i + b > 0$, matching the boundary condition.
If $y_i = 0$ (non-toxic), $2y_i - 1 = -1$, so the condition is $w \cdot x_i + b \leq 0$, again matching the boundary condition.

To normalize the loss across datasets of different sizes, we divide by $n$, the number of plants. Thus, the loss function becomes:

$$ L(w, b) = \frac{1}{n} \sum_{i=1}^n \mathbb{1}_{\{(2y_i - 1)(w \cdot x_i + b) > 0\}} $$

Observations:

Equivalence of Formulations
The condition $(2y_i - 1)(w \cdot x_i + b) > 0$ is equivalent to the true classification $y_i = \hat{y}_i$. When this product is positive, it indicates that the prediction matches the true label, resulting in zero loss for that particular sample. Conversely, if the product is negative, the prediction does not match the true label, which contributes to the loss.
Normalization by Sample Size
Dividing by $n$ (the total number of samples) helps standardize the loss value across datasets of different sizes. Without normalization, datasets with more samples would inherently have larger loss values, even if the model’s classification performance remained consistent.
Discrete Nature of the Loss
Due to the indicator function $\mathbb{1}$, this loss is non-differentiable, making it challenging to optimize directly. Minimizing the 0/1 loss exactly is typically impractical, and so alternative approaches—such as using differentiable approximations—are common in machine learning. This limitation is what motivates the use of functions like the hinge loss or logistic loss. These alternatives approximate the 0/1 behavior while enabling efficient optimization.

To address the non-differentiability of the indicator-based loss, we replace the hard decision boundary with a smooth, probabilistic interpretation of classification using the sigmoid function:

$$ \sigma(x) = \frac{1}{1 + e^{-x}}. $$

# Define the sigmoid function
def sigmoid(x):
 return 1 / (1 + np.exp(-x))

# Define the 0/1 function
def zero_one(x):
 return np.where(x > 0, 1, 0)

# Generate x values
x_values = np.linspace(-10, 10, 400)

# Compute y values for both functions
sigmoid_values = sigmoid(x_values)
zero_one_values = zero_one(x_values)

# Plot the functions
plt.figure(figsize=(8, 5))
plt.plot(x_values, sigmoid_values, label='Sigmoid Function', color='blue')
plt.plot(x_values, zero_one_values, label='0/1 Function', color='red', linestyle='--')

# Add an upward-pointing arrow for "Probability of Right Classification"
plt.annotate(
 "Probability of Right Classification",
 xy=(4, sigmoid(4)), # Arrow points at this coordinate
 xytext=(4, 0.3), # Position of the text
 arrowprops=dict(facecolor='black', shrink=0.05, width=1.5, headwidth=8),
 ha='center'
)

# Add a downward-pointing arrow for "Probability of Misclassification"
plt.annotate(
 "Probability of Misclassification",
 xy=(-4, sigmoid(-4)), # Arrow points at this coordinate
 xytext=(-4, 0.8), # Position of the text
 arrowprops=dict(facecolor='black', shrink=0.05, width=1.5, headwidth=8),
 ha='center'
)

# Add labels and legend
plt.xlabel("x")
plt.ylabel("Output")
plt.title("Sigmoid and 0/1 Functions")
plt.legend()
plt.grid()
plt.savefig("7.png")
plt.show()

The sigmoid function maps any real-valued input to the interval $[0, 1]$, which is useful for interpreting the output as a probability. By applying the sigmoid function to the linear expression $(2y_i - 1)(w \cdot x_i + b)$, we can smoothly approximate the classification probability of each sample. In the context of our plant classification task, where each plant is represented by its leaf size $(x_i, y_i)$, the expression

$$ \sigma((2y_i - 1)(w \cdot x_i + b)) $$

gives the probability that the plant is well classified. Here, $(2y_i - 1)(w \cdot x_i + b)$ is a measure of how far the sample is from the decision boundary:

If this value is close to zero, it suggests that the plant is near the decision boundary, and thus the model has low confidence in classifying it as toxic or non-toxic.
If the value is positive and large, it means that the sample is far from the boundary and the model is very confident that the plant is well classified.
Conversely, if it is large and negative, it suggests with high confidence that the plant is misclassified.

Given this probabilistic interpretation, we can define an overall quantity that measures how well our model classifies all samples:

$$ \mathbb{P}(w,b) = \prod_{i = 1}^n \sigma((2y_i - 1)(w \cdot x_i + b)) $$

This product represents the probability that all plants are classified correctly according to our model. Known as the likelihood, this quantity serves as a natural criterion for determining the best decision boundary $(w, b)$. To maximize this probability, we seek the decision boundary that yields the highest likelihood, a process known in statistics as maximum likelihood estimation (MLE). Here, we estimate the parameters of our model by maximizing the likelihood function.

Remark: The idea behind maximizing the likelihood is intuitive. In data science, our objective—illustrated here by the plant classification task—is to extract insights from data. Specifically, we aim to explain what determines toxicity in plants based on observable features. One way to tackle this is by hypothesizing a model, then adjusting it to make it as realistic as possible. But “realistic” needs clarification, and a practical interpretation is to “maximize the probability of observing the data we have.”

To achieve this, we often turn to optimization techniques by minimizing the negative logarithm of this probability. The expression becomes:

$$ \begin{aligned} \mathcal{L}(w,b) &= - \sum_{i = 1}^n \log(\sigma((2y_i - 1)(w \cdot x_i + b))) \\[5pt] &= \sum_{i = 1}^n \log \left(1 - e^{-(2y_i - 1)(w \cdot x_i + b)} \right). \end{aligned} $$

This expression, known as the logistic loss, is differentiable and allows us to use gradient-based optimization methods to find the optimal values of $w$ and $b$.

By minimizing the logistic loss, we adjust the model parameters so that toxic plants lie well into the positive region and non-toxic plants lie well into the negative region, thus maximizing the probability of correct classification and achieving effective separation between the classes.

Since the logistic loss is differentiable, we can proceed by performing a gradient descent to find the minimum. The gradient is given by:

$$ ∇ \mathcal{L}(w,b) = \begin{pmatrix} \frac{\partial \mathcal{L}(w, b)}{\partial w} \\ \frac{\partial \mathcal{L}(w, b)}{\partial b} \end{pmatrix}. $$

These derivatives provide the direction of steepest descent for the logistic loss, guiding the optimization process towards the values of $w$ and $b$ that minimize the loss and yield the best separation between toxic and non-toxic plants.

In the code below, we implement logistic regression using the LogisticRegression function from the scikit-learn library. As being said, logistic regression is a powerful classification algorithm commonly used for binary classification tasks, where the goal is to predict one of two possible outcomes. By fitting a linear decision boundary to the training data, the model predicts the probability of an instance belonging to one of the classes. Scikit-learn’s LogisticRegression class automatically applies optimization techniques to find the best-fitting model parameters (weights and bias), which maximize the likelihood of correct predictions. The model output is interpreted as a probability, thanks to the sigmoid function, and we can use it to classify new data points.

This implementation provides a straightforward and efficient way to train a logistic regression model, evaluate its accuracy, and visualize the decision boundary for classification tasks.

# Separate features and labels
X = data[:, :2] # Width and Radius as features
y = data[:, 2] # Toxicity as labels

# Initialize and train the linear classifier (Logistic Regression)
classifier = LogisticRegression()
classifier.fit(X, y)

# Predict the labels using the trained model
predictions = classifier.predict(X)
accuracy = accuracy_score(y, predictions)
print("Accuracy:", accuracy)

# Plotting the decision boundary
# Create a mesh to plot the decision boundary
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),
 np.arange(y_min, y_max, 0.01))

# Predict over the mesh grid
Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plot the decision boundary and data points
plt.contourf(xx, yy, Z, alpha=0.2, cmap=plt.cm.RdYlBu)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolor='k', cmap=plt.cm.RdYlBu, s=60)
plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Linear Classification of Plants (Toxic vs. Edible)")
plt.colorbar(label='Toxicity')
plt.savefig("8.png")
plt.show()

Accuracy: 1.0

There are four steps in the alogorithm:

The first step is to create an instance of the logistic regression model. This is done using the LogisticRegression() function from scikit-learn. model = LogisticRegression()
The next step is to train the model using the training data. We use the fit() method, which takes the feature data ($X =(\textrm{width},\textrm{radius})$) and the target labels ($y \in \{0,1\}$) to adjust the model’s parameters (weights and bias). model.fit(X,y)
After training the model, we evaluate its performance by visualizing the decision boundary. In 2D, this boundary is a line, and in higher dimensions, it is a hyperplane that separates the two classes. By plotting the decision boundary, we can visually inspect how well the model classifies the data and identify areas where it may struggle (i.e., near the boundary). This helps us assess the model’s generalization ability and robustness. We can also computate the accuracy, $$ \textrm{accuracy} = \frac{\textrm{well classified data}}{\textrm{well} + \textrm{misclassified data}}.$$

Remark: It is important to be cautious when using any metric score, such as accuracy, to evaluate model performance. In cases of imbalanced datasets, accuracy can provide a misleading assessment of the model’s effectiveness. For example, if there are significantly more toxic plants than non-toxic ones in the dataset, a model that predicts “toxic” for most plants may appear to perform well in terms of accuracy, even though it fails to correctly classify non-toxic plants.

Now that our logistic regression model is trained, we can use it to make predictions for new plants. Given the features of a new plant (e.g., leaf size, width, and radius), we input these values into the trained model to obtain the predicted class. The model will output a probability indicating how likely the plant is to belong to the toxic or non-toxic category. Based on this probability, we can assign the plant to the most likely class.

For example, we can use the following code to predict the class of a new plant:

# Test Dataset: New data to evaluate the classifier
test_data = np.array([
 [5.7, 2.5, 0],
 [6.3, 2.9, 1],
 [4.9, 2.0, 0],
 [6.4, 3.1, 1],
 [5.5, 2.2, 0],
 [6.7, 3.3, 1],
 [5.8, 2.4, 0],
 [6.1, 2.7, 1]
])

# Separate test features and labels
X_test = test_data[:, :2]
y_test = test_data[:, 2]

# Initialize and train the linear classifier (Logistic Regression)
classifier = LogisticRegression()
classifier.fit(X, y)

# Predict on the test set
test_predictions = classifier.predict(X_test)

# Calculate the accuracy on the test set
test_accuracy = accuracy_score(y_test, test_predictions)
print("Test Set Accuracy:", test_accuracy)

# Print predictions for the test set
print("Test Predictions:", test_predictions)
print("Actual Test Labels:", y_test)

# Plotting the decision boundary with both training and test points
# Create a mesh to plot the decision boundary
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),
 np.arange(y_min, y_max, 0.01))

# Predict over the mesh grid
Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plot the decision boundary and training points
plt.contourf(xx, yy, Z, alpha=0.2, cmap=plt.cm.RdYlBu)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolor='k', cmap=plt.cm.RdYlBu, s=60, marker='o', label="Training Points")
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, edgecolor='k', cmap=plt.cm.RdYlBu, s=60, marker='s', label="Test Points")
plt.xlabel("Width (cm)")
plt.ylabel("Radius (cm)")
plt.title("Linear Classification of Plants (Toxic vs. non toxic)")
plt.colorbar(label='Toxicity')
plt.legend()
plt.savefig("9.png")
plt.show()

Test Set Accuracy: 0.5
Test Predictions: [1 1 1 1 1 1 1 1]
Actual Test Labels: [0. 1. 0. 1. 0. 1. 0. 1.]

After training our logistic regression model on the training dataset, we evaluate its performance using a test dataset. This evaluation is crucial as it helps us understand how well the model generalizes to new, unseen data—something that is essential for ensuring its real-world applicability. Below is an overview of the key results:

Test Set Performance: The model achieved perfect accuracy on the test set, correctly classifying all test samples as toxic or non-toxic. This suggests that the model has effectively learned the relationship between the input features (leaf size) and the target labels (toxicity) during training and can accurately predict toxicity in new, unseen samples.
Decision Boundary and Class Separation: By visualizing the decision boundary, we can see that the model has created a clear division between the toxic and non-toxic plants, with the test data points also lying on the correct side of the boundary. This visual inspection confirms that the model’s decision-making is consistent with the underlying structure of the data.
Model Generalization: The fact that the model performs well on both the training data and the test data suggests that it has generalized well. This is a key aspect of a robust model—ensuring that it does not overfit to the training data, but instead learns patterns that are applicable to any new data it encounters.

Broader Takeaways

The success of logistic regression in this task highlights the power of such ML algorithm called here supervised learning algorithms in classification tasks, especially when the data is well-structured and the model is appropriately regularized. Furthermore, the ability to visualize the decision boundary provides valuable insights into the model’s behavior, offering a clear explanation of how it classifies new examples.

In real-world applications, this approach is essential because models that cannot generalize well to unseen data can lead to poor performance when deployed in dynamic environments. The high accuracy and well-separated decision boundary in our case suggest that this logistic regression model would be effective in real-world plant toxicity classification tasks, making it a practical tool for predictive analytics in fields like agriculture or environmental science.

Conclusion and take home message

The classification task that we performed is known as binary linear classification. It is binary because it involves two distinct classes, and linear because the decision boundary can be represented with a simple linear equation.

This task captures the essence of machine learning, where models learn to identify patterns from data, extracting knowledge that might otherwise remain hidden. Machine learning does not just automate processes—it helps us interpret, understand, and even predict aspects of reality by leveraging the power of computation.

Yet, reality is often complex, and the relationships in data are not always clear-cut or easily separable by simple boundaries. For instance, if the plants in our dataset were not linearly separable, we would need more sophisticated techniques to uncover the underlying patterns, perhaps through nonlinear transformations or other feature engineering approaches. This is where the potential of machine learning truly unfolds.

##Edibility of plants and nonlinear classification

The team of biologists celebrated their groundbreaking achievement: they had successfully classified toxic and non-toxic plants using the shapes of their leaves through a linear classification model. This breakthrough promised safer ecosystems, as animals and humans could now distinguish between harmful and harmless plants with ease. The team’s discovery was heralded as a triumph of science and machine learning.

However, an alarming phenomenon soon emerged. Entire colonies of ants were mysteriously dying after collecting what the model identified as “non-toxic” plants. Despite the model’s high accuracy in the lab, these plants wreaked havoc in the ants’ colonies. Confused and concerned, the biologists embarked on a deeper investigation.

To understand the mystery, the team began mapping the geographic locations of both the thriving and decimated ant colonies. Run the code below to import the data:

# Function to generate the dataset
def colonies_locations(num_points=200, circle_radius=5, center=(0, 0)):
 """
 Generate a dataset of ant colonies' locations. Colonies inside the toxic radius
 are marked as affected (1), while others outside are unaffected (0).
 """
 # Generate random points (x, y) in the 2D plane
 X = np.random.uniform(-circle_radius * 1.5, circle_radius * 1.5, (num_points, 2))

 # Calculate the Euclidean distance of each point from the center
 distances = np.linalg.norm(X - center, axis=1)

 # Label points based on whether they are inside (1) or outside (0) the toxic zone
 y = (distances > circle_radius).astype(int)

 return X, y

X, y = colonies_locations(num_points=200, circle_radius=5)

Data Vizualization

Just as before, a good starting point is to closely examine the dataset. Observing its structure, patterns, and distribution provides valuable insights into the problem at hand and sets the foundation for any subsequent analysis or modeling.

# Plot the dataset
plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red', label='Decimated Colonies', alpha=0.6)
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue', label='Thriving Colonies', alpha=0.6)
plt.xlabel('Longitude')
plt.ylabel('Latitude')
plt.title('Geographical Distribution of Ant Colonies')
plt.axhline(0, color='black', linewidth=1)
plt.axvline(0, color='black', linewidth=1)
plt.grid(True)
plt.legend()
plt.savefig("10.png")
plt.show()

To solve this problem using machine learning, we can leverage what we’ve learned about linear classification. However, in this case, it’s clear that no simple straight line can separate the decimated colonies (red) from the thriving colonies (blue). To overcome this, we can transform the dataset in a way that makes it linearly separable while preserving its inherent structure.

Feature engineering

One approach is to apply a feature map, which is a mathematical function that transforms the data into a higher-dimensional space where the separation becomes easier. Specifically, we define a feature map $\Phi$ from the original 2D space $\mathbb{R}^2$ to a transformed space $\Phi(\mathbb{R}^2)$:

$$ \Phi : \mathbb{R}^2 \to \Phi(\mathbb{R}^2) $$

The goal is to transform the dataset so that it becomes linearly separable in the new feature space. A smart way to do this is by adding a feature that measures the Euclidean distance from the center point (the origin, in this case). This new feature can help in distinguishing between the colonies that are inside the circle (label 0) and those that are outside (label 1).

We define the feature map as:

$$ \Phi(x_1,x_2) = \left( x_1, x_2, 4(x_1^2 + x_2^2) \right) $$

This transformation introduces a new third dimension based on the squared distance from the center of the circle, which can help make the data linearly separable in the transformed space.

The following plot visualizes the location of the ants’ colonies after applying the feature map, showing how the transformation helps in distinguishing the two classes more clearly.

# Feature map function
def feature_map(X):
 x1 = X[:, 0]
 x2 = X[:, 1]
 return np.column_stack((x1, x2, 4*(x1**2 + x2**2)))


# Apply the feature map to the dataset
X_featured = feature_map(X)
data = np.column_stack((X_featured, y))

# Plotting in 3D space
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

# Scatter plot the transformed points
ax.scatter(X_featured[y == 0, 0], X_featured[y == 0, 1], X_featured[y == 0, 2],
 color='red', label='Decimated colony', alpha=0.6)
ax.scatter(X_featured[y == 1, 0], X_featured[y == 1, 1], X_featured[y == 1, 2],
 color='blue', label='Thriving colony', alpha=0.6)

# Labels and title
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('4*(x1^2 + x2^2)')
ax.set_title('3D Feature Space: Transformed Points by Feature Map')

# Show legend
ax.legend()

# Adjust view to make the red points clearly above the blue points
ax.view_init(elev=1, azim=30)

plt.savefig("11.png")
plt.show()

Support vector classifier in transformed space

In the transformed feature space, the data appears to be linearly separable. To leverage the techniques we’ve learned in this course, we can use a Support Vector Classifier (SVC) from the scikit-learn library to find the optimal decision boundary.

While it is possible to derive the decision boundary manually by maximizing the margin — the distance between the two classes — the focus of this course is not on hand-calculating these values. Instead, we aim to take advantage of simple, efficient methods provided by existing libraries, reserving complex mathematical derivations for when they are necessary.

The following code demonstrates how to use the SVC to find and plot the separating affine hyperplane that divides the two classes.

# Train SVM on the transformed feature space
svm_classifier = SVC(kernel='linear')
svm_classifier.fit(X_featured, y)

# Extract the separating hyperplane parameters (weights and bias)
weights = svm_classifier.coef_[0]
bias = svm_classifier.intercept_[0]

# Define the decision boundary (hyperplane) equation in the feature space
# Equation of the hyperplane: w1*x1 + w2*x2 + w3*x3 + b = 0

# Create a grid of points in 3D space for plotting
x1_range = np.linspace(X_featured[:, 0].min(), X_featured[:, 0].max(), 50)
x2_range = np.linspace(X_featured[:, 1].min(), X_featured[:, 1].max(), 50)
x1_grid, x2_grid = np.meshgrid(x1_range, x2_range)

# Compute the corresponding x3 values based on the decision boundary
x3_grid = -(weights[0]*x1_grid + weights[1]*x2_grid + bias) / weights[2]

# Plotting the data and the separating hyperplane
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

# Plot the data points
ax.scatter(X_featured[y == 0, 0], X_featured[y == 0, 1], X_featured[y == 0, 2],
 color='red', label='Decimated colonies', alpha=0.6)
ax.scatter(X_featured[y == 1, 0], X_featured[y == 1, 1], X_featured[y == 1, 2],
 color='blue', label='Thriving colonies', alpha=0.6)

# Plot the separating hyperplane (decision boundary)
ax.plot_surface(x1_grid, x2_grid, x3_grid, color='yellow', alpha=0.5, rstride=100, cstride=100)

# Labels and title
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('4*(x1^2 + x2^2)')
ax.set_title('3D Feature Space: SVM Separating Hyperplane')

# Show legend
ax.legend()

# Adjust view for better visualization
ax.view_init(elev=5, azim=30)

plt.savefig("12.png")
plt.show()

Achieving a nonlinear boundary using a linear approach

To transition from the feature space back to the original geographic space of the colonies (latitude and longitude), we need to determine the boundary $B$ that separates the decimated colonies from the thriving ones in $\mathbb{R}^2$.

Let $H$ denote the affine separating hyperplane in the feature space. The corresponding boundary $B$ in $\mathbb{R}^2$ is defined as:

$$ B = \Phi^{-1} \left( H \cap \Phi \left( \mathbb{R}^2 \right) \right). $$

Why does this definition work? The reasoning is as follows:

A point $(x_1, x_2)$ lies on the boundary $B$ if and only if its feature-transformed image $\Phi(x_1, x_2)$ lies on the hyperplane $H$: $$ (x_1, x_2) \in B \iff \Phi(x_1, x_2) \in H. $$
Additionally, since $\Phi(x_1, x_2)$ is in the range of $\Phi$, we also have: $$ \Phi(x_1, x_2) \in H \cap \Phi\left(\mathbb{R}^2\right). $$
Applying $\Phi^{-1} : \Phi \left( \mathbb{R}^2 \right) \to \mathbb{R}^2$, which is bijective, we arrive at: $$ (x_1, x_2) \in \Phi^{-1} \left( H \cap \Phi\left(\mathbb{R}^2\right) \right). $$

Thus, the boundary $B$ is precisely the inverse image of the intersection of $H$ with $\Phi(\mathbb{R}^2)$.

We now derive the boundary

The feature map is defined as:

$$ \Phi(x_1, x_2) = \left(x_1, x_2, 4(x_1^2 + x_2^2)\right). $$

The range of $\Phi$ is:

$$ \Phi\left(\mathbb{R}^2\right) = \left\lbrace \left(x_1, x_2, 4(x_1^2 + x_2^2)\right) \mid (x_1, x_2) \in \mathbb{R}^2 \right\rbrace. $$

The separating hyperplane $H$ in the feature space is given by the equation derived from the SVM classifier:

$$ H: \left\lbrace (y_1, y_2, y_3) \in \mathbb{R}^3 \mid w_1 y_1 + w_2 y_2 + w_3 y_3 + b = 0 \right\rbrace. $$

The intersection $H \cap \Phi\left(\mathbb{R}^2\right)$ is therefore:

$$ H \cap \Phi\left(\mathbb{R}^2\right) = \left\lbrace \left(x_1, x_2, 4(x_1^2 + x_2^2)\right) \mid (x_1, x_2) \in \mathbb{R}^2 \text{ and } w_1 x_1 + w_2 x_2 + 4w_3(x_1^2 + x_2^2) + b = 0 \right\rbrace. $$

Applying $\Phi^{-1}$, we obtain the boundary in $\mathbb{R}^2$:

$$ B = \left\lbrace (x_1, x_2) \in \mathbb{R}^2 \mid 4w_3 x_1^2 + 4w_3 x_2^2 + w_1 x_1 + w_2 x_2 + b = 0 \right\rbrace. $$

The resulting equation for $B$ is a conic section (e.g., a circle, ellipse, parabola, or hyperbola) depending on the parameters $w_1, w_2, w_3,$ and $b$. This reflects the flexibility of using nonlinear feature transformations, as they allow us to solve problems that are not linearly separable in the original space.

In this case, the SVM in the feature space finds a linear separator, but when projected back to the original space, the separator becomes a curved boundary, effectively distinguishing the decimated colonies from the thriving ones.

# Define a grid for the original space
x1_range = np.linspace(X[:, 0].min(), X[:, 0].max(), 100)
x2_range = np.linspace(X[:, 1].min(), X[:, 1].max(), 100)
x1_grid, x2_grid = np.meshgrid(x1_range, x2_range)

# Compute the corresponding boundary in the original space
boundary_values = (
 4 * weights[2] * (x1_grid**2 + x2_grid**2)
 + weights[0] * x1_grid
 + weights[1] * x2_grid
 + bias
)

# Plot the dataset and boundary in the original space
plt.figure(figsize=(8, 6))

# Plot the data points
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red', label='Decimated colonies', alpha=0.6)
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue', label='Thriving colonies', alpha=0.6)

# Plot the boundary
plt.contour(x1_grid, x2_grid, boundary_values, levels=[0], colors='yellow', linewidths=2)

# Add labels, title, and legend
plt.xlabel('x1 (Latitude)')
plt.ylabel('x2 (Longitude)')
plt.title('Original Space: Dataset and Boundary $B$')
plt.legend()
plt.grid(True)

plt.savefig("13.png")
plt.show()

The classification results in the transformed feature space are highly successful. By mapping the data to a higher-dimensional space, we were able to achieve a clear separation between the decimated and thriving colonies. The SVM classifier identified a linear hyperplane in this new space, which corresponds to a non-linear decision boundary in the original feature space. This process showcases the effectiveness of feature engineering in simplifying complex classification tasks.

The core idea behind this approach was to modify the feature space such that the complex relationships in the original data become more tractable. Initially, the data in $ \mathbb{R}^2 $ was not linearly separable. To address this, we applied a feature map:

$$ \Phi(x_1, x_2) = (x_1, x_2, 4(x_1^2 + x_2^2)), $$

which introduces an additional feature that captures the squared Euclidean distance from the origin. This transformation sends the data into a higher-dimensional space $ \mathbb{R}^3 $, where the two classes become linearly separable. After identifying a linear separator (hyperplane) in this new space, we can map the decision boundary back to the original space, where it appears as a non-linear separation.

The motivation behind transforming the feature space stems from the limitations of linear classifiers. While linear classifiers are powerful and easy to interpret, they struggle with data that is not linearly separable. By mapping the data into a higher-dimensional space, we take advantage of the geometry in that space to make the classification task simpler. This strategy is the essence of kernel methods, such as kernelized SVM, which extend the concept of linear classification to non-linear problems by implicitly working in a higher-dimensional feature space.

Kernel Methods: Extending Linear Classification to Nonlinear Problems

Kernel methods provide a powerful framework for tackling classification tasks where data is not linearly separable in the original feature space. Instead of explicitly transforming the data into a higher-dimensional space, kernel methods use a mathematical trick that allows us to compute the inner product of data points in this higher-dimensional space without ever computing their explicit coordinates. This trick is known as the kernel trick, and it allows us to perform complex non-linear classification efficiently, using simple linear classifiers like Support Vector Machines (SVMs).

The idea behind kernel methods is to use a kernel function, which implicitly maps the data from the original feature space into a higher-dimensional space where linear separation becomes possible. A kernel function computes the inner product between the transformed data points in this higher-dimensional space, without actually performing the transformation. The most commonly used kernel functions are:

Linear Kernel: This is simply the standard dot product between data points in the original space, and is equivalent to using no transformation at all.
$$ K(x, y) = x^T y $$
Polynomial Kernel: This kernel maps the data to a higher-dimensional space based on polynomial features.
$$ K(x, y) = (x^T y + c)^d $$
Radial Basis Function (RBF) Kernel: Also known as the Gaussian kernel, it maps data to an infinite-dimensional space, and is particularly effective when dealing with complex data distributions.
$$ K(x, y) = \exp\left(-\frac{\|x - y\|^2}{2\sigma^2}\right) $$

# Train an SVM classifier with a polynomial kernel (degree 2)
svm_classifier = SVC(kernel='poly', degree=2, C=1)
svm_classifier.fit(X, y)

# Plotting the decision boundary in the original space
plt.figure(figsize=(8, 6))
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red', label='Decimated colonies')
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue', label='Thriving colonies')

# Create a mesh grid for plotting decision boundary
x1_range = np.linspace(X[:, 0].min(), X[:, 0].max(), 50)
x2_range = np.linspace(X[:, 1].min(), X[:, 1].max(), 50)
xx, yy = np.meshgrid(x1_range, x2_range)

# Use the trained SVM to predict on the grid points
Z = svm_classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plot the decision boundary
plt.contour(xx, yy, Z, levels=[0.5], linewidths=2, colors='yellow')

# Labels and title for the original space
plt.xlabel('x1')
plt.ylabel('x2')
plt.title('Decision Boundary with Polynomial Kernel (Degree 2)')
plt.legend()

plt.savefig("14.png")
plt.show()

The decision boundary obtained using the polynomial kernel method exhibits slight differences compared to the one derived from the explicit feature mapping and linear classification. These differences stem from the nature of kernel methods and their underlying computations.

Explicit Feature Map: When using a hand-crafted feature map (e.g., ($ \Phi(x_1, x_2) = (x_1, x_2, 4(x_1^2 + x_2^2)) $), the transformation is predefined and fixed. The classifier then finds a hyperplane in the explicitly mapped feature space, which corresponds to a non-linear boundary in the original space.
Kernel Trick: In contrast, the polynomial kernel implicitly computes the feature interactions without explicitly mapping the data into the higher-dimensional space. This implicit mapping allows the kernel to adaptively capture the data structure based on the degree of the polynomial and the distribution of the data.

The boundary obtained using the polynomial kernel is influenced by the kernel parameters and the data distribution. The kernel computes similarity directly between points, allowing for a more flexible separation. When using the hand-crafted feature map, the decision boundary is directly tied to the chosen transformation. While effective for specific problems (e.g., circular separability), this approach may lack flexibility if the transformation does not perfectly capture the data’s underlying geometry.

In this example, the explicit feature map emphasizes radial separability with a specific quadratic term ($ 4(x_1^2 + x_2^2) $), while the polynomial kernel considers all possible quadratic combinations of the features. This subtle difference in feature representation affects the decision boundary’s shape.

Despite the slight differences in the boundary, both approaches successfully classify the two classes. However, the polynomial kernel’s flexibility ensures robustness across various data distributions, which might not always be achievable with a manually defined feature map.

The differences between the two boundaries highlight the balance between flexibility and specificity in feature transformation. While explicit feature maps can provide elegant solutions for specific problems, kernel methods excel in generality and adaptability, making them a cornerstone of modern machine learning techniques.

###Polynomial classification

Instead of relying on kernel methods, one might choose to leverage the hypothesis on the form of the decision boundary in the original feature space. As mentioned above, in our classification problem, the data suggests a quadratic separation between the two classes:

$$ \mathcal{B}: \alpha_1 x_1^2 + \alpha_2 x_2^2 + \alpha_3 x_1 x_2 + \alpha_4 x_1 + \alpha_5 x_2 + \beta = 0.$$

(To be more specified we can already set $\beta = 0$ since the dataset is centered ouround the origin). This approach involves making an explicit assumption about the mathematical structure of the boundary, such as a second-degree polynomial equation, and then determining the optimal parameters of this equation.

The strategy here mirrors that of logistic regression but applied to an expanded feature space. By generating polynomial features (e.g., quadratic terms), we transform the dataset into a higher-dimensional representation where the decision boundary becomes linear. The parameters of the quadratic decision boundary are then estimated by minimizing the logistic loss function over the dataset, as in standard logistic regression.

# Create polynomial features (degree 2)
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)

# Train a logistic regression classifier on the expanded polynomial features
classifier = LogisticRegression()
classifier.fit(X_poly, y)

# Create a mesh grid for plotting decision boundary
x1_range = np.linspace(X[:, 0].min(), X[:, 0].max(), 50)
x2_range = np.linspace(X[:, 1].min(), X[:, 1].max(), 50)
xx, yy = np.meshgrid(x1_range, x2_range)
grid_points = np.c_[xx.ravel(), yy.ravel()]
grid_points_poly = poly.transform(grid_points)

# Predict probabilities for the grid points
Z = classifier.predict(grid_points_poly)
Z = Z.reshape(xx.shape)

# Plot the decision boundary
plt.figure(figsize=(8, 6))
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red', label='Decimated colonies')
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue', label='Thriving colonies')
plt.contour(xx, yy, Z, levels=[0.5], linewidths=2, colors='yellow')

plt.xlabel('x1')
plt.ylabel('x2')
plt.title('Decision Boundary with Polynomial Classification (Degree 2)')
plt.legend()

plt.savefig("15.png")
plt.show()

As we can see, the decision boundary derived using the logistic regression model is very similar to the one obtained with the Support Vector Machine (SVM). Despite the differences in the underlying methods, both approaches successfully capture the separation between the two classes in the feature space. This is especially evident given the high accuracy achieved by the logistic regression model, which indicates that the quadratic form of the decision boundary effectively classifies the data points with a high degree of precision. The similarity between the boundaries reflects how well the quadratic separation hypothesis aligns with the true structure of the data, confirming that this method is capable of capturing the underlying patterns in a way that is comparable to more complex methods like SVMs.

This method has several advantages:

Interpretability: By explicitly constructing the polynomial features, the resulting boundary can be directly interpreted as a specific quadratic equation.
Simplicity: This approach avoids the implicit feature mapping of kernel methods, providing a more transparent model.
Customization: It allows researchers to leverage their intuition about the dataset to design the feature space, such as adding specific polynomial terms relevant to the problem.

However, there are limitations to this approach:

Manual feature design: It requires some intuition or prior knowledge about the data to determine the appropriate polynomial degree.
Scalability: Explicitly generating polynomial features can become computationally expensive for high-degree polynomials or large datasets.

Conclusion on nonlinear classification and the non edibility of plants

Through the process of classification, the biologist team was able to delineate the area separating the decimated and thriving colonies, which led to the hypothesis that a factor in the center of the zone might be contaminating the plants used by the ants.

Further investigation revealed the presence of nuclear waste in the central area, likely releasing toxic isotopes into the soil and water, which in turn affected the plants that the ants relied on for food. This contamination, caused by radioactive material, could have impaired the plants’ ability to produce essential nutrients or even led to the accumulation of harmful substances in the ants’ food sources.

By leveraging data-driven techniques, the biologists were able to uncover an underlying environmental hazard.

Conclusion

Through these two toy examples, we have explored the fundamental concept of binary classification. A variety of machine learning algorithms and techniques have been discussed, including:

Logistic Regression
Linear Regression
Polynomial Classification
Support Vector Classifiers (SVM)
Kernel Methods
Maximimum Likelyhood Estimator

We also covered essential techniques for improving model performance, such as:

Feature Engineering
Convexification of the Loss Function
Gradient Descent
Optimization Methods

Moreover, we highlighted several key concepts that are central to effective machine learning, such as:

Adaptability
Specificity
Robustness
Flexibility

The core takeaway from this exploration is not just the mastery of techniques but the underlying philosophy of machine learning. At its core, machine learning is about extracting knowledge from data. The ultimate question it addresses is how we can leverage the computational power of modern systems to uncover patterns, insights, and relationships within vast datasets, enabling us to make more informed decisions and solve complex problems that were once out of reach.

Guillhem Artis
Sorbonne graduate in Machine Learning and Statistics - ENS Mathematics diploma
LinkedIn

Estimating Molecular Ground State Energy

Mon, 01 Jan 0001 00:00:00 +0000

Variational Quantum Eigensolver (VQE) using PennyLane

Overview

Variational Quantum Eigensolver (VQE) is a hybrid quantum-classical algorithm used to estimate the ground-state energy of molecular systems. In this tutorial, we demonstrate how to use PennyLane to perform VQE on the Beryllium Hydride (BeH₂) molecule. We start by building the molecular Hamiltonian then prepares a trial wave function, and the classical optimizer adjusts the parameters to minimize the energy.

1. Building the electronic Hamiltonoian

Import necessary libraries

import pennylane as qml
from pennylane import numpy as np
import functools

Define molecular geometry

mol=qml.qchem.mol_data("BeH2")
symbols = ["H","Be","H"]
geometry = np.array([[0.0, 0.0, -1.7],[0.0,0.0,0.0], [0.0, 0.0, 1.7]])

mol1=qml.qchem.mol_data("BeH2")
print(mol1)

(['Be', 'H', 'H'], tensor([[ 4.79404621, 0.29290755, 0. ],
 [ 3.77945225, -0.29290755, 0. ],
 [ 5.80882913, -0.29290755, 0. ]], requires_grad=True))

Define active space

Define an active space to perform quantum simulations with a reduced number of qubits by classifying the molecular orbitals as core and active orbitals.

core, active = qml.qchem.active_space(6, 5, active_electrons=4, active_orbitals=3)
print('core orbitals:', core, '\nactive orbitals:', active )

core orbitals: [0]
active orbitals: [1, 2, 3]

Build the Hamiltonian


H, qubits = qml.qchem.molecular_hamiltonian(symbols, geometry, active_electrons=4, active_orbitals=4)
print('qubits:',qubits,'\n\nH =',H)

qubits: 8
H = (-14.225298300082315) [I0]
+ (-0.017858339631270377) [Z4]
+ (-0.017858339631270377) [Z5]
+ (-0.01785833963125627) [Z7]
+ (-0.01785833963125623) [Z6]
+ (0.18376934404852158) [Z3]
+ (0.1837693440485218) [Z2]
+ (0.189293865627094) [Z0]
+ (0.189293865627094) [Z1]
+ (0.07464706092699114) [Z0 Z2]
+ (0.07464706092699114) [Z1 Z3]
+ (0.0872371502053069) [Z0 Z4]
+ (0.0872371502053069) [Z1 Z5]
+ (0.0872371502053263) [Z0 Z6]
+ (0.0872371502053263) [Z1 Z7]
+ (0.09401471929144516) [Z2 Z4]
+ (0.09401471929144516) [Z3 Z5]
+ (0.09401471929146607) [Z2 Z6]
+ (0.09401471929146607) [Z3 Z7]
+ (0.0942777355550643) [Z4 Z6]
+ (0.0942777355550643) [Z5 Z7]
+ (0.0987691272565404) [Z2 Z5]
+ (0.0987691272565404) [Z3 Z4]
+ (0.09876912725656237) [Z2 Z7]
+ (0.09876912725656237) [Z3 Z6]
+ (0.10034008122331718) [Z4 Z7]
+ (0.10034008122331718) [Z5 Z6]
+ (0.10166582964774823) [Z0 Z5]
+ (0.10166582964774823) [Z1 Z4]
+ (0.10166582964777082) [Z0 Z7]
+ (0.10166582964777082) [Z1 Z6]
+ (0.11246477255979793) [Z4 Z5]
+ (0.11246477255984795) [Z6 Z7]
+ (0.11360615202622484) [Z0 Z1]
+ (0.11637400311980817) [Z0 Z3]
+ (0.11637400311980817) [Z1 Z2]
+ (0.12193472299847673) [Z2 Z3]
+ (-0.04172694219281703) [Y0 Y1 X2 X3]
+ (-0.04172694219281703) [X0 X1 Y2 Y3]
+ (-0.014428679442444536) [Y0 Y1 X6 X7]
+ (-0.014428679442444536) [X0 X1 Y6 Y7]
+ (-0.014428679442441326) [Y0 Y1 X4 X5]
+ (-0.014428679442441326) [X0 X1 Y4 Y5]
+ (-0.006062345668252879) [Y4 Y5 X6 X7]
+ (-0.006062345668252879) [X4 X5 Y6 Y7]
+ (-0.004754407965096297) [Y2 Y3 X6 X7]
+ (-0.004754407965096297) [X2 X3 Y6 Y7]
+ (-0.00475440796509524) [Y2 Y3 X4 X5]
+ (-0.00475440796509524) [X2 X3 Y4 Y5]
+ (0.00475440796509524) [Y2 X3 X4 Y5]
+ (0.00475440796509524) [X2 Y3 Y4 X5]
+ (0.004754407965096297) [Y2 X3 X6 Y7]
+ (0.004754407965096297) [X2 Y3 Y6 X7]
+ (0.006062345668252879) [Y4 X5 X6 Y7]
+ (0.006062345668252879) [X4 Y5 Y6 X7]
+ (0.014428679442441326) [Y0 X1 X4 Y5]
+ (0.014428679442441326) [X0 Y1 Y4 X5]
+ (0.014428679442444536) [Y0 X1 X6 Y7]
+ (0.014428679442444536) [X0 Y1 Y6 X7]
+ (0.04172694219281703) [Y0 X1 X2 Y3]
+ (0.04172694219281703) [X0 Y1 Y2 X3]

charge=0, mult=1, basis='sto-3g', method='dhf', active_electrons=4, active_orbitals=4, mapping='jordan_wigner'

2. Simulation Setup

Define the cost function to compute the expectation value of the molecular Hamiltonian in the trial state prepared by the circuit.

Prepare initial state and ansatz

initial_state = qml.qchem.hf_state(4,qubits)
singles, doubles = qml.qchem.excitations(4, qubits)
s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
ansatz = functools.partial(qml.UCCSD, init_state=initial_state, s_wires=s_wires, d_wires=d_wires)

Visualize the circuit

qml.draw_mpl(cost)(np.zeros(len(singles)+len(doubles)))

(<Figure size 3000x900 with 1 Axes>, <Axes: >)

Define the device and cost function

dev = qml.device('lightning.qubit', wires=qubits)
@qml.qnode(dev)
def cost(params):
 ansatz(params, wires=dev.wires)
 return qml.expval(H)

3. Running the VQE Optimization

Now we proceed to minimize the cost function to find the ground state of the $BeH_{2}$ molecule. To start, we need to define the classical optimizer and initialize the circuit parameter $\theta$.

Initialize optimizer and parameters

optimizer = qml.GradientDescentOptimizer(stepsize=0.4)
theta = np.array(np.random.normal(0, np.pi, len(singles) + len(doubles)), requires_grad=True)
print(cost(theta))

-14.54714957820648

Optimization loop

# store the values of the cost function
energy = [cost(theta)]

# store the values of the circuit parameter
angle = [theta]

max_iterations = 80
conv_tol = 1e-06

for n in range(max_iterations):
 theta, prev_energy = optimizer.step_and_cost(cost, theta)

 energy.append(cost(theta))
 angle.append(theta)

 conv = np.abs(energy[-1] - prev_energy)

 if n % 2 == 0:
 print(f"Step = {n}, Energy = {energy[-1]:.8f} Ha")

 if conv <= conv_tol:
 break

print("\n" f"Final value of the ground-state energy = {energy[-1]:.8f} Ha")
#print("\n" f"Optimal value of the circuit parameter = {angle[-1]:.4f}")

Step = 0, Energy = -14.63557759 Ha
Step = 2, Energy = -14.78225259 Ha
Step = 4, Energy = -14.88670434 Ha
Step = 6, Energy = -14.95791760 Ha
Step = 8, Energy = -15.00763932 Ha
Step = 10, Energy = -15.04499395 Ha
Step = 12, Energy = -15.07580596 Ha
Step = 14, Energy = -15.10340072 Ha
Step = 16, Energy = -15.12944838 Ha
Step = 18, Energy = -15.15456471 Ha
Step = 20, Energy = -15.17872483 Ha
Step = 22, Energy = -15.20157124 Ha
Step = 24, Energy = -15.22265201 Ha
Step = 26, Energy = -15.24158903 Ha
Step = 28, Energy = -15.25816881 Ha
Step = 30, Energy = -15.27236184 Ha
Step = 32, Energy = -15.28429206 Ha
Step = 34, Energy = -15.29418402 Ha
Step = 36, Energy = -15.30230986 Ha
Step = 38, Energy = -15.30894833 Ha
Step = 40, Energy = -15.31435887 Ha
Step = 42, Energy = -15.31876880 Ha
Step = 44, Energy = -15.32236951 Ha
Step = 46, Energy = -15.32531797 Ha
Step = 48, Energy = -15.32774085 Ha
Step = 50, Energy = -15.32973939 Ha
Step = 52, Energy = -15.33139419 Ha
Step = 54, Energy = -15.33276939 Ha
Step = 56, Energy = -15.33391611 Ha
Step = 58, Energy = -15.33487528 Ha
Step = 60, Energy = -15.33567983 Ha
Step = 62, Energy = -15.33635639 Ha
Step = 64, Energy = -15.33692662 Ha
Step = 66, Energy = -15.33740823 Ha
Step = 68, Energy = -15.33781579 Ha
Step = 70, Energy = -15.33816130 Ha
Step = 72, Energy = -15.33845473 Ha
Step = 74, Energy = -15.33870437 Ha
Step = 76, Energy = -15.33891713 Ha
Step = 78, Energy = -15.33909878 Ha

Final value of the ground-state energy = -15.33917949 Ha

4. Visualization of the Optimization Process

Plot energy convergence

import matplotlib.pyplot as plt

fig = plt.figure()
fig.set_figheight(5)
fig.set_figwidth(12)

# Full configuration interaction (FCI) energy computed classically
E_fci = -15.56089
ax1 = fig.add_subplot(121)
ax1.plot(range(n + 2), energy, "go", ls="dashed")
ax1.plot(range(n + 2), np.full(n + 2, E_fci), color="red")
ax1.set_xlabel("Optimization step", fontsize=13)
ax1.set_ylabel("Energy (Hartree)", fontsize=13)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.show()

References

Peruzzo et al., A variational eigenvalue solver on a photonic quantum processor, Nat. Commun. 5, 4213 (2014).
Seeley, Richard & Love, The Bravyi–Kitaev transformation, J. Chem. Phys. 137, 224109 (2012).
Cao et al., Quantum Chemistry in the Age of Quantum Computing, Chem. Rev. 119, 10856–10915 (2019).
Born & Oppenheimer, Quantum Theory of the Molecules, Ann. Phys. 84, 457 (1927).
Seeger & Pople, Self-consistent molecular orbital methods XVIII, J. Chem. Phys. 66, 3045 (1977).
Fermann & Valeev, Fundamentals of Molecular Integrals Evaluation, arXiv:2007.12057.
Bao et al., Automatic Selection of an Active Space, J. Chem. Theory Comput. 14, 2017 (2018).
PennyLane Tutorial: VQE Demo —

Hamza Benkadour
PhD Student in Quantum Computing - Algeria
LinkedIn

OpenVQA Hub Community

Wed, 02 Apr 2025 00:00:00 +0000

Mastering Quantum Chemistry with OpenVQE - A Community-Driven Guide to Quantum Computing

Wed, 26 Feb 2025 00:00:00 +0000

Release second version of OpenVQE package

Sat, 08 Feb 2025 00:00:00 +0000

Announcing the Release of OpenVQE v2.0!

We are excited to announce the release of the second version of OpenVQE, a major update that brings significant improvements and new features to our quantum variational eigensolver package.

What’s New in OpenVQE OpenVQE v2.0?

Following the success of the first version, OpenVQE v2.0 introduces:

✅ Enhanced Quantum Algorithms – Optimized for better performance in quantum computing simulations.
✅ Expanded Quantum Chemistry Support – New integrations for advanced shortcut amongst the folders
✅ Better Usability & Documentation – Making it easier for researchers and developers to use OpenVQE effectively.

Our Partners & Contributors

We are proud to collaborate with Atos, Sciences Sorbonne Université, TotalEnergies in the first version of OpenVQE. And in this second version with more than 35 contributors around the world that make the second version become more advanced and better

Get Involved!

We invite the community to explore OpenVQE v2.0 and contribute to its ongoing development. Check out the latest version on and try out the new features.

🚀 Let’s push the boundaries of quantum computing together!

Quantum and the Future of Computing Summit

Tue, 14 Jan 2025 00:00:00 +0000

Quantum Computing for Quantum Chemistry A Review of UCC Methods and Adapt-VQE Algorithms

Sat, 14 Dec 2024 00:00:00 +0000

Vietnam School of Artificial Intelligence and Quantum Computing

Sat, 17 Aug 2024 00:00:00 +0000

SUMMER SCHOOL - QUANTUM, FROM THE LAB TO NEW TECHNOLOGIES

Thu, 30 May 2024 00:00:00 +0000

Opensource VQE extension of QLM

Sun, 05 May 2024 00:00:00 +0000

Quantum Innovation Summit

Sat, 17 Feb 2024 00:00:00 +0000

The Journal of Physical Chemistry A, 2023, Vol 127/Issue 15, 3543–3550

Fri, 19 Jan 2024 00:00:00 +0000

The reasearch paper “Extension of the Trotterized Unitary Coupled Cluster to Triple Excitations” is now available on The Journal of Physical Chemistry! This release grants some following highlights include:

Highlights include:

The research paper addresses the need to extend the Trotterized Unitary Coupled Cluster Single and Double (UCCSD) ansatz to include true Triple T excitations in order to recover missing correlation effects for molecular simulations on quantum computers
The limitations of UCCSD for larger molecules are discussed, and the addition of (true) Triple T excitations to the UCCSD approach is proposed to improve accuracy.
The paper introduces the Trotterized UCCSDT approach and analyzes the behavior of triple excitations on a set of molecules compared to the initial UCCSD.
The computational methodology used for the theoretical experiments and the results obtained from testing several molecules using UCCSDT-VQE and sym-UCCSDT-VQE methods are presented.
. The significance of incorporating symmetries, such as spin and point group symmetries, to reduce the number of circuit excitations in the UCCSDT ansatz and accelerate the optimization process for tackling larger molecules is emphasized.
The paper provides insights into the UCCSD and Trotterized UCCSD ansatz, acknowledging their successes and limitations in representing wavefunctions for molecular simulations.
The significance of incorporating symmetries, such as spin and point group symmetries, to reduce the number of circuit excitations in the UCCSDT ansatz and accelerate the optimization process for tackling larger molecules is emphasized. Thank you to everyone who contributed to this release!
Extensive numerical tests on molecules such as LiH, BeH2, and H2O using the UCCSDT-VQE and sym-UCCSDT-VQE methods are presented, demonstrating the superiority of the sym-UCCSDT approach in terms of accuracy, particularly in recovering correlation energy missed by the sym-UCCSD ansatz.
The paper highlights the need for further analysis to understand the limitations of the sym-UCCSDT approach at larger bond lengths and suggests potential improvements by adding higher-order excitations, stressing the potential of the Trotterized UCCSDT approach to achieve competitive results with the gold-standard CCSD(T) classical methods

Theoretical Framework and Quantum Computing

The paper describes the theoretical formalism of the Unitary Coupled Cluster (UCC) method for electronic structure calculations, including detailed formalism of triple excitations in its simplified form after applying both spin and orbital symmetries. It highlights the challenges and opportunities associated with the use of quantum computers for solving problems in quantum chemistry, especially in simulating the full configuration interaction wavefunction of many-electron molecular systems. The Variational Quantum Eigensolver (VQE) is discussed as a promising algorithm for practical implementation on Noisy Intermediate Scaled Quantum (NISQ) devices. The paper also provides insights into the UCCSD and Trotterized UCCSD ansatz, acknowledging their successes and limitations in representing wavefunctions for molecular simulations.

Incorporating Symmetries for Computational Efficiency

The authors emphasize the significance of incorporating symmetries, such as spin and point group symmetries, to reduce the number of circuit excitations in the UCCSDT ansatz and accelerate the optimization process for tackling larger molecules. They discuss the reduction in the number of optimization parameters due to the incorporation of symmetry constraints and the use of the Trotterization approach for breaking up the exponential of a sum into a product of individual exponentials

Numerical Tests and Comparative Analysis

The research paper extensively presents the authors’ numerical tests on molecules such as LiH, BeH2, and H2O using the UCCSDT-VQE and sym-UCCSDT-VQE methods. It discusses the reductions in the number of optimization parameters for different molecules and the results obtained, showing that the sym-UCCSDT method improves the overall accuracy by at least two orders of magnitudes with respect to standard UCCSD. The authors compare the performance of the sym-UCCSDT method with classical methods such as CCSD, CCSD(T), and CCSDT-full and demonstrate the superiority of the sym-UCCSDT approach in terms of accuracy, particularly in recovering correlation energy missed by the sym-UCCSD ansatz

Limitations and Future Directions

Furthermore, the paper highlights the need for further analysis to understand the limitations of the sym-UCCSDT approach at larger bond lengths and suggests potential improvements by adding higher-order excitations. It also discusses the implications of the correlation effects on the accuracy of the sym-UCCSDT method and provides a thorough analysis of the errors and energy differences with reference to the FCI energies. The authors stress the potential of the Trotterized UCCSDT approach to achieve competitive results with the gold-standard CCSD(T) classical methods, delineating its significance for the quantum chemistry community

WIREs Computational Molecular ScienceVolume 13, Issue 5 e1664

Wed, 15 Mar 2023 00:00:00 +0000

The reasearch paper “Open source variational quantum eigensolver extension of the quantum learning machine for quantum chemistry” is now available on Wiley Journal! This release grants some following highlights include:

The paper introduces the OpenVQE open-source package, which extends the Atos Quantum Learning Machine (QLM) to provide advanced tools for using and developing variational quantum eigensolver (VQE) algorithms for quantum chemistry applications.
Present quantum processing units (QPUs) have limited qubit counts and circuit depths due to large errors, and VQE algorithms can potentially overcome such issues.
The OpenVQE package is designed to work synergistically with the myQLM-fermion open-source module, which provides key QLM resources important for quantum chemistry developments.
OpenVQE focuses on giving access to modules enabling the use of the unitary coupled cluster (UCC) family of methods and adaptive ansatz algorithms like ADAPT-VQE.
The UCC family modules in OpenVQE include various features such as different types of UCC generators, including UCCSD, k-UpCCGSD, and QUCCSD.
The adaptive VQE algorithms include fermionic-ADAPT-VQE and qubit-ADAPT-VQE, with different operator pools.
The paper presents extensive benchmarks using the OpenVQE/myQLM-fermion package on a range of molecules from 4 to 24 qubits, demonstrating the use of active space selection, MP2 pre-screening initial guesses, and comparing the fermionic and qubit-ADAPT-VQE results.
The paper compares the “fixed-length” UCC methods to the ADAPT-VQE approach, showing that ADAPT-VQE can achieve higher accuracy with fewer parameters and gates, depending on the chosen convergence threshold.
The paper emphasizes the open-source nature of the OpenVQE/myQLM-fermion packages, facilitating their use and contribution by the broader community, and provides perspectives for developing new types of UCC ansätze and/or new variational algorithms within OpenVQE.

Introduction to OpenVQE package

This paper introduces the OpenVQE open-source package, which extends the Atos Quantum Learning Machine (QLM) to provide advanced tools for using and developing variational quantum eigensolver (VQE) algorithms for quantum chemistry applications. The paper highlights that present quantum processing units (QPUs) have limited qubit counts and circuit depths due to large errors, and that VQE algorithms can potentially overcome such issues.

Design of the OpenVQE package

The UCC family modules in OpenVQE include various features such as different types of UCC generators (truncated to single and double excitations), including unitary coupled cluster singles and doubles (UCCSD), unitary pair CC with generalized singles and doubles product (k-UpCCGSD), and qubit unitary coupled cluster singles and doubles (QUCCSD). The adaptive VQE algorithms include fermionic-ADAPT-VQE and qubit-ADAPT-VQE, with different operator pools.

Benchmarking using OpenVQE/myQLM-fermion package

The paper presents extensive benchmarks using the OpenVQE/myQLM-fermion package on a range of molecules from 4 to 24 qubits. It first shows the properties of the QLM simulator, including the timings for applying the UCCSD ansatz and measuring the Hamiltonian expectation value. It then demonstrates the use of active space selection and MP2 pre-screening initial guesses for different test molecules. Using the ADAPT-VQE module, it compares the fermionic and qubit-ADAPT-VQE results in terms of chemical accuracy, number of variational parameters, operators, and quantum gates. Finally, it compares the “fixed-length” UCC methods to the ADAPT-VQE approach, showing that ADAPT-VQE can achieve higher accuracy with fewer parameters and gates, depending on the chosen convergence threshold.

Circuit-based quantum programming

Mon, 01 Jan 0001 00:00:00 +0000

This is the training session for the preliminary understanding about QLM language

Usage

Creating a bell pair

Let’s us create a Bell pair

 1from qat.lang import Program, H, CNOT, X, S
 2
 3# Create a Program
 4qprog = Program()
 5nbqbits = 2
 6qbits = qprog.qalloc(nbqbits)
 7
 8H(qbits[0])
 9CNOT(qbits[0], qbits[1])
10
11# Export this program into a quantum circuit
12circuit = qprog.to_circ()
13circuit.display()
14
15# Import a Quantum Processor Unit Factory (the default one)
16from qlmaas.qpus import get_default_qpu
17# from qlmaas.qpus import get_default_qpu to run on the QAPTIVA appliance
18qpu = get_default_qpu()
19
20# Create a job
21job = circuit.to_job(nbshots=100)
22result = qpu.submit(job)
23
24# Iterate over the final state vector to get all final components
25for sample in result:
26 print("State %s amplitude %s, %s (%s)" % (sample.state, sample.amplitude, sample.probability, sample.err))

Result

1State |00> amplitude None, 0.48 (0.05021167315686783)
2State |11> amplitude None, 0.52 (0.05021167315686783)

More advanced features:

nbshots in job
Measure only certain qubits
Difference between sample.amplitude and sample.probability
Difference between final measure and intermediate measure

Intermediate measurements

 1qprog = Program()
 2nbqbits = 2
 3qbits = qprog.qalloc(nbqbits)
 4H(qbits[0])
 5qprog.measure(qbits[0])
 6CNOT(qbits)
 7circuit = qprog.to_circ()
 8circuit.display()
 9
10
11qpu = get_default_qpu()
12job = circuit.to_job(nbshots=5, aggregate_data=False)
13result = qpu.submit(job)
14
15for sample in result:
16 print(sample.state, sample.intermediate_measurements)

Result

1|11> [IntermediateMeasurement(cbits=[True], gate_pos=1, probability=0.4999999999999999)]
2|00> [IntermediateMeasurement(cbits=[False], gate_pos=1, probability=0.4999999999999999)]
3|00> [IntermediateMeasurement(cbits=[False], gate_pos=1, probability=0.4999999999999999)]
4|11> [IntermediateMeasurement(cbits=[True], gate_pos=1, probability=0.4999999999999999)]
5|11> [IntermediateMeasurement(cbits=[True], gate_pos=1, probability=0.4999999999999999)]

Useful tools for gates

You can check all the gates avalable in the myQLM demo: . You can also create personal gates

Quantum routines

 1from qat.lang.AQASM import Program, QRoutine, H, CNOT
 2
 3routine = QRoutine()
 4routine.apply(H, 0)
 5routine.apply(CNOT, 0, 1)
 6
 7prog = Program()
 8qbits = prog.qalloc(4)
 9for _ in range(3):
10 for bl in range(2):
11 prog.apply(routine, qbits[2*bl:2*bl+2])
12prog.apply(routine, qbits[0], qbits[2])
13circ = prog.to_circ()
14circ.display()

1circ = prog.to_circ(box_routines=True)
2circ.display()

Using typed registers

 1## quantum adder
 2from qat.lang.AQASM.classarith import add
 3prog = Program()
 4reg_a = prog.qalloc(2, QInt)
 5reg_b = prog.qalloc(2, QInt)
 6
 7X(reg_a[0])
 8X(reg_b[1])
 9
10# |a> = |10> ("2") and |b>=|01> ("1") 
11# expect |a+b>|b> = |11>|01>
12prog.apply(add(2, 2), reg_a, reg_b)
13circ = prog.to_circ(inline=False)
14circ.display()
15
16
17qpu = get_default_qpu()
18result = qpu.submit(circ.to_job())
19for sample in result:
20 print(sample.state, sample.amplitude)

Variational computations

framework: Variational Quantum Eigensolver (VQE) is to find eigenvalues of a Hamiltonian

Our task: VQE on the following Ising model:

$$ H = \sum_{i=1}^{N} a_i X_i + \sum_{i=1}^{N} \sum_{j=1}^{i-1} J_{ij} Z_i Z_j $$

… with a “hardware-efficient” ansatz.

 1import numpy as np
 2from qat.core import Observable, Term
 3
 4def ising(N):
 5 np.random.seed(123)
 6
 7 terms = []
 8
 9 # Generate random coefficients for the transverse field term (X)
10 a_coefficients = np.random.random(N)
11 for i in range(N):
12 term = Term(coefficient=a_coefficients[i], pauli_op="X", qbits=[i])
13 terms.append(term)
14
15 # Generate random coefficients for the interaction term (ZZ)
16 J_coefficients = np.random.random((N, N))
17 for i in range(N):
18 for j in range(i):
19 if i != j: # avoid duplicate terms
20 term = Term(coefficient=J_coefficients[i, j], pauli_op="ZZ", qbits=[i, j])
21 terms.append(term)
22 ising = Observable(N, pauli_terms=terms, constant_coeff=0.0)
23 return ising

If we have the number of qubit = 4

1nqbits = 4
2model = ising(nqbits)
3print(model)

Result

 10.6964691855978616 * (X|[0]) +
 20.28613933495037946 * (X|[1]) +
 30.2268514535642031 * (X|[2]) +
 40.5513147690828912 * (X|[3]) +
 50.48093190148436094 * (ZZ|[1, 0]) +
 60.4385722446796244 * (ZZ|[2, 0]) +
 70.05967789660956835 * (ZZ|[2, 1]) +
 80.18249173045349998 * (ZZ|[3, 0]) +
 90.17545175614749253 * (ZZ|[3, 1]) +
100.5315513738418384 * (ZZ|[3, 2])

Applying for Hardware-Efficient Anazt

 1from qat.lang.AQASM import Program, QRoutine, RY, CNOT, RX, Z, H, RZ
 2from qat.core import Observable, Term, Circuit
 3from qat.lang.AQASM.gates import Gate
 4import matplotlib as mpl
 5import numpy as np
 6from typing import Optional, List
 7import warnings
 8
 9def HEA_Linear(
10 nqbits: int,
11 #theta: List[float],
12 n_cycles: int = 1,
13 rotation_gates: List[Gate] = None,
14 entangling_gate: Gate = CNOT,
15) -> Circuit: #linear entanglement
16 """
17 This Hardware Efficient Ansatz has the reference from "Nonia Vaquero Sabater et al. Simulating molecules
18 with variational quantum eigensolvers. 2022" -Figure 6 -Link
19 "https://uvadoc.uva.es/bitstream/handle/10324/57885/TFM-G1748.pdf?sequence=1"
20
21 Args:
22 nqbits (int): Number of qubits of the circuit.
23 n_cycles (int): Number of layers.
24 rotation_gates (List[Gate]): Parametrized rotation gates to include around the entangling gate. Defaults to :math:`RY`. Must
25 be of arity 1.
26 entangling_gate (Gate): The 2-qubit entangler. Must be of arity 2. Defaults to :math:`CNOT`.
27 """
28
29 if rotation_gates is None:
30 rotation_gates = [RZ]
31
32 n_rotations = len(rotation_gates)
33
34 prog = Program()
35 reg = prog.qalloc(nqbits)
36 theta = [prog.new_var(float, rf"\theta_{{{i}}}") for i in range(n_rotations * (nqbits + 2 * (nqbits - 1) * n_cycles))]
37
38 ind_theta = 0
39
40 for i in range(nqbits):
41
42 for rot in rotation_gates:
43
44 prog.apply(rot(theta[ind_theta]), reg[i])
45 ind_theta += 1
46
47 for k in range(n_cycles):
48
49 for i in range(nqbits - 1):
50 prog.apply(CNOT, reg[i], reg[i+1])
51
52 for i in range(nqbits):
53 for rot in rotation_gates:
54
55 prog.apply(rot(theta[ind_theta]), reg[i])
56 ind_theta += 1
57
58 return prog.to_circ()

Display

1n_layers = 4
2circ_Linear = HEA_Linear(nqbits, n_layers, [RX,RZ], CNOT)
3circ_Linear.display()

Variational Quantum Eigensolver

 1from qat.plugins import ScipyMinimizePlugin
 2qpu = get_default_qpu()
 3optimizer_scipy = ScipyMinimizePlugin(method="BFGS", # Methods
 4 tol=1e-6,
 5 options={"maxiter": 200},
 6 x0=np.random.rand(n_layers*nqbits))
 7stack1 = optimizer_scipy | qpu
 8
 9import numpy as np
10import matplotlib.pyplot as plt
11
12# construct a (variational) job with the variational circuit and the observable
13job = circ_Linear.to_job(observable=model)
14# we submit the job and print the optimized variational energy (the exact GS energy is -3)
15result1 = stack1.submit(job)
16print(f"Minimum VQE energy ={result1.value}")
17plt.plot(eval(result1.meta_data['optimization_trace']))
18plt.xlabel("VQE iterations")
19plt.ylabel("energy")
20plt.grid()
21plt.savefig("newfigure.pdf")

VQE - Unitary Coupled Cluster

This part is adapted from myQLM documentation demo

The Variational Quantum Eigensolver method solves the following minimization problem: $$ E = \min_{\vec{\theta}}\; \langle \psi(\vec{\theta}) \,|\, \hat{H} \,|\, \psi(\vec{\theta}) \rangle $$

Here, we use a Unitary Coupled Cluster trial state, of the form: $$ |\psi(\vec{\theta})\rangle = e^{\hat{T}(\vec{\theta}) - \hat{T}^\dagger(\vec{\theta})} |0\rangle $$

where $\hat{T}(\theta)$ is the cluster operator: $$ \hat{T}(\vec{\theta}) = \hat{T}_1(\vec{\theta}) + \hat{T}_2(\vec{\theta}) + \cdots $$

where $$ \hat{T}_1 = \sum_{a\in U}\sum_{i \in O} \theta_a^i\, \hat{a}_a^\dagger \hat{a}_i \qquad \hat{T}_2 = \sum_{a>b\in U}\sum_{i>j\in O} \theta_{a, b}^{i, j}\, \hat{a}^\dagger_a \hat{a}^\dagger_b \hat{a}_i \hat{a}_j \qquad \cdots $$

$O$ is the set of occupied orbitals and $U$, the set of unoccupied ones.

 1from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation
 2
 3geometry = [("H", (0.0, 0.0, 0.0)), ("H", (0.0, 0.0, 0.7414))]
 4basis = "sto-3g"
 5spin = 0
 6charge = 0
 7
 8(
 9 rdm1,
10 orbital_energies,
11 nuclear_repulsion,
12 n_electrons,
13 one_body_integrals,
14 two_body_integrals,
15 info,
16) = perform_pyscf_computation(geometry=geometry, basis=basis, spin=spin, charge=charge, run_fci=True)
17
18print(
19 f" HF energy : {info['HF']}\n",
20 f"MP2 energy : {info['MP2']}\n",
21 f"FCI energy : {info['FCI']}\n",
22)
23print(f"Number of qubits before active space selection = {rdm1.shape[0] * 2}")
24
25nqbits = rdm1.shape[0] * 2
26print("Number of qubits = ", nqbits)

If we make the plot amongst the HF, MP2 with FCI is the reference we obtain

In these such cases, methods like Hartree-Fock (HF) and Møller-Plesset perturbation theory (MP2) become less accurate compared to Full Configuration Interaction (FCI).However in this case for Hydrogen this difference is barely visible, because the HF energy is totally on the same path as FCI from the beginning till the minimum energy point then the curve begins to experience the bond dissociation when the two hydrogen molecules move far each other

Following to show the molecular Hamiltonian

1from qat.fermion.chemistry import MolecularHamiltonian, MoleculeInfo
2
3# Define the molecular hamiltonian
4mol_h = MolecularHamiltonian(one_body_integrals, two_body_integrals, nuclear_repulsion)
5
6print(mol_h)

MolecularHamiltonian(

constant_coeff : 0.7137539936876182
integrals shape
- one_body_integrals : (2, 2)
- two_body_integrals : (2, 2, 2, 2) )

Computation of cluster operators $T$ and good guess $\vec{\theta}_0$

We now construct the cluster operators (cluster_ops) defined in the introduction part as $\hat{T}(\vec{\theta})$, as well as a good starting parameter $\vec{\theta}$ (based on the second order Møller-Plesset perturbation theory).

 1from qat.fermion.chemistry.ucc import guess_init_params, get_hf_ket, get_cluster_ops
 2
 3# Computation of the initial parameters
 4theta_init = guess_init_params(
 5 mol_h.two_body_integrals,
 6 n_electrons,
 7 orbital_energies,
 8)
 9
10print(f"List of initial parameters : {theta_init}")
11
12# Define the initial Hartree-Fock state
13ket_hf_init = get_hf_ket(n_electrons, nqbits=nqbits)
14
15# Compute the cluster operators
16cluster_ops = get_cluster_ops(n_electrons, nqbits=nqbits)
17
18
19from qat.fermion.transforms import transform_to_jw_basis # , transform_to_bk_basis, transform_to_parity_basis
20from qat.fermion.transforms import recode_integer, get_jw_code # , get_bk_code, get_parity_code
21
22# Compute the ElectronicStructureHamiltonian
23H = mol_h.get_electronic_hamiltonian()
24
25# Transform the ElectronicStructureHamiltonian into a spin Hamiltonian
26H_sp = transform_to_jw_basis(H)
27
28# Express the cluster operator in spin terms
29cluster_ops_sp = [transform_to_jw_basis(t_o) for t_o in cluster_ops]
30
31# Encoding the initial state to new encoding
32hf_init_sp = recode_integer(ket_hf_init, get_jw_code(H_sp.nbqbits))
33
34print(H_sp)

 1(-0.09886396933545824+0j) * I^4 +
 2(0.16862219158920938+0j) * (ZZ|[0, 1]) +
 3(0.12054482205301799+0j) * (ZZ|[0, 2]) +
 4(0.165867024105892+0j) * (ZZ|[1, 2]) +
 5(0.165867024105892+0j) * (ZZ|[0, 3]) +
 6(0.17119774903432972+0j) * (Z|[0]) +
 7(0.12054482205301799+0j) * (ZZ|[1, 3]) +
 8(0.17119774903432972+0j) * (Z|[1]) +
 9(0.04532220205287398+0j) * (XYYX|[0, 1, 2, 3]) +
10(-0.04532220205287398+0j) * (XXYY|[0, 1, 2, 3]) +
11(-0.04532220205287398+0j) * (YYXX|[0, 1, 2, 3]) +
12(0.04532220205287398+0j) * (YXXY|[0, 1, 2, 3]) +
13(0.17434844185575668+0j) * (ZZ|[2, 3]) +
14(-0.22278593040418448+0j) * (Z|[2]) +
15(-0.22278593040418448+0j) * (Z|[3])

Applying the trotterization method

 1from qat.lang.AQASM import Program, X
 2from qat.fermion.trotterisation import make_trotterisation_routine
 3prog = construct_ucc_ansatz(cluster_ops_sp, hf_init_sp, n_steps=1)
 4
 5prog = Program()
 6reg = prog.qalloc(H_sp.nbqbits)
 7
 8# Initialize the Hartree-Fock state into the Program
 9for j, char in enumerate(format(hf_init_sp, "0" + str(H_sp.nbqbits) + "b")):
10 if char == "1":
11 prog.apply(X, reg[j])
12
13# Define the parameters to optimize
14theta_list = [prog.new_var(float, "\\theta_{%s}" % i) for i in range(len(cluster_ops))]
15
16# Define the parameterized Hamiltonian
17cluster_op = sum([theta * T for theta, T in zip(theta_list, cluster_ops_sp)])
18
19# Trotterize the Hamiltonian (with 1 trotter step)
20qrout = make_trotterisation_routine(cluster_op, n_trotter_steps=1, final_time=1)
21
22prog.apply(qrout, reg)
23circ = prog.to_circ()
24
25prog = construct_ucc_ansatz(cluster_ops_sp, hf_init_sp, n_steps=1)
26circ = prog.to_circ()
27circ.display()

For the molecule $H_2$, it has double qubit excitation and by using the UCC method to simulate on this molecule, I obtain the the circuit construction as bellow with the interprobility with Qiskit and this construction is based on the staire-case algorithms

Using the Gradient Based Optimizer to solve the VQE

The graphic is show:

 1job = circ.to_job(observable=H_sp, nbshots=0)
 2
 3from qat.qpus import get_default_qpu
 4from qat.plugins import ScipyMinimizePlugin
 5
 6optimizer_scipy = ScipyMinimizePlugin(method="BFGS", tol=1e-3, options={"maxiter": 1000}, x0=theta_init)
 7qpu = optimizer_scipy | get_default_qpu()
 8result = qpu.submit(job)
 9
10print("Minimum energy =", result.value)

Minimum energy = -1.1372692847285149 \

Make the plot

 1%matplotlib inline
 2import matplotlib.pyplot as plt
 3
 4plt.plot(eval(result.meta_data["optimization_trace"]), lw=3)
 5plt.plot(
 6 [info["FCI"] for _ in enumerate(eval(result.meta_data["optimization_trace"]))],
 7 "--k",
 8 label="FCI",
 9)
10
11plt.xlabel("Steps")
12plt.ylabel("Energy")
13plt.grid()

Reference

Made by Eviden "myQLM – Quantum Python Package"

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

MyQLM-Fermion

Mon, 01 Jan 0001 00:00:00 +0000

A submodule of myQLM-fermion is specifically devoted to quantum chemistry. It provides tools for selecting active spaces (based on natural-orbital occupation numbers), generating cluster operators (and thus, via the aforementioned Trotterization tools, UCC-type ansätze), and initial guesses for their variational parameters. The architecture of QLM and myQLM-fermion allows for experts in a given field to construct their own advanced modules with the QLM building blocks.
The key building block of quantum chemistry computations is the Hamiltonian. On QLM, it is described by an object ElectronicStructureHamiltonian

1 from qat . fermion import ElectronicStructureHamiltonian
2 hamiltonian = ElectronicStructureHamiltonian (h , g)

where h and g are the tensors ℎ_pq and ℎ_pqrs. Such an object also describes cluster operators

1from qat . fermion import get_cluster_ops
2cluster_ops = get_cluster_ops ( n_electrons , nqbits = nqbits )

creates the list containing the sets of single excitations and double excitations wnich can be readily converted to a spin (or qubit) representation using various fermion-spin transforms:

 1
 2 # Jordan - Wigner
 3 from qat . fermion . transforms import transform_to_jw_basis
 4 hamiltonian_jw = transform_to_jw_basis ( hamiltonian )
 5 cluster_ops_jw = [ transform_to_jw_basis ( t_o ) for t_o in cluster_ops ]
 6
 7 # Bravyi - Kitaev
 8 from qat . fermion . transforms import transform_to_bk_basis
 9 hamiltonian_bk = transform_to_bk_basis ( hamiltonian )
10 cluster_ops_bk = [ transform_to_bk_basis ( t_o ) for t_o in cluster_ops ]

With these qubit operators, one can then easily contruct a imple UCCSD ansatz via trotterization of the exponential of the parametric cluster operator defined as cluster_ops_jw

 1from qat . lang . AQASM import Program , X
 2from qat . fermion . trotterisation import make_trotterisation_routine
 3
 4prog = Program ()
 5reg = prog . qalloc ( nqbits )
 6# Create Hartree - Fock state ( assuming JW representation )
 7
 8for qb in range ( n_electrons ) :
 9prog . apply (X , reg [ qb ])
10
11 # Define the full cluster operator with its parameters
12theta_list = [ prog . new_var (float , "\\ theta_ {%s}" % i) for i in range (len ( cluster_ops_jw ) )]
13cluster_op = sum ([ theta * T for theta , T in zip( theta_list , cluster_ops_jw ) ])
14
15# Trotterize the Hamiltonian ( with 1 trotter step )
16qrout = make_trotterisation_routine ( cluster_op , n_trotter_steps =1 , final_time =1)
17prog . apply ( qrout , reg )
18circ = prog . to_circ ()

The circuit we constructed, circ, is a variational circuit that creates a variational wavefunction. Its parameters can be optimized to minimize the variational energy which can be done by a simple VQE loop with the UCC method

A simulation starts by constructing a fermionic Hamiltonian with particularly straightforward initialization as a classical mean-field state; most often as a HF product state $$ \ket{\psi_{HF}} $$ . This is required as the reference preparation for the UCC-chemically-inspired ansatz.
The fermionic Hamiltonian is mapped into a qubit Hamiltonian, represented as a sum of Pauli strings: $$ H = \sum_j \alpha_j \prod_i \sigma_i^j, $$ where $$ \sigma_i^j \in \{ \text{I}, X, Y, Z \} $$ .
A quantum circuit implementing the unitary operator $$ U(\vec{{\bm{\theta}} }) $$ is applied to $$ \ket{\psi_{HF}} $$ , mapping the initial state to a parameterized “Ansatz” state: $$ |\psi(\vec{{\bm{\theta}}}) \rangle = U(\vec{{\bm{\theta}}}) |\psi_{HF} \rangle. $$ Thus, the trial state is prepared on a quantum computer as a quantum circuit consisting of parameterized gates.
One measures the expectation value of the energy: $$ \langle H \rangle = \langle \psi_{HF}(\vec{{\bm{\theta}}}_0) | H | \psi_{HF}(\vec{{\bm{\theta}}}_0) \rangle. $$ At iteration $$ k $$ , the energy of the Hamiltonian is computed by measuring every Hamiltonian term: $$ \langle \psi(\vec{{\bm{\theta}}_k}) | P_j | \psi(\vec{{\bm{\theta}}_k}) \rangle $$ on a quantum computer and adding them on a classical computer.
The energy $$ E(\vec{{\bm{\theta}}_k}) $$ is fed into the classical algorithm that updates parameters for the next step of optimization $$ \vec{{\bm{\theta}}}_{k+1} $$ according to the chosen optimization algorithm.

 1# create a quantum job containing the variational circuit and the Hamiltonian
 2job = circ . to_job ( observable = hamiltonian_jw , nbshots =0)
 3# import a plugin to perform the optimization
 4from qat . plugins import scipyMinimizePlugin
 5optimizer_scipy = scipyMinimizePlugin ( method =" COBYLA ", tol =1e -3 , options ={" maxiter ": 1000} , x0 = theta_init )
 6
 7# import a QPU to execute the quantum circuit
 8from qat . qpus import get_default_qpu
 9
10# define the quantum stack
11stack = optimizer_scipy | get_default_qpu ()
12# submit the job and read the result
13result = stack . submit ( job )
14print (" Minimum energy =", result . value )

Active space selection

In the context of chemical properAmiensties regardless of small/large molecular systems, the lowest orbitals are assumed to be frozen and fully occupied, contributing to the core energy. The highest orbitals, on the other hand, are considered non-active and empty. Mathematically, the Quantum Learning Machine (QLM) \cite{haidar2023open} defines two subspaces: active orbitals ($\mathcal{A}$) and occupied orbitals ($\mathcal{O}$). By calculating the eigenvalues of the molecule’s reduced density matrix, the Natural Orbital Occupation Numbers $n_i$ for each molecular orbital $i$ are obtained. We use the QLM library, which contains a function that enables us to determine the population of the two subspaces, through upper and lower thresholds $\epsilon_1$ and $\epsilon_2$ to select the relevant orbitals. In fact, the choice of $\epsilon_1$ and $\epsilon_2$ is the choice of the active orbitals.

$$ \mathcal{A} = \{i \ | \ n_i \in [\epsilon_2,2-\epsilon_1] \} \cup \{i \ | \ n_i \geq 2 - \epsilon_1, \ 2(i+1) \geq N_{elec} \} $$$$ \mathcal{O} = \{i \ | \ n_i \geq 2 - \epsilon_1, \ 2(i+1) < N_{elec} \}. $$

The QLM function can then evaluate the one-body term and the core energy.

$$ \forall p,q \in \mathcal{A} $$$$ h_{pq} \text{-----} h_{pq} + \sum_{i \in \mathcal{O}} 2h_{ipqi} - h_{ipiq}, $$$$ E_{\rm core} \text{-----} E_{\rm core} + \sum_{i \in \mathcal{O}} h_{ii} + \sum_{i,j \in \mathcal{O}} 2h_{ijji} - h_{ijij}. $$

To apply CAS on UCCSD ansatz, it is required to determine the total number of electrons $n_{e}$ and the subspace of spin orbitals $\mathcal{O}$ in a molecule. Then we can determine the number of active electrons $n_{e_{act}} = n_{e} - 2|\mathcal{O}|$ as well as the number of electrons that are distributed over the active orbitals. Therefore $\mathcal{A}$ is divided into two sub-spaces : $\mathcal{I'}$ which contains the unoccupied active orbitals and $\mathcal{O'}$ containing the occupied active orbitals, and the anti-Hermitian operator is created:

$\forall i,j,p,q \in \mathcal{I'}^{2}\times\mathcal{O'}^{2}$

$$ T^{(\mathrm{CAS})}_{\mathrm{UCCSD}} = \sum_{i\in \mathcal{O^{\prime }} , p\in \mathcal{I^{\prime }}} \theta^{p}_{i} (\hat{a}^{\dagger }_{i} \hat{a}_{p} -\hat{a}^{\dagger }_{p} \hat{a}_{i}) + + \sum_{i,j\in \mathcal{O^{\prime }}, p,q\in \mathcal{I^{\prime }}} \theta^{pq}_{ij} (\hat{a}^{\dagger }_{i} \hat{a}^{\dagger }_{j} \hat{a}_{p} \hat{a}_{q} - \hat{a}^{\dagger }_{p} \hat{a}^{\dagger }_{q} \hat{a}_{i} \hat{a}_{j}) $$

Visualization of spatial orbitals in LiH molecule uisng sto-3g basis-set: 2 HUMOs and 4 LUMOs.

In this method we have the figure of the plot with respect to certain number of qubit with respect to the orbital energy

 1import matplotlib.pyplot as plt
 2
 3# Sample data (you can replace this with your actual data)
 4noons = list(reversed(noons))
 5
 6# Define the threshold couples and their corresponding labels
 7threshold_couples = [
 8 (0.02, 0.004, "4 qubit / second"),
 9 (0.02e-6, 0.002, "6 qubit"),
10 (0.02, 0.001, "10 qubit"),
11 (0.02, 0.001e-1, "12 qubit"),
12]
13
14# Initialize lists to store optimization results
15results = []
16
17# Iterate through different threshold couples
18for threshold_1, threshold_2, label in threshold_couples:
19 mol_h_active, active_indices, occupied_indices = mol_h_new_basis.select_active_space(
20 noons=noons, n_electrons=n_elec, threshold_1=threshold_1, threshold_2=threshold_2
21 )
22
23 # Rest of your code for getting theta_list and performing the optimization...
24
25 # Store the result
26 result = qpu.submit(job)
27 results.append((result, label))
28
29# Create the plot for UCCSD-VQE with multiple threshold couples
30plt.figure(figsize=(10, 6))
31for result, label in results:
32 plt.plot(eval(result.meta_data["optimization_trace"]), label=f"UCCSD-VQE ({label})", lw=3)
33
34plt.plot(
35 [info["FCI"] for _ in range(len(eval(result.meta_data["optimization_trace"])))],
36 "--k",
37 label="FCI",
38)
39plt.legend(loc="best")
40plt.xlabel("Steps")
41plt.ylabel("Energy")
42plt.grid()
43plt.title("UCCSD-VQE Optimization with Different Thresholds")
44plt.show()

If we make the plot with the threshold

 1FCI_energy = info['FCI']
 2
 3markers = ['o', 'x', '^', 's']
 4colors = ['firebrick', 'green', 'black', 'red']
 5
 6plt.figure(figsize=(10, 6))
 7for (result, label), marker, color in zip(results, markers, colors):
 8 optimization_trace = eval(result.meta_data["optimization_trace"])
 9 errors = [abs(energy - FCI_energy) for energy in optimization_trace]
10 steps = list(range(len(errors)))
11 plt.errorbar(steps, errors, fmt=marker, color=color, elinewidth=1, capsize=2, label=f"{label}")
12
13# Plot the chemical accuracy line
14plt.axhline(y=1.593e-3, color='darkblue', linestyle='-', label="Chemical Accuracy")
15
16plt.yscale('log')
17plt.legend(loc="best")
18plt.xlabel("Steps")
19plt.ylabel("Energy Error (Log Scale)")
20plt.grid()
21plt.title("UCCSD-VQE Optimization Error with Different Thresholds")
22plt.show()

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Observables

Mon, 01 Jan 0001 00:00:00 +0000

This is the training session for the preliminary understanding about QLM language for mostly in Quantum Chemistry

Class: Observable

This can be any hermitian or non-Hermitian operators

Stores a list of Pauli chains + their coefficients

$$ H\ =\ \sum_{k}^{} c_{k}P_{k}\ \text{with} \ P_{k}=I,X,Y,Z,XX,XZ,\ XYZ,... $$

Class: Term

This class contains a Pauli chain and its coefficient

 1from qat.core import Term, Observable
 2
 3# Define a term with 4 qubits and a Pauli string
 4term = Term(1.5, # coefficient
 5 "XXYZ", # Pauli chain for 4 qubits
 6 [0, 1, 2, 3]) # qubits on which each Pauli acts
 7
 8# Define an observable acting on 4 qubits with multiple terms
 9obs = Observable(4, # total number of qubits
10 pauli_terms=[Term(2.5, "ZZ", [0, 1]),
11 Term(1.0, "YX", [2, 3]),
12 Term(0.8, "XYZ", [0, 2, 3])])
13
14# Display the term and the observable
15print(term)
16print(obs)

Result with the Hamiltonian

$$H\ =\ 2.5\times Z_{0}Z_{1}+1\times Y_{2}X_{3}+0.8\times X_{0}Y_{2}Z_{3}$$

Term(_coeff=TNumber(is_abstract=False, type=1, int_p=None, double_p=1.5, string_p=None, matrix_p=None, serialized_p=None, complex_p=None), op='XXYZ', qbits=[0, 1, 2, 3], _do_validity_check=True)
2.5 * (ZZ|[0, 1]) +
1.0 * (YX|[2, 3]) +
0.8 * (XYZ|[0, 2, 3])

Transform to matrix representation to see that the Dense matrix is exponential in number of qubits

We can show its matrix representation for the Observable

1print(obs.to_matrix()) # a scipy sparse array
2print(obs.to_matrix(sparse=False)) # a numpy array

Dense matrix is exponential in number of qubits!

Class: Fermionic System

In the context of quantum chemistry, the hamiltonian is expressed in the fermionic second-quantized form witht the ‘$c$’ (small) for annihilation operator ‘$c^{\dag }$’ or creation operator

$$ H=\sum^{}_{p,q} h_{pq}c^{\dag }_{p}c_{q}+\frac{1}{2} \sum^{}_{p,q,r,s} h_{pqrs}c^{\dag }_{p}c^{\dag }_{q}c_{r}c_{s} $$

where $h_{pq}$ and $h_{pqrs}$ are the one and two electron integrals. The one-electron integrals are obtained from the kinetic energy and electron-nuclei interactions while the two-electron integrals are obtained from the electron-electron interactions, defined with the help of some basis functions.

1from qat.fermion import ElectronicStructureHamiltonian
2import numpy as np
3h_pq = np. array([[1., 2.],
4 [2., 0.11]])
5h_pqrs = np.zeros ((2, 2, 2, 2))
6h_pqrs[0, 1, 0, 1] = -8.0
7ham = ElectronicStructureHamiltonian(h_pq, h_pqrs)
8print (ham)

Result with the Hamiltonian

$$H = c_0^\dagger c_0 + 2c_0^\dagger c_1 + 2c_1^\dagger c_0 + 4c_0^\dagger c_0 c_1^\dagger c_1 $$

In the Fock space representation, the operator can be transformed to the qubit space by three main common mapping methods: Jordan-Wigner , Parity and Bravyi-Kitaev found more details in this . . It is currently unknown which encoding method is the most noise-resilient - i.e. best for NISQ experiments. Numerical studies aiming to compare the Jordan-Wigner and Bravyi-Kitaev mappings, has found that the BK transformations was at less as efficient as the JW one, in finding the ground states of molecular systems. Most commonly, we directly use the Jordan Wigner transformation as it is the most straightforward qubit encoding; thus it is a one to one correspondence between Slater determinants and computational basis qubit states:

1ham_spin = ham.to_spin("jordan-wigner")
2print (ham_spin)

(1.5550000000000002+0j) * I^2 +
(1+0j) * (XX|[0, 1]) +
(1+0j) * (YY|[0, 1]) +
(1+0j) * (ZZ|[0, 1]) +
(-1.5+0j) * (Z|[0]) +
(-1.055+0j) * (Z|[1])

Now that we have defined the Hamiltonian in spin representatin, we can already start playing with it. We can give a try for running exact diagonalization. Firstly we can convert our Hamiltonian operator into a sparse matrix

1model_matrix_sp = ham_spin.get_matrix(sparse=True)

Since this is just a regular scipy sparse matrix, we can just use any sparse diagonalization routine in there to find the eigenstates.

1from scipy.sparse.linalg import eigsh
2eigval, eigvec = eigsh(model_matrix_sp, k = 2)
3print("eigenvalues with scipy sparse:", eigval)
4E_gs = eigval[0]

eigenvalues with scipy sparse: [5.11 2.60390825]

Reference

Made by Eviden "myQLM – Quantum Python Package"

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

OpenVQE Overall

Mon, 01 Jan 0001 00:00:00 +0000

A Openvqe extension to create cards. Cards can be shown as links or as plain text.

Usage

Shortcodes Table

Options

Parameter	Description
`molecule_symbol`	molecule examples : H2 , H4 , H6 , LiH , H2O , CO , CO2 , NH3 etc …
`type_of_generator`	user can apply type of generators , such as: uccsd , quccsd , uccgsd , k- upccgsd , etc …
`transform`	user type Jordan wigner (JW), user can also type Bravyi - Kitaev or Parity basis.
`active`	user can use AS (Active Space) method - True or non active space - False

The user specifies these parameters in a class called MoleculeFactory. This class takes those parameters as input

1from openvqe . common_files . molecule_factory import MoleculeFactory
2# returns the properties of a molecule :
3r , geometry , charge , spin , basis = MoleculeFactory . get_parameters ( molecule_symbol = ’H2O ’)

define a function named as generate_hamiltonian that generates the electronic structure Hamiltonian (hamiltonian) and other properties such as the spin hamiltonian (for example hamiltonian_jw), number of electrons (n_els), the list contains the number of natural orbital occupation numbers (noons_full), the list of orbital energies (orb_energies_full) where the orbital energies are doubled due to spin degeneracy and info which is a dictionary that stores energies of some classical methods( such as Hartree-Fock, CCSD and FCI):

1Hamiltonian , hamiltonian_jw , n_els , noons_full , orb_energies_full , info = MoleculeFactory . generate_hamiltonian (
2molecule_symbol =’H2O ’, active = False , transform =’JW ’)

*Briefing about the geometry and energy level of H20 you can visualize the geometry of the molecule on the ORCA application

In addition to that, we define another function named as generate_cluster_ops() that takes as input the name of excitation generator user need (e.g., UCCSD, QUCCSD, UCCGSD, etc.) and internally it calls the file name generator_excitations.py which allows generate_cluster_ops() to return as output the size of pool excitations, fermionic operators, and JW transformed operators denoted in our code respectively as pool_size, cluster_ops and cluster_ops_jw:

 1from . generator_excitations import ( uccsd , quccsd , singlet_gsd , singlet_sd , singlet_upccgsd , spin_complement_gsd ,
 2spin_complement_gsd_twin )
 3pool_size , cluster_ops , cluster_ops_jw = MoleculeFactory . generate_cluster_ops ( molecule_symbol =’H2O ’,
 4type_of_generator =’ spin_complement_gsd ’, transform =’JW ’, active = False )
 5# in our example ’ spin_complement_gsd ’:
 6def generate_cluster_ops () :
 7 pool_size , cluster_ops , cluster_ops_jw = None , None , None
 8 if type_of_generator == ’ spin_complement_gsd ’:
 9 pool_size , cluster_ops , cluster_ops_jw = spin_complement_gsd ( n_el , n_orb ,’JW ’)
10# elif for other excitations (uccsd , quccsd , singlet_upccgsd ...)
11# ::::
12 return pool_size , cluster_ops , cluster_ops_jw

Once these are generated, we import them as input to the UCC-family and ADAPT modules. In the example of fermionic-ADAPT sub-module, we call the function fermionic_adapt_vqe() that takes as parameters the fermionic cluster operators, spin Hamiltonian, maximum number of gradients to be taken per iteration, the type of optimizer, tolerance, threshold of norm () and the maximum number of adaptive iterations:

 1from openvqe . adapt . fermionic_adapt_vqe import fermionic_adapt_vqe
 2# choose maximum number of gradients needed (1 ,2 ,3....)
 3n_max_grads = 1
 4# choose optimizer needed ( COBYLA , BFGS , SLSQP , Nelder - Mead etc ...)
 5optimizer = ’COBYLA ’
 6tolerance = 10**( -6)
 7# according to a given norm value we stop the ADAPT - VQE loop
 8type_conver = ’norm ’
 9threshold_needed = 1e -2
10# the maximum external number of iterations to complete the ADAPT - VQE under a given threshold_needed
11max_iterations = 35
12fci = info [’FCI ’]
13# sparse the Hamiltonian and cluster operators using myQLM - fermion tools obtained from MoleculeFactory , which are
14explicitly :
15hamiltonian_sparse = hamiltonian_jw . get_matrix ( sparse = True )
16cluster_ops_sparse = cluster_ops . get_matrix ( sparse = True )
17# reference_ket and hf_init_sp can be obtained from class MoleculeFactory ():
18reference_ket , hf_init_sp = MoleculeFactory . get_reference_ket ( hf_init , nbqbits , ’JW ’)
19# when all these parameters are satisfied , then fermionic -ADAPT - VQE function is:
20fermionic_adapt_vqe ( cluster_ops , hamiltonian_sparse , cluster_ops_sparse , reference_ket , h_sp , cluster_ops_jw ,
21hf_init_sp , n_max_grads , fci , optimizer , tolerance , type_conver = type_conver , threshold_needed =
22threshold_needed , max_external_iterations = max_iterations )

The function fermionic_adapt_vqe() shows several steps (1) It prepares the trial state using prepare_state(), (2) computes the commutator between the Hamiltonian and the fermionic operator with compute_gradient() (or numerically via hamiltonian_jw | cluster_ops_sp), (3) sorts the gradients in descending order while excluding zeros using sorted_gradient(), and (4) checks if the norm meets a threshold to decide whether to exit or continue. If continuing, it optimizes the maximum gradient operator(s) using ucc_action() before appending them to the trial state. The function returns the number of classical parameters, CNOT gates, other gates, optimized energies, and energy difference from FCI. The qubit-ADAPT sub-module is similar but differs in using qubit pool generators, a distinct trial state preparation, and a different gradient calculation method, while returning the same properties as fermionic_adapt_vqe().

Demo of the fermionic adapt VQE ( Method + Algorithms )

OpenVQE algorithms have targetted the following object

Step 1

Import the librabries from the main folder

1from openvqe.common_files.molecule_factory_with_sparse import MoleculeFactory
2from openvqe.adapt.fermionic_adapt_vqe import fermionic_adapt_vqe
3molecule_factory = MoleculeFactory()

Step 2

In this step we will run the non-active case with 8 qubits

 1## non active case
 2molecule_symbol = 'H2'
 3type_of_generator = 'spin_complement_gsd'
 4transform = 'JW'
 5active = False
 6r, geometry, charge, spin, basis = molecule_factory.get_parameters(molecule_symbol)
 7print(" --------------------------------------------------------------------------")
 8print("Running in the non active case: ")
 9print(" molecule symbol: %s " %(molecule_symbol))
10print(" molecule basis: %s " %(basis))
11print(" type of generator: %s " %(type_of_generator))
12print(" transform: %s " %(transform))
13print(" --------------------------------------------------------------------------")
14
15print(" --------------------------------------------------------------------------")
16print(" ")
17print(" Generate Hamiltonians and Properties from :")
18print(" ")
19print(" --------------------------------------------------------------------------")
20print(" ")
21hamiltonian, hamiltonian_sparse, hamiltonian_sp, hamiltonian_sp_sparse, n_elec, noons_full, orb_energies_full, info = molecule_factory.generate_hamiltonian(molecule_symbol,active=active, transform=transform)
22nbqbits = len(orb_energies_full)
23print(n_elec)
24hf_init = molecule_factory.find_hf_init(hamiltonian, n_elec, noons_full, orb_energies_full)
25reference_ket, hf_init_sp = molecule_factory.get_reference_ket(hf_init, nbqbits, transform)
26print(" --------------------------------------------------------------------------")
27print(" ")
28print(" Generate Cluster OPS from :")
29print(" ")
30print(" --------------------------------------------------------------------------")
31print(" ")
32pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator, transform=transform, active=active)
33# for case of UCCSD from library
34# pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse,theta_MP2, hf_init = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator,transform=transform, active=active)
35
36print('Pool size: ', pool_size)
37print('length of the cluster OP: ', len(cluster_ops))
38print('length of the cluster OPS: ', len(cluster_ops_sp))
39print(hf_init_sp)
40print(reference_ket)
41print(" --------------------------------------------------------------------------")
42print(" ")
43print(" Start adapt-VQE algorithm:")
44print(" ")
45print(" --------------------------------------------------------------------------")
46print(" ")
47
48
49n_max_grads = 1
50optimizer = 'COBYLA'
51tolerance = 10**(-6)
52type_conver = 'norm'
53threshold_needed = 1e-2
54max_external_iterations = 35
55fci = info['FCI']
56fermionic_adapt_vqe(hamiltonian_sparse, cluster_ops_sparse, reference_ket, hamiltonian_sp,
57 cluster_ops_sp, hf_init_sp, n_max_grads, fci,
58 optimizer,
59 tolerance,
60 type_conver = type_conver,
61 threshold_needed = threshold_needed,
62 max_external_iterations = max_external_iterations)

After the fifth iteration we obtain

 1 --------------------------------------------------------------------------
 2 Fermionic_ADAPT-VQE iteration: 5
 3 --------------------------------------------------------------------------
 4 Check gradient list chronological order
 5 Norm of the gradients in current iteration = 0.00009243
 6 Max gradient in current iteration= -0.00006448
 7 Index of the Max gradient in current iteration= 29
 8Convergence is done
 9 -----------Final ansatz-----------
10 *final converged energy iteration is -1.151688545279

 1({'energies': [-1.1327826008725905,
 2 -1.1381935787336812,
 3 -1.1446756115964445,
 4 -1.1516131561999758,
 5 -1.1516885452787875],
 6 'energies_substracted_from_FCI': [0.018905946644018012,
 7 0.01349496878292733,
 8 0.007012935920164054,
 9 7.539131663270027e-05,
10 2.2378210395856968e-09],
11 'norms': [1.1787990251924685,
12 0.8635450036709927,
13 0.6286051658725658,
14 0.5004792404827069,
15 0.044516747244794035],
16 'Max_gradients': [0.5465649202698061,
17 0.4109751817065878,
18 0.32276851883318675,
19 0.3507577344126926,
20 0.02644094985356347],
21 'fidelity': [0.9852300170572142,
22 0.9870545052389407,
23 0.9895621336258196,
24 0.9937025822193148,
25 0.9999286595965128],
26 'CNOTs': [48, 96, 288, 336, 368],
27 'Hadamard': [32, 64, 128, 160, 168],
28 'RY': [0, 4, 4, 4, 4],
29 'RX': [16, 32, 64, 80, 84]},
30 {'indices': [38, 32, 29, 23, 2],
31 'Number_operators': 5,
32 'final_norm': 9.243327155226241e-05,
33 'parameters': [-0.02140083663347611,
34 -0.025081299644836987,
35 -0.046035927664188785,
36 -0.03941898799451784,
37 -0.005705200709434039],
38 'Number_CNOT_gates': 368,
39 'Number_Hadamard_gates': 168,
40 'Number_RX_gates': 84,
41 'final_energy_last_iteration': -1.1516885452787875})

Step 3

In this step we consider the case of active space selection with the H4 molecule

 1## active case
 2from openvqe.common_files.molecule_factory_with_sparse import MoleculeFactory
 3from openvqe.adapt.fermionic_adapt_vqe import fermionic_adapt_vqe
 4
 5# initializing the variables in the case of active 
 6molecule_symbol = 'H4'
 7type_of_generator = 'spin_complement_gsd' #'spin_complement_gsd_twin'
 8transform = 'JW'
 9active = True
10
11
12r, geometry, charge, spin, basis = molecule_factory.get_parameters(molecule_symbol)
13print(" --------------------------------------------------------------------------")
14print("Running in the active case: ")
15print(" molecule symbol: %s " %(molecule_symbol))
16print(" molecule basis: %s " %(basis))
17print(" type of generator: %s " %(type_of_generator))
18print(" transform: %s " %(transform))
19print(" --------------------------------------------------------------------------")
20
21
22print(" --------------------------------------------------------------------------")
23print(" ")
24print(" Generate Hamiltonians and Properties from :")
25print(" ")
26print(" --------------------------------------------------------------------------")
27print(" ")
28hamiltonian_active, hamiltonian_active_sparse, hamiltonian_sp,hamiltonian_sp_sparse,nb_active_els,active_noons,active_orb_energies,info=molecule_factory.generate_hamiltonian(molecule_symbol,active=active,transform=transform)
29print(" --------------------------------------------------------------------------")
30print(" ")
31print(" Generate Cluster OPS from :")
32print(" ")
33print(" --------------------------------------------------------------------------")
34print(" ")
35nbqbits = hamiltonian_sp.nbqbits
36hf_init = molecule_factory.find_hf_init(hamiltonian_active, nb_active_els,active_noons, active_orb_energies)
37reference_ket, hf_init_sp = molecule_factory.get_reference_ket(hf_init, nbqbits, transform)
38pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator, transform=transform, active=active)
39print("Clusters were generated...")
40print('Pool size: ', pool_size)
41print('length of the cluster OP: ', len(cluster_ops))
42print('length of the cluster OPS: ', len(cluster_ops_sp))
43print('length of the cluster OPS_sparse: ', len(cluster_ops_sp))
44
45print(" --------------------------------------------------------------------------")
46print(" ")
47print(" Start adapt-VQE algorithm:")
48print(" ")
49print(" --------------------------------------------------------------------------")
50print(" ")
51
52n_max_grads = 1
53optimizer = 'COBYLA'
54tolerance = 10**(-7)
55type_conver = 'norm'
56threshold_needed = 1e-3
57max_external_iterations = 30
58fci = info['FCI']
59fermionic_adapt_vqe(hamiltonian_active_sparse, cluster_ops_sparse, reference_ket, hamiltonian_sp,
60 cluster_ops_sp, hf_init_sp, n_max_grads, fci,
61 optimizer,
62 tolerance,
63 type_conver = type_conver,
64 threshold_needed = threshold_needed,
65 max_external_iterations = max_external_iterations)

After the third iteration we obtain:

 1--------------------------------------------------------------------------
 2 Fermionic_ADAPT-VQE iteration: 3
 3 --------------------------------------------------------------------------
 4 Check gradient list chronological order
 5 Norm of the gradients in current iteration = 0.00000157
 6 Max gradient in current iteration= 0.00000098
 7 Index of the Max gradient in current iteration= 22
 8Convergence is done
 9 -----------Final ansatz-----------
10 *final converged energy iteration is -2.150071872977

 1({'energies': [-2.1475588531337, -2.149998032049138, -2.150071872976795],
 2 'energies_substracted_from_FCI': [0.0307547797466996,
 3 0.028315600831261722,
 4 0.02824175990360489],
 5 'norms': [0.9780904621524203, 0.44476756978359294, 0.04777693846151295],
 6 'Max_gradients': [0.5600407258694875,
 7 0.3073244780480784,
 8 0.027972834656648148],
 9 'fidelity': [0.9796754217306467, 0.9989670200933669, 0.9999401845822582],
10 'CNOTs': [48, 96, 128],
11 'Hadamard': [32, 64, 72],
12 'RY': [0, 4, 4],
13 'RX': [16, 32, 36]},
14 {'indices': [16, 22, 2],
15 'Number_operators': 3,
16 'final_norm': 1.56924035843115e-06,
17 'parameters': [-0.06970457006634999,
18 -0.015636706722331747,
19 -0.005282460997328426],
20 'Number_CNOT_gates': 128,
21 'Number_Hadamard_gates': 72,
22 'Number_RX_gates': 36,
23 'final_energy_last_iteration': -2.150071872976795})

References

Haidar, Mohammad, et al. "Open source variational quantum eigensolver extension of the quantum learning machine for quantum chemistry." Wiley Interdisciplinary Reviews: Computational Molecular Science 13.5 (2023): e1664.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Adapt-VQE

Mon, 01 Jan 0001 00:00:00 +0000

In 2019, ADAPT-VQE was introduced in this with the purpose of creating a more accurate, compact, and problem-customized ansatz for VQE. This version will hereby be denoted fermionic-ADAPT-VQE to distinguish it against a more recent version that will be covered shortly. The idea behind the proposal is to let the molecule in study ‘choose’ its own state preparation circuit, by creating the ansatz in a strongly system-adapted manner.

The ADAPT-VQE algorithm constructs the molecular system’s wavefunction dynamically and can in principle avoid redundant terms. It is grown iteratively in the form of a disentangled UCC ansatz as given in the below equation:

$$\prod_{k=1}^{\infty} \prod_{pq} \left( e^{\theta_{pq} (k)\hat{A}_{p,q}}\prod_{rs} e^{\theta_{pqrs} (k)\hat{A}_{pq,rs}} \right) |\psi_{\mathrm{HF}} \rangle$$

which is the in the form of a long product of one-body $\hat{A}_{p,q}$ and two-body $\hat{A}_{pq,rs}$ operators generated from the pool of excitations, where each of the variational parameters $\left\{ \theta_{pq} ,\theta_{pqrs} \right\}$

At each step, an operator or a few operators are chosen from a pool: the operator(s) contributing to the largest energy deviations is (are) chosen and added gradually to the ansatz until the exact FCI wavefunction has been reached is associated to an operator.

Algorithm Steps

Initialize Circuit: Start with the identity circuit $U^{(0)}(\theta) = I$, where the state is initialized to the Hartree-Fock state $|\Psi_{HF}\rangle$.
Gradient Measurement: For the current ansatz state $|\Psi^{(k-1)}\rangle$, compute the energy gradient for each operator $A_m$ in the operator pool using the formula:
$$ \frac{\partial E^{(k-1)}}{\partial \theta_m} = \langle \Psi(\theta_{k-1}) | [H, A_m] | \Psi(\theta_{k-1}) \rangle. $$
Check Gradient Norm: Evaluate the norm of the gradient vector $||g^{(k-1)}||$. If it is below the threshold $\epsilon$, the algorithm stops. If not, proceed to the next step.
Select Operator with Maximum Gradient: The operator with the largest gradient is chosen, and its corresponding variational parameter $\theta_k$ is added to the ansatz.
Update Ansatz: Perform a Variational Quantum Eigensolver (VQE) experiment to re-optimize all the parameters $\{\theta_k, \theta_{k-1}, \dots, \theta_1\}$ in the ansatz.
Repeat: Return to step 2 and repeat the process until convergence.

In the following numerical simulation, we used UCCGSD excitation for $H_2$ molecule in 6-31g basis set thus give us 8 qubits; we can run the following script to see the result (The result will not be shown all in here due to its long scrolled lines,you can see it yourself when running the script )

 1from openvqe.common_files.molecule_factory_with_sparse import MoleculeFactory
 2from openvqe.adapt.fermionic_adapt_vqe import fermionic_adapt_vqe
 3molecule_factory = MoleculeFactory()
 4
 5## non active case
 6molecule_symbol = 'H2'
 7type_of_generator = 'spin_complement_gsd'
 8transform = 'JW'
 9active = False
10r, geometry, charge, spin, basis = molecule_factory.get_parameters(molecule_symbol)
11print(" --------------------------------------------------------------------------")
12print("Running in the non active case: ")
13print(" molecule symbol: %s " %(molecule_symbol))
14print(" molecule basis: %s " %(basis))
15print(" type of generator: %s " %(type_of_generator))
16print(" transform: %s " %(transform))
17print(" --------------------------------------------------------------------------")
18
19print(" --------------------------------------------------------------------------")
20print(" ")
21print(" Generate Hamiltonians and Properties from :")
22print(" ")
23print(" --------------------------------------------------------------------------")
24print(" ")
25hamiltonian, hamiltonian_sparse, hamiltonian_sp, hamiltonian_sp_sparse, n_elec, noons_full, orb_energies_full, info = molecule_factory.generate_hamiltonian(molecule_symbol,active=active, transform=transform)
26nbqbits = len(orb_energies_full)
27print(n_elec)
28hf_init = molecule_factory.find_hf_init(hamiltonian, n_elec, noons_full, orb_energies_full)
29reference_ket, hf_init_sp = molecule_factory.get_reference_ket(hf_init, nbqbits, transform)
30print(" --------------------------------------------------------------------------")
31print(" ")
32print(" Generate Cluster OPS from :")
33print(" ")
34print(" --------------------------------------------------------------------------")
35print(" ")
36pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator, transform=transform, active=active)
37# for case of UCCSD from library
38# pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse,theta_MP2, hf_init = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator,transform=transform, active=active)
39
40print('Pool size: ', pool_size)
41print('length of the cluster OP: ', len(cluster_ops))
42print('length of the cluster OPS: ', len(cluster_ops_sp))
43print(hf_init_sp)
44print(reference_ket)
45print(" --------------------------------------------------------------------------")
46print(" ")
47print(" Start adapt-VQE algorithm:")
48print(" ")
49print(" --------------------------------------------------------------------------")
50print(" ")
51
52
53n_max_grads = 1
54optimizer = 'COBYLA'
55tolerance = 10**(-6)
56type_conver = 'norm'
57threshold_needed = 1e-2
58max_external_iterations = 35
59fci = info['FCI']
60fermionic_adapt_vqe(hamiltonian_sparse, cluster_ops_sparse, reference_ket, hamiltonian_sp,
61 cluster_ops_sp, hf_init_sp, n_max_grads, fci,
62 optimizer,
63 tolerance,
64 type_conver = type_conver,
65 threshold_needed = threshold_needed,
66 max_external_iterations = max_external_iterations)

We make an analysed plot for the converged energy and the fidelity. It took 5 fermionic adapt iteration and the converged energy is -1.1516 Ha with the fidelity : 0.999 and 368 number of CNOT gates

Second version of OpenVQE (Updated code)

Parameters

Molecule Symbol: H2
Type of Generator: spin_complement_gsd
Transformation: JW
Active: False

Workflow

Initialization: Initialize the VQE algorithm with the specified parameters.
Execution: Execute the VQE algorithm to find the ground state energy.
Results: Plot the energy results and error results obtained from the VQE execution.

 1from openvqe.vqe import VQE
 2import matplotlib.pyplot as plt
 3import numpy as np
 4
 5
 6molecule_symbol = 'H2'
 7type_of_generator = 'spin_complement_gsd'
 8transform = 'JW'
 9algorithm = 'fermionic_adapt'
10
11opts = {
12 'n_max_grads': 1,
13 'optimizer': 'COBYLA',
14 'tolerance': 10**(-6),
15 'type_conver': 'norm',
16 'threshold_needed': 1e-2,
17 'max_external_iterations': 35
18 }
19
20
21vqe_non_active = VQE.algorithm(algorithm, molecule_symbol, type_of_generator, transform, False, opts)
22vqe_non_active.execute()

Make the plot

 1
 2energies_1, energies_2 = vqe_non_active.iterations['energies'], vqe_active.iterations['energies']
 3# Plot results with custom styles
 4plt.figure(figsize=(14, 8)) # Larger plot size
 5plt.plot(
 6 energies_1,
 7 "-o", # Line style with circle markers
 8 color="orange", # Use custom color
 9 label=f"Non active space"
10)
11plt.plot(
12 energies_2,
13 "-o", # Line style with circle markers
14 color="red", # Use custom color
15 label=f"Active space"
16)
17plt.plot(
18 [vqe_non_active.info['FCI']] * max([len(energies_1), len(energies_2)]),
19 "k--",
20 label="True ground state energy(FCI)"
21)
22plt.xlabel("Optimization step", fontsize=20)
23plt.ylabel("Energy (Ha)", fontsize=20)
24
25plt.xticks(fontsize=16) # Set font size for x-axis tick labels
26plt.yticks(fontsize=16)
27
28# Move the legend box outside the plot
29plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0., fontsize=12)
30plt.grid()
31plt.title(f"VQE {algorithm} energy evolution for {molecule_symbol} molecule", fontsize=20)
32plt.tight_layout() # Adjust layout to prevent clipping
33
34plt.show()

You can go to the git repo for more detail at

References

Harper R. Grimsley, Sophia E. Economou, Edwin Barnes, Nicholas J. Mayhall. "An adaptive variational algorithm for exact molecular simulations on a quantum computer." Nature communications, 10(1), 3007.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Parameter-Shift Rule

Mon, 01 Jan 0001 00:00:00 +0000

Let us describe below how to act the parameter-shift rules on the UCC circuit ansatz. In the present work, we use a UCC ansatz truncated at the single and double excitation levels with a single Trotter step. Off course, one can go further to triple, quadruple and further excitation, however our goal in this section is to show how to link the parameter shift rule on a unitary coupled cluster gates in a circuit, which is the most important key point. Once these approximations are performed, each exponential of a fermionic excitation operator can be directly implemented as a sequence of gates. This in practice, can be done by using the standard CNOT staircase method (described in the previous chapter). The unitary transformation carried out by the circuit can thus be broken down into a product of local unitaries

$$ U\left(x;\bm{\theta}\right)=U_N\left(\bm{\theta}_N\right)U_{N-1}\left(\bm{\theta}_{N-1}\right)\cdots U_i\left(\bm{\theta}_i\right) \cdots U_1\left(\bm{\theta}_1\right)U_0\left(x\right) $$

Each of these gates is unitary, and therefore must have the form

$$ U_j\left(\gamma_j\right)=\exp{\left(i\gamma_jH_j\right)} $$

where $H_j$ is a Hermitian operator which generates the gate and $\gamma_j$ is the gate parameter. When using CNOT staircase method, $U_j\left(\gamma_j\right)$ are typically equivalent to $R_z(\bm{\theta})$ gates. Since for any type of coupled cluster excitations, the circuit, in practice should be composed of multiple parameterized $R_z(\bm{\theta})$ gates, and some other non-parameterized gates such as (CNOT, Hadamard etc.). There should be then a tool how to make the quantum circuit function to compute gradient ($\nabla{\bm{\theta}_i}{f}(x;\bm{\theta}_i$)) for a certain $\bm{\theta}_i$:\ in fact any gates applied before gate $i$ into the initial state, can be expressed as:

$$ \left|\psi_{i-1}\right\rangle=U_{i-1}\left(\bm{\theta}_{i-1}\right)\cdots U_1\left(\bm{\theta}_1\right)U_0\left(x\right)\left|0\right\rangle $$

Similarly, any gates applied after gate $i$ are combined with the observable, which is the Hamiltonian in our case

$$ \hat{H}_{i+1}=U_N^\dag(\bm{\theta}_N)\cdot U^\dag_{i+1}(\bm{\theta}_{i+1})\hat{H}U_{i+1}(\bm{\theta}_{i+1})\cdots U_N(\bm{\theta}_N) $$

With this simplification, the quantum circuit function becomes

$$ f(x;\bm{\theta})=\left\langle\psi_{i-1}\left|U_i^\dag(\bm{\theta}_i)\hat{H}_{i+1}U_i(\bm{\theta}_i)\right|\psi_{i-1}\right\rangle $$

now suppose

$$\mathcal{M}_{\bm{\theta}_i}(\hat{H}_{i+1}) = U_i^\dag(\bm{\theta}_i)\hat{H}_{i+1}U_i(\bm{\theta}_i) $$

then its gradient takes the form

$$ \nabla_{\bm{\theta}_i}f\left(x;\bm{\theta}\right)=\left\langle\psi_{i-1}\left|\nabla_{\bm{\theta}_i}\mathcal{M}_{\bm{\theta}_i}\left(\hat{H}_{i+1}\right)\right|\psi_{i-1}\right\rangle $$

as is seen in the expression above, in terms of the circuit, one can leave all other gates as they are, and only gate
$U_i\left(\bm{\theta}_i\right)$ should be changed when question comes to differentiate it with respect to the parameter
$\bm{\theta}_i$. Let us now apply the equations above into $R_z$ gate. Consider a quantum computer with parameterized gates of the form

$$ R_i\left(\bm{\theta}_i\right)=\exp{\left(-i\frac{\bm{\theta}_i}{2}\widehat{Z_i}\right)} $$

where $\widehat{Z_i}={\widehat{Z}_i}^ \dag$ is a Pauli operator. The gradient of $R_z$ is

$$ \nabla_{\bm{\theta}_i}R_i\left(\bm{\theta}_i\right)=-\frac{i}{2}\widehat{Z_i}R_i\left(\bm{\theta}_i\right)=-\frac{i}{2}R_i\left(\bm{\theta}_i\right)\widehat{Z_i} $$

By substituting this expression into the quantum circuit function $f(x;\bm{\theta})$, we get

$$ \nabla_{\bm{\theta}_i} f\left(x;\bm{\theta}\right) = \frac{i}{2} \left\langle \psi_{i-1} \left| R_i\left(\bm{\theta}_i\right)^\dag \left( Z_i \widehat{H}_{i+1} - \widehat{H}_{i+1} Z_i \right) R_i\left(\bm{\theta}_i\right) \right| \psi_{i-1} \right\rangle $$

$$= \frac{i}{2} \left\langle \psi_{i-1} \left| R_i\left(\bm{\theta}_i\right)^\dag \left[ Z_i, \widehat{H}_{i+1} \right] R_i\left(\bm{\theta}_i\right) \right| \psi_{i-1} \right\rangle$$

where $\left[X,Y\right]=XY-YX$ is the commutator. \ \ We now make use of the following mathematical identity for commutators involving Pauli operators

$$ \left[\widehat{Z_i},\hat{H}\right] = -i\left(R_i^\dag\left(\frac{\pi}{2}\right)\hat{H}R_i\left(\frac{\pi}{2}\right) - R_i^\dag\left(-\frac{\pi}{2}\right)\hat{H}R_i\left(-\frac{\pi}{2}\right)\right). $$

Substituting this into the previous equation, we obtain the gradient expression

$$ \nabla_{\bm{\theta}_i} f\left(x;\bm{\theta}\right)= \frac{1}{2}\left\langle\psi_{i-1}\left|R_i^\dag\left(\bm{\theta}_i+\frac{\pi}{2}\right){\widehat{H}}_{i+1}R_i\left(\bm{\theta}_i+\frac{\pi}{2}\right)\right|\psi_{i-1}\right\rangle $$$$ -\frac{1}{2}\left\langle\psi_{i-1}\left|R_i^\dag\left(\bm{\theta}_i-\frac{\pi}{2}\right){\widehat{H}}_{i+1}R_i\left(\bm{\theta}_i-\frac{\pi}{2}\right)\right|\psi_{i-1}\right\rangle $$

Finally, this gradient can be rewritten in terms of quantum functions:

$$ \nabla_{\bm{\theta}_i} f\left(x;\bm{\theta}\right)=\frac{1}{2}\left[f\left(x;\bm{\theta}+\frac{\pi}{2}\right)-f\left(x;\bm{\theta}-\frac{\pi}{2}\right)\right] $$

We recognize from the comparison of equations above, that these unitaries represent instances of the initial gate, and thus shift the gate’s parameter. This leads to the parameter shift rule for circuit gradients. Below is the code for PMRS for LiH in with CAS method reduced to 6 qubits

 1import matplotlib.pyplot as plt
 2import numpy as np
 3import scipy.optimize
 4
 5# Assuming the necessary functions are defined: 
 6# get_optimization_func, get_grad_func, and the variables circ, qpu, H_sp, nqbits, psi0, theta_0, E0
 7
 8# Initialize dictionaries to store results
 9res = {}
10energy_list, fid_list = {}, {}
11
12# Define the optimization methods to use
13methods = ["CG", "BFGS", "COBYLA"]
14
15# Perform optimization for each method
16for method in methods:
17 energy_list[method], fid_list[method] = [], []
18 my_func = get_optimization_func(circ, qpu, H_sp, method, nqbits, psi0, energy_list, fid_list)
19 my_grad = get_grad_func(circ, qpu, H_sp)
20 res[method] = scipy.optimize.minimize(my_func, jac=my_grad, x0=theta_0, method=method, options={"maxiter": 50000, "disp": True})
21
22fig, ax = plt.subplots(figsize=(11, 7))
23steps = np.arange(0, 700)
24
25col = {"CG": "orange", "COBYLA": "firebrick", "BFGS": "darkcyan"}
26
27for method in ["CG", "BFGS", "COBYLA"]:
28 energy_list[method] = np.array(energy_list[method])
29 error = np.maximum(energy_list[method] - E0, 1e-6) # Ensure no values less than 1e-16
30 print(f"The error for the {method} method:", error)
31 ax.plot(error, "-o", color=col[method], label=f" Subtracted energy [{method}]")
32
33 if method == "COBYLA" and error.size > 0:
34 ax.fill_between(steps[:len(error)], 1e-6, 1e-3, color="cadetblue", alpha=0.2, interpolate=True, label="Chemical Accuracy")
35
36
37
38ax.set_xlabel("optimization step")
39ax.set_xlim(0,128)
40
41ax.set_yscale('log')
42ax.legend()
43ax.grid(True, which="both", ls="--")
44plt.savefig("error_H4.pdf")
45 # Grid lines for both major and minor ticks
46
47plt.show()

 1fig, ax = plt.subplots(figsize=(11, 7))
 2steps = np.arange(0, 700)
 3
 4col = {"CG": "orange", "COBYLA": "firebrick", "BFGS": "darkcyan"}
 5
 6for method in ["CG", "BFGS", "COBYLA"]:
 7 energy_list[method] = np.array(energy_list[method])
 8 error = np.maximum(energy_list[method] - E0, 1e-6) # Ensure no values less than 1e-16
 9 print(f"The error for the {method} method:", error)
10 ax.plot(error, "-o", color=col[method], label=f" Subtracted energy [{method}]")
11
12 if method == "COBYLA" and error.size > 0:
13 ax.fill_between(steps[:len(error)], 1e-6, 1e-3, color="cadetblue", alpha=0.2, interpolate=True, label="Chemical Accuracy")
14
15
16
17ax.set_xlabel("optimization step")
18ax.set_xlim(0,128)
19
20ax.set_yscale('log')
21ax.legend()
22ax.grid(True, which="both", ls="--")
23plt.savefig("error_LiH.pdf")
24 # Grid lines for both major and minor ticks
25
26plt.show()

 1fig, ax = plt.subplots(figsize=(11, 7))
 2steps = np.arange(0, 700)
 3
 4col = {"CG": "orange", "COBYLA": "firebrick", "BFGS": "darkcyan"}
 5
 6for method in ["CG", "BFGS", "COBYLA"]:
 7 fid_list[method] = np.array(fid_list[method])
 8
 9 ax.plot(fid_list[method], "-o", color=col[method], label= f"fidelity w.r.t true ground state [{method}]")
10
11
12ax.set_xlabel("optimization step")
13
14ax.legend()
15ax.grid(True, which="both", ls="--")
16plt.savefig("fidelity_H4_.pdf")
17 # Grid lines for both major and minor ticks
18
19plt.show()

The energy according to the chosen optimization algorithm.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Subspace-search variational quantum eigensolver for excited states

Mon, 01 Jan 0001 00:00:00 +0000

In Variational Quantum Eigensolver (VQE), the real parameters $\theta$ for the ansatz states $|\psi \left( \theta \right) \rangle $ are classically optimised with respect to the expectation value of the Hamiltonian in the equation ; it is computed using a lowdepth quantum circuit. As a result of the variational principle, finding the global minimum of $E\left( \theta \right) $ is equivalent to finding the ground state energy of $H$

In this section, our goal is to extend to calculate find excited states from HEA ansatz model, using subspace-search VQE (SSVQE). The SSVQE takes two or more orthogonal states as inputs to a parametrized quantum circuit, and minimizes the expectation value of the energy in the space spanned by those states. In this work, the proposed algorithm can find the $k$-th excited state state that works on an $n$-qubit quantum computer; SSVQE runs as follows:

Algorithm

Construct an ansatz circuit $ U(\bm{\theta}) $ and choose input states $ \left\{ \ket{\varphi_j} \right\}_{j=0}^k $ whic
Minimize
\[ \mathcal{L}_1(\bm{\theta}) = \sum_{j=0}^k \langle \varphi_{j} | U^\dagger(\bm{\theta}) H U(\bm{\theta}) | \varphi_{j} \rangle. \]
We denote the optimal $ \bm{\theta} $ by $ \bm{\theta}^* $.
Construct another parametrized quantum circuit $ V(\bm{\phi}) $ that only acts on the space spanned by $ \left\{ \ket{\varphi_j} \right\}_{j=0}^k $.
Choose an arbitrary index $ s \in \{0, \ldots, k\} $, and maximize

\[ \mathcal{L}_2(\bm{\phi}) = \langle \varphi_{s} | V^\dagger(\bm{\phi}) U^\dagger(\bm{\theta}^*) H U(\bm{\theta}^*) V(\bm{\phi}) | \varphi_{s} \rangle. \]
We note that, in practice, the input states $ \left\{ \ket{\varphi_j} \right\}_{j=0}^k $ will be chosen from a set of states which are easily preparable, such as the computational basis (in our work, we use the binary representation technique for generating the basis). Additionally, in step 2, we can find the subspace which includes $ \ket{E_k} $ as the highest energy state, using a carefully constructed ansatz $U(\boldsymbol{\theta})$. The unitary $ V(\bm{\phi}) $ is responsible for searching in that subspace. By maximizing $ \mathcal{L}_2(\bm{\phi}) $, we find the $ k $-th excited state $ \ket{E_k} $.

A particular instance of the “hardware-efficient ansatz” - the entanglement pattern with 6 CX gates and depth = 1 is shown. The parameters $\boldsymbol{\theta}$ are optimized to to minimize the cost function $\mathcal{L}_{1}$ then the ansatz structure will be updated the parameters, called $\boldsymbol{\phi }$ thus to optimize $\mathcal{L}_{2}$

 1import numpy as np
 2import scipy.optimize
 3import matplotlib.pyplot as plt
 4from numpy import binary_repr
 5from qat.qpus import get_default_qpu
 6
 7qpu = get_default_qpu()
 8method = "BFGS"
 9model = hamiltonian_sp
10vals = 15
11
12eigenvec_input_tar = calculate_eigen_vectors(model, vals)
13eigenvec_input = [eigenvec_input_tar[2],eigenvec_input_tar[8], eigenvec_input_tar[13]]
14
15
16energy_lists = {f"energy_circ_{i}": {method: []} for i in range(len(circuits_store))}
17fidelity_lists = {f"fidelity_circ_{i}": {method: []} for i in range(len(circuits_store))}
18
19def opt_funct(circuits, model, qpu, nqbits, energy_lists, fidelity_lists, weight, eigenvec_input):
20 def input_funct(x):
21 total_energy = 0
22 for i, circ in enumerate(circuits):
23 bound_circ = circ.bind_variables({k: v for k, v in zip(sorted(circ.get_variables()), x)})
24 result = qpu.submit(bound_circ.to_job(observable=model))
25 energy = result.value
26 energy_lists[f"energy_circ_{i}"][method].append(energy)
27
28 # Calculate fidelity
29 fidelity = fun_fidelity(bound_circ, eigenvec_input[i], nqbits)
30 fidelity_lists[f"fidelity_circ_{i}"][method].append(fidelity)
31 #print(fidelity)
32
33 total_energy += weight[i] * energy
34 return total_energy
35
36 def callback(x):
37 for i, circ in enumerate(circuits):
38 bound_circ = circ.bind_variables({k: v for k, v in zip(sorted(circ.get_variables()), x)})
39 result = qpu.submit(bound_circ.to_job(observable=model))
40 energy = result.value
41 energy_lists[f"energy_circ_{i}"][method].append(energy)
42
43 # Calculate fidelity
44 fidelity = fun_fidelity(bound_circ, eigenvec_input[i], nqbits)
45 fidelity_lists[f"fidelity_circ_{i}"][method].append(fidelity)
46
47 return input_funct, callback
48
49
50input_funct, callback = opt_funct(circuits_store, model, qpu, nqbits, energy_lists, fidelity_lists, weight, eigenvec_input)
51options = {"disp": True, "maxiter": 5000, "gtol": 1e-7}
52Optimizer = scipy.optimize.minimize(input_funct, x0=init_theta_list, method=method, callback=callback, options=options)
53
54# Plot energy
55plt.rcParams["font.size"] = 18
56all_energy_lists = []
57
58for i in range(len(circuits_store)):
59 energy_list = energy_lists[f"energy_circ_{i}"][method]
60 all_energy_lists.append(energy_list)
61 plt.plot(range(len(energy_list)), energy_list, label=f"Energy for k={binary_repr(k_lst[i]).zfill(4)}")
62
63 # Print the final energy for each k
64 final_energy = energy_list[-1]
65 print(f"Final energy for k={binary_repr(k_lst[i]).zfill(4)}: {final_energy}")
66
67plt.xlabel("Iterations")
68plt.ylabel("Energy")
69plt.title("Energy Evolution")
70plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0, fontsize=18)
71plt.show()
72
73
74
75
76# Plot fidelity
77plt.figure()
78all_fidelity_lists = []
79
80for i in range(len(circuits_store)):
81 fidelity_list = fidelity_lists[f"fidelity_circ_{i}"][method]
82 all_fidelity_lists.append(fidelity_list)
83 plt.plot(range(len(fidelity_list)), fidelity_list, label=f"Fidelity for k={binary_repr(k_lst[i]).zfill(4)}")
84
85 # Print the final fidelity for each k
86 final_fidelity = fidelity_list[-1]
87 print(f"Final fidelity for k={binary_repr(k_lst[i]).zfill(4)}: {final_fidelity}")
88
89plt.xlabel("Iterations")
90plt.ylabel("Fidelity")
91plt.title("Fidelity Evolution")
92plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0, fontsize=18)
93plt.show()

We implement the SSVQE on the molecular Hamiltonians such as H$_2$ molecule ( with a fixed distance between two hydrogen atoms $r=0.85 $ at the STO-3G minimal basis set. We choose our own weight (W) for the minimization; We obtain accurate energies with height fidelity rate $\left[ 0,978\longrightarrow 0,998 \right] $. Meaning that the algorithms assures assures the orthogonality of the states at the input of the ansatz circuit

The energy levels of the Hamiltonian of H$_2$ in the STO-3g basis set: four qubits. The fidelity is close to one. It is the Overlap $\langle\Psi_j(\vec{\theta}) |\Psi_{k}\rangle$ between the computed VQE state at each optimization step $j$ and the theoretical ground (or excited) state $|\Psi_{k}\rangle$ of Hamiltonian $H$, where $|\Psi_{k}\rangle$ is obtained through diagonalization.

References

Nakanishi, Ken M., Kosuke Mitarai, and Keisuke Fujii. "Subspace-search variational quantum eigensolver for excited states." Physical Review Research 1.3 (2019): 033062.

About the Author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Unitary Selective Coupled Cluster

Mon, 01 Jan 0001 00:00:00 +0000

The Unitary Coupled-Cluster with Singles and Doubles (UCCSD) method parameterizes coupled-cluster variational parameters for each fermionic excitation from a reference state, whether single or double excitations. This ansatz has been successfully applied to compute accurate electronic energies for small molecules. However, for large molecules, this approach can introduce many redundant, unimportant excitations, resulting in a large number of parameters to optimize and excessively long circuits

The UsCC method systematically reduces the energy error with an increasing ansatz size for a set of test molecules. A significant advantage of the UsCC method is that expanding the ansatz does not necessitate additional measurements on a quantum computer. The implementation of the UsCC method begins with the reference Hartree–Fock state. One- and two-body excitations (from occupied to unoccupied orbitals) with corresponding Hamiltonian matrix elements above a given threshold $\epsilon$ are included in the ansatz. A Variational Quantum Eigensolver (VQE) is then performed on this ansatz until convergence, completing the first iteration. In subsequent iterations, the threshold is updated such that $\epsilon_i = \frac{\epsilon_{i-1}}{2}$. New, higher-order excitations are generated by applying one- and two-body excitations to those already included in the ansatz. The metric to compare to the threshold for inclusion of these excitations is obtained by multiplying the parameters obtained after optimization at the previous step with the Hamiltonian matrix element corresponding to the single or double excitation added. As in previous iterations, coefficients that are above the threshold are included in the ansatz and then optimized through VQE. The optimization continues until a convergence criterion is met or sufficient excitations have been included.

The ansatz generation starts with the reference Hartree–Fock state, with no initial excitation amplitudes available. First, all possible single- and double-electronic excitations are generated. These excitations are expressed in spin-block notation: the occupied orbitals, from which excitations are performed, are labeled $i$, $j$, $k$, and $l$, while the virtual orbitals, to which electrons are excited, are labeled $p$, $q$, $r$, and $s$. For instance, single and double excitations are denoted as $[i, p]$ and $[i, j, p, q]$, respectively.

UsCCSDTQ-VQE Algorithm

Generate single and double excitations for a given molecule.

For all single (S) and double (D) excitations $[i, p]$ and $[i, j, p, q]$ in UCCSD:

If $h_1[i, p]$ and $h_2[i, j, p, q]$ are larger than $\epsilon_1$ then:
- Add to ansatz.
- end if

end for

Repeat.

Run VQE with the current ansatz to compute energy, update amplitudes for each excitation present in ansatz.
For each single $[i, p]$ or double $[i, j, p, q]$ excitation present in ansatz using $t_1$ and $t_2$ values from the previous iteration and additional excitations $[k, r]$ or $[k, l, r, s]$, generate triple and quadruple excitations with the following coefficients:
- $t_1[i, p] \cdot h_2[j, k, q, r]$
- $h_1[i, p] \cdot t_2[j, k, q, r]$
- $t_2[i, j, p, q] \cdot h_1[k, r]$
- $h_2[i, j, p, q] \cdot t_1[k, r]$
- $t_2[i, j, p, q] \cdot h_2[k, l, r, s]$
For each excitation, if the absolute value of the largest coefficient computed in step 3 is larger than $\epsilon_n$ on iteration $n$, add this excitation to ansatz.

Code Source Implementation

Step 1

Import necessary library and define the fucntions

 1from openvqe.common_files.qubit_pool import QubitPool
 2from openvqe.common_files.molecule_factory import MoleculeFactory
 3from openvqe.ucc_family.get_energy_ucc import EnergyUCC
 4from qat.fermion.transforms import (get_jw_code, recode_integer)
 5from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation
 6from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation
 7from qat.fermion.chemistry import MolecularHamiltonian, MoleculeInfo
 8from qat.fermion.chemistry.ucc import guess_init_params, get_hf_ket, get_cluster_ops
 9from qat.fermion.transforms import transform_to_jw_basis # , transform_to_bk_basis, transform_to_parity_basis
 10from qat.fermion.transforms import recode_integer, get_jw_code # , get_bk_code, get_parity_code
 11from qat.lang.AQASM import Program, X
 12from qat.fermion.trotterisation import make_trotterisation_routine
 13from qat.fermion import ElectronicStructureHamiltonian
 14import scipy.optimize
 15from qat.fermion.chemistry.ucc_deprecated import build_ucc_ansatz
 16from qat.lang.AQASM import Program
 17from qat.qpus import get_default_qpu
 18from openvqe.common_files.circuit import count
 19import numpy as np
 20
 21class EnergyUCC:
 22 def ucc_action(self, theta_current, hamiltonian_sp, cluster_ops_sp, hf_init_sp, theta_thresh=1e-7):
 23 """
 24 It maps the exponential of cluster operators ("cluster_ops_sp") associated by their parameters ("theta_current")
 25 using the CNOTS-staircase method, which is done by "build_ucc_ansatz" which creates the circuit on the top of
 26 the HF-state ("hf_init_sp"). Then, this function also calculates the expected value of the hamiltonian ("hamiltonian_sp").
 27
 28 Parameters
 29 ----------
 30 theta_current: List<float>
 31 the Parameters of the cluster operators
 32
 33 hamiltonian_sp: Hamiltonian
 34 Hamiltonian in the spin representation
 35
 36 cluster_ops_sp: list[Hamiltonian]
 37 list of spin cluster operators
 38
 39 hf_init_sp: int
 40 the integer corresponds to the hf_init (The Hartree-Fock state in integer representation) obtained by using
 41 "qat.fermion.transforms.record_integer".
 42
 43 Returns
 44 --------
 45 res.value: float
 46 the resulted energy
 47
 48 """
 49 qpu = 0
 50 prog = 0
 51 reg = 0
 52 qpu = get_default_qpu()
 53 prog = Program()
 54 reg = prog.qalloc(hamiltonian_sp.nbqbits)
 55 qrout = 0
 56 for n_term, (term, theta_term) in enumerate(zip(cluster_ops_sp, theta_current)):
 57 init = hf_init_sp if n_term == 0 else 0
 58 qprog = build_ucc_ansatz([term], init, n_steps=1)
 59 if abs(theta_term) > theta_thresh:
 60 prog.apply(qprog([theta_term]), reg)
 61 circ = prog.to_circ()
 62
 63 return circ
 64
 65 def get_optimization_func(self, circ, qpu, hamiltonian_sp, method, nqbits, psi0, energy_list, fid_list):
 66 # below, I show an example of minimization of the energy where I store the energy and fidelity for each parameter
 67 # I use a gradient-free procedure.
 68 def my_func(x):
 69 """returns energy given parameter x, and stores it + the fidelity of state"""
 70 circ1 = circ.bind_variables(
 71 {k: v for k, v in zip(sorted(circ.get_variables()), x)}
 72 )
 73 res0 = qpu.submit(circ1.to_job(observable=hamiltonian_sp))
 74 energy = res0.value
 75 energy_list[method].append(energy)
 76
 77 # additional computation to compute fidelity (just for my own information)
 78 res = qpu.submit(circ1.to_job())
 79 psi = np.zeros((2**nqbits,), complex)
 80 for sample in res:
 81 psi[sample.state.int] = sample.amplitude
 82 fid = abs(psi.conj().dot(psi0)) ** 2
 83 fid_list[method].append(fid)
 84
 85 return energy
 86
 87 return my_func
 88
 89
 90 def get_grad_func(self, circ, qpu, hamiltonian_sp):
 91 # here I show a gradient-based minimization strategy
 92 def my_grad(x):
 93 grads = circ.to_job(observable=hamiltonian_sp).gradient()
 94 grad_list = []
 95 for var_name in sorted(circ.get_variables()):
 96 list_jobs = grads[var_name]
 97 # list_jobs contains jobs to compute E(theta+pi/2) and E(theta-pi/2)
 98 # the gradient w.r.t theta is then 0.5 (E(theta+pi/2) - E(theta-pi/2))
 99 grad = 0.0
100 for ind in range(len(list_jobs)):
101 circ1 = list_jobs[ind].circuit.bind_variables(
102 {k: v for k, v in zip(circ.get_variables(), x)}
103 )
104 job = circ1.to_job(observable=list_jobs[ind].observable)
105 res = qpu.submit(job)
106 grad += 0.5 * res.value
107 grad_list.append(grad)
108 return grad_list
109
110
111 def prepare_state_ansatz(
112 self, hamiltonian_sp, cluster_ops_sp, hf_init_sp, parameters
113 ):
114 """
115 It constructs the trial wave function (ansatz)
116
117 Parameters
118 ----------
119 hamiltonian_sp: Hamiltonian
120 Hamiltonian in the spin representation
121
122 cluster_ops_sp: list[Hamiltonian]
123 list of spin cluster operators
124
125 hf_init_sp: int
126 the integer corresponds to the hf_init (The Hartree-Fock state in integer representation) obtained by using
127 "qat.fermion.transforms.record_integer".
128
129 parameters: List<float>
130 the Parameters for the trial wave function to be constructed
131
132
133
134 Returns
135 --------
136 curr_state: qat.core.Circuit
137 the circuit that represent the trial wave function
138
139 """
140 qpu = get_default_qpu()
141 prog = Program()
142 reg = prog.qalloc(hamiltonian_sp.nbqbits)
143 for n_term, (term, theta_term) in enumerate(zip(cluster_ops_sp, parameters)):
144 init = hf_init_sp if n_term == 0 else 0
145 qprog = build_ucc_ansatz([term], init, n_steps=1)
146 prog.apply(qprog([theta_term]), reg)
147 circ = prog.to_circ()
148 curr_state = circ
149 return curr_state
150
151 def get_energies(
152 self,
153 hamiltonian_sp,
154 cluster_ops_sp,
155 hf_init_sp,
156 theta_current,
157 fci,
158 method="BFGS"
159 ):
160 """
161 It calls internally the functions "ucc_action" and "prepare_state_ansatz", and uses scipy.optimize to
162 return the properties of the ucc energy and wave function.
163
164 Parameters
165 ----------
166 hamiltonian_sp: Hamiltonian
167 Hamiltonian in the spin representation
168
169 cluster_ops_sp: list[Hamiltonian]
170 list of spin cluster operators
171
172 hf_init_sp: int
173 the integer corresponds to the hf_init (The Hartree-Fock state in integer representation) obtained by using
174 "qat.fermion.transforms.record_integer".
175
176 theta_current: List<float>
177 the Parameters of the cluster operators of "cluster_ops_sp"
178
179
180 theta_current2: List<float>
181 the Parameters of the cluster operators of "pool_generator"
182
183
184 theta_current2: List<float>
185 the Parameters of the cluster operators of "pool_generator"
186
187 fci: float
188 the full configuration interaction energy (for any basis set)
189
190
191 Returns
192 --------
193 iterations: Dict
194 the minimum energy and the optimized parameters
195
196 result: Dict
197 the number of CNOT gates, the number of operators/parameters, and the substraction of the optimized energy from fci.
198
199 """
200
201 iterations = {
202 "minimum_energy_result_guess": [],
203 "theta_optimized_result": [],
204 }
205 result = {}
206 tolerance = 10 ** (-4)
207 print("tolerance= ", tolerance)
208 print("method= ", method)
209
210 theta_optimized_result = []
211
212
213
214 opt_result = scipy.optimize.minimize(
215 lambda theta: self.ucc_action(
216 theta, hamiltonian_sp, cluster_ops_sp, hf_init_sp
217 ),
218 x0=theta_current,
219 method=method,
220 tol=tolerance,
221 options={"maxiter": 50000, "disp": True},
222 )
223
224 xlist = opt_result.x
225
226 for si in range(len(theta_current)):
227 theta_optimized_result.append(xlist[si])
228
229 curr_state_result = self.prepare_state_ansatz(
230 hamiltonian_sp, cluster_ops_sp, hf_init_sp, theta_optimized_result
231 )
232
233 gates = curr_state_result.ops
234 cnot = count("CNOT", gates)
235 iterations["minimum_energy_result_guess"].append(opt_result.fun)
236 iterations["theta_optimized_result"].append(theta_optimized_result)
237 result["CNOT"] = cnot
238 result["len_op"] = len(theta_optimized_result)
239 result["energies_substracted_from_FCI"] = abs(opt_result.fun - fci)
240 return iterations, result

Step 2

Callout the function and excecute the program

 1from openvqe.common_files.molecule_factory import MoleculeFactory
 2#from openvqe.ucc_family.get_energy_ucc import EnergyUCC
 3from openvqe.common_files.generator_excitations import _apply_transforms
 4from qat.fermion.transforms import get_jw_code, recode_integer
 5from qat.core import Term
 6from qat.fermion import FermionHamiltonian
 7
 8
 9def get_h(hamiltonian, exc):
 10 hamiltonian_string = str(hamiltonian)
 11 lines = hamiltonian_string.strip().split("\n")
 12 if len(exc) == 2:
 13 id_str = f"(Cc|[{exc[0]}, {exc[1]}])"
 14 else:
 15 id_str = f"(CCcc|[{exc[0]}, {exc[1]}, {exc[2]}, {exc[3]}])"
 16
 17 lines = [line for line in lines if id_str in line]
 18 if len(lines) == 0:
 19 print("zero h:", exc)
 20 return complex(0.0)
 21 assert len(lines) == 1
 22
 23 line = lines[0]
 24 start_ind = line.find("(") + 1
 25 end_ind = line.find(")")
 26 value = line[start_ind:end_ind]
 27 return complex(value)
 28
 29
 30def init(molecule_symbol):
 31 (
 32 hamiltonian,
 33 hamiltonian_sp,
 34 _,
 35 active_noons,
 36 _,
 37 info,
 38 ) = MoleculeFactory().generate_hamiltonian(
 39 molecule_symbol, active=False, transform="JW"
 40 )
 41
 42 (
 43 _,
 44 cluster_ops,
 45 _,
 46 theta_MP2,
 47 hf_init,
 48 ) = MoleculeFactory().generate_cluster_ops(
 49 molecule_symbol, type_of_generator="UCCSD", transform="JW", active=False
 50 )
 51
 52 hf_init_sp = recode_integer(hf_init, get_jw_code(hamiltonian_sp.nbqbits))
 53 fci = info["FCI"]
 54 print("FCI", fci)
 55 nqbits = len(active_noons)
 56
 57 excitations = [tuple(op.terms[0].qbits) for op in cluster_ops]
 58 current_coeffs = {}
 59
 60 # TODO:
 61 # theta_MP2 = [x if x != 0 else 0.01 for x in theta_MP2]
 62 theta_MP2 = [0.01 for x in theta_MP2]
 63 for i, exc in enumerate(excitations):
 64 current_coeffs[exc] = {"h": get_h(hamiltonian, exc)}
 65
 66 return hamiltonian_sp, hf_init_sp, fci, current_coeffs, nqbits
 67
 68
 69def build_cluster_ops(exc_list, nqbits: int):
 70 """Adapted from myqlm"""
 71 t_opti = []
 72
 73 for op_index in exc_list:
 74 current_excitation_op = []
 75
 76 op_description, indices, indices_conj = None, None, None
 77 if len(op_index) == 2:
 78 op_description = "Cc"
 79 indices, indices_conj = list(op_index), [op_index[1], op_index[0]]
 80
 81 elif len(op_index) == 4:
 82 op_description = "CCcc"
 83 indices, indices_conj = list(op_index), [
 84 op_index[2],
 85 op_index[3],
 86 op_index[0],
 87 op_index[1],
 88 ]
 89 elif len(op_index) == 6:
 90 op_description = "CCCccc"
 91 indices, indices_conj = list(op_index), [
 92 op_index[3],
 93 op_index[4],
 94 op_index[5],
 95 op_index[0],
 96 op_index[1],
 97 op_index[2],
 98 ]
 99
100 elif len(op_index) == 8:
101 op_description = "CCCCcccc"
102 indices, indices_conj = list(op_index), [
103 op_index[4],
104 op_index[5],
105 op_index[6],
106 op_index[7],
107 op_index[0],
108 op_index[1],
109 op_index[2],
110 op_index[3],
111 ]
112
113 current_excitation_op.append(Term(1j, op_description, indices))
114 current_excitation_op.append(Term(-1j, op_description, indices_conj))
115 t_opti.append(FermionHamiltonian(nqbits=nqbits, terms=current_excitation_op))
116
117 return t_opti
118
119
120def update_ansatz(current_excitations, current_coeffs, thresh, nqbits):
121 all_excitations = list(current_coeffs.keys())
122
123 for optimized_exc in current_excitations:
124 for exc in all_excitations:
125 exc_len = len(exc)
126 opt_exc_len = len(optimized_exc)
127
128 # single-single
129 if exc_len == 2 and opt_exc_len == 2:
130 new_exc = sorted([exc[0], optimized_exc[0]]) + sorted(
131 [exc[1], optimized_exc[1]]
132 )
133 elif exc_len == 2 and opt_exc_len == 4:
134 new_exc = sorted([exc[0], optimized_exc[0], optimized_exc[1]]) + sorted(
135 [exc[1], optimized_exc[2], optimized_exc[3]]
136 )
137 elif exc_len == 4 and opt_exc_len == 2:
138 new_exc = sorted([exc[0], exc[1], optimized_exc[0]]) + sorted(
139 [exc[2], exc[3], optimized_exc[1]]
140 )
141 elif exc_len == 4 and opt_exc_len == 4:
142 new_exc = sorted(
143 [exc[0], exc[1], optimized_exc[0], optimized_exc[1]]
144 ) + sorted([exc[2], exc[3], optimized_exc[2], optimized_exc[3]])
145 else:
146 continue
147
148 if len(set(new_exc)) != len(new_exc):
149 continue
150 th = 0
151 ht = 0
152 if "t" in current_coeffs[optimized_exc] and "h" in current_coeffs[exc]:
153 # print(
154 # thresh,
155 # f"t{opt_exc_len//2}",
156 # f"h{exc_len//2}",
157 # len(new_exc) // 2,
158 # current_coeffs[optimized_exc]["t"],
159 # current_coeffs[exc]["h"],
160 # )
161 th = current_coeffs[optimized_exc]["t"] * current_coeffs[exc]["h"]
162 if "t" in current_coeffs[exc] and "h" in current_coeffs[optimized_exc]:
163 # print(
164 # thresh,
165 # f"h{opt_exc_len//2}",
166 # f"t{exc_len//2}",
167 # len(new_exc) // 2,
168 # current_coeffs[optimized_exc]["h"],
169 # current_coeffs[exc]["t"],
170 # )
171 ht = current_coeffs[optimized_exc]["h"] * current_coeffs[exc]["t"]
172
173 new_exc = tuple(new_exc)
174 if new_exc not in current_coeffs:
175 current_coeffs[new_exc] = {}
176
177 current_coeffs[new_exc]["th"] = max(
178 current_coeffs[new_exc].get("th", 0), abs(th)
179 )
180 current_coeffs[new_exc]["ht"] = max(
181 current_coeffs[new_exc].get("ht", 0), abs(ht)
182 )
183
184 for exc in current_coeffs.keys():
185 if exc in current_excitations:
186 continue
187
188 coeffs = list(map(abs, current_coeffs[exc].values()))
189 max_coeff = max(coeffs)
190 if max_coeff > thresh:
191 print("ADDED", exc)
192 current_excitations.append(exc)
193
194 current_theta = [
195 current_coeffs[exc]["t"] if "t" in current_coeffs[exc] else 0.01
196 for exc in current_excitations
197 ]
198
199 cluster_ops = build_cluster_ops(current_excitations, nqbits)
200 _, _, cluster_ops_sp = _apply_transforms(cluster_ops, "JW")
201
202 return current_excitations, current_theta, cluster_ops_sp
203
204
205def iterate(hamiltonian_sp, ansatz_ops, hf_init_sp, theta_current, fci):
206 iterations, result = EnergyUCC().get_energies(
207 hamiltonian_sp, ansatz_ops, hf_init_sp, theta_current, fci, "BFGS"
208 )
209 new_theta = iterations["theta_optimized_result"][0]
210 energy = result["energies_substracted_from_FCI"]
211 print("ENERGY ERROR", energy)
212
213 return new_theta, energy
214
215
216def energy_stop_condition(energy):
217 return False
218
219
220thresholds = iter(
221 [0.04, 0.02, 0.01, 0.005, 0.002, 0.001, 0.0005, 0.0002, 1e-4, 1e-5, 1e-6, 1e-7]
222)
223hamiltonian_sp, hf_init_sp, fci, current_coeffs, nqbits = init("LIH")
224current_excitations = []
225thresh = next(thresholds)
226
227just_count = 0
228while True:
229 prev_num_excitations = len(current_excitations)
230 current_excitations, current_theta, cluster_ops_sp = update_ansatz(
231 current_excitations, current_coeffs, thresh, nqbits
232 )
233 if len(current_excitations) == prev_num_excitations:
234 try:
235 thresh = next(thresholds)
236 except StopIteration:
237 break
238 continue
239 print("Optimization:", just_count)
240 just_count += 1
241
242
243
244 new_theta, energy = iterate(
245 hamiltonian_sp, cluster_ops_sp, hf_init_sp, current_theta, fci
246 )
247 if energy_stop_condition(energy):
248 break
249
250 for i, exc in enumerate(current_excitations):
251 current_coeffs[exc]["t"] = new_theta[i]
252
253
254for exc in current_excitations:
255 print(exc)

Analytical Results

We test UsCCSDTQ-VQE on H$_4$ and LiH molecules using PMRS method (described in the previous section). We emulate 8 qubits in STO-3G basis set. Numerical results are shown in Figure 1 for H$_4$ and 2 LiH for as below:

Figure 1: PMRS application on UsCCSDTQ-VQE algorithm using H₄ molecule (8 qubits) at 0.85Å, using BFGS optimizer: (left figure) shows the energy obtained from UsCC simulations with respect to the number of selective parameters. (Right figure) shows the number of function evaluations per each iteration. Error is the difference between UsCCDTQ energies and FCI. STO-3G basis set is used.

Figure 2: PMRS application on UsCCSDTQ-VQE algorithm using LiH molecule (12 qubits) at 1.45Å, using BFGS optimizer: (left figure) shows the energy obtained from UsCC simulations with respect to the number of selective parameters. (Right figure) shows the number of function evaluations per each iteration. Error is the difference between UsCCDTQ energies and FCI. STO-3G basis set is used.

We observe that only three iterations are needed to reach $10^{-9}$ Hartee for H$_4$ (with overall 19 parameters to optimize, with function evaluations 225 (first iteration), 198 (second iteration) and 180( third iteration)) and 13 iterations are needed for LiH reach to 1.06 $\times 10^{-5}$ Hartree, with about 45 function evaluations. We observe that PMRS helps reduce the number of function evaluations in both systems, which would exceed 1000 if PMRS were not used. This is demonstrated in the below table

$\bm{r_{\text{Li} - \text{H}}}$	Selective Parameters	Functions Evaluation	Gradient Evaluation	Error (Ha)
$0.5\mathring{\text{A}}$	54	10938	226	$3.7\times 10^{-13}$
$1.0\mathring{\text{A}}$	68	10795	247	$4.4\times 10^{-13}$
$1.5\mathring{\text{A}}$	72	10640	242	$7.84\times 10^{-13}$
$2.0\mathring{\text{A}}$	68	11406	263	$1.96\times 10^{-12}$

Table 1: Test UsCCSDTQ-VQE on LiH 12 qubits. BFGS optimizer, tolerance $10^{-6}$ (Hartree), STO-3G basis set is used. (Molecule LiH at $r_{\text{Li} -\text{H}} = \left[0.5 - 2.0 \right] \mathring{\text{A}}$)

References

Fedorov, Dmitry A., et al. "Unitary selective coupled-cluster method." Quantum 6 (2022): 703.
Haidar, Mohammad, et al. "Open source variational quantum eigensolver extension of the quantum learning machine for quantum chemistry." Wiley Interdisciplinary Reviews: Computational Molecular Science 13.5 (2023): e1664.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

OpenVQA Community

Mon, 01 Jan 0001 00:00:00 +0000

Community Introduction

Watch our community introduction video to learn more about OpenVQA and our mission:

– Lead, OpenVQA Hub Community
– Director of Documentation (External)
– Administrator, OpenVQE GitHub Source Code
– Management & Organization
– Developer of Drug Discovery Quantum Computing Applications
– Quantum Computing Algorithm Developer
– Senior Advisor in Quantum Computing Algorithms & Applications
– Administrator, OpenVQA GitHub Source Code
– Codirect Administrator, OpenVQE GitHub Source Code
– AI Integration with Quantum Computing Algorithms
– AI Integration with Quantum Computing Algorithms
– External Advisor
– Advisor & Quantum Enthusiast
– Quantum Enthusiast
– Machine Learning Developer
– Quantum Algorithm Developer, RIKEN

Advisors

Group Activities

Contacts for events & collaboration

Haidar Mohammad:

Mohammad-Tazmil Ziavoudine:

Rodrigue Pekar:

Overview

Mon, 01 Jan 0001 00:00:00 +0000

🌐 Introduction

Mohammad Haidar, a passionate quantum computing researcher and innovator, is the creator of the OpenVQE algorithmic suite. His vision led to the creation of OpenVQAn, followed by the establishment of the OpenVQA Community — a global initiative committed to advancing open-source quantum computing tools. Under his leadership, OpenVQA evolved into a dynamic ecosystem connecting developers, researchers, and industry experts across the world.

⚛️ Why Quantum Computing Matters

Quantum computing is reshaping the way we think about solving some of the world’s most complex problems. With its ability to perform computations beyond the reach of classical computers, quantum technology is emerging as a transformative force in various fields:

📊 Finance: Advanced risk modeling and portfolio optimization
🔗 Optimization: Solving large-scale industrial and logistical challenges
⚙️ Physics & Chemistry: Accurate molecular simulations and material discovery
🤖 Machine Learning: Enabling novel models and faster training on quantum-enhanced data

The OpenVQA Package

To bridge the gap between quantum theory and practical applications, we developed the OpenVQA package — a collection of high-quality quantum algorithms designed for NISQ (Noisy Intermediate-Scale Quantum) devices.

These algorithms are implemented across a wide range of quantum programming frameworks, supported by the global industry:

MyQLM by Eviden (France) –
Qiskit by IBM –
Cirq by Google Quantum AI –
Q# by Microsoft –

🔄 From OpenVQA to OpenNISQ: Bridging Algorithms to Real Quantum Devices

As the field matures, we are preparing the next leap: the OpenNISQ platform — a natural extension of OpenVQA tailored for direct use on real NISQ hardware. While OpenVQA provides algorithmic innovation, OpenNISQ will offer a practical environment for testing, validating, and benchmarking these algorithms on real quantum machines.

By enabling real-world proof-of-concept demonstrations, OpenNISQ ensures that both academic and industrial users can:

Optimize algorithms based on real-device performance
Evaluate cross-platform behavior and efficiency
Collaborate globally on hardware-agnostic innovation

🔭 Roadmap 2026–2027

We are launching a global OpenNISQ Hub — a collaborative space where developers and researchers can contribute, test, and deploy quantum applications across the NISQ landscape. This will mark a major milestone in uniting quantum software with physical hardware, opening the doors to scalable, industry-relevant innovation.

🌍 Looking Ahead: OpenQuantumNet

Our long-term vision is OpenQuantumNet — a worldwide, unified platform gathering all quantum algorithms tested and applied across existing and emerging quantum technologies. It will serve as a centralized hub for:

Sharing validated quantum algorithms
Benchmarking across diverse quantum devices
Driving community-led research and industry-aligned progress

For a detailed look at what’s coming next, please check our Roadmap section.

Sponsorship and Roadmap

Mon, 01 Jan 0001 00:00:00 +0000

Community Introduction

Watch our community introduction video to learn more about OpenVQA and our mission:

Roadmap

Please find our road map as below:

Sponsorship

fully support our community in the future: access to Qaptiva systems for events and hackathons, subject to case-by-case discussion.