Replaced GroverOperator usage by grover_operator

qiskit_algorithms/amplitude_amplifiers/amplification_problem.py

@@ -17,7 +17,7 @@
 from typing import Any, List, cast
 
 from qiskit.circuit import QuantumCircuit, Gate
-from qiskit.circuit.library import GroverOperator
+from qiskit.circuit.library import grover_operator as grover_operator_builder
 from qiskit.quantum_info import Statevector
 
 
@@ -205,10 +205,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/grover.py

@@ -96,7 +96,7 @@ 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
+    For more information, see the :func:`~qiskit.circuit.library.grover_operator` function in the
     circuit library.
 
     References:
@@ -217,9 +217,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_estimators/estimation_problem.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
@@ -19,7 +19,7 @@
 import numpy
 
 from qiskit.circuit import QuantumCircuit, QuantumRegister
-from qiskit.circuit.library import GroverOperator
+from qiskit.circuit.library import grover_operator as grover_operator_builder
 
 
 class EstimationProblem:
@@ -167,7 +167,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 +191,16 @@ 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.
         """
         self._grover_operator = grover_operator
 

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

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

test/test_grover.py

@@ -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)