A Noisy Heisenberg Model | 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.

Consider a spin chain that contains particles of spin in each of its sites. We make this model more realistic by assuming that the spins may be pointing in any direction, and we consider that there may be an external magnetic field acting on the system.

When we model a closed spin chain of length in which spins can point in any direction, we need to use the Heisenberg Hamiltonian. In the presence of an external magnetic field of intensity , the Hamiltonian is given by

The subindices indicate the spin site where the operators act. In a closed spin chain, we identify site with the first site. The coefficients , and are known as coupling constants and they measure the strength of the interaction between neighbouring spins.

We would like to estimate how the noise affects Hamiltonian evolution. Your task is to build a Trotterization circuit that simulates . This circuit must only contain , , , and gates. Moreover, to make the Trotterization more realisitc, we will introduce noise on the target qubit of every execution of a CNOT gate. We model this via a Depolarizing Channel with parameter . To quantify the effects of noise, you are asked to find the fidelity between this noisy Trotterization and the noiseless one.

Challenge code

You must complete the heisenberg_trotter that implements the Trotterization of the Heisenberg Hamiltonian for using only the following PennyLane gates: qml.RX qml.RY, qml.RZ, qml.CNOT, and qml.DepolarizingChannel. This function will return a quantum state. You should also minimize the number of CNOT gates as much as you can, in order to avoid noise. To verify that the that the Trotterization that you proposed is not excessively noisy, we will calculate for you the fidelity of your output state with respect to the noiseless case using the calculate_fidelity function.

Input

As input to this problem, you are given:

couplings (list(float)): An array of length 4 that contains the coupling constants and the magnetic field strength, in the order .
p (float): The depolarization probability on the target qubit after each CNOT gate.
depth (int): The Trotterization depth.
time (float): Time during which the state evolves.

Output

This code will output a float corresponding to the fidelity between the output states of the noisy and noiseless trotterizations, calculated from the output of heisenberg_trotter. The outputs in the test cases correspond to the minimal fidelity that you should achieve if you used a small enough amount of CNOT gates.

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: [[1,2,1,0.3],0.05,2.5,1]
expected_output: 0.33723981123369573
test_input: [[1,3,2,0.3],0.05,2.5,2]
expected_output: 0.15411351752086694

If your fidelity is larger, up to a tolerance of 0.005, of that specified in the output cases, 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

num_wires = 4

dev = qml.device("default.mixed", wires=num_wires)

@qml.qnode(dev)

def heisenberg_trotter(couplings, p, time, depth):

"""This QNode returns the final state of the spin chain after evolution for a time t,

under the Trotter approximation of the exponential of the Heisenberg Hamiltonian.

Args:

couplings (list(float)):

An array of length 4 that contains the coupling constants and the magnetic field

strength, in the order [J_x, J_y, J_z, h].

p (float): The depolarization probability after each CNOT gate.

depth (int): The Trotterization depth.

time (float): Time during which the state evolves

Returns:

(numpy.tensor): The evolved quantum state.

"""

# Put your code here #

return qml.state()

def calculate_fidelity(couplings, p, time, depth):

"""This function returns the fidelity between the final states of the noisy and

noiseless Trotterizations of the Heisenberg models, using only CNOT and rotation gates

Args:

couplings (list(float)):

A list with the J_x, J_y, J_z and h parameters in the Heisenberg Hamiltonian, as

defined in the problem statement.

p (float): The depolarization probability of the depolarization gate that acts on the

target qubit of each CNOT gate.

time (float): The period of time evolution simulated by the Trotterization.

depth (int): The Trotterization depth.

Returns:

(float): Fidelity between final states of the noisy and noiseless Trotterizations

"""

return qml.math.fidelity(heisenberg_trotter(couplings,0,time, depth),heisenberg_trotter(couplings,p,time,depth))

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

ins = json.loads(test_case_input)

output =calculate_fidelity(*ins)

return str(output)

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

"""

Compare solution with expected.

Args:

solution_output: The output from an evaluated solution. Will be

the same type as returned.

expected_output: The correct result for the test case.

Raises:

``AssertionError`` if the solution output is incorrect in any way.

"""

def create_hamiltonian(params):

couplings = [-params[-1]]

ops = [qml.PauliX(3)]

for i in range(3):

couplings = [-params[-1]] + couplings

ops = [qml.PauliX(i)] + ops

for i in range(4):

couplings = [-params[-2]] + couplings

ops = [qml.PauliZ(i)@qml.PauliZ((i+1)%4)] + ops

# These are the public test cases

test_cases = [

('[[1,2,1,0.3],0.05,2.5,1]', '0.33723981123369573'),

('[[1,3,2,0.3],0.05,2.5,2]', '0.15411351752086694')

]

# 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