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