Integrate QRAO into Qiskit Optimization

qiskit_optimization/algorithms/qrao/magic_rounding.py

@@ -113,12 +113,12 @@ def basis_sampling(self):
 
     @staticmethod
     def _make_circuits(
-        circ: QuantumCircuit, bases: np.ndarray[Any, Any], vars_per_qubit: int
+        circuit: QuantumCircuit, bases: np.ndarray[Any, Any], vars_per_qubit: int
     ) -> List[QuantumCircuit]:
         """Make a list of circuits to measure in the given magic bases.
 
         Args:
-            circ: Quantum circuit to measure.
+            circuit: Quantum circuit to measure.
             bases: List of magic bases to measure in.
             vars_per_qubit: Number of variables per qubit.
 
@@ -128,11 +128,11 @@ def _make_circuits(
         circuits = []
         for basis in bases:
             if vars_per_qubit == 3:
-                qc = circ.compose(_z_to_31p_qrac_basis_circuit(basis).inverse(), inplace=False)
+                qc = circuit.compose(_z_to_31p_qrac_basis_circuit(basis).inverse(), inplace=False)
             elif vars_per_qubit == 2:
-                qc = circ.compose(_z_to_21p_qrac_basis_circuit(basis).inverse(), inplace=False)
+                qc = circuit.compose(_z_to_21p_qrac_basis_circuit(basis).inverse(), inplace=False)
             elif vars_per_qubit == 1:
-                qc = circ.copy()
+                qc = circuit.copy()
             qc.measure_all()
             circuits.append(qc)
         return circuits
@@ -319,6 +319,7 @@ def _sample_bases_weighted(
                 corresponds to the number of shots to use for the corresponding basis in
                 the bases array.
         """
+        # pylint: disable=C0401
         # First, we make sure all Pauli expectation values have absolute value
         # at most 1.  Otherwise, some of the probabilities computed below might
         # be negative.
@@ -365,11 +366,11 @@ def _sample_bases_weighted(
         bases, basis_shots = np.unique(bases_, axis=0, return_counts=True)
         return bases, basis_shots
 
-    def round(self, ctx: RoundingContext) -> MagicRoundingResult:
+    def round(self, rounding_context: RoundingContext) -> MagicRoundingResult:
         """Perform magic rounding using the given RoundingContext.
 
         Args:
-            ctx: The context containing the information needed for the rounding.
+            rounding_context: The context containing the information needed for the rounding.
 
         Returns:
             MagicRoundingResult: The results of the magic rounding process.
@@ -378,11 +379,11 @@ def round(self, ctx: RoundingContext) -> MagicRoundingResult:
             NotImplementedError: If the circuit is not available for magic rounding.
             ValueError: If the sampler is not configured with a number of shots.
         """
-        expectation_values = ctx.expectation_values
-        circuit = ctx.circuit
-        q2vars = ctx.encoding.q2vars
-        var2op = ctx.encoding.var2op
-        vars_per_qubit = ctx.encoding.max_vars_per_qubit
+        expectation_values = rounding_context.expectation_values
+        circuit = rounding_context.circuit
+        q2vars = rounding_context.encoding.q2vars
+        var2op = rounding_context.encoding.var2op
+        vars_per_qubit = rounding_context.encoding.max_vars_per_qubit
 
         if circuit is None:
             raise NotImplementedError(
@@ -421,10 +422,10 @@ def round(self, ctx: RoundingContext) -> MagicRoundingResult:
         soln_samples = [
             SolutionSample(
                 x=np.asarray([int(bit) for bit in soln]),
-                fval=ctx.encoding.problem.objective.evaluate([int(bit) for bit in soln]),
+                fval=rounding_context.encoding.problem.objective.evaluate([int(bit) for bit in soln]),
                 probability=count / self._shots,
                 status=OptimizationResultStatus.SUCCESS
-                if ctx.encoding.problem.is_feasible([int(bit) for bit in soln])
+                if rounding_context.encoding.problem.is_feasible([int(bit) for bit in soln])
                 else OptimizationResultStatus.INFEASIBLE,
             )
             for soln, count in soln_counts.items()

qiskit_optimization/algorithms/qrao/quantum_random_access_encoding.py

@@ -113,11 +113,11 @@ def _qrac_state_prep_1q(bit_list: List[int]) -> QuantumCircuit:
 
     if len(bit_list) == 3:
         # Prepare (3,1,p)-qrac
-        # In the following lines, the input bits are XOR'd to match the
+        # In the following lines, the input bits are XORed to match the
         # conventions used in the paper.
         # To understand why this transformation happens,
         # observe that the two states that define each magic basis
-        # correspond to the same bitstrings but with a global bitflip.
+        # correspond to the same bitstrings but with a global bit flip.
         # Thus the three bits of information we use to construct these states are:
         # base_index0,base_index1 : two bits to pick one of four magic bases
         # bit_flip: one bit to indicate which magic basis projector we are interested in.
@@ -152,15 +152,15 @@ def _qrac_state_prep_1q(bit_list: List[int]) -> QuantumCircuit:
     return circ
 
 
-def _qrac_state_prep_multiqubit(
-    dvars: List[int],
+def _qrac_state_prep_multi_qubit(
+    x: List[int],
     q2vars: List[List[int]],
     max_vars_per_qubit: int,
 ) -> QuantumCircuit:
-    """Prepares a multiqubit QRAC state.
+    """Prepares a multi qubit QRAC state.
 
     Args:
-        dvars: The state of each decision variable (0 or 1).
+        x: The state of each decision variable (0 or 1).
         q2vars: A list of lists of integers. Each inner list contains the indices of decision variables
         mapped to a specific qubit.
         max_vars_per_qubit: The maximum number of decision variables that can be mapped to a
@@ -170,12 +170,12 @@ def _qrac_state_prep_multiqubit(
         A QuantumCircuit object representing the prepared state.
 
     Raises:
-        ValueError: If any qubit is associated with more than ``max_vars_per_qubit`` variables.
-        ValueError: If a decision variable in ``q2vars`` is not included in ``dvars``.
-        ValueError: If there are unused decision variables in `dvars` after mapping to qubits.
+        ValueError: If any qubit is associated with more than `max_vars_per_qubit` variables.
+        ValueError: If a decision variable in ``q2vars`` is not included in `x`.
+        ValueError: If there are unused decision variables in `x` after mapping to qubits.
     """
     # Create a set of all remaining decision variables
-    remaining_dvars = set(range(len(dvars)))
+    remaining_dvars = set(range(len(x)))
     # Create a list to store the binary mappings of each qubit to its corresponding decision variables
     variable_mappings: List[List[int]] = []
     # Check that each qubit is associated with at most max_vars_per_qubit variables
@@ -193,7 +193,7 @@ def _qrac_state_prep_multiqubit(
         # to the qubit bits
         for dvar in qi_vars:
             try:
-                qi_bits.append(dvars[dvar])
+                qi_bits.append(x[dvar])
             except IndexError:
                 raise ValueError(f"Decision variable not included in dvars: {dvar}") from None
             try:
@@ -213,7 +213,7 @@ def _qrac_state_prep_multiqubit(
     if remaining_dvars:
         raise ValueError(f"Not all dvars were included in q2vars: {remaining_dvars}")
 
-    # Prepare the individual qrac circuit and combine them into a multiqubit circuit
+    # Prepare the individual qrac circuit and combine them into a multi qubit circuit
     qracs = [_qrac_state_prep_1q(qi_bits) for qi_bits in variable_mappings]
     qrac_circ = reduce(lambda x, y: x.tensor(y), qracs)
     return qrac_circ
@@ -272,7 +272,7 @@ def var2op(self) -> Dict[int, Tuple[int, SparsePauliOp]]:
 
     @property
     def q2vars(self) -> List[List[int]]:
-        """Each element contains the list of decision variable indice(s) encoded on that qubit"""
+        """Each element contains the list of decision variable indices encoded on that qubit"""
         return self._q2vars
 
     @property
@@ -556,14 +556,14 @@ def encode(self, problem: QuadraticProgram) -> None:
 
         self.freeze()
 
-    def state_preparation_circuit(self, dvars: List[int]) -> QuantumCircuit:
+    def state_preparation_circuit(self, x: List[int]) -> QuantumCircuit:
         """
         Generate a circuit that prepares the state corresponding to the given binary string.
 
         Args:
-            dvars: A list of binary values to be encoded into the state.
+            x: A list of binary values to be encoded into the state.
 
         Returns:
             A QuantumCircuit that prepares the state corresponding to the given binary string.
         """
-        return _qrac_state_prep_multiqubit(dvars, self.q2vars, self.max_vars_per_qubit)
+        return _qrac_state_prep_multi_qubit(x, self.q2vars, self.max_vars_per_qubit)

qiskit_optimization/algorithms/qrao/quantum_random_access_optimizer.py

@@ -211,7 +211,7 @@ def solve_relaxed(
         )
         relaxed_result.time_taken = time.time() - start_time_relaxed
 
-        # Get auxiliary expectaion values for rounding.
+        # Get auxiliary expectation values for rounding.
         if relaxed_result.aux_operators_evaluated is not None:
             expectation_values = [v[0] for v in relaxed_result.aux_operators_evaluated]
         else:

qiskit_optimization/algorithms/qrao/rounding_common.py

@@ -56,7 +56,7 @@ class RoundingScheme(ABC):
     """Base class for a rounding scheme"""
 
     @abstractmethod
-    def round(self, ctx: RoundingContext) -> RoundingResult:
+    def round(self, rounding_context: RoundingContext) -> RoundingResult:
         """Perform rounding
 
         Returns: an instance of RoundingResult

qiskit_optimization/algorithms/qrao/semideterministic_rounding.py

@@ -47,11 +47,11 @@ def __init__(self, *, seed: Optional[int] = None):
         super().__init__()
         self.rng = np.random.RandomState(seed)
 
-    def round(self, ctx: RoundingContext) -> SemideterministicRoundingResult:
+    def round(self, rounding_context: RoundingContext) -> SemideterministicRoundingResult:
         """Perform semideterministic rounding
 
         Args:
-            ctx: Rounding context containing information about the problem and solution.
+            rounding_context: Rounding context containing information about the problem and solution.
 
         Returns:
             Result containing the rounded solution.
@@ -63,30 +63,30 @@ def round(self, ctx: RoundingContext) -> SemideterministicRoundingResult:
         def sign(val) -> int:
             return 0 if (val > 0) else 1
 
-        if ctx.expectation_values is None:
+        if rounding_context.expectation_values is None:
             raise NotImplementedError(
                 "Semideterministric rounding requires the expectation values of the ",
                 "``RoundingContext`` to be available, but they are not.",
             )
         rounded_vars = np.array(
             [
                 sign(e) if not np.isclose(0, e) else self.rng.randint(2)
-                for e in ctx.expectation_values
+                for e in rounding_context.expectation_values
             ]
         )
 
         soln_samples = [
             SolutionSample(
                 x=np.asarray(rounded_vars),
-                fval=ctx.encoding.problem.objective.evaluate(rounded_vars),
+                fval=rounding_context.encoding.problem.objective.evaluate(rounded_vars),
                 probability=1.0,
                 status=OptimizationResultStatus.SUCCESS
-                if ctx.encoding.problem.is_feasible(rounded_vars)
+                if rounding_context.encoding.problem.is_feasible(rounded_vars)
                 else OptimizationResultStatus.INFEASIBLE,
             )
         ]
 
         result = SemideterministicRoundingResult(
-            expectation_values=ctx.expectation_values, samples=soln_samples
+            expectation_values=rounding_context.expectation_values, samples=soln_samples
         )
         return result

test/algorithms/qrao/test_quantum_random_access_encoding.py

@@ -140,7 +140,7 @@ def test_qrac_state_prep(self):
         with self.subTest(msg="(3,1,p) QRAC"):
             encoding = QuantumRandomAccessEncoding(3)
             encoding.encode(self.problem)
-            state_prep_circ = encoding.state_preparation_circuit(dvars=dvars)
+            state_prep_circ = encoding.state_preparation_circuit(x=dvars)
             circ = QuantumCircuit(1)
             beta = np.arccos(1 / np.sqrt(3))
             circ.r(np.pi - beta, np.pi / 4, 0)
@@ -149,7 +149,7 @@ def test_qrac_state_prep(self):
         with self.subTest(msg="(2,1,p) QRAC"):
             encoding = QuantumRandomAccessEncoding(2)
             encoding.encode(self.problem)
-            state_prep_circ = encoding.state_preparation_circuit(dvars=dvars)
+            state_prep_circ = encoding.state_preparation_circuit(x=dvars)
             circ = QuantumCircuit(2)
             circ.x(0)
             circ.r(-3 * np.pi / 4, -np.pi / 2, 0)
@@ -159,7 +159,7 @@ def test_qrac_state_prep(self):
         with self.subTest(msg="(1,1,p) QRAC"):
             encoding = QuantumRandomAccessEncoding(1)
             encoding.encode(self.problem)
-            state_prep_circ = encoding.state_preparation_circuit(dvars=dvars)
+            state_prep_circ = encoding.state_preparation_circuit(x=dvars)
             circ = QuantumCircuit(3)
             circ.x(0)
             circ.x(1)