poly_to_angles fixing #6978

doc/releases/changelog-dev.md

@@ -399,10 +399,16 @@
   passed to the `QNode`, instead of assuming the method is always `deferred`.
   [(#6903)](https://github.com/PennyLaneAI/pennylane/pull/6903)
 
+* The `poly_to_angles` functionality now correctly works with different tensor interfaces. 
+  Also, now it does not modify the input.
+  [(#6979)](https://github.com/PennyLaneAI/pennylane/pull/6979)
+
+
 <h3>Contributors ✍️</h3>
 
 This release contains contributions from (in alphabetical order):
 
+Guillermo Alonso,
 Utkarsh Azad,
 Henry Chang,
 Yushao Chen,

pennylane/templates/subroutines/qsvt.py

@@ -953,42 +953,43 @@ def circuit_qsvt():
 
     """
 
+    poly_list = list(poly)
     # Trailing zeros are removed from the array
-    for _ in range(len(poly)):
-        if not np.isclose(poly[-1], 0.0):
+    for _ in range(len(poly_list)):
+        if not np.isclose(poly_list[-1], 0.0):
             break
-        poly.pop()
+        poly_list.pop()
 
-    if len(poly) == 1:
+    if len(poly_list) == 1:
         raise AssertionError("The polynomial must have at least degree 1.")
 
     for x in [-1, 0, 1]:
-        if qml.math.abs(qml.math.sum(coeff * x**i for i, coeff in enumerate(poly))) > 1:
+        if qml.math.abs(qml.math.sum(coeff * x**i for i, coeff in enumerate(poly_list))) > 1:
             # Check that |P(x)| ≤ 1. Only points -1, 0, 1 will be checked.
             raise AssertionError("The polynomial must satisfy that |P(x)| ≤ 1 for all x in [-1, 1]")
 
     if routine in ["QSVT", "QSP"]:
         if not (
-            np.isclose(qml.math.sum(qml.math.abs(poly[::2])), 0.0)
-            or np.isclose(qml.math.sum(qml.math.abs(poly[1::2])), 0.0)
+            np.isclose(qml.math.sum(qml.math.abs(poly_list[::2])), 0.0)
+            or np.isclose(qml.math.sum(qml.math.abs(poly_list[1::2])), 0.0)
         ):
             raise AssertionError(
                 "The polynomial has no definite parity. All odd or even entries in the array must take a value of zero."
             )
         assert np.allclose(
-            np.array(poly, dtype=np.complex128).imag, 0
+            np.array(poly_list, dtype=np.complex128).imag, 0
         ), "Array must not have an imaginary part"
 
     if routine == "QSVT":
         if angle_solver == "root-finding":
-            return transform_angles(_compute_qsp_angle(poly), "QSP", "QSVT")
+            return transform_angles(_compute_qsp_angle(poly_list), "QSP", "QSVT")
         raise AssertionError("Invalid angle solver method. We currently support 'root-finding'")
 
     if routine == "QSP":
         if angle_solver == "root-finding":
-            return _compute_qsp_angle(poly)
+            return _compute_qsp_angle(poly_list)
         raise AssertionError("Invalid angle solver method. Valid value is 'root-finding'")
 
     if routine == "GQSP":
-        return _compute_gqsp_angles(poly)
+        return _compute_gqsp_angles(poly_list)
     raise AssertionError("Invalid routine. Valid values are 'QSP' and 'QSVT'")

tests/templates/test_subroutines/test_qsvt.py

@@ -792,3 +792,66 @@ def test_raise_error(self, poly, routine, angle_solver, msg_match):
 
         with pytest.raises(AssertionError, match=msg_match):
             _ = qml.poly_to_angles(poly, routine, angle_solver)
+
+    def test_immutable_input(self):
+        """Test `poly_to_angles` does not modify the input"""
+
+        poly = [0, 1.0, 0, -1 / 2, 0, 1 / 3, 0]
+        poly_copy = poly.copy()
+        qml.poly_to_angles(poly, "QSVT")
+
+        assert len(poly) == len(poly_copy)
+        assert np.allclose(poly, poly_copy)
+
+    def test_interface_numpy(self):
+        """Test `poly_to_angles` works with numpy"""
+
+        poly = [0, 1.0, 0, -1 / 2, 0, 1 / 3, 0]
+        angles = qml.poly_to_angles(poly, "QSVT")
+
+        poly_numpy = np.array(poly)
+        angles_numpy = qml.poly_to_angles(poly_numpy, "QSVT")
+
+        assert qml.math.allclose(angles, angles_numpy)
+
+    @pytest.mark.jax
+    def test_interface_jax(self):
+        """Test `poly_to_angles` works with jax"""
+
+        import jax
+
+        poly = [0, 1.0, 0, -1 / 2, 0, 1 / 3, 0]
+        angles = qml.poly_to_angles(poly, "QSVT")
+
+        poly_jax = jax.numpy.array(poly)
+        angles_jax = qml.poly_to_angles(poly_jax, "QSVT")
+
+        assert qml.math.allclose(angles, angles_jax)
+
+    @pytest.mark.torch
+    def test_interface_torch(self):
+        """Test `poly_to_angles` works with torch"""
+
+        import torch
+
+        poly = [0, 1.0, 0, -1 / 2, 0, 1 / 3, 0]
+        angles = qml.poly_to_angles(poly, "QSVT")
+
+        poly_torch = torch.tensor(poly)
+        angles_torch = qml.poly_to_angles(poly_torch, "QSVT")
+
+        assert qml.math.allclose(angles, angles_torch)
+
+    @pytest.mark.tf
+    def test_interface_tf(self):
+        """Test `poly_to_angles` works with tensorflow"""
+
+        import tensorflow as tf
+
+        poly = [0, 1.0, 0, -1 / 2, 0, 1 / 3, 0]
+        angles = qml.poly_to_angles(poly, "QSVT")
+
+        poly_tf = tf.Variable(poly)
+        angles_tf = qml.poly_to_angles(poly_tf, "QSVT")
+
+        assert qml.math.allclose(angles, angles_tf)