diff --git a/qiskit_optimization/algorithms/minimum_eigen_optimizer.py b/qiskit_optimization/algorithms/minimum_eigen_optimizer.py index e35286090..ef5364449 100644 --- a/qiskit_optimization/algorithms/minimum_eigen_optimizer.py +++ b/qiskit_optimization/algorithms/minimum_eigen_optimizer.py @@ -214,7 +214,7 @@ def solve(self, problem: QuadraticProgram) -> MinimumEigenOptimizationResult: problem_ = self._convert(problem, self._converters) # construct operator and offset - operator, offset = problem_.to_ising(opflow=False) + operator, offset = problem_.to_ising() return self._solve_internal(operator, offset, problem_, problem) diff --git a/qiskit_optimization/algorithms/optimization_algorithm.py b/qiskit_optimization/algorithms/optimization_algorithm.py index 68ee6c244..1742d62db 100644 --- a/qiskit_optimization/algorithms/optimization_algorithm.py +++ b/qiskit_optimization/algorithms/optimization_algorithm.py @@ -19,7 +19,6 @@ from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast import numpy as np -from qiskit.opflow import DictStateFn, StateFn from qiskit.quantum_info import Statevector from qiskit.result import QuasiDistribution @@ -524,7 +523,7 @@ def _interpret_samples( @staticmethod def _eigenvector_to_solutions( - eigenvector: Union[QuasiDistribution, Statevector, dict, np.ndarray, StateFn], + eigenvector: Union[QuasiDistribution, Statevector, dict, np.ndarray], qubo: QuadraticProgram, min_probability: float = _MIN_PROBABILITY, ) -> List[SolutionSample]: @@ -540,26 +539,9 @@ def _eigenvector_to_solutions( state as bitstring along with the QUBO evaluated at that bitstring and the probability of sampling this bitstring from the eigenvector. - Examples: - >>> op = MatrixOp(numpy.array([[1, 1], [1, -1]]) / numpy.sqrt(2)) - >>> eigenvectors = {'0': 12, '1': 1} - >>> print(eigenvector_to_solutions(eigenvectors, op)) - [('0', 0.7071067811865475, 0.9230769230769231), - ('1', -0.7071067811865475, 0.07692307692307693)] - - >>> op = MatrixOp(numpy.array([[1, 1], [1, -1]]) / numpy.sqrt(2)) - >>> eigenvectors = numpy.array([1, 1] / numpy.sqrt(2), dtype=complex) - >>> print(eigenvector_to_solutions(eigenvectors, op)) - [('0', 0.7071067811865475, 0.4999999999999999), - ('1', -0.7071067811865475, 0.4999999999999999)] - Raises: TypeError: If the type of eigenvector is not supported. """ - if isinstance(eigenvector, DictStateFn): - eigenvector = eigenvector.primitive - elif isinstance(eigenvector, StateFn): - eigenvector = eigenvector.to_matrix() def generate_solution(bitstr, qubo, probability): x = np.fromiter(list(bitstr[::-1]), dtype=int) diff --git a/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py b/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py index e26421360..8f2eba1c0 100644 --- a/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py +++ b/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py @@ -310,7 +310,7 @@ def solve(self, problem: QuadraticProgram) -> MinimumEigenOptimizationResult: pre_solutions = opt_result.samples[:num_pre_solutions] # construct operator and offset - operator, offset = converted_problem.to_ising(opflow=False) + operator, offset = converted_problem.to_ising() results: List[MinimumEigenOptimizationResult] = [] for pre_solution in pre_solutions: diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py index a2b02d7aa..8b98ef120 100644 --- a/qiskit_optimization/applications/graph_optimization_application.py +++ b/qiskit_optimization/applications/graph_optimization_application.py @@ -13,15 +13,15 @@ """An abstract class for graph optimization application classes.""" from abc import abstractmethod -from typing import Union, Optional, Dict, List +from typing import Dict, List, Optional, Union import networkx as nx import numpy as np import qiskit_optimization.optionals as _optionals -from .optimization_application import OptimizationApplication + from ..algorithms import OptimizationResult -from ..deprecation import DeprecatedType, deprecate_method +from .optimization_application import OptimizationApplication class GraphOptimizationApplication(OptimizationApplication): @@ -79,19 +79,3 @@ def graph(self) -> nx.Graph: A graph for a problem """ return self._graph - - @staticmethod - @deprecate_method( - "0.3.0", DeprecatedType.FUNCTION, "networkx.gnm_random_graph", "in NetworkX, directly" - ) - def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> nx.Graph: - """ - Args: - num_nodes: The number of nodes in a graph - num_edges: The number of edges in a graph - seed: seed for a random graph - - Returns: - A random graph of NetworkX - """ - return nx.gnm_random_graph(num_nodes, num_edges, seed) diff --git a/qiskit_optimization/applications/optimization_application.py b/qiskit_optimization/applications/optimization_application.py index 963e2a065..1794d9d8b 100644 --- a/qiskit_optimization/applications/optimization_application.py +++ b/qiskit_optimization/applications/optimization_application.py @@ -16,7 +16,6 @@ from typing import Dict, Union import numpy as np -from qiskit.opflow import StateFn from qiskit.quantum_info import Statevector from qiskit.result import QuasiDistribution @@ -95,10 +94,6 @@ def sample_most_likely( binary_string = max(state_vector.items(), key=lambda kv: kv[1])[0] x = np.asarray([int(y) for y in reversed(list(binary_string))]) return x - elif isinstance(state_vector, StateFn): - binary_string = list(state_vector.sample().keys())[0] - x = np.asarray([int(y) for y in reversed(list(binary_string))]) - return x elif isinstance(state_vector, np.ndarray): n = int(np.log2(state_vector.shape[0])) k = np.argmax(np.abs(state_vector)) diff --git a/qiskit_optimization/problems/quadratic_program.py b/qiskit_optimization/problems/quadratic_program.py index 0aff7854b..f017f9a43 100644 --- a/qiskit_optimization/problems/quadratic_program.py +++ b/qiskit_optimization/problems/quadratic_program.py @@ -22,7 +22,6 @@ import numpy as np from docplex.mp.model_reader import ModelReader from numpy import ndarray -from qiskit.opflow import OperatorBase from qiskit.quantum_info import SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator from scipy.sparse import spmatrix @@ -1009,21 +1008,13 @@ def substitute_variables( return substitute_variables(self, constants, variables) - def to_ising( - self, opflow: Optional[bool] = None - ) -> Tuple[Union[OperatorBase, SparsePauliOp], float]: + def to_ising(self) -> Tuple[SparsePauliOp, float]: """Return the Ising Hamiltonian of this problem. Variables are mapped to qubits in the same order, i.e., i-th variable is mapped to i-th qubit. See https://github.com/Qiskit/qiskit-terra/issues/1148 for details. - Args: - opflow: The output object is an OpFlow's operator if True. - Otherwise, it is ``SparsePauliOp``. - Refer to :func:`~qiskit_optimization.translators.to_ising` - for the default value. - Returns: qubit_op: The qubit operator for the problem offset: The constant value in the Ising Hamiltonian. @@ -1035,11 +1026,11 @@ def to_ising( # pylint: disable=cyclic-import from ..translators.ising import to_ising - return to_ising(self, opflow=opflow) + return to_ising(self) def from_ising( self, - qubit_op: Union[OperatorBase, BaseOperator], + qubit_op: BaseOperator, offset: float = 0.0, linear: bool = False, ) -> None: diff --git a/qiskit_optimization/translators/ising.py b/qiskit_optimization/translators/ising.py index 5ebd5af6f..699b3bb26 100644 --- a/qiskit_optimization/translators/ising.py +++ b/qiskit_optimization/translators/ising.py @@ -13,11 +13,9 @@ """Translator between an Ising Hamiltonian and a quadratic program""" import math -from typing import Optional, Tuple, Union -from warnings import warn +from typing import Tuple import numpy as np -from qiskit.opflow import ListOp, OperatorBase, PauliOp, PauliSumOp from qiskit.quantum_info import Pauli, SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator @@ -25,24 +23,15 @@ from qiskit_optimization.problems.quadratic_program import QuadraticProgram -def to_ising( - quad_prog: QuadraticProgram, opflow: Optional[bool] = None -) -> Tuple[Union[PauliSumOp, SparsePauliOp], float]: +def to_ising(quad_prog: QuadraticProgram) -> Tuple[SparsePauliOp, float]: """Return the Ising Hamiltonian of this problem. Variables are mapped to qubits in the same order, i.e., i-th variable is mapped to i-th qubit. See https://github.com/Qiskit/qiskit-terra/issues/1148 for details. - .. note:: - - The default value of ``opflow`` argument is currently set ``True``, but it will - first be changed to ``False`` and then deprecated in future releases. - Args: quad_prog: The problem to be translated. - opflow: The output object is a ``PauliSumOp`` operator if True. - Otherwise, it is ``SparsePauliOp``. (default: True) Returns: A tuple (qubit_op, offset) comprising the qubit operator for the problem @@ -53,15 +42,6 @@ def to_ising( in the problem. QiskitOptimizationError: If constraints exist in the problem. """ - if opflow is None: - opflow = True - warn( - "`opflow` argument of `to_ising` is not set explicitly. " - "It is currently set True, but the default value will be changed to False. " - "We suggest using `SparsePauliOp` instead of Opflow operators.", - stacklevel=2, - ) - # if problem has variables that are not binary, raise an error if quad_prog.get_num_vars() > quad_prog.get_num_binary_vars(): raise QiskitOptimizationError( @@ -133,14 +113,11 @@ def to_ising( num_vars = max(1, num_vars) qubit_op = SparsePauliOp("I" * num_vars, 0) - if opflow: - qubit_op = PauliSumOp(qubit_op) - return qubit_op, offset def from_ising( - qubit_op: Union[OperatorBase, BaseOperator], + qubit_op: BaseOperator, offset: float = 0.0, linear: bool = False, ) -> QuadraticProgram: @@ -150,13 +127,6 @@ def from_ising( i-th variable is mapped to i-th qubit. See https://github.com/Qiskit/qiskit-terra/issues/1148 for details. - .. note:: - - The ``qubit_op`` argument can currently accept Opflow operators (``OperatorBase`` type), - but have been superseded by Qiskit Terra quantum_info ``BaseOperators`` such as - ``SparsePauliOp``. Opflow operator support will be deprecated in a future release - and subsequently removed after that. - Args: qubit_op: The qubit operator of the problem. offset: The constant term in the Ising Hamiltonian. @@ -172,35 +142,12 @@ def from_ising( QiskitOptimizationError: if there are Pauli Xs or Ys in any Pauli term QiskitOptimizationError: if there are more than 2 Pauli Zs in any Pauli term QiskitOptimizationError: if any Pauli term has an imaginary coefficient - NotImplementedError: If the input operator is a ListOp """ # quantum_info if isinstance(qubit_op, BaseOperator): if not isinstance(qubit_op, SparsePauliOp): qubit_op = SparsePauliOp(qubit_op) - # opflow - if isinstance(qubit_op, OperatorBase): - warn( - "The `qubit_op` argument can currently accept Opflow operators (`OperatorBase` type), " - "but have been superseded by Qiskit Terra quantum_info `BaseOperators` such as " - "`SparsePauliOp`. Opflow operators have been deprecated in Qiskit Terra 0.24.0 " - "and subsequently removed after that.", - category=DeprecationWarning, - stacklevel=2, - ) - if isinstance(qubit_op, PauliSumOp): - qubit_op = qubit_op.primitive * qubit_op.coeff - if isinstance(qubit_op, PauliOp): - qubit_op = SparsePauliOp(qubit_op.primitive, qubit_op.coeff) - # No support for ListOp yet, this can be added in future - # pylint: disable=unidiomatic-typecheck - if type(qubit_op) == ListOp: - raise NotImplementedError( - "Conversion of a ListOp is not supported, convert each " - "operator in the ListOp separately." - ) - quad_prog = QuadraticProgram() quad_prog.binary_var_list(qubit_op.num_qubits) diff --git a/test/applications/test_optimization_application.py b/test/applications/test_optimization_application.py index 7c5e5f020..aafc7d184 100644 --- a/test/applications/test_optimization_application.py +++ b/test/applications/test_optimization_application.py @@ -17,7 +17,6 @@ import numpy as np from ddt import data, ddt -from qiskit.opflow import StateFn from qiskit.result import QuasiDistribution from qiskit_optimization.applications import OptimizationApplication @@ -29,7 +28,6 @@ class TestOptimizationApplication(QiskitOptimizationTestCase): @data( np.array([0, 0, 1, 0]), - StateFn([0, 0, 1, 0]), {"10": 0.8, "01": 0.2}, QuasiDistribution({"10": 0.8, "01": 0.2}), ) diff --git a/test/converters/test_converters.py b/test/converters/test_converters.py index 66f0c1199..f90eb386b 100644 --- a/test/converters/test_converters.py +++ b/test/converters/test_converters.py @@ -64,7 +64,7 @@ def test_empty_problem(self): op = conv.convert(op) conv = MaximizeToMinimize() op = conv.convert(op) - _, shift = op.to_ising(opflow=True) + _, shift = op.to_ising() self.assertEqual(shift, 0.0) def test_valid_variable_type(self): @@ -73,12 +73,12 @@ def test_valid_variable_type(self): with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.integer_var(0, 10, "int_var") - _ = op.to_ising(opflow=True) + _ = op.to_ising() # Continuous variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.continuous_var(0, 10, "continuous_var") - _ = op.to_ising(opflow=True) + _ = op.to_ising() def test_inequality_binary(self): """Test InequalityToEqualityConverter with binary variables""" @@ -399,7 +399,7 @@ def test_optimizationproblem_to_ising(self): op.linear_constraint(linear, Constraint.Sense.EQ, 3, "sum1") penalize = LinearEqualityToPenalty(penalty=1e5) op2 = penalize.convert(op) - qubitop, offset = op2.to_ising(opflow=False) + qubitop, offset = op2.to_ising() self.assertTrue(qubitop.equiv(QUBIT_OP_MAXIMIZE_SAMPLE)) self.assertEqual(offset, OFFSET_MAXIMIZE_SAMPLE) diff --git a/test/translators/test_ising.py b/test/translators/test_ising.py index 14d68ef6d..b1de23501 100644 --- a/test/translators/test_ising.py +++ b/test/translators/test_ising.py @@ -16,8 +16,6 @@ from test.optimization_test_case import QiskitOptimizationTestCase import numpy as np -from ddt import data, ddt -from qiskit.opflow import I, OperatorBase, PauliSumOp, Z from qiskit.quantum_info import Pauli, SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator @@ -26,27 +24,10 @@ from qiskit_optimization.translators import from_ising, to_ising -@ddt class TestIsingTranslator(QiskitOptimizationTestCase): """Test from_ising and to_ising""" - def op_from_list(self, lst, opflow): - """generate an operator from a list""" - if opflow: - with self.assertWarns(DeprecationWarning): - return PauliSumOp.from_list(lst) - else: - return SparsePauliOp.from_list(lst) - - def assert_deprecation_warning(self, opflow: bool): - """assert deprecation warning if opflow is used""" - if opflow: - return self.assertWarns(DeprecationWarning) - else: - return nullcontext() - - @data(True, False, None) - def test_to_ising(self, opflow): + def test_to_ising(self): """test to_ising""" with self.subTest("minimize"): @@ -56,12 +37,7 @@ def test_to_ising(self, opflow): q_p.binary_var(name="x") q_p.binary_var(name="y") q_p.minimize(linear={"x": 1}, quadratic={("x", "y"): 1}) - with self.assert_deprecation_warning(opflow in [None, True]): - op, offset = to_ising(q_p, opflow) - if opflow in [None, True]: - self.assertIsInstance(op, OperatorBase) - else: - self.assertIsInstance(op, BaseOperator) + op, offset = to_ising(q_p) op_ref = SparsePauliOp.from_list([("ZI", -0.25), ("IZ", -0.75), ("ZZ", 0.25)]) np.testing.assert_allclose(op.to_matrix(), op_ref.to_matrix()) self.assertAlmostEqual(offset, 0.75) @@ -73,18 +49,12 @@ def test_to_ising(self, opflow): q_p.binary_var(name="x") q_p.binary_var(name="y") q_p.maximize(linear={"x": 1}, quadratic={("x", "y"): 1}) - with self.assert_deprecation_warning(opflow in [None, True]): - op, offset = to_ising(q_p, opflow) - if opflow in [None, True]: - self.assertIsInstance(op, OperatorBase) - else: - self.assertIsInstance(op, BaseOperator) + op, offset = to_ising(q_p) op_ref = SparsePauliOp.from_list([("ZI", 0.25), ("IZ", 0.75), ("ZZ", -0.25)]) np.testing.assert_allclose(op.to_matrix(), op_ref.to_matrix()) self.assertAlmostEqual(offset, -0.75) - @data(True, False, None) - def test_to_ising2(self, opflow): + def test_to_ising2(self): """test to_ising 2""" with self.subTest("minimize"): @@ -94,12 +64,7 @@ def test_to_ising2(self, opflow): q_p.binary_var(name="x") q_p.binary_var(name="y") q_p.minimize(constant=1, linear={"x": -2, "y": -2}, quadratic={("x", "y"): 4}) - with self.assert_deprecation_warning(opflow in [None, True]): - op, offset = to_ising(q_p, opflow) - if opflow in [None, True]: - self.assertIsInstance(op, OperatorBase) - else: - self.assertIsInstance(op, BaseOperator) + op, offset = to_ising(q_p) op_ref = SparsePauliOp.from_list([("ZZ", 1.0)]) np.testing.assert_allclose(op.to_matrix(), op_ref.to_matrix()) self.assertAlmostEqual(offset, 0.0) @@ -111,25 +76,18 @@ def test_to_ising2(self, opflow): q_p.binary_var(name="x") q_p.binary_var(name="y") q_p.maximize(constant=1, linear={"x": -2, "y": -2}, quadratic={("x", "y"): 4}) - with self.assert_deprecation_warning(opflow in [None, True]): - op, offset = to_ising(q_p, opflow) - if opflow in [None, True]: - self.assertIsInstance(op, OperatorBase) - else: - self.assertIsInstance(op, BaseOperator) + op, offset = to_ising(q_p) op_ref = SparsePauliOp.from_list([("ZZ", -1.0)]) np.testing.assert_allclose(op.to_matrix(), op_ref.to_matrix()) self.assertAlmostEqual(offset, 0.0) - @data(True, False) - def test_from_ising(self, opflow): + def test_from_ising(self): """test from_ising""" # minimize: x + x * y # subject to: x, y \in {0, 1} - op = self.op_from_list([("ZI", -0.25), ("IZ", -0.75), ("ZZ", 0.25)], opflow) + op = SparsePauliOp.from_list([("ZI", -0.25), ("IZ", -0.75), ("ZZ", 0.25)]) with self.subTest("linear: True"): - with self.assert_deprecation_warning(opflow): - q_p = from_ising(op, 0.75, linear=True) + q_p = from_ising(op, 0.75, linear=True) self.assertEqual(q_p.get_num_vars(), op.num_qubits) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -138,8 +96,7 @@ def test_from_ising(self, opflow): np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 1], [0, 0]]) with self.subTest("linear: False"): - with self.assert_deprecation_warning(opflow): - q_p = from_ising(op, 0.75, linear=False) + q_p = from_ising(op, 0.75, linear=False) self.assertEqual(q_p.get_num_vars(), op.num_qubits) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -147,15 +104,13 @@ def test_from_ising(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[1, 1], [0, 0]]) - @data(True, False) - def test_from_ising2(self, opflow): + def test_from_ising2(self): """test from_ising 2""" # minimize: 1 - 2 * x1 - 2 * x2 + 4 * x1 * x2 # subject to: x, y \in {0, 1} - op = self.op_from_list([("ZZ", 1)], opflow) + op = SparsePauliOp.from_list([("ZZ", 1)]) with self.subTest("linear: True"): - with self.assert_deprecation_warning(opflow): - q_p = from_ising(op, 0, linear=True) + q_p = from_ising(op, 0, linear=True) self.assertEqual(q_p.get_num_vars(), op.num_qubits) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -164,8 +119,7 @@ def test_from_ising2(self, opflow): np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 4], [0, 0]]) with self.subTest("linear: False"): - with self.assert_deprecation_warning(opflow): - q_p = from_ising(op, 0, linear=False) + q_p = from_ising(op, 0, linear=False) self.assertEqual(q_p.get_num_vars(), op.num_qubits) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -173,36 +127,29 @@ def test_from_ising2(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[-2, 4], [0, -2]]) - @data(True, False) - def test_from_ising_pauli_with_invalid_paulis(self, opflow): + def test_from_ising_pauli_with_invalid_paulis(self): """test from_ising with invalid Pauli terms""" with self.assertRaises(QiskitOptimizationError): - op = self.op_from_list([("IX", 1)], opflow) - with self.assert_deprecation_warning(opflow): - _ = from_ising(op, 0) + op = SparsePauliOp.from_list([("IX", 1)]) + _ = from_ising(op, 0) with self.assertRaises(QiskitOptimizationError): - op = self.op_from_list([("IY", 1)], opflow) - with self.assert_deprecation_warning(opflow): - _ = from_ising(op, 0) + op = SparsePauliOp.from_list([("IY", 1)]) + _ = from_ising(op, 0) with self.assertRaises(QiskitOptimizationError): - op = self.op_from_list([("ZZZ", 1)], opflow) - with self.assert_deprecation_warning(opflow): - _ = from_ising(op, 0) + op = SparsePauliOp.from_list([("ZZZ", 1)]) + _ = from_ising(op, 0) with self.assertRaises(QiskitOptimizationError): - op = self.op_from_list([("IZ", 1j)], opflow) - with self.assert_deprecation_warning(opflow): - _ = from_ising(op, 0) + op = SparsePauliOp.from_list([("IZ", 1j)]) + _ = from_ising(op, 0) - @data(True, False) - def test_pauli_I_Z(self, opflow): + def test_pauli_I_Z(self): """test from_ising and to_ising with Pauli I and Z""" with self.subTest("0 * I, linear=False"): - with self.assert_deprecation_warning(opflow): - operator = 0 * I if opflow else SparsePauliOp("I", 0) - q_p = from_ising(operator, linear=False) + operator = SparsePauliOp("I", 0) + q_p = from_ising(operator, linear=False) self.assertEqual(q_p.get_num_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -210,15 +157,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 0) with self.subTest("0 * I, linear=True"): - with self.assert_deprecation_warning(opflow): - operator = 0 * I if opflow else SparsePauliOp("I", 0) - q_p = from_ising(operator, linear=True) + operator = SparsePauliOp("I", 0) + q_p = from_ising(operator, linear=True) self.assertEqual(q_p.get_num_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -226,15 +171,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 0) with self.subTest("2 * I, linear=False"): - with self.assert_deprecation_warning(opflow): - operator = 2 * I if opflow else SparsePauliOp("I", 2) - q_p = from_ising(operator, linear=False) + operator = SparsePauliOp("I", 2) + q_p = from_ising(operator, linear=False) self.assertEqual(q_p.get_num_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -242,15 +185,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 2) with self.subTest("2 * I, linear=True"): - with self.assert_deprecation_warning(opflow): - operator = 2 * I if opflow else SparsePauliOp("I", 2) - q_p = from_ising(operator, linear=True) + operator = SparsePauliOp("I", 2) + q_p = from_ising(operator, linear=True) self.assertEqual(q_p.get_num_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -258,15 +199,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 2) with self.subTest("Z, linear=False"): - with self.assert_deprecation_warning(opflow): - operator = Z if opflow else Pauli("Z") - q_p = from_ising(operator, linear=False) + operator = Pauli("Z") + q_p = from_ising(operator, linear=False) self.assertEqual(q_p.get_num_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -274,15 +213,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[-2]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), operator.to_matrix()) self.assertAlmostEqual(offset, 0) with self.subTest("Z, linear=True"): - with self.assert_deprecation_warning(opflow): - operator = Z if opflow else Pauli("Z") - q_p = from_ising(operator, linear=True) + operator = Pauli("Z") + q_p = from_ising(operator, linear=True) self.assertEqual(q_p.get_num_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -290,15 +227,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [-2]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), operator.to_matrix()) self.assertAlmostEqual(offset, 0) with self.subTest("3 * II, linear=False"): - with self.assert_deprecation_warning(opflow): - operator = 3 * I ^ I if opflow else SparsePauliOp("II", 3) - q_p = from_ising(operator, linear=False) + operator = SparsePauliOp("II", 3) + q_p = from_ising(operator, linear=False) self.assertEqual(q_p.get_num_vars(), 2) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -306,15 +241,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 0], [0, 0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((4, 4))) self.assertAlmostEqual(offset, 3) with self.subTest("3 * II, linear=True"): - with self.assert_deprecation_warning(opflow): - operator = 3 * I ^ I if opflow else SparsePauliOp("II", 3) - q_p = from_ising(operator, linear=True) + operator = SparsePauliOp("II", 3) + q_p = from_ising(operator, linear=True) self.assertEqual(q_p.get_num_vars(), 2) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -322,15 +255,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 0], [0, 0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((4, 4))) self.assertAlmostEqual(offset, 3) with self.subTest("IZ, linear=False"): - with self.assert_deprecation_warning(opflow): - operator = I ^ Z if opflow else Pauli("IZ") - q_p = from_ising(operator, linear=False) + operator = Pauli("IZ") + q_p = from_ising(operator, linear=False) self.assertEqual(q_p.get_num_vars(), 2) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -338,15 +269,13 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [0, 0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[-2, 0], [0, 0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), operator.to_matrix()) self.assertAlmostEqual(offset, 0) with self.subTest("IZ, linear=True"): - with self.assert_deprecation_warning(opflow): - operator = I ^ Z if opflow else Pauli("IZ") - q_p = from_ising(operator, linear=True) + operator = Pauli("IZ") + q_p = from_ising(operator, linear=True) self.assertEqual(q_p.get_num_vars(), 2) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) @@ -354,44 +283,28 @@ def test_pauli_I_Z(self, opflow): np.testing.assert_allclose(q_p.objective.linear.to_array(), [-2, 0]) np.testing.assert_allclose(q_p.objective.quadratic.to_array(), [[0, 0], [0, 0]]) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow=opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), operator.to_matrix()) self.assertAlmostEqual(offset, 0) - @data(True, False) - def test_to_ising_wo_variable(self, opflow): + def test_to_ising_wo_variable(self): """test to_ising with problems without variables""" with self.subTest("empty problem"): q_p = QuadraticProgram() - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 0) with self.subTest("min 3"): q_p = QuadraticProgram() q_p.minimize(constant=3) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 3) with self.subTest("max -1"): q_p = QuadraticProgram() q_p.maximize(constant=-1) - with self.assert_deprecation_warning(opflow): - op, offset = to_ising(q_p, opflow) + op, offset = to_ising(q_p) np.testing.assert_allclose(op.to_matrix(), np.zeros((2, 2))) self.assertAlmostEqual(offset, 1) - - def test_warning(self): - """Test warning message""" - q_p = QuadraticProgram() - with self.assertWarns((UserWarning, DeprecationWarning)): - _ = to_ising(q_p) - - with self.assertWarns(DeprecationWarning): - op = PauliSumOp.from_list([("Z", 1)]) - with self.assertWarns(DeprecationWarning): - _ = from_ising(op)