New articles - OurBigBook.com

This makes things irreversible (TODO what does reversibility mean in this random context?), as opposed to Circuit-based quantum computer where you measure all output qubits at once.

TODO what is the advantage?

 Read the full article

Analog and digital quantum computers by

Ciro Santilli 37 Updated 2025-07-16

 Read the full article

Digital quantum computer by

Ciro Santilli 37 Updated 2025-07-16

 View more

As of 2022, this tends to be the more "default" when you talk about a quantum computer.

But there are some serious analog quantum computer contestants in the field as well.

 Read the full article

Quantum state vector by

Ciro Santilli 37 Updated 2025-07-16

 Read the full article

Tensor product in quantum computing by

Ciro Santilli 37 Updated 2025-07-16

 View more

We don't need to understand a super generalized version of tensor products to know what they mean in basic quantum computing!

Intuitively, taking a tensor product of two qubits simply means putting them together on the same quantum system/computer.

When we write the bra-ket notation:

∣ 00 ⟩

that is the same as

∣ 0 ⟩ \otimes ∣ 0 ⟩

The tensor product is called a "product" because it distributes over addition.

E.g. consider:

(\frac{∣ 0 ⟩ + ∣ 1 ⟩}{2}) \otimes ∣ 0 ⟩ = \frac{∣ 0 ⟩ \otimes ∣ 0 ⟩ + ∣ 1 ⟩ \otimes ∣ 0 ⟩}{2} = \frac{∣ 00 ⟩ + ∣ 10 ⟩}{2}

(1)

Intuitively, in this operation we just put a Hadamard gate qubit together with a second pure

∣ 0 ⟩

qubit.

And the outcome still has the second qubit as always 0, because we haven't made them interact.

The quantum state

\frac{∣ 00 ⟩ + ∣ 10 ⟩}{2}

is called a separable state, because it can be written as a single product of two different qubits. We have simply brought two qubits together, without making them interact.

If we then add a CNOT gate to make a Bell state:

\frac{∣ 00 ⟩ + ∣ 11 ⟩}{2} = \frac{∣ 0 ⟩ \otimes ∣ 0 ⟩ + ∣ 1 ⟩ \otimes ∣ 1 ⟩}{2}

(2)

we can now see that the Bell state is non-separable: we've made the two qubits interact, and there is no way to write this state with a single tensor product. The qubits are fundamentally entangled.

 Read the full article

Quantum logic gate by

Ciro Santilli 37 Updated 2025-07-16

 View more

At Section "Quantum computing is just matrix multiplication" we saw that making a quantum circuit actually comes down to designing one big unitary matrix.

We have to say though that that was a bit of a lie.

Quantum programmers normally don't just produce those big matrices manually from scratch.

Instead, they use quantum logic gates.

The following are the main reasons for that:

 Read the full article

Quantum logic gates are needed for physical implementation by

Ciro Santilli 37 Updated 2025-07-16

 View more

One direct practical reason is that we need to map the matrix to real quantum hardware somehow, and all quantum hardware designs so far and likely in the future are gate-based: you manipulate a small number of qubits at a time (2) and add more and more of such operations.

While there are "quantum compilers" to increase the portability of quantum programs, it is to be expected that programs manually crafted for a specific hardware will be more efficient just like in classic computers.

TODO: is there any clear reason why computers can't beat humans in approximating any unitary matrix with a gate set?

This is analogous to what classic circuit programmers will do, by using smaller logic gates to create complex circuits, rather than directly creating one huge truth table.

The most commonly considered quantum gates take 1, 2, or 3 qubits as input.

The gates themselves are just unitary matrices that operate on the input qubits and produce the same number of output qubits.

For example, the matrix for the CNOT gate, which takes 2 qubits as input is:

The final question is then: if I have a 2 qubit gate but an input with more qubits, say 3 qubits, then what does the 2 qubit gate (4x4 matrix) do for the final big 3 qubit matrix (8x8)? In order words, how do we scale quantum gates up to match the total number of qubits?

The intuitive answer is simple: we "just" extend the small matrix with a larger identity matrix so that the sum of the probabilities third bit is unaffected.

More precisely, we likely have to extend the matrix in a way such that the partial measurement of the original small gate qubits leaves all other qubits unaffected.

For example, if the circuit were made up of a CNOT gate operating on the first and second qubits as in:

0 ----+----- 0
      |
1 ---CNOT--- 1

2 ---------- 2

then we would just extend the 2x2 CNOT gate to:

TODO lazy to properly learn right now. Apparently you have to use the Kronecker product by the identity matrix. Also, zX-calculus appears to provide a powerful alternative method in some/all cases.

Bibliography:

quantumcomputing.stackexchange.com/questions/2299/how-to-interpret-a-quantum-circuit-as-a-matrix

 Read the full article

Universal quantum gates by

Ciro Santilli 37 Updated 2025-07-16

 View more

Just like as for classic gates, we would like to be able to select quantum computer physical implementations that can represent one or a few gates that can be used to create any quantum circuit.

Unfortunately, in the case of quantum circuits this is obviously impossible, since the space of N x N unitary matrices is infinite and continuous.

Therefore, when we say that certain gates form a "set of universal quantum gates", we actually mean that "any unitary matrix can be approximated to arbitrary precision with enough of these gates".

Or if you like fancy Mathy words, you can say that the subgroup of the unitary group generated by our basic gate set is a dense subset of the unitary group.

 Read the full article

Single-qubit gate by

Ciro Santilli 37 Updated 2025-07-16

 View more

The first two that you should study are:

 Read the full article

Pauli gate by

Ciro Santilli 37 Updated 2025-07-16

 Read the full article

Pauli-X gate by

Ciro Santilli 37 Updated 2025-07-16

 View more

The quantum NOT gate swaps the state of

∣ 0 ⟩

and

∣ 1 ⟩

, i.e. it maps:

x ∣ 0 ⟩ + y ∣ y ⟩ \to y ∣ 0 ⟩ + x ∣ y ⟩

(1)

As a result, this gate also inverts the probability of measuring 0 or 1, e.g.

if the old probability of 0 was 0, then it becomes 1
if the old probability of 0 was 0.2, then it becomes 0.8

[0110]

(2)

Equation 2.

Quantum NOT gate matrix

Figure 1.
Quantum NOT gate symbol
. Source.

 Read the full article

Phase shift gate by

Ciro Santilli 37 Updated 2025-07-16

 Read the full article

Multi-qubit gate by

Ciro Santilli 37 Updated 2025-07-16

 View more

The most common way to construct multi-qubit gates is to use single-qubit gates as part of a controlled quantum gate.

 Read the full article

Controlled quantum gate by

Ciro Santilli 37 Updated 2025-07-16

 View more

Controlled quantum gates are gates that have two types of input qubits:

control qubits
operand qubits (terminology made up by Ciro Santilli just now)

These gates can be understood as doing a certain unitary operation only if the control qubits are enabled or disabled.

The first example to look at is the CNOT gate.

Figure 1.
Generic controlled quantum gate symbol
. Source.
The black dot means "control qubit", and "U" means an arbitrary Unitary operation.
When the operand has a conventional symbol, e.g. the Figure "Quantum NOT gate symbol" for the quantum NOT gate to form the CNOT gate, that symbol is used in the operand instead.

 Read the full article

Empty circle control qubit notation by

Ciro Santilli 37 Updated 2025-07-16

 View more

Some authors use the convention of:

filled black circle: conventional controlled quantum gate, i.e. operate if control qubit is active
empty (White) circle: operate if control qubit is inactive

 Read the full article

CNOT gate by

Ciro Santilli 37 Updated 2025-07-16

 View more

The CNOT gate is a controlled quantum gate that operates on two qubits, flipping the second (operand) qubit if the first (control) qubit is set.

This gate is the first example of a controlled quantum gate that you should study.

1000010000010010

(1)

Equation 1.

CNOT gate matrix

Figure 1.
CNOT gate symbol
. Source. The symbol follow the generic symbol convention for controlled quantum gates shown at Figure "Generic controlled quantum gate symbol", but replacing the generic "U" with the Figure "Quantum NOT gate symbol".

To understand why the gate is called a CNOT gate, you should think as follows.

First let's produce a generic quantum state vector where the control qubit is certain to be 0.

On the standard basis:

∣ 00 ⟩ ∣ 01 ⟩ ∣ 10 ⟩ ∣ 11 ⟩

(2)

we see that this means that only

∣ 00 ⟩

and

∣ 01 ⟩

should be possible. Therefore, the state must be of the form:

x y 00

(3)

where

x

and

y

are two complex numbers such that

∣ x ∣ + ∣ y ∣ = 1.0

If we operate the CNOT gate on that state, we obtain:

1000010000010010 \times x y 00 = x y 00

(4)

and so the input is unchanged as desired, because the control qubit is 0.

If however we take only states where the control qubit is for sure 1:

1000010000010010 \times 00 x y = 00 y x

(5)

Therefore, in that case, what happened is that the probabilities of

∣ 10 ⟩

and

∣ 11 ⟩

were swapped from

x

and

y

y

and

x

respectively, which is exactly what the quantum NOT gate does.

So from this we understand more concretely what "the gate only operates if the first qubit is set to one" means.

Now go and study the Bell state and understand intuitively how this gate is used to produce it.

 Read the full article

 Pinned article: Introduction to the OurBigBook Project

Welcome to the OurBigBook Project! Our goal is to create the perfect publishing platform for STEM subjects, and get university-level students to write the best free STEM tutorials ever.

Everyone is welcome to create an account and play with the site: ourbigbook.com/go/register. We belive that students themselves can write amazing tutorials, but teachers are welcome too. You can write about anything you want, it doesn't have to be STEM or even educational. Silly test content is very welcome and you won't be penalized in any way. Just keep it legal!

Video 1.

Intro to OurBigBook

. Source.

We have two killer features:

topics: topics group articles by different users with the same title, e.g. here is the topic for the "Fundamental Theorem of Calculus" ourbigbook.com/go/topic/fundamental-theorem-of-calculus
Articles of different users are sorted by upvote within each article page. This feature is a bit like:
- a Wikipedia where each user can have their own version of each article
- a Q&A website like Stack Overflow, where multiple people can give their views on a given topic, and the best ones are sorted by upvote. Except you don't need to wait for someone to ask first, and any topic goes, no matter how narrow or broad
This feature makes it possible for readers to find better explanations of any topic created by other writers. And it allows writers to create an explanation in a place that readers might actually find it.
Figure 1.
Screenshot of the "Derivative" topic page
. View it live at: ourbigbook.com/go/topic/derivative
Video 2.
OurBigBook Web topics demo
. Source.
local editing: you can store all your personal knowledge base content locally in a plaintext markup format that can be edited locally and published either:
- to OurBigBook.com to get awesome multi-user features like topics and likes
- as HTML files to a static website, which you can host yourself for free on many external providers like GitHub Pages, and remain in full control
This way you can be sure that even if OurBigBook.com were to go down one day (which we have no plans to do as it is quite cheap to host!), your content will still be perfectly readable as a static site.
Figure 2.
You can publish local OurBigBook lightweight markup files to either https://OurBigBook.com or as a static website
.
Figure 3.
Visual Studio Code extension installation
.
Figure 4.
Visual Studio Code extension tree navigation
.
Figure 5.
Web editor
. You can also edit articles on the Web editor without installing anything locally.
Video 3.
Edit locally and publish demo
. Source. This shows editing OurBigBook Markup and publishing it using the Visual Studio Code extension.
Video 4.
OurBigBook Visual Studio Code extension editing and navigation demo
. Source.
Internal cross file references done right:
Infinitely deep tables of contents:
Figure 6.
Dynamic article tree with infinitely deep table of contents
.
Live URL: ourbigbook.com/cirosantilli/chordate
Descendant pages can also show up as toplevel e.g.: ourbigbook.com/cirosantilli/chordate-subclade

All our software is open source and hosted at: github.com/ourbigbook/ourbigbook

Further documentation can be found at: docs.ourbigbook.com

Feel free to reach our to us for any help or suggestions: docs.ourbigbook.com/#contact

 Site settings

 Pinned article: Introduction to the OurBigBook Project  Hide

 Pinned article: Introduction to the OurBigBook Project