Introduction to LCUs | PennyLane Challenges

To attempt this challenge, please switch to a larger screen size.

Challenge statement

This challenge is included in the QHack 2023 Flashback Badge Challenge event.

Suppose that we know a certain Hamiltonian can be written as a linear combination of unitaries, that is

We know that quantum circuits can implement unitary operations really easily, but is there a way to implement a sum of unitaries? Note that the sum of unitaries is not always a unitary, so how can we even do this? We can use measurements!

A circuit of the form

drawing

will probabilistically implement the combination of unitaries on the bottom (main) register, where and are positive real numbers, without loss of generality. Here, the single-qubit unitary is represented by the matrix

The combination will only be applied on the bottom (main) register when we measure the state of the top (auxiliary) register to be .

Your task is to calculate the probability that this the linear combination of unitaries is implemented with the circuit above.

Challenge code

You must complete the linear_combination function to build the above circuit that implements the linear combination

of two single-qubit unitaries U and V, and returns the probabilities on the auxiliary register. For simplicity, we take and to be positive real numbers.

As a helper function, you are also asked to complete the W function, which returns the unitary

Input

As input to this problem, you are given:

U (list(list(float))): A matrix representing the single-qubit unitary operator .
V (list(list(float))): A matrix representing the single-qubit unitary operator
alpha (float): The prefactor of in the linear combination, as above.
beta (float): The prefactor of in the linear combination, as above.

Output

The output used to test your solution is a float corresponding to the probability of measuring on the auxiliary register. This is the first element of your output of linear_combination. We will extract this element for you in our testing functions!

Test cases

The following public test cases are available to you. Note that there are additional hidden test cases that we use to verify that your code is valid in full generality.

test_input: [[[ 0.70710678,  0.70710678], 
[ 0.70710678, -0.70710678]],[[1, 0], [0, -1]], 1, 3]
expected_output: 0.8901650422902458

If your solution matches the correct one within the given tolerance specified in check (in this case it's a 1e-3 absolute error tolerance), the output will be "Success!". Otherwise, you will receive an "Incorrect" prompt.

Good luck!

import json

import pennylane as qml

import pennylane.numpy as np

def W(alpha, beta):

""" This function returns the matrix W in terms of

the coefficients alpha and beta

Args:

- alpha (float): The prefactor alpha of U in the linear combination, as in the

challenge statement.

- beta (float): The prefactor beta of V in the linear combination, as in the

challenge statement.

Returns

-(numpy.ndarray): A 2x2 matrix representing the operator W,

as defined in the challenge statement

"""

# Put your code here #

# Return the real matrix of the unitary W, in terms of the coefficients.

dev = qml.device('default.qubit', wires = 2)

@qml.qnode(dev)

def linear_combination(U, V, alpha, beta):

"""This circuit implements the circuit that probabilistically calculates the linear combination

of the unitaries.

Args:

- U (list(list(float))): A 2x2 matrix representing the single-qubit unitary operator U.

- V (list(list(float))): A 2x2 matrix representing the single-qubit unitary operator U.

- alpha (float): The prefactor alpha of U in the linear combination, as above.

- beta (float): The prefactor beta of V in the linear combination, as above.

Returns:

-(numpy.tensor): Probabilities of measuring the computational

basis states on the auxiliary wire.

"""

# Put your code here #

# Return the probabilities on the first wire

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

dev = qml.device('default.qubit', wires = 2)

ins = json.loads(test_case_input)

output = linear_combination(*ins)[0]

return str(output)

def check(solution_output: str, expected_output: str) -> None:

solution_output = json.loads(solution_output)

expected_output = json.loads(expected_output)

assert np.allclose(

solution_output, expected_output, atol=1e-3

), "Your circuit doesn't look quite right "

# These are the public test cases

test_cases = [

('[[[ 0.70710678, 0.70710678], [ 0.70710678, -0.70710678]],[[1, 0], [0, -1]], 1, 3]', '0.8901650422902458')

]

# This will run the public test cases locally

for i, (input_, expected_output) in enumerate(test_cases):

print(f"Running test case {i} with input '{input_}'...")

try:

output = run(input_)

except Exception as exc:

print(f"Runtime Error. {exc}")

else:

if message := check(output, expected_output):

print(f"Wrong Answer. Have: '{output}'. Want: '{expected_output}'.")

else:

print("Correct!")

or to submit your code