Revisiting Schrodinger's Cat | PennyLane Challenges

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

Challenge statement

This challenge was part of the Canadian Quantum Cup 2023 coding competition.

Schrodinger's cat has become a staple of pop culture, but very few people understand it properly. Even physicists get themselves confused! Let's recap the story we're usually told.

Inside a box, we have a radioactive atom, a contraption, and a cat. When the atom decays radioactively, it sends a signal that triggers the contraption, which kills the cat instantly. However, radioactive decay is a random quantum process. After a period of time equal to the atom's half-life, the state of the atom is

where is the undecayed state and is the decayed state. Therefore, after one half-life, the cat must be in a superposition

where represents a cat that is alive, and represents one that isn't. The cat inside the box is in a superposition of being alive and dead, which is something we don't see in real life!

This story is, however, not quite correct! According to an observer outside the box, the states of the atom and the cat evolve jointly, which means they are highly entangled systems. Indeed, they are strongly interacting systems—the very life of the cat depends on the state of the atom—so this is not surprising. Therefore, the actual picture is that, after a half-life, the whole atom-cat system inside the box is in the maximally entangled state

Therefore, the state of the cat is not a superposition, but it's instead described by the reduced density matrix

which does not correspond to , or any pure state for that matter.

Does this mean we cannot have cats in a superposition? We can, but we have to be a bit more careful with our experiment to obtain such an exotic being! We actually need to measure the state of the atom alone in the basis. Since the state can also be written as

measuring implies that the cat is in the state , a superposition of being alive and dead! This process is implemented by the following circuit.

Your task in this coding challenge is to answer a more general question. Given an arbitrary evolution operator for the joint atom-cat system, what basis do we have to measure the atom in to place the cat in a uniform superposition? Specifically, given an arbitrary unitary , you are asked to find a set of parameters , , and for the gate in the circuit below,

such that when the state is measured on the 'atom' wire, the state in the 'cat' wire is sure to be

Challenge code

In the code shown, you must complete one helper function:

evolve_atom_cat: a QNode that implements the unitary evolution on the atom-cat system, followed by an application of on the atom. The arguments of this function are:
- unitary (np.array(complex)): The matrix of the unitary evolution operator .
- params (list(float)): A list of three angles corresponding to the parameters of the U3 gate.
This function then returns the quantum state via qml.state() (np.tensor).

Then, you must complete the main function:

u3_parameters: Takes in a unitary describing the evolution operator and returns the list of parameters in that order such that, when is measured on the atom, the cat is guaranteed to be in a uniform superposition.

Input

As input to this problem, you are given:

unitary (np.array(complex)): The matrix of the unitary evolution operator .

Output

Although your function u3_parameters must output some parameters, these are not necessarily unique. For this reason, there is no definite output for this problem. Instead, the testing function will check whether your parameters satisfy the right condition for the cat's state, up to an absolute tolerance of in the components of the state.

Test cases

The following unitary matrices will be used to test your code. Note that we will test with additional hidden cases to verify that your solution works in full generality

test_input: [[ 0.70710678,  0 ,  0.70710678,  0], [0 ,0.70710678, 0, 0.70710678], [ 0,  0.70710678,  0, -0.70710678], [ 0.70710678,  0, -0.70710678,  0]]

test_input: [[-0.00202114,  0.99211964, -0.05149589, -0.11420469], [-0.13637119, -0.1236727, -0.30532593, -0.93428263], [0.89775373,  0.00794205, -0.363445,  0.24876274], [ 0.41885207, -0.01845563, -0.8786535,  0.22845207]]

Good luck!

import json

import pennylane as qml

import pennylane.numpy as np

dev = qml.device('default.qubit', wires = ['atom', 'cat'])

@qml.qnode(dev)

def evolve_atom_cat(unitary, params):

"""

Circuit that implements the evolution of the atom-cat system under the action of a unitary

and the change of basis in the atom wire before measuring.

Args:

unitary (np.array(complex)): The matrix of a 4x4 unitary operator.

params (list(float)): A list of three angles corresponding to the parameters

of the U3 gate

Returns:

(np.tensor): The state of the joint atom-cat system after unitary evolution.

"""

# Put your code here #

def u3_parameters(unitary):

"""

Find adequate parameters that yield a uniform position on the cat wire

when the atom wire is measured to be |0>.

Args:

unitary (np.array(complex)): The matrix of a 4x4 unitary operator.

Returns:

(np.array(float)): The parameters for the U3 change of basis that yield

a uniform superposition for the cat when the atom is measured in the

state |0>.

"""

# Put your code here #

# Return a set of parameters that satisfy the required condition

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

ins = json.loads(test_case_input)

output = u3_parameters(ins).tolist()

if np.isclose(evolve_atom_cat(ins,output)[0], evolve_atom_cat(ins,output)[1], atol = 5e-2):

return "Cat state generated"

return "Cat state not generated"

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

def unitary_circ():

qml.Hadamard(wires=0)

qml.CNOT(wires=[0,1])

U1 = qml.matrix(unitary_circ, wire_order=[0,1])()

assert np.isclose(evolve_atom_cat(U1,[1,1,1])[0], 0.62054458), "Your evolve_atom_cat circuit does not do what is expected."

assert solution_output == expected_output, "Your parameters do not generate a Schrodinger cat"

# These are the public test cases

test_cases = [

('[[ 0.70710678, 0 , 0.70710678, 0], [0 ,0.70710678, 0, 0.70710678], [ 0, 0.70710678, 0, -0.70710678], [ 0.70710678, 0, -0.70710678, 0]]', 'Cat state generated'),

('[[-0.00202114, 0.99211964, -0.05149589, -0.11420469], [-0.13637119, -0.1236727 , -0.30532593, -0.93428263], [0.89775373, 0.00794205, -0.363445 , 0.24876274], [ 0.41885207, -0.01845563, -0.8786535 , 0.22845207]]', 'Cat state generated')

]

# 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