Hamiltonians and Operator Arithmetic

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

Challenge statement

The Hamiltonian is the energy observable for a quantum system, and a quintessential component in many quantum algorithms. How do we implement Hamiltonians in PennyLane? You'll be tested on this in this challenge.

You will be tasked with creating the Hamiltonian

where is the number of qubits, and are the familiar Pauli X and Z operators acting on the -th wire, and denotes a sum over all pairs where For example, for , the pairs that enter the sum are ). Note that we're indexing from 0!

In this challenge, you need to create the following quantum circuit simulation that returns the expectation value of this Hamiltonian.

Be mindful that the gates represent the Hadamard gate, not the Hamiltonian, which we denoted by to avoid this exact confusion!

Challenge code

In the code shown, you must complete two functions:

hamiltonian: responsible for creating the Hamiltonian in question for a general number of qubits (num_wires). You must complete this function.
expectation_value: simulates the circuit in question and returns the expectation value of the Hamiltonian in question. You must complete this function by creating a QNode within this function that returns the expectation value of the Hamiltonian.

Here are some helpful resources and hints:

The term, mathematically, denotes a tensor product between the two Pauli-X operators. Here are some ways you can perform this in PennyLane:
- use the @ operator to take the tensor product between operators;
- use qml.prod.
qml.Hamiltonian
Operator arithmetic

Input

As input to this problem, you are given the number of qubits num_wires (int), denoted by in the above definition of the Hamiltonian .

Output

This code must output the expectation value of the Hamiltonian (float).

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: 8
expected_output: 9.33333

test_input: 3
expected_output: 1.00000

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

def hamiltonian(num_wires):

"""

A function for creating the Hamiltonian in question for a general

number of qubits.

Args:

num_wires (int): The number of qubits.

Returns:

(qml.Hamiltonian): A PennyLane Hamiltonian.

"""

# Put your solution here #

return

def expectation_value(num_wires):

"""

Simulates the circuit in question and returns the expectation value of the

Hamiltonian in question.

Args:

num_wires (int): The number of qubits.

Returns:

(float): The expectation value of the Hamiltonian.

"""

# Put your solution here #

# Define a device using qml.device

dev =

@qml.qnode(dev)

def circuit(num_wires):

"""

A quantum circuit with Hadamard gates on every qubit and that measures

the expectation value of the Hamiltonian in question.

Args:

num_wires (int): The number of qubits.

Returns:

(float): The expectation value of the Hamiltonian.

"""

# Put Hadamard gates here #

# Then return the expectation value of the Hamiltonian using qml.expval

return

return circuit(num_wires)

# These functions are responsible for testing the solution.

def run(test_case_input: str) -> str:

num_wires = json.loads(test_case_input)

output = expectation_value(num_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)

# These are the public test cases

test_cases = [

('8', '9.33333'),

('3', '1.00000')

]

# 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