def test_save_density_matrix(self, method, device):
"""Test save density matrix for instruction"""
backend = self.backend(method=method, device=device)
# Stabilizer test circuit
circ = QuantumCircuit(3)
circ.h(0)
circ.sdg(0)
circ.cx(0, 1)
circ.cx(0, 2)
# Target statevector
target = qi.DensityMatrix(circ)
# Add save to circuit
label = 'state'
circ.save_density_matrix(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 = qi.DensityMatrix(simdata[label])
self.assertEqual(value, target)
def test_save_density_matrix_conditional(self, method, device):
"""Test conditional save density matrix instruction"""
backend = self.backend(method=method, device=device)
# Stabilizer test circuit
label = 'state'
circ = QuantumCircuit(2)
circ.h(0)
circ.sdg(0)
circ.cx(0, 1)
circ.measure_all()
circ.save_density_matrix(label=label, conditional=True)
# Target statevector
target = {
'0x0': qi.DensityMatrix(np.diag([1, 0, 0, 0])),
'0x3': qi.DensityMatrix(np.diag([0, 0, 0, 1]))
}
# 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)
for key, state in simdata[label].items():
self.assertIn(key, target)
self.assertEqual(qi.DensityMatrix(state), target[key])
def test_local_mbasis_qubit_povms(self):
"""Test qubit povms kwarg"""
size = 2
outcomes = 2
qubits = [0, 2]
qubit_povms = {
qubits[0]: [
[qi.random_density_matrix(2, seed=30 + i + j) for i in range(outcomes)]
for j in range(size)
],
qubits[1]: [
[qi.random_density_matrix(2, seed=40 + i + j) for i in range(outcomes)]
for j in range(size)
],
}
basis = LocalMeasurementBasis("fitter_basis", qubit_povms=qubit_povms)
# Check states
indices = it.product(range(size), repeat=len(qubits))
outcomes = it.product(range(outcomes), repeat=len(qubits))
for index in indices:
for outcome in outcomes:
basis_state = qi.DensityMatrix(
basis.matrix(index, self._outcome_tup_to_int(outcome), qubits)
)
target0 = qi.DensityMatrix(qubit_povms[qubits[0]][index[0]][outcome[0]])
target1 = qi.DensityMatrix(qubit_povms[qubits[1]][index[1]][outcome[1]])
target = target0.expand(target1)
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def test_save_density_matrix_pershot(self, method, device):
"""Test pershot save density matrix instruction"""
backend = self.backend(method=method, device=device)
# Stabilizer test circuit
circ = QuantumCircuit(1)
circ.x(0)
circ.reset(0)
circ.h(0)
circ.sdg(0)
# Target statevector
target = qi.DensityMatrix(circ)
# Add save
label = 'state'
circ.save_density_matrix(label=label, pershot=True)
# Run
shots = 10
result = backend.run(transpile(circ, backend, optimization_level=0),
shots=shots).result()
self.assertTrue(result.success)
simdata = result.data(0)
self.assertIn(label, simdata)
value = simdata[label]
for state in value:
self.assertEqual(qi.DensityMatrix(state), target)
def test_kraus_circuit_noise(self, method, device):
"""Test simulation with Kraus quantum errors in circuit."""
backend = self.backend(method=method, device=device)
shots = 1000
error0 = noise.amplitude_damping_error(0.05)
error1 = noise.amplitude_damping_error(0.15)
error01 = error1.tensor(error0)
# Target Circuit 0
tc0 = QuantumCircuit(2)
tc0.h(0)
tc0.append(qi.Kraus(error0), [0])
tc0.cx(0, 1)
tc0.append(qi.Kraus(error01), [0, 1])
target_probs0 = qi.DensityMatrix(tc0).probabilities_dict()
# Sim circuit 0
qc0 = QuantumCircuit(2)
qc0.h(0)
qc0.append(error0, [0])
qc0.cx(0, 1)
qc0.append(error01, [0, 1])
qc0.measure_all()
# Target Circuit 1
tc1 = QuantumCircuit(2)
tc1.h(1)
tc1.append(qi.Kraus(error0), [1])
tc1.cx(1, 0)
tc1.append(qi.Kraus(error01), [1, 0])
target_probs1 = qi.DensityMatrix(tc1).probabilities_dict()
# Sim circuit 1
qc1 = QuantumCircuit(2)
qc1.h(1)
qc1.append(error0, [1])
qc1.cx(1, 0)
qc1.append(error01, [1, 0])
qc1.measure_all()
result = backend.run([qc0, qc1], shots=shots).result()
self.assertSuccess(result)
probs = [{
key: val / shots
for key, val in result.get_counts(i).items()
} for i in range(2)]
self.assertDictAlmostEqual(target_probs0, probs[0], delta=0.1)
self.assertDictAlmostEqual(target_probs1, probs[1], delta=0.1)
def test_clifford_circuit_noise(self, method, device):
"""Test simulation with mixed Clifford quantum errors in circuit."""
backend = self.backend(method=method, device=device)
shots = 1000
error1 = noise.QuantumError([
([(IGate(), [0])], 0.8),
([(Reset(), [0])], 0.1),
([(HGate(), [0])], 0.1)])
error2 = noise.QuantumError([
([(IGate(), [0])], 0.75),
([(Reset(), [0])], 0.1),
([(Reset(), [1])], 0.1),
([(Reset(), [0]), (Reset(), [1])], 0.05)])
qc = QuantumCircuit(2)
qc.h(0)
qc.append(error1, [0])
qc.cx(0, 1)
qc.append(error2, [0, 1])
target_probs = qi.DensityMatrix(qc).probabilities_dict()
# Add measurement
qc.measure_all()
result = backend.run(qc, shots=shots).result()
self.assertSuccess(result)
probs = {key: val / shots for key, val in result.get_counts(0).items()}
self.assertDictAlmostEqual(target_probs, probs, delta=0.1)
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_set_density_matrix(self, num_qubits):
"""Test SetDensityMatrix instruction"""
SUPPORTED_METHODS = [
'automatic', 'density_matrix', 'density_matrix_gpu',
'density_matrix_thrust'
]
seed = 100
save_label = 'state'
target = qi.random_density_matrix(2 ** num_qubits, seed=seed)
circ = QuantumCircuit(num_qubits)
circ.set_density_matrix(target)
circ.save_density_matrix(label=save_label)
# Run
opts = self.BACKEND_OPTS.copy()
qobj = assemble(circ, self.SIMULATOR)
result = self.SIMULATOR.run(qobj, **opts).result()
method = opts.get('method', 'automatic')
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
data = result.data(0)
self.assertIn(save_label, data)
value = qi.DensityMatrix(result.data(0)[save_label])
self.assertAlmostEqual(value, target)
def _target_quantum_state(
cls,
circuit: QuantumCircuit,
measurement_qubits: Optional[Sequence[int]] = None):
"""Return the state tomography target"""
# Check if circuit contains measure instructions
# If so we cannot return target state
circuit_ops = circuit.count_ops()
if "measure" in circuit_ops:
return None
perm_circ = cls._permute_circuit(circuit,
measurement_qubits=measurement_qubits)
try:
if "reset" in circuit_ops or "kraus" in circuit_ops or "superop" in circuit_ops:
state = qi.DensityMatrix(perm_circ)
else:
state = qi.Statevector(perm_circ)
except QiskitError:
# Circuit couldn't be simulated
return None
total_qubits = circuit.num_qubits
if measurement_qubits:
num_meas = len(measurement_qubits)
else:
num_meas = total_qubits
if num_meas == total_qubits:
return state
# Trace out non-measurement qubits
tr_qargs = range(num_meas, total_qubits)
return qi.partial_trace(state, tr_qargs)
def test_save_expval_var_cptp_pauli(self, pauli):
"""Test Pauli expval_var for stabilizer circuit"""
SUPPORTED_METHODS = [
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust'
]
SEED = 5832
opts = self.BACKEND_OPTS.copy()
if opts.get('method') in SUPPORTED_METHODS:
oper = qi.Pauli(pauli)
# CPTP channel test circuit
channel = qi.random_quantum_channel(4, seed=SEED)
state_circ = QuantumCircuit(2)
state_circ.append(channel, range(2))
state = qi.DensityMatrix(state_circ)
expval = state.expectation_value(oper).real
variance = state.expectation_value(oper**2).real - expval**2
target = [expval, variance]
# Snapshot circuit
circ = transpile(state_circ, self.SIMULATOR)
circ.save_expectation_value_variance(oper, [0, 1], label='expval')
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertTrue(allclose(value, target))
def _test_save_expval(self, circuit, oper, qubits, variance, **options):
"""Test Pauli expval for stabilizer circuit"""
backend = self.backend(**options)
label = 'expval'
# Format operator and target value
circ = circuit.copy()
oper = qi.Operator(oper)
state = qi.DensityMatrix(circ)
expval = state.expectation_value(oper, qubits).real
if variance:
var = state.expectation_value(oper**2, qubits).real - expval**2
target = [expval, var]
circ.save_expectation_value_variance(oper, qubits, label=label)
else:
target = expval
circ.save_expectation_value(oper, qubits, label=label)
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]
if variance:
self.assertTrue(allclose(value, target))
else:
self.assertAlmostEqual(value, target)
def test_local_pbasis_default_densitymatrix(self):
"""Test default states kwarg"""
default_states = [qi.random_density_matrix(2, seed=30 + i) for i in range(3)]
basis = LocalPreparationBasis("fitter_basis", default_states=default_states)
for i, state in enumerate(default_states):
basis_state = qi.DensityMatrix(basis.matrix([i], [0]))
fid = qi.state_fidelity(state, basis_state)
self.assertTrue(isclose(fid, 1))
def test_local_pbasis_qubit_states(self):
"""Test qubit states kwarg"""
size = 3
qubits = [0, 2]
qubit_states = {
qubits[0]: [qi.random_density_matrix(2, seed=30 + i) for i in range(size)],
qubits[1]: [qi.random_statevector(2, seed=40 + i) for i in range(size)],
}
basis = LocalPreparationBasis("fitter_basis", qubit_states=qubit_states)
# Check states
indices = it.product(range(size), repeat=2)
for index in indices:
basis_state = qi.DensityMatrix(basis.matrix(index, qubits))
target0 = qi.DensityMatrix(qubit_states[qubits[0]][index[0]])
target1 = qi.DensityMatrix(qubit_states[qubits[1]][index[1]])
target = target0.expand(target1)
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def test_local_pbasis_default_and_qubit_states(self):
"""Test qubit states kwarg"""
size = 3
qubits = [2, 0]
default_states = [qi.random_density_matrix(2, seed=20 + i) for i in range(size)]
qubit_states = {2: [qi.random_statevector(2, seed=40 + i) for i in range(size)]}
basis = LocalPreparationBasis(
"fitter_basis", default_states=default_states, qubit_states=qubit_states
)
# Check states
indices = it.product(range(size), repeat=2)
states0 = qubit_states[qubits[0]] if qubits[0] in qubit_states else default_states
states1 = qubit_states[qubits[1]] if qubits[1] in qubit_states else default_states
for index in indices:
basis_state = qi.DensityMatrix(basis.matrix(index, qubits))
target = qi.DensityMatrix(states0[index[0]]).expand(states1[index[1]])
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def _test_gate(self, gate, gates_dict, **options):
"""Test standard gates."""
backend = self.backend(**options)
gate_cls, num_angles, has_ctrl_qubits = gates_dict[gate]
circuits = self.gate_circuits(gate_cls,
num_angles=num_angles,
has_ctrl_qubits=has_ctrl_qubits,
rng=self.RNG)
label = 'final'
method = backend.options.method
for circuit in circuits:
if method == 'density_matrix':
target = qi.DensityMatrix(circuit)
circuit.save_density_matrix(label=label)
state_fn = qi.DensityMatrix
fidelity_fn = qi.state_fidelity
elif method == 'stabilizer':
target = qi.Clifford(circuit)
circuit.save_stabilizer(label=label)
state_fn = qi.Clifford.from_dict
fidelity_fn = qi.process_fidelity
elif method == 'unitary':
target = qi.Operator(circuit)
circuit.save_unitary(label=label)
state_fn = qi.Operator
fidelity_fn = qi.process_fidelity
elif method == 'superop':
target = qi.SuperOp(circuit)
circuit.save_superop(label=label)
state_fn = qi.SuperOp
fidelity_fn = qi.process_fidelity
else:
target = qi.Statevector(circuit)
circuit.save_statevector(label=label)
state_fn = qi.Statevector
fidelity_fn = qi.state_fidelity
result = backend.run(transpile(circuit,
backend,
optimization_level=0),
shots=1).result()
# Check results
success = getattr(result, 'success', False)
self.assertTrue(success)
data = result.data(0)
self.assertIn(label, data)
value = state_fn(data[label])
fidelity = fidelity_fn(target, value)
self.assertGreater(fidelity, 0.9999)
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_save_density_matrix_pershot_conditional(self):
"""Test pershot conditional save density matrix instruction"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust', 'density_matrix', 'density_matrix_gpu',
'density_matrix_thrust', 'matrix_product_state'
]
# Stabilizer test circuit
circ = QuantumCircuit(1)
circ.x(0)
circ.reset(0)
circ.h(0)
circ.sdg(0)
# Target statevector
target = qi.DensityMatrix(circ)
# Add save
save_key = 'state'
circ.save_density_matrix(save_key, pershot=True, conditional=True)
circ.measure_all()
# Run
shots = 10
opts = self.BACKEND_OPTS.copy()
qobj = assemble(circ, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(qobj, **opts).result()
method = opts.get('method', 'automatic')
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
data = result.data(0)
self.assertIn(save_key, data)
value = result.data(0)[save_key]
self.assertIn('0x0', value)
for state in value['0x0']:
self.assertAlmostEqual(qi.DensityMatrix(state), target)
def test_local_mbasis_default_and_qubit_states(self):
"""Test qubit and default povm kwarg"""
size = 3
outcomes = 2
qubits = [2, 0]
default_povms = (
[
[qi.random_statevector(2, seed=20 + i + j) for i in range(outcomes)]
for j in range(size)
],
)
qubit_povms = {
qubits[0]: [
[qi.random_density_matrix(2, seed=30 + i + j) for i in range(outcomes)]
for j in range(size)
],
qubits[1]: [
[qi.random_density_matrix(2, seed=40 + i + j) for i in range(outcomes)]
for j in range(size)
],
}
basis = LocalMeasurementBasis(
"fitter_basis", default_povms=default_povms, qubit_povms=qubit_povms
)
# Check states
states0 = qubit_povms[qubits[0]] if qubits[0] in qubit_povms else default_povms
states1 = qubit_povms[qubits[1]] if qubits[1] in qubit_povms else default_povms
indices = it.product(range(size), repeat=2)
outcomes = it.product(range(outcomes), repeat=len(qubits))
for index in indices:
for outcome in outcomes:
basis_state = qi.DensityMatrix(
basis.matrix(index, self._outcome_tup_to_int(outcome), qubits)
)
target0 = qi.DensityMatrix(states0[index[0]][outcome[0]])
target1 = qi.DensityMatrix(states1[index[1]][outcome[1]])
target = target0.expand(target1)
fid = qi.state_fidelity(basis_state, target)
self.assertTrue(isclose(fid, 1))
def test_save_density_matrix_conditional(self):
"""Test conditional save density matrix instruction"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust', 'density_matrix', 'density_matrix_gpu',
'density_matrix_thrust', 'matrix_product_state'
]
# Stabilizer test circuit
save_key = 'state'
circ = QuantumCircuit(2)
circ.h(0)
circ.sdg(0)
circ.cx(0, 1)
circ.measure_all()
circ.save_density_matrix(save_key, conditional=True)
# Target statevector
target = {
'0x0': qi.DensityMatrix(np.diag([1, 0, 0, 0])),
'0x3': qi.DensityMatrix(np.diag([0, 0, 0, 1]))
}
# Run
opts = self.BACKEND_OPTS.copy()
qobj = assemble(circ, self.SIMULATOR, shots=10)
result = self.SIMULATOR.run(qobj, **opts).result()
method = opts.get('method', 'automatic')
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
data = result.data(0)
self.assertIn(save_key, data)
for key, state in data[save_key].items():
self.assertIn(key, target)
self.assertAlmostEqual(qi.DensityMatrix(state), target[key])
def test_local_mbasis_default_statevector(self):
"""Test default povms kwarg"""
size = 2
outcomes = 3
default_povms = [
[qi.random_statevector(2, seed=30 + i + j) for j in range(outcomes)]
for i in range(size)
]
basis = LocalMeasurementBasis("fitter_basis", default_povms=default_povms)
for i, povm in enumerate(default_povms):
for outcome, effect in enumerate(povm):
basis_state = qi.DensityMatrix(basis.matrix([i], outcome, [0]))
fid = qi.state_fidelity(effect, basis_state)
self.assertTrue(isclose(fid, 1))
def test_save_density_matrix(self):
"""Test save density matrix for instruction"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust', 'density_matrix', 'density_matrix_gpu',
'density_matrix_thrust', 'matrix_product_state'
]
# Stabilizer test circuit
circ = QuantumCircuit(3)
circ.h(0)
circ.sdg(0)
circ.cx(0, 1)
circ.cx(0, 2)
# Target statevector
target = qi.DensityMatrix(circ)
# Add save to circuit
save_key = 'state'
circ.save_density_matrix(save_key)
# Run
opts = self.BACKEND_OPTS.copy()
qobj = assemble(circ, self.SIMULATOR)
result = self.SIMULATOR.run(qobj, **opts).result()
method = opts.get('method', 'automatic')
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
data = result.data(0)
self.assertIn(save_key, data)
value = qi.DensityMatrix(result.data(0)[save_key])
self.assertAlmostEqual(value, target)
def test_pauli_gate(self, method, device, pauli):
"""Test multi-qubit Pauli gate."""
pauli = qi.Pauli(pauli)
circuit = QuantumCircuit(pauli.num_qubits)
circuit.append(pauli, range(pauli.num_qubits))
backend = self.backend(method=method, device=device)
label = 'final'
if method == 'density_matrix':
target = qi.DensityMatrix(circuit)
circuit.save_density_matrix(label=label)
state_fn = qi.DensityMatrix
fidelity_fn = qi.state_fidelity
elif method == 'stabilizer':
target = qi.Clifford(circuit)
circuit.save_stabilizer(label=label)
state_fn = qi.Clifford.from_dict
fidelity_fn = qi.process_fidelity
elif method == 'unitary':
target = qi.Operator(circuit)
circuit.save_unitary(label=label)
state_fn = qi.Operator
fidelity_fn = qi.process_fidelity
elif method == 'superop':
target = qi.SuperOp(circuit)
circuit.save_superop(label=label)
state_fn = qi.SuperOp
fidelity_fn = qi.process_fidelity
else:
target = qi.Statevector(circuit)
circuit.save_statevector(label=label)
state_fn = qi.Statevector
fidelity_fn = qi.state_fidelity
result = backend.run(transpile(circuit, backend, optimization_level=0),
shots=1).result()
# Check results
success = getattr(result, 'success', False)
self.assertTrue(success)
data = result.data(0)
self.assertIn(label, data)
value = state_fn(data[label])
fidelity = fidelity_fn(target, value)
self.assertGreater(fidelity, 0.9999)
def test_set_density_matrix(self, method, device, num_qubits):
"""Test SetDensityMatrix instruction"""
backend = self.backend(method=method, device=device)
seed = 100
label = 'state'
target = qi.random_density_matrix(2**num_qubits, seed=seed)
circ = QuantumCircuit(num_qubits)
circ.set_density_matrix(target)
circ.save_density_matrix(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 = qi.DensityMatrix(simdata[label])
self.assertEqual(value, target)
