Returning Expectation Values | PennyLane Challenges

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

Review of quantum circuits in PennyLane

Skip to Challenge statement if you are already familiar with simple quantum circuits in PennyLane.

If you're new to PennyLane, this is the perfect coding challenge for you! In this challenge, you will build a simple PennyLane circuit.

Central to PennyLane is the QNode, or Quantum Node. This object combines:

A device
A quantum function
Any additional configuration information

We first need a device. The device evaluates a quantum function. It could be either a simulator or actual quantum hardware. For the purpose of this coding challenge, we use "default.qubit", a simple built-in simulator that does not require external dependencies. To initialize a "default.qubit" device, we also need to specify the number of wires.

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

Usually, a wire is just a qubit. Any hashable object can label a wire, but people often denote individual wires by numbers (0, 1, 2) or strings ("alice", "auxiliary").

Quantum functions accept classical inputs, apply quantum operations, and return one or more quantum measurement statistics. We write quantum functions as plain, old Python functions, but with some constraints; the function always needs to return a measurement.

We can put these components together to see the required structure of a quantum function:

def my_quantum_function(param):
    qml.PauliZ(wires=0) # a single-wire gate
    qml.RX(param, wires=0) # a single-wire parameterized gate
    qml.CNOT(wires=[0, 1]) # a two-wire gate

    # Finally we return a measurement of an operator on a wire
    return qml.expval(qml.PauliX(0))

While quantum functions look like Python functions, you can't call my_quantum_function on its own and have the described circuit executed. We instead have to call a QNode, an object containing both a quantum function and a device.

To quickly create a qnode, we apply a decorator that modifies the quantum function. The decorator takes the function as input and spits out something new that we can evaluate.

@qml.qnode(dev)
def my_quantum_function(param):
    qml.PauliZ(wires=0) # a single-wire gate
    qml.RX(param, wires=0) # a single-wire parameterized gate
    qml.CNOT(wires=[0, 1]) # a two-wire gate

    # Finally we return a measurement of an operator on a wire
    return qml.expval(qml.PauliX(0))

result = my_quantum_function(0.1)

Challenge statement

You are tasked with calculating the expectation value for a measurement of a rotated qubit. To achieve this, you will need to

define a device
create a quantum function and QNode
run the circuit

The quantum function in the second step should:

Rotate the qubit around the y-axis by an angle using qml.RY
Return the expectation value qml.expval of qml.PauliX

Here is a drawing of the circuit you should code.

For those that prefer to see the mathematics, we can write the problem as:

Challenge code

In the code shown, you must complete the simple_circuit function, which takes the argument angle (float)—corresponding to in the challenge statement above— and returns a float corresponding the expectation value of the Pauli operator.

Additionally, you must complete some lines to define a PennyLane device and add a decorator to define a QNode.

Here are some helpful resources and hints:

Input

The simple_circuit function is a QNode that receives one float angle, corresponding to the rotation angle in the gate.

Output

The expected output is a float corresponding to the expectation value of the Pauli operator.

Note: Although the qml.expval measurement returns an np.tensor containing one float, you don't need to worry about extracting it. We will do this for you.

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.23456
expected_output: 0.9440031218347901
test_input: 2.957
expected_output: 0.1835461227247332

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

# Step 1: initialize a device

dev = # Put your code here #

# Step 2: Add a decorator below

def simple_circuit(angle):

"""

In this function:

* Rotate the qubit around the y-axis by angle

* Measure the expectation value of the Pauli X observable

Args:

angle (float): how much to rotate a state around the y-axis

Returns:

Union[tensor, float]: The expectation value of the Pauli X observable

"""

# Step 3: Add gates to the QNode

# Put your code here #

# Step 4: Return the required expectation value

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

angle = json.loads(test_case_input)

output = simple_circuit(angle)

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.23456', '0.9440031218347901'),

('2.957', '0.1835461227247332')

]

# 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