def test_full_qst(self, num_qubits, fitter):
"""Test 1-qubit QST experiment"""
backend = AerSimulator(seed_simulator=9000)
seed = 1234
f_threshold = 0.95
target = qi.random_statevector(2**num_qubits, seed=seed)
qstexp = StateTomography(target)
if fitter:
qstexp.analysis.set_options(fitter=fitter)
expdata = qstexp.run(backend)
results = expdata.analysis_results()
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(isinstance(state, qi.DensityMatrix),
msg="fitted state is not density matrix")
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, target, validate=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_qst_teleport(self):
"""Test subset state tomography generation"""
# NOTE: This test breaks transpiler. I think it is a bug with
# conditionals in Terra.
# Teleport qubit 0 -> 2
backend = AerSimulator(seed_simulator=9000)
exp = StateTomography(teleport_circuit(), measurement_qubits=[2])
expdata = exp.run(backend)
self.assertExperimentDone(expdata)
results = expdata.analysis_results()
# Check result
f_threshold = 0.95
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(isinstance(state, qi.DensityMatrix),
msg="fitted state is not a density matrix")
# Manually check fidelity
fid = qi.state_fidelity(state, qi.Statevector([1, 0]), validate=False)
self.assertGreater(fid,
f_threshold,
msg="fitted state fidelity is low")
def test_exp_circuits_measurement_qubits(self, meas_qubits):
"""Test subset state tomography generation"""
# Subsystem unitaries
seed = 1111
nq = 3
ops = [qi.random_unitary(2, seed=seed + i) for i in range(nq)]
# Preparation circuit
circ = QuantumCircuit(nq)
for i, op in enumerate(ops):
circ.append(op, [i])
num_meas = len(meas_qubits)
exp = StateTomography(circ, measurement_qubits=meas_qubits)
tomo_circuits = exp.circuits()
# Check correct number of circuits are generated
self.assertEqual(len(tomo_circuits), 3**num_meas)
# Check circuit metadata is correct
for circ in tomo_circuits:
meta = circ.metadata
clbits = meta.get("clbits")
self.assertEqual(clbits,
list(range(num_meas)),
msg="metadata clbits is incorrect")
# Check analysis target is correct
target_state = exp.analysis.options.target
target_circ = QuantumCircuit(num_meas)
for i, qubit in enumerate(meas_qubits):
target_circ.append(ops[qubit], [i])
fid = qi.state_fidelity(target_state, qi.Statevector(target_circ))
self.assertGreater(fid, 0.99, msg="target_state is incorrect")
def test_experiment_config(self):
"""Test converting to and from config works"""
exp = StateTomography(QuantumCircuit(3),
measurement_qubits=[0, 2],
qubits=[5, 7, 1])
loaded_exp = StateTomography.from_config(exp.config())
self.assertNotEqual(exp, loaded_exp)
self.assertTrue(self.json_equiv(exp, loaded_exp))
def test_expdata_serialization(self):
"""Test serializing experiment data works."""
backend = AerSimulator(seed_simulator=9000)
exp = StateTomography(XGate())
expdata = exp.run(backend)
self.assertExperimentDone(expdata)
self.assertRoundTripSerializable(expdata,
check_func=self.experiment_data_equiv)
self.assertRoundTripPickle(expdata,
check_func=self.experiment_data_equiv)
def time_state_tomography_cat(self, n_qubits):
qr = qiskit.QuantumRegister(n_qubits, 'qr')
circ = qiskit.QuantumCircuit(qr, name='cat')
circ.h(qr[0])
for i in range(1, n_qubits):
circ.cx(qr[0], qr[i])
qst_exp = StateTomography(circ)
expdata = qst_exp.run(self.qasm_backend,
shots=5000).block_for_results()
expdata.analysis_results("state")
expdata.analysis_results("state_fidelity")
def time_state_tomography_bell(self, n_qubits):
meas_qubits = [n_qubits - 2, n_qubits - 1]
qr_full = qiskit.QuantumRegister(n_qubits)
bell = qiskit.QuantumCircuit(qr_full)
bell.h(qr_full[meas_qubits[0]])
bell.cx(qr_full[meas_qubits[0]], qr_full[meas_qubits[1]])
qst_exp = StateTomography(bell, measurement_qubits=meas_qubits)
expdata = qst_exp.run(self.qasm_backend,
shots=5000).block_for_results()
expdata.analysis_results("state")
expdata.analysis_results("state_fidelity")
def test_full_exp_measurement_qubits(self, meas_qubits):
"""Test subset state tomography generation"""
# Subsystem unitaries
seed = 1111
nq = 3
ops = [qi.random_unitary(2, seed=seed + i) for i in range(nq)]
# Target state
target_circ = QuantumCircuit(len(meas_qubits))
for i, qubit in enumerate(meas_qubits):
target_circ.append(ops[qubit], [i])
target = qi.Statevector(target_circ)
# Preparation circuit
circ = QuantumCircuit(nq)
for i, op in enumerate(ops):
circ.append(op, [i])
# Run
backend = AerSimulator(seed_simulator=9000)
exp = StateTomography(circ, measurement_qubits=meas_qubits)
expdata = exp.run(backend)
self.assertExperimentDone(expdata)
results = expdata.analysis_results()
# Check result
f_threshold = 0.95
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(isinstance(state, qi.DensityMatrix),
msg="fitted state is not density matrix")
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, target, validate=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_full_qst(self, num_qubits):
"""Test QST experiment"""
seed = 1234
shots = 5000
f_threshold = 0.99
# Generate tomography data without analysis
backend = AerSimulator(seed_simulator=seed, shots=shots)
target = qi.random_statevector(2**num_qubits, seed=seed)
exp = StateTomography(target)
expdata = exp.run(backend, analysis=None)
self.assertExperimentDone(expdata)
# Run each tomography fitter analysis as a subtest so
# we don't have to re-run simulation data for each fitter
for fitter in FITTERS:
with self.subTest(fitter=fitter):
if fitter:
exp.analysis.set_options(fitter=fitter)
fitdata = exp.analysis.run(expdata)
self.assertExperimentDone(fitdata)
results = expdata.analysis_results()
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(
isinstance(state, qi.DensityMatrix),
msg=f"{fitter} fitted state is not density matrix",
)
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid,
f_threshold,
msg=f"{fitter} fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, target, validate=False)
self.assertAlmostEqual(
fid,
target_fid,
places=6,
msg=f"{fitter} result fidelity is incorrect")
def test_mixed_batch_exp(self):
"""Test batch state and process tomography experiment"""
# Subsystem unitaries
state_op = qi.random_unitary(2, seed=321)
chan_op = qi.random_unitary(2, seed=123)
state_target = qi.Statevector(state_op.to_instruction())
chan_target = qi.Choi(chan_op.to_instruction())
state_exp = StateTomography(state_op)
chan_exp = ProcessTomography(chan_op)
batch_exp = BatchExperiment([state_exp, chan_exp])
# Run batch experiments
backend = AerSimulator(seed_simulator=9000)
par_data = batch_exp.run(backend)
self.assertExperimentDone(par_data)
f_threshold = 0.95
# Check state tomo results
state_results = par_data.child_data(0).analysis_results()
state = filter_results(state_results, "state").value
# Check fit state fidelity
state_fid = filter_results(state_results, "state_fidelity").value
self.assertGreater(state_fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, state_target, validate=False)
self.assertAlmostEqual(state_fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
# Check process tomo results
chan_results = par_data.child_data(1).analysis_results()
chan = filter_results(chan_results, "state").value
# Check fit process fidelity
chan_fid = filter_results(chan_results, "process_fidelity").value
self.assertGreater(chan_fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.process_fidelity(chan,
chan_target,
require_cp=False,
require_tp=False)
self.assertAlmostEqual(chan_fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_batch_exp(self):
"""Test batch state tomography experiment with measurement_qubits kwarg"""
# Subsystem unitaries
seed = 1111
nq = 3
ops = [qi.random_unitary(2, seed=seed + i) for i in range(nq)]
# Preparation circuit
circuit = QuantumCircuit(nq)
for i, op in enumerate(ops):
circuit.append(op, [i])
# Component experiments
exps = []
targets = []
for i in range(nq):
targets.append(qi.Statevector(ops[i].to_instruction()))
exps.append(StateTomography(circuit, measurement_qubits=[i]))
# Run batch experiments
backend = AerSimulator(seed_simulator=9000)
batch_exp = BatchExperiment(exps)
batch_data = batch_exp.run(backend)
batch_data.block_for_results()
# Check target fidelity of component experiments
f_threshold = 0.95
for i in range(batch_exp.num_experiments):
results = batch_data.component_experiment_data(
i).analysis_results()
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(isinstance(state, qi.DensityMatrix),
msg="fitted state is not density matrix")
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, targets[i], validate=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_parallel_exp(self):
"""Test parallel state tomography experiment"""
# Subsystem unitaries
seed = 1221
nq = 4
ops = [qi.random_unitary(2, seed=seed + i) for i in range(nq)]
# Component experiments
exps = []
targets = []
for i in range(nq):
exps.append(StateTomography(ops[i], qubits=[i]))
targets.append(qi.Statevector(ops[i].to_instruction()))
# Run batch experiments
backend = AerSimulator(seed_simulator=9000)
par_exp = ParallelExperiment(exps)
par_data = par_exp.run(backend)
self.assertExperimentDone(par_data)
# Check target fidelity of component experiments
f_threshold = 0.95
for i in range(par_exp.num_experiments):
results = par_data.child_data(i).analysis_results()
# Check state is density matrix
state = filter_results(results, "state").value
self.assertTrue(isinstance(state, qi.DensityMatrix),
msg="fitted state is not density matrix")
# Check fit state fidelity
fid = filter_results(results, "state_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.state_fidelity(state, targets[i], validate=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")