A Shor Thing | 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.

Quantum computational advantage — the ability of quantum computers to perform certain tasks faster than the best classical computers — has now been demonstrated in a number of cases. Arguably, the next big milestone in quantum computing is fault-tolerance for large-scale devices, allowing them to correct errors that crop up as a result of noisy interactions with the environment or between parts of the computer.

The early years of quantum error correction yielded several ground-breaking protocols, none more famous than Peter Shor's 9-qubit-code, pictured below.

In this challenge, you will implement Shor's code for an arbitrary initial state that is subject to an error.

Challenge code

In the code below, you are given a couple functions:

shor: a QNode that contains the operations required to define Shor's code given an initial state and an error occuring in the middle of the circuit. It must output the expectation value of the Pauli Z operator on each qubit. You must complete this function.
error: this function contains the error operator that will be introduced into the circuit you create with shor. The possible errors are Pauli X, Y, and Z errors (see error_dict in the code). To call this within shor, simply write error(error_key, qubit) and it will apply the error!

Here are some helpful resources:

Input

As input to this problem, you are given:

state (list(float)): defines the initial one-qubit state . The remaining 8 qubits are initialized in the state.
error_key (int): an integer corresponding to a Pauli X, Y, or Z error. See error_dict.
qubit (int): an integer corresponding to which qubit the error will occur on.

Output

This code must output a list(float) corresponding to the expectation values of the Pauli Z operator on every qubit.

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, 1], 0, 3]
expected_output: [-1.0,  1.0,  1.0,  1.0, -1.0, -1.0,  1.0,  1.0,  1.0]
test_input: [[0.5, 0.8660254038], 2, 1]
expected_output: [-0.5, 1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0]

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

n_qubits = 9

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

error_dict = {0: 'PauliX', 1: 'PauliY', 2: 'PauliZ'}

def error(error_key, qubit):

"""Defines the error that is induced in the circuit.

Args:

error_key (int): An integer associated to the type of error (Pauli X, Y, or Z)

qubit (int): The qubit that the error occurs on.

"""

getattr(qml, error_dict[error_key])(qubit)

@qml.qnode(dev)

def shor(state, error_key, qubit):

"""A circuit defining Shor's code for error correction.

Args:

state (list(float)): The quantum state of the first qubit in the circuit.

error_key (int): An integer associated to the type of error (Pauli X, Y, or Z)

qubit (int): The qubit that the error occurs on.

Returns:

(list(float)): The expectation value of the Pauli Z operator on every qubit.

"""

qml.StatePrep(np.array(state), wires=0)

# Put your code here #

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

state, error_key, qubit = json.loads(test_case_input)

outs = [round(float(elem), 1) for elem in shor(state, error_key, qubit)]

output = [outs[i] for i in dev.wires]

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), "Incorrect result for expectation values."

# These are the public test cases

test_cases = [

('[[0, 1], 0, 3]', '[-1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0]')

]

# 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