%%writefile ghz_dnoisy.py

import numpy as np
import matplotlib.pyplot as plt

from qat.lang.AQASM import Program, H, CNOT

# Generate the circuit on 8 qbits
nqbits = 8

prog = Program()
qbits = prog.qalloc(nqbits)
prog.apply(H, qbits[0])
for i in range(0, nqbits - 1):
    prog.apply(CNOT, [qbits[i], qbits[i + 1]])

circ = prog.to_circ()

Writing ghz_dnoisy.py

%run ghz_dnoisy.py

circ.display()

%%writefile -a ghz_dnoisy.py

from itertools import product
from qat.hardware import HardwareModel, DefaultGatesSpecification
from qat.quops import QuantumChannelKraus, ParametricAmplitudeDamping, ParametricPureDephasing

# Specify appliation time of each gate
gate_times = {
                "CNOT": 10,
                "H": 2, 
             }
# Create the GatesSpecification of the hardware, with perfect gates with nonzero application time
gates_spec = DefaultGatesSpecification(gate_times)

# Create an idle noise model, assuming that each qubit experiences the same AD/PD noise.  
idle_noise = [ParametricAmplitudeDamping(T_1=200), ParametricPureDephasing(T_phi=100)]

# Instantie a noise model representing a depolarizing noise, to be applyed after application of each perfect gate
# with probability 1%
prob = 0.01
Xmat = np.array([[0, 1], [1, 0]])
Ymat = np.array([[0, -1j], [1j, 0]])
Zmat = np.array([[1, 0], [0, -1]])
kraus_ops = [np.sqrt(1-prob)*np.identity(2),
             np.sqrt(prob/3)*Xmat, np.sqrt(prob/3)*Ymat, np.sqrt(prob/3)*Zmat]
noise = QuantumChannelKraus(kraus_ops)

# two-qbit version for the CNOT gate
noise2 = QuantumChannelKraus([np.kron(K1, K2) for K1, K2 in product(noise.kraus_operators, 
                                                                    noise.kraus_operators)])
# for each gate, we specify the noise
# note that the values in this dictionary are lambda functions
# with as many arguments as the gate's number of arguments
gates_noise = {"H": lambda: noise,
               "CNOT": lambda: noise2,
               }

#Create the hardware model, with gate noise and idle noise

hardware_model = HardwareModel(gates_spec, gates_noise, idle_noise)

Appending to ghz_dnoisy.py

%%writefile -a ghz_dnoisy.py

from qat.qpus import DNoisy

# The nb_processes here is set to 1, so the simulation will only run on a single node
# This argument is optional and the number of reserved nodes in the SLURM environment will be used by default
nb_processes = 1
# The temp_dir argument must be configured to point to a writable temporary directory shared by all the nodes in the cluster
# if the directory containing this Python script does not have write permissions or is not shared
temp_dir = "/tmp/"
qpu = DNoisy(nb_processes=nb_processes, temp_dir=temp_dir, hardware_model=hardware_model)

job = circ.to_job(nbshots=10000)

res = qpu.submit(job)

for sample in res:
    print(f"Sampled state {sample.state} with probability {sample.probability} and error {sample.err}")

Appending to ghz_dnoisy.py

%%file submit.sh
#!/bin/sh

#SBATCH --nodes 1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=64
#SBATCH --time 00:03:00
#SBATCH --job-name ghz_dnoisy
#SBATCH --output slurm_output/ghz_dnoisy.out
#SBATCH --error slurm_output/ghz_dnoisy.err
#SBATCH --exclusive

# Load the python3 module to be used on the cluster
# module load python3

echo "Loading the qaptiva-hpc module environment"
module load qaptiva-hpc

# Load other modules if necessary such as openmpi
# module load openmpi

echo "Running the DNoisy simulation"
python3 ghz_dnoisy.py

Writing submit.sh

%%bash
sbatch --wait --deadline=now+4minutes submit.sh

Submitted batch job 1740

%%bash
cat slurm_output/ghz_dnoisy.out

Loading the qaptiva-hpc module environment

Running the DNoisy simulation

Sampled state |00000000> with probability 0.4636 and error 0.004986982153477182

Sampled state |00000001> with probability 0.0028 and error 0.000528435354979622

Sampled state |00000010> with probability 0.0032 and error 0.0005648078441293809

Sampled state |00000011> with probability 0.0031 and error 0.0005559405606633672

Sampled state |00000100> with probability 0.002 and error 0.00044678849805718994

Sampled state |00000111> with probability 0.0043 and error 0.0006543652033703643

Sampled state |00001000> with probability 0.0027 and error 0.0005189392351643681

Sampled state |00001011> with probability 0.0004 and error 0.00019996999474891224

Noisy distributed simulation with DNoisy¶

Simulation of quantum circuits on a HPC cluster

Example simulation

Preparing a python script describing the quantum program and hardware model

Writing the SLURM batch script to define the resources needed to run the job

Submitting the SLURM job on the cluster¶

Reading the result from the SLURM output file¶