`qiroMaxSat` and `maxSat` should not use `app_sb_phase_polynomial`

[purva-thakre]

Qrisp/src/qrisp/algorithms/qaoa/problems/maxSat.py

Lines 98 to 128 in 0f9adb0

	def create_maxsat_cost_operator(problem):
	r"""
	Creates the cost operator for an instance of the maximum satisfiability problem.
	For a given cost function
	.. math::
	C(x) = \sum_{\alpha=1}^m C_{\alpha}(x)
	the cost operator is given by $e^{-i\gamma C}$ where $C=\sum_x C(x)\ket{x}\bra{x}$.
	Parameters
	----------
	problem : tuple(int, list[list[int]])
	The number of variables, and the clauses of the maximum satisfiability problem instance.
	Returns
	-------
	cost_operator : function
	A function receiving a :ref:`QuantumVariable` and a real parameter $\gamma$.
	This function performs the application of the cost operator.
	"""
	cost_polynomials, symbols = create_maxsat_cost_polynomials(problem)
	def cost_operator(qv, gamma):
	for P in cost_polynomials:
	app_sb_phase_polynomial([qv], -P, symbols, t=gamma)
	return cost_operator

Qrisp/src/qrisp/algorithms/qiro/qiroproblems/qiroMaxSat.py

Lines 136 to 165 in 0f9adb0

	def create_maxsat_cost_operator_reduced(problem_updated):
	"""
	Creates the ``cost_operator`` for the problem instance.
	This operator is adjusted to consider qubits that were found to be a part of the problem solution.
	Parameters
	----------
	problem_updated : List
	Updates that happened during the QIRO routine. Consits of the updated problem, a list of Qubits which were found to be positively correlated, i.e. part of the problem solution,
	and a list Qubits which were found to be negatively correlated, i.e. they contradict solution qubits in accordance with the update rules.
	Returns
	-------
	cost_operator : function
	A function receiving a :ref:`QuantumVariable` and a real parameter $\gamma$. This function performs the application of the cost operator.
	"""
	from qrisp.algorithms.qaoa import create_maxsat_cost_polynomials
	problem = problem_updated[0]
	cost_polynomials, symbols = create_maxsat_cost_polynomials(problem)
	def cost_operator(qv, gamma):
	for P in cost_polynomials:
	if not isinstance(P, int):
	app_sb_phase_polynomial([qv], -P, symbols, t=gamma)
	return cost_operator

[purva-thakre]

Worth considering with this issue, there is a unit test that uses app_phase_polynomial from SBP arithmetic.

Qrisp/tests/primitives_tests/test_diagonal_hamiltonian_application.py

Lines 135 to 177 in 0f9adb0

	def test_phase_polynomial_application():
	import numpy as np
	import sympy as sp
	from qrisp import QuantumFloat, h, app_phase_polynomial
	# We apply the phase function specified by the polynomial P(x) = 1 - 0.9x^2 + x^3 on a QuantumFloat (unsigned)
	x = sp.symbols('x')
	P = 1-0.9*x**2+x**3
	qf = QuantumFloat(3,-3)
	h(qf)
	app_phase_polynomial([qf],P)
	sv_function = qf.qs.statevector("function")
	qf_values = np.array([qf.decoder(i) for i in range(2 ** qf.size)])
	sv_phase_array = np.angle([sv_function({qf : i}) for i in qf_values])
	P_func = sp.lambdify(x, P, 'numpy')
	# Check if phases agree
	from numpy.linalg import norm
	assert norm((sv_phase_array - P_func(qf_values))) < 1e-4
	# We apply the phase function specified by the polynomial P(x) = 1 - 0.9x^2 + x^3 on a QuantumFloat (signed)
	x = sp.symbols('x')
	P = 1-0.9*x**2+x**3
	qf = QuantumFloat(3,-3,signed=True)
	h(qf)
	app_phase_polynomial([qf],P)
	sv_function = qf.qs.statevector("function")
	qf_values = np.array([qf.decoder(i) for i in range(2 ** qf.size)])
	sv_phase_array = np.angle([sv_function({qf : i}) for i in qf_values])
	P_func = sp.lambdify(x, P, 'numpy')
	# Check if phases agree
	from numpy.linalg import norm
	assert norm((sv_phase_array - P_func(qf_values))) < 1e-4