Merge 1eff16f into 6700f3c

Author: tnemoz

docs/tutorials/06_grover.ipynb

@@ -16,10 +16,15 @@
 from collections.abc import Callable
 from typing import Any, List, cast
 
+from qiskit.version import get_version_info
 from qiskit.circuit import QuantumCircuit, Gate
-from qiskit.circuit.library import GroverOperator
 from qiskit.quantum_info import Statevector
 
+if get_version_info() >= "2.1.0":
+    from qiskit.circuit.library import grover_operator as grover_operator_builder
+else:
+    from qiskit.circuit.library import GroverOperator as grover_operator_builder
+
 
 class AmplificationProblem:
     """The amplification problem is the input to amplitude amplification algorithms, like Grover.
@@ -205,10 +210,10 @@ def grover_operator(self) -> QuantumCircuit | None:
 
         Returns:
             The Grover operator, or None if neither the Grover operator nor the
-            :math:`\mathcal{A}` operator is  set.
+            :math:`\mathcal{A}` operator is set.
         """
         if self._grover_operator is None:
-            return GroverOperator(self.oracle, self.state_preparation)
+            return grover_operator_builder(self.oracle, self.state_preparation)
         return self._grover_operator
 
     @grover_operator.setter

qiskit_algorithms/amplitude_amplifiers/amplification_problem.py

@@ -96,8 +96,9 @@ class Grover(AmplitudeAmplifier):
 
         \mathcal{Q} = \mathcal{A} \mathcal{S}_0 \mathcal{A}^\dagger \mathcal{S}_f.
 
-    For more information, see the :class:`~qiskit.circuit.library.GroverOperator` in the
-    circuit library.
+    For more information, see the :func:`~qiskit.circuit.library.grover_operator` function in the
+    circuit library or the :class:`~qiskit.circuit.library.GroverOperator` class if you're using a
+    version of Qiskit older than 2.1.0.
 
     References:
         [1]: L. K. Grover (1996), A fast quantum mechanical algorithm for database search,
@@ -217,9 +218,7 @@ def amplify(self, amplification_problem: AmplificationProblem) -> "GroverResult"
             iterator: Iterator[int] = iter(self._iterations)
         else:
             max_iterations = max(10, 2**amplification_problem.oracle.num_qubits)
-            max_power = np.ceil(
-                2 ** (len(amplification_problem.grover_operator.reflection_qubits) / 2)
-            )
+            max_power = np.ceil(2 ** (len(amplification_problem.objective_qubits) / 2))
             iterator = self._iterations
 
         result = GroverResult()

qiskit_algorithms/amplitude_amplifiers/grover.py

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2020, 2024.
+# (C) Copyright IBM 2020, 2025.
 #
 # 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
@@ -17,9 +17,13 @@
 from collections.abc import Callable
 
 import numpy
-
 from qiskit.circuit import QuantumCircuit, QuantumRegister
-from qiskit.circuit.library import GroverOperator
+from qiskit.version import get_version_info
+
+if get_version_info() >= "2.1.0":
+    from qiskit.circuit.library import grover_operator as grover_operator_builder
+else:
+    from qiskit.circuit.library import GroverOperator as grover_operator_builder
 
 
 class EstimationProblem:
@@ -167,7 +171,8 @@ def grover_operator(self) -> QuantumCircuit | None:
         r"""Get the :math:`\mathcal{Q}` operator, or Grover operator.
 
         If the Grover operator is not set, we try to build it from the :math:`\mathcal{A}` operator
-        and `objective_qubits`. This only works if `objective_qubits` is a list of integers.
+        and `objective_qubits` using the :func:`~qiskit.circuit.library.grover_operator` function.
+        This only works if `objective_qubits` is a list of integers.
 
         Returns:
             The Grover operator, or None if neither the Grover operator nor the
@@ -190,15 +195,18 @@ def grover_operator(self) -> QuantumCircuit | None:
         oracle.h(self.objective_qubits[-1])
 
         # construct the grover operator
-        return GroverOperator(oracle, self.state_preparation)
+        return grover_operator_builder(oracle, self.state_preparation)
 
     @grover_operator.setter
     def grover_operator(self, grover_operator: QuantumCircuit | None) -> None:
         r"""Set the :math:`\mathcal{Q}` operator.
 
         Args:
             grover_operator: The new :math:`\mathcal{Q}` operator. If set to ``None``,
-                the default construction via ``qiskit.circuit.library.GroverOperator`` is used.
+                the default construction via :func:`~qiskit.circuit.library.grover_operator` is
+                used when accessing the property using Qiskit in its 2.1.0 version or an older
+                one. If using Qiskit in an older version, the
+                :class:`~qiskit.circuit.library.GroverOperator` is instead used.
         """
         self._grover_operator = grover_operator
 

qiskit_algorithms/amplitude_estimators/estimation_problem.py

@@ -0,0 +1,10 @@
+---
+fixes:
+  - |
+    :class:`AmplificationProblem` and :class:`EstimationProblem` now use the function
+    :func:`~qiskit.circuit.library.grover_operator` to construct the Grover operator
+    by default when using Qiskit in its 2.1.0 version or an older one, instead of the 
+    class :class:`~qiskit.circuit.library.GroverOperator`, to follow with the latter's
+    deprecation in Qiskit 2.10. In particular, if these classes are instantiated without
+    providing a Grover operator and the new default construction is used, it won't be
+    possible to access the attributes of the deprecated class.

releasenotes/notes/add-support-for-grover_operator-function-8221f7abca3b84d6.yaml

@@ -17,9 +17,9 @@
 from test import QiskitAlgorithmsTestCase
 
 import numpy as np
-from ddt import data, ddt
+from ddt import data, ddt, idata, unpack
 from qiskit import QuantumCircuit
-from qiskit.circuit.library import GroverOperator, PhaseOracle, PhaseOracleGate
+from qiskit.circuit.library import grover_operator, GroverOperator, PhaseOracle, PhaseOracleGate
 from qiskit.primitives import StatevectorSampler
 from qiskit.quantum_info import Operator, Statevector
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
@@ -36,24 +36,24 @@ def setUp(self):
         super().setUp()
         oracle = QuantumCircuit(2)
         oracle.cz(0, 1)
-        self._expected_grover_op = GroverOperator(oracle=oracle)
 
-    @data("oracle_only", "oracle_and_stateprep")
-    def test_groverop_getter(self, kind):
+    @idata(product(["oracle_only", "oracle_and_stateprep"], [GroverOperator, grover_operator]))
+    @unpack
+    def test_groverop_getter(self, kind, oracle_builder):
         """Test the default construction of the Grover operator."""
         oracle = QuantumCircuit(2)
         oracle.cz(0, 1)
 
         if kind == "oracle_only":
             problem = AmplificationProblem(oracle, is_good_state=["11"])
-            expected = GroverOperator(oracle)
+            expected = oracle_builder(oracle)
         else:
             stateprep = QuantumCircuit(2)
             stateprep.ry(0.2, [0, 1])
             problem = AmplificationProblem(
                 oracle, state_preparation=stateprep, is_good_state=["11"]
             )
-            expected = GroverOperator(oracle, stateprep)
+            expected = oracle_builder(oracle, stateprep)
 
         self.assertEqual(Operator(expected), Operator(problem.grover_operator))
 
@@ -204,11 +204,12 @@ def test_run_state_vector_oracle(self):
         result = grover.amplify(problem)
         self.assertIn(result.top_measurement, ["11"])
 
-    def test_run_custom_grover_operator(self):
+    @data(GroverOperator, grover_operator)
+    def test_run_custom_grover_operator(self, oracle_builder):
         """Test execution with a grover operator oracle"""
         oracle = QuantumCircuit(2)
         oracle.cz(0, 1)
-        grover_op = GroverOperator(oracle)
+        grover_op = oracle_builder(oracle)
         problem = AmplificationProblem(
             oracle=oracle, grover_operator=grover_op, is_good_state=["11"]
         )
@@ -225,15 +226,16 @@ def test_optimal_num_iterations(self):
             actual = Grover.optimal_num_iterations(num_solutions, num_qubits)
             self.assertEqual(actual, expected)
 
-    def test_construct_circuit(self):
+    @data(GroverOperator, grover_operator)
+    def test_construct_circuit(self, oracle_builder):
         """Test construct_circuit"""
         oracle = QuantumCircuit(2)
         oracle.cz(0, 1)
         problem = AmplificationProblem(oracle, is_good_state=["11"])
         grover = Grover()
         constructed = grover.construct_circuit(problem, 2, measurement=False)
 
-        grover_op = GroverOperator(oracle)
+        grover_op = oracle_builder(oracle)
         expected = QuantumCircuit(2)
         expected.h([0, 1])
         expected.compose(grover_op.power(2), inplace=True)