The Standard Model and Quantum Computation

I hope you all are doing fine.

In the previous edition, I said that Part II would deal with the Standard Model from the Frog's Perspective, but I could not stop thinking about how to express the Standard Model in terms of quantum computation. It is a challenging and fascinating question that deserves some consideration. I hope you'll forgive me and what follows is my humble attempt to start the thinking process...

We did see in the previous editions that, in a nutshell, the Standard Model of particle physics is a theoretical framework that describes the fundamental subatomic particles, how they interact with each other, and the forces that govern these interactions. On the other hand, quantum computation deals with performing computational operations on quantum bits (qubits) instead of classical bits. We try to exploit the collective properties of quantum states, such as superposition and entanglement, to perform computation. The devices that perform quantum computation are quantum computers. Everett’s Many Worlds interpretation of quantum mechanics may elegantly explain the inner workings of quantum computers. These are really machines that perform calculations simultaneously in different parallel worlds (branches).

Welcome back to a new edition of our monthly newsletter which is envisioned as a venue where a broader audience can get exposed to calculations in Theoretical Particle Physics.

Let's get started.

The Standard Model

?As you know the Standard Model consists of three types of particles: quarks, leptons, and gauge bosons. These particles are further divided into six quarks, six leptons, and four types of gauge bosons. The interactions among these particles are described by three of the four fundamental forces of nature: electromagnetic force, weak force, and strong force. Gravity is not a part of the Standard Model.

Quantum Computation

Quantum computation provides a new way of approaching problems that are otherwise very hard to solve using classical methods. In classical computing, the basic unit of information is a bit, which can either be a 0 or a 1. In contrast, in quantum computing, the basic unit of information is a qubit, which can exist in multiple states at the same time. The general state of the qubit is a superposition of |0> and |1> states

This allows quantum computers to perform specific calculations much faster than classical computers. So right here we have a hint: we should represent each particle as a qubit in a certain superposition state, for example, up quark as

or W gauge boson as

Elementary particles as qubits

Each of the particles will be encoded as a unique superposition of |0> and |1> qubit states. In general, for a particle p, the representation will be

and you easily check that

where angles theta and phi are defined on the Bloch sphere. The Bloch sphere is a nice geometrical representation of the qubit states. The qubit states are points on the sphere. And since the sphere has an infinite number of points, we have an endless number of possible states for a qubit, an incredible encoding power.

Now, you probably remember this picture of the Standard Model that we had in one of the earlier editions of the newsletter

As you can see, we have 18 elementary particles (W boson has + and - electric charge flavors) that we need to encode as a unique superposition of |0> and |1> qubit states. Since we have 18 elementary particles we can encode them in, let's say, 10 degrees increments:

Interactions in the Standard Model

In one of our earlier editions, we mentioned that processes involving virtual particles can be described by a schematic representation known as Feynman diagrams in which virtual particles are represented by internal lines. For example, when two electrons interact and exchange a virtual photon that is represented by the diagram below

These diagrams are built from so-called interacting vertices. Below are all possible interacting vertices in the Standard Model. Important to note is that all Feynman diagrams in the Standard Model are built from combinations of these vertices.

Our challenge is how to encode these vertices in terms of qubits. Since we encode elementary particles as qubits, a natural progression is to encode interactions among these particles as quantum gates. For example, the electron-neutrino-W vertex could be encoded as this quantum circuit:

An electron comes from the left and at the very far right neutrino and W boson exit the circuit. This is the qiskit code that generates this lovely circuit:

The last line generates the above graphical representation of the electron-neutrino-W vertex quantum circuit.

Why this circuit simulates the electron-neutrino-W vertex?

The idea behind the circuit is very simple. In quantum computation, all qubits are initialized to |0> state. To generate "the electron" we apply u(theta_e, phi_e, 0, 0) gate to q0 |0> state to get

U gate rotates |0> state on the Bloch sphere to |e>.

We apply now a SWAP gate between q0 and q1 which swaps |0> state of q1 and |e> state of q0 so that q1 ends in |e> state and q0 in |0> state. The SWAP gate is constructed out of 3 CNOT gates:

To understand this combination of 3 CNOT gates you need, of course, to see what a single CNOT gate does.

CNOT stands for Controlled-NOT and here is a snippet from Wikipedia:

You are ready now for the math behind the SWAP gate.

Going back to our "Vertex" quantum circuit, after the SWAP gate, q0 is in |0> state, and q1 is in |e> state. We undo |e> state by applying the inverse of u(theta_e, phi_e, 0, 0) to q1, which is

u(-theta_e,phi_e,0,1)|e>=|0> and immediately apply u(theta_n,phi_n,0,1) to q1 |0> state to get our "neutrino"

Then we repeat the above steps to create "W" boson.

A bit of "technical" proof that our final state is |0>|n>|W>

Here is a little bit of "technical" proof that our final state is |0>|n>|W>, ignore |0> for a moment, since our electron has vanished to the sea of |0> qubits.

To generate |0>|n>|W> we run the circuit on a statevector_simulator:

We check now that values in "nfj" array are what we expect to be. Pay close attention to the last line with the "outer" product for neutrino and W boson. Ignore zeros in "nfj", they are due to that |0> qubit and focus on non-zero values, they match values in the "outer" product.

Conclusion and Outlook

This was a very exciting and challenging attempt to express the Standard Model in terms of quantum computation. What we have here is just a very beginning of a fascinating journey where a unifying motif is a qubit. Each elementary particle is a qubit in a certain superposition state. We don't consider |0> qubit state as an elementary particle. So, our starting point is a sea of qubits in |0> state. To create an elementary particle we apply gates to the sea and the above electron-neutrino-W vertex quantum circuit illustrates how to do that. It seems we can apply the same circuit with different parameters to create other vertices in the Standard Model, but will leave this for further exploration, as well as the question of how to incorporate interaction strengths of the vertices into the respective quantum circuits.

Stay well!