%%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.4605 and error 0.004984622317283889
Sampled state |00000001> with probability 0.002

6 and error 0.0005092641112364972
Sampled state |00000010> with probability 0.0025 and error 0.00049

93995794892096
Sampled state |00000011> with probability 0.0027 and error 0.0005189392351643681
Samp

led state |00000100> with probability 0.0035 and error 0.0005906012876620731
Sampled state |00000101

> with probability 0.0001 and error 0.0001
Sampled state |00000111> with probability 0.004 and error

 0.0006312209153572135
Sampled state |00001000> with probability 0.0024 and error 0.0004893341851888

946
Sampled state |00001011> with probability 0.0005 and error 0.00022356206744392033
Sampled state

|00001111> with probability 0.0044 and error 0.000661897130059557
Sampled state |00010000> with prob

ability 0.0033 and error 0.000573536306077862
Sampled state |00010100> with probability 0.0001 and e

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¶