Source code: Q-Qubit.js


Perfect pairs

A qubit is just a pair of numbers. That’s it—two shiny happy number values, holding hands. Let’s call the first number “alpha” and the second number “beta.” Look at this handsome couple:


alpha, beta

We can package alpha and beta together by storing them in a very small matrix that is only one unit wide and two units tall—and because this matrix is only one unit wide it is not merely a matrix, it’s also a vector. (What’s a matrix? What’s a vector? See the Matrix page for quick refreshers on both.)

So when you think of a qubit you can imagine it as a 1 × 2 matrix containing its alpha value on the top and its beta value on the bottom, like so:


alpha
beta

Now that we know a qubit is a matrix, we also know that we can perform addition with qubits, perform multiplication with qubits, and so on—just as one can do with any matrix. (That will become rather important when we eventually introduce the idea of quantum gates, which are also matrices.)

Predictable couples

The thing that makes this pair of numbers special is their relationship to each other, which we can define as follows: alpha multiplied by alpha, added to beta multiplied by beta, must always equal one. We can express this as an equation:


( alpha × alpha ) + ( beta × beta ) = 1

The parentheses in the equation above are not strictly necessary as the “order of operations” rules dictate that these multiplications must be carried out prior to the additions—but emphasis can often be more helpful than brevity when learning something new. And now that we understand this relationship we can express it more compactly using exponents rather than multiplications: alpha squared added to beta squared must always equal one.


alpha2 + beta2 = 1

A bit further below we’ll add one small wrinkle to this equation, but otherwise this is what defines a qubit. That’s it. It’s that easy.

Named couples

Let’s start plugging in values for alpha and beta. Each different value combination makes a different sort of qubit. The most frequently used qubit value combinations have names and belong to a set of named vectors called Jones vectors. We’ll begin with the two simplest qubits. This first qubit is named Horizontal and the second is named Vertical. Both are composed from a zero and a one and we can see that this satisfies our qubit definition above.


alpha = 1
beta = 0
A Horizontal qubit is considered
to be “0” or “OFF.”


alpha2 + beta2 1
12 + 02 1
1 + 0 1
1 1 ✓

alpha = 0
beta = 1
A Vertical qubit is considered
to be “1” or “ON.”


alpha2 + beta2 1
02 + 12 1
0 + 1 1
1 1 ✓


What does it mean to be named Horizontal or Vertical? Where do these orientation-based names come from? Are there more orientation-based names? To understand, let’s plot these two qubit vectors on a graph. We’ll use the alpha value as our x coordinate and the beta value as our y coordinate:


alpha
beta
→   ( alpha, beta )

Plotting alpha and beta as x and y yields (1, 0) for a Horizontal qubit and (0, 1) for a Vertical qubit.


Vertical
Horizontal
0, 0
1, 0
0, 1
-1, 0
0, -1

We can see that the values from a Horizontal qubit, when plotted as x and y, form a horizontal line from the origin (0, 0) out to (1, 0). Meanwhile, when we plot the values of a Vertical qubit as x and y, it forms a vertical line from the origin (0, 0) up to (0, 1). Before we introduce more named Jones vectors let’s take what we’ve learned about qubit values and generalize it for vectors with more than two elements so we can better understand what these qubit values truly mean.

State vectors

Did it seem strange to read that the qubit we refer to as “0” begins with an alpha value of 1? (Or that the qubit we refer to as “1” begins with an alpha value of 0?) Does that mean we refer to qubits by their beta values? Is that some sort of quantum computing convention?


alpha = 1
beta = 0
Recall that a Horizontal qubit
is considered “0” or “OFF.”

The short answer is “No.” To understand why, we must recognize that a qubit is the simplest example of a quantum state vector—a list of all possible states for a quantum system to exist in, with each possible state accompanied by the probability that the system is indeed in that state. When a single qubit is measured there are only two possible states for it to be in: 0 or 1. This is why a qubit is represented by a two-element vector; one element per possible outcome. On this very short list of possible outcomes, 0 is the first possible outcome and 1 is the second possible outcome. When we say that a Horizontal qubit is “0we’re not referring to the qubit’s beta value at all. We’re instead highlighting the fact that the 1 in this (1, 0) pair happens to be in the “zeroth” slot—the alpha slot of this (alpha, beta) pair. We’re saying that for the possible outcome “0” our qubit is voting 1, or TRUE. At the same time we’re saying that for the possible outcome “1”, our qubit is voting 0, or FALSE.


Outcome will be 0TRUE (1)  
Outcome will be 1FALSE (0)

For good measure let’s look at the converse example.


Outcome will be 0FALSE (0)
Outcome will be 1TRUE (1)  

To further clarify—and to hint at how a quantum circuit functions—let’s look at a state vector for a quantum system composed of two qubits. With one qubit there were two possible outcomes: 0 and 1. (And because there are only two elements of a qubit vector we named them alpha and beta to make referring to them more convenient.) For two qubits there are four possible outcomes: 00, 01, 10, and 11. (We won’t bother to name elements of state vectors larger than two. It would get unwieldy rather quickly.) Which of those four possible outcomes might the following state vector represent?


0
0
1
0
A state vector for
two qubits.

The above vector represents four possible outcomes and we see that three out of those four possible outcomes are FALSE (0). Meanwhile, the third of those four possible outcomes is TRUE (1). Because the result value of the third possible outcome is 10 we see that this two qubit vector state is telling us it represents a result of 10. Let’s break this down the same way we did with Horizontal and Vertical qubits.


Outcome will be 00FALSE (0)
Outcome will be 01FALSE (0)
Outcome will be 10TRUE (1)  
Outcome will be 11FALSE (0)
A state vector for
two qubits.

We’ve learned that a single qubit is the simplest example of a quantum state vector. It is a list of the votes per each possible outcome—and for a single qubit there are only two possible outcomes. We’ve also seen that we can represent the state of a multi-qubit system where there are more than two possible outcomes.

Ket notation

Paul Dirac’s “bra-ket” notation offers us a more compact means of describing quantum state vectors—and by extension, qubits. (While “bra-ket” offers us two named elements—“bra” and “ket”—for our purposes we need only focus on the latter.) Kets represent the result value that our quantum vector state represents. They are expressed as values enclosed between a vertical bar and a rightward angle bracket. The following is pronounced “ket zero.”


0

We began by stating that a Horizontal qubit represents “0”, and later explained why this was so. Kets provide us a convenient way to refer to this result state directly as in-line text rather than a clunky matrix.


1
0
0

Similarly, we defined a Vertical qubit as representing “1” and illustrated this as well. We can now also express this column vector as a ket.


0
1
1

The convenience of ket notation becomes more apparent as we represent state vectors that are larger than a single qubit. (For n qubits we must use a state vector that has 2n elements. Meanwhile our ket values are still just n digits long.) Here we express four possible states of a two qubit system as both state vectors and their equivalent kets.


1
0
0
0
= 00,
0
1
0
0
= 01,
0
0
1
0
= 10,
0
0
0
1
= 11

Superposition

You’ve probably heard the term “superposition”—and along with that you’ve likely been spoonfed some measure of mysticism; pizza-bagels and whatnot. In the real, physical world, superposition is indeed weird magic. But mathematically it’s dead simple: Superposition is any qubit state where the alpha and beta values are anything other than exactly 0 or exactly 1. Up until now we’ve thought of alpha and beta values as being either TRUE (1) or FALSE (0) but each is actually capable of expressing an entire spectrum between TRUE (1) and FALSE (0). Let’s investigate that idea by building on what we’ve already learned.

Given the constraint alpha2 + beta2 = 1, if we plot all of the possible alpha and beta values on a graph as x and y respectively, the outcome is a circle with a radius of 1 centered at the origin (0, 0); ie. a unit circle. All possible combinations of alpha and beta lay on the perimeter of this circle. To illustrate this, here’s a plot of named Jones vectors as well as their conjugates.

Vertical
Diagonal
Horizontal
Anti-diagonal
45˚
90˚
135˚
180˚
225˚
270˚
315˚
1, 0
1
√ 2
,
1
√ 2
0, 1
-1
√ 2
,
1
√ 2
-1, 0
-1
√ 2
,
-1
√ 2
0, -1
1
√ 2
,
-1
√ 2

What the alpha and beta values represent are the individual probability amplitudes for each outcome; that a qubit when measured will be in either a 0 or a 1 state. Measurement itself causes a qubit’s probability wave to collapse, bringing an end to its superposition. The probability that upon measurement a qubit’s probability amplitude will collapse to 0 is alpha2, while the probability that it will collapse to 1 is beta2.

We already know that a Horizontal qubit exists in a state of 0 (“ket zero”) and therefore has a 100% chance of being measured as 0.


1
0

Similarly, we also know that a Vertical qubit exists in a state of 1 (“ket one”) and therefore has a 100% chance of being measured as 1.


0
1

Meanwhile, a Diagonal qubit exists in a state of superposition as + (“ket plus”). It is a state which does not have a definite result value prior to measurement but it does of course have a definite state vector and that state vector has a positive orientation. (Recall our unit circle diagram above to see how this value lays in a positive quadrant of the graph.) There is a 50% chance of it being measured as 0 (“ket zero”) and a 50% chance of it being measured as 1 (“ket one”).


1
1
×
1
√ 2
=
1 ÷ √ 2
1 ÷ √ 2


alpha2 + beta2 1
(1 ÷ √ 2)2 + (1 ÷ √ 2)2 1
(1 ÷ 2) + (1 ÷ 2) 1
0.5 + 0.5 1
1 1 ✓


And finally, an Anti-diagonal qubit also exists in a state of superposition, but as - (“ket minus”). Like the Diagonal qubit it has a 50% chance of being measured as 0 (“ket zero”) and a 50% chance of being measured as 1 (“ket one”).


1
-1
×
1
√ 2
=
1 ÷ √ 2
-1 ÷ √ 2


alpha2 + beta2 1
(1 ÷ √ 2)2 + (-1 ÷ √ 2)2 1
(1 ÷ 2) + (1 ÷ 2) 1
0.5 + 0.5 1
1 1 ✓

What does it mean that a Diagonal qubit state and an Anti-diagonal qubit state collapse with the same probabilies? What about their conjugates which also behave in this same fashion? These questions begin to hint at the quirks of quantum circuits; the aspects of quantum computing that quantum algorithms are engineered to take advantage of.

Complex couples

We’ve spent the majority of this primer describing qubits as containing alpha and beta values ranging from 0 up to 1. The unit circle above illustrates that these values can also range from 0 down to -1. While all of this remains true, the story is slightly more complex.

Qubits are actually made of complex number pairs, meaning there is an imaginary component. (See the ComplexNumber page for a quick refresher on real, imaginary, and complex numbers.) This means one qubit is actually made of four parts: The alpha value has a ① real component and an ② imaginary one. The beta value also has a ③ real component and an ④ imaginary one.

To account for this we must slightly evolve our definition of a qubit; specifically the relationship between its alpha and beta values. Rather than simply adding their squares together, we must instead add the squares of their absolute values. Our evolved equation, which indicates absolute values by enclosing numbers between vertical bars, now looks like this:


|alpha|2 + |beta|2 = 1

By taking the absolute values of alpha and beta before squaring them, we continue to ensure that our sum of squares will equal exactly 1; that it continues to equal a simple, real number rather than an imaginary or complex number.

The Bloch sphere

And that’s really it. That’s what makes a mathematical qubit. But with that last-minute addition of complex numbers above, we can no longer visualize a qubit as a two-dimensional unit circle. Instead we must map our two complex values onto a three dimensional graph known as a Bloch sphere. Select one of the following qubit states to observe its graph on the Bloch sphere. Tap and drag the sphere itself to rotate it.

Horizontal qubit
1
0
Imagine the North Pole.
Vertical qubit
0
1
Imagine the South Pole.
Diagonal qubit
1
1
×
1
√ 2
Imagine the Gulf of Guinea off of Africa.
Anti-diagonal qubit
 1
-1
×
1
√ 2
Imagine Kiribati in the Pacific Ocean.
Right-hand circular polarized qubit
 1
-i
×
1
√ 2
Imagine the Galápagos Islands in the Pacific Ocean.
Left-hand circular polarized qubit
1
i
×
1
√ 2
Imagine Sumatra in the Indian Ocean.
˚ polar angle θ (theta)
˚ azimuth angle ϕ (phi)

Constructor

Qubit Function([ Q.Matrix* ][ alpha: Number or Q.ComplexNumber, beta: Number or Q.ComplexNumber [, label: String [, name: String ]]]) => Q.Qubit
Qubit extends Q.Matrix and therefore inherits its static and prototypal properties. The Qubit constructor can accept as a single argument a Q.Matrix instance, or anything that inherits from Q.Matrix—such as a Q.Qubit instance—and will return a new qubit constructed from the passed object’s values.

Alternatively, the constructor expects two arguments that are each either instances of Number or Q.ComplexNumber which will will then correspond to the qubit’s alpha and beta values. Further, an optional third argument may be supplied for label—expected in the form of a single character String—to be used as a tiny label for the qubit when represented in diagram or graphic form. Even further, an optional fourth argument may be supplied for name—expected as a String—to be used as a more descriptive name for the qubit. If arguments for label or name are not supplied then the constructor checks against the list of existing constants and if a qubit with matching alpha and beta values is found then the corresponding label and / or name will be copied to this new instance.

When a new qubit is created it internally invokes the Q.Matrix constructor, such that new Q.Qubit( alpha, beta ) is similar to new Q.Matrix([ alpha ], [ beta ]). If the two supplied values do not satisfy the assertion that |alpha|2 + |beta|2 = 1 then an error is thrown.


var fox = new Q.Qubit( 1, 0 )

Static properties

Because Q.Qubit extends Q.Matrix, the following append or replace the latter’s existing static properties.

Constants and constant creation

Constants — Jones Vectors

Q.Qubit provides the following built-in Jones vectors.

Inspection


Prototype properties

Because Q.Qubit extends Q.Matrix, the following append or replace the latter’s existing prototype properties.

Non-destructive methods

Destructive methods