def _replace_pauli_sums(cls, operator):
try:
from qiskit.providers.aer.library import SaveExpectationValue
except ImportError as ex:
raise MissingOptionalLibraryError(
libname="qiskit-aer",
name="AerPauliExpectation",
pip_install="pip install qiskit-aer",
) from ex
# The 'expval_measurement' label on the save instruction is special - the
# CircuitSampler will look for it to know that the circuit is a Expectation
# measurement, and not simply a
# circuit to replace with a DictStateFn
if operator.__class__ == ListOp:
return operator.traverse(cls._replace_pauli_sums)
if isinstance(operator, PauliSumOp):
save_instruction = SaveExpectationValue(operator.primitive,
"expval_measurement")
return CircuitStateFn(save_instruction,
coeff=operator.coeff,
is_measurement=True,
from_operator=True)
# Change to Pauli representation if necessary
if {"Pauli"} != operator.primitive_strings():
logger.warning(
"Measured Observable is not composed of only Paulis, converting to "
"Pauli representation, which can be expensive.")
# Setting massive=False because this conversion is implicit. User can perform this
# action on the Observable with massive=True explicitly if they so choose.
operator = operator.to_pauli_op(massive=False)
if isinstance(operator, SummedOp):
sparse_pauli = reduce(add,
(meas.coeff * SparsePauliOp(meas.primitive)
for meas in operator.oplist))
save_instruction = SaveExpectationValue(sparse_pauli,
"expval_measurement")
return CircuitStateFn(save_instruction,
coeff=operator.coeff,
is_measurement=True,
from_operator=True)
if isinstance(operator, PauliOp):
sparse_pauli = operator.coeff * SparsePauliOp(operator.primitive)
save_instruction = SaveExpectationValue(sparse_pauli,
"expval_measurement")
return CircuitStateFn(save_instruction,
is_measurement=True,
from_operator=True)
raise TypeError(
f"Conversion of OperatorStateFn of {operator.__class__.__name__} is not defined."
)
def test_pershot_kwarg(self):
"""Test pershot kwarg"""
key = 'test_key'
instr = SaveExpectationValue(key, Pauli('X'), pershot=True)
self.assertEqual(instr.name, 'save_expval')
self.assertEqual(instr._key, key)
self.assertEqual(instr._subtype, 'list')
def test_unnorm_kwarg(self):
"""Test unnormalized kwarg"""
key = 'test_key'
instr = SaveExpectationValue(key, Pauli('X'), unnormalized=True)
self.assertEqual(instr.name, 'save_expval')
self.assertEqual(instr._key, key)
self.assertEqual(instr._subtype, 'accum')
def test_cond_kwarg(self):
"""Test conditional kwarg"""
key = 'test_key'
instr = SaveExpectationValue(key, Pauli('X'), conditional=True)
self.assertEqual(instr.name, 'save_expval')
self.assertEqual(instr._key, key)
self.assertEqual(instr._subtype, 'c_average')
def test_default_kwarg(self):
"""Test default kwargs"""
key = 'test_key'
instr = SaveExpectationValue(key, Pauli('X'))
self.assertEqual(instr.name, 'save_expval')
self.assertEqual(instr._key, key)
self.assertEqual(instr._subtype, 'average')
def test_pershot_cond_kwarg(self):
"""Test pershot, conditonal kwargs"""
key = 'test_key'
instr = SaveExpectationValue(key,
Pauli('X'),
conditional=True,
pershot=True)
self.assertEqual(instr.name, 'save_expval')
self.assertEqual(instr._key, key)
self.assertEqual(instr._subtype, 'c_list')
def test_unnorm_cond_kwarg(self):
"""Test unnormalized, conditonal kwargs"""
key = 'test_key'
instr = SaveExpectationValue(Pauli('X'),
key,
conditional=True,
unnormalized=True)
self.assertEqual(instr.name, 'save_expval')
self.assertEqual(instr._label, key)
self.assertEqual(instr._subtype, 'c_accum')
def test_nonhermitian_raises(self):
"""Test non-Hermitian op raises exception."""
op = [[0, 1j], [1j, 0]]
self.assertRaises(ExtensionError,
lambda: SaveExpectationValue('expval', op))
def test_invalid_key_raises(self):
"""Test save instruction key is str"""
self.assertRaises(ExtensionError,
lambda: SaveExpectationValue(1, Pauli('Z')))
