# PennyLane Challenge: Universality of single-qubit gates

I have implemented the error function as

def error(U, params):
matrix = get_matrix(params)
z = np.ravel(np.square(np.abs(U - matrix)))
z = np.sum(qml.math.toarray(z))
return z.item()


which is \displaystyle\sum_i\sum_j|U_{ij}-M_{ij}|^2.

With the given seed, the optimization passes the [[1, 0], [0, -1]] case rather easily, but fo test case [[0.70710678, 0.70710678], [0.70710678, -0.70710678]] with this error function the optimization does not converge fast enough.

I have also tried with taking max instead of sum but still, even though they are good enough to pass the [[1, 0], [0, -1]] case the other case still does not converge.

    matrix = get_matrix(list(params))
z = qml.math.toarray(np.max(np.abs((np.ravel(U - matrix)))))
return z.item()


Any hints would appreciated.

Hi @LdBeth ,

It’s much simpler than that. You don’t need to use np.ravel or many of the other things you’re using. You want U and matrix to be the same. What’s the simplest way that you can calculate a single number that tells you how different these two matrices are? The solution isn’t fancy but it works!

I hope this helps.

I have to hand roll these because the most obvious to me np.linalg.norm does not work here,

Runtime Error: Failed to execute run() function: loop of ufunc does not support argument 0 of type ArrayBox which has no callable sqrt method


If norm doesn’t work, I guess I should go for trace the of differences?

I think I know it is using the autograd package to compute the derivative but unfortunately I have no clue on where I can learn what functions are supported and apparently not all numpy function are included, for example sqrt.

Thanks, and it turns out the fault is not cause by my error function, in fact \sum_i\sum_j|U_{ij}-M_{ij}|^2 is the correct way to go and my first error function is almost correct. (and it is certainly fine to use np.ravel.

The issue is with my get_matrix implementation, for some strange beliefs I wrote np.matmul(rz2, rx, rz1), although give a (2, 2) shaped array, which turns out is not the same as (rz2 @ rx @ rz1), after fixed this all tests are passed.

As a suggestion, maybe it would be better if additional checks to the get_matrix result is added

I’m glad you solved it @LdBeth ! And thanks for the suggestion, I will share it with our team.

Oh, I forget to check the private test, which failed without revealing the reason why it has failed, and I now I have really no clues. My implementation is attached below.

def get_matrix(params):
alpha, beta, gamma, phi = params

a, b = np.cos(beta / 2), -1j * np.sin(beta / 2)
rx = np.matrix([[a, b], [b, a]])
rz1 = np.matrix([[np.exp(-1j * alpha / 2), 0], [0, np.exp(1j * alpha / 2)]])
rz2 = np.matrix([[np.exp(-1j * gamma / 2), 0], [0, np.exp(1j * gamma / 2)]])
return np.exp(1j * phi) * (rz2 @ rx @ rz1)

def error(U, params):
# Put your code here #
# Return the error
return sum(sum(qml.math.toarray(np.square(np.abs(U-matrix)))))


Hi @LdBeth ,

For the get_matrix function you can use qml.RZ() and qml.RX() to create a unitary. Then you can use qml.matrix() to turn that unitary into a matrix.

For the error you don’t need to square it or turn it into an array.

1 Like

I see, thanks! So that is all because the matrices I manually computed has caused much worse autograd performance, which gives more than 0.01 difference in the optimized result and failed to converge for other tests.

That could be it @LdBeth !

Hello,
My code outputs the wrong answer and I still pass the test ? Can someone help me understand why ?

Here is my get_matrix

alpha, beta, gamma, phi = params

# Put your code here #
RX_matrix = qml.matrix(qml.RX(beta, 0))
RZ_matrix_gamma = qml.matrix(qml.RZ(gamma, 0))
RZ_matrix_alpha = qml.matrix(qml.RZ(alpha, 0))

U = np.exp(1j*phi)*RZ_matrix_gamma@RX_matrix@RZ_matrix_alpha

# Return the matrix
return U


and my err

err = np.sum(np.abs(U-matrix))
return err


This is my output

Test 1 of 2 passed! ✅
Input: [[ 1,  0], [ 0, -1]]
Expected output: [[ 1,  0], [ 0, -1]]
Solution output: [1.6892801452045216, -0.0015257310053992737, 1.4371410130382238, 1.5707963267948966]
Failure message: null

Test 2 of 2 passed! ✅
Input: [[ 0.70710678,  0.70710678], [ 0.70710678, -0.70710678]]
Expected output: [[ 0.70710678,  0.70710678], [ 0.70710678, -0.70710678]]
Solution output: [1.570570205712601, 1.5707931060347167, 1.5648959446953452, 1.5707944021778046]
Failure message: null


Hi @yoshypdf ,

Thank you for pointing this out!
I think what’s happening is that the Solution output is showing the params while the Expected output is showing the matrix.

So even though your solution output and expected output don’t match, the solution seems indeed to be correct.

I’m not sure if/how we can fix it but at least it’s good to be aware of this issue. Thanks for making this post!