%%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 3

%%bash
cat slurm_output/ghz_dnoisy.out

Loading the qaptiva-hpc module environment
Running the DNoisy simulation
Sampled state |00000000> wi

th probability 0.4603 and error 0.0049844634101925914
Sampled state |00000001> with probability 0.00

23 and error 0.0004790552675787414
Sampled state |00000010> with probability 0.0019 and error 0.0004

3549737748530665
Sampled state |00000011> with probability 0.0026 and error 0.0005092641112364972
Sa

mpled state |00000100> with probability 0.0027 and error 0.0005189392351643681
Sampled state |000001

01> with probability 0.0001 and error 0.0001
Sampled state |00000111> with probability 0.0033 and er

ror 0.000573536306077862
Sampled state |00001000> with probability 0.0031 and error 0.00055594056066

33672
Sampled state |00001011> with probability 0.0007 and error 0.00026449573871724277
Sampled stat

e |00001111> with probability 0.0032 and error 0.0005648078441293809
Sampled state |00010000> with p

robability 0.0023 and error 0.0004790552675787414
Sampled state |00010111> with probability 0.0009 a

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¶