def setUp(self):
"""Setup the tests."""
super().setUp()
# Setup noise model, including more gate for complicated EPG computation
# Note that 1Q channel error is amplified to check 1q channel correction mechanism
x_error = depolarizing_error(0.04, 1)
h_error = depolarizing_error(0.02, 1)
s_error = depolarizing_error(0.00, 1)
cx_error = depolarizing_error(0.08, 2)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(x_error, "x")
noise_model.add_all_qubit_quantum_error(h_error, "h")
noise_model.add_all_qubit_quantum_error(s_error, "s")
noise_model.add_all_qubit_quantum_error(cx_error, "cx")
# Need level1 for consecutive gate cancellation for reference EPC value calculation
transpiler_options = {
"basis_gates": ["x", "h", "s", "cx"],
"optimization_level": 1,
}
# Aer simulator
backend = AerSimulator(noise_model=noise_model, seed_simulator=123)
# Prepare experiment data and cache for analysis
exp_1qrb_q0 = rb.StandardRB(
qubits=(0, ),
lengths=[1, 10, 30, 50, 80, 120, 150, 200],
seed=123,
backend=backend,
)
exp_1qrb_q0.set_transpile_options(**transpiler_options)
expdata_1qrb_q0 = exp_1qrb_q0.run(analysis=None).block_for_results(
timeout=300)
exp_1qrb_q1 = rb.StandardRB(
qubits=(1, ),
lengths=[1, 10, 30, 50, 80, 120, 150, 200],
seed=123,
backend=backend,
)
exp_1qrb_q1.set_transpile_options(**transpiler_options)
expdata_1qrb_q1 = exp_1qrb_q1.run(analysis=None).block_for_results(
timeout=300)
exp_2qrb = rb.StandardRB(
qubits=(0, 1),
lengths=[1, 3, 5, 10, 15, 20, 30, 50],
seed=123,
backend=backend,
)
exp_2qrb.set_transpile_options(**transpiler_options)
expdata_2qrb = exp_2qrb.run(analysis=None).block_for_results(
timeout=300)
self.expdata_1qrb_q0 = expdata_1qrb_q0
self.expdata_1qrb_q1 = expdata_1qrb_q1
self.expdata_2qrb = expdata_2qrb
def test_full_sampling(self):
"""Test if full sampling generates different circuits."""
exp1 = rb.StandardRB(
qubits=(0, 1),
lengths=[10, 20, 30],
seed=123,
backend=self.backend,
full_sampling=False,
)
exp2 = rb.StandardRB(
qubits=(0, 1),
lengths=[10, 20, 30],
seed=123,
backend=self.backend,
full_sampling=True,
)
circs1 = exp1.circuits()
circs2 = exp2.circuits()
self.assertEqual(circs1[0].decompose(), circs2[0].decompose())
# fully sampled circuits are regenerated while other is just built on top of previous length
self.assertNotEqual(circs1[1].decompose(), circs2[1].decompose())
self.assertNotEqual(circs1[2].decompose(), circs2[2].decompose())
def test_add_more_circuit_yields_lower_variance(self):
"""Test variance reduction with larger number of sampling."""
exp1 = rb.StandardRB(
qubits=(0, 1),
lengths=list(range(1, 30, 3)),
seed=123,
backend=self.backend,
num_samples=3,
)
exp1.analysis.set_options(gate_error_ratio=None)
exp1.set_transpile_options(**self.transpiler_options)
expdata1 = exp1.run()
self.assertExperimentDone(expdata1)
exp2 = rb.StandardRB(
qubits=(0, 1),
lengths=list(range(1, 30, 3)),
seed=456,
backend=self.backend,
num_samples=5,
)
exp2.analysis.set_options(gate_error_ratio=None)
exp2.set_transpile_options(**self.transpiler_options)
expdata2 = exp2.run()
self.assertExperimentDone(expdata2)
self.assertLess(
expdata2.analysis_results("EPC").value.s,
expdata1.analysis_results("EPC").value.s,
)
def test_single_qubit(self):
"""Test single qubit RB."""
exp = rb.StandardRB(
qubits=(0, ),
lengths=list(range(1, 300, 30)),
seed=123,
backend=self.backend,
)
exp.analysis.set_options(gate_error_ratio=None)
exp.set_transpile_options(**self.transpiler_options)
self.assertAllIdentity(exp.circuits())
expdata = exp.run()
self.assertExperimentDone(expdata)
# Given we have gate number per Clifford n_gpc, we can compute EPC as
# EPC = 1 - (1 - r)^n_gpc
# where r is gate error of SX gate, i.e. dep-parameter divided by 2.
# We let transpiler use SX and RZ.
# The number of physical gate per Clifford will distribute
# from 0 to 2, i.e. arbitrary U gate can be decomposed into up to 2 SX with RZs.
# We may want to expect the average number of SX is (0 + 1 + 2) / 3 = 1.0.
epc = expdata.analysis_results("EPC")
epc_expected = 1 - (1 - 1 / 2 * self.p1q)**1.0
self.assertAlmostEqual(epc.value.n,
epc_expected,
delta=0.1 * epc_expected)
def test_two_qubit(self):
"""Test two qubit RB."""
exp = rb.StandardRB(
qubits=(0, 1),
lengths=list(range(1, 30, 3)),
seed=123,
backend=self.backend,
)
exp.analysis.set_options(gate_error_ratio=None)
exp.set_transpile_options(**self.transpiler_options)
self.assertAllIdentity(exp.circuits())
expdata = exp.run()
self.assertExperimentDone(expdata)
# Given CX error is dominant and 1q error can be negligible.
# Arbitrary SU(4) can be decomposed with (0, 1, 2, 3) CX gates, the expected
# average number of CX gate per Clifford is 1.5.
# Since this is two qubit RB, the dep-parameter is factored by 3/4.
epc = expdata.analysis_results("EPC")
# Allow for 50 percent tolerance since we ignore 1q gate contribution
epc_expected = 1 - (1 - 3 / 4 * self.p2q)**1.5
self.assertAlmostEqual(epc.value.n,
epc_expected,
delta=0.5 * epc_expected)
def test_return_same_circuit(self):
"""Test if setting the same seed returns the same circuits."""
exp1 = rb.StandardRB(
qubits=(0, 1),
lengths=[10, 20, 30],
seed=123,
backend=self.backend,
)
exp2 = rb.StandardRB(
qubits=(0, 1),
lengths=[10, 20, 30],
seed=123,
backend=self.backend,
)
circs1 = exp1.circuits()
circs2 = exp2.circuits()
self.assertEqual(circs1[0].decompose(), circs2[0].decompose())
self.assertEqual(circs1[1].decompose(), circs2[1].decompose())
self.assertEqual(circs1[2].decompose(), circs2[2].decompose())
def test_expdata_serialization(self):
"""Test serializing experiment data works."""
exp = rb.StandardRB(
qubits=(0, ),
lengths=list(range(1, 200, 50)),
seed=123,
backend=self.backend,
)
exp.set_transpile_options(**self.transpiler_options)
expdata = exp.run()
self.assertExperimentDone(expdata)
self.assertRoundTripSerializable(expdata,
check_func=self.experiment_data_equiv)
self.assertRoundTripPickle(expdata,
check_func=self.experiment_data_equiv)
def test_roundtrip_serializable(self):
"""Test round trip JSON serialization"""
exp = rb.StandardRB(qubits=(0, ), lengths=[10, 20, 30], seed=123)
self.assertRoundTripSerializable(exp, self.json_equiv)
def test_experiment_config(self):
"""Test converting to and from config works"""
exp = rb.StandardRB(qubits=(0, ), lengths=[10, 20, 30], seed=123)
loaded_exp = rb.StandardRB.from_config(exp.config())
self.assertNotEqual(exp, loaded_exp)
self.assertTrue(self.json_equiv(exp, loaded_exp))