Qiskit

Qiskit is the world’s most popular software stack for quantum computing, with over 2,000 forks, over 8,000 contributions, and over 3 trillion circuits run.

Usage

Example script : testQiskit.sh

#!/bin/bash

#SBATCH -e qiskit_test%j.err
#SBATCH -o qiskit_test%j.msg
#SBATCH -p thin
#SBATCH -N 4
#SBATCH --ntasks-per-node=24

module load qiskit/0.45.0

python vqe-qiskit-test.py

Submit with :

sbatch --account=your_project_ID testQiskit.sh

Example script : vqe-qiskit-test.py

# General libraries
import warnings
import numpy as np
from functools import partial
from scipy.optimize import minimize

# Qiskit libraries
import qiskit
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Estimator
from qiskit.algorithms.minimum_eigensolvers import VQE

warnings.filterwarnings("ignore")

# Minimize the energy of this 4-qubit Hamiltonian given in Pauli operators
# H = 1.0 * XXII + 0.3 * ZIII + 1.0 * IXXI + 0.3 * IZII + 1.0 * IIXX + 0.3 * IIZI + 1.0 * XIIX + 0.3 * IIIZ

def ising_chain_ham(n, gam):

    # Esta función nos devuelve el Hamiltoniano en términos utilizables por los algoritmos de Qiskit
    # n = number of spin positions
    # gam = transverse field parameter
    from qiskit.opflow import X, Z, I

    for i in range(n):
        vecX = [I] * n
        vecZ = [I] * n
        vecX[i] = X
        vecZ[i] = Z

        if i == n - 1:
            vecX[0] = X
        else:
            vecX[i+1] = X

        auxX = vecX[0]
        auxZ = vecZ[0]

        for a in vecX[1:n]:
            auxX = auxX ^ a
        for b in vecZ[1:n]:
            auxZ = auxZ ^ b

        if i == 0:
            H = (auxX) + (gam * auxZ)
        else:
            H = H + (auxX) + (gam * auxZ)

    return H

# Hamiltonian definition
n = 4 # number of qubits
gam = 0.3

op_H = ising_chain_ham(n, gam) # Hamiltonian creation

print("Estructura del Hamiltoniano en matrices de Pauli:")
print("--------------------------------------------------\n")
print(op_H)

# ansatz creation
ansatz = TwoLocal(num_qubits=n, rotation_blocks='ry', entanglement_blocks='cx')

seed = 63
np.random.seed(seed) # seed for reproducibility
algorithm_globals.random_seed = seed

# use L-BFGS-B optimizer with minimizze function
optimizer = partial(minimize, method="L-BFGS-B")

initial_point = np.random.random(ansatz.num_parameters) # valor inicial

intermediate_info = {
    'nfev': [],
    'parameters': [],
    'mean': [],
}

def callback(nfev, parameters, mean, stddev):
    intermediate_info['nfev'].append(nfev)
    intermediate_info['parameters'].append(parameters)
    intermediate_info['mean'].append(mean)

backend = Aer.get_backend('aer_simulator')

qi = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)

vqe_min = VQE(estimator = Estimator(),
           ansatz=ansatz,
           optimizer=optimizer,
           initial_point=initial_point,
           callback=callback)

vqe_min.quantum_instance = qi

result = vqe_min.compute_minimum_eigenvalue(op_H)

print('\nEigenvalue:', result.eigenvalue)
print('Eigenvalue real part:', result.eigenvalue.real)

print(result, "\n")
print("E_G =", result.optimal_value)

print("Qiskit version:", qiskit.__version__)

More info :