States and Probabilities | PennyLane Challenges

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

Challenge statement

In PennyLane, the fundamental unit of quantum circuit simulation is called a QNode. Basically, a QNode takes a quantum function—a Python function that contains instructions in the form of quantum gates acting on wires—and a device,then runs the function on the device, and returns a measurement. To see how this works, check out our YouTube video.

In this challenge, you need to simulate the following quantum circuit and return the resulting probability distribution as an output:

Challenge code

In the template code provided, you are given a function called circuit. You must complete this function by specifying a device, turning circuit into a QNode, and providing the appropriate gates.

Here are some helpful resources:

Input

As input to this problem, you are given two angles (list(float)). The first and second entries of angles correspond to and in the diagram above.

Output

This code must output the probabilities (numpy.tensor(float)) of measuring the output states and in that order resulting from the quantum circuit pictured above.

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: [1.23, 4.56]
expected_output: [0.28293, 0.38419, 0.14117, 0.19171]
test_input: [7.89, 0.12]
expected_output: [0.48026, 0.00173, 0.51614, 0.00186]

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

# Put your code here #

# Create a default.qubit device with 2 qubits / wires using qml.device

# Turn your circuit into a QNode

def circuit(angles):

"""

The quantum circuit that you will simulate.

Args:

angles (list(float)): The gate angles in the circuit.

Returns:

(numpy.tensor): The probability vector of the underlying quantum state

that this circuit produces.

"""

# Put the rotation gates here

return qml.probs(wires=[0, 1])

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

angles = json.loads(test_case_input)

output = circuit(angles).tolist()

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, rtol=1e-4)

# These are the public test cases

test_cases = [

('[1.23, 4.56]', '[0.2829251572359589, 0.3841937063262924, 0.1411749135148633, 0.1917062229228854]'),

('[7.89, 0.12]', '[0.48026161094775754, 0.001733099740534947, 0.5161427069791757, 0.0018625823325319265]')

]

# 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