The False Proof | 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.

In the 17th century, a nice custom spread among intellectuals: challenging each other to solve numerical problems and puzzles. These challenges were sent through letters and, thanks to this, mathematics expanded and gained a lot of popularity.

It seems that this tradition is making a comeback because the other day Reece received the following letter at the office:

"I have just come to a discovery of great importance, I have just proved that I attach a simple proof. If you think I'm wrong, prove it!*"

drawing

Actually, the proof is very convincing, but Reece turns to quantum computing to show that this is not so (for fun, if you like math: find the line where the mistake is!). To do this, Reece manages to show that is different from In fact, they are so different that a single shot is enough to distinguish them!

This will be your objetive for this challenge! We are going to give you a gate , which you know is either or Your task will be to build a quantum circuit containing to unambiguously determine which of the two gates it is using only one shot.

To do this, you will have access to a two-qubit circuit. You can use as many times as you want, but one thing is important: the solution must guarantee with 100% probability which of the two options it is.

Note: even if you do not know , you are allowed to use qml.ctrl over if necessary.

Challenge code

On one hand you are asked to complete circuit (you only need to apply gates). On the other hand you must complete process_output, which will take the output of circuit (a vector of dimension two where each term can take the value 0 or 1) and will return 2 if or 4 if

Output

The circuit function will receive the gate that you are asked to determine. To judge whether your circuit works as expected, we will randomly send 5000 different examples and check that they always classified correctly. Therefore, in this question there are no public or private test cases. They are randomly generated. Good luck!

import json

import pennylane as qml

import pennylane.numpy as np

dev = qml.device("default.qubit", wires=2, shots=1)

@qml.qnode(dev)

def circuit(U):

"""This will be the circuit you will use to determine which of the two angles we have.

Remember that only a single shot will be executed.

Args:

U (qml.ops): It is the gate to discriminate between RY(2pi/3) or RY(4pi/3).

Returns:

(numpy.tensor): Vector of two elements representing the output measured in each of the qubits.

"""

# Put your code here #

# to use U, call 'U(wires = <wire where you want to apply the gate>)'

# to use Control-U, call 'qml.ctrl(U, control = <control wire>)(wires = <wire where you want to apply the gate>)'

return qml.sample(wires=range(2))

def process_output(measurement):

"""This function processes the output of the circuit to discriminate between gates.

Args:

measurement (numpy.array): Output of the previous circuit a vector of dimension 2.

Returns:

(int): return 2 or 4 depending on the associated RY gate.

"""

# Put your code here #

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

return None

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

numbers = 2 * np.random.randint(1, 3, 5000)

def U2(wires):

class op(qml.operation.Operator):

num_wires = 1

def compute_decomposition(self, wires):

raise ValueError("You cannot decompose this gate")

def matrix(self):

return qml.matrix(qml.RY(2 * np.pi / 3, wires=3))

op(wires=wires)

return None

def U4(wires):

class op(qml.operation.Operator):

num_wires = 1

def compute_decomposition(self, wires):

raise ValueError("You cannot decompose this gate")

def matrix(self):

return qml.matrix(qml.RY(4 * np.pi / 3, wires=3))

op(wires=wires)

return None

output = []

for i in numbers:

if i == 2:

# These are the public test cases

test_cases = [

('No input', 'No output')

]

# 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