def kraus_gate_error_noise_models_full():
"""Kraus gate error noise models on many gate types"""
# Amplitude damping error on "u1", "u2", "u3", "cx"
error = amplitude_damping_error(0.2)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ['h'])
noise_model.add_all_qubit_quantum_error(error.tensor(error),
['cp', 'swap'])
return noise_model
def test_errors(self):
gamma = 0.23
error = amplitude_damping_error(gamma)
# kraus error is legit, transform_channel_operators are not
with self.assertRaisesRegex(
TypeError, "takes 1 positional argument but 2 were given"):
approximate_quantum_error(error, 7)
with self.assertRaisesRegex(RuntimeError,
"No information about noise type seven"):
approximate_quantum_error(error, operator_string="seven")
def test_amplitude_damping_error_full_1state_noncanonical(self):
"""Test amplitude damping error with param=1 and canonical kraus"""
error = amplitude_damping_error(1, excited_state_population=1,
canonical_kraus=False)
targets = [np.diag([0, 1]), np.array([[0, 0], [1, 0]])]
circ, p = error.error_term(0)
self.assertEqual(p, 1, msg="Kraus probability")
self.assertEqual(circ[0]["qubits"], [0])
for op in circ[0]['params']:
self.remove_if_found(op, targets)
self.assertEqual(targets, [], msg="Incorrect kraus matrices")
def kraus_gate_error_noise_models():
"""Kraus gate error noise models"""
noise_models = []
# Amplitude damping error on "id"
error = amplitude_damping_error(0.75, 0.25)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
noise_models.append(noise_model)
return noise_models
def test_amplitude_damping_error_ideal_noncanonical(self):
"""Test amplitude damping error with param=0 and noncanonical kraus"""
error = amplitude_damping_error(0,
excited_state_population=0.5,
canonical_kraus=False)
circ, p = error.error_term(0)
self.assertEqual(p, 1, msg="ideal probability")
self.assertEqual(circ[0], {
"name": "id",
"qubits": [0]
},
msg="ideal circuit")
def test_t1(self):
"""
Run the simulator with amplitude damping noise.
Then verify that the calculated T1 matches the amplitude damping
parameter.
"""
# 25 numbers ranging from 1 to 200, linearly spaced
num_of_gates = (np.linspace(1, 200, 25)).astype(int)
gate_time = 0.11
num_of_qubits = 2
qubit = 0
circs, xdata = t1_circuits(num_of_gates, gate_time, num_of_qubits,
qubit)
expected_t1 = 10
gamma = 1 - np.exp(-gate_time / expected_t1)
error = amplitude_damping_error(gamma)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
# TODO: Include SPAM errors
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 300
backend_result = qiskit.execute(circs,
backend,
shots=shots,
backend_options={
'max_parallel_experiments': 0
},
noise_model=noise_model).result()
initial_t1 = expected_t1
initial_a = 1
initial_c = 0
fit = T1Fitter(backend_result,
shots,
xdata,
num_of_qubits,
qubit,
fit_p0=[initial_a, initial_t1, initial_c],
fit_bounds=([0, 0, -1], [2, expected_t1 * 1.2, 1]))
self.assertAlmostEqual(fit.time,
expected_t1,
delta=20,
msg='Calculated T1 is inaccurate')
self.assertTrue(
fit.time_err < 30,
'Confidence in T1 calculation is too low: ' + str(fit.time_err))
def test_errors(self):
gamma = 0.23
error = amplitude_damping_error(gamma)
# kraus error is legit, transform_channel_operators are not
with self.assertRaisesRegex(
TypeError, "takes 1 positional argument but 2 were given"):
approximate_quantum_error(error, 7)
with self.assertRaisesRegex(RuntimeError,
"No information about noise type seven"):
approximate_quantum_error(error, operator_string="seven")
# let's pretend cvxopt does not exist; the script should raise ImportError with proper message
import unittest.mock
import sys
with unittest.mock.patch.dict(sys.modules, {'cvxopt': None}):
with self.assertRaisesRegex(
ImportError,
"The CVXOPT library is required to use this module"):
approximate_quantum_error(error, operator_string="reset")
def test_approx_noise_model(self):
noise_model = NoiseModel()
gamma = 0.23
p = 0.4
q = 0.33
ad_error = amplitude_damping_error(gamma)
r_error = reset_error(p, q) # should be approximated as-is
noise_model.add_all_qubit_quantum_error(ad_error, 'iden x y s')
noise_model.add_all_qubit_quantum_error(r_error, 'iden z h')
result = approximate_noise_model(noise_model, operator_string="reset")
expected_result = NoiseModel()
gamma_p = (gamma - numpy.sqrt(1 - gamma) + 1) / 2
gamma_q = 0
ad_error_approx = reset_error(gamma_p, gamma_q)
expected_result.add_all_qubit_quantum_error(ad_error_approx,
'iden x y s')
expected_result.add_all_qubit_quantum_error(r_error, 'iden z h')
self.assertNoiseModelsAlmostEqual(expected_result, result)
def test_transformation_by_kraus(self):
gamma = 0.23
error = amplitude_damping_error(gamma)
reset_to_0 = [
numpy.array([[1, 0], [0, 0]]),
numpy.array([[0, 1], [0, 0]])
]
reset_to_1 = [
numpy.array([[0, 0], [1, 0]]),
numpy.array([[0, 0], [0, 1]])
]
reset_kraus = [Kraus(reset_to_0), Kraus(reset_to_1)]
actual = approximate_quantum_error(error, operator_list=reset_kraus)
p = (1 + gamma - numpy.sqrt(1 - gamma)) / 2
expected_probs = [1 - p, p, 0]
self.assertListAlmostEqual(expected_probs, actual.probabilities)
with self.assertWarns(DeprecationWarning):
approximate_quantum_error(error,
operator_list=[reset_to_0, reset_to_1])
def test_amplitude_damping_error(self):
"""Test amplitude damping error damps to correct state"""
qr = QuantumRegister(1, 'qr')
cr = ClassicalRegister(1, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.x(qr) # prepare + state
for _ in range(30):
# Add noisy identities
circuit.barrier(qr)
circuit.i(qr)
circuit.barrier(qr)
circuit.measure(qr, cr)
shots = 4000
backend = AerSimulator()
# test noise model
error = amplitude_damping_error(0.75, 0.25)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
# Execute
target = {'0x0': 3 * shots / 4, '0x1': shots / 4}
circuit = transpile(circuit, basis_gates=noise_model.basis_gates, optimization_level=0)
result = backend.run(circuit, shots=shots, noise_model=noise_model).result()
self.assertSuccess(result)
self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
def test_approx_names(self):
gamma = 0.23
error = amplitude_damping_error(gamma)
results_1 = approximate_quantum_error(error, operator_string="pauli")
results_2 = approximate_quantum_error(error, operator_string="Pauli")
self.assertErrorsAlmostEqual(results_1, results_2)
def load_device(params: dict,
exact: bool = True,
ibm_data: dict = {}) -> qml.Device:
"""Load simulator or QPU."""
if exact:
if params["dev_ex"] == "def.qub":
dev = qml.device("default.qubit", wires=params["n_qubits"])
else:
raise ValueError("Unknown exact device")
else:
# zero_noise default qubit with finite shots
if params["dev_ns"] == "def.qub":
dev = qml.device(
"default.qubit",
wires=params["n_qubits"],
shots=params["n_shots"],
analytic=False,
)
elif params["dev_ns"] == "ibmq":
if ibm_data:
dev = qml.device(
"qiskit.ibmq",
wires=params["n_qubits"],
backend=params["ns_type"],
shots=params["n_shots"],
provider=ibm_data,
)
else:
dev = qml.device(
"qiskit.ibmq",
wires=params["n_qubits"],
backend=params["ns_type"],
shots=params["n_shots"],
)
elif params["dev_ns"] == "qsk.aer":
# depolarizing noise
if params["ns_type"] == "dep":
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
depolarizing_error(params["noise"], 1), ["u1", "u2", "u3"])
# amplitude damping noise
elif params["ns_type"] == "amp":
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
amplitude_damping_error(params["noise"], 1),
["u1", "u2", "u3"])
# noise model from device
elif params["ns_type"] in ibm_data.keys():
dev_data = ibm_data[params["ns_type"]]
noise_model = dev_data["noise_model"]
# zero_noise (i.e. exact "qsk.aer" simulator)
elif params["ns_type"] == "zero_noise":
noise_model = None
else:
raise ValueError("Unknown noise source")
dev = qml.device(
"qiskit.aer",
wires=params["n_qubits"],
shots=params["n_shots"],
noise_model=noise_model,
backend="qasm_simulator",
)
else:
raise ValueError("Unknown noisy device")
return dev
