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)