Undo that Computation | 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.

Some classical logical operations are irreversible. For instance,

so given that , we can't tell the values of and

Put differently, there is no way to press ctrl-Z and learn what went in! In contrast, quantum circuits are built out of unitary gates, which are always reversible. We can always press ctrl-Z! How can we encode something irreversible, like an AND gate, into a quantum circuit? Aptly, the answer is a controlled gate! It encodes the classical operation into a phase:

A phase by itself is unobservable, so we need to interfere this state with some others to detect it. A simple way to do this is to use a controlled controlled gate, with some extra operations on either side:

In this challenge, you are asked to figure out which operations to apply so that measurement on the first qubit is guaranteed to be in state

Challenge code

In the code below, you are given a function called AND(j, k). You must complete this circuit and provide gates which implement a classical AND gate. More precisely, if the second and third qubits are in states and , the circuit should place the first qubit in state

Inputs

As input to this problem, you are given two bits j (int) and k (int), encoded onto the second and third qubits for you.

Output

Your circuit must place the first qubit in basis state AND(j, k). This will be checked using qml.probs(wires = 0), which gives [1, 0] for and [0, 1] for

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: [0, 0]
expected_output: [1, 0]
test_input: [1, 1]
expected_output: [0, 1]

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 = qml.device("default.qubit", wires=3)

@qml.qnode(dev)

def AND(j, k):

"""Implements the AND gate using quantum gates and computes j AND k.

Args:

j (int): A classical bit, either 0 or 1.

k (int): A classical bit, either 0 or 1.

Returns:

float: The probabilities of measurement on wire 0.

"""

if j == 1:

qml.PauliX(wires=1)

if k == 1:

qml.PauliX(wires=2)

# Put your code here #

qml.ctrl(qml.PauliZ, control =[0, 1])(wires = [2])

# Your code here #

return qml.probs(wires=0)

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

j, k = json.loads(test_case_input)

output = AND(j, k).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), "Your classical operation isn't behaving correctly!"

# These are the public test cases

test_cases = [

('[0, 0]', '[1, 0]'),

('[1, 1]', '[0, 1]')

]

# 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