Certificate Challenge: Introduction to PennyLane

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

Welcome to the Introduction to PennyLane certificate challenge. Upon completion of this challenge, you will receive a certificate that attests to your proficiency with the use of basic PennyLane functionalities. In particular, you should be able to

Define the quantum device that addresses your needs,
Create circuits that depend on real parameters,
Concatenate subcircuits into a larger QNode,
Return observable quantities.

Challenge statement

One of the main goals of Quantum Machine Learning is to come up with quantum circuits that produce a family of interesting models. Some quantum circuits that achieve this are of the following form

The blocks are known as trainable blocks and depend on some parameters collectively represented by the matrices The blocks are known as encoding blocks and depend on the input data . Let's take a look a these blocks separately.

The trainable blocks

The trainable blocks entangle the input qubits to allow for a larger number of possible outputs. For the purposes of this challenge, they are constructed by concatenating several layers of the form

For layers and wires, the full block reads

We will encode the rotation parameters shown in the figure in an matrix

In our model, we have training blocks. Each one has different parameters encoded in the matrices .

The encoding blocks

Let's now turn to the encoding blocks They all depend on the single input data , which we take to be a real number, and they're all of the form

where is a Hermitian matrix.

Your task in this challenge is to build the entire quantum model given a set of matrices , a data input and a generator .

Challenge code

To make your task more streamlined, the code is divided into three functions that you must complete.

First, you should complete the subcircuit W which, given a matrix params of real (float) parameters ( in the statement), constructs a single trainable block . As we saw above, the number of rows in params is equal to the number of trainable blocks, and the number of columns in params is equal to the number of wires used in the model.

Second, you should complete the subcircuit which takes in three arguments:

g (pennylane.Operator): A Hermitian PennyLane operator (such as qml.PauliX) which acts as the generator for the unitary .
x (float): The coefficient of the operator .
num_wires (int): The number of wires in this block.

Finally, you should define a device dev and build the quantum_model QNode that depends on the following:

param_set (np.array). A sequence of matrices which encode the parameters for each trainable block. The length of this list is equal to the number of trainable blocks, which is always greater than, or equal to 2.
g (pennylane.Operator): A Hermitian PennyLane operator (such as qml.PauliX) which acts as the generator for the unitary .
x (float): The coefficient of the operator .

This QNode should return the computational basis measurement probabilities on the first wire.

Input

As input to this problem, you are given:

param_set (np.array): An array of matrices, one for each encoding block in the circuit read from left to right. All of these matrices have the same number of columns, equal to the wires in the circuit. The number of rows may differ depending on the number of layers in each encoding block.
g (string): A string with the PennyLane name for the generator of the gates , for example, "PauliX". You don't need to parse this string into an operator, this is done for you by the grader. If you're curious about how this was done, look into the getattr Python function!
x (float): The coefficient of the operator .

Output

This code must output an np.array of shape (2,) corresponding to the computational basis measurement probabilities on the first wire for the entire quantum model.

Test cases

The following public test cases are available for you to check your work. There are also some hidden test cases that we will use to check that your solution works in full generality.

test_input = [[[1.0472, 0.7854, 3.1416, 0.3927],
               [1.0472, 0.7854, 3.1416, 0.5236]],
               [[1.0472, 0.7854, 1.5708, 0.3927],
               [0.7854, 0.7854, 1.5708, 0.7854]]],
               "PauliX",
               0.7854
expected_output = [0.46653, 0.53347]

expected_input = [[[0.62832, 0.3927, 1.0472, 0.7854],
                    [0.7854, 0.31416, 0.62832, 0.5236]],
                    [[0.31416, 0.7854, 0.7854, 0.3927],
                    [0.31416, 0.3927, 0.31416, 0.3927]]],
                "PauliY",
                0.5236
expected_output = [0.68594, 0.31406]

If your answer matches the exact answer up to an absolute error of the output will be "Success!". Otherwise, you will receive an "Incorrect" prompt.

import json

import pennylane as qml

import pennylane.numpy as np

def W(params):

"""

Subcircuit that implements the trainable block W

Args:

params (np.array): A matrix containing the parameters for the trainable block W. The length of

params is equal to the depth of the circuit. The length of each row in params is the number

of qubits used. See the challenge statement for a detailed explanation

Returns:

Since this function is a subcircuit, you must not return anything.

"""

# Put your code here

def S(g, x, num_wires):

"""

Subcircuit that implements the encoding block S

Args:

g (pennylane.Operator): A PennyLane operator representing the generator for the encoding

gates. It must be Hermitian in order to generate a unitary. Call it as g(wires) to specify

the wires on which it acts.

x (complex): The scalar coefficient of the operator g.

num_wires (int): The number of wires over which the encoding gate is broadcast.

Returns:

Since this function is a subcircuit, you must not return anything.

"""

# Put your code here

# Create a device

dev =

@qml.qnode(dev)

def quantum_model(param_set, g, x):

"""

This QNode implements the quantum model with alternating trainable and encoding blocks

Args:

param_set (np.array): A numpy array whose elements are the parameter matrices for each of the trainable

blocks. Therefore, the length of this list is equal to the number of trainable blocks, which is greater

than, or equal to 2.

g (pennylane.Operator): A PennyLane operator representing the generator for the encoding

gates. It must be Hermitian in order to generate a unitary.

x: The scalar coefficient of the operator g.

Returns:

(np.tensor(float)): A tensor of dimensions (2,) representing the measurement probabilities in the computational

basis on the first wire.

"""

# Put your code here

# These functions are used to test your solution

def run(test_case_input: str) -> str:

ins = json.loads(test_case_input)

params = np.array(ins[0])

g = getattr(qml, ins[1])

x = ins[2]

outs = quantum_model(params, g, x).tolist()

return str(outs)

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

solution_output = json.loads(solution_output)

expected_output = json.loads(expected_output)

dev_test = qml.device("default.qubit", wires = [0,1,2])

@qml.qnode(dev_test)

def w_node(params):

W(params)

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

@qml.qnode(dev_test)

def s_node(g, x, num_wires):

S(g, x, num_wires)

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

params_test = np.array([[np.pi, np.pi/4, np.pi],[np.pi, np.pi/4, np.pi/3]])

w_test = w_node(params_test)

s_test = s_node(qml.PauliX, np.pi/7, 3)

assert np.allclose(w_test, [0.10983496, 0.21338835, 0.03661165, 0.64016504], atol = 1e-3), "Something isn't quite right with the trainable block."

# These are the public test cases

test_cases = [

('[[[[1.0472, 0.7854, 3.1416, 0.3927],[1.0472, 0.7854, 3.1416, 0.5236]],[[1.0472, 0.7854, 1.5708, 0.3927],[0.7854, 0.7854, 1.5708, 0.7854]]],"PauliX", 0.7854]', '[0.46653, 0.53347]'),

('[[[[0.62832, 0.3927, 1.0472, 0.7854],[0.7854, 0.31416, 0.62832, 0.5236]],[[0.31416, 0.7854, 0.7854, 0.3927],[0.31416, 0.3927, 0.31416, 0.3927]]],"PauliY", 0.5236]', '[0.68594, 0.31406]')

]

# 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