def pauli_gate_error_noise_models():
"""Local Pauli gate error noise models"""
noise_models = []
# 100% all-qubit Pauli error on "id" gates
error = pauli_error([('X', 1)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
noise_models.append(noise_model)
# 25% all-qubit Pauli error on "id" gates
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'id')
noise_models.append(noise_model)
# 100% Pauli error on "id" gates on qubit-1
error = pauli_error([('X', 1)])
noise_model = NoiseModel()
noise_model.add_quantum_error(error, 'id', [1])
noise_models.append(noise_model)
# 25% all-qubit Pauli error on "id" gates on qubit-0
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_quantum_error(error, 'id', [0])
noise_models.append(noise_model)
# 25% Pauli-X error on spectator for CX gate on [0, 1]
error = pauli_error([('XII', 0.25), ('III', 0.75)])
noise_model = NoiseModel()
noise_model.add_nonlocal_quantum_error(error, 'cx', [0, 1], [0, 1, 2])
noise_models.append(noise_model)
return noise_models
def test_multiple_inputs(self):
qr = QuantumRegister(1, 'qr')
circuit1 = QuantumCircuit(qr)
circuit1.x(qr[0])
circuit2 = QuantumCircuit(qr)
circuit2.y(qr[0])
circuits_list = [circuit1, circuit2]
circuits_tuple = (circuit1, circuit2)
noise_model = NoiseModel()
error_x = pauli_error([('Y', 0.25), ('I', 0.75)])
error_y = pauli_error([('X', 0.35), ('Z', 0.65)])
noise_model.add_all_qubit_quantum_error(error_x, 'x')
noise_model.add_all_qubit_quantum_error(error_y, 'y')
target_circuit1 = QuantumCircuit(qr)
target_circuit1.x(qr[0])
target_circuit1.append(error_x.to_instruction(), [qr[0]])
target_circuit2 = QuantumCircuit(qr)
target_circuit2.y(qr[0])
target_circuit2.append(error_y.to_instruction(), [qr[0]])
target_circuits = [target_circuit1, target_circuit2]
result_circuits = insert_noise(circuits_list, noise_model)
self.assertEqual(target_circuits, result_circuits)
target_circuits = [target_circuit1, target_circuit2]
result_circuits = insert_noise(circuits_tuple, noise_model)
self.assertEqual(target_circuits, result_circuits)
def tensored_calib_circ_execution(shots: int, seed: int):
"""
create tensored measurement calibration circuits and simulate them with noise
Args:
shots (int): number of shots per simulation
seed (int): the seed to use in the simulations
Returns:
list: list of Results of the measurement calibration simulations
list: the mitigation pattern
dict: dictionary of results counts of GHZ circuit simulation with measurement errors
"""
# define the circuits
meas_calibs, mit_pattern, ghz_circ = tensored_calib_circ_creation()
# define noise
prob = 0.2
error_meas = pauli_error([('X', prob), ('I', 1 - prob)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error_meas, "measure")
# run the circuits multiple times
backend = qiskit.Aer.get_backend('qasm_simulator')
cal_results = qiskit.execute(meas_calibs,
backend=backend,
shots=shots,
noise_model=noise_model,
seed_simulator=seed).result()
ghz_results = qiskit.execute(ghz_circ,
backend=backend,
shots=shots,
noise_model=noise_model,
seed_simulator=seed).result()
return cal_results, mit_pattern, ghz_results
def test_transformation_by_pauli(self):
n = NoiseTransformer()
# polarization in the XY plane; we represent via Kraus operators
X = self.ops['X']
Y = self.ops['Y']
Z = self.ops['Z']
p = 0.22
theta = numpy.pi / 5
E0 = numpy.sqrt(1 - p) * numpy.array(numpy.eye(2))
E1 = numpy.sqrt(p) * (numpy.cos(theta) * X + numpy.sin(theta) * Y)
results = approximate_quantum_error((E0, E1),
operator_dict={
"X": X,
"Y": Y,
"Z": Z})
expected_results = pauli_error(
[('X', p * numpy.cos(theta) * numpy.cos(theta)),
('Y', p * numpy.sin(theta) * numpy.sin(theta)), ('Z', 0),
('I', 1 - p)])
self.assertErrorsAlmostEqual(expected_results, results)
# now try again without fidelity; should be the same
n.use_honesty_constraint = False
results = approximate_quantum_error((E0, E1),
operator_dict={
"X": X,
"Y": Y,
"Z": Z})
self.assertErrorsAlmostEqual(expected_results, results)
def test_pauli_error_2q_gate_from_pauli(self):
"""Test two-qubit pauli error as gate qobj from Pauli obj"""
paulis = [Pauli.from_label(s) for s in ['XZ', 'YX', 'ZY']]
probs = [0.5, 0.3, 0.2]
error = pauli_error(zip(paulis, probs), standard_gates=True)
target_circs = [[{
"name": "z",
"qubits": [0]
}, {
"name": "x",
"qubits": [1]
}], [{
"name": "x",
"qubits": [0]
}, {
"name": "y",
"qubits": [1]
}], [{
"name": "y",
"qubits": [0]
}, {
"name": "z",
"qubits": [1]
}]]
target_probs = probs.copy()
for j in range(len(paulis)):
circ, p = error.error_term(j)
self.remove_if_found(p, target_probs)
self.remove_if_found(circ, target_circs)
self.assertEqual(target_probs, [], msg="Incorrect probabilities")
self.assertEqual(target_circs, [], msg="Incorrect circuits")
def test_pauli_error_1q_unitary_from_string(self):
"""Test single-qubit pauli error as unitary qobj from string label"""
paulis = ['I', 'X', 'Y', 'Z']
probs = [0.4, 0.3, 0.2, 0.1]
error = pauli_error(zip(paulis, probs), standard_gates=False)
target_unitaries = [
standard_gate_unitary('x'),
standard_gate_unitary('y'),
standard_gate_unitary('z')
]
target_probs = probs.copy()
target_identity_count = 0
for j in range(len(paulis)):
circ, p = error.error_term(j)
name = circ[0]['name']
self.assertIn(name, ('unitary', 'id'))
self.assertEqual(circ[0]['qubits'], [0])
self.remove_if_found(p, target_probs)
if name == "unitary":
self.remove_if_found(circ[0]['params'][0], target_unitaries)
else:
target_identity_count += 1
self.assertEqual(target_probs, [], msg="Incorrect probabilities")
self.assertEqual(target_unitaries, [], msg="Incorrect unitaries")
self.assertEqual(target_identity_count, 1, msg="Incorrect identities")
def test_pauli_error_1q_gate_from_string(self):
"""Test single-qubit pauli error as gate qobj from string label"""
paulis = ['I', 'X', 'Y', 'Z']
probs = [0.4, 0.3, 0.2, 0.1]
error = pauli_error(zip(paulis, probs), standard_gates=True)
target_circs = [[{
"name": "id",
"qubits": [0]
}], [{
"name": "x",
"qubits": [0]
}], [{
"name": "y",
"qubits": [0]
}], [{
"name": "z",
"qubits": [0]
}]]
target_probs = probs.copy()
for j in range(len(paulis)):
circ, p = error.error_term(j)
self.remove_if_found(p, target_probs)
self.remove_if_found(circ, target_circs)
self.assertEqual(target_probs, [], msg="Incorrect probabilities")
self.assertEqual(target_circs, [], msg="Incorrect circuits")
def test_nonlocal_pauli_error_gate_25percent(self):
"""Test 100% non-local Pauli error on cx(0, 1) gate"""
qr = QuantumRegister(3, 'qr')
cr = ClassicalRegister(3, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.cx(qr[0], qr[1])
circuit.barrier(qr)
circuit.cx(qr[1], qr[0])
circuit.barrier(qr)
circuit.measure(qr, cr)
backend = QasmSimulator()
shots = 1000
# test noise model
error = pauli_error([('XII', 0.25), ('III', 0.75)])
noise_model = NoiseModel()
noise_model.add_nonlocal_quantum_error(error, 'cx', [0, 1], [0, 1, 2])
# Execute
target = {'0x0': 3 * shots / 4, '0x4': shots / 4}
qobj = compile([circuit],
backend,
shots=shots,
basis_gates=noise_model.basis_gates)
result = backend.run(qobj, noise_model=noise_model).result()
self.is_completed(result)
self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
def test_all_qubit_pauli_error_reset_25percent(self):
"""Test 25% Pauli-X error on reset"""
qr = QuantumRegister(2, 'qr')
cr = ClassicalRegister(2, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.reset(qr)
circuit.barrier(qr)
circuit.measure(qr, cr)
backend = QasmSimulator()
shots = 2000
# test noise model
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'measure')
# Execute
target = {
'0x0': 9 * shots / 16,
'0x1': 3 * shots / 16,
'0x2': 3 * shots / 16,
'0x3': shots / 16
}
qobj = compile([circuit],
backend,
shots=shots,
basis_gates=noise_model.basis_gates)
result = backend.run(qobj, noise_model=noise_model).result()
self.is_completed(result)
self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
def test_clifford(self):
x_p = 0.17
y_p = 0.13
z_p = 0.34
error = pauli_error([('X', x_p), ('Y', y_p), ('Z', z_p),
('I', 1 - (x_p + y_p + z_p))])
results = approximate_quantum_error(error, operator_string="clifford")
self.assertErrorsAlmostEqual(error, results)
def test_paulis_1_and_2_qubits(self):
probs = [0.5, 0.3, 0.2]
paulis_1q = ['X', 'Y', 'Z']
paulis_2q = ['XI', 'YI', 'ZI']
error_1q = pauli_error(zip(paulis_1q, probs))
error_2q = pauli_error(zip(paulis_2q, probs))
results_1q = approximate_quantum_error(error_1q, operator_string="pauli")
results_2q = approximate_quantum_error(error_2q, operator_string="pauli")
self.assertErrorsAlmostEqual(error_1q, results_1q)
self.assertErrorsAlmostEqual(error_2q, results_2q, places = 2)
paulis_2q = ['XY', 'ZZ', 'YI']
error_2q = pauli_error(zip(paulis_2q, probs))
results_2q = approximate_quantum_error(error_2q, operator_string="pauli")
self.assertErrorsAlmostEqual(error_2q, results_2q, places=2)
def test_noise_models_not_equal(self):
"""Test two noise models are not equal"""
error = pauli_error([['X', 1]])
model1 = NoiseModel()
model1.add_all_qubit_quantum_error(error, ['u3'], False)
model2 = NoiseModel(basis_gates=['u3', 'cx'])
model2.add_all_qubit_quantum_error(error, ['u3'], False)
def test_noise_models_equal(self):
"""Test two noise models are Equal"""
roerror = [[0.9, 0.1], [0.5, 0.5]]
error1 = pauli_error([['X', 1]], standard_gates=False)
error2 = pauli_error([['X', 1]], standard_gates=True)
model1 = NoiseModel()
model1.add_all_qubit_quantum_error(error1, ['u3'], False)
model1.add_quantum_error(error1, ['u3'], [2], False)
model1.add_nonlocal_quantum_error(error1, ['cx'], [0, 1], [3], False)
model1.add_all_qubit_readout_error(roerror, False)
model1.add_readout_error(roerror, [0], False)
model2 = NoiseModel()
model2.add_all_qubit_quantum_error(error2, ['u3'], False)
model2.add_quantum_error(error2, ['u3'], [2], False)
model2.add_nonlocal_quantum_error(error2, ['cx'], [0, 1], [3], False)
model2.add_all_qubit_readout_error(roerror, False)
model2.add_readout_error(roerror, [0], False)
self.assertEqual(model1, model2)
def test_pauli_error_1q_gate_from_string(self):
"""Test single-qubit pauli error as gate qobj from string label"""
paulis = ['I', 'X', 'Y', 'Z']
probs = [0.4, 0.3, 0.2, 0.1]
actual = pauli_error(zip(paulis, probs))
expected = QuantumError([(IGate(), 0.4), (XGate(), 0.3), (YGate(), 0.2), (ZGate(), 0.1)])
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ, msg=f"Incorrect {i}-th circuit")
self.assertAlmostEqual(prob, expected_prob, msg=f"Incorrect {i}-th probability")
def test_transpiling(self):
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.x(qr[0])
circuit.y(qr[1])
circuit.z(qr[2])
error_x = pauli_error([('Y', 0.25), ('I', 0.75)])
error_y = pauli_error([('X', 0.35), ('Z', 0.65)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error_x, 'x')
noise_model.add_all_qubit_quantum_error(error_y, 'u1')
target_circuit = QuantumCircuit(qr)
target_circuit.x(qr[0])
target_circuit.append(error_x.to_instruction(), [qr[0]])
target_circuit.u3(pi, pi / 2, pi / 2, qr[1])
target_circuit.u1(pi, qr[2])
target_circuit.append(error_y.to_instruction(), [qr[2]])
result_circuit = insert_noise(circuit, noise_model, transpile=True)
self.assertEqual(target_circuit, result_circuit)
def test_noise_model_noise_qubits(self):
"""Test noise instructions"""
model = NoiseModel()
target = []
self.assertEqual(model.noise_qubits, target)
# Check adding a default error isn't added to noise qubits
model = NoiseModel()
model.add_all_qubit_quantum_error(pauli_error([['XX', 1]]), ['label'],
False)
target = []
self.assertEqual(model.noise_qubits, target)
# Check adding a local error adds to noise qubits
model = NoiseModel()
model.add_quantum_error(pauli_error([['XX', 1]]), ['label'], [1, 0],
False)
target = sorted([0, 1])
self.assertEqual(model.noise_qubits, target)
# Check adding a non-local error adds to noise qubits
model = NoiseModel()
with self.assertWarns(DeprecationWarning):
model.add_nonlocal_quantum_error(pauli_error([['XX', 1]]),
['label'], [0], [1, 2], False)
target = sorted([0, 1, 2])
self.assertEqual(model.noise_qubits, target)
# Check adding a default error isn't added to noise qubits
model = NoiseModel()
model.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]], False)
target = []
self.assertEqual(model.noise_qubits, target)
# Check adding a local error adds to noise qubits
model = NoiseModel()
model.add_readout_error([[0.9, 0.1], [0, 1]], [2], False)
target = [2]
self.assertEqual(model.noise_qubits, target)
def test_transpiling(self):
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.x(qr[0])
circuit.y(qr[1])
circuit.z(qr[2])
error_x = pauli_error([('Y', 0.25), ('I', 0.75)])
error_y = pauli_error([('X', 0.35), ('Z', 0.65)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error_x, 'x')
noise_model.add_all_qubit_quantum_error(error_y, 'y')
target_circuit = QuantumCircuit(qr)
target_circuit.x(qr[0])
target_circuit.append(error_x.to_instruction(), [qr[0]])
target_circuit.y(qr[1])
target_circuit.append(error_y.to_instruction(), [qr[1]])
target_circuit.z(qr[2])
target_basis = ['kraus'] + noise_model.basis_gates
target_circuit = transpile(target_circuit, basis_gates=target_basis)
result_circuit = insert_noise(circuit, noise_model, transpile=True)
self.assertEqual(SuperOp(target_circuit), SuperOp(result_circuit))
def test_pauli_error_2q_gate_from_pauli(self):
"""Test two-qubit pauli error as gate qobj from Pauli obj"""
paulis = [qi.Pauli(s) for s in ['XZ', 'YX', 'ZY']]
probs = [0.5, 0.3, 0.2]
actual = pauli_error(zip(paulis, probs))
expected = QuantumError(
[(PauliGate("XZ"), 0.5), (PauliGate("YX"), 0.3), (PauliGate("ZY"), 0.2)]
)
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ, msg=f"Incorrect {i}-th circuit")
self.assertAlmostEqual(prob, expected_prob, msg=f"Incorrect {i}-th probability")
def pauli_measure_error_noise_models():
"""Local Pauli measure error noise models"""
noise_models = []
# 25% all-qubit Pauli error on measure
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'measure')
noise_models.append(noise_model)
# 25% local Pauli error on measure of qubit 1
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_quantum_error(error, 'measure', [1])
noise_models.append(noise_model)
# 25 % non-local Pauli error on qubit 1 for measure of qubit-1
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_nonlocal_quantum_error(error, 'measure', [0], [1])
noise_models.append(noise_model)
return noise_models
def test_local_quantum_errors(self):
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.x(qr[0])
circuit.x(qr[1])
circuit.y(qr[2])
error_x = pauli_error([('Y', 0.25), ('I', 0.75)])
error_y = pauli_error([('X', 0.35), ('Z', 0.65)])
noise_model = NoiseModel()
noise_model.add_quantum_error(error_x, 'x', [0])
noise_model.add_quantum_error(error_y, 'y', [2])
target_circuit = QuantumCircuit(qr)
target_circuit.x(qr[0])
target_circuit.append(error_x.to_instruction(), [qr[0]])
target_circuit.x(qr[1])
target_circuit.y(qr[2])
target_circuit.append(error_y.to_instruction(), [qr[2]])
result_circuit = insert_noise(circuit, noise_model)
self.assertEqual(target_circuit, result_circuit)
def pauli_reset_error_noise_models():
"""Local Pauli reset error noise models"""
noise_models = []
# 25% all-qubit Pauli error on reset
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'reset')
noise_models.append(noise_model)
# 25% local Pauli error on reset of qubit 1
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_quantum_error(error, 'reset', [1])
noise_models.append(noise_model)
# 25 % non-local Pauli error on qubit 1 for reset of qubit-0
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_nonlocal_quantum_error(error, 'reset', [0], [1])
noise_models.append(noise_model)
return noise_models
def tensored_calib_circ_execution(shots: int, seed: int):
"""
create tensored measurement calibration circuits and simulates them with noise
Args:
shots (int): number of shots per simulation
seed (int): the seed to use in the simulations
Returns:
list: list of Results of the measurement calibration simulations
list: the mitigation pattern
dict: dictionary of results counts of bell circuit simulation with measurement errors
"""
# define the circuits
qr = qiskit.QuantumRegister(5)
mit_pattern = [[2], [4, 1]]
meas_calibs, mit_pattern = tensored_meas_cal(mit_pattern=mit_pattern,
qr=qr,
circlabel='test')
# define noise
prob = 0.2
error_meas = pauli_error([('X', prob), ('I', 1 - prob)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error_meas, "measure")
# run the circuits multiple times
backend = qiskit.Aer.get_backend('qasm_simulator')
cal_results = qiskit.execute(meas_calibs,
backend=backend,
shots=shots,
noise_model=noise_model,
seed_simulator=seed).result()
# create bell state and get it's results
cr = qiskit.ClassicalRegister(3)
qc = qiskit.QuantumCircuit(qr, cr)
qc.h(qr[2])
qc.cx(qr[2], qr[4])
qc.cx(qr[2], qr[1])
qc.measure(qr[2], cr[0])
qc.measure(qr[4], cr[1])
qc.measure(qr[1], cr[2])
bell_results = qiskit.execute(qc,
backend=backend,
shots=shots,
noise_model=noise_model,
seed_simulator=seed).result()
return cal_results, mit_pattern, bell_results
def test_pauli_error_1q_unitary_from_pauli(self):
"""Test single-qubit pauli error as unitary qobj from Pauli obj"""
from qiskit.extensions import UnitaryGate
paulis = [qi.Pauli(s) for s in ['I', 'X', 'Y', 'Z']]
probs = [0.4, 0.3, 0.2, 0.1]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=False)
target_unitaries = [qi.Pauli("I").to_matrix(),
qi.Pauli("X").to_matrix(),
qi.Pauli("Y").to_matrix(),
qi.Pauli("Z").to_matrix()]
expected = QuantumError([(UnitaryGate(mat), p) for mat, p in zip(target_unitaries, probs)])
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ)
self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_2q_unitary_from_pauli(self):
"""Test two-qubit pauli error as unitary qobj from Pauli obj"""
from qiskit.extensions import UnitaryGate
paulis = [qi.Pauli(s) for s in ['XY', 'YZ', 'ZX']]
probs = [0.5, 0.3, 0.2]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=False)
X = qi.Pauli("X").to_matrix()
Y = qi.Pauli("Y").to_matrix()
Z = qi.Pauli("Z").to_matrix()
target_unitaries = [np.kron(X, Y), np.kron(Y, Z), np.kron(Z, X)]
expected = QuantumError([(UnitaryGate(mat), p) for mat, p in zip(target_unitaries, probs)])
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ)
self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_2q_gate_from_pauli(self):
"""Test two-qubit pauli error as gate qobj from Pauli obj"""
paulis = [qi.Pauli(s) for s in ['XZ', 'YX', 'ZY']]
probs = [0.5, 0.3, 0.2]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=True)
target_circs = [[{"name": "z", "qubits": [0]}, {"name": "x", "qubits": [1]}],
[{"name": "x", "qubits": [0]}, {"name": "y", "qubits": [1]}],
[{"name": "y", "qubits": [0]}, {"name": "z", "qubits": [1]}]]
with self.assertWarns(DeprecationWarning):
expected = QuantumError(zip(target_circs, probs), standard_gates=True)
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ)
self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_2q_gate_from_string_1qonly(self):
"""Test two-qubit pauli error as gate qobj from string label"""
paulis = ['XI', 'YI', 'ZI']
probs = [0.5, 0.3, 0.2]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=True)
target_circs = [[{"name": "id", "qubits": [0]}, {"name": "x", "qubits": [1]}],
[{"name": "id", "qubits": [0]}, {"name": "y", "qubits": [1]}],
[{"name": "id", "qubits": [0]}, {"name": "z", "qubits": [1]}]]
with self.assertWarns(DeprecationWarning):
expected = QuantumError(zip(target_circs, probs), standard_gates=True)
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertTrue(qi.Operator(circ).equiv(qi.Operator(expected_circ)))
self.assertAlmostEqual(prob, expected_prob)
def meas_calibration_circ_execution(nqunits: int, shots: int, seed: int):
"""
create measurement calibration circuits and simulates them with noise
Args:
nqunits (int): number of qubits to run the measurement calibration on
shots (int): number of shots per simulation
seed (int): the seed to use in the simulations
Returns:
list: list of Results of the measurement calibration simulations
list: list of all the possible states with this amount of qubits
dict: dictionary of results counts of bell circuit simulation with measurement errors
"""
# define the circuits
qr = qiskit.QuantumRegister(nqunits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='test')
# define noise
prob = 0.2
error_meas = pauli_error([('X', prob), ('I', 1 - prob)])
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error_meas, "measure")
# run the circuits multiple times
backend = qiskit.Aer.get_backend('qasm_simulator')
cal_results = qiskit.execute(meas_calibs,
backend=backend,
shots=shots,
noise_model=noise_model,
seed_simulator=seed).result()
# create bell state and get it's results
qc = qiskit.QuantumCircuit(nqunits, nqunits)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.measure(qc.qregs[0], qc.cregs[0])
bell_results = qiskit.execute(qc,
backend=backend,
shots=shots,
noise_model=noise_model,
seed_simulator=seed).result().get_counts()
return cal_results, state_labels, bell_results
def test_pauli_error_2q_unitary_from_string_1q_only(self):
"""Test two-qubit pauli error as unitary qobj from string label"""
paulis = ['XI', 'YI', 'ZI']
probs = [0.5, 0.3, 0.2]
error = pauli_error(zip(paulis, probs), standard_gates=False)
target_unitaries = [standard_gate_unitary('x'),
standard_gate_unitary('y'),
standard_gate_unitary('z')]
target_probs = probs.copy()
for j in range(len(paulis)):
circ, p = error.error_term(j)
name = circ[0]['name']
self.assertIn(name, 'unitary')
self.assertEqual(circ[0]['qubits'], [1])
self.remove_if_found(p, target_probs)
self.remove_if_found(circ[0]['params'], target_unitaries)
self.assertEqual(target_probs, [], msg="Incorrect probabilities")
self.assertEqual(target_unitaries, [], msg="Incorrect unitaries")
def test_nonlocal_quantum_errors(self):
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.x(qr[0])
circuit.x(qr[2])
error_x = pauli_error([('Y', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
with self.assertWarns(DeprecationWarning):
noise_model.add_nonlocal_quantum_error(error_x, 'x', [0], [1])
target_circuit = QuantumCircuit(qr)
target_circuit.x(qr[0])
target_circuit.append(error_x.to_instruction(), [qr[1]])
target_circuit.x(qr[2])
result_circuit = insert_noise(circuit, noise_model)
self.assertEqual(SuperOp(target_circuit), SuperOp(result_circuit))
def test_specific_qubit_pauli_error_measure_25percent(self):
"""Test 25% Pauli-X error on measure of qubit-1"""
qr = QuantumRegister(2, 'qr')
cr = ClassicalRegister(2, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.measure(qr, cr)
backend = QasmSimulator()
shots = 2000
# test noise model
error = pauli_error([('X', 0.25), ('I', 0.75)])
noise_model = NoiseModel()
noise_model.add_quantum_error(error, 'measure', [1])
# Execute
target = {'0x0': 3 * shots / 4, '0x2': shots / 4}
circuit = transpile(circuit, basis_gates=noise_model.basis_gates)
qobj = assemble([circuit], backend, shots=shots)
result = backend.run(qobj, noise_model=noise_model).result()
self.is_completed(result)
self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
