def get_quantum_error(dim):
error_param = 0.1 # damping parameter
# Construct the error
i_error = errors.amplitude_damping_error(error_param)
for i in range(dim - 1):
i_error = i_error.tensor(errors.amplitude_damping_error(error_param))
return i_error
def test_backend_method_nonclifford_circuit_and_kraus_noise(self):
"""Test statevector method is used for Clifford circuit"""
# Noise Model
error = amplitude_damping_error(0.5)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
error, ['id', 'x', 'y', 'z', 'h', 's', 'sdg'])
# Test circuits
shots = 100
circuits = ref_non_clifford.ccx_gate_circuits_deterministic(
final_measure=True)
qobj = compile(circuits, self.SIMULATOR, shots=shots)
def get_result():
return self.SIMULATOR.run(
qobj,
backend_options=self.BACKEND_OPTS,
noise_model=noise_model).result()
# Check simulation method
method = self.BACKEND_OPTS.get('method')
if method == 'stabilizer':
self.assertRaises(AerError, get_result)
else:
result = get_result()
self.is_completed(result)
self.compare_result_metadata(result, circuits, 'method',
'statevector')
def test_backend_method_nonclifford_circuit_and_kraus_noise(self):
"""Test statevector method is used for Clifford circuit"""
# Noise Model
error = amplitude_damping_error(0.5)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
error, ['id', 'x', 'y', 'z', 'h', 's', 'sdg'])
# Test circuits
shots = 100
circuits = ref_non_clifford.ccx_gate_circuits_deterministic(
final_measure=True)
qobj = assemble(circuits, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(qobj,
backend_options=self.BACKEND_OPTS,
noise_model=noise_model).result()
success = getattr(result, 'success', False)
# Check simulation method
method = self.BACKEND_OPTS.get('method', 'automatic')
if method == 'stabilizer':
self.assertFalse(success)
else:
self.assertTrue(success)
if method == 'automatic':
target_method = 'density_matrix'
else:
target_method = method
self.compare_result_metadata(result, circuits, 'method',
target_method)
def kraus_noise_model():
"""Return test Kraus noise model"""
noise_model = NoiseModel()
error1 = amplitude_damping_error(0.1)
noise_model.add_all_qubit_quantum_error(error1, ['u1', 'u2', 'u3'])
error2 = error1.tensor(error1)
noise_model.add_all_qubit_quantum_error(error2, ['cx'])
return NoiseWithDescription(noise_model, "Kraus Noise")
def kraus_noise_model():
"""Return test Kraus noise model"""
noise_model = NoiseModel()
error1 = amplitude_damping_error(0.1)
noise_model.add_all_qubit_quantum_error(error1, ['u1', 'u2', 'u3'])
error2 = error1.kron(error1)
noise_model.add_all_qubit_quantum_error(error2, ['cx'])
return noise_model
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 test_auto_method_nonclifford_circuit_and_kraus_noise(self):
"""Test statevector method is used for Clifford circuit"""
# Noise Model
error = amplitude_damping_error(0.5)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
error, ['id', 'x', 'y', 'z', 'h', 's', 'sdg'])
backend = self.backend(noise_model=noise_model)
# Test circuits
shots = 100
circuits = ref_non_clifford.ccx_gate_circuits_deterministic(
final_measure=True)
result = backend.run(circuits, shots=shots).result()
success = getattr(result, 'success', False)
self.compare_result_metadata(result, circuits, 'method',
"density_matrix")
def amplified_qiskit_model(name, amplification=1, gate_time=0.001):
provider = IBMQ.load_account()
device = provider.get_backend(name)
properties = device.properties()
noise_model = NoiseModel()
# depolarizing error
cnot_depol_errs = [
x.parameters[0].value for x in properties.gates if x.gate == 'cx'
]
ave_cnot_error = sum(cnot_depol_errs) / len(
cnot_depol_errs) / amplification
cnot_depol_error = depolarizing_error(ave_cnot_error, 2)
single_depol_errs = [
x.parameters[0].value for x in properties.gates if x.gate != 'cx'
]
ave_single_error = sum(single_depol_errs) / len(
single_depol_errs) / amplification
single_depol_error = depolarizing_error(ave_single_error, 1)
# amp damp
t1s = [x[0].value for x in properties.qubits]
ave_t1 = sum(t1s) / len(t1s)
t1_ratio = gate_time / (ave_t1 * amplification)
amp_gamma = 1 - np.exp(-t1_ratio)
amp_error = amplitude_damping_error(amp_gamma)
# phase damp
t2s = [x[1].value for x in properties.qubits]
ave_t2 = sum(t2s) / len(t2s)
t2_ratio = gate_time / (ave_t2 * amplification)
phase_gamma = 1 - np.exp(-t2_ratio)
phase_error = phase_damping_error(phase_gamma)
thermal_error = amp_error.compose(phase_error)
noise_model.add_all_qubit_quantum_error(
single_depol_error.compose(thermal_error), ['u1', 'u2', 'u3'])
noise_model.add_all_qubit_quantum_error(
cnot_depol_error.compose(thermal_error.tensor(thermal_error)), ['cx'])
return noise_model
