diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..a4f825fa2
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,3 @@
+[tool.black]
+line-length = 100
+target-version = ['py36', 'py37', 'py38', 'py39']
diff --git a/qiskit_optimization/algorithms/admm_optimizer.py b/qiskit_optimization/algorithms/admm_optimizer.py
index a70af31ff..2b4694d5d 100644
--- a/qiskit_optimization/algorithms/admm_optimizer.py
+++ b/qiskit_optimization/algorithms/admm_optimizer.py
@@ -112,9 +112,7 @@ def __init__(
         self.warm_start = warm_start
 
     def __repr__(self) -> str:
-        props = ", ".join(
-            ["{}={}".format(key, value) for (key, value) in vars(self).items()]
-        )
+        props = ", ".join(["{}={}".format(key, value) for (key, value) in vars(self).items()])
         return "{0}({1})".format(type(self).__name__, props)
 
 
@@ -203,9 +201,7 @@ def __init__(
             state: the internal computation state of ADMM.
             status: Termination status of an optimization algorithm
         """
-        super().__init__(
-            x=x, fval=fval, variables=variables, status=status, raw_results=state
-        )
+        super().__init__(x=x, fval=fval, variables=variables, status=status, raw_results=state)
 
     @property
     def state(self) -> ADMMState:
@@ -246,9 +242,7 @@ def __init__(
         self._params = params or ADMMParameters()
 
         # create optimizers if not specified
-        self._qubo_optimizer = qubo_optimizer or MinimumEigenOptimizer(
-            NumPyMinimumEigensolver()
-        )
+        self._qubo_optimizer = qubo_optimizer or MinimumEigenOptimizer(NumPyMinimumEigensolver())
         self._continuous_optimizer = continuous_optimizer or SlsqpOptimizer()
 
         # internal state where we'll keep intermediate solution
@@ -273,9 +267,7 @@ def get_compatibility_msg(self, problem: QuadraticProgram) -> Optional[str]:
 
         # 1. get bin/int and continuous variable indices
         bin_int_indices = self._get_variable_indices(problem, Variable.Type.BINARY)
-        continuous_indices = self._get_variable_indices(
-            problem, Variable.Type.CONTINUOUS
-        )
+        continuous_indices = self._get_variable_indices(problem, Variable.Type.CONTINUOUS)
 
         # 2. binary and continuous variables are separable in objective
         for bin_int_index in bin_int_indices:
@@ -319,9 +311,7 @@ def solve(self, problem: QuadraticProgram) -> ADMMOptimizationResult:
         self._state = ADMMState(problem, self._params.rho_initial)
 
         # parse problem and convert to an ADMM specific representation.
-        self._state.binary_indices = self._get_variable_indices(
-            problem, Variable.Type.BINARY
-        )
+        self._state.binary_indices = self._get_variable_indices(problem, Variable.Type.BINARY)
         self._state.continuous_indices = self._get_variable_indices(
             problem, Variable.Type.CONTINUOUS
         )
@@ -448,9 +438,7 @@ def _turn_to_minimization(
             problem.objective.sense = QuadraticObjective.Sense.MINIMIZE
             problem.objective.constant = (-1) * problem.objective.constant
             problem.objective.linear = (-1) * problem.objective.linear.coefficients
-            problem.objective.quadratic = (
-                -1
-            ) * problem.objective.quadratic.coefficients
+            problem.objective.quadratic = (-1) * problem.objective.quadratic.coefficients
         return problem, sense
 
     @staticmethod
@@ -492,9 +480,7 @@ def _revert_solution_indexes(
         Returns:
             A solution array.
         """
-        solution = np.zeros(
-            len(self._state.binary_indices) + len(self._state.continuous_indices)
-        )
+        solution = np.zeros(len(self._state.binary_indices) + len(self._state.continuous_indices))
         # restore solution at the original index location
         solution.put(self._state.binary_indices, binary_vars)
         solution.put(self._state.continuous_indices, continuous_vars)
@@ -532,14 +518,10 @@ def _convert_problem_representation(self) -> None:
 
         # objective
         self._state.q0 = self._get_q(self._state.step1_absolute_indices)
-        c0_vec = self._state.op.objective.linear.to_array()[
-            self._state.step1_absolute_indices
-        ]
+        c0_vec = self._state.op.objective.linear.to_array()[self._state.step1_absolute_indices]
         self._state.c0 = c0_vec
         self._state.q1 = self._get_q(self._state.continuous_indices)
-        self._state.c1 = self._state.op.objective.linear.to_array()[
-            self._state.continuous_indices
-        ]
+        self._state.c1 = self._state.op.objective.linear.to_array()[self._state.continuous_indices]
         # equality constraints with binary vars only
         self._state.a0, self._state.b0 = self._get_a0_b0()
 
@@ -561,9 +543,7 @@ def _get_step1_indices(self) -> Tuple[List[int], List[int]]:
             # either in the linear or quadratic terms
             if (
                 self._state.op.objective.linear[binary_index] != 0
-                or np.abs(
-                    self._state.op.objective.quadratic.coefficients[binary_index, :]
-                ).sum()
+                or np.abs(self._state.op.objective.quadratic.coefficients[binary_index, :]).sum()
                 != 0
             ):
                 # add the variable if it was not added before
@@ -649,11 +629,7 @@ def _get_a0_b0(self) -> Tuple[np.ndarray, np.ndarray]:
         vector = []
 
         for constraint in self._state.binary_equality_constraints:
-            row = (
-                constraint.linear.to_array()
-                .take(self._state.step1_absolute_indices)
-                .tolist()
-            )
+            row = constraint.linear.to_array().take(self._state.step1_absolute_indices).tolist()
 
             matrix.append(row)
             vector.append(constraint.rhs)
@@ -662,9 +638,7 @@ def _get_a0_b0(self) -> Tuple[np.ndarray, np.ndarray]:
             np_matrix = np.array(matrix)
             np_vector = np.array(vector)
         else:
-            np_matrix = np.array([0] * len(self._state.step1_absolute_indices)).reshape(
-                (1, -1)
-            )
+            np_matrix = np.array([0] * len(self._state.step1_absolute_indices)).reshape((1, -1))
             np_vector = np.zeros(shape=(1,))
 
         return np_matrix, np_vector
@@ -686,9 +660,7 @@ def _create_step1_problem(self) -> QuadraticProgram:
         # prepare and set quadratic objective.
         quadratic_objective = (
             self._state.q0
-            + self._params.factor_c
-            / 2
-            * np.dot(self._state.a0.transpose(), self._state.a0)
+            + self._params.factor_c / 2 * np.dot(self._state.a0.transpose(), self._state.a0)
             + self._state.rho / 2 * np.eye(binary_size)
         )
         op1.objective.quadratic = quadratic_objective
@@ -726,9 +698,9 @@ def _create_step2_problem(self) -> QuadraticProgram:
             # replacing Q0 objective and take of min/max sense, initially we consider minimization
             op2.objective.quadratic[var_index, var_index] = self._state.rho / 2
             # replacing linear objective
-            op2.objective.linear[var_index] = -1 * self._state.lambda_mult[
-                i
-            ] - self._state.rho * (self._state.x0[i] - self._state.y[i])
+            op2.objective.linear[var_index] = -1 * self._state.lambda_mult[i] - self._state.rho * (
+                self._state.x0[i] - self._state.y[i]
+            )
 
         # remove A0 x0 = b0 constraints
         for constraint in self._state.binary_equality_constraints:
@@ -750,15 +722,13 @@ def _create_step3_problem(self) -> QuadraticProgram:
             op3.continuous_var(lowerbound=-np.inf, upperbound=np.inf, name=name)
 
         # set quadratic objective y
-        quadratic_y = self._params.beta / 2 * np.eye(
+        quadratic_y = self._params.beta / 2 * np.eye(binary_size) + self._state.rho / 2 * np.eye(
             binary_size
-        ) + self._state.rho / 2 * np.eye(binary_size)
+        )
         op3.objective.quadratic = quadratic_y
 
         # set linear objective for y
-        linear_y = -self._state.lambda_mult - self._state.rho * (
-            self._state.x0 - self._state.z
-        )
+        linear_y = -self._state.lambda_mult - self._state.rho * (self._state.x0 - self._state.z)
         op3.objective.linear = linear_y
 
         return op3
@@ -873,9 +843,7 @@ def _get_constraint_residual(self) -> float:
         cr_ineq = 0.0
         for constraint in self._state.inequality_constraints:
             sense = -1.0 if constraint.sense == Constraint.Sense.GE else 1.0
-            cr_ineq += max(
-                sense * (constraint.evaluate(solution) - constraint.rhs), 0.0
-            )
+            cr_ineq += max(sense * (constraint.evaluate(solution) - constraint.rhs), 0.0)
 
         return cr_eq + cr_ineq
 
diff --git a/qiskit_optimization/algorithms/goemans_williamson_optimizer.py b/qiskit_optimization/algorithms/goemans_williamson_optimizer.py
index a4c1a7d7a..1cf06bdd6 100644
--- a/qiskit_optimization/algorithms/goemans_williamson_optimizer.py
+++ b/qiskit_optimization/algorithms/goemans_williamson_optimizer.py
@@ -166,8 +166,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
         cuts = self._generate_random_cuts(chi, len(adj_matrix))
 
         numeric_solutions = [
-            (cuts[i, :], self.max_cut_value(cuts[i, :], adj_matrix))
-            for i in range(self._num_cuts)
+            (cuts[i, :], self.max_cut_value(cuts[i, :], adj_matrix)) for i in range(self._num_cuts)
         ]
 
         if self._sort_cuts:
@@ -263,9 +262,7 @@ def _solve_max_cut_sdp(self, adj_matrix: np.ndarray) -> np.ndarray:
             constraints.append(x[i, i] == 1)
 
         # objective function
-        expr = cvx.sum(
-            cvx.multiply(adj_matrix, (np.ones((num_vertices, num_vertices)) - x))
-        )
+        expr = cvx.sum(cvx.multiply(adj_matrix, (np.ones((num_vertices, num_vertices)) - x)))
 
         # solve
         problem = cvx.Problem(cvx.Maximize(expr), constraints)
diff --git a/qiskit_optimization/algorithms/grover_optimizer.py b/qiskit_optimization/algorithms/grover_optimizer.py
index e8dba401b..749f5409f 100644
--- a/qiskit_optimization/algorithms/grover_optimizer.py
+++ b/qiskit_optimization/algorithms/grover_optimizer.py
@@ -136,9 +136,7 @@ def _get_a_operator(self, qr_key_value, problem):
     def _get_oracle(self, qr_key_value):
         # Build negative value oracle O.
         if qr_key_value is None:
-            qr_key_value = QuantumRegister(
-                self._num_key_qubits + self._num_value_qubits
-            )
+            qr_key_value = QuantumRegister(self._num_key_qubits + self._num_value_qubits)
 
         oracle_bit = QuantumRegister(1, "oracle")
         oracle = QuantumCircuit(qr_key_value, oracle_bit)
@@ -227,9 +225,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
             while not improvement_found:
                 # Determine the number of rotations.
                 loops_with_no_improvement += 1
-                rotation_count = int(
-                    np.ceil(algorithm_globals.random.uniform(0, m - 1))
-                )
+                rotation_count = int(np.ceil(algorithm_globals.random.uniform(0, m - 1)))
                 rotations += rotation_count
                 # Apply Grover's Algorithm to find values below the threshold.
                 # TODO: Utilize Grover's incremental feature - requires changes to Grover.
@@ -272,12 +268,8 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
                     raw_samples = self._eigenvector_to_solutions(
                         self._circuit_results, problem_init
                     )
-                    raw_samples.sort(
-                        key=lambda x: problem_.objective.sense.value * x.fval
-                    )
-                    samples = self._interpret_samples(
-                        problem, raw_samples, self._converters
-                    )
+                    raw_samples.sort(key=lambda x: problem_.objective.sense.value * x.fval)
+                    samples = self._interpret_samples(problem, raw_samples, self._converters)
                 else:
                     # Using Durr and Hoyer method, increase m.
                     m = int(np.ceil(min(m * 8 / 7, 2 ** (n_key / 2))))
@@ -306,9 +298,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
         if optimum_value >= 0 and orig_constant == 0:
             optimum_key = 0
 
-        opt_x = np.array(
-            [1 if s == "1" else 0 for s in ("{0:%sb}" % n_key).format(optimum_key)]
-        )
+        opt_x = np.array([1 if s == "1" else 0 for s in ("{0:%sb}" % n_key).format(optimum_key)])
         # Compute function value
         fval = problem_init.objective.evaluate(opt_x)
 
@@ -346,8 +336,7 @@ def _get_probs(self, qc: QuantumCircuit) -> Dict[str, float]:
         if self.quantum_instance.is_statevector:
             state = result.get_statevector(qc)
             keys = [
-                bin(i)[2::].rjust(int(np.log2(len(state))), "0")[::-1]
-                for i in range(0, len(state))
+                bin(i)[2::].rjust(int(np.log2(len(state))), "0")[::-1] for i in range(0, len(state))
             ]
             probs = [abs(a) ** 2 for a in state]
             total = math.fsum(probs)
@@ -358,9 +347,7 @@ def _get_probs(self, qc: QuantumCircuit) -> Dict[str, float]:
             state = result.get_counts(qc)
             shots = self.quantum_instance.run_config.shots
             hist = {key[::-1]: val / shots for key, val in state.items() if val > 0}
-            self._circuit_results = {
-                b[::-1]: np.sqrt(v / shots) for (b, v) in state.items()
-            }
+            self._circuit_results = {b[::-1]: np.sqrt(v / shots) for (b, v) in state.items()}
         return hist
 
     @staticmethod
diff --git a/qiskit_optimization/algorithms/minimum_eigen_optimizer.py b/qiskit_optimization/algorithms/minimum_eigen_optimizer.py
index d4b60eadb..31ecd9daa 100644
--- a/qiskit_optimization/algorithms/minimum_eigen_optimizer.py
+++ b/qiskit_optimization/algorithms/minimum_eigen_optimizer.py
@@ -219,9 +219,7 @@ def _solve_internal(
                 raw_samples = self._eigenvector_to_solutions(
                     eigen_result.eigenstate, converted_problem
                 )
-                raw_samples.sort(
-                    key=lambda x: converted_problem.objective.sense.value * x.fval
-                )
+                raw_samples.sort(key=lambda x: converted_problem.objective.sense.value * x.fval)
                 x = raw_samples[0].x
                 fval = raw_samples[0].fval
 
@@ -229,9 +227,7 @@ def _solve_internal(
         else:
             x = np.zeros(converted_problem.get_num_binary_vars())
             fval = offset
-            raw_samples = [
-                SolutionSample(x, fval, 1.0, OptimizationResultStatus.SUCCESS)
-            ]
+            raw_samples = [SolutionSample(x, fval, 1.0, OptimizationResultStatus.SUCCESS)]
 
         if fval is None or x is None:
             # if not function value is given, then something went wrong, e.g., a
@@ -246,9 +242,7 @@ def _solve_internal(
                 min_eigen_solver_result=eigen_result,
             )
         # translate result back to integers
-        samples = self._interpret_samples(
-            original_problem, raw_samples, self._converters
-        )
+        samples = self._interpret_samples(original_problem, raw_samples, self._converters)
         return cast(
             MinimumEigenOptimizationResult,
             self._interpret(
diff --git a/qiskit_optimization/algorithms/multistart_optimizer.py b/qiskit_optimization/algorithms/multistart_optimizer.py
index 965683ae3..57ed26394 100644
--- a/qiskit_optimization/algorithms/multistart_optimizer.py
+++ b/qiskit_optimization/algorithms/multistart_optimizer.py
@@ -78,12 +78,8 @@ def multi_start_solve(
             x_0 = np.zeros(problem.get_num_vars())
             if trial > 0:
                 for i, var in enumerate(problem.variables):
-                    lowerbound = (
-                        var.lowerbound if var.lowerbound > -INFINITY else -self._clip
-                    )
-                    upperbound = (
-                        var.upperbound if var.upperbound < INFINITY else self._clip
-                    )
+                    lowerbound = var.lowerbound if var.lowerbound > -INFINITY else -self._clip
+                    upperbound = var.upperbound if var.upperbound < INFINITY else self._clip
                     x_0[i] = uniform.rvs(lowerbound, (upperbound - lowerbound))
             # run optimization
             t_0 = time.time()
diff --git a/qiskit_optimization/algorithms/optimization_algorithm.py b/qiskit_optimization/algorithms/optimization_algorithm.py
index b302fa2f8..41174e493 100644
--- a/qiskit_optimization/algorithms/optimization_algorithm.py
+++ b/qiskit_optimization/algorithms/optimization_algorithm.py
@@ -143,17 +143,11 @@ def __init__(
         if samples:
             sum_prob = np.sum([e.probability for e in samples])
             if not np.isclose(sum_prob, 1.0):
-                warn(
-                    "The sum of probability of samples is not close to 1: {}".format(
-                        sum_prob
-                    )
-                )
+                warn("The sum of probability of samples is not close to 1: {}".format(sum_prob))
             self._samples = samples
         else:
             self._samples = [
-                SolutionSample(
-                    x=cast(np.ndarray, x), fval=fval, status=status, probability=1.0
-                )
+                SolutionSample(x=cast(np.ndarray, x), fval=fval, status=status, probability=1.0)
             ]
 
     def __repr__(self) -> str:
@@ -188,8 +182,7 @@ def __getitem__(self, key: Union[int, str]) -> float:
         if isinstance(key, str):
             return self._variables_dict[key]
         raise TypeError(
-            "Integer or string key required,"
-            "instead {}({}) provided.".format(type(key), key)
+            "Integer or string key required," "instead {}({}) provided.".format(type(key), key)
         )
 
     def get_correlations(self) -> np.ndarray:
@@ -368,16 +361,12 @@ def _get_feasibility_status(
         is_feasible = problem.is_feasible(x)
 
         return (
-            OptimizationResultStatus.SUCCESS
-            if is_feasible
-            else OptimizationResultStatus.INFEASIBLE
+            OptimizationResultStatus.SUCCESS if is_feasible else OptimizationResultStatus.INFEASIBLE
         )
 
     @staticmethod
     def _prepare_converters(
-        converters: Optional[
-            Union[QuadraticProgramConverter, List[QuadraticProgramConverter]]
-        ],
+        converters: Optional[Union[QuadraticProgramConverter, List[QuadraticProgramConverter]]],
         penalty: Optional[float] = None,
     ) -> List[QuadraticProgramConverter]:
         """Prepare a list of converters from the input.
@@ -405,9 +394,7 @@ def _prepare_converters(
         ):
             return converters
         else:
-            raise TypeError(
-                "`converters` must all be of the QuadraticProgramConverter type"
-            )
+            raise TypeError("`converters` must all be of the QuadraticProgramConverter type")
 
     @staticmethod
     def _convert(
@@ -442,7 +429,7 @@ def _interpret(
             Union[QuadraticProgramConverter, List[QuadraticProgramConverter]]
         ] = None,
         result_class: Type[OptimizationResult] = OptimizationResult,
-        **kwargs
+        **kwargs,
     ) -> OptimizationResult:
         """Convert back the result of the converted problem to the result of the original problem.
 
@@ -481,7 +468,7 @@ def _interpret(
             fval=problem.objective.evaluate(x),
             variables=problem.variables,
             status=cls._get_feasibility_status(problem, x),
-            **kwargs
+            **kwargs,
         )
 
     @classmethod
@@ -548,9 +535,7 @@ def _eigenvector_to_solutions(
             TypeError: If the type of eigenvector is not supported.
         """
         if isinstance(eigenvector, DictStateFn):
-            eigenvector = {
-                bitstr: val ** 2 for (bitstr, val) in eigenvector.primitive.items()
-            }
+            eigenvector = {bitstr: val ** 2 for (bitstr, val) in eigenvector.primitive.items()}
         elif isinstance(eigenvector, StateFn):
             eigenvector = eigenvector.to_matrix()
 
@@ -572,9 +557,7 @@ def generate_solution(bitstr, qubo, probability):
                 sampling_probability = count / all_counts
                 # add the bitstring, if the sampling probability exceeds the threshold
                 if sampling_probability >= min_probability:
-                    solutions.append(
-                        generate_solution(bitstr, qubo, sampling_probability)
-                    )
+                    solutions.append(generate_solution(bitstr, qubo, sampling_probability))
 
         elif isinstance(eigenvector, np.ndarray):
             num_qubits = int(np.log2(eigenvector.size))
@@ -585,13 +568,9 @@ def generate_solution(bitstr, qubo, probability):
                 # add the i-th state if the sampling probability exceeds the threshold
                 if sampling_probability >= min_probability:
                     bitstr = "{:b}".format(i).rjust(num_qubits, "0")[::-1]
-                    solutions.append(
-                        generate_solution(bitstr, qubo, sampling_probability)
-                    )
+                    solutions.append(generate_solution(bitstr, qubo, sampling_probability))
 
         else:
-            raise TypeError(
-                "Unsupported format of eigenvector. Provide a dict or numpy.ndarray."
-            )
+            raise TypeError("Unsupported format of eigenvector. Provide a dict or numpy.ndarray.")
 
         return solutions
diff --git a/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py b/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py
index ca6899f1b..f9487eb9f 100644
--- a/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py
+++ b/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py
@@ -186,9 +186,7 @@ def __init__(
         if min_num_vars_optimizer:
             self._min_num_vars_optimizer = min_num_vars_optimizer
         else:
-            self._min_num_vars_optimizer = MinimumEigenOptimizer(
-                NumPyMinimumEigensolver()
-            )
+            self._min_num_vars_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
         self._penalty = penalty
         self._history = history
 
@@ -249,9 +247,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
                 # set x_i = x_j
                 problem_ = problem_.substitute_variables(variables={i: (j, 1)})
                 if problem_.status == QuadraticProgram.Status.INFEASIBLE:
-                    raise QiskitOptimizationError(
-                        "Infeasible due to variable substitution"
-                    )
+                    raise QiskitOptimizationError("Infeasible due to variable substitution")
                 replacements[x_i] = (x_j, 1)
             else:
                 # set x_i = 1 - x_j, this is done in two steps:
@@ -281,9 +277,7 @@ def solve(self, problem: QuadraticProgram) -> OptimizationResult:
                 # 2. replace x_i by -x_j
                 problem_ = problem_.substitute_variables(variables={i: (j, -1)})
                 if problem_.status == QuadraticProgram.Status.INFEASIBLE:
-                    raise QiskitOptimizationError(
-                        "Infeasible due to variable substitution"
-                    )
+                    raise QiskitOptimizationError("Infeasible due to variable substitution")
                 replacements[x_i] = (x_j, -1)
 
         # solve remaining problem
diff --git a/qiskit_optimization/algorithms/slsqp_optimizer.py b/qiskit_optimization/algorithms/slsqp_optimizer.py
index c1c1a5b74..3473e0ed0 100644
--- a/qiskit_optimization/algorithms/slsqp_optimizer.py
+++ b/qiskit_optimization/algorithms/slsqp_optimizer.py
@@ -189,9 +189,7 @@ def _objective(x):
             return problem.objective.sense.value * problem.objective.evaluate(x)
 
         def _objective_gradient(x):
-            return problem.objective.sense.value * problem.objective.evaluate_gradient(
-                x
-            )
+            return problem.objective.sense.value * problem.objective.evaluate_gradient(x)
 
         # initialize constraints and bounds
         slsqp_bounds = []
@@ -213,17 +211,11 @@ def _objective_gradient(x):
             sense = constraint.sense
 
             if sense == Constraint.Sense.EQ:
-                slsqp_eq_constraints += [
-                    lambda x, rhs=rhs, c=constraint: rhs - c.evaluate(x)
-                ]
+                slsqp_eq_constraints += [lambda x, rhs=rhs, c=constraint: rhs - c.evaluate(x)]
             elif sense == Constraint.Sense.LE:
-                slsqp_ineq_constraints += [
-                    lambda x, rhs=rhs, c=constraint: rhs - c.evaluate(x)
-                ]
+                slsqp_ineq_constraints += [lambda x, rhs=rhs, c=constraint: rhs - c.evaluate(x)]
             elif sense == Constraint.Sense.GE:
-                slsqp_ineq_constraints += [
-                    lambda x, rhs=rhs, c=constraint: c.evaluate(x) - rhs
-                ]
+                slsqp_ineq_constraints += [lambda x, rhs=rhs, c=constraint: c.evaluate(x) - rhs]
             else:
                 raise QiskitOptimizationError("Unsupported constraint type!")
 
diff --git a/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py b/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py
index 360bc5c0b..53148fecd 100644
--- a/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py
+++ b/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py
@@ -40,9 +40,7 @@ class BaseAggregator(ABC):
     """A base abstract class for aggregates results"""
 
     @abstractmethod
-    def aggregate(
-        self, results: List[MinimumEigenOptimizationResult]
-    ) -> List[SolutionSample]:
+    def aggregate(self, results: List[MinimumEigenOptimizationResult]) -> List[SolutionSample]:
         """
         Aggregates the results.
 
@@ -58,9 +56,7 @@ def aggregate(
 class MeanAggregator(BaseAggregator):
     """Aggregates the results by averaging the probability of each sample."""
 
-    def aggregate(
-        self, results: List[MinimumEigenOptimizationResult]
-    ) -> List[SolutionSample]:
+    def aggregate(self, results: List[MinimumEigenOptimizationResult]) -> List[SolutionSample]:
         """
         Args:
             results: List of result objects that need to be combined.
@@ -313,8 +309,7 @@ def solve(self, problem: QuadraticProgram) -> MinimumEigenOptimizationResult:
         opt_result = self._pre_solver.solve(pre_solver_problem)
         if opt_result.status != OptimizationResultStatus.SUCCESS:
             raise QiskitOptimizationError(
-                f"Presolver returned status {opt_result.status}, "
-                f"the problem can't be solved"
+                f"Presolver returned status {opt_result.status}, " f"the problem can't be solved"
             )
 
         # we pick only a certain number of the pre-solved solutions.
@@ -327,27 +322,21 @@ def solve(self, problem: QuadraticProgram) -> MinimumEigenOptimizationResult:
         results: List[MinimumEigenOptimizationResult] = []
         for pre_solution in pre_solutions:
             # Set the solver using the result of the pre-solver.
-            initial_variables = self._warm_start_factory.create_initial_variables(
-                pre_solution.x
-            )
+            initial_variables = self._warm_start_factory.create_initial_variables(pre_solution.x)
             self._qaoa.initial_state = self._warm_start_factory.create_initial_state(
                 initial_variables
             )
             self._qaoa.mixer = self._warm_start_factory.create_mixer(initial_variables)
 
             # approximate ground state of operator using min eigen solver.
-            results.append(
-                self._solve_internal(operator, offset, converted_problem, problem)
-            )
+            results.append(self._solve_internal(operator, offset, converted_problem, problem))
 
         if len(results) == 1:
             # there's no need to call _interpret, it is already done by MinimumEigenOptimizer
             return results[0]
         else:
             samples = self._aggregator.aggregate(results)
-            samples.sort(
-                key=lambda sample: converted_problem.objective.sense.value * sample.fval
-            )
+            samples.sort(key=lambda sample: converted_problem.objective.sense.value * sample.fval)
 
             # translate result back to the original variables
             return cast(
diff --git a/qiskit_optimization/applications/exact_cover.py b/qiskit_optimization/applications/exact_cover.py
index 1e560a829..125d18093 100644
--- a/qiskit_optimization/applications/exact_cover.py
+++ b/qiskit_optimization/applications/exact_cover.py
@@ -49,22 +49,17 @@ def to_quadratic_program(self) -> QuadraticProgram:
             from the exact cover instance.
         """
         mdl = Model(name="Exact cover")
-        x = {
-            i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._subsets))
-        }
+        x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._subsets))}
         mdl.minimize(mdl.sum(x[i] for i in x))
         for element in self._set:
             mdl.add_constraint(
-                mdl.sum(x[i] for i, sub in enumerate(self._subsets) if element in sub)
-                == 1
+                mdl.sum(x[i] for i, sub in enumerate(self._subsets) if element in sub) == 1
             )
         op = QuadraticProgram()
         op.from_docplex(mdl)
         return op
 
-    def interpret(
-        self, result: Union[OptimizationResult, np.ndarray]
-    ) -> List[List[int]]:
+    def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[int]]:
         """Interpret a result as a list of subsets
 
         Args:
diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py
index 467039afa..00838d7fa 100644
--- a/qiskit_optimization/applications/graph_optimization_application.py
+++ b/qiskit_optimization/applications/graph_optimization_application.py
@@ -94,9 +94,7 @@ def graph(self) -> nx.Graph:
         return self._graph
 
     @staticmethod
-    def random_graph(
-        num_nodes: int, num_edges: int, seed: Optional[int] = None
-    ) -> nx.Graph:
+    def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> nx.Graph:
         """
 
         Args:
diff --git a/qiskit_optimization/applications/graph_partition.py b/qiskit_optimization/applications/graph_partition.py
index 3aaddb9df..9d3370e90 100644
--- a/qiskit_optimization/applications/graph_partition.py
+++ b/qiskit_optimization/applications/graph_partition.py
@@ -53,9 +53,7 @@ def to_quadratic_program(self) -> QuadraticProgram:
         op.from_docplex(mdl)
         return op
 
-    def interpret(
-        self, result: Union[OptimizationResult, np.ndarray]
-    ) -> List[List[int]]:
+    def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[int]]:
         """Interpret a result as a list of node indices
 
         Args:
diff --git a/qiskit_optimization/applications/knapsack.py b/qiskit_optimization/applications/knapsack.py
index faba86604..329c9d0ad 100644
--- a/qiskit_optimization/applications/knapsack.py
+++ b/qiskit_optimization/applications/knapsack.py
@@ -49,13 +49,9 @@ def to_quadratic_program(self) -> QuadraticProgram:
             from the knapsack problem instance.
         """
         mdl = Model(name="Knapsack")
-        x = {
-            i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._values))
-        }
+        x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._values))}
         mdl.maximize(mdl.sum(self._values[i] * x[i] for i in x))
-        mdl.add_constraint(
-            mdl.sum(self._weights[i] * x[i] for i in x) <= self._max_weight
-        )
+        mdl.add_constraint(mdl.sum(self._weights[i] * x[i] for i in x) <= self._max_weight)
         op = QuadraticProgram()
         op.from_docplex(mdl)
         return op
diff --git a/qiskit_optimization/applications/max_cut.py b/qiskit_optimization/applications/max_cut.py
index 97ee237a5..3510773cc 100644
--- a/qiskit_optimization/applications/max_cut.py
+++ b/qiskit_optimization/applications/max_cut.py
@@ -41,8 +41,7 @@ def to_quadratic_program(self) -> QuadraticProgram:
         """
         mdl = Model(name="Max-cut")
         x = {
-            i: mdl.binary_var(name="x_{0}".format(i))
-            for i in range(self._graph.number_of_nodes())
+            i: mdl.binary_var(name="x_{0}".format(i)) for i in range(self._graph.number_of_nodes())
         }
         for w, v in self._graph.edges:
             self._graph.edges[w, v].setdefault("weight", 1)
@@ -70,9 +69,7 @@ def _draw_result(
         x = self._result_to_x(result)
         nx.draw(self._graph, node_color=self._node_color(x), pos=pos, with_labels=True)
 
-    def interpret(
-        self, result: Union[OptimizationResult, np.ndarray]
-    ) -> List[List[int]]:
+    def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[int]]:
         """Interpret a result as two lists of node indices
 
         Args:
diff --git a/qiskit_optimization/applications/number_partition.py b/qiskit_optimization/applications/number_partition.py
index b58e1334a..4c72e058d 100644
--- a/qiskit_optimization/applications/number_partition.py
+++ b/qiskit_optimization/applications/number_partition.py
@@ -46,21 +46,15 @@ def to_quadratic_program(self) -> QuadraticProgram:
             from the number partitioning problem instance.
         """
         mdl = Model(name="Number partitioning")
-        x = {
-            i: mdl.binary_var(name="x_{0}".format(i))
-            for i in range(len(self._number_set))
-        }
+        x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._number_set))}
         mdl.add_constraint(
-            mdl.sum(num * (-2 * x[i] + 1) for i, num in enumerate(self._number_set))
-            == 0
+            mdl.sum(num * (-2 * x[i] + 1) for i, num in enumerate(self._number_set)) == 0
         )
         op = QuadraticProgram()
         op.from_docplex(mdl)
         return op
 
-    def interpret(
-        self, result: Union[OptimizationResult, np.ndarray]
-    ) -> List[List[int]]:
+    def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[int]]:
         """Interpret a result as a list of subsets
 
         Args:
diff --git a/qiskit_optimization/applications/set_packing.py b/qiskit_optimization/applications/set_packing.py
index fd26cc7ce..3341ff455 100644
--- a/qiskit_optimization/applications/set_packing.py
+++ b/qiskit_optimization/applications/set_packing.py
@@ -50,22 +50,17 @@ def to_quadratic_program(self) -> QuadraticProgram:
             from the set packing instance.
         """
         mdl = Model(name="Set packing")
-        x = {
-            i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._subsets))
-        }
+        x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(len(self._subsets))}
         mdl.maximize(mdl.sum(x[i] for i in x))
         for element in self._set:
             mdl.add_constraint(
-                mdl.sum(x[i] for i, sub in enumerate(self._subsets) if element in sub)
-                <= 1
+                mdl.sum(x[i] for i, sub in enumerate(self._subsets) if element in sub) <= 1
             )
         op = QuadraticProgram()
         op.from_docplex(mdl)
         return op
 
-    def interpret(
-        self, result: Union[OptimizationResult, np.ndarray]
-    ) -> List[List[int]]:
+    def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[int]]:
         """Interpret a result as a list of subsets
 
         Args:
diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py
index 168f9ce50..822f8a601 100644
--- a/qiskit_optimization/applications/tsp.py
+++ b/qiskit_optimization/applications/tsp.py
@@ -118,9 +118,7 @@ def _edgelist(self, x: np.ndarray):
 
     @staticmethod
     # pylint: disable=undefined-variable
-    def create_random_instance(
-        n: int, low: int = 0, high: int = 100, seed: int = None
-    ) -> "Tsp":
+    def create_random_instance(n: int, low: int = 0, high: int = 100, seed: int = None) -> "Tsp":
         """Create a random instance of the traveling salesman problem
 
         Args:
@@ -136,13 +134,9 @@ def create_random_instance(
             algorithm_globals.random_seed = seed
         coord = algorithm_globals.random.uniform(low, high, (n, 2))
         pos = {i: (coord_[0], coord_[1]) for i, coord_ in enumerate(coord)}
-        graph = nx.random_geometric_graph(
-            n, np.hypot(high - low, high - low) + 1, pos=pos
-        )
+        graph = nx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos)
         for w, v in graph.edges:
-            delta = [
-                graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)
-            ]
+            delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)]
             graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1]))
         return Tsp(graph)
 
@@ -183,9 +177,7 @@ def parse_tsplib_format(filename: str) -> "Tsp":
                     typ.strip()
                     if typ != "EUC_2D":
                         raise QiskitOptimizationError(
-                            'This supports only "EUC_2D" edge weight. Actual: {}'.format(
-                                typ
-                            )
+                            'This supports only "EUC_2D" edge weight. Actual: {}'.format(typ)
                         )
                 elif line.startswith("NODE_COORD_SECTION"):
                     coord_section = True
@@ -204,9 +196,7 @@ def parse_tsplib_format(filename: str) -> "Tsp":
             len(coord), np.hypot(x_max - x_min, y_max - y_min) + 1, pos=coord
         )
         for w, v in graph.edges:
-            delta = [
-                graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)
-            ]
+            delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)]
             graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1]))
         return Tsp(graph)
 
diff --git a/qiskit_optimization/applications/vehicle_routing.py b/qiskit_optimization/applications/vehicle_routing.py
index ad5911368..5be280d1d 100644
--- a/qiskit_optimization/applications/vehicle_routing.py
+++ b/qiskit_optimization/applications/vehicle_routing.py
@@ -83,12 +83,10 @@ def to_quadratic_program(self) -> QuadraticProgram:
                 mdl.add_constraint(mdl.sum(x[i, j] for i in range(n) if i != j) == 1)
         # For the depot node
         mdl.add_constraint(
-            mdl.sum(x[i, self.depot] for i in range(n) if i != self.depot)
-            == self.num_vehicles
+            mdl.sum(x[i, self.depot] for i in range(n) if i != self.depot) == self.num_vehicles
         )
         mdl.add_constraint(
-            mdl.sum(x[self.depot, j] for j in range(n) if j != self.depot)
-            == self.num_vehicles
+            mdl.sum(x[self.depot, j] for j in range(n) if j != self.depot) == self.num_vehicles
         )
 
         # To eliminate sub-routes
@@ -99,16 +97,13 @@ def to_quadratic_program(self) -> QuadraticProgram:
                 clique_set.append(list(comb))
         for clique in clique_set:
             mdl.add_constraint(
-                mdl.sum(x[(i, j)] for i in clique for j in clique if i != j)
-                <= len(clique) - 1
+                mdl.sum(x[(i, j)] for i in clique for j in clique if i != j) <= len(clique) - 1
             )
         op = QuadraticProgram()
         op.from_docplex(mdl)
         return op
 
-    def interpret(
-        self, result: Union[OptimizationResult, np.ndarray]
-    ) -> List[List[List[int]]]:
+    def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[List[int]]]:
         """Interpret a result as a list of the routes for each vehicle
 
         Args:
@@ -182,11 +177,7 @@ def _edgelist(self, route_list: List[List[List[int]]]):
     def _edge_color(self, route_list: List[List[List[int]]]):
         # Arrange route_list and return the list of the colors of each route
         # for edge_color of nx.draw_networkx_edges
-        return [
-            k / len(route_list)
-            for k in range(len(route_list))
-            for edge in route_list[k]
-        ]
+        return [k / len(route_list) for k in range(len(route_list)) for edge in route_list[k]]
 
     @property
     def num_vehicles(self) -> int:
@@ -248,15 +239,9 @@ def create_random_instance(
             A VehicleRouting instance created from the input information
         """
         random.seed(seed)
-        pos = {
-            i: (random.randint(low, high), random.randint(low, high)) for i in range(n)
-        }
-        graph = nx.random_geometric_graph(
-            n, np.hypot(high - low, high - low) + 1, pos=pos
-        )
+        pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(n)}
+        graph = nx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos)
         for w, v in graph.edges:
-            delta = [
-                graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)
-            ]
+            delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)]
             graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1]))
         return VehicleRouting(graph, num_vehicle, depot)
diff --git a/qiskit_optimization/converters/inequality_to_equality.py b/qiskit_optimization/converters/inequality_to_equality.py
index ef5d71785..a59cafb71 100644
--- a/qiskit_optimization/converters/inequality_to_equality.py
+++ b/qiskit_optimization/converters/inequality_to_equality.py
@@ -81,17 +81,13 @@ def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
             if x.vartype == Variable.Type.BINARY:
                 self._dst.binary_var(name=x.name)
             elif x.vartype == Variable.Type.INTEGER:
-                self._dst.integer_var(
-                    name=x.name, lowerbound=x.lowerbound, upperbound=x.upperbound
-                )
+                self._dst.integer_var(name=x.name, lowerbound=x.lowerbound, upperbound=x.upperbound)
             elif x.vartype == Variable.Type.CONTINUOUS:
                 self._dst.continuous_var(
                     name=x.name, lowerbound=x.lowerbound, upperbound=x.upperbound
                 )
             else:
-                raise QiskitOptimizationError(
-                    "Unsupported variable type {}".format(x.vartype)
-                )
+                raise QiskitOptimizationError("Unsupported variable type {}".format(x.vartype))
 
         # Copy the objective function
         constant = self._src.objective.constant
@@ -126,9 +122,7 @@ def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
                         linear, l_constraint.sense, l_constraint.rhs, l_constraint.name
                     )
                 else:
-                    raise QiskitOptimizationError(
-                        "Unsupported mode is selected: {}".format(mode)
-                    )
+                    raise QiskitOptimizationError("Unsupported mode is selected: {}".format(mode))
             else:
                 raise QiskitOptimizationError(
                     "Type of sense in {} is not supported".format(l_constraint.name)
@@ -175,9 +169,7 @@ def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
                         q_constraint.name,
                     )
                 else:
-                    raise QiskitOptimizationError(
-                        "Unsupported mode is selected: {}".format(mode)
-                    )
+                    raise QiskitOptimizationError("Unsupported mode is selected: {}".format(mode))
             else:
                 raise QiskitOptimizationError(
                     "Type of sense in {} is not supported".format(q_constraint.name)
@@ -220,9 +212,7 @@ def _add_integer_slack_var_linear_constraint(self, linear, sense, rhs, name):
                 self._dst.integer_var(name=slack_name, lowerbound=0, upperbound=var_ub)
                 var_added = True
         else:
-            raise QiskitOptimizationError(
-                "The type of Sense in {} is not supported".format(name)
-            )
+            raise QiskitOptimizationError("The type of Sense in {} is not supported".format(name))
 
         # Add a new equality constraint.
         new_linear = copy.deepcopy(linear)
@@ -240,22 +230,16 @@ def _add_continuous_slack_var_linear_constraint(self, linear, sense, rhs, name):
             var_ub = rhs - lhs_lb
             if var_ub > 0:
                 sign = 1
-                self._dst.continuous_var(
-                    name=slack_name, lowerbound=0, upperbound=var_ub
-                )
+                self._dst.continuous_var(name=slack_name, lowerbound=0, upperbound=var_ub)
                 var_added = True
         elif sense == Constraint.Sense.GE:
             var_ub = lhs_ub - rhs
             if var_ub > 0:
                 sign = -1
-                self._dst.continuous_var(
-                    name=slack_name, lowerbound=0, upperbound=var_ub
-                )
+                self._dst.continuous_var(name=slack_name, lowerbound=0, upperbound=var_ub)
                 var_added = True
         else:
-            raise QiskitOptimizationError(
-                "The type of Sense in {} is not supported".format(name)
-            )
+            raise QiskitOptimizationError("The type of Sense in {} is not supported".format(name))
 
         # Add a new equality constraint.
         new_linear = copy.deepcopy(linear)
@@ -271,13 +255,11 @@ def _add_auto_slack_var_linear_constraint(self, linear, sense, rhs, name):
         else:
             self._add_integer_slack_var_linear_constraint(linear, sense, rhs, name)
 
-    def _add_integer_slack_var_quadratic_constraint(
-        self, linear, quadratic, sense, rhs, name
-    ):
+    def _add_integer_slack_var_quadratic_constraint(self, linear, quadratic, sense, rhs, name):
         # If a coefficient that is not integer exist, raise an error
-        if self._contains_any_float_value(
-            list(linear.values())
-        ) or self._contains_any_float_value(list(quadratic.values())):
+        if self._contains_any_float_value(list(linear.values())) or self._contains_any_float_value(
+            list(quadratic.values())
+        ):
             raise QiskitOptimizationError(
                 '"{0}" contains float coefficients. '
                 'We can not use an integer slack variable for "{0}"'.format(name)
@@ -310,9 +292,7 @@ def _add_integer_slack_var_quadratic_constraint(
                 self._dst.integer_var(name=slack_name, lowerbound=0, upperbound=var_ub)
                 var_added = True
         else:
-            raise QiskitOptimizationError(
-                "The type of Sense in {} is not supported".format(name)
-            )
+            raise QiskitOptimizationError("The type of Sense in {} is not supported".format(name))
 
         # Add a new equality constraint.
         new_linear = copy.deepcopy(linear)
@@ -320,9 +300,7 @@ def _add_integer_slack_var_quadratic_constraint(
             new_linear[slack_name] = sign
         self._dst.quadratic_constraint(new_linear, quadratic, "==", new_rhs, name)
 
-    def _add_continuous_slack_var_quadratic_constraint(
-        self, linear, quadratic, sense, rhs, name
-    ):
+    def _add_continuous_slack_var_quadratic_constraint(self, linear, quadratic, sense, rhs, name):
         # Add a new continuous variable.
         slack_name = name + self._delimiter + "continuous_slack"
 
@@ -334,22 +312,16 @@ def _add_continuous_slack_var_quadratic_constraint(
             var_ub = rhs - lhs_lb
             if var_ub > 0:
                 sign = 1
-                self._dst.continuous_var(
-                    name=slack_name, lowerbound=0, upperbound=var_ub
-                )
+                self._dst.continuous_var(name=slack_name, lowerbound=0, upperbound=var_ub)
                 var_added = True
         elif sense == Constraint.Sense.GE:
             var_ub = lhs_ub - rhs
             if var_ub > 0:
                 sign = -1
-                self._dst.continuous_var(
-                    name=slack_name, lowerbound=0, upperbound=lhs_ub - rhs
-                )
+                self._dst.continuous_var(name=slack_name, lowerbound=0, upperbound=lhs_ub - rhs)
                 var_added = True
         else:
-            raise QiskitOptimizationError(
-                "The type of Sense in {} is not supported".format(name)
-            )
+            raise QiskitOptimizationError("The type of Sense in {} is not supported".format(name))
 
         # Add a new equality constraint.
         new_linear = copy.deepcopy(linear)
@@ -357,21 +329,15 @@ def _add_continuous_slack_var_quadratic_constraint(
             new_linear[slack_name] = sign
         self._dst.quadratic_constraint(new_linear, quadratic, "==", rhs, name)
 
-    def _add_auto_slack_var_quadratic_constraint(
-        self, linear, quadratic, sense, rhs, name
-    ):
+    def _add_auto_slack_var_quadratic_constraint(self, linear, quadratic, sense, rhs, name):
         # If a coefficient that is not integer exist, use a continuous slack variable
-        if self._contains_any_float_value(
-            list(linear.values())
-        ) or self._contains_any_float_value(list(quadratic.values())):
-            self._add_continuous_slack_var_quadratic_constraint(
-                linear, quadratic, sense, rhs, name
-            )
+        if self._contains_any_float_value(list(linear.values())) or self._contains_any_float_value(
+            list(quadratic.values())
+        ):
+            self._add_continuous_slack_var_quadratic_constraint(linear, quadratic, sense, rhs, name)
         # Else use an integer slack variable
         else:
-            self._add_integer_slack_var_quadratic_constraint(
-                linear, quadratic, sense, rhs, name
-            )
+            self._add_integer_slack_var_quadratic_constraint(linear, quadratic, sense, rhs, name)
 
     def _calc_linear_bounds(self, linear):
         lhs_lb, lhs_ub = 0, 0
diff --git a/qiskit_optimization/converters/integer_to_binary.py b/qiskit_optimization/converters/integer_to_binary.py
index 42a12513e..b4e19db85 100644
--- a/qiskit_optimization/converters/integer_to_binary.py
+++ b/qiskit_optimization/converters/integer_to_binary.py
@@ -108,9 +108,7 @@ def _convert_var(
         bounded_coef = var_range - (2 ** power - 1)
 
         coeffs = [2 ** i for i in range(power)] + [bounded_coef]
-        return [
-            (name + self._delimiter + str(i), coef) for i, coef in enumerate(coeffs)
-        ]
+        return [(name + self._delimiter + str(i), coef) for i, coef in enumerate(coeffs)]
 
     def _convert_linear_coefficients_dict(
         self, coefficients: Dict[str, float]
@@ -229,10 +227,7 @@ def interpret(self, x: Union[np.ndarray, List[float]]) -> np.ndarray:
         new_x = np.zeros(self._src.get_num_vars())
         for i, var in enumerate(self._src.variables):
             if var in self._conv:
-                new_x[i] = (
-                    sum(sol[aux] * coef for aux, coef in self._conv[var])
-                    + var.lowerbound
-                )
+                new_x[i] = sum(sol[aux] * coef for aux, coef in self._conv[var]) + var.lowerbound
             else:
                 new_x[i] = sol[var.name]
         return np.array(new_x)
diff --git a/qiskit_optimization/converters/linear_equality_to_penalty.py b/qiskit_optimization/converters/linear_equality_to_penalty.py
index 1214c3fe0..17cce7ab6 100644
--- a/qiskit_optimization/converters/linear_equality_to_penalty.py
+++ b/qiskit_optimization/converters/linear_equality_to_penalty.py
@@ -75,9 +75,7 @@ def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
             elif x.vartype == Variable.Type.INTEGER:
                 self._dst.integer_var(x.lowerbound, x.upperbound, x.name)
             else:
-                raise QiskitOptimizationError(
-                    "Unsupported vartype: {}".format(x.vartype)
-                )
+                raise QiskitOptimizationError("Unsupported vartype: {}".format(x.vartype))
 
         # get original objective terms
         offset = self._src.objective.constant
@@ -116,9 +114,7 @@ def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
                     # according to implementation of quadratic terms in OptimizationModel,
                     # don't need to multiply by 2, since loops run over (x, y) and (y, x).
                     tup = cast(Union[Tuple[int, int], Tuple[str, str]], (j, k))
-                    quadratic[tup] = (
-                        quadratic.get(tup, 0.0) + sense * penalty * coef_1 * coef_2
-                    )
+                    quadratic[tup] = quadratic.get(tup, 0.0) + sense * penalty * coef_1 * coef_2
 
         if self._src.objective.sense == QuadraticObjective.Sense.MINIMIZE:
             self._dst.minimize(offset, linear, quadratic)
@@ -161,13 +157,9 @@ def _auto_define_penalty(self) -> float:
         # Firstly, add 1 to guarantee that infeasible answers will be greater than upper bound.
         penalties = [1.0]
         # add linear terms of the object function.
-        penalties.extend(
-            abs(coef) for coef in self._src.objective.linear.to_dict().values()
-        )
+        penalties.extend(abs(coef) for coef in self._src.objective.linear.to_dict().values())
         # add quadratic terms of the object function.
-        penalties.extend(
-            abs(coef) for coef in self._src.objective.quadratic.to_dict().values()
-        )
+        penalties.extend(abs(coef) for coef in self._src.objective.quadratic.to_dict().values())
 
         return fsum(penalties)
 
diff --git a/qiskit_optimization/converters/quadratic_program_to_qubo.py b/qiskit_optimization/converters/quadratic_program_to_qubo.py
index 60e01c9a7..55fd993e1 100644
--- a/qiskit_optimization/converters/quadratic_program_to_qubo.py
+++ b/qiskit_optimization/converters/quadratic_program_to_qubo.py
@@ -119,21 +119,14 @@ def get_compatibility_msg(problem: QuadraticProgram) -> str:
         compatible_with_integer_slack = True
         for l_constraint in problem.linear_constraints:
             linear = l_constraint.linear.to_dict()
-            if any(
-                isinstance(coef, float) and not coef.is_integer()
-                for coef in linear.values()
-            ):
+            if any(isinstance(coef, float) and not coef.is_integer() for coef in linear.values()):
                 compatible_with_integer_slack = False
         for q_constraint in problem.quadratic_constraints:
             linear = q_constraint.linear.to_dict()
             quadratic = q_constraint.quadratic.to_dict()
             if any(
-                isinstance(coef, float) and not coef.is_integer()
-                for coef in quadratic.values()
-            ) or any(
-                isinstance(coef, float) and not coef.is_integer()
-                for coef in linear.values()
-            ):
+                isinstance(coef, float) and not coef.is_integer() for coef in quadratic.values()
+            ) or any(isinstance(coef, float) and not coef.is_integer() for coef in linear.values()):
                 compatible_with_integer_slack = False
         if not compatible_with_integer_slack:
             msg += "Can not convert inequality constraints to equality constraint because \
diff --git a/qiskit_optimization/problems/linear_expression.py b/qiskit_optimization/problems/linear_expression.py
index d348e6bf6..5ff5468a0 100644
--- a/qiskit_optimization/problems/linear_expression.py
+++ b/qiskit_optimization/problems/linear_expression.py
@@ -27,9 +27,7 @@ class LinearExpression(QuadraticProgramElement):
     def __init__(
         self,
         quadratic_program: Any,
-        coefficients: Union[
-            ndarray, spmatrix, List[float], Dict[Union[int, str], float]
-        ],
+        coefficients: Union[ndarray, spmatrix, List[float], Dict[Union[int, str], float]],
     ) -> None:
         """Creates a new linear expression.
 
@@ -108,9 +106,7 @@ def coefficients(self) -> dok_matrix:
     @coefficients.setter
     def coefficients(
         self,
-        coefficients: Union[
-            ndarray, spmatrix, List[float], Dict[Union[str, int], float]
-        ],
+        coefficients: Union[ndarray, spmatrix, List[float], Dict[Union[str, int], float]],
     ) -> None:
         """Sets the coefficients of the linear expression.
 
@@ -164,9 +160,7 @@ def evaluate(self, x: Union[ndarray, List, Dict[Union[int, str], float]]) -> flo
         return val
 
     # pylint: disable=unused-argument
-    def evaluate_gradient(
-        self, x: Union[ndarray, List, Dict[Union[int, str], float]]
-    ) -> ndarray:
+    def evaluate_gradient(self, x: Union[ndarray, List, Dict[Union[int, str], float]]) -> ndarray:
         """Evaluate the gradient of the linear expression for given variables.
 
         Args:
diff --git a/qiskit_optimization/problems/quadratic_expression.py b/qiskit_optimization/problems/quadratic_expression.py
index 5f4cb3c86..e9682643e 100644
--- a/qiskit_optimization/problems/quadratic_expression.py
+++ b/qiskit_optimization/problems/quadratic_expression.py
@@ -66,9 +66,7 @@ def __getitem__(self, key: Tuple[Union[int, str], Union[int, str]]) -> float:
             j = self.quadratic_program.variables_index[j]
         return self.coefficients[min(i, j), max(i, j)]
 
-    def __setitem__(
-        self, key: Tuple[Union[int, str], Union[int, str]], value: float
-    ) -> None:
+    def __setitem__(self, key: Tuple[Union[int, str], Union[int, str]], value: float) -> None:
         """Sets the coefficient where i, j can be a variable names or indices.
 
         Args:
@@ -167,11 +165,7 @@ def to_array(self, symmetric: bool = False) -> ndarray:
         Returns:
             An array with the coefficients corresponding to the quadratic expression.
         """
-        coeffs = (
-            self._symmetric_matrix(self._coefficients)
-            if symmetric
-            else self._coefficients
-        )
+        coeffs = self._symmetric_matrix(self._coefficients) if symmetric else self._coefficients
         return coeffs.toarray()
 
     def to_dict(
@@ -187,11 +181,7 @@ def to_dict(
         Returns:
             An dictionary with the coefficients corresponding to the quadratic expression.
         """
-        coeffs = (
-            self._symmetric_matrix(self._coefficients)
-            if symmetric
-            else self._coefficients
-        )
+        coeffs = self._symmetric_matrix(self._coefficients) if symmetric else self._coefficients
         if use_name:
             return {
                 (
@@ -220,9 +210,7 @@ def evaluate(self, x: Union[ndarray, List, Dict[Union[int, str], float]]) -> flo
         # return the result
         return val
 
-    def evaluate_gradient(
-        self, x: Union[ndarray, List, Dict[Union[int, str], float]]
-    ) -> ndarray:
+    def evaluate_gradient(self, x: Union[ndarray, List, Dict[Union[int, str], float]]) -> ndarray:
         """Evaluate the gradient of the quadratic expression for given variables.
 
         Args:
diff --git a/qiskit_optimization/problems/quadratic_objective.py b/qiskit_optimization/problems/quadratic_objective.py
index 82c70f165..e602ec49a 100644
--- a/qiskit_optimization/problems/quadratic_objective.py
+++ b/qiskit_optimization/problems/quadratic_objective.py
@@ -41,9 +41,7 @@ def __init__(
         self,
         quadratic_program: Any,
         constant: float = 0.0,
-        linear: Union[
-            ndarray, spmatrix, List[float], Dict[Union[str, int], float]
-        ] = None,
+        linear: Union[ndarray, spmatrix, List[float], Dict[Union[str, int], float]] = None,
         quadratic: Union[
             ndarray,
             spmatrix,
@@ -167,9 +165,7 @@ def evaluate(self, x: Union[ndarray, List, Dict[Union[int, str], float]]) -> flo
         """
         return self.constant + self.linear.evaluate(x) + self.quadratic.evaluate(x)
 
-    def evaluate_gradient(
-        self, x: Union[ndarray, List, Dict[Union[int, str], float]]
-    ) -> ndarray:
+    def evaluate_gradient(self, x: Union[ndarray, List, Dict[Union[int, str], float]]) -> ndarray:
         """Evaluate the gradient of the quadratic objective for given variable values.
 
         Args:
diff --git a/qiskit_optimization/problems/quadratic_program.py b/qiskit_optimization/problems/quadratic_program.py
index 477e7b57b..6c88b2f81 100644
--- a/qiskit_optimization/problems/quadratic_program.py
+++ b/qiskit_optimization/problems/quadratic_program.py
@@ -169,9 +169,7 @@ def _add_variable(
             key_format = "{}"
         else:
             key_format = ""
-        return self._add_variables(
-            1, lowerbound, upperbound, vartype, name, key_format
-        )[1][0]
+        return self._add_variables(1, lowerbound, upperbound, vartype, name, key_format)[1][0]
 
     def _add_variables(
         self,
@@ -194,9 +192,7 @@ def _add_variables(
             )
         if key_format.count("{}") > 1:
             raise QiskitOptimizationError(
-                "Formatter cannot contain more than one substitution: {}".format(
-                    key_format
-                )
+                "Formatter cannot contain more than one substitution: {}".format(key_format)
             )
 
         def _find_name(name, key_format, k):
@@ -269,11 +265,7 @@ def _var_dict(
                                      nested substitution.
         """
         return dict(
-            zip(
-                *self._add_variables(
-                    keys, lowerbound, upperbound, vartype, name, key_format
-                )
-            )
+            zip(*self._add_variables(keys, lowerbound, upperbound, vartype, name, key_format))
         )
 
     def _var_list(
@@ -308,9 +300,7 @@ def _var_list(
             QiskitOptimizationError: if `key_format` has more than one substitution or a
                                      nested substitution.
         """
-        return self._add_variables(
-            keys, lowerbound, upperbound, vartype, name, key_format
-        )[1]
+        return self._add_variables(keys, lowerbound, upperbound, vartype, name, key_format)[1]
 
     def continuous_var(
         self,
@@ -331,9 +321,7 @@ def continuous_var(
         Raises:
             QiskitOptimizationError: if the variable name is already occupied.
         """
-        return self._add_variable(
-            lowerbound, upperbound, Variable.Type.CONTINUOUS, name
-        )
+        return self._add_variable(lowerbound, upperbound, Variable.Type.CONTINUOUS, name)
 
     def continuous_var_dict(
         self,
@@ -519,9 +507,7 @@ def integer_var_dict(
             QiskitOptimizationError: if `key_format` has more than one substitution or a
                                      nested substitution.
         """
-        return self._var_dict(
-            keys, lowerbound, upperbound, Variable.Type.INTEGER, name, key_format
-        )
+        return self._var_dict(keys, lowerbound, upperbound, Variable.Type.INTEGER, name, key_format)
 
     def integer_var_list(
         self,
@@ -552,9 +538,7 @@ def integer_var_list(
             QiskitOptimizationError: if `key_format` has more than one substitution or a
                                      nested substitution.
         """
-        return self._var_list(
-            keys, lowerbound, upperbound, Variable.Type.INTEGER, name, key_format
-        )
+        return self._var_list(keys, lowerbound, upperbound, Variable.Type.INTEGER, name, key_format)
 
     def get_variable(self, i: Union[int, str]) -> Variable:
         """Returns a variable for a given name or index.
@@ -628,9 +612,7 @@ def linear_constraints_index(self) -> Dict[str, int]:
 
     def linear_constraint(
         self,
-        linear: Union[
-            ndarray, spmatrix, List[float], Dict[Union[int, str], float]
-        ] = None,
+        linear: Union[ndarray, spmatrix, List[float], Dict[Union[int, str], float]] = None,
         sense: Union[str, ConstraintSense] = "<=",
         rhs: float = 0.0,
         name: Optional[str] = None,
@@ -667,9 +649,7 @@ def linear_constraint(
         self.linear_constraints_index[name] = len(self.linear_constraints)
         if linear is None:
             linear = {}
-        constraint = LinearConstraint(
-            self, name, linear, Constraint.Sense.convert(sense), rhs
-        )
+        constraint = LinearConstraint(self, name, linear, Constraint.Sense.convert(sense), rhs)
         self.linear_constraints.append(constraint)
         return constraint
 
@@ -719,9 +699,7 @@ def quadratic_constraints_index(self) -> Dict[str, int]:
 
     def quadratic_constraint(
         self,
-        linear: Union[
-            ndarray, spmatrix, List[float], Dict[Union[int, str], float]
-        ] = None,
+        linear: Union[ndarray, spmatrix, List[float], Dict[Union[int, str], float]] = None,
         quadratic: Union[
             ndarray,
             spmatrix,
@@ -844,9 +822,7 @@ def objective(self) -> QuadraticObjective:
     def minimize(
         self,
         constant: float = 0.0,
-        linear: Union[
-            ndarray, spmatrix, List[float], Dict[Union[str, int], float]
-        ] = None,
+        linear: Union[ndarray, spmatrix, List[float], Dict[Union[str, int], float]] = None,
         quadratic: Union[
             ndarray,
             spmatrix,
@@ -871,9 +847,7 @@ def minimize(
     def maximize(
         self,
         constant: float = 0.0,
-        linear: Union[
-            ndarray, spmatrix, List[float], Dict[Union[str, int], float]
-        ] = None,
+        linear: Union[ndarray, spmatrix, List[float], Dict[Union[str, int], float]] = None,
         quadratic: Union[
             ndarray,
             spmatrix,
@@ -974,9 +948,7 @@ def from_docplex(self, model: Model) -> None:
                 # If any constraint is not linear/quadratic constraints, it raises an error.
                 # Notice that NotEqualConstraint is a subclass of Docplex's LinearConstraint,
                 # but it cannot be handled by optimization.
-                raise QiskitOptimizationError(
-                    "Unsupported constraint: {}".format(constraint)
-                )
+                raise QiskitOptimizationError("Unsupported constraint: {}".format(constraint))
             name = constraint.name
             sense = constraint.sense
 
@@ -1004,9 +976,7 @@ def from_docplex(self, model: Model) -> None:
             elif sense == sense.LE:
                 self.linear_constraint(lhs, "<=", rhs, name)
             else:
-                raise QiskitOptimizationError(
-                    "Unsupported constraint sense: {}".format(constraint)
-                )
+                raise QiskitOptimizationError("Unsupported constraint sense: {}".format(constraint))
 
         # get quadratic constraints
         for constraint in model.iter_quadratic_constraints():
@@ -1044,9 +1014,7 @@ def from_docplex(self, model: Model) -> None:
                     quadratic[i, j] = quadratic.get((i, j), 0.0) - v
             else:
                 for x in right_expr.iter_variables():
-                    linear[var_names[x]] = linear.get(
-                        var_names[x], 0.0
-                    ) - right_expr.get_coef(x)
+                    linear[var_names[x]] = linear.get(var_names[x], 0.0) - right_expr.get_coef(x)
 
             if sense == sense.EQ:
                 self.quadratic_constraint(linear, quadratic, "==", rhs, name)
@@ -1055,9 +1023,7 @@ def from_docplex(self, model: Model) -> None:
             elif sense == sense.LE:
                 self.quadratic_constraint(linear, quadratic, "<=", rhs, name)
             else:
-                raise QiskitOptimizationError(
-                    "Unsupported constraint sense: {}".format(constraint)
-                )
+                raise QiskitOptimizationError("Unsupported constraint sense: {}".format(constraint))
 
     def to_docplex(self) -> Model:
         """Returns a docplex model corresponding to this quadratic program.
@@ -1076,20 +1042,14 @@ def to_docplex(self) -> Model:
         var = {}
         for idx, x in enumerate(self.variables):
             if x.vartype == Variable.Type.CONTINUOUS:
-                var[idx] = mdl.continuous_var(
-                    lb=x.lowerbound, ub=x.upperbound, name=x.name
-                )
+                var[idx] = mdl.continuous_var(lb=x.lowerbound, ub=x.upperbound, name=x.name)
             elif x.vartype == Variable.Type.BINARY:
                 var[idx] = mdl.binary_var(name=x.name)
             elif x.vartype == Variable.Type.INTEGER:
-                var[idx] = mdl.integer_var(
-                    lb=x.lowerbound, ub=x.upperbound, name=x.name
-                )
+                var[idx] = mdl.integer_var(lb=x.lowerbound, ub=x.upperbound, name=x.name)
             else:
                 # should never happen
-                raise QiskitOptimizationError(
-                    "Unsupported variable type: {}".format(x.vartype)
-                )
+                raise QiskitOptimizationError("Unsupported variable type: {}".format(x.vartype))
 
         # add objective
         objective = self.objective.constant
@@ -1120,9 +1080,7 @@ def to_docplex(self) -> Model:
                 mdl.add_constraint(linear_expr <= rhs, ctname=name)
             else:
                 # should never happen
-                raise QiskitOptimizationError(
-                    "Unsupported constraint sense: {}".format(sense)
-                )
+                raise QiskitOptimizationError("Unsupported constraint sense: {}".format(sense))
 
         # add quadratic constraints
         for i, q_constraint in enumerate(self.quadratic_constraints):
@@ -1148,9 +1106,7 @@ def to_docplex(self) -> Model:
                 mdl.add_constraint(quadratic_expr <= rhs, ctname=name)
             else:
                 # should never happen
-                raise QiskitOptimizationError(
-                    "Unsupported constraint sense: {}".format(sense)
-                )
+                raise QiskitOptimizationError("Unsupported constraint sense: {}".format(sense))
 
         return mdl
 
@@ -1249,9 +1205,7 @@ def write_to_lp_file(self, filename: str) -> None:
     def substitute_variables(
         self,
         constants: Optional[Dict[Union[str, int], float]] = None,
-        variables: Optional[
-            Dict[Union[str, int], Tuple[Union[str, int], float]]
-        ] = None,
+        variables: Optional[Dict[Union[str, int], Tuple[Union[str, int], float]]] = None,
     ) -> "QuadraticProgram":
         """Substitutes variables with constants or other variables.
 
@@ -1440,18 +1394,14 @@ def from_ising(
                 qubo_matrix[z_index[0], z_index[1]] = coeff.real
             else:
                 raise QiskitOptimizationError(
-                    "There are more than 2 Pauli Zs in the Pauli term {}".format(
-                        pauli.z
-                    )
+                    "There are more than 2 Pauli Zs in the Pauli term {}".format(pauli.z)
                 )
 
             # If there are Pauli Xs in the Pauli term, raise an error
             lst_x = pauli.x.tolist()
             x_index = [i for i, x in enumerate(lst_x) if x is True]
             if len(x_index) > 0:
-                raise QiskitOptimizationError(
-                    "Pauli Xs exist in the Pauli {}".format(pauli.x)
-                )
+                raise QiskitOptimizationError("Pauli Xs exist in the Pauli {}".format(pauli.x))
 
         # Initialize dicts for linear terms and quadratic terms
         linear_terms = {}
@@ -1537,9 +1487,7 @@ def get_feasibility_info(
                 violated_constraints.append(constraint)
             elif constraint.sense == ConstraintSense.GE and lhs < constraint.rhs:
                 violated_constraints.append(constraint)
-            elif constraint.sense == ConstraintSense.EQ and not isclose(
-                lhs, constraint.rhs
-            ):
+            elif constraint.sense == ConstraintSense.EQ and not isclose(lhs, constraint.rhs):
                 violated_constraints.append(constraint)
 
         feasible = not violated_variables and not violated_constraints
@@ -1576,9 +1524,7 @@ def substitute_variables(
         self,
         src: QuadraticProgram,
         constants: Optional[Dict[Union[str, int], float]] = None,
-        variables: Optional[
-            Dict[Union[str, int], Tuple[Union[str, int], float]]
-        ] = None,
+        variables: Optional[Dict[Union[str, int], Tuple[Union[str, int], float]]] = None,
     ) -> QuadraticProgram:
         """Substitutes variables with constants or other variables.
 
@@ -1653,9 +1599,7 @@ def _subs_dict(self, constants, variables):
                 i_2 = self._src.get_variable(i).name
                 if i_2 in subs:
                     raise QiskitOptimizationError(
-                        "Cannot substitute the same variable twice: {} <- {}".format(
-                            i, v
-                        )
+                        "Cannot substitute the same variable twice: {} <- {}".format(i, v)
                     )
                 subs[i_2] = (self.CONST, v)
 
@@ -1670,15 +1614,11 @@ def _subs_dict(self, constants, variables):
                 j_2 = self._src.get_variable(j).name
                 if i_2 == j_2:
                     raise QiskitOptimizationError(
-                        "Cannot substitute the same variable: {} <- {} {}".format(
-                            i, j, v
-                        )
+                        "Cannot substitute the same variable: {} <- {} {}".format(i, j, v)
                     )
                 if i_2 in subs:
                     raise QiskitOptimizationError(
-                        "Cannot substitute the same variable twice: {} <- {} {}".format(
-                            i, j, v
-                        )
+                        "Cannot substitute the same variable twice: {} <- {} {}".format(i, j, v)
                     )
                 if j_2 in subs:
                     raise QiskitOptimizationError(
@@ -1769,9 +1709,7 @@ def _quadratic_expression(
     ) -> Tuple[List[float], Optional[LinearExpression], Optional[QuadraticExpression]]:
         const = []
         lin_dict = defaultdict(float)  # type: Dict[Union[int, str], float]
-        quad_dict = defaultdict(
-            float
-        )  # type: Dict[Tuple[Union[int, str], Union[int, str]], float]
+        quad_dict = defaultdict(float)  # type: Dict[Tuple[Union[int, str], Union[int, str]], float]
         for (i, j), w_ij in quad_expr.to_dict(use_name=True).items():
             repl_i = self._subs[i] if i in self._subs else (i, 1)
             repl_j = self._subs[j] if j in self._subs else (j, 1)
@@ -1799,13 +1737,9 @@ def _objective(self) -> bool:
         constant = fsum([obj.constant] + const1 + const2)
         linear = lin1.coefficients + lin2.coefficients
         if obj.sense == obj.sense.MINIMIZE:
-            self._dst.minimize(
-                constant=constant, linear=linear, quadratic=quadratic.coefficients
-            )
+            self._dst.minimize(constant=constant, linear=linear, quadratic=quadratic.coefficients)
         else:
-            self._dst.maximize(
-                constant=constant, linear=linear, quadratic=quadratic.coefficients
-            )
+            self._dst.maximize(constant=constant, linear=linear, quadratic=quadratic.coefficients)
         return True
 
     def _linear_constraints(self) -> bool:
@@ -1822,9 +1756,7 @@ def _linear_constraints(self) -> bool:
                 )
             else:
                 if not self._feasible(lin_cst.sense, rhs):
-                    logger.warning(
-                        "constraint %s is infeasible due to substitution", lin_cst.name
-                    )
+                    logger.warning("constraint %s is infeasible due to substitution", lin_cst.name)
                     feasible = False
         return feasible
 
@@ -1849,14 +1781,10 @@ def _quadratic_constraints(self) -> bool:
                 lin_names = set(lin.name for lin in self._dst.linear_constraints)
                 while name in lin_names:
                     name = "_" + name
-                self._dst.linear_constraint(
-                    name=name, linear=linear, sense=quad_cst.sense, rhs=rhs
-                )
+                self._dst.linear_constraint(name=name, linear=linear, sense=quad_cst.sense, rhs=rhs)
             else:
                 if not self._feasible(quad_cst.sense, rhs):
-                    logger.warning(
-                        "constraint %s is infeasible due to substitution", quad_cst.name
-                    )
+                    logger.warning("constraint %s is infeasible due to substitution", quad_cst.name)
                     feasible = False
 
         return feasible
diff --git a/test/algorithms/test_admm.py b/test/algorithms/test_admm.py
index 145a52750..774484c55 100644
--- a/test/algorithms/test_admm.py
+++ b/test/algorithms/test_admm.py
@@ -39,9 +39,7 @@ def test_admm_maximization(self):
 
         admm_params = ADMMParameters()
 
-        solver = ADMMOptimizer(
-            params=admm_params, continuous_optimizer=CobylaOptimizer()
-        )
+        solver = ADMMOptimizer(params=admm_params, continuous_optimizer=CobylaOptimizer())
         solution = solver.solve(op)
         self.assertIsNotNone(solution)
         self.assertIsInstance(solution, ADMMOptimizationResult)
diff --git a/test/algorithms/test_grover_optimizer.py b/test/algorithms/test_grover_optimizer.py
index c43d58723..a79476c11 100644
--- a/test/algorithms/test_grover_optimizer.py
+++ b/test/algorithms/test_grover_optimizer.py
@@ -93,9 +93,7 @@ def test_qubo_gas_int_simple(self):
 
         # Get the optimum key and value.
         n_iter = 8
-        gmf = GroverOptimizer(
-            4, num_iterations=n_iter, quantum_instance=self.sv_simulator
-        )
+        gmf = GroverOptimizer(4, num_iterations=n_iter, quantum_instance=self.sv_simulator)
         results = gmf.solve(op)
         self.validate_results(op, results)
 
@@ -116,9 +114,7 @@ def test_qubo_gas_int_simple_maximize(self):
 
         # Get the optimum key and value.
         n_iter = 8
-        gmf = GroverOptimizer(
-            4, num_iterations=n_iter, quantum_instance=self.sv_simulator
-        )
+        gmf = GroverOptimizer(4, num_iterations=n_iter, quantum_instance=self.sv_simulator)
         results = gmf.solve(op)
         self.validate_results(op, results)
 
@@ -210,9 +206,7 @@ def test_samples_and_raw_samples(self):
         self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
         self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1)
         self.assertAlmostEqual(min(s.fval for s in result.samples), 0)
-        self.assertAlmostEqual(
-            min(s.fval for s in result.samples if s.status == success), opt_sol
-        )
+        self.assertAlmostEqual(min(s.fval for s in result.samples if s.status == success), opt_sol)
         self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol)
         for sample in result.raw_samples:
             self.assertEqual(sample.status, success)
diff --git a/test/algorithms/test_min_eigen_optimizer.py b/test/algorithms/test_min_eigen_optimizer.py
index f223a03e5..65bfd591f 100644
--- a/test/algorithms/test_min_eigen_optimizer.py
+++ b/test/algorithms/test_min_eigen_optimizer.py
@@ -149,9 +149,7 @@ def test_converter_list(self):
         min_eigen_solver = NumPyMinimumEigensolver()
         # a single converter
         qp2qubo = QuadraticProgramToQubo()
-        min_eigen_optimizer = MinimumEigenOptimizer(
-            min_eigen_solver, converters=qp2qubo
-        )
+        min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver, converters=qp2qubo)
         result = min_eigen_optimizer.solve(op)
         self.assertEqual(result.fval, 4)
         # a list of converters
@@ -159,9 +157,7 @@ def test_converter_list(self):
         int2bin = IntegerToBinary()
         penalize = LinearEqualityToPenalty()
         converters = [ineq2eq, int2bin, penalize]
-        min_eigen_optimizer = MinimumEigenOptimizer(
-            min_eigen_solver, converters=converters
-        )
+        min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver, converters=converters)
         result = min_eigen_optimizer.solve(op)
         self.assertEqual(result.fval, 4)
         with self.assertRaises(TypeError):
@@ -210,9 +206,7 @@ def test_samples(self):
         self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
         self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1)
         self.assertAlmostEqual(min(s.fval for s in result.samples), 0)
-        self.assertAlmostEqual(
-            min(s.fval for s in result.samples if s.status == SUCCESS), opt_sol
-        )
+        self.assertAlmostEqual(min(s.fval for s in result.samples if s.status == SUCCESS), opt_sol)
         self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol)
         for sample in result.raw_samples:
             self.assertEqual(sample.status, SUCCESS)
@@ -251,9 +245,7 @@ def test_samples(self):
         self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
         self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1)
         self.assertAlmostEqual(max(s.fval for s in result.samples), 5)
-        self.assertAlmostEqual(
-            max(s.fval for s in result.samples if s.status == SUCCESS), opt_sol
-        )
+        self.assertAlmostEqual(max(s.fval for s in result.samples if s.status == SUCCESS), opt_sol)
         self.assertAlmostEqual(max(s.fval for s in result.raw_samples), opt_sol)
         for sample in result.raw_samples:
             self.assertEqual(sample.status, SUCCESS)
diff --git a/test/algorithms/test_recursive_optimization.py b/test/algorithms/test_recursive_optimization.py
index bd1eeb859..40f5ad033 100755
--- a/test/algorithms/test_recursive_optimization.py
+++ b/test/algorithms/test_recursive_optimization.py
@@ -137,9 +137,7 @@ def test_recursive_warm_qaoa(self):
             pre_solver=SlsqpOptimizer(), relax_for_pre_solver=True, qaoa=qaoa
         )
 
-        recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
-            warm_qaoa, min_num_vars=4
-        )
+        recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(warm_qaoa, min_num_vars=4)
 
         # load optimization problem
         problem = QuadraticProgram()
@@ -189,9 +187,7 @@ def test_converter_list(self):
         # invalid converters
         with self.assertRaises(TypeError):
             invalid = [qp2qubo, "invalid converter"]
-            RecursiveMinimumEigenOptimizer(
-                min_eigen_optimizer, min_num_vars=2, converters=invalid
-            )
+            RecursiveMinimumEigenOptimizer(min_eigen_optimizer, min_num_vars=2, converters=invalid)
 
 
 if __name__ == "__main__":
diff --git a/test/applications/test_clique.py b/test/applications/test_clique.py
index 30eb585f7..c219bfcb7 100644
--- a/test/applications/test_clique.py
+++ b/test/applications/test_clique.py
@@ -58,9 +58,7 @@ def test_to_quadratic_program(self):
         obj = op.objective
         self.assertEqual(obj.sense, QuadraticObjective.Sense.MAXIMIZE)
         self.assertEqual(obj.constant, 0)
-        self.assertDictEqual(
-            obj.linear.to_dict(), {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0}
-        )
+        self.assertDictEqual(obj.linear.to_dict(), {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0})
         self.assertDictEqual(obj.quadratic.to_dict(), {})
         # Test constraint
         lin = op.linear_constraints
@@ -80,9 +78,7 @@ def test_interpret(self):
     def test_node_colors(self):
         """Test _node_colors"""
         clique = Clique(self.graph)
-        self.assertEqual(
-            clique._node_colors(self.result), ["r", "darkgrey", "r", "r", "r"]
-        )
+        self.assertEqual(clique._node_colors(self.result), ["r", "darkgrey", "r", "r", "r"])
 
     def test_size(self):
         """Test size"""
@@ -117,9 +113,7 @@ def test_to_quadratic_program_c3(self):
         self.assertEqual(lin[1].linear.to_dict(), {1: 1.0, 4: 1.0})
         self.assertEqual(lin[2].sense, Constraint.Sense.EQ)
         self.assertEqual(lin[2].rhs, 3)
-        self.assertEqual(
-            lin[2].linear.to_dict(), {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0}
-        )
+        self.assertEqual(lin[2].linear.to_dict(), {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0})
 
     def test_interpret_c3(self):
         """Test interpret for the clique size 3"""
diff --git a/test/applications/test_exact_cover.py b/test/applications/test_exact_cover.py
index e3bcba1ba..1c53bf19b 100644
--- a/test/applications/test_exact_cover.py
+++ b/test/applications/test_exact_cover.py
@@ -61,11 +61,7 @@ def test_to_quadratic_program(self):
             self.assertEqual(lin.rhs, 1)
             self.assertEqual(
                 lin.linear.to_dict(),
-                {
-                    j: 1
-                    for j, subset in enumerate(self.list_of_subsets)
-                    if i + 1 in subset
-                },
+                {j: 1 for j, subset in enumerate(self.list_of_subsets) if i + 1 in subset},
             )
 
     def test_interpret(self):
diff --git a/test/applications/test_graph_partition.py b/test/applications/test_graph_partition.py
index 785a14bcb..fb0ef1e60 100644
--- a/test/applications/test_graph_partition.py
+++ b/test/applications/test_graph_partition.py
@@ -71,6 +71,4 @@ def test_interpret(self):
     def test_node_colors(self):
         """Test _node_colors"""
         graph_partitioning = GraphPartition(self.graph)
-        self.assertEqual(
-            graph_partitioning._node_colors(self.result), ["b", "r", "r", "b"]
-        )
+        self.assertEqual(graph_partitioning._node_colors(self.result), ["b", "r", "r", "b"])
diff --git a/test/applications/test_knapsack.py b/test/applications/test_knapsack.py
index 5938dc7c3..c422c8766 100644
--- a/test/applications/test_knapsack.py
+++ b/test/applications/test_knapsack.py
@@ -40,9 +40,7 @@ def setUp(self):
 
     def test_to_quadratic_program(self):
         """Test to_quadratic_program"""
-        knapsack = Knapsack(
-            values=self.values, weights=self.weights, max_weight=self.max_weight
-        )
+        knapsack = Knapsack(values=self.values, weights=self.weights, max_weight=self.max_weight)
         op = knapsack.to_quadratic_program()
         # Test name
         self.assertEqual(op.name, "Knapsack")
@@ -65,15 +63,11 @@ def test_to_quadratic_program(self):
 
     def test_interpret(self):
         """Test interpret"""
-        knapsack = Knapsack(
-            values=self.values, weights=self.weights, max_weight=self.max_weight
-        )
+        knapsack = Knapsack(values=self.values, weights=self.weights, max_weight=self.max_weight)
         self.assertEqual(knapsack.interpret(self.result), [1, 3])
 
     def test_max_weight(self):
         """Test max_weight"""
-        knapsack = Knapsack(
-            values=self.values, weights=self.weights, max_weight=self.max_weight
-        )
+        knapsack = Knapsack(values=self.values, weights=self.weights, max_weight=self.max_weight)
         knapsack.max_weight = 5
         self.assertEqual(knapsack.max_weight, 5)
diff --git a/test/applications/test_set_packing.py b/test/applications/test_set_packing.py
index ab2ca5421..507bcdcbe 100644
--- a/test/applications/test_set_packing.py
+++ b/test/applications/test_set_packing.py
@@ -60,11 +60,7 @@ def test_to_quadratic_program(self):
             self.assertEqual(lin.rhs, 1)
             self.assertEqual(
                 lin.linear.to_dict(),
-                {
-                    j: 1
-                    for j, subset in enumerate(self.list_of_subsets)
-                    if i + 1 in subset
-                },
+                {j: 1 for j, subset in enumerate(self.list_of_subsets) if i + 1 in subset},
             )
 
     def test_interpret(self):
diff --git a/test/applications/test_stable_set.py b/test/applications/test_stable_set.py
index 23d297769..3a6f11c72 100644
--- a/test/applications/test_stable_set.py
+++ b/test/applications/test_stable_set.py
@@ -51,9 +51,7 @@ def test_to_quadratic_program(self):
         obj = op.objective
         self.assertEqual(obj.sense, QuadraticObjective.Sense.MAXIMIZE)
         self.assertEqual(obj.constant, 0)
-        self.assertDictEqual(
-            obj.linear.to_dict(), {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0}
-        )
+        self.assertDictEqual(obj.linear.to_dict(), {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0})
         # Test constraint
         lin = op.linear_constraints
         self.assertEqual(len(lin), len(self.graph.edges))
@@ -70,6 +68,4 @@ def test_interpret(self):
     def test_node_colors(self):
         """Test node_colors"""
         stable_set = StableSet(self.graph)
-        self.assertEqual(
-            stable_set._node_colors(self.result), ["r", "r", "r", "r", "darkgrey"]
-        )
+        self.assertEqual(stable_set._node_colors(self.result), ["r", "r", "r", "r", "darkgrey"])
diff --git a/test/applications/test_tsp.py b/test/applications/test_tsp.py
index 5e378fa67..b8552a321 100644
--- a/test/applications/test_tsp.py
+++ b/test/applications/test_tsp.py
@@ -32,16 +32,11 @@ def setUp(self):
         random.seed(123)
         low = 0
         high = 100
-        pos = {
-            i: (random.randint(low, high), random.randint(low, high)) for i in range(4)
-        }
-        self.graph = nx.random_geometric_graph(
-            4, np.hypot(high - low, high - low) + 1, pos=pos
-        )
+        pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(4)}
+        self.graph = nx.random_geometric_graph(4, np.hypot(high - low, high - low) + 1, pos=pos)
         for w, v in self.graph.edges:
             delta = [
-                self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i]
-                for i in range(2)
+                self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i] for i in range(2)
             ]
             self.graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1]))
 
@@ -71,9 +66,7 @@ def test_to_quadratic_program(self):
         self.assertEqual(obj.constant, 0)
         self.assertDictEqual(obj.linear.to_dict(), {})
         for edge, val in obj.quadratic.to_dict().items():
-            self.assertEqual(
-                val, self.graph.edges[edge[0] // 4, edge[1] // 4]["weight"]
-            )
+            self.assertEqual(val, self.graph.edges[edge[0] // 4, edge[1] // 4]["weight"])
 
         # Test constraint
         lin = op.linear_constraints
@@ -88,9 +81,7 @@ def test_to_quadratic_program(self):
         for i in range(4):
             self.assertEqual(lin[4 + i].sense, Constraint.Sense.EQ)
             self.assertEqual(lin[4 + i].rhs, 1)
-            self.assertEqual(
-                lin[4 + i].linear.to_dict(), {i: 1, 4 + i: 1, 8 + i: 1, 12 + i: 1}
-            )
+            self.assertEqual(lin[4 + i].linear.to_dict(), {i: 1, 4 + i: 1, 8 + i: 1, 12 + i: 1})
 
     def test_interpret(self):
         """Test interpret"""
diff --git a/test/applications/test_vehicle_routing.py b/test/applications/test_vehicle_routing.py
index 05d048ad2..bbdb2006e 100644
--- a/test/applications/test_vehicle_routing.py
+++ b/test/applications/test_vehicle_routing.py
@@ -31,16 +31,11 @@ def setUp(self):
         random.seed(600)
         low = 0
         high = 100
-        pos = {
-            i: (random.randint(low, high), random.randint(low, high)) for i in range(4)
-        }
-        self.graph = nx.random_geometric_graph(
-            4, np.hypot(high - low, high - low) + 1, pos=pos
-        )
+        pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(4)}
+        self.graph = nx.random_geometric_graph(4, np.hypot(high - low, high - low) + 1, pos=pos)
         for w, v in self.graph.edges:
             delta = [
-                self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i]
-                for i in range(2)
+                self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i] for i in range(2)
             ]
             self.graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1]))
         op = QuadraticProgram()
@@ -133,9 +128,7 @@ def test_to_quadratic_program(self):
         self.assertEqual(lin[10].linear.to_dict(), {8: 1.0, 11: 1.0})
         self.assertEqual(lin[11].sense, Constraint.Sense.LE)
         self.assertEqual(lin[11].rhs, 2)
-        self.assertEqual(
-            lin[11].linear.to_dict(), {4: 1, 5: 1, 7: 1, 8: 1, 10: 1, 11: 1}
-        )
+        self.assertEqual(lin[11].linear.to_dict(), {4: 1, 5: 1, 7: 1, 8: 1, 10: 1, 11: 1})
 
     def test_interpret(self):
         """Test interpret"""
@@ -231,9 +224,7 @@ def test_to_quadratic_program_d2(self):
         self.assertEqual(lin[10].linear.to_dict(), {5: 1.0, 10: 1.0})
         self.assertEqual(lin[11].sense, Constraint.Sense.LE)
         self.assertEqual(lin[11].rhs, 2)
-        self.assertEqual(
-            lin[11].linear.to_dict(), {0: 1, 2: 1, 3: 1, 5: 1, 9: 1, 10: 1}
-        )
+        self.assertEqual(lin[11].linear.to_dict(), {0: 1, 2: 1, 3: 1, 5: 1, 9: 1, 10: 1})
 
     def test_interpret_d2(self):
         """Test interpret for depot=2"""
@@ -327,9 +318,7 @@ def test_to_quadratic_program_nv3(self):
         self.assertEqual(lin[10].linear.to_dict(), {8: 1.0, 11: 1.0})
         self.assertEqual(lin[11].sense, Constraint.Sense.LE)
         self.assertEqual(lin[11].rhs, 2)
-        self.assertEqual(
-            lin[11].linear.to_dict(), {4: 1, 5: 1, 7: 1, 8: 1, 10: 1, 11: 1}
-        )
+        self.assertEqual(lin[11].linear.to_dict(), {4: 1, 5: 1, 7: 1, 8: 1, 10: 1, 11: 1})
 
     def test_interpret_nv3(self):
         """Test interpret for num_vehicles=3"""
@@ -362,9 +351,7 @@ def test_create_random_instance(self):
         for node in graph.nodes:
             self.assertEqual(graph.nodes[node]["pos"], self.graph.nodes[node]["pos"])
         for edge in graph.edges:
-            self.assertEqual(
-                graph.edges[edge]["weight"], self.graph.edges[edge]["weight"]
-            )
+            self.assertEqual(graph.edges[edge]["weight"], self.graph.edges[edge]["weight"])
 
     def test_num_vehicles(self):
         """Test num_vehicles"""
diff --git a/test/converters/test_converters.py b/test/converters/test_converters.py
index 32c93dad3..7f93e97e5 100644
--- a/test/converters/test_converters.py
+++ b/test/converters/test_converters.py
@@ -362,12 +362,8 @@ def test_integer_to_binary(self):
         conv = IntegerToBinary()
         op2 = conv.convert(op)
         self.assertEqual(op2.get_num_vars(), 5)
-        self.assertListEqual(
-            [x.vartype for x in op2.variables], [Variable.Type.BINARY] * 5
-        )
-        self.assertListEqual(
-            [x.name for x in op2.variables], ["x0", "x1", "x2@0", "x2@1", "x2@2"]
-        )
+        self.assertListEqual([x.vartype for x in op2.variables], [Variable.Type.BINARY] * 5)
+        self.assertListEqual([x.name for x in op2.variables], ["x0", "x1", "x2@0", "x2@1", "x2@2"])
         dct = op2.objective.linear.to_dict()
         self.assertEqual(dct[2], 3)
         self.assertEqual(dct[3], 6)
@@ -504,9 +500,7 @@ def test_auto_penalty(self):
         op.binary_var("y")
         op.binary_var("z")
         op.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2})
-        op.linear_constraint(
-            linear={"x": 1, "y": 1, "z": 1}, sense="EQ", rhs=2, name="xyz_eq"
-        )
+        op.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="EQ", rhs=2, name="xyz_eq")
         lineq2penalty = LinearEqualityToPenalty(penalty=1e5)
         lineq2penalty_auto = LinearEqualityToPenalty()
         qubo = lineq2penalty.convert(op)
@@ -525,9 +519,7 @@ def test_auto_penalty_warning(self):
         op.binary_var("y")
         op.binary_var("z")
         op.minimize(linear={"x": 1, "y": 2})
-        op.linear_constraint(
-            linear={"x": 0.5, "y": 0.5, "z": 0.5}, sense="EQ", rhs=1, name="xyz"
-        )
+        op.linear_constraint(linear={"x": 0.5, "y": 0.5, "z": 0.5}, sense="EQ", rhs=1, name="xyz")
         with self.assertLogs("qiskit_optimization", level="WARNING") as log:
             lineq2penalty = LinearEqualityToPenalty()
             _ = lineq2penalty.convert(op)
@@ -546,9 +538,7 @@ def test_penalty_recalculation_when_reusing(self):
         op.binary_var("y")
         op.binary_var("z")
         op.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2})
-        op.linear_constraint(
-            linear={"x": 1, "y": 1, "z": 1}, sense="EQ", rhs=2, name="xyz_eq"
-        )
+        op.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="EQ", rhs=2, name="xyz_eq")
         # First, create a converter with no penalty
         lineq2penalty = LinearEqualityToPenalty()
         self.assertIsNone(lineq2penalty.penalty)
@@ -571,9 +561,7 @@ def test_linear_equality_to_penalty_decode(self):
         qprog.binary_var("y")
         qprog.binary_var("z")
         qprog.maximize(linear={"x": 3, "y": 1, "z": 1})
-        qprog.linear_constraint(
-            linear={"x": 1, "y": 1, "z": 1}, sense="EQ", rhs=2, name="xyz_eq"
-        )
+        qprog.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="EQ", rhs=2, name="xyz_eq")
         lineq2penalty = LinearEqualityToPenalty()
         qubo = lineq2penalty.convert(qprog)
         exact_mes = NumPyMinimumEigensolver()
@@ -592,26 +580,16 @@ def test_0var_range_inequality(self):
         op.binary_var("y")
         op.linear_constraint(linear={"x": 1, "y": 1}, sense="LE", rhs=0, name="xy_leq1")
         op.linear_constraint(linear={"x": 1, "y": 1}, sense="GE", rhs=2, name="xy_geq1")
-        op.quadratic_constraint(
-            quadratic={("x", "x"): 1}, sense="LE", rhs=0, name="xy_leq2"
-        )
-        op.quadratic_constraint(
-            quadratic={("x", "y"): 1}, sense="GE", rhs=1, name="xy_geq2"
-        )
+        op.quadratic_constraint(quadratic={("x", "x"): 1}, sense="LE", rhs=0, name="xy_leq2")
+        op.quadratic_constraint(quadratic={("x", "y"): 1}, sense="GE", rhs=1, name="xy_geq2")
         ineq2eq = InequalityToEquality()
         new_op = ineq2eq.convert(op)
         self.assertEqual(new_op.get_num_vars(), 2)
         self.assertTrue(
-            all(
-                l_const.sense == Constraint.Sense.EQ
-                for l_const in new_op.linear_constraints
-            )
+            all(l_const.sense == Constraint.Sense.EQ for l_const in new_op.linear_constraints)
         )
         self.assertTrue(
-            all(
-                q_const.sense == Constraint.Sense.EQ
-                for q_const in new_op.quadratic_constraints
-            )
+            all(q_const.sense == Constraint.Sense.EQ for q_const in new_op.quadratic_constraints)
         )
 
     def test_integer_to_binary2(self):
@@ -626,20 +604,12 @@ def test_integer_to_binary2(self):
         self.assertListEqual(
             [e.name + "@0" for e in mod.variables], [e.name for e in mod2.variables]
         )
-        self.assertDictEqual(
-            mod.objective.linear.to_dict(), mod2.objective.linear.to_dict()
-        )
-        self.assertDictEqual(
-            mod.objective.quadratic.to_dict(), mod2.objective.quadratic.to_dict()
-        )
-        self.assertEqual(
-            mod.get_num_linear_constraints(), mod2.get_num_linear_constraints()
-        )
+        self.assertDictEqual(mod.objective.linear.to_dict(), mod2.objective.linear.to_dict())
+        self.assertDictEqual(mod.objective.quadratic.to_dict(), mod2.objective.quadratic.to_dict())
+        self.assertEqual(mod.get_num_linear_constraints(), mod2.get_num_linear_constraints())
         for cst, cst2 in zip(mod.linear_constraints, mod2.linear_constraints):
             self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict())
-        self.assertEqual(
-            mod.get_num_quadratic_constraints(), mod2.get_num_quadratic_constraints()
-        )
+        self.assertEqual(mod.get_num_quadratic_constraints(), mod2.get_num_quadratic_constraints())
         for cst, cst2 in zip(mod.quadratic_constraints, mod2.quadratic_constraints):
             self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict())
             self.assertDictEqual(cst.quadratic.to_dict(), cst2.quadratic.to_dict())
diff --git a/test/optimization_test_case.py b/test/optimization_test_case.py
index f54e37e29..32be73ff0 100755
--- a/test/optimization_test_case.py
+++ b/test/optimization_test_case.py
@@ -77,9 +77,8 @@ def setUpClass(cls) -> None:
         # is set.
         if os.getenv("LOG_LEVEL"):
             # Set up formatter.
-            log_fmt = (
-                "{}.%(funcName)s:%(levelname)s:%(asctime)s:"
-                " %(message)s".format(cls.__name__)
+            log_fmt = "{}.%(funcName)s:%(levelname)s:%(asctime)s:" " %(message)s".format(
+                cls.__name__
             )
             formatter = logging.Formatter(log_fmt)
 
diff --git a/test/problems/test_linear_constraint.py b/test/problems/test_linear_constraint.py
index 70cb8266b..07eb15218 100644
--- a/test/problems/test_linear_constraint.py
+++ b/test/problems/test_linear_constraint.py
@@ -38,12 +38,8 @@ def test_init(self):
         quadratic_program.linear_constraint(sense="==")
         self.assertEqual(quadratic_program.get_num_linear_constraints(), 1)
         self.assertEqual(quadratic_program.linear_constraints[0].name, "c0")
-        self.assertEqual(
-            len(quadratic_program.linear_constraints[0].linear.to_dict()), 0
-        )
-        self.assertEqual(
-            quadratic_program.linear_constraints[0].sense, Constraint.Sense.EQ
-        )
+        self.assertEqual(len(quadratic_program.linear_constraints[0].linear.to_dict()), 0)
+        self.assertEqual(quadratic_program.linear_constraints[0].sense, Constraint.Sense.EQ)
         self.assertEqual(quadratic_program.linear_constraints[0].rhs, 0.0)
         self.assertEqual(
             quadratic_program.linear_constraints[0],
@@ -61,14 +57,9 @@ def test_init(self):
         self.assertEqual(quadratic_program.get_num_linear_constraints(), 2)
         self.assertEqual(quadratic_program.linear_constraints[1].name, "c1")
         self.assertTrue(
-            (
-                quadratic_program.linear_constraints[1].linear.to_array()
-                == coefficients
-            ).all()
-        )
-        self.assertEqual(
-            quadratic_program.linear_constraints[1].sense, Constraint.Sense.EQ
+            (quadratic_program.linear_constraints[1].linear.to_array() == coefficients).all()
         )
+        self.assertEqual(quadratic_program.linear_constraints[1].sense, Constraint.Sense.EQ)
         self.assertEqual(quadratic_program.linear_constraints[1].rhs, 1.0)
         self.assertEqual(
             quadratic_program.linear_constraints[1],
@@ -83,12 +74,8 @@ def test_init(self):
         quadratic_program.linear_constraint(sense=">=")
         self.assertEqual(quadratic_program.get_num_linear_constraints(), 3)
         self.assertEqual(quadratic_program.linear_constraints[2].name, "c2")
-        self.assertEqual(
-            len(quadratic_program.linear_constraints[2].linear.to_dict()), 0
-        )
-        self.assertEqual(
-            quadratic_program.linear_constraints[2].sense, Constraint.Sense.GE
-        )
+        self.assertEqual(len(quadratic_program.linear_constraints[2].linear.to_dict()), 0)
+        self.assertEqual(quadratic_program.linear_constraints[2].sense, Constraint.Sense.GE)
         self.assertEqual(quadratic_program.linear_constraints[2].rhs, 0.0)
         self.assertEqual(
             quadratic_program.linear_constraints[2],
@@ -106,14 +93,9 @@ def test_init(self):
         self.assertEqual(quadratic_program.get_num_linear_constraints(), 4)
         self.assertEqual(quadratic_program.linear_constraints[3].name, "c3")
         self.assertTrue(
-            (
-                quadratic_program.linear_constraints[3].linear.to_array()
-                == coefficients
-            ).all()
-        )
-        self.assertEqual(
-            quadratic_program.linear_constraints[3].sense, Constraint.Sense.GE
+            (quadratic_program.linear_constraints[3].linear.to_array() == coefficients).all()
         )
+        self.assertEqual(quadratic_program.linear_constraints[3].sense, Constraint.Sense.GE)
         self.assertEqual(quadratic_program.linear_constraints[3].rhs, 1.0)
         self.assertEqual(
             quadratic_program.linear_constraints[3],
@@ -128,12 +110,8 @@ def test_init(self):
         quadratic_program.linear_constraint(sense="<=")
         self.assertEqual(quadratic_program.get_num_linear_constraints(), 5)
         self.assertEqual(quadratic_program.linear_constraints[4].name, "c4")
-        self.assertEqual(
-            len(quadratic_program.linear_constraints[4].linear.to_dict()), 0
-        )
-        self.assertEqual(
-            quadratic_program.linear_constraints[4].sense, Constraint.Sense.LE
-        )
+        self.assertEqual(len(quadratic_program.linear_constraints[4].linear.to_dict()), 0)
+        self.assertEqual(quadratic_program.linear_constraints[4].sense, Constraint.Sense.LE)
         self.assertEqual(quadratic_program.linear_constraints[4].rhs, 0.0)
         self.assertEqual(
             quadratic_program.linear_constraints[4],
@@ -151,14 +129,9 @@ def test_init(self):
         self.assertEqual(quadratic_program.get_num_linear_constraints(), 6)
         self.assertEqual(quadratic_program.linear_constraints[5].name, "c5")
         self.assertTrue(
-            (
-                quadratic_program.linear_constraints[5].linear.to_array()
-                == coefficients
-            ).all()
-        )
-        self.assertEqual(
-            quadratic_program.linear_constraints[5].sense, Constraint.Sense.LE
+            (quadratic_program.linear_constraints[5].linear.to_array() == coefficients).all()
         )
+        self.assertEqual(quadratic_program.linear_constraints[5].sense, Constraint.Sense.LE)
         self.assertEqual(quadratic_program.linear_constraints[5].rhs, 1.0)
         self.assertEqual(
             quadratic_program.linear_constraints[5],
diff --git a/test/problems/test_linear_expression.py b/test/problems/test_linear_expression.py
index f9d0535be..a11d24b77 100644
--- a/test/problems/test_linear_expression.py
+++ b/test/problems/test_linear_expression.py
@@ -124,9 +124,7 @@ def test_evaluate_gradient(self):
         values_dict_str = {"x{}".format(i): i for i in range(len(x))}
 
         for values in [values_list, values_array, values_dict_int, values_dict_str]:
-            np.testing.assert_almost_equal(
-                linear.evaluate_gradient(values), coefficients_list
-            )
+            np.testing.assert_almost_equal(linear.evaluate_gradient(values), coefficients_list)
 
 
 if __name__ == "__main__":
diff --git a/test/problems/test_quadratic_constraint.py b/test/problems/test_quadratic_constraint.py
index 5c4d9b7bf..6a783123c 100644
--- a/test/problems/test_quadratic_constraint.py
+++ b/test/problems/test_quadratic_constraint.py
@@ -43,15 +43,9 @@ def test_init(self):
         quadratic_program.quadratic_constraint(sense="==")
         self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 1)
         self.assertEqual(quadratic_program.quadratic_constraints[0].name, "q0")
-        self.assertEqual(
-            len(quadratic_program.quadratic_constraints[0].linear.to_dict()), 0
-        )
-        self.assertEqual(
-            len(quadratic_program.quadratic_constraints[0].quadratic.to_dict()), 0
-        )
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[0].sense, Constraint.Sense.EQ
-        )
+        self.assertEqual(len(quadratic_program.quadratic_constraints[0].linear.to_dict()), 0)
+        self.assertEqual(len(quadratic_program.quadratic_constraints[0].quadratic.to_dict()), 0)
+        self.assertEqual(quadratic_program.quadratic_constraints[0].sense, Constraint.Sense.EQ)
         self.assertEqual(quadratic_program.quadratic_constraints[0].rhs, 0.0)
         self.assertEqual(
             quadratic_program.quadratic_constraints[0],
@@ -62,33 +56,23 @@ def test_init(self):
             quadratic_program.get_quadratic_constraint(0),
         )
 
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[0].evaluate(linear_coeffs), 0.0
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[0].evaluate(linear_coeffs), 0.0)
 
         with self.assertRaises(QiskitOptimizationError):
             quadratic_program.quadratic_constraint(name="q0", sense="==")
 
-        quadratic_program.quadratic_constraint(
-            linear_coeffs, quadratic_coeffs, "==", 1.0, "q1"
-        )
+        quadratic_program.quadratic_constraint(linear_coeffs, quadratic_coeffs, "==", 1.0, "q1")
         self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 2)
         self.assertEqual(quadratic_program.quadratic_constraints[1].name, "q1")
         self.assertTrue(
-            (
-                quadratic_program.quadratic_constraints[1].linear.to_array()
-                == linear_coeffs
-            ).all()
+            (quadratic_program.quadratic_constraints[1].linear.to_array() == linear_coeffs).all()
         )
         self.assertTrue(
             (
-                quadratic_program.quadratic_constraints[1].quadratic.to_array()
-                == quadratic_coeffs
+                quadratic_program.quadratic_constraints[1].quadratic.to_array() == quadratic_coeffs
             ).all()
         )
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[1].sense, Constraint.Sense.EQ
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[1].sense, Constraint.Sense.EQ)
         self.assertEqual(quadratic_program.quadratic_constraints[1].rhs, 1.0)
         self.assertEqual(
             quadratic_program.quadratic_constraints[1],
@@ -99,23 +83,15 @@ def test_init(self):
             quadratic_program.get_quadratic_constraint(1),
         )
 
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[1].evaluate(linear_coeffs), 930.0
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[1].evaluate(linear_coeffs), 930.0)
 
         # geq constraints
         quadratic_program.quadratic_constraint(sense=">=")
         self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 3)
         self.assertEqual(quadratic_program.quadratic_constraints[2].name, "q2")
-        self.assertEqual(
-            len(quadratic_program.quadratic_constraints[2].linear.to_dict()), 0
-        )
-        self.assertEqual(
-            len(quadratic_program.quadratic_constraints[2].quadratic.to_dict()), 0
-        )
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[2].sense, Constraint.Sense.GE
-        )
+        self.assertEqual(len(quadratic_program.quadratic_constraints[2].linear.to_dict()), 0)
+        self.assertEqual(len(quadratic_program.quadratic_constraints[2].quadratic.to_dict()), 0)
+        self.assertEqual(quadratic_program.quadratic_constraints[2].sense, Constraint.Sense.GE)
         self.assertEqual(quadratic_program.quadratic_constraints[2].rhs, 0.0)
         self.assertEqual(
             quadratic_program.quadratic_constraints[2],
@@ -126,33 +102,23 @@ def test_init(self):
             quadratic_program.get_quadratic_constraint(2),
         )
 
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[2].evaluate(linear_coeffs), 0.0
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[2].evaluate(linear_coeffs), 0.0)
 
         with self.assertRaises(QiskitOptimizationError):
             quadratic_program.quadratic_constraint(name="q2", sense=">=")
 
-        quadratic_program.quadratic_constraint(
-            linear_coeffs, quadratic_coeffs, ">=", 1.0, "q3"
-        )
+        quadratic_program.quadratic_constraint(linear_coeffs, quadratic_coeffs, ">=", 1.0, "q3")
         self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 4)
         self.assertEqual(quadratic_program.quadratic_constraints[3].name, "q3")
         self.assertTrue(
-            (
-                quadratic_program.quadratic_constraints[3].linear.to_array()
-                == linear_coeffs
-            ).all()
+            (quadratic_program.quadratic_constraints[3].linear.to_array() == linear_coeffs).all()
         )
         self.assertTrue(
             (
-                quadratic_program.quadratic_constraints[3].quadratic.to_array()
-                == quadratic_coeffs
+                quadratic_program.quadratic_constraints[3].quadratic.to_array() == quadratic_coeffs
             ).all()
         )
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[3].sense, Constraint.Sense.GE
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[3].sense, Constraint.Sense.GE)
         self.assertEqual(quadratic_program.quadratic_constraints[3].rhs, 1.0)
         self.assertEqual(
             quadratic_program.quadratic_constraints[3],
@@ -163,20 +129,14 @@ def test_init(self):
             quadratic_program.get_quadratic_constraint(3),
         )
 
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[3].evaluate(linear_coeffs), 930.0
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[3].evaluate(linear_coeffs), 930.0)
 
         # leq constraints
         quadratic_program.quadratic_constraint(sense="<=")
         self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 5)
         self.assertEqual(quadratic_program.quadratic_constraints[4].name, "q4")
-        self.assertEqual(
-            len(quadratic_program.quadratic_constraints[4].linear.to_dict()), 0
-        )
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[4].sense, Constraint.Sense.LE
-        )
+        self.assertEqual(len(quadratic_program.quadratic_constraints[4].linear.to_dict()), 0)
+        self.assertEqual(quadratic_program.quadratic_constraints[4].sense, Constraint.Sense.LE)
         self.assertEqual(quadratic_program.quadratic_constraints[4].rhs, 0.0)
         self.assertEqual(
             quadratic_program.quadratic_constraints[4],
@@ -187,33 +147,23 @@ def test_init(self):
             quadratic_program.get_quadratic_constraint(4),
         )
 
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[4].evaluate(linear_coeffs), 0.0
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[4].evaluate(linear_coeffs), 0.0)
 
         with self.assertRaises(QiskitOptimizationError):
             quadratic_program.quadratic_constraint(name="q4", sense="<=")
 
-        quadratic_program.quadratic_constraint(
-            linear_coeffs, quadratic_coeffs, "<=", 1.0, "q5"
-        )
+        quadratic_program.quadratic_constraint(linear_coeffs, quadratic_coeffs, "<=", 1.0, "q5")
         self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 6)
         self.assertEqual(quadratic_program.quadratic_constraints[5].name, "q5")
         self.assertTrue(
-            (
-                quadratic_program.quadratic_constraints[5].linear.to_array()
-                == linear_coeffs
-            ).all()
+            (quadratic_program.quadratic_constraints[5].linear.to_array() == linear_coeffs).all()
         )
         self.assertTrue(
             (
-                quadratic_program.quadratic_constraints[5].quadratic.to_array()
-                == quadratic_coeffs
+                quadratic_program.quadratic_constraints[5].quadratic.to_array() == quadratic_coeffs
             ).all()
         )
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[5].sense, Constraint.Sense.LE
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[5].sense, Constraint.Sense.LE)
         self.assertEqual(quadratic_program.quadratic_constraints[5].rhs, 1.0)
         self.assertEqual(
             quadratic_program.quadratic_constraints[5],
@@ -224,9 +174,7 @@ def test_init(self):
             quadratic_program.get_quadratic_constraint(5),
         )
 
-        self.assertEqual(
-            quadratic_program.quadratic_constraints[5].evaluate(linear_coeffs), 930.0
-        )
+        self.assertEqual(quadratic_program.quadratic_constraints[5].evaluate(linear_coeffs), 930.0)
 
 
 if __name__ == "__main__":
diff --git a/test/problems/test_quadratic_expression.py b/test/problems/test_quadratic_expression.py
index e11f22f88..830eb903b 100644
--- a/test/problems/test_quadratic_expression.py
+++ b/test/problems/test_quadratic_expression.py
@@ -40,8 +40,7 @@ def test_init(self):
         coefficients_dok = dok_matrix(coefficients_list)
         coefficients_dict_int = {(i, j): v for (i, j), v in coefficients_dok.items()}
         coefficients_dict_str = {
-            ("x{}".format(i), "x{}".format(j)): v
-            for (i, j), v in coefficients_dok.items()
+            ("x{}".format(i), "x{}".format(j)): v for (i, j), v in coefficients_dok.items()
         }
 
         for coeffs in [
@@ -54,12 +53,8 @@ def test_init(self):
             quadratic = QuadraticExpression(quadratic_program, coeffs)
             self.assertEqual((quadratic.coefficients != coefficients_dok).nnz, 0)
             self.assertTrue((quadratic.to_array() == coefficients_list).all())
-            self.assertDictEqual(
-                quadratic.to_dict(use_name=False), coefficients_dict_int
-            )
-            self.assertDictEqual(
-                quadratic.to_dict(use_name=True), coefficients_dict_str
-            )
+            self.assertDictEqual(quadratic.to_dict(use_name=False), coefficients_dict_int)
+            self.assertDictEqual(quadratic.to_dict(use_name=True), coefficients_dict_str)
 
     def test_get_item(self):
         """test get_item."""
@@ -78,9 +73,7 @@ def test_get_item(self):
                 if i == j:
                     self.assertEqual(quadratic[i, j], coefficients[i][j])
                 else:
-                    self.assertEqual(
-                        quadratic[i, j], coefficients[i][j] + coefficients[j][i]
-                    )
+                    self.assertEqual(quadratic[i, j], coefficients[i][j] + coefficients[j][i])
 
     def test_setters(self):
         """test setters."""
@@ -101,8 +94,7 @@ def test_setters(self):
         coefficients_dok = dok_matrix(coefficients_list)
         coefficients_dict_int = {(i, j): v for (i, j), v in coefficients_dok.items()}
         coefficients_dict_str = {
-            ("x{}".format(i), "x{}".format(j)): v
-            for (i, j), v in coefficients_dok.items()
+            ("x{}".format(i), "x{}".format(j)): v for (i, j), v in coefficients_dok.items()
         }
 
         for coeffs in [
@@ -115,12 +107,8 @@ def test_setters(self):
             quadratic.coefficients = coeffs
             self.assertEqual((quadratic.coefficients != coefficients_dok).nnz, 0)
             self.assertTrue((quadratic.to_array() == coefficients_list).all())
-            self.assertDictEqual(
-                quadratic.to_dict(use_name=False), coefficients_dict_int
-            )
-            self.assertDictEqual(
-                quadratic.to_dict(use_name=True), coefficients_dict_str
-            )
+            self.assertDictEqual(quadratic.to_dict(use_name=False), coefficients_dict_int)
+            self.assertDictEqual(quadratic.to_dict(use_name=True), coefficients_dict_str)
 
     def test_evaluate(self):
         """test evaluate."""
@@ -161,9 +149,7 @@ def test_evaluate_gradient(self):
 
         grad_values = [0.0, 60.0, 120.0, 180.0, 240.0]
         for values in [values_list, values_array, values_dict_int, values_dict_str]:
-            np.testing.assert_almost_equal(
-                quadratic.evaluate_gradient(values), grad_values
-            )
+            np.testing.assert_almost_equal(quadratic.evaluate_gradient(values), grad_values)
 
     def test_symmetric_set(self):
         """test symmetric set"""
@@ -172,9 +158,7 @@ def test_symmetric_set(self):
         q_p.binary_var("y")
         q_p.binary_var("z")
         quad = QuadraticExpression(q_p, {("x", "y"): -1, ("y", "x"): 2, ("z", "x"): 3})
-        self.assertDictEqual(
-            quad.to_dict(use_name=True), {("x", "y"): 1, ("x", "z"): 3}
-        )
+        self.assertDictEqual(quad.to_dict(use_name=True), {("x", "y"): 1, ("x", "z"): 3})
         self.assertDictEqual(
             quad.to_dict(symmetric=True, use_name=True),
             {("x", "y"): 0.5, ("y", "x"): 0.5, ("x", "z"): 1.5, ("z", "x"): 1.5},
diff --git a/test/problems/test_quadratic_objective.py b/test/problems/test_quadratic_objective.py
index 377797b1a..86da07e15 100644
--- a/test/problems/test_quadratic_objective.py
+++ b/test/problems/test_quadratic_objective.py
@@ -33,9 +33,7 @@ def test_init(self):
         self.assertEqual(quadratic_program.objective.constant, 0.0)
         self.assertEqual(len(quadratic_program.objective.linear.to_dict()), 0)
         self.assertEqual(len(quadratic_program.objective.quadratic.to_dict()), 0)
-        self.assertEqual(
-            quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE
-        )
+        self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE)
 
         constant = 1.0
         linear_coeffs = np.array(range(5))
@@ -48,28 +46,20 @@ def test_init(self):
         quadratic_program.minimize(constant, linear_coeffs, quadratic_coeffs)
 
         self.assertEqual(quadratic_program.objective.constant, constant)
-        self.assertTrue(
-            (quadratic_program.objective.linear.to_array() == linear_coeffs).all()
-        )
+        self.assertTrue((quadratic_program.objective.linear.to_array() == linear_coeffs).all())
         self.assertTrue(
             (quadratic_program.objective.quadratic.to_array() == quadratic_coeffs).all()
         )
-        self.assertEqual(
-            quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE
-        )
+        self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE)
 
         quadratic_program.maximize(constant, linear_coeffs, quadratic_coeffs)
 
         self.assertEqual(quadratic_program.objective.constant, constant)
-        self.assertTrue(
-            (quadratic_program.objective.linear.to_array() == linear_coeffs).all()
-        )
+        self.assertTrue((quadratic_program.objective.linear.to_array() == linear_coeffs).all())
         self.assertTrue(
             (quadratic_program.objective.quadratic.to_array() == quadratic_coeffs).all()
         )
-        self.assertEqual(
-            quadratic_program.objective.sense, QuadraticObjective.Sense.MAXIMIZE
-        )
+        self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MAXIMIZE)
 
         self.assertEqual(quadratic_program.objective.evaluate(linear_coeffs), 931.0)
 
@@ -98,26 +88,18 @@ def test_setters(self):
         quadratic_program.objective.quadratic = quadratic_coeffs
 
         self.assertEqual(quadratic_program.objective.constant, constant)
-        self.assertTrue(
-            (quadratic_program.objective.linear.to_array() == linear_coeffs).all()
-        )
+        self.assertTrue((quadratic_program.objective.linear.to_array() == linear_coeffs).all())
         self.assertTrue(
             (quadratic_program.objective.quadratic.to_array() == quadratic_coeffs).all()
         )
 
-        self.assertEqual(
-            quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE
-        )
+        self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE)
 
         quadratic_program.objective.sense = quadratic_program.objective.Sense.MAXIMIZE
-        self.assertEqual(
-            quadratic_program.objective.sense, QuadraticObjective.Sense.MAXIMIZE
-        )
+        self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MAXIMIZE)
 
         quadratic_program.objective.sense = quadratic_program.objective.Sense.MINIMIZE
-        self.assertEqual(
-            quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE
-        )
+        self.assertEqual(quadratic_program.objective.sense, QuadraticObjective.Sense.MINIMIZE)
 
 
 if __name__ == "__main__":
diff --git a/test/problems/test_quadratic_program.py b/test/problems/test_quadratic_program.py
index 18d19eff0..6119c1d1e 100644
--- a/test/problems/test_quadratic_program.py
+++ b/test/problems/test_quadratic_program.py
@@ -105,9 +105,7 @@ def test_var_dict(self):
             self.assertEqual(var.vartype, VarType.BINARY)
             self.assertTupleEqual(var.as_tuple(), d_1[var.name].as_tuple())
 
-        d_2 = q_p.integer_var_dict(
-            keys=1, key_format="-{}", lowerbound=-4, upperbound=10
-        )
+        d_2 = q_p.integer_var_dict(keys=1, key_format="-{}", lowerbound=-4, upperbound=10)
         self.assertSetEqual(set(d_2.keys()), {"x-8"})
         self.assertSetEqual(
             {var.name for var in q_p.variables},
@@ -259,9 +257,7 @@ def test_var_list(self):
             self.assertEqual(var.vartype, VarType.BINARY)
             self.assertTupleEqual(var.as_tuple(), d_1[i].as_tuple())
 
-        d_2 = q_p.integer_var_list(
-            keys=1, key_format="-{}", lowerbound=-4, upperbound=10
-        )
+        d_2 = q_p.integer_var_list(keys=1, key_format="-{}", lowerbound=-4, upperbound=10)
         names = ["x-8"]
         self.assertSetEqual(
             {var.name for var in q_p.variables},
@@ -480,9 +476,7 @@ def test_variables_handling(self):
             z = quadratic_program.get_variable(x.name)
             self.assertEqual(x.name, y.name)
             self.assertEqual(x.name, z.name)
-        self.assertDictEqual(
-            quadratic_program.variables_index, {"x" + str(i): i for i in range(6)}
-        )
+        self.assertDictEqual(quadratic_program.variables_index, {"x" + str(i): i for i in range(6)})
 
     def test_linear_constraints_handling(self):
         """test linear constraints handling"""
@@ -590,9 +584,7 @@ def test_quadratic_constraints_handling(self):
         self.assertDictEqual(quad[0].linear.to_dict(use_name=True), {"x": 1})
         self.assertListEqual(quad[0].linear.to_array().tolist(), [1, 0, 0])
         self.assertDictEqual(quad[0].quadratic.to_dict(), {(0, 1): 1})
-        self.assertDictEqual(
-            quad[0].quadratic.to_dict(symmetric=True), {(0, 1): 0.5, (1, 0): 0.5}
-        )
+        self.assertDictEqual(quad[0].quadratic.to_dict(symmetric=True), {(0, 1): 0.5, (1, 0): 0.5})
         self.assertDictEqual(quad[0].quadratic.to_dict(use_name=True), {("x", "y"): 1})
         self.assertDictEqual(
             quad[0].quadratic.to_dict(use_name=True, symmetric=True),
@@ -615,9 +607,7 @@ def test_quadratic_constraints_handling(self):
         self.assertDictEqual(quad[1].linear.to_dict(use_name=True), {"y": 1})
         self.assertListEqual(quad[1].linear.to_array().tolist(), [0, 1, 0])
         self.assertDictEqual(quad[1].quadratic.to_dict(), {(1, 2): 1})
-        self.assertDictEqual(
-            quad[1].quadratic.to_dict(symmetric=True), {(1, 2): 0.5, (2, 1): 0.5}
-        )
+        self.assertDictEqual(quad[1].quadratic.to_dict(symmetric=True), {(1, 2): 0.5, (2, 1): 0.5})
         self.assertDictEqual(quad[1].quadratic.to_dict(use_name=True), {("y", "z"): 1})
         self.assertDictEqual(
             quad[1].quadratic.to_dict(use_name=True, symmetric=True),
@@ -640,9 +630,7 @@ def test_quadratic_constraints_handling(self):
         self.assertDictEqual(quad[2].linear.to_dict(use_name=True), {"z": 1})
         self.assertListEqual(quad[2].linear.to_array().tolist(), [0, 0, 1])
         self.assertDictEqual(quad[2].quadratic.to_dict(), {(0, 2): 1})
-        self.assertDictEqual(
-            quad[2].quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5}
-        )
+        self.assertDictEqual(quad[2].quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5})
         self.assertDictEqual(quad[2].quadratic.to_dict(use_name=True), {("x", "z"): 1})
         self.assertDictEqual(
             quad[2].quadratic.to_dict(use_name=True, symmetric=True),
@@ -679,9 +667,7 @@ def test_quadratic_constraints_handling(self):
         self.assertDictEqual(quad[1].linear.to_dict(use_name=True), {"z": 1})
         self.assertListEqual(quad[1].linear.to_array().tolist(), [0, 0, 1])
         self.assertDictEqual(quad[1].quadratic.to_dict(), {(0, 2): 1})
-        self.assertDictEqual(
-            quad[1].quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5}
-        )
+        self.assertDictEqual(quad[1].quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5})
         self.assertDictEqual(quad[1].quadratic.to_dict(use_name=True), {("x", "z"): 1})
         self.assertDictEqual(
             quad[1].quadratic.to_dict(use_name=True, symmetric=True),
@@ -728,16 +714,12 @@ def test_objective_handling(self):
         self.assertDictEqual(
             obj.quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5, (1, 1): 1}
         )
-        self.assertDictEqual(
-            obj.quadratic.to_dict(use_name=True), {("x", "z"): 1, ("y", "y"): 1}
-        )
+        self.assertDictEqual(obj.quadratic.to_dict(use_name=True), {("x", "z"): 1, ("y", "y"): 1})
         self.assertDictEqual(
             obj.quadratic.to_dict(use_name=True, symmetric=True),
             {("x", "z"): 0.5, ("z", "x"): 0.5, ("y", "y"): 1},
         )
-        self.assertListEqual(
-            obj.quadratic.to_array().tolist(), [[0, 0, 1], [0, 1, 0], [0, 0, 0]]
-        )
+        self.assertListEqual(obj.quadratic.to_array().tolist(), [[0, 0, 1], [0, 1, 0], [0, 0, 0]])
         self.assertListEqual(
             obj.quadratic.to_array(symmetric=True).tolist(),
             [[0, 0, 0.5], [0, 1, 0], [0.5, 0, 0]],
@@ -752,9 +734,7 @@ def test_read_from_lp_file(self):
                 q_p.read_from_lp_file("")
             with self.assertRaises(FileNotFoundError):
                 q_p.read_from_lp_file("no_file.txt")
-            lp_file = self.get_resource_path(
-                "test_quadratic_program.lp", "problems/resources"
-            )
+            lp_file = self.get_resource_path("test_quadratic_program.lp", "problems/resources")
             q_p.read_from_lp_file(lp_file)
             self.assertEqual(q_p.name, "my problem")
             self.assertEqual(q_p.get_num_vars(), 3)
@@ -962,9 +942,7 @@ def test_docplex(self):
         self.assertListEqual(var_names, ["x0", "x1", "x2"])
         senses = [Constraint.Sense.EQ, Constraint.Sense.GE, Constraint.Sense.LE]
         for i, c in enumerate(q_p.linear_constraints):
-            self.assertDictEqual(
-                c.linear.to_dict(use_name=True), {"x0": 1, "x1": 1, "x2": -1}
-            )
+            self.assertDictEqual(c.linear.to_dict(use_name=True), {"x0": 1, "x1": 1, "x2": -1})
             self.assertEqual(c.rhs, 0)
             self.assertEqual(c.sense, senses[i])
         for i, c in enumerate(q_p.quadratic_constraints):
@@ -999,9 +977,7 @@ def test_substitute_variables(self):
         q_p2 = q_p.substitute_variables(constants={"x": 0})
         self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
         self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), {"y": 2})
-        self.assertDictEqual(
-            q_p2.objective.quadratic.to_dict(use_name=True), {("z", "z"): 2}
-        )
+        self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True), {("z", "z"): 2})
         self.assertEqual(q_p2.objective.constant, 1)
         self.assertEqual(len(q_p2.linear_constraints), 1)
         self.assertEqual(len(q_p2.quadratic_constraints), 1)
@@ -1019,12 +995,8 @@ def test_substitute_variables(self):
 
         q_p2 = q_p.substitute_variables(constants={"z": -1})
         self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
-        self.assertDictEqual(
-            q_p2.objective.linear.to_dict(use_name=True), {"x": 1, "y": 2}
-        )
-        self.assertDictEqual(
-            q_p2.objective.quadratic.to_dict(use_name=True), {("x", "y"): -1}
-        )
+        self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), {"x": 1, "y": 2})
+        self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True), {("x", "y"): -1})
         self.assertEqual(q_p2.objective.constant, 3)
         self.assertEqual(len(q_p2.linear_constraints), 2)
         self.assertEqual(len(q_p2.quadratic_constraints), 0)
diff --git a/test/test_readme_sample.py b/test/test_readme_sample.py
index 9fd0897db..41310c2e4 100644
--- a/test/test_readme_sample.py
+++ b/test/test_readme_sample.py
@@ -56,9 +56,7 @@ def print(*args):
 
         # Formulate the problem as quadratic program
         problem = QuadraticProgram()
-        _ = [
-            problem.binary_var("x{}".format(i)) for i in range(n)
-        ]  # create n binary variables
+        _ = [problem.binary_var("x{}".format(i)) for i in range(n)]  # create n binary variables
         linear = w.dot(np.ones(n))
         quadratic = -w
         problem.maximize(linear=linear, quadratic=quadratic)
diff --git a/tools/check_copyright.py b/tools/check_copyright.py
index d5d7a570f..8a01ac08d 100644
--- a/tools/check_copyright.py
+++ b/tools/check_copyright.py
@@ -32,9 +32,7 @@ def __init__(self, root_dir: str) -> None:
 
     @staticmethod
     def _exception_to_string(excp: Exception) -> str:
-        stack = traceback.extract_stack()[:-3] + traceback.extract_tb(
-            excp.__traceback__
-        )
+        stack = traceback.extract_stack()[:-3] + traceback.extract_tb(excp.__traceback__)
         pretty = traceback.format_list(stack)
         return "".join(pretty) + "\n  {} {}".format(excp.__class__, excp)
 
@@ -53,9 +51,7 @@ def _format_output(out: bytes, err: bytes) -> Tuple[int, Union[None, str]]:
         year = CopyrightChecker._get_year_from_date(out_str)
         return year, err_str
 
-    def _process_file_last_year(
-        self, relative_path: str
-    ) -> Tuple[int, Union[None, str]]:
+    def _process_file_last_year(self, relative_path: str) -> Tuple[int, Union[None, str]]:
         # construct minimal environment
         env = {}
         for k in ["SYSTEMROOT", "PATH"]:
@@ -195,9 +191,7 @@ def check_path(path):
 
 if __name__ == "__main__":
     PARSER = argparse.ArgumentParser(description="Check Copyright Tool")
-    PARSER.add_argument(
-        "-path", type=check_path, metavar="path", help="Root path of project."
-    )
+    PARSER.add_argument("-path", type=check_path, metavar="path", help="Root path of project.")
 
     ARGS = PARSER.parse_args()
     if not ARGS.path:
@@ -206,10 +200,6 @@ def check_path(path):
     ARGS.path = os.path.abspath(os.path.realpath(os.path.expanduser(ARGS.path)))
     INVALID_UTF8, INVALID_YEAR, HAS_HEADER = CopyrightChecker(ARGS.path).check()
     print("{} files have utf8 headers.".format(INVALID_UTF8))
-    print(
-        "{} of {} files with copyright header have wrong years.".format(
-            INVALID_YEAR, HAS_HEADER
-        )
-    )
+    print("{} of {} files with copyright header have wrong years.".format(INVALID_YEAR, HAS_HEADER))
 
     sys.exit(os.EX_OK if INVALID_UTF8 == 0 and INVALID_YEAR == 0 else os.EX_SOFTWARE)
diff --git a/tools/extract_deprecation.py b/tools/extract_deprecation.py
index f762b8e45..05aa66b95 100644
--- a/tools/extract_deprecation.py
+++ b/tools/extract_deprecation.py
@@ -82,9 +82,7 @@ def _check_file(path) -> str:
 
 
 if __name__ == "__main__":
-    PARSER = argparse.ArgumentParser(
-        description="Qiskit Extract Deprecation Messages Tool"
-    )
+    PARSER = argparse.ArgumentParser(description="Qiskit Extract Deprecation Messages Tool")
     PARSER.add_argument(
         "-file", type=_check_file, required=True, metavar="file", help="Input file."
     )