def test_noise_model_basis_gates(self): """Test noise model basis_gates""" basis_gates = ['u1', 'u2', 'u3', 'cx'] model = NoiseModel(basis_gates) target = sorted(basis_gates) self.assertEqual(model.basis_gates, target) # Check adding readout errors doesn't add to basis gates model = NoiseModel(basis_gates) target = sorted(basis_gates) model.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]], False) self.assertEqual(model.basis_gates, target) model.add_readout_error([[0.9, 0.1], [0, 1]], [2], False) self.assertEqual(model.basis_gates, target) # Check a reset instruction error isn't added to basis gates model = NoiseModel(basis_gates) target = sorted(basis_gates) model.add_all_qubit_quantum_error(reset_error(0.2), ['reset'], False) self.assertEqual(model.basis_gates, target) # Check a non-standard gate isn't added to basis gates model = NoiseModel(basis_gates) target = sorted(basis_gates) model.add_all_qubit_quantum_error(reset_error(0.2), ['label'], False) self.assertEqual(model.basis_gates, target) # Check a standard gate is added to basis gates model = NoiseModel(basis_gates) target = sorted(basis_gates + ['h']) model.add_all_qubit_quantum_error(reset_error(0.2), ['h'], False) self.assertEqual(model.basis_gates, target)
def test_reduce_noise_model(self): """Test reduction mapping of noise model.""" error1 = depolarizing_error(0.5, 1) error2 = depolarizing_error(0.5, 2) roerror1 = [[0.9, 0.1], [0.5, 0.5]] roerror2 = [[0.8, 0.2, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0.1, 0.9]] model = NoiseModel() model.add_all_qubit_quantum_error(error1, ['u3'], False) model.add_quantum_error(error1, ['u3'], [1], False) with self.assertWarns(DeprecationWarning): model.add_nonlocal_quantum_error(error2, ['cx'], [2, 0], [3, 1], False) model.add_all_qubit_readout_error(roerror1, False) model.add_readout_error(roerror2, [0, 2], False) remapped_model = remap_noise_model(model, [0, 1, 2], discard_qubits=True, warnings=False) target = NoiseModel() target.add_all_qubit_quantum_error(error1, ['u3'], False) target.add_quantum_error(error1, ['u3'], [1], False) target.add_all_qubit_readout_error(roerror1, False) target.add_readout_error(roerror2, [0, 2], False) self.assertEqual(remapped_model, target)
def noise_model_depolarizing(error, measure=True, thermal=True): """ Creates error for depolarizing channel :param error: Probability of depolarizing channel :param measure: True or False, whether we include readout errors with probability 10 * error :param thermal: True or False, whether we include thermal relaxation, see noise_model_thermal :return: noise model for the error """ noise_model = NoiseModel() depolarizing = depolarizing_error(error, 1) cdepol_error = depolarizing_error(2 * error, 2) noise_model.add_all_qubit_quantum_error(cdepol_error, ['cx'], warnings=False) noise_model.add_all_qubit_quantum_error(depolarizing, ["u1", "u2", "u3"]) if measure: measure_error = 10 * error measure_error = array([[1 - measure_error, measure_error], [measure_error, 1 - measure_error]]) noise_model.add_all_qubit_readout_error(measure_error) if thermal: thermal = thermal_relaxation_error(1.5, 1.2, error) cthermal = thermal_relaxation_error(1.5, 1.2, 2 * error) cthermal = cthermal.tensor(cthermal) noise_model.add_all_qubit_quantum_error(cthermal, ['cx'], warnings=False) noise_model.add_all_qubit_quantum_error(thermal, ["u1", "u2", "u3"], warnings=False) return noise_model
def test_measure_sampling_with_quantum_noise(self): """Test QasmSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() depolarizing = {'u3': (1, 0.001), 'cx': (2, 0.02)} readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) for gate, (num_qubits, gate_error) in depolarizing.items(): noise_model.add_all_qubit_quantum_error( depolarizing_error(gate_error, num_qubits), gate) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, noise_model=noise_model, backend_options=self.BACKEND_OPTS).result() self.assertTrue(getattr(result, 'success', False)) sampling = (self.BACKEND_OPTS.get( "method", "automatic").startswith("density_matrix")) self.compare_result_metadata(result, circuits, "measure_sampling", sampling)
def test_noise_model_noise_instructions(self): """Test noise instructions""" model = NoiseModel() target = [] self.assertEqual(model.noise_instructions, target) # Check a non-standard gate is added to noise instructions model = NoiseModel() model.add_all_qubit_quantum_error(reset_error(0.2), ['label'], False) target = ['label'] self.assertEqual(model.noise_instructions, target) # Check a standard gate is added to noise instructions model = NoiseModel() model.add_all_qubit_quantum_error(reset_error(0.2), ['h'], False) target = ['h'] self.assertEqual(model.noise_instructions, target) # Check a reset is added to noise instructions model = NoiseModel() model.add_all_qubit_quantum_error(reset_error(0.2), ['reset'], False) target = ['reset'] self.assertEqual(model.noise_instructions, target) # Check a measure is added to noise instructions for readout error model = NoiseModel() model.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]], False) target = ['measure'] self.assertEqual(model.noise_instructions, target)
def readout_error_noise_models(): """Readout error test circuit noise models.""" noise_models = [] # 1-qubit readout error on qubit 0 noise_model = NoiseModel() noise_model.add_readout_error(ROERROR_1Q, [0]) noise_models.append(noise_model) # 1-qubit readout error on qubit 1 noise_model = NoiseModel() noise_model.add_readout_error(ROERROR_1Q, [1]) noise_models.append(noise_model) # 1-qubit readout error on qubit 1 noise_model = NoiseModel() noise_model.add_all_qubit_readout_error(ROERROR_1Q) noise_models.append(noise_model) # 2-qubit readout error on qubits 0,1 noise_model = NoiseModel() noise_model.add_readout_error(ROERROR_2Q, [0, 1]) noise_models.append(noise_model) return noise_models
def test_readout_error_all_qubit(self): """Test 100% readout error on all qubits""" # Test circuit: ideal bell state qr = QuantumRegister(2, 'qr') cr = ClassicalRegister(2, 'cr') circuit = QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) # Ensure qubit 0 is measured before qubit 1 circuit.barrier(qr) circuit.measure(qr[0], cr[0]) circuit.barrier(qr) circuit.measure(qr[1], cr[1]) backend = QasmSimulator() # Asymetric readout error on qubit-0 only probs_given0 = [0.9, 0.1] probs_given1 = [0.3, 0.7] noise_model = NoiseModel() noise_model.add_all_qubit_readout_error([probs_given0, probs_given1]) # Expected counts shots = 2000 p00 = 0.5 * (probs_given0[0] ** 2 + probs_given1[0] ** 2) p01 = 0.5 * (probs_given0[0] * probs_given0[1] + probs_given1[0] * probs_given1[1]) p10 = 0.5 * (probs_given0[0] * probs_given0[1] + probs_given1[0] * probs_given1[1]) p11 = 0.5 * (probs_given0[1] ** 2 + probs_given1[1] ** 2) target = target = {'0x0': p00 * shots, '0x1': p01 * shots, '0x2': p10 * shots, '0x3': p11 * shots} 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 get_data_point(circ, theta, phi, lam, readout_params, depol_param, thermal_params, shots): """Generate a dict datapoint with the given circuit and noise parameters""" U3_gate_length = 7.111111111111112e-08 # extract parameters (p0_0, p1_0), (p0_1, p1_1) = readout_params depol_prob = depol_param t1, t2, population = thermal_params # Add Readout and Quantum Errors noise_model = NoiseModel() noise_model.add_all_qubit_readout_error(ReadoutError(readout_params)) noise_model.add_all_qubit_quantum_error(depolarizing_error(depol_param, 1), 'u3', warnings=False) noise_model.add_all_qubit_quantum_error( thermal_relaxation_error(t1, t2, U3_gate_length, excited_state_population=population), 'u3', warnings=False) job = execute(circ, QasmSimulator(), shots=shots, noise_model=noise_model) result = job.result() # add data point to DataFrame data_point = {'theta': theta, 'phi': phi, 'lam': lam, 'p0_0': p0_0, 'p1_0': p1_0, 'p0_1': p0_1, 'p1_1': p1_1, 'depol_prob': depol_prob, 't1': t1, 't2': t2, 'population': population, 'E': result.get_counts(0).get('1', 0) / shots} return data_point
def test_measure_sampling_with_quantum_noise(self): """Test QasmSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() depolarizing = {'u3': (1, 0.001), 'cx': (2, 0.02)} readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) for gate, (num_qubits, gate_error) in depolarizing.items(): noise_model.add_all_qubit_quantum_error( depolarizing_error(gate_error, num_qubits), gate) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, noise_model=noise_model, backend_options=self.BACKEND_OPTS).result() self.is_completed(result) for res in result.results: self.assertIn("measure_sampling", res.metadata) self.assertEqual(res.metadata["measure_sampling"], False) # Test sampling was disabled for res in result.results: self.assertIn("measure_sampling", res.metadata) self.assertEqual(res.metadata["measure_sampling"], False)
def create_high_noise_model(): """ create high noise model with depolarizing error, thermal error and readout error Returns: NoiseModel: noise model """ noise_model = NoiseModel() p1q = 0.004 p2q = 0.05 depol_sx = depolarizing_error(p1q, 1) depol_x = depolarizing_error(p1q, 1) depol_cx = depolarizing_error(p2q, 2) # Add T1/T2 noise to the simulation t_1 = 110e2 t_2 = 120e2 gate1q = 50 gate2q = 100 termal_sx = thermal_relaxation_error(t_1, t_2, gate1q) termal_x = thermal_relaxation_error(t_1, t_2, gate1q) termal_cx = thermal_relaxation_error(t_1, t_2, gate2q).tensor( thermal_relaxation_error(t_1, t_2, gate2q) ) noise_model.add_all_qubit_quantum_error(depol_sx.compose(termal_sx), "sx") noise_model.add_all_qubit_quantum_error(depol_x.compose(termal_x), "x") noise_model.add_all_qubit_quantum_error(depol_cx.compose(termal_cx), "cx") read_err = readout_error.ReadoutError([[0.98, 0.02], [0.04, 0.96]]) noise_model.add_all_qubit_readout_error(read_err) return noise_model
def noise_model_phase(error, measure=True, thermal=True): """ Creates error for phase flip :param error: Probability of happening a phaseflip :param measure: True or False, whether we include readout errors with probability 10 * error :param thermal: True or False, whether we include thermal relaxation, see noise_model_thermal :return: noise model for the error """ noise_model = NoiseModel() #basis_gates=['id', 'u2', 'u3', 'cx']) phase_error = error cz_error = 2 * error phase_flip = pauli_error([('Z', phase_error), ('I', 1 - phase_error)]) cz_error = pauli_error([('Z', cz_error), ('I', 1 - cz_error)]) cz_error = cz_error.tensor(cz_error) noise_model.add_all_qubit_quantum_error(cz_error, ['cx'], warnings=False) noise_model.add_all_qubit_quantum_error(phase_flip, ["u1", "u2", "u3"]) if measure: measure_error = 10 * error measure_error = array([[1 - measure_error, measure_error], [measure_error, 1 - measure_error]]) noise_model.add_all_qubit_readout_error(measure_error) if thermal: thermal = thermal_relaxation_error(1.5, 1.2, error) cthermal = thermal_relaxation_error(1.5, 1.2, 2 * error) cthermal = cthermal.tensor(cthermal) noise_model.add_all_qubit_quantum_error(cthermal, ['cx'], warnings=False) noise_model.add_all_qubit_quantum_error(thermal, ["u1", "u2", "u3"], warnings=False) return noise_model
def noise_model_bit(error, measure=True, thermal=True): """ Creates error for bit flip :param error: Probability of happening a bitflip :param measure: True or False, whether we include readout errors with probability 10 * error :param thermal: True or False, whether we include thermal relaxation, see noise_model_thermal :return: noise model for the error """ noise_model = NoiseModel() flip_error = error cnot_error = 2 * error bit_flip = pauli_error([('X', flip_error), ('I', 1 - flip_error)]) cnot_flip = pauli_error([('X', cnot_error), ('I', 1 - cnot_error)]) cnot_error = cnot_flip.tensor(cnot_flip) noise_model.add_all_qubit_quantum_error(bit_flip, ["u1", "u2", "u3"]) noise_model.add_all_qubit_quantum_error(cnot_error, ['cx'], warnings=False) if measure: measure_error = 10 * error measure_error = array([[1 - measure_error, measure_error], [measure_error, 1 - measure_error]]) noise_model.add_all_qubit_readout_error(measure_error) if thermal: thermal = thermal_relaxation_error(1.5, 1.2, error) cthermal = thermal_relaxation_error(1.5, 1.2, 2 * error) cthermal = cthermal.tensor(cthermal) noise_model.add_all_qubit_quantum_error(cthermal, ['cx'], warnings=False) noise_model.add_all_qubit_quantum_error(thermal, ["u1", "u2", "u3"], warnings=False) return noise_model
def test_remap_all_qubit_readout_errors(self): """Test remapping of all-qubit readout errors.""" model = NoiseModel() error1 = [[0.9, 0.1], [0.5, 0.5]] model.add_all_qubit_readout_error(error1, False) remapped_model = remap_noise_model(model, [[0, 1], [1, 2], [2, 0]], warnings=False) self.assertEqual(remapped_model, model)
def noise_model(self): readout_error = [0.01, 0.1] depolarizing = {'u3': (1, 0.001), 'cx': (2, 0.02)} noise = NoiseModel() readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise.add_all_qubit_readout_error(ReadoutError(readout)) for gate, (num_qubits, gate_error) in depolarizing.items(): noise.add_all_qubit_quantum_error( depolarizing_error(gate_error, num_qubits), gate) return noise
def noise_model_kraus(self): """ Creates a new noise model for testing purposes """ readout_error = [0.01, 0.1] params = {'u3': (1, 0.001), 'cx': (2, 0.02)} noise = NoiseModel() readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise.add_all_qubit_readout_error(ReadoutError(readout)) for gate, (num_qubits, gate_error) in params.items(): noise.add_all_qubit_quantum_error( amplitude_damping_error(gate_error, num_qubits), gate) return noise
def noise_model_measure(error, measure=True, thermal=True): """ Creates errors for readout :param error: Probability of occuring a readout error / 10. This factor is added to maintain comparability with the rest of the code :return: noise model for the error """ noise_model = NoiseModel() measure_error = 10 * error measure_error = array([[1 - measure_error, measure_error], [measure_error, 1 - measure_error]]) noise_model.add_all_qubit_readout_error(measure_error) return noise_model
def get_data_point(theta, phi, lam, readout_params, depol_param, thermal_params, shots): """Generate a dict datapoint with the given circuit and noise parameters""" U3_gate_length = 7.111111111111112e-08 circ = QuantumCircuit(1, 1) circ.append(U3Gate(theta, phi, lam), [0]) circ.measure(0, 0) new_circ = qiskit.compiler.transpile(circ, basis_gates=['u3'], optimization_level=0) # extract parameters (p0_0, p1_0), (p0_1, p1_1) = readout_params depol_prob = depol_param t1, t2, population = thermal_params noise_model = NoiseModel() # Add Readout and Quantum Errors noise_model.add_all_qubit_readout_error(ReadoutError(readout_params)) noise_model.add_all_qubit_quantum_error(depolarizing_error(depol_param, 1), 'u3', warnings=False) noise_model.add_all_qubit_quantum_error(thermal_relaxation_error( t1, t2, U3_gate_length, population), 'u3', warnings=False) job = execute(circ, QasmSimulator(), shots=shots, noise_model=noise_model) result = job.result() # add data point to DataFrame data_point = { 'theta': theta, 'phi': phi, 'lam': lam, 'p0_0': p0_0, 'p1_0': p1_0, 'p0_1': p0_1, 'p1_1': p1_1, 'depol_prob': depol_prob, 't1': t1, 't2': t2, 'population': population, 'E': result.get_counts(0).get('0', 0) / shots } return data_point
def test_measure_sampling_with_readouterror(self): """Test QasmSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run(qobj, noise_model=noise_model, **self.BACKEND_OPTS).result() self.assertSuccess(result)
def test_measure_sampling_with_readouterror(self, method, device): """Test AerSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) backend = self.backend(method=method, device=device, noise_model=noise_model) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) result = backend.run(circuits, shots=shots).result() self.assertSuccess(result) self.compare_result_metadata(result, circuits, "measure_sampling", True)
def test_transform_noise(self): org_error = reset_error(0.2) new_error = pauli_error([("I", 0.5), ("Z", 0.5)]) model = NoiseModel() model.add_all_qubit_quantum_error(org_error, ['x']) model.add_quantum_error(org_error, ['sx'], [0]) model.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]]) def map_func(noise): return new_error if noise == org_error else None actual = transform_noise_model(model, map_func) expected = NoiseModel() expected.add_all_qubit_quantum_error(new_error, ['x']) expected.add_quantum_error(new_error, ['sx'], [0]) expected.add_all_qubit_readout_error([[0.9, 0.1], [0, 1]]) self.assertEqual(actual, expected)
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_measure_sampling_with_quantum_noise(self): """Test QasmSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() depolarizing = {'u3': (1, 0.001), 'cx': (2, 0.02)} readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) for gate, (num_qubits, gate_error) in depolarizing.items(): noise_model.add_all_qubit_quantum_error( depolarizing_error(gate_error, num_qubits), gate) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run(qobj, noise_model=noise_model, **self.BACKEND_OPTS).result() self.assertSuccess(result)
def noise_model_thermal(error, measure=False, thermal=False): """ Creates error for thermal relaxation for T1, T2 = 1.5, 1.2 :param error: time of gate. Normalized to be equal to the error in all other functions :param measure: True or False, whether we include readout errors with probability 10 * error :return: noise model for the error """ noise_model = NoiseModel() thermal = thermal_relaxation_error(1.5, 1.2, error) cthermal = thermal_relaxation_error(1.5, 1.2, 2 * error) cthermal = cthermal.tensor(cthermal) noise_model.add_all_qubit_quantum_error(cthermal, ['cx'], warnings=False) noise_model.add_all_qubit_quantum_error(thermal, ["u1", "u2", "u3"]) if measure: measure_error = 10 * error measure_error = array([[1 - measure_error, measure_error], [measure_error, 1 - measure_error]]) noise_model.add_all_qubit_readout_error(measure_error) return noise_model
def test_measure_sampling_with_readouterror(self): """Test QasmSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, noise_model=noise_model, backend_options=self.BACKEND_OPTS).result() self.is_completed(result) # Test sampling was disabled for res in result.results: self.assertIn("measure_sampling", res.metadata) self.assertEqual(res.metadata["measure_sampling"], True)
def test_noise_models_equal(self): """Test two noise models are Equal""" roerror = [[0.9, 0.1], [0.5, 0.5]] error1 = kraus_error([np.diag([1, 0]), np.diag([0, 1])]) error2 = pauli_error([("I", 0.5), ("Z", 0.5)]) model1 = NoiseModel() model1.add_all_qubit_quantum_error(error1, ['u3'], False) model1.add_quantum_error(error1, ['u3'], [2], False) with self.assertWarns(DeprecationWarning): 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) with self.assertWarns(DeprecationWarning): 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_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_measure_sampling_with_quantum_noise(self, method, device): """Test AerSimulator measure with deterministic counts with sampling and readout-error""" readout_error = [0.01, 0.1] noise_model = NoiseModel() depolarizing = {'u3': (1, 0.001), 'cx': (2, 0.02)} readout = [[1.0 - readout_error[0], readout_error[0]], [readout_error[1], 1.0 - readout_error[1]]] noise_model.add_all_qubit_readout_error(ReadoutError(readout)) for gate, (num_qubits, gate_error) in depolarizing.items(): noise_model.add_all_qubit_quantum_error( depolarizing_error(gate_error, num_qubits), gate) backend = self.backend(method=method, device=device, noise_model=noise_model) shots = 1000 circuits = ref_measure.measure_circuits_deterministic( allow_sampling=True) targets = ref_measure.measure_counts_deterministic(shots) result = backend.run(circuits, shots=shots).result() self.assertSuccess(result) sampling = (method == "density_matrix") self.compare_result_metadata(result, circuits, "measure_sampling", sampling)