Dict-based aux_operators

.pylintdict

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

qiskit_nature/__init__.py

@@ -49,11 +49,19 @@
 
 """
 
-from .version import __version__
+from qiskit.algorithms.minimum_eigen_solvers.minimum_eigen_solver import (
+    ListOrDict as ListOrDictType,
+)
+
 from .exceptions import QiskitNatureError, UnsupportMethodError
+from .settings import settings
+from .version import __version__
+
 
 __all__ = [
     "__version__",
+    "ListOrDictType",
     "QiskitNatureError",
     "UnsupportMethodError",
+    "settings",
 ]

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, QiskitNatureError
 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,7 +60,7 @@ 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,
     ) -> EigenstateResult:
         """Compute Ground and Excited States properties.
 
@@ -67,8 +69,12 @@ def solve(
             aux_operators: Additional auxiliary operators to evaluate.
 
         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`)
+            QiskitNatureError: if the user-provided `aux_operators` contain a name which clashes
+                with an internally constructed auxiliary operator. Note: the names used for the
+                internal auxiliary operators correspond to the `Property.name` attributes which
+                generated the respective operators.
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also
@@ -79,19 +85,46 @@ def solve(
         # by the user but also additional ones from the transformation
         second_q_ops = problem.second_q_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):
+                    if name in aux_ops.keys():
+                        raise QiskitNatureError(
+                            f"The key '{name}' is already taken by an internally constructed "
+                            "auxliliary operator! Please use a different name for your custom "
+                            "operator."
+                        )
+                    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,7 +30,7 @@ class ExcitedStatesSolver(ABC):
     def solve(
         self,
         problem: BaseProblem,
-        aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None,
+        aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None,
     ) -> EigenstateResult:
         r"""Compute the excited states energies of the molecule that was supplied via the driver.
 

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,7 @@ 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,
     ) -> EigenstateResult:
         """Run the excited-states calculation.
 
@@ -102,13 +103,18 @@ def solve(
             )
 
         # 1. Run ground state calculation
-        groundstate_result = self._gsc.solve(problem)
+        groundstate_result = self._gsc.solve(problem, aux_operators)
 
         # 2. Prepare the excitation operators
+        second_q_ops = problem.second_q_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.convert_only(
-            problem.second_q_ops()[0], problem.num_particles
+            main_second_q_op, problem.num_particles
         )
-
         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,7 +138,7 @@ 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,
     ) -> "AdaptVQEResult":
         """Computes the ground state.
 
@@ -147,6 +149,12 @@ def solve(
         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`)
+            QiskitNatureError: if the user-provided `aux_operators` contain a name which clashes
+                with an internally constructed auxiliary operator. Note: the names used for the
+                internal auxiliary operators correspond to the `Property.name` attributes which
+                generated the respective operators.
 
         Returns:
             An AdaptVQEResult which is an ElectronicStructureResult but also includes runtime
@@ -155,19 +163,46 @@ def solve(
         """
         second_q_ops = problem.second_q_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):
+                    if name in aux_ops.keys():
+                        raise QiskitNatureError(
+                            f"The key '{name}' is already taken by an internally constructed "
+                            "auxliliary operator! Please use a different name for your custom "
+                            "operator."
+                        )
+                    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, QiskitNatureError
 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,7 +67,7 @@ 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,
     ) -> EigenstateResult:
         """Compute Ground State properties.
 
@@ -74,8 +76,12 @@ def solve(
             aux_operators: Additional auxiliary operators to evaluate.
 
         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`)
+            QiskitNatureError: if the user-provided `aux_operators` contain a name which clashes
+                with an internally constructed auxiliary operator. Note: the names used for the
+                internal auxiliary operators correspond to the `Property.name` attributes which
+                generated the respective operators.
 
         Returns:
             An interpreted :class:`~.EigenstateResult`. For more information see also
@@ -86,19 +92,46 @@ def solve(
         # user but also additional ones from the transformation
         second_q_ops = problem.second_q_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):
+                    if name in aux_ops.keys():
+                        raise QiskitNatureError(
+                            f"The key '{name}' is already taken by an internally constructed "
+                            "auxliliary operator! Please use a different name for your custom "
+                            "operator."
+                        )
+                    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,7 +44,7 @@ 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,
     ) -> EigenstateResult:
         """Compute the ground state energy of the molecule that was supplied via the driver.