Comparing Expectation Values | PennyLane Challenges

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

Challenge statement

In this coding challenge, you are asked to construct two circuits that perform two rotations on one qubit and then measure the expectation value of the Pauli observable. The two circuits you need to implement are pictured in the figure below.

We can see that the circuits implement the same operations, but in a different order. Your task is to measure how different the outputs of both circuits are by calculating the quantity

NOTE: Sometimes we think that non-commutativity is exclusive to quantum mechanics. But classical rotations do not commute either, so the commutativity of unitaries is not actually quantum per se. It is the non-commutativity of measurements that is an exclusively quantum phenomenon, and what gives rise to the unintuitive quantum behaviours.

You are asked to create two separate quantum functions that define the two circuits in the figure above, which we call circuit1 (top circuit in the figure) and circuit2 (bottom circuit in the figure). Namely, the circuits perform the following operations:

circuit1: Rotates the qubit via the gate (qml.RX), then via the gate (qml.RY), and finally outputs (using qml.expval(qml.PauliX(0))).
circuit2: Rotates the qubit via the gate (qml.RY), then via the gate (qml.RX), and finally outputs (using qml.expval(qml.PauliX(0))).

The code contains a function compare_circuits that you need to complete. Specifically, the completed compare_circuits function should process the results from both circuits to return the absolute value of the difference between the circuit outputs:

Challenge code

In the code template shown, you must complete the following helper functions:

circuit1: which takes an array of the two angles and returns the expectation value
circuit2: which takes an array of the two angles and returns the expectation value

Then, you must complete the main function compare_circuits, which processes the outputs of circuit1 and circuit2.

compare_circuits: which takes an array and returns

Input

As an input to this problem, you are given the array , as an np.array(float).

Output

The code must output a float corresponding to the absolute value of the difference between the circuit outputs.

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: [3.79894785, 0.71678115]
expected_output: 1.177019
test_input: [5.88344281, 0.30672784]
expected_output: 0.023805

If your solution matches the correct one within the given tolerance specified in check (in this case it's a 1e-4 relative 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

dev = # Define your device

@qml.qnode(dev)

def circuit1(angles):

"""

A Qnode implementing the circuit shown in the top part of the image

Args:

angles (np.ndarray(float)): A list [theta_1, theta_2] of angle

parameters for the RX and RY gates respectively

Returns:

(np.tensor): The expectation value of the PauliX observable

"""

# Put your code here #

# Return the expectation value

@qml.qnode(dev)

def circuit2(angles):

"""

A Qnode implementing the circuit shown in the bottom part of the image

Args:

angles (np.ndarray(float)): A list [theta_1, theta_2] of angle

parameters for the RX and RY gates respectively

Returns:

(np.tensor): The expectation value of the PauliX observable

"""

# Put your code here #

# Return the expectation value

def compare_circuits(angles):

"""

Given two angles, compare two circuit outputs that have their order of

operations flipped: RX then RY VERSUS RY then RX.

Args:

angles (np.ndarray(float)): An array of two angles [theta_1, theta_2]

Returns:

(float): The absolute value of the difference between the expectation

values of the circuits.

"""

# Put your code here #

# Return the required difference in expectation values

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

ins = json.loads(test_case_input)

output = compare_circuits(ins)

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.isclose(solution_output, expected_output, rtol=1e-4)

# These are the public test cases

test_cases = [

('[3.79894785, 0.71678115]', '1.177019'),

('[5.88344281, 0.30672784]', '0.023805')

]

# 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