Integrate QRAO into Qiskit Optimization

qiskit_optimization/algorithms/optimization_algorithm.py

@@ -491,7 +491,9 @@ def _interpret_samples(
         cls,
         problem: QuadraticProgram,
         raw_samples: List[SolutionSample],
-        converters: List[QuadraticProgramConverter],
+        converters: Optional[
+            Union[QuadraticProgramConverter, List[QuadraticProgramConverter]]
+        ] = None,
     ) -> Tuple[List[SolutionSample], SolutionSample]:
         """Interpret and sort all samples and return the raw sample corresponding to the best one"""
         converters = cls._check_converters(converters)

qiskit_optimization/algorithms/qrao/__init__.py

@@ -0,0 +1,70 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Quantum Random Access Optimization (:mod:`qiskit_optimization.algorithms.qrao`)
+===============================================================================
+
+.. currentmodule:: qiskit_optimization.algorithms.qrao
+
+
+Quantum Random Access Encoding and Optimization
+===============================================
+.. autosummary::
+    :toctree: ../stubs/
+    :nosignatures:
+
+    EncodingCommutationVerifier
+    QuantumRandomAccessEncoding
+    QuantumRandomAccessOptimizer
+    QuantumRandomAccessOptimizationResult
+
+Rounding schemes
+================
+
+.. autosummary::
+    :toctree: ../stubs/
+    :nosignatures:
+
+    MagicRounding
+    MagicRoundingResult
+    RoundingScheme
+    RoundingContext
+    RoundingResult
+    SemideterministicRounding
+    SemideterministicRoundingResult
+
+"""
+
+from .encoding_commutation_verifier import EncodingCommutationVerifier
+from .quantum_random_access_encoding import QuantumRandomAccessEncoding
+from .magic_rounding import MagicRounding, MagicRoundingResult
+from .quantum_random_access_optimizer import (
+    QuantumRandomAccessOptimizationResult,
+    QuantumRandomAccessOptimizer,
+)
+from .rounding_common import RoundingContext, RoundingResult, RoundingScheme
+from .semideterministic_rounding import SemideterministicRounding, SemideterministicRoundingResult
+
+__all__ = [
+    "EncodingCommutationVerifier",
+    "QuantumRandomAccessEncoding",
+    "RoundingScheme",
+    "RoundingContext",
+    "RoundingResult",
+    "SemideterministicRounding",
+    "SemideterministicRoundingResult",
+    "MagicRounding",
+    "MagicRoundingResult",
+    "QuantumRandomAccessOptimizer",
+    "QuantumRandomAccessOptimizationResult",
+]

qiskit_optimization/algorithms/qrao/encoding_commutation_verifier.py

@@ -0,0 +1,72 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""The EncodingCommutationVerifier."""
+
+from typing import Tuple
+
+from qiskit.primitives import Estimator
+
+from qiskit_optimization.exceptions import QiskitOptimizationError
+
+from .quantum_random_access_encoding import QuantumRandomAccessEncoding
+
+
+class EncodingCommutationVerifier:
+    """Class for verifying that the relaxation commutes with the objective function."""
+
+    def __init__(self, encoding: QuantumRandomAccessEncoding, estimator: Estimator = None):
+        """
+        Args:
+            encoding: The encoding to verify.
+        """
+        self._encoding = encoding
+        if estimator is not None:
+            self._estimator = estimator
+        else:
+            self._estimator = Estimator()
+
+    def __len__(self) -> int:
+        return 2**self._encoding.num_vars
+
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self[i]
+
+    def __getitem__(self, i: int) -> Tuple[str, float, float]:
+        if i not in range(len(self)):
+            raise IndexError(f"Index out of range: {i}")
+
+        encoding = self._encoding
+        str_dvars = f"{i:0{encoding.num_vars}b}"
+        dvars = [int(b) for b in str_dvars]
+        encoded_bitstr_qc = encoding.state_preparation_circuit(dvars)
+
+        # Evaluate the original objective function
+        problem = encoding.problem
+        sense = problem.objective.sense.value
+        obj_val = problem.objective.evaluate(dvars) * sense
+
+        # Evaluate the encoded Hamiltonian
+        encoded_op = encoding.qubit_op
+        offset = encoding.offset
+
+        job = self._estimator.run([encoded_bitstr_qc], [encoded_op])
+
+        try:
+            encoded_obj_val = job.result().values[0] + offset
+        except Exception as exc:
+            raise QiskitOptimizationError(
+                "The primitive job to verify commutation failed!"
+            ) from exc
+
+        return (str_dvars, obj_val, encoded_obj_val)