January 3, 2019

Nerdy, speculative blog post ahead. Better skip this one and go on to the next one. Or, if you want really speculative, stoner lit., read a Quanta Magazine article instead.

Read this at your own peril!

Benzene (C_6 H_6) is a molecule composed of six Carbon atoms coupled together in a hexagonally shaped ring, with a Hydrogen atom attached to each Carbon atom. A good exercise found in many “Group Theory for Chemists” books is finding the wavefunction for the valence electrons of a Benzene molecule. If _ means Single bond and = means a Double bond, and the Carbon atoms are labelled 0, 1, .., 5, one finds a ground state that is a superposition of two states

Before 1865, scientists knew that Benzene had equal numbers of C and H atoms, but they had no idea what was the structure of its molecule. It wasn’t until 1865 that the German chemist Friedrich August Kekulé wrote a paper hypothesizing that the Carbon atoms in Benzene are coupled in a ring shape. 25 years later, at a symposium commemorating Kekule’s work, Kekulé himself explained that the idea of a ring shape had come to him as a day-dream in which he saw a snake biting its own tail (this is a common symbol in many ancient cultures).

It’s quite amazing how chemists were able to figure out the structure of Benzene long before the dawn (circa 1925) of quantum mechanics.

Now consider a “Benzene” molecule made of qubits, i.e., 6 qubits coupled in a ring. Such a ring could be used to realize a quantum computing gate with one X target and 5 controls. In my Python program Qubiter, such a gate is depicted as

X—@—@—@—@—@

(Analogous gates with X at a different position and some @ controls replaced by O controls, could likewise be implement on that qubit Benzene molecule).

More simply, one could consider 3 qubits coupled in a triangular ring, and use that to implement the so called Toffoli gate

I will henceforth call a generalized Toffoli gate, a gate with any single-qubit rotation (for instance, X) as target and an arbitrary number of controls of either the @ or O kind.

My quantum computer simulator Qubiter can implement a generalized Toffoli gate in a SINGLE step. Qubiter can also decompose any such gate into a Sequence of Elementary Operations (SEO)(by elementary ops we mean single qubit rotations and CNOTs). For example, the usual Toffoli with 2 controls can be expressed as a SEO with a minimum of 6 CNOTs. At present, none of the other famous qc simulators (IBM qasm, Google Cirq, Rigetti PyQuil) can do more than 2 controls; they can only model an X with 1 or 2 controls, but not more, as a single step.
CORRECTION: As of Jan. 2, 2019, IBM qiskit includes multi-controlled NOTs. Qubiter has had this feature for 2 years though.

Quantum AI uses “multiplexor” quantum gates (my quantum AI program Quantum_Edward available at Github, certainly uses them). Multiplexor gates are discussed in an appendix below. They are gates which are even more complicated than generalized Toffoli gates, but which can be expressed as products of generalized Toffoli gates. Hence, I believe that in the future, quantum AI will make ample use of generalized Toffoli gates, especially if they can be implemented in a single step using qubit rings.

Another reason why qubit rings could turn out to be useful is that some people believe that a whole ring of physical qubits could be used as a single logical qubit. If when all the spins of the ring are up (resp., down) is represented by the logical state |0> (resp., |1>), then |0> and |1> have the same energy, and an energy barrier can be engineered between the two states, because flipping all the spins of a ring could be more energetically expensive than flipping a single spin. So the energy barrier between |0> and |1> could be made proportional to the number of spins in the ring.

Appendix: Quick review of multiplexor quantum gates:

Multiplexor quantum gates were first used in the following reference, henceforth referred to as Ref.[1]:

Ref.[1] uses the CS (Cosine-Sine) decomposition of LAPACK which states that any unitary matrix U can be decomposed as

U = L (multiplexor matrix) R

where R (and L too) is a block diagonal matrix with two unitary matrices of the same size along its diagonal. Ref. [1] applies the CS decomposition first to U, then to R and L, and so on, recursively. The net effect is to decompose U into a product of multiplexors. Ref. [1] then shows how to decompose any single multiplexor into a SEO.

As explained in Ref.[1], a multiplexor matrix, after a permutation of its qubits, can be expressed as a block diagonal matrix with a string of independent 2 dimensional rotation matrices along its diagonal.

Ref.[1] does not use the term ‘multiplexor’. It calls them ‘central matrices’ instead. The name multiplexors was given to such matrices by others many years later.

Ref.[1] came with a C++ implementation called Qubiter. A new version of Qubiter, written in Python, is currently available at Github. It includes a rewrite (using numpy and Python wrappers of LAPACK to do the heavy lifting in Linear Algebra) of the old C++ implementation.

Advertisements

Share this:

Like this:

Related

I am mostly sure, if you arrange the matrix elements coming out of your binary tree as functions of an integer index from 0 to 2^N-1, there will more or less tend to be fractal sequences!
My bet: for any such computation, there will exist an “horizontal” morphism connecting all matrix elements row-wise in the word dictionary deployement of any such tree that makes the original computation obsolete for any N greater some N0.

Some interesting facts about the recursive use of the CS decomposition.

In general, for arbitrary initial unitary matrix U, there are a lot of free parameters that are not unique in this decomposition and can be used for optimization

In the case that U is the quantum Fourier Transform matrix, there exists a 1 dimensional path of nodes in the tree going from the root node to one of its leaves with all nodes outside that path equal to 1. In other words, the tree reduces to a simple chain from the root node to one of the leaves