Issue with qml.poly_to_angles(poly, "GQSP")

[HYW]

Hi,

I have an issue when using qml.poly_to_angles(poly, “GQSP”).

The code is okay for num = 10 or below but it doesn’t work when num is greater than 10. I need to have num = 30.

import pennylane as qml
import numpy as np
from sympy import *

num=30  # at least 30
fac=5

def taylor(num):
    taylor=np.ones(num+1)
    for i in range(1,num+1):
        taylor[i]=(-1)**i * 1/factorial(i)
    return taylor
taylor(num)

poly = taylor(num)/fac
poly

angles = qml.poly_to_angles(poly, "GQSP")
angles

If you want help with diagnosing an error, please put the full error message below:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[111], line 1
----> 1 angles = qml.poly_to_angles(poly, "GQSP")
      2 angles

File /Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pennylane/templates/subroutines/qsvt.py:1117, in poly_to_angles(poly, routine, angle_solver)
   1115     if not np.isclose(poly[-1], 0.0):
   1116         break
-> 1117     poly.pop()
   1119 if len(poly) == 1:
   1120     raise AssertionError("The polynomial must have at least degree 1.")

AttributeError: 'numpy.ndarray' object has no attribute 'pop'

And, finally, make sure to include the versions of your packages. Specifically, show us the output of qml.about().
Name: PennyLane
Version: 0.40.0

Thanks,
HYW

[CatalinaAlbornoz]

Hi @HYW,

I think you may have uncovered a bug .

There’s a section of the code that tries to remove trailing zeros from the array. Given your polynomials, the larger num is, the closest poly[-1] gets to zero. So for num<=10 the code that removes trailing zeros is skipped, which is why it works. However for num>10 the code tries to remove the last zero and it breaks.

I think the source of the issue is the same as this issue, so it’s possible that using the Master (development) version of PennyLane fixes the problem. Could you please try using this version and let us know if the problem is fixed for you? Let us know if you need any help on how to use this version.

[HYW]

Thank you Catalina.

Could you tell me how to install Master (development) version of PennyLane?

Thank you,
HYW

[HYW]

Hi Catalina,

poly = taylor(num)/fac
poly = poly.tolist()
poly

angles = qml.poly_to_angles(poly, “GQSP”)
angles

I convert ploy to a list and no error exists now. However, there is a new issue.
The resulting angles for num = 10 and 11, 12, 13… are all the same. You can observe that the number of resulting angles is unchaged for num >= 10.

I understand that these high-order angles are very small but they play a vital role for my application. My application is highly related to their inverse exponential so the result is incorrect if they are ignored and neglected. Could you tell me how to keep these high-order terms? I need to set num = 30 at least.

Thank you,
HYW

[Guillermo_Alonso]

@HYW

import pennylane as qml
import numpy as np
from sympy import *

num=30  # at least 30
fac=5

def taylor(num):
    taylor=np.ones(num+1)
    for i in range(1,num+1):
        taylor[i]=(-1)**i * 1/factorial(i)
    return taylor
taylor(num)

poly = taylor(num)/fac
poly

angles = qml.poly_to_angles(poly, "GQSP")
angles

Hi @HYW ! Glad to see you are using this functionality
Indeed, the first thing is a bug that has been fixed, to install the latest version run the following cell:

!pip install git+https://github.com/PennyLaneAI/pennylane.git

Regarding your comments. It seems to work on my end Notice that although the second set of angles take the value 0, the first set is updated

I hope this helps

[HYW]

Hi Guillermo,

Thank you for your help. I will examine how GQSP can be used in my application.

I also spot a bug - the order of tensor product seems wrong for the defined unitary(wires) function.
Could you fix it?

HYW

[daniela.murcillo]

Hi!
I do see your point. However, this one is not a bug.
The two implementations you are describing are different operators.
The one using the decorator and the function is a bit confusing, but it is correct. It makes sense because when you are implementing a circuit, the implementation is sequential from top to bottom. And when you write that in equation form, like the code output, the operations are applied onto the state from right to left, as U\vert\psi\rangle=RY(\phi)RX(\theta)\vert\psi\rangle.
We will make sure to improve the documentation for qml.prod so this is clear.

[HYW]

Hi Daniela,

Thnak you. Are there any commands/functions/decorators for tensor product in Pennylane? Something like U = qml.kron(RX,RY) such that U is formed by the tensor product of RX(0.3, wires=[1]) and RY(0.2, wires=[2]). I understand that the defined function “unitary(wires)” without the decorator “@qml.prod” is a tensor form itself.

HYW

[CatalinaAlbornoz]

Hi @HYW !

You can use “@”

Eg qml.PauliZ(0) @ qml.PauliZ(1) would give you the tensor product.

Is this what you were looking for?

[HYW]

Hi Catalina,

Thnak you. You are right. So the formula Daniela wrote is a “matrix multiplication” (Ry(phi) dot Rx(theta)) rather than a “tensor product” (Ry(phi) tp Rx(theta)).

I am now confused with the decorator @qml.prod that acts on the function. If the defined unitary(wires) function decorated with @qml.prod is a tensor product form, there is no so-called sequential actions because both rotation gates stay the same layer , i.e., “output state = (Ry tp Rx) dot input state” instead of “output state = Ry dot Rx dot input state”.

HYW

[daniela.murcillo]

Hi!
I understand the confusion since I didn’t specify the subsystems in which the rotations were to be applied to. It could have been a tensor product or a matrix multiplication, and qml.prod understands this. If the operators are applied to the same wire, then order matters and it is a matrix composition. But if they are to be applied to different wires, the tensor product takes place and the order wouldn’t matter (if and only if the operators apply to different wires, of course there could more complex and general cases and PennyLane handles them well). The documentation for qml.prod says “The generalized product operation represents both the tensor product as well as matrix composition. This can be resolved naturally from the wires that the given operators act on.”

[HYW]

Thank you for your reply!

[HYW]

Hi,

I am having trouble calculating angles using the following polynomial in PennyLane:

a = np.array([0.05892399, 0.0588961 , 0.05874494, 0.05877388, 0.05885096,

0.05881982, 0.05876688, 0.05880182, 0.0588432 , 0.05880182,

0.05876688, 0.05881982, 0.05885096, 0.05877388, 0.05874494,

0.0588961 , 0.05892399])

angles = qml.poly_to_angles(a, “GQSP”)

While I am unable to get the result with PennyLane, I can successfully calculate the angles using Classiq, which returns the following arrays:

(array([0.06343462, 0.072379 , 0.08109513, 0.089588 , 0.0973795 ,

0.10391662, 0.10889516, 0.11209859, 0.11322308, 0.11209859,

0.10889516, 0.10391662, 0.0973795 , 0.089588 , 0.08109513,

0.072379 , 1.50736171]),

array([-3.14159265e+00, -3.14159265e+00, -3.14159265e+00, -3.14159265e+00,

-3.14159265e+00, -3.14159265e+00, -3.14159265e+00, -3.14159265e+00,

-3.14159265e+00, -3.14159265e+00, -3.14159265e+00, -3.14159265e+00,

-3.14159265e+00, -3.14159265e+00, -3.14159264e+00, 1.04481339e-08,

0.00000000e+00]),

array([3.14159254, 0. , 0. , 0. , 0. ,

0. , 0. , 0. , 0. , 0. ,

0. , 0. , 0. , 0. , 0. ,

0. , 0. ]))

Could you please look into the PennyLane code to see why it is failing to process this input?

Thanks you.

[CatalinaAlbornoz]

Hi @HYW ,

Can you please share more details about the problem you’re having in generating the angles? I ran the code with PennyLane v0.44 and I get no errors. Is the problem that you’re getting an error, or is it that you’re expecting a different output?

If it’s an error, can you please share the full error traceback here?

[HYW]

Hi Catalina,

I believe there may be an issue within the internal code. When running the following using PennyLane and Classiq, I encountered an error message in PennyLane:

import pennylane as qml

from pennylane import numpy as np

from classiq.applications.qsp import gqsp_phases

a = np.array([0.0589239935160568024, 0.0588961045642827571, 0.0587449364005482935, 0.0587738794921155230, 0.0588509555995164330, 0.0588198248786198086, 0.0587668836827426114, 0.0588018197557002992, 0.0588432042208527906, 0.0588018197557015343, 0.0587668836827327165, 0.0588198248786164571, 0.0588509555995114231, 0.0587738794921151067, 0.0587449364005477662, 0.0588961045642827571, 0.0589239935160568579])

gqsp_phases(a)

qml.poly_to_angles(a, “GQSP”)

Could you please look into this?

Best,

[CatalinaAlbornoz]

Hi @HYW ,

It looks like you’re hitting a problem with a cutoff. Basically having so many decimals is what’s causing the problem. You can fix it by rounding them off to the 8th decimal as shown with the code below. Would this me enough for what you need, or do you absolutely need all of those additional decimals?

import pennylane as qml
import numpy as np

a = np.array([0.0589239935160568024, 0.0588961045642827571, 0.0587449364005482935, 
              0.0587738794921155230, 0.0588509555995164330, 0.0588198248786198086, 
              0.0587668836827426114, 0.0588018197557002992, 0.0588432042208527906, 
              0.0588018197557015343, 0.0587668836827327165, 0.0588198248786164571,
              0.0588509555995114231, 0.0587738794921151067, 0.0587449364005477662, 
              0.0588961045642827571, 0.0589239935160568579])

rounded_a = np.round(a, decimals=8)

qml.poly_to_angles(rounded_a, "GQSP")

I hope this helps and let me know if this fixes the problem!

[HYW]

Hi Catalina,

However, both rounded_a = np.round(a, decimals=7) and rounded_a = np.round(a, decimals=6) don’t work. I would need decimals=10 at least.

[CatalinaAlbornoz]

Hi @HYW,

Thanks for sharing this constraint. I’ll share this with our team so that they can investigate.
Please note that it may take a while for our team to look into this. At a first glance this seems like a tricky issue so it might be hard to find a solution. Thank you again for bringing this to our attention and we’ll get back to you as soon as we can.

Edit: actually I found a solution.

As the error and the docs state, the polynomial must satisfy that |P(x)| ≤ 1 for all x in [-1, 1].

In fact in the code this is checked for x=-1, x=0, and x=1 in line 1256.

In this line the code checks if math.abs(sum(coeff * x**i for i, coeff in enumerate(poly))) > 1. If this is true then you get the error that you’re seeing.

I tested this for your code with all of the decimals and I noticed that for x=1 the norm is 1.0. While this is technically within the allowed range, when you evaluate it at the numerical precision which is something like 1e-17, this is basically considered to be larger than one.

The quick and easy solution is to slightly modify your polynomial, for example shifting it slightly.

In the code below I subtract 1e-17 from the polynomial, basically shifting it ever so slightly, and this now avoids the error that you were seeing before!

This normally wouldn’t be an issue with most polynomials, but in this particular case since your polynomial was exactly one at the boundary that’s why it caused issues.

import pennylane as qml
import numpy as np

a = np.array([0.0589239935160568024, 0.0588961045642827571, 0.0587449364005482935, 
              0.0587738794921155230, 0.0588509555995164330, 0.0588198248786198086, 
              0.0587668836827426114, 0.0588018197557002992, 0.0588432042208527906, 
              0.0588018197557015343, 0.0587668836827327165, 0.0588198248786164571,
              0.0588509555995114231, 0.0587738794921151067, 0.0587449364005477662, 
              0.0588961045642827571, 0.0589239935160568579])

poly = a - 1e-17
for x in [-1, 0, 1]:
  print(f"x={x}, Norm:",qml.math.abs(sum(coeff * x**i for i, coeff in enumerate(poly))))

qml.poly_to_angles(poly, "GQSP")

Let me know if this solution works for you!