An Itch to Switch | 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.

Did you know that there is no way for us to clone a quantum state? The no-cloning theorem states that there is no gate such that

for all states . However, if we only work with basis states , there exist operations such that

Zenda and Reece are each in possession of one basis state, which we denote and respectively. Their PhD supervisor, Dr. Trine, tells them to send each other their basis state without losing their own. "If basis states can be cloned, then surely we can do this", claims Zenda confidently. "Just give us two qubits in the state to each of us and we're good to go."

Trine thinks about this... "It's too easy if I allow you to do whatever you want"—she concludes. "Let's make it more fun. I'll give you each one qubit from a Bell state

"Then you'll have to send your qubit to each other by acting only on the qubits in your possession."

Zenda and Reece try and try, but it seems like a futile task. "We need more resources—mumbles Reece. "Mmm... disappointing" says Trine. "Then, I'll allow you to use a magic gate between your initially entangled qubits, but figure it out fast!"

In this challenge, you will help Zenda and Reece figure out a quantum circuit that performs the operation

with the constraints imposed by Trine. This means that the circuit must be of the form shown in the image below.

In the above, is the operator Zenda applies on her qubits, is the operator Reece applies on his qubits, and is the magic operator provided by Trine.

Challenge code

In the code below, you are given a number of functions:

zenda_operator: Quantum function corresponding to the operator to be applied by Zenda on her qubits. You must complete this function.
reece_operator: Quantum function corresponding to the operator to be applied by Reece on his qubits. You must complete this function.
magic_operator: The magic operator provided by Trine to be applied on the initially entangled qubits and . You must complete this function.

Inputs and outputs

There are no inputs nor outputs for this challenge. You answer will be judged based on the fact that your circuit produces the correct final state for any combination of basis states and . This will be verified in the check function.

import json

import pennylane as qml

import pennylane.numpy as np

def zenda_operator():

"""

Quantum function corresponding to the operator to be applied by

Zenda in her qubits.This function does not return anything,

you must simply write the necessary gates.

"""

# Put your code here #

def reece_operator():

"""

Quantum function corresponding to the operator to be applied by

Reece in his qubits.This function does not return anything,

you must simply write the necessary gates.

"""

# Put your code here #

def magic_operator():

"""

Quantum function corresponding to the operator to be applied on the "z1"

and "r1" qubits. This function does not return anything, you must

simply write the necessary gates.

"""

# Put your code here #

def bell_generator():

"""

Quantum function preparing bell state shared by Reece and Zenda.

"""

qml.Hadamard(wires=["z1"])

qml.CNOT(wires=["z1", "r1"])

dev = qml.device("default.qubit", wires=["z0", "z1", "r1", "r0"])

@qml.qnode(dev)

def circuit(j, k):

bell_generator()

# j encoding and Zenda operation

qml.BasisEmbedding([j], wires="z0")

zenda_operator()

# k encoding and Reece operation

qml.BasisEmbedding([k], wires="r0")

reece_operator()

magic_operator()

return qml.probs(wires=dev.wires)

# 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:

try:

dev1 = qml.device("default.qubit", wires = ["z0", "z1"])

@qml.qnode(dev1)

def circuit1():

zenda_operator()

return qml.probs(dev1.wires)

circuit1()

except:

assert False, "zenda_operator can only act on z0 and z1 wires"

try:

dev2 = qml.device("default.qubit", wires = ["r0", "r1"])

@qml.qnode(dev2)

def circuit2():

reece_operator()

return qml.probs(dev2.wires)

circuit2()

except:

assert False, "reece_operator can only act on r0 and r1 wires"

try:

dev3 = qml.device("default.qubit", wires = ["z1", "r1"])

@qml.qnode(dev3)

def circuit3():

magic_operator()

return qml.probs(dev3.wires)

circuit3()

except:

assert False, "magic_operator can only act on r1 and z1 wires"

# 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