For the Enhancement of converters of QuadraticProgram

qiskit/optimization/algorithms/grover_optimizer.py

@@ -47,6 +47,7 @@ def __init__(self, num_value_qubits: int, num_iterations: int = 3,
         self._num_value_qubits = num_value_qubits
         self._n_iterations = num_iterations
         self._quantum_instance = None
+        self._qubo_converter = QuadraticProgramToQubo()
 
         if quantum_instance is not None:
             self.quantum_instance = quantum_instance
@@ -108,8 +109,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
         self._verify_compatibility(problem)
 
         # convert problem to QUBO
-        qubo_converter = QuadraticProgramToQubo()
-        problem_ = qubo_converter.convert(problem)
+        problem_ = self._qubo_converter.convert(problem)
 
         # convert to minimization problem
         sense = problem_.objective.sense
@@ -228,10 +228,10 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
             fval = -fval
         result = OptimizationResult(x=opt_x, variables=problem.variables, fval=fval,
                                     results={"grover_results": grover_results,
-                                             "qubo_converter": qubo_converter})
+                                             "qubo_converter": self._qubo_converter})
 
         # cast binaries back to integers
-        result = qubo_converter.interpret(result)
+        result = self._qubo_converter.interpret(result)
 
         return result
 

qiskit/optimization/algorithms/minimum_eigen_optimizer.py

@@ -109,6 +109,7 @@ def __init__(self, min_eigen_solver: MinimumEigensolver, penalty: Optional[float
         """
         self._min_eigen_solver = min_eigen_solver
         self._penalty = penalty
+        self._qubo_converter = QuadraticProgramToQubo()
 
     def get_compatibility_msg(self, problem: QuadraticProgram) -> str:
         """Checks whether a given problem can be solved with this optimizer.
@@ -141,8 +142,7 @@ def solve(self, problem: QuadraticProgram) -> MinimumEigenOptimizerResult:
         self._verify_compatibility(problem)
 
         # convert problem to QUBO
-        qubo_converter = QuadraticProgramToQubo()
-        problem_ = qubo_converter.convert(problem)
+        problem_ = self._qubo_converter.convert(problem)
 
         # construct operator and offset
         operator, offset = problem_.to_ising()
@@ -172,9 +172,9 @@ def solve(self, problem: QuadraticProgram) -> MinimumEigenOptimizerResult:
             samples = [(x_str, offset, 1.0)]
 
         # translate result back to integers
-        opt_res = MinimumEigenOptimizerResult(x, fval, samples, qubo_converter,
+        opt_res = MinimumEigenOptimizerResult(x, fval, samples, self._qubo_converter,
                                               variables=problem.variables)
-        opt_res = cast(MinimumEigenOptimizerResult, qubo_converter.interpret(opt_res))
+        opt_res = cast(MinimumEigenOptimizerResult, self._qubo_converter.interpret(opt_res))
 
         # translate results back to original problem
         return opt_res

qiskit/optimization/algorithms/recursive_minimum_eigen_optimizer.py

@@ -91,6 +91,7 @@ def __init__(self, min_eigen_optimizer: MinimumEigenOptimizer, min_num_vars: int
         else:
             self._min_num_vars_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
         self._penalty = penalty
+        self._qubo_converter = QuadraticProgramToQubo()
 
     def get_compatibility_msg(self, problem: QuadraticProgram) -> str:
         """Checks whether a given problem can be solved with this optimizer.
@@ -124,8 +125,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
         self._verify_compatibility(problem)
 
         # convert problem to QUBO, this implicitly checks if the problem is compatible
-        qubo_converter = QuadraticProgramToQubo()
-        problem_ = qubo_converter.convert(problem)
+        problem_ = self._qubo_converter.convert(problem)
         problem_ref = deepcopy(problem_)
 
         # run recursive optimization until the resulting problem is small enough
@@ -209,9 +209,9 @@ def find_value(x, replacements, var_values):
         # construct result
         x_v = [var_values[x_aux.name] for x_aux in problem_ref.variables]
         fval = result.fval
-        results = OptimizationResult(x_v, fval, (replacements, qubo_converter),
+        results = OptimizationResult(x_v, fval, (replacements, self._qubo_converter),
                                      variables=problem.variables)
-        results = qubo_converter.interpret(results)
+        results = self._qubo_converter.interpret(results)
         return results
 
     def _find_strongest_correlation(self, correlations):

qiskit/optimization/converters/quadratic_program_to_qubo.py

@@ -46,8 +46,7 @@ def __init__(self, penalty: Optional[float] = None) -> None:
 
         self._int_to_bin = IntegerToBinary()
         self._ineq_to_eq = InequalityToEquality(mode='integer')
-        self._penalize_lin_eq_constraints = LinearEqualityToPenalty()
-        self._penalty = penalty
+        self._penalize_lin_eq_constraints = LinearEqualityToPenalty(penalty=penalty)
 
     def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
         """Convert a problem with linear equality constraints into new one with a QUBO form.
@@ -202,7 +201,7 @@ def penalty(self) -> Optional[float]:
         Returns:
             The penalty factor used in conversion.
         """
-        return self._penalty
+        return self._penalize_lin_eq_constraints.penalty
 
     @penalty.setter
     def penalty(self, penalty: Optional[float]) -> None:
@@ -212,4 +211,4 @@ def penalty(self, penalty: Optional[float]) -> None:
             penalty: The new penalty factor.
                      If None is passed, penalty factor will be automatically calculated.
         """
-        self._penalty = penalty
+        self._penalize_lin_eq_constraints.penalty = penalty