Dict-based aux_operators

.pylintdict

@@ -22,6 +22,7 @@ arxiv
 asparagine
 aspartic
 atol
+attr
 autosummary
 avogadro
 äquivalenzverbot

qiskit_nature/__init__.py

@@ -49,11 +49,18 @@
 
 """
 
+from typing import Dict, List, Optional, TypeVar, Union
 from .version import __version__
 from .exceptions import QiskitNatureError, UnsupportMethodError
 
+# pylint: disable=invalid-name
+T = TypeVar("T")
+ListOrDictType = Union[List[Optional[T]], Dict[Union[int, str], T]]
+
+
 __all__ = [
     "__version__",
     "QiskitNatureError",
     "UnsupportMethodError",
+    "ListOrDictType",
 ]

qiskit_nature/algorithms/excited_states_solvers/excited_states_eigensolver.py

@@ -12,12 +12,14 @@
 
 """The calculation of excited states via an Eigensolver algorithm"""
 
-from typing import List, Union, Optional
+from typing import Union, Optional
 
 from qiskit.algorithms import Eigensolver
 from qiskit.opflow import PauliSumOp
 
+from qiskit_nature import ListOrDictType
 from qiskit_nature.converters.second_quantization import QubitConverter
+from qiskit_nature.converters.second_quantization.utils import ListOrDict
 from qiskit_nature.operators.second_quantization import SecondQuantizedOp
 from qiskit_nature.problems.second_quantization import BaseProblem
 from qiskit_nature.results import EigenstateResult
@@ -58,17 +60,20 @@ def solver(self, solver: Union[Eigensolver, EigensolverFactory]) -> None:
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        dict_based_aux_ops: bool = False,
     ) -> EigenstateResult:
         """Compute Ground and Excited States properties.
 
         Args:
             problem: a class encoding a problem to be solved.
             aux_operators: Additional auxiliary operators to evaluate.
+            dict_based_aux_ops: if True, the auxiliary operators will be stored in a `dict` rather
+                than `list`.
 
         Raises:
-            NotImplementedError: If an operator in ``aux_operators`` is not of type
-                ``FermionicOperator``.
+            ValueError: if the grouped property object returned by the driver does not contain a
+                main property as requested by the problem being solved (`problem.main_property_name`)
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also
@@ -77,21 +82,42 @@ def solve(
         # get the operator and auxiliary operators, and transform the provided auxiliary operators
         # note that ``aux_operators`` contains not only the transformed ``aux_operators`` passed
         # by the user but also additional ones from the transformation
-        second_q_ops = problem.second_q_ops()
+        second_q_ops = problem.second_q_ops(return_list=not dict_based_aux_ops)
+
+        aux_second_q_ops: ListOrDictType[SecondQuantizedOp]
+        if isinstance(second_q_ops, list):
+            main_second_q_op = second_q_ops[0]
+            aux_second_q_ops = second_q_ops[1:]
+        elif isinstance(second_q_ops, dict):
+            name = problem.main_property_name
+            main_second_q_op = second_q_ops.pop(name, None)
+            if main_second_q_op is None:
+                raise ValueError(
+                    f"The main `SecondQuantizedOp` associated with the {name} property cannot be "
+                    "`None`."
+                )
+            aux_second_q_ops = second_q_ops
 
         main_operator = self._qubit_converter.convert(
-            second_q_ops[0],
+            main_second_q_op,
             num_particles=problem.num_particles,
             sector_locator=problem.symmetry_sector_locator,
         )
-        aux_ops = self._qubit_converter.convert_match(second_q_ops[1:])
+        aux_ops = self._qubit_converter.convert_match(aux_second_q_ops)
 
         if aux_operators is not None:
-            for aux_op in aux_operators:
+            wrapped_aux_operators: ListOrDict[Union[SecondQuantizedOp, PauliSumOp]] = ListOrDict(
+                aux_operators
+            )
+            for name, aux_op in iter(wrapped_aux_operators):
                 if isinstance(aux_op, SecondQuantizedOp):
-                    aux_ops.append(self._qubit_converter.convert_match(aux_op, True))
+                    converted_aux_op = self._qubit_converter.convert_match(aux_op, True)
                 else:
-                    aux_ops.append(aux_op)
+                    converted_aux_op = aux_op
+                if isinstance(aux_ops, list):
+                    aux_ops.append(converted_aux_op)
+                elif isinstance(aux_ops, dict):
+                    aux_ops[name] = converted_aux_op
 
         if isinstance(self._solver, EigensolverFactory):
             # this must be called after transformation.transform

qiskit_nature/algorithms/excited_states_solvers/excited_states_solver.py

@@ -13,10 +13,11 @@
 """ The excited states calculation interface """
 
 from abc import ABC, abstractmethod
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 from qiskit.opflow import PauliSumOp
 
+from qiskit_nature import ListOrDictType
 from qiskit_nature.operators.second_quantization import SecondQuantizedOp
 from qiskit_nature.problems.second_quantization import BaseProblem
 from qiskit_nature.results import EigenstateResult
@@ -29,13 +30,16 @@ class ExcitedStatesSolver(ABC):
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        dict_based_aux_ops: bool = False,
     ) -> EigenstateResult:
         r"""Compute the excited states energies of the molecule that was supplied via the driver.
 
         Args:
             problem: a class encoding a problem to be solved.
             aux_operators: Additional auxiliary operators to evaluate.
+            dict_based_aux_ops: if True, the auxiliary operators will be stored in a `dict` rather
+                than `list`.
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also

qiskit_nature/algorithms/excited_states_solvers/qeom.py

@@ -30,6 +30,7 @@
     PauliSumOp,
 )
 
+from qiskit_nature import ListOrDictType
 from qiskit_nature.operators.second_quantization import SecondQuantizedOp
 from qiskit_nature.problems.second_quantization import BaseProblem
 from qiskit_nature.results import EigenstateResult
@@ -79,7 +80,8 @@ def excitations(self, excitations: Union[str, List[List[int]]]) -> None:
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[SecondQuantizedOp]] = None,
+        aux_operators: Optional[ListOrDictType[SecondQuantizedOp]] = None,
+        dict_based_aux_ops: bool = False,
     ) -> EigenstateResult:
         """Run the excited-states calculation.
 
@@ -89,6 +91,8 @@ def solve(
         Args:
             problem: a class encoding a problem to be solved.
             aux_operators: Additional auxiliary operators to evaluate.
+            dict_based_aux_ops: if True, the auxiliary operators will be stored in a `dict` rather
+                than `list`.
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also
@@ -105,7 +109,13 @@ def solve(
         groundstate_result = self._gsc.solve(problem)
 
         # 2. Prepare the excitation operators
-        self._untapered_qubit_op_main = self._gsc._qubit_converter.map(problem.second_q_ops()[0])
+        second_q_ops = problem.second_q_ops(return_list=not dict_based_aux_ops)
+        if isinstance(second_q_ops, list):
+            main_second_q_op = second_q_ops[0]
+        elif isinstance(second_q_ops, dict):
+            main_second_q_op = second_q_ops.pop(problem.main_property_name)
+
+        self._untapered_qubit_op_main = self._gsc._qubit_converter.map(main_second_q_op)
         matrix_operators_dict, size = self._prepare_matrix_operators(problem)
 
         # 3. Evaluate eom operators

qiskit_nature/algorithms/ground_state_solvers/adapt_vqe.py

@@ -24,10 +24,12 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.opflow import OperatorBase, PauliSumOp
 from qiskit.utils.validation import validate_min
+from qiskit_nature import ListOrDictType
 from qiskit_nature.exceptions import QiskitNatureError
 from qiskit_nature.circuit.library import UCC
 from qiskit_nature.operators.second_quantization import SecondQuantizedOp
 from qiskit_nature.converters.second_quantization import QubitConverter
+from qiskit_nature.converters.second_quantization.utils import ListOrDict
 from qiskit_nature.problems.second_quantization import BaseProblem
 from qiskit_nature.results import ElectronicStructureResult
 
@@ -136,38 +138,64 @@ def _check_cyclicity(indices: List[int]) -> bool:
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        dict_based_aux_ops: bool = False,
     ) -> "AdaptVQEResult":
         """Computes the ground state.
 
         Args:
             problem: a class encoding a problem to be solved.
             aux_operators: Additional auxiliary operators to evaluate.
+            dict_based_aux_ops: if True, the auxiliary operators will be stored in a `dict` rather
+                than `list`.
 
         Raises:
             QiskitNatureError: if a solver other than VQE or a ansatz other than UCCSD is provided
                 or if the algorithm finishes due to an unforeseen reason.
+            ValueError: if the grouped property object returned by the driver does not contain a
+                main property as requested by the problem being solved (`problem.main_property_name`)
 
         Returns:
             An AdaptVQEResult which is an ElectronicStructureResult but also includes runtime
             information about the AdaptVQE algorithm like the number of iterations, finishing
             criterion, and the final maximum gradient.
         """
-        second_q_ops = problem.second_q_ops()
+        second_q_ops = problem.second_q_ops(return_list=not dict_based_aux_ops)
+
+        aux_second_q_ops: ListOrDictType[SecondQuantizedOp]
+        if isinstance(second_q_ops, list):
+            main_second_q_op = second_q_ops[0]
+            aux_second_q_ops = second_q_ops[1:]
+        elif isinstance(second_q_ops, dict):
+            name = problem.main_property_name
+            main_second_q_op = second_q_ops.pop(name, None)
+            if main_second_q_op is None:
+                raise ValueError(
+                    f"The main `SecondQuantizedOp` associated with the {name} property cannot be "
+                    "`None`."
+                )
+            aux_second_q_ops = second_q_ops
 
         self._main_operator = self._qubit_converter.convert(
-            second_q_ops[0],
+            main_second_q_op,
             num_particles=problem.num_particles,
             sector_locator=problem.symmetry_sector_locator,
         )
-        aux_ops = self._qubit_converter.convert_match(second_q_ops[1:])
+        aux_ops = self._qubit_converter.convert_match(aux_second_q_ops)
 
         if aux_operators is not None:
-            for aux_op in aux_operators:
+            wrapped_aux_operators: ListOrDict[Union[SecondQuantizedOp, PauliSumOp]] = ListOrDict(
+                aux_operators
+            )
+            for name, aux_op in iter(wrapped_aux_operators):
                 if isinstance(aux_op, SecondQuantizedOp):
-                    aux_ops.append(self._qubit_converter.convert_match(aux_op, True))
+                    converted_aux_op = self._qubit_converter.convert_match(aux_op, True)
                 else:
-                    aux_ops.append(aux_op)
+                    converted_aux_op = aux_op
+                if isinstance(aux_ops, list):
+                    aux_ops.append(converted_aux_op)
+                elif isinstance(aux_ops, dict):
+                    aux_ops[name] = converted_aux_op
 
         if isinstance(self._solver, MinimumEigensolverFactory):
             vqe = self._solver.get_solver(problem, self._qubit_converter)

qiskit_nature/algorithms/ground_state_solvers/ground_state_eigensolver.py

@@ -22,8 +22,10 @@
 from qiskit.algorithms import MinimumEigensolver
 from qiskit.opflow import OperatorBase, PauliSumOp, StateFn, CircuitSampler
 
+from qiskit_nature import ListOrDictType
 from qiskit_nature.operators.second_quantization import SecondQuantizedOp
 from qiskit_nature.converters.second_quantization import QubitConverter
+from qiskit_nature.converters.second_quantization.utils import ListOrDict
 from qiskit_nature.problems.second_quantization import BaseProblem
 from qiskit_nature.results import EigenstateResult
 from .ground_state_solver import GroundStateSolver
@@ -65,17 +67,20 @@ def returns_groundstate(self) -> bool:
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        dict_based_aux_ops: bool = False,
     ) -> EigenstateResult:
         """Compute Ground State properties.
 
         Args:
             problem: a class encoding a problem to be solved.
             aux_operators: Additional auxiliary operators to evaluate.
+            dict_based_aux_ops: if True, the auxiliary operators will be stored in a `dict` rather
+                than `list`.
 
         Raises:
-            NotImplementedError: If an operator in ``aux_operators`` is not of type
-                ``FermionicOperator``.
+            ValueError: if the grouped property object returned by the driver does not contain a
+                main property as requested by the problem being solved (`problem.main_property_name`)
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also
@@ -84,21 +89,42 @@ def solve(
         # get the operator and auxiliary operators, and transform the provided auxiliary operators
         # note that ``aux_ops`` contains not only the transformed ``aux_operators`` passed by the
         # user but also additional ones from the transformation
-        second_q_ops = problem.second_q_ops()
+        second_q_ops = problem.second_q_ops(return_list=not dict_based_aux_ops)
+
+        aux_second_q_ops: ListOrDictType[SecondQuantizedOp]
+        if isinstance(second_q_ops, list):
+            main_second_q_op = second_q_ops[0]
+            aux_second_q_ops = second_q_ops[1:]
+        elif isinstance(second_q_ops, dict):
+            name = problem.main_property_name
+            main_second_q_op = second_q_ops.pop(name, None)
+            if main_second_q_op is None:
+                raise ValueError(
+                    f"The main `SecondQuantizedOp` associated with the {name} property cannot be "
+                    "`None`."
+                )
+            aux_second_q_ops = second_q_ops
 
         main_operator = self._qubit_converter.convert(
-            second_q_ops[0],
+            main_second_q_op,
             num_particles=problem.num_particles,
             sector_locator=problem.symmetry_sector_locator,
         )
-        aux_ops = self._qubit_converter.convert_match(second_q_ops[1:])
+        aux_ops = self._qubit_converter.convert_match(aux_second_q_ops)
 
         if aux_operators is not None:
-            for aux_op in aux_operators:
+            wrapped_aux_operators: ListOrDict[Union[SecondQuantizedOp, PauliSumOp]] = ListOrDict(
+                aux_operators
+            )
+            for name, aux_op in iter(wrapped_aux_operators):
                 if isinstance(aux_op, SecondQuantizedOp):
-                    aux_ops.append(self._qubit_converter.convert_match(aux_op, True))
+                    converted_aux_op = self._qubit_converter.convert_match(aux_op, True)
                 else:
-                    aux_ops.append(aux_op)
+                    converted_aux_op = aux_op
+                if isinstance(aux_ops, list):
+                    aux_ops.append(converted_aux_op)
+                elif isinstance(aux_ops, dict):
+                    aux_ops[name] = converted_aux_op
 
         if isinstance(self._solver, MinimumEigensolverFactory):
             # this must be called after transformation.transform

qiskit_nature/algorithms/ground_state_solvers/ground_state_solver.py

@@ -22,6 +22,7 @@
 from qiskit.result import Result
 from qiskit.opflow import OperatorBase, PauliSumOp
 
+from qiskit_nature import ListOrDictType
 from qiskit_nature.operators.second_quantization import SecondQuantizedOp
 from qiskit_nature.converters.second_quantization import QubitConverter
 from qiskit_nature.problems.second_quantization import BaseProblem
@@ -43,13 +44,16 @@ def __init__(self, qubit_converter: QubitConverter) -> None:
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        dict_based_aux_ops: bool = False,
     ) -> EigenstateResult:
         """Compute the ground state energy of the molecule that was supplied via the driver.
 
         Args:
             problem: a class encoding a problem to be solved.
             aux_operators: Additional auxiliary operators to evaluate.
+            dict_based_aux_ops: if True, the auxiliary operators will be stored in a `dict` rather
+                than `list`.
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also