Recoherence | 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.

One of the reasons why building a quantum computer is so difficult is due to the phenomenon known as decoherence, by which quantum states are lost due to interaction with the environment. Loosely speaking, decoherence means that a pure quantum state becomes mixed when it interacts with other states.

To understand decoherence more deeply, let us consider a system of 5 spins interacting with their nearest neighbours, with the geometry shown below.

Their interaction is described by the Hamiltonian

where labels the central spin and labels the spins around it. The force of the interaction between the central spin and spin is encoded in the coupling constants , which may not be all equal.

After interacting with the spins via for a time , the state of the central spin will be, in general, a mixed state. However, at certain specific times, the state will be pure again! That is, if you plot the purity of the state against time, you would see something like the plot below.

In this challenge, you will study the evolution of the purity of the central spin as it interacts with the spins around it via the Hamiltonian . Assuming that the initial state for spin is given by

where , , , , and you are asked to

Create a QNode evolve_state that returns the density matrix of the central spin after it evolves under for a time
Create a function purity that calculates the purity of a density matrix.
Build a function recoherence_time that estimates the recoherence time, which is the first time at which the purity of the central spin's state becomes 1 again.

You'll see that this time is relatively short in the scale we are working in. However, if we had a lot of spins (say ), this recoherence time would be many times larger than the age of the universe. This is why we don't see macroscopic states randomly recohere. We won't live long enough to see it!

Challenge code

In the code below, you must complete two helper functions:

evolve_state: a QNode that calculates the density matrix (np.tensor) of the central spin after evolving the initial state given above for a time time (float) under the action of . The list coeffs (list(float)) of coupling constants is also an input for this function.
purity: a function that returns the purity (float) of a density matrix rho (array(array(complex))).

Then, you must complete the main function:

recoherence_time: a function that returns the first time (float) in which the purity of the central spin's state is equal to one again. This function takes the list coeffs (list(float)) of coupling constants as an argument.

Input

As input to this problem, you are given:

coeffs (list(float)): The list of coupling constants

Output

This code must output a float corresponding to the recoherece time of the central spin.

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: [5,5,5,5]
sample_output: 0.314

test_input: [1.1,1.3,1,2.3]
sample_output: 15.71

Your answer must match the exact answer up to a relative error of

Good luck!

import json

import pennylane as qml

import pennylane.numpy as np

dev = qml.device("default.qubit", wires=5)

@qml.qnode(dev)

def evolve_state(coeffs, time):

"""

Args:

coeffs (list(float)): A list of the coupling constants g_1, g_2, g_3, and g_4

time (float): The evolution time of th system under the given Hamiltonian

Returns:

(numpy.tensor): The density matrix for the evolved state of the central spin.

"""

# We build the Hamiltonian for you

operators = [

qml.PauliZ(0) @ qml.PauliZ(1),

qml.PauliZ(0) @ qml.PauliZ(2),

qml.PauliZ(0) @ qml.PauliZ(3),

qml.PauliZ(0) @ qml.PauliZ(4),

]

hamiltonian = qml.dot(coeffs, operators)

# Put your code here #

# Return the required density matrix.

def purity(rho):

"""

Args:

rho (array(array(complex))): An array-like object representing a density matrix

Returns:

(float): The purity of the density matrix rho

"""

# Put your code here

# Return the purity

def recoherence_time(coeffs):

"""

Args:

coeffs (list(float)): A list of the coupling constants g_1, g_2, g_3, and g_4.

Returns:

(float): The recoherence time of the central spin.

"""

# Return the recoherence time

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

params = json.loads(test_case_input)

output = recoherence_time(params)

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.isclose(solution_output, expected_output, rtol=5e-2)

# These are the public test cases

test_cases = [

('[5,5,5,5]', '0.314'),

('[1.1,1.3,1,2.3]', '15.71')

]

# 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