def _check_quantum_instance_and_modes_consistent(self) -> None:
""" Checks whether the statevector and param_qobj settings are compatible with the
backend
Raises:
ValueError: statevector or param_qobj are True when not supported by backend.
"""
if self._statevector and not is_statevector_backend(self.quantum_instance.backend):
raise ValueError('Statevector mode for circuit sampling requires statevector '
'backend, not {}.'.format(self.quantum_instance.backend))
if self._param_qobj and not is_aer_provider(self.quantum_instance.backend):
raise ValueError('Parameterized Qobj mode requires Aer '
'backend, not {}.'.format(self.quantum_instance.backend))
def is_statevector(self):
"""Return True if backend is a statevector-type simulator."""
return is_statevector_backend(self._backend)
def build(operator: OperatorBase,
backend: Optional[Union[Backend, BaseBackend,
QuantumInstance]] = None,
include_custom: bool = True) -> ExpectationBase:
"""
A factory method for convenient automatic selection of an Expectation based on the
Operator to be converted and backend used to sample the expectation value.
Args:
operator: The Operator whose expectation value will be taken.
backend: The backend which will be used to sample the expectation value.
include_custom: Whether the factory will include the (Aer) specific custom
expectations if their behavior against the backend might not be as expected.
For instance when using Aer qasm_simulator with paulis the Aer snapshot can
be used but the outcome lacks shot noise and hence does not intuitively behave
overall as people might expect when choosing a qasm_simulator. It is however
fast as long as the more state vector like behavior is acceptable.
Returns:
The expectation algorithm which best fits the Operator and backend.
Raises:
ValueError: If operator is not of a composition for which we know the best Expectation
method.
"""
backend_to_check = backend.backend if isinstance(
backend, QuantumInstance) else backend
# pylint: disable=cyclic-import,import-outside-toplevel
primitives = operator.primitive_strings()
if primitives in ({'Pauli'}, {'SparsePauliOp'}):
if backend_to_check is None:
# If user has Aer but didn't specify a backend, use the Aer fast expectation
if has_aer():
from qiskit import Aer
backend_to_check = Aer.get_backend('qasm_simulator')
# If user doesn't have Aer, use statevector_simulator
# for < 16 qubits, and qasm with warning for more.
else:
if operator.num_qubits <= 16:
backend_to_check = BasicAer.get_backend(
'statevector_simulator')
else:
logging.warning(
'%d qubits is a very large expectation value. '
'Consider installing Aer to use '
'Aer\'s fast expectation, which will perform better here. We\'ll use '
'the BasicAer qasm backend for this expectation to avoid having to '
'construct the %dx%d operator matrix.',
operator.num_qubits, 2**operator.num_qubits,
2**operator.num_qubits)
backend_to_check = BasicAer.get_backend(
'qasm_simulator')
# If the user specified Aer qasm backend and is using a
# Pauli operator, use the Aer fast expectation if we are including such
# custom behaviors.
if is_aer_qasm(backend_to_check) and include_custom:
return AerPauliExpectation()
# If the user specified a statevector backend (either Aer or BasicAer),
# use a converter to produce a
# Matrix operator and compute using matmul
elif is_statevector_backend(backend_to_check):
if operator.num_qubits >= 16:
logging.warning(
'Note: Using a statevector_simulator with %d qubits can be very expensive. '
'Consider using the Aer qasm_simulator instead to take advantage of Aer\'s '
'built-in fast Pauli Expectation', operator.num_qubits)
return MatrixExpectation()
# All other backends, including IBMQ, BasicAer QASM, go here.
else:
return PauliExpectation()
elif primitives == {'Matrix'}:
return MatrixExpectation()
else:
raise ValueError(
'Expectations of Mixed Operators not yet supported.')