Computation, Information, and Qubits

The mechanism: information lives in physical states

Quantum computing is a model of computation in which information is stored in physical systems whose valid states are described by complex amplitudes, and whose allowed closed-system operations are reversible linear transformations. Every word of that sentence is load-bearing, and this guide unpacks all of them.

The right starting point is computation as physics:

• A bit is a physical system used to encode 0 or 1.
• A logic gate is a physical process that transforms encoded information.
• A circuit is those transformations composed in sequence.
• A qubit is a physical two-level system whose state can require amplitudes over both classical basis states.

The hard part is not saying that a qubit can be "both 0 and 1." The hard part is learning when that phrase helps, when it misleads, and how to replace it with a calculation.

Three ways to carry one bit of information

Classical bit

A classical bit holds one value from the set $\{0,1\}$. A one-bit register is in exactly one of two states, full stop. There is no nuance available, and that bluntness is precisely what makes classical hardware so reliable.

Probabilistic bit

A probabilistic bit carries uncertainty over classical values: $P(0)=p$ and $P(1)=1-p$. A fair coin gives $P(0)=\frac{1}{2}$, $P(1)=\frac{1}{2}$. Nothing here is quantum. The bit itself is ordinary; the probabilities describe your ignorance of it, not the physics of it.

Qubit

A qubit state is written $|\psi ⟩=\alpha |0⟩+\beta |1⟩$, where $\alpha$ and $\beta$ are complex numbers satisfying $|\alpha {|}^2+|\beta {|}^2=1$. Measurement in the computational basis returns 0 with probability $|\alpha {|}^2$ and 1 with probability $|\beta {|}^2$.

The amplitudes are not probabilities. Probabilities are derived from the squared magnitudes of amplitudes — and that one extra step, the squaring, is where quantum mechanics keeps both its strangeness and its computational power.

Worked example: same odds, different states

Consider two states:

Measured immediately in the computational basis, both produce 0 half the time and 1 half the time. Watch only that measurement and the two states look identical.

They are not identical. The relative sign is phase information, and phase controls what happens under later gates. Take the Hadamard gate:

Apply $H$ to $|+⟩$:

Apply $H$ to $|-⟩$:

One gate turns $|+⟩$ into a definite 0 and $|-⟩$ into a definite 1. Same immediate measurement odds, different future behavior. That is the entire argument for why amplitudes — signs included — are the real state, and probabilities are only a shadow of it.

Why "tries all answers at once" misleads

The slogan points at a real fact: an $n$-qubit state carries amplitudes for $2^n$ basis states. Two qubits give $|\psi ⟩=a_{00}|00⟩+a_{01}|01⟩+a_{10}|10⟩+a_{11}|11⟩$; three qubits give eight amplitudes; the count doubles with every added qubit.

But measurement never lets you read those amplitudes. It returns one classical outcome, sampled according to the squared magnitudes. A quantum algorithm earns its speedup only by arranging for wrong answers to cancel through interference and right answers to reinforce — then sampling a distribution that has been shaped in your favor.

The better mental model: quantum algorithms are amplitude-engineering procedures. They do not merely create many branches. They create, transform, cancel, and amplify amplitudes, and then they sample.

Reversibility: the bridge from classical gates to quantum gates

Quantum evolution in a closed system is reversible, so quantum gates are not arbitrary functions — each one must preserve enough information to be undone. Classical AND fails that test:

a b | a AND b
0 0 | 0
0 1 | 0
1 0 | 0
1 1 | 1

Three different inputs map to output 0. Knowing the output is 0 tells you almost nothing about the input; information was destroyed.

The Toffoli gate repairs AND by keeping the inputs and writing the result into a target bit: $(a,b,c)\mapsto (a,b,c\oplus (a\wedge b))$. With $c=0$ this computes $(a,b,0)\mapsto (a,b,a\wedge b)$:

a b c | a b c'
0 0 0 | 0 0 0
0 1 0 | 0 1 0
1 0 0 | 1 0 0
1 1 0 | 1 1 1

The inputs survive in the output, so the map can be run backwards. This is the general pattern: any classical computation can be made reversible at modest cost, which is why everything a classical computer can do, a quantum computer can also do — the interesting question is always what it can do differently.

The model, stated precisely

A one-qubit pure state is a unit vector in a two-dimensional complex vector space: $|\psi ⟩=\alpha |0⟩+\beta |1⟩$ with $|\alpha {|}^2+|\beta {|}^2=1$. The computational basis is $|0⟩=\left(\begin{array}{c}1\\ 0\end{array}\right)$ and $|1⟩=\left(\begin{array}{c}0\\ 1\end{array}\right)$.

A valid one-qubit closed-system gate is a $2\times 2$ unitary matrix $U$, meaning $U^{†}U=I$, where the dagger is the conjugate transpose. Unitarity preserves normalization, so the squared magnitudes still sum to one after the operation — the mathematics refuses to let probabilities leak. Reversibility is not an extra assumption here; it falls straight out of the definition.

Misconceptions worth unlearning

"A qubit is both 0 and 1, so it stores two bits." A qubit state takes two amplitudes to describe, but measuring one qubit returns one classical bit. The computational benefit comes from interference staged across a whole circuit, never from reading all possible values at once.

"Observation means consciousness changes reality." Measurement is a physical interaction that produces classical information — a detector, an amplifier, a record. Nothing in the computational model requires mystical vocabulary, and this book uses none.

"More qubits automatically means a more useful computer." Useful quantum computation depends on gate fidelity, connectivity, coherence times, error correction, compilation, and application fit. A raw physical qubit count, on its own, tells you almost nothing.

The computer-science view

For a computer scientist, the clean bridge from classical to quantum runs through six substitutions:

• Bits become basis states.
• Probability distributions become the contrast class — the thing amplitudes are not.
• Logic gates become reversible transformations.
• Quantum gates become unitary matrices.
• Algorithms become procedures for arranging interference.
• Measurement becomes a sampling operation with information loss.

If you can follow a state transition, a probability distribution, and a matrix-vector multiplication, you already own every tool this guide uses.

What this means on hardware

A qubit is a physical system, not a symbol floating in space — superconducting circuit energy levels, ion internal states, neutral atom states, photonic modes, silicon spin states, or bosonic encodings — and every implementation has to answer the same seven questions:

• How is the qubit initialized?
• How is it controlled?
• How is it coupled to other qubits?
• How long does it preserve quantum information?
• How accurately can gates be applied?
• How is it measured?
• How does it scale?

Part VII of the book takes these questions modality by modality. For now, hold onto the shape of the list: it is the checklist every hardware claim eventually has to survive.

What this buys you in diligence

When you evaluate a quantum company, the first filter is not "how many qubits?" It is: what kind of information is being protected, transformed, and measured, and what evidence shows that quality improves as the system scales? The early questions that follow:

• Is the team improving physical qubit quality, or only increasing count?
• Is there a credible error-correction path?
• Do larger systems preserve performance, or degrade it?
• Does the company publish enough technical detail to verify progress?
• Are application claims benchmarked against named classical baselines?

A company that answers these well with fifty qubits is a better bet than one that dodges them with five thousand.

Exercises

1. Explain the difference between a bit, a probabilistic bit, and a qubit in fewer than 150 words.
2. Write down two states with the same computational-basis measurement probabilities but different relative phase.
3. Compute $H|+⟩$ and $H|-⟩$ by hand, showing every step.
4. Build the truth table for AND and explain, in one sentence, why it is irreversible.
5. Build the Toffoli truth table for all eight inputs and confirm the map is a permutation.
6. Write one paragraph explaining why quantum computing is not parallel classical computing.
7. Pick one company roadmap and identify whether it emphasizes physical qubits, logical qubits, error correction, applications, or cloud access.

Check your understanding

You have this guide when you can do three things without notes:

• Explain why an amplitude is not a probability, and where the squaring comes in.
• Use Hadamard interference to distinguish $|+⟩$ from $|-⟩$.
• Explain why reversibility is the bridge from classical circuits to quantum circuits.

What to read next

Part I of the book takes each idea in this guide and gives it a full chapter:

• Computation Is Physical — the four questions every computational model must answer.
• Qubits Without Mysticism — the state space of one qubit, without the slogans.
• Measurement and What It Does Not Mean — what measurement does, and what it refuses to do.

Then continue to Amplitudes, Measurement, and Gates, which turns the one-qubit picture into working mathematics.