I want to attend this years QHack hackathon by Xanadu. To get most out of my experience, I want to shape up, prior to the event. Starting today, I’m committing myself to a 4 week prep challenge. Every day, I will complete some quantum coding exercise, riddle or challenge, I’ll refine my road-map along the way, as a starting point, I’ll take on last years challenges.
Quantum Chemistry: particle conservation (difficulty easy)
The problem statement an base code was taken from this link. It is a rather simple problem, not requiring any particular knowledge in Pennylane, Quantum mechanics or quantum computing beyond a grasp of quantum state representations.
Intro
Larger quantum systems are more conveniently described in second quantization, i.e. a systems state is described by the occupation of a given quantum state (orbital).
Looking at a single molecule, during chemical processes the number of electrons are conserved – none disappear, nor appear out of thin air. If you want to map a molecular Hamiltonian to a qubit Hamiltonian, the used quantum gates need to preserve this particle count. How to mathematically construct suitable operators using the Jordan-Wigner representation is nicely described here. Now a detailed outline on how the problem was solved.
Representation wrangling
Firstly, it comes in handy to convert integer state representations (easy to enumerate) to a second quantization representation of a fixed width (easy to obtain particle counts).
def binary_list(m, n):
"""Converts number m to binary encoded on a list of length n
Args:
- m (int): Number to convert to binary
- n (int): Number of wires in the circuit
Returns:
- (list(int)): Binary stored as a list of length n
"""
bin_str = np.binary_repr(m, width=n)
arr = [int(s) for s in bin_str]
return arr
Listing up all basis states of a fixed width
Secondly, all basis states were needed, to test if they were particle conserving under a given quantum circuit.
def basis_states(n):
"""Given a number n, returns a list of all binary_list(m,n) for m < 2**n, thus providing all basis states
for a circuit of n wires
Args:
- n(int): integer representing the number of wires in the circuit
Returns:
- (list(list(int))): list of basis states represented as lists of 0s and 1s.
"""
arr = []
for m in range(2**n):
arr += [binary_list(m, n), ]
return arr
Check if particle conservation is given for a given circuit
Lastly, given a certain width, we obtain the particle counts of all possible state configurations given a certain width. Then we apply a given circuit onto all basis states, and check if the resulting states comprises states with the original particle count. If this is not the case, we abort the test.
def is_particle_preserving(circuit, n):
"""Given a circuit and its number of wires n, returns 1 if it preserves the number of particles, and 0 if it does not
Args:
- circuit (qml.QNode): A QNode that has a state such as [0,0,1,0] as an input and outputs the final state after performing
quantum operation
- n (int): the number of wires of circuit
Returns:
- (bool): True / False according to whether the input circuit preserves the number of particles or not
"""
particle_counts_in_states = np.array([sum(binary_list(m, n)) for m in range(2**n)])
is_particle_preserving = True
for inp_state in basis_states(n):
out_state = circuit(inp_state)
out_contains_base_state = [not np.isclose(base_state, 0.) for base_state in out_state]
if not np.all(particle_counts_in_states[out_contains_base_state] == sum(inp_state)):
is_particle_preserving = False
break
return is_particle_preserving
Test data
The puzzle creators provided two circuits for testing the algorithm.
The first circuit contains the well-known Hadamard and CNOT gates, extensively used for logical operations in quantum computing. Unsurprisingly, these gates are not explicitly designed to fulfill particle conservation, and thus fail our test.
The second circuit contains specially designed DoubleExcitation and SingleExcitation operators, these do fulfill our particle conservation requirement.
