def test_local_mbasis_qubit_povm_no_default(self):
"""Test matrix method raises for invalid qubit with no default states"""
size = 2
qubits = [0, 2]
qubit_povms = {
qubits[0]: [qi.random_unitary(2, seed=30 + i) for i in range(size)],
qubits[1]: [qi.random_unitary(2, seed=40 + i) for i in range(size)],
}
basis = LocalMeasurementBasis("fitter_basis", qubit_povms=qubit_povms)
# No default states so should raise an exception
with self.assertRaises(ValueError):
basis.matrix([0, 0], 0, [0, 1])
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_unitary_is_preserved_if_basis_is_None(self, level):
"""Test that a unitary is not synthesized if basis is None."""
qc = QuantumCircuit(2)
qc.unitary(random_unitary(4, seed=4242), [0, 1])
qc.measure_all()
result = transpile(qc, basis_gates=None, optimization_level=level)
self.assertEqual(result, qc)
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_density_matrix_snapshot_ideal(self):
seed = 500
op = qi.random_unitary(8, seed=seed)
circ = QuantumCircuit(3)
circ.append(op, [0, 1, 2])
method = self.BACKEND_OPTS.get('method', 'automatic')
label = 'density_matrix'
snap_qargs = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1],
[2, 1, 0], [0, 1], [1, 0], [0, 2], [2, 0], [1, 2],
[2, 1], [0], [1], [2]]
evolve_qargs = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [2, 0, 1], [1, 2, 0],
[2, 1, 0], [0, 1, 2], [1, 0, 2], [0, 2, 1], [1, 2, 0],
[2, 0, 1], [2, 1, 0], [0, 1, 2], [1, 0, 2], [2, 1, 0]]
for squbits, equbits in zip(snap_qargs, evolve_qargs):
with self.subTest(msg='qubits={}'.format(squbits)):
num_qubits = len(squbits)
tmp = circ.copy()
tmp.append(Snapshot(label, 'density_matrix', num_qubits),
squbits)
result = execute(tmp,
self.SIMULATOR,
backend_options=self.BACKEND_OPTS).result()
if method not in QasmSnapshotDensityMatrixTests.SUPPORTED_QASM_METHODS:
self.assertFalse(result.success)
else:
self.assertSuccess(result)
snapshots = result.data(0)['snapshots']['density_matrix']
value = qi.DensityMatrix(snapshots[label][0]['value'])
target = qi.DensityMatrix.from_label(3 * '0').evolve(
circ, equbits)
if num_qubits == 2:
target = qi.partial_trace(target, [2])
elif num_qubits == 1:
target = qi.partial_trace(target, [1, 2])
self.assertEqual(value, target)
def test_bogoliubov_transform_compose_num_conserving(self, n_orbitals):
"""Test Bogoliubov transform composition, particle-number-conserving."""
unitary1 = np.array(random_unitary(n_orbitals, seed=4331))
unitary2 = np.array(random_unitary(n_orbitals, seed=2506))
bog_circuit_1 = BogoliubovTransform(unitary1)
bog_circuit_2 = BogoliubovTransform(unitary2)
bog_circuit_composed = BogoliubovTransform(unitary1 @ unitary2)
register = QuantumRegister(n_orbitals)
circuit = QuantumCircuit(register)
circuit.append(bog_circuit_1, register)
circuit.append(bog_circuit_2, register)
self.assertTrue(
Operator(circuit).equiv(Operator(bog_circuit_composed), atol=1e-8))
def test_full_qpt(self, num_qubits, fitter):
"""Test QPT experiment"""
backend = AerSimulator(seed_simulator=9000)
seed = 1234
f_threshold = 0.94
target = qi.random_unitary(2**num_qubits, seed=seed)
qstexp = ProcessTomography(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.Choi),
msg="fitted state is not a Choi matrix")
# Check fit state fidelity
fid = filter_results(results, "process_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.process_fidelity(state,
target,
require_tp=False,
require_cp=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_density_matrix_evolve(self):
orig = qi.random_density_matrix(2, seed=10)
compat = cqi.DensityMatrix(orig.data)
orig_op = qi.random_unitary(2, seed=10)
compat_op = cqi.Operator(orig_op.data)
target = orig.evolve(orig_op)
self.assertEqual(orig.evolve(compat_op), target)
self.assertEqual(compat.evolve(orig_op), target)
self.assertEqual(compat.evolve(compat_op), target)
def test_statevector_evolve(self):
orig = qi.random_statevector(2, seed=10)
compat = cqi.Statevector(orig.data)
orig_op = qi.random_unitary(2, seed=10)
compat_op = cqi.Operator(orig_op.data)
target = orig.evolve(orig_op)
self.assertEqual(orig.evolve(compat_op), target)
self.assertEqual(compat.evolve(orig_op), target)
self.assertEqual(compat.evolve(compat_op), target)
def test_circuit_qasm_pi(self):
"""Test circuit qasm() method with pi params.
"""
circuit = QuantumCircuit(2)
circuit.append(random_unitary(4, seed=1234), [0, 1])
circuit = circuit.decompose()
qasm_str = circuit.qasm()
circuit2 = QuantumCircuit.from_qasm_str(qasm_str)
self.assertEqual(circuit, circuit2)
def test_local_mbasis_default_unitary(self):
"""Test default povms kwarg"""
default_povms = [qi.random_unitary(2, seed=30 + i) for i in range(3)]
basis = LocalMeasurementBasis("fitter_basis", default_povms=default_povms)
for i, povm in enumerate(default_povms):
adjoint = povm.adjoint()
for outcome in range(2):
state = qi.Statevector.from_int(outcome, dims=2**adjoint.num_qubits)
state = state.evolve(adjoint)
basis_state = qi.DensityMatrix(basis.matrix([i], outcome, [0]))
fid = qi.state_fidelity(state, basis_state)
self.assertTrue(isclose(fid, 1))
def test_unitary_is_preserved_if_in_basis_synthesis_translation(self, level):
"""Test that a unitary is not synthesized if in the basis with synthesis translation."""
qc = QuantumCircuit(2)
qc.unitary(random_unitary(4, seed=424242), [0, 1])
qc.measure_all()
result = transpile(
qc,
basis_gates=["cx", "u", "unitary"],
optimization_level=level,
translation_method="synthesis",
)
self.assertEqual(result, qc)
def test_batch_exp_with_measurement_qubits(self):
"""Test batch process tomography experiment with kwargs"""
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(ops[i])
exps.append(
ProcessTomography(circuit,
measurement_qubits=[i],
preparation_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.Choi),
msg="fitted state is not a Choi matrix")
# Check fit state fidelity
fid = filter_results(results, "process_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.process_fidelity(state,
targets[i],
require_tp=False,
require_cp=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_unitary_iterable_methods(self):
"""Test that the iterable magic methods and related Numpy properties
work on the compatibility classes."""
compat = cqi.Operator(qi.random_unitary(2, seed=10))
compat_data = compat.data
with self.assertWarns(DeprecationWarning):
compat_len = len(compat)
self.assertEqual(compat_len, len(compat_data))
with self.assertWarns(DeprecationWarning):
compat_shape = compat.shape
self.assertEqual(compat_shape, compat_data.shape)
with self.assertWarns(DeprecationWarning):
compat_iter = tuple(compat)
np.testing.assert_array_equal(compat_iter, compat.data)
def test_translate_ecr_basis(self, optimization_level):
"""Verify that rewriting in ECR basis is efficient."""
circuit = QuantumCircuit(2)
circuit.append(random_unitary(4, seed=1), [0, 1])
circuit.barrier()
circuit.cx(0, 1)
circuit.barrier()
circuit.swap(0, 1)
circuit.barrier()
circuit.iswap(0, 1)
res = transpile(circuit, basis_gates=['u', 'ecr'],
optimization_level=optimization_level)
self.assertEqual(res.count_ops()['ecr'], 9)
self.assertTrue(Operator(res).equiv(circuit))
def test_unitary_snap(self):
"""Test Unitary matrix snaps on a random circuit"""
backend = UnitarySimulator()
target = qi.random_unitary(2 ** 4, seed=111)
circ = QuantumCircuit(4)
circ.append(target, [0, 1, 2, 3])
circ.append(Snapshot("final", "unitary", 4), [0, 1, 2, 3])
qobj = assemble(circ, backend=backend, shots=1)
job = backend.run(qobj)
result = job.result()
self.assertSuccess(result)
snaps = result.data(0)['snapshots']['unitary']['final']
for arr in snaps:
self.assertTrue(isinstance(arr, np.ndarray))
self.assertEqual(qi.Operator(arr), target)
def test_unitary_snap(self):
"""Test Unitary matrix snaps on a random circuit"""
backend = UnitarySimulator()
backend_opts = {}
circ = QuantumCircuit(4)
circ.append(qi.random_unitary(2**4), [0, 1, 2, 3])
circ.append(Snapshot("final", "unitary", 4), [0, 1, 2, 3])
qobj = assemble(circ, backend=backend)
aer_input = backend._format_qobj(qobj, self.BACKEND_OPTS, None)
aer_output = backend._controller(aer_input)
self.assertIsInstance(aer_output, dict)
self.assertTrue(aer_output['success'])
snaps = aer_output['results'][0]['data']['snapshots']['unitary'][
'final']
self.assertTrue(all([isinstance(arr, np.ndarray) for arr in snaps]))
def test_full_exp_meas_prep_qubits(self, 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(qubits))
for i, qubit in enumerate(qubits):
target_circ.append(ops[qubit], [i])
target = qi.Operator(target_circ)
# Preparation circuit
circ = QuantumCircuit(nq)
for i, op in enumerate(ops):
circ.append(op, [i])
# Run
backend = AerSimulator(seed_simulator=9000)
exp = ProcessTomography(circ,
measurement_qubits=qubits,
preparation_qubits=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.Choi),
msg="fitted state is not a Choi matrix")
# Check fit state fidelity
fid = filter_results(results, "process_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.process_fidelity(state,
target,
require_tp=False,
require_cp=False)
self.assertAlmostEqual(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)
self.assertExperimentDone(batch_data)
# Check target fidelity of component experiments
f_threshold = 0.95
for i in range(batch_exp.num_experiments):
results = batch_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")
def test_disassemble_isometry(self):
"""Test disassembling a circuit with an isometry."""
q = QuantumRegister(2, name="q")
circ = QuantumCircuit(q, name="circ")
circ.iso(qi.random_unitary(4).data, circ.qubits, [])
qobj = assemble(circ)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 0)
self.assertEqual(len(circuits), 1)
# params array
assert_allclose(circuits[0]._data[0][0].params[0], circ._data[0][0].params[0])
# all other data
self.assertEqual(circuits[0]._data[0][0].params[1:], circ._data[0][0].params[1:])
self.assertEqual(circuits[0]._data[0][1:], circ._data[0][1:])
self.assertEqual(circuits[0]._data[1:], circ._data[1:])
self.assertEqual({}, header)
def test_parallel_exp(self):
"""Test parallel process 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(ProcessTomography(ops[i], qubits=[i]))
targets.append(ops[i])
# 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.Choi),
msg="fitted state is not a Choi matrix")
# Check fit state fidelity
fid = filter_results(results, "process_fidelity").value
self.assertGreater(fid, f_threshold, msg="fit fidelity is low")
# Manually check fidelity
target_fid = qi.process_fidelity(state,
targets[i],
require_tp=False,
require_cp=False)
self.assertAlmostEqual(fid,
target_fid,
places=6,
msg="result fidelity is incorrect")
def test_set_unitary(self, method, device, num_qubits):
"""Test SetUnitary instruction"""
backend = self.backend(method=method, device=device)
seed = 100
label = 'state'
target = qi.random_unitary(2**num_qubits, seed=seed)
circ = QuantumCircuit(num_qubits)
circ.set_unitary(target)
circ.save_unitary(label=label)
# Run
result = backend.run(transpile(circ, backend, optimization_level=0),
shots=1).result()
self.assertTrue(result.success)
simdata = result.data(0)
self.assertIn(label, simdata)
value = simdata[label]
self.assertEqual(value, target)
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)
par_data.block_for_results()
# Check target fidelity of component experiments
f_threshold = 0.95
for i in range(par_exp.num_experiments):
results = par_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_exp_measurement_preparation_qubits(self, qubits):
"""Test subset measurement process 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(qubits)
exp = ProcessTomography(circ,
measurement_qubits=qubits,
preparation_qubits=qubits)
tomo_circuits = exp.circuits()
# Check correct number of circuits are generated
size = 3**num_meas * 4**num_meas
self.assertEqual(len(tomo_circuits), size)
# 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 experiment target metadata is correct
exp_meta = exp._metadata()
target_state = exp_meta.get("target")
target_circ = QuantumCircuit(num_meas)
for i, qubit in enumerate(qubits):
target_circ.append(ops[qubit], [i])
fid = qi.process_fidelity(target_state, qi.Operator(target_circ))
self.assertGreater(fid, 0.99, msg="target_state is incorrect")
def C(self, c_label):
coin = self.c
state = self.dim
#creating the identity in the S space
I = np.zeros((2**state, 2**state))
for i in range(2**state):
I[i][i] = 1
I = Operator(I)
if c_label == "Hadamard":
result = np.zeros((2**coin, 2**coin))
for i in range(2**coin):
for j in range(2**coin):
#bin_i = bin(i)
#bin_j = bin(j)
if i >= 2 and j >= 2:
result[i][j] = -1 * (-1)**(i * j) * (2**(-1 *
(0.5 * coin)))
else:
result[i][j] = (-1)**(i * j) * (2**(-1 * (0.5 * coin)))
res_op = (Operator(result))
C_final = res_op.tensor(I)
return C_final
elif c_label == "Random":
dim = []
for i in range(coin):
dim.append(2)
res_op = random_unitary(tuple(dim))
C_final = res_op.tensor(I)
return C_final
else:
raise TypeError("Label string for C is not a valid input")
def test_roundtrip_operator(self):
"""Test round-trip serialization of an Operator"""
obj = qi.random_unitary(4, seed=10)
self.assertRoundTripSerializable(obj)
def test_unitary_compose(self):
orig = qi.random_unitary(2, seed=10)
compat = cqi.Operator(orig.data)
target = orig.compose(orig)
self.assertEqual(compat.compose(orig), target)
self.assertEqual(orig.compose(compat), target)
def test_unitary_evolve(self):
orig = qi.random_unitary(2, seed=10)
compat = cqi.Operator(orig.data)
state = qi.random_statevector(2, seed=10)
target = state.evolve(orig)
self.assertEqual(state.evolve(compat), target)
def get_sample_state_qc(k):
# k is the number of available logical qubits
return random_unitary(2**k).to_instruction()
def random_unitary(Q: int) -> np.ndarray:
from qiskit.quantum_info import random_unitary
return random_unitary(2**Q).data
