def test_phase_damping_error_canonical(self):
"""Test phase damping error with canonical kraus"""
p_phase = 0.3
error = phase_damping_error(p_phase, canonical_kraus=True)
# The canonical form of this channel should be a mixed
# unitary dephasing channel
targets = [qi.Pauli("I").to_matrix(),
qi.Pauli("Z").to_matrix()]
self.assertEqual(error.size, 1)
circ, p = error.error_term(0)
self.assertEqual(p, 1, msg="Kraus probability")
self.assertEqual(circ[0][1], [circ.qubits[0]])
for actual, expected in zip(circ[0][0].params, targets):
self.assertTrue(np.allclose(actual/actual[0][0], expected),
msg="Incorrect kraus matrix")
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_nonstabilizer_pauli(self, pauli):
"""Test Pauli expval for non-stabilizer circuit"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust',
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust',
'matrix_product_state'
]
SEED = 7382
# Stabilizer test circuit
state_circ = QuantumVolume(2, 1, seed=SEED)
oper = qi.Pauli(pauli)
state = qi.Statevector(state_circ)
target = state.expectation_value(oper).real.round(10)
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
method = opts.get('method', 'automatic')
circ = transpile(state_circ, basis_gates=['u1', 'u2', 'u3', 'cx', 'swap'])
circ.save_expectation_value('expval', oper, [0, 1])
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertAlmostEqual(value, target)
def test_save_expval_var_stabilizer_pauli(self, pauli):
"""Test Pauli expval_var for stabilizer circuit"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust',
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust',
'matrix_product_state', 'stabilizer'
]
SEED = 5832
# Stabilizer test circuit
state_circ = qi.random_clifford(2, seed=SEED).to_circuit()
oper = qi.Pauli(pauli)
state = qi.Statevector(state_circ)
expval = state.expectation_value(oper).real
variance = state.expectation_value(oper ** 2).real - expval ** 2
target = [expval, variance]
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
method = opts.get('method', 'automatic')
circ = transpile(state_circ, basis_gates=[
'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'cx', 'cz', 'swap'])
circ.save_expectation_value_variance('expval', oper, [0, 1])
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertTrue(allclose(value, target))
def test_save_expval_var_nonstabilizer_pauli(self, pauli):
"""Test Pauli expval_var for non-stabilizer circuit"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust', 'density_matrix', 'density_matrix_gpu',
'density_matrix_thrust', 'matrix_product_state',
'extended_stabilizer'
]
SEED = 7382
# Stabilizer test circuit
state_circ = QuantumVolume(2, 1, seed=SEED)
oper = qi.Operator(qi.Pauli(pauli))
state = qi.Statevector(state_circ)
expval = state.expectation_value(oper).real
variance = state.expectation_value(oper**2).real - expval**2
target = [expval, variance]
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
method = opts.get('method', 'automatic')
circ = transpile(state_circ,
basis_gates=['u1', 'u2', 'u3', 'cx', 'swap'])
circ.save_expectation_value_variance(oper, [0, 1], label='expval')
qobj = assemble(circ)
result = self.SIMULATOR.run(qobj, **opts).result()
if method not in SUPPORTED_METHODS:
self.assertFalse(result.success)
else:
self.assertTrue(result.success)
value = result.data(0)['expval']
self.assertTrue(allclose(value, target))
def test_save_expval_stabilizer_pauli(self, pauli):
"""Test Pauli expval for stabilizer circuit"""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust',
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust',
'matrix_product_state', 'stabilizer'
]
SEED = 5832
# Stabilizer test circuit
state = qi.random_clifford(2, seed=SEED).to_circuit()
oper = qi.Pauli(pauli)
target = qi.Statevector(state).expectation_value(oper).real.round(10)
# Snapshot circuit
opts = self.BACKEND_OPTS.copy()
circ = transpile(state, self.SIMULATOR)
circ.save_expectation_value('expval', oper, [0, 1])
qobj = assemble(circ)
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)
value = result.data(0)['expval']
self.assertAlmostEqual(value, target)
def test_pauli_error_2q_unitary_from_pauli(self):
"""Test two-qubit pauli error as unitary qobj from Pauli obj"""
from qiskit.extensions import UnitaryGate
paulis = [qi.Pauli(s) for s in ['XY', 'YZ', 'ZX']]
probs = [0.5, 0.3, 0.2]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=False)
X = qi.Pauli("X").to_matrix()
Y = qi.Pauli("Y").to_matrix()
Z = qi.Pauli("Z").to_matrix()
target_unitaries = [np.kron(X, Y), np.kron(Y, Z), np.kron(Z, X)]
expected = QuantumError([(UnitaryGate(mat), p) for mat, p in zip(target_unitaries, probs)])
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ)
self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_1q_unitary_from_pauli(self):
"""Test single-qubit pauli error as unitary qobj from Pauli obj"""
from qiskit.extensions import UnitaryGate
paulis = [qi.Pauli(s) for s in ['I', 'X', 'Y', 'Z']]
probs = [0.4, 0.3, 0.2, 0.1]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=False)
target_unitaries = [qi.Pauli("I").to_matrix(),
qi.Pauli("X").to_matrix(),
qi.Pauli("Y").to_matrix(),
qi.Pauli("Z").to_matrix()]
expected = QuantumError([(UnitaryGate(mat), p) for mat, p in zip(target_unitaries, probs)])
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ)
self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_1q_gate_from_pauli(self):
"""Test single-qubit pauli error as gate qobj from Pauli obj"""
paulis = [qi.Pauli(s) for s in ['I', 'X', 'Y', 'Z']]
probs = [0.4, 0.3, 0.2, 0.1]
actual = pauli_error(zip(paulis, probs))
expected = QuantumError([(IGate(), 0.4), (XGate(), 0.3), (YGate(), 0.2), (ZGate(), 0.1)])
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ, msg=f"Incorrect {i}-th circuit")
self.assertAlmostEqual(prob, expected_prob, msg=f"Incorrect {i}-th probability")
def test_save_expval_var_stabilizer_pauli(self, method, device, pauli):
"""Test Pauli expval_var for stabilizer circuit"""
SEED = 5832
circ = qi.random_clifford(2, seed=SEED).to_circuit()
oper = qi.Operator(qi.Pauli(pauli))
qubits = [0, 1]
self._test_save_expval(circ,
oper,
qubits,
True,
method=method,
device=device)
def test_save_expval_var_nonstabilizer_pauli(self, method, device, pauli):
"""Test Pauli expval_var for non-stabilizer circuit"""
SEED = 7382
circ = QuantumVolume(2, 1, seed=SEED)
oper = qi.Operator(qi.Pauli(pauli))
qubits = [0, 1]
self._test_save_expval(circ,
oper,
qubits,
True,
method=method,
device=device)
def test_save_expval_bell_pauli(self, method, device, pauli):
"""Test Pauli expval for Bell state circuit"""
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0, 1)
oper = qi.Pauli(pauli)
qubits = [0, 1]
self._test_save_expval(circ,
oper,
qubits,
False,
method=method,
device=device)
def test_save_expval_var_cptp_pauli(self, method, device, pauli):
"""Test Pauli expval_var for stabilizer circuit"""
SEED = 5832
oper = qi.Operator(qi.Operator(qi.Pauli(pauli)))
channel = qi.random_quantum_channel(4, seed=SEED)
circ = QuantumCircuit(2)
circ.append(channel, range(2))
qubits = [0, 1]
self._test_save_expval(circ,
oper,
qubits,
True,
method=method,
device=device)
def test_pauli_error_2q_gate_from_pauli(self):
"""Test two-qubit pauli error as gate qobj from Pauli obj"""
paulis = [qi.Pauli(s) for s in ['XZ', 'YX', 'ZY']]
probs = [0.5, 0.3, 0.2]
actual = pauli_error(zip(paulis, probs))
expected = QuantumError(
[(PauliGate("XZ"), 0.5), (PauliGate("YX"), 0.3), (PauliGate("ZY"), 0.2)]
)
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ, msg=f"Incorrect {i}-th circuit")
self.assertAlmostEqual(prob, expected_prob, msg=f"Incorrect {i}-th probability")
def test_save_expval_stabilizer_pauli_cache_blocking(
self, method, device, pauli):
"""Test Pauli expval for stabilizer circuit"""
SEED = 5832
circ = qi.random_clifford(2, seed=SEED).to_circuit()
oper = qi.Operator(qi.Pauli(pauli))
qubits = [0, 1]
self._test_save_expval(circ,
oper,
qubits,
False,
method=method,
device=device,
blocking_qubits=2,
max_parallel_threads=1)
def OTOCoutcome(circ):
""" OTOC measurement via expval of Pauli Y on the ancilla qubit
Args:
circ (Circuit): valid quantum circuit
Returns:
Float: expectation value of Pauli Y, in [-1,1]
"""
# Noisy simulator definition
simulator = Aer.get_backend("qasm_simulator")
otocCirc = transpile(circ, simulator)
# Operator to take expectation value of
qubitM = qi.Pauli("Y")
qubitT = [0]
otocCirc.save_expectation_value(qubitM, qubitT)
result = simulator.run(otocCirc).result()
exp = result.data()["expectation_value"]
return exp
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_pauli_error_2q_gate_from_pauli(self):
"""Test two-qubit pauli error as gate qobj from Pauli obj"""
paulis = [qi.Pauli(s) for s in ['XZ', 'YX', 'ZY']]
probs = [0.5, 0.3, 0.2]
with self.assertWarns(DeprecationWarning):
actual = pauli_error(zip(paulis, probs), standard_gates=True)
target_circs = [[{"name": "z", "qubits": [0]}, {"name": "x", "qubits": [1]}],
[{"name": "x", "qubits": [0]}, {"name": "y", "qubits": [1]}],
[{"name": "y", "qubits": [0]}, {"name": "z", "qubits": [1]}]]
with self.assertWarns(DeprecationWarning):
expected = QuantumError(zip(target_circs, probs), standard_gates=True)
for i in range(actual.size):
circ, prob = actual.error_term(i)
expected_circ, expected_prob = expected.error_term(i)
self.assertEqual(circ, expected_circ)
self.assertAlmostEqual(prob, expected_prob)
