A classical bit is easy to picture. It’s either 0 or 1, nothing more. A qubit works in a different way. So how do we actually describe what a qubit’s state looks like?
This question sits at the heart of quantum computing. Before you can understand quantum algorithms or quantum gates, you need to understand how a quantum state gets described.
In this guide, we’ll break down quantum state representation step by step, using simple language and clear examples.
What Is a Quantum State?
A quantum state describes the condition of a quantum system at a given moment.
For a single qubit, this state tells us everything we need to know to predict what happens when we measure it.
Think of it like a full description of “where things stand” for that qubit, before we check its value.
Classical Bit vs Qubit
A classical bit works in a simple way.
Classical bit:
- It’s either 0 or 1, always one or the other.
Qubit:
- Before measurement, it can be described as a combination of the basis states 0 and 1.
It’s tempting to say a qubit is “0 and 1 at the same time.” This phrase gets used a lot, but it’s a simplified way of describing something more precise. The real idea is called superposition, which we’ll explain properly a bit later.
What Are Basis States?
The two basic states of a qubit are written as |0⟩ and |1⟩.
These are called basis states. They work like the building blocks for any qubit state, similar to how 0 and 1 work for a classical bit.
Every possible qubit state can be described using these two basis states.
What Is Dirac or Ket Notation?
You’ll often see quantum states written with symbols like |0⟩, |1⟩, or |ψ⟩.
This is called Dirac notation, or ket notation. The symbol “ψ” (pronounced “sai”) is commonly used to represent a general quantum state.
This notation is just a standard way to write quantum states clearly. You don’t need advanced math to read it. Just think of the bars and angle brackets as a label that says “this is a quantum state.”
Representing a Qubit as a State Vector
A qubit’s state is commonly written like this:
|ψ⟩ = α|0⟩ + β|1⟩
Here’s what each part means:
- |ψ⟩ – the full quantum state of the qubit
- |0⟩ and |1⟩ – the two basis states
- α and β – numbers called probability amplitudes
These amplitudes tell us how much each basis state contributes to the overall state. They can be complex numbers, meaning they may include an imaginary part. For this guide, we’ll keep the math light and focus on the core idea.
What Are Probability Amplitudes?
Probability amplitudes are numbers attached to each basis state in a quantum state.
Here’s an important point: amplitudes are not the same as probabilities.
To find the actual probability of a measurement result, you square the size (called the magnitude) of the amplitude:
P(0) = |α|²
P(1) = |β|²
There’s also a rule called normalization. The total probability must always add up to 1, or 100%:
|α|² + |β|² = 1
This makes sense. When you measure a qubit, you must get some result, either 0 or 1, so the probabilities must add up to full certainty.
Simple Quantum State Examples
Let’s look at a few basic examples.
Example 1: |0⟩
This state means measurement will always give 0. There’s no uncertainty here.
Example 2: |1⟩
This state means measurement will always give 1.
Example 3: Equal Superposition
Consider this state:
|ψ⟩ = (1/√2)|0⟩ + (1/√2)|1⟩
Here, measurement gives 0 or 1 with equal probability, 50% each. Squaring 1/√2 gives 1/2, which matches this equal chance.
What Is Superposition?
Superposition means a qubit’s state can be described as a combination of basis states, before it gets measured.
It’s not that the qubit is “doing both things at once” in a literal sense. Instead, the state itself is a mathematical combination of |0⟩ and |1⟩, with specific amplitudes attached to each.
Simple example: In our equal superposition example above, the qubit’s state includes both |0⟩ and |1⟩, each with the same amplitude. Only when we measure it do we get one definite result, 0 or 1.
What Happens During Measurement?
Measurement is the moment we check a qubit’s value and get a classical result.
Here’s what happens:
- Measurement always gives a classical result, either 0 or 1.
- A qubit described by superposition can give either result.
- The probability of each result depends on the state’s amplitudes.
- In the standard picture of measurement, the act of measuring changes the qubit’s state.
Once measured, the qubit settles into the specific basis state that matched the result. The superposition, in this sense, is gone after measurement.
Quantum State Representation and the Bloch Sphere
The Bloch sphere gives us a visual way to picture a single qubit’s state.
Picture a sphere, similar to a globe. Any pure single-qubit state can be shown as a point on this sphere’s surface.
The general form looks like this:
|ψ⟩ = cos(θ/2)|0⟩ + e^(iφ) sin(θ/2)|1⟩
You don’t need to calculate anything with this formula as a beginner. Just know that θ (theta) and φ (phi) are angles that describe where the point sits on the sphere. Together, they pin down the qubit’s exact state.
Why the Bloch Sphere Is Useful
The Bloch sphere helps beginners build a mental picture for several ideas:
- How qubit states look and differ from each other
- How superposition appears visually
- How a state changes over time
- How quantum gates move a state around the sphere
- How measurement relates to specific directions on the sphere
Instead of just working with equations, learners can picture qubit states as points and movements on a sphere. This makes abstract ideas much easier to follow.
Quantum State Representation for Multiple Qubits
A single qubit needs two basis states. Two qubits together need more.
With two qubits, we use four basis states:
- |00⟩
- |01⟩
- |10⟩
- |11⟩
A two-qubit state can be written as a combination of these four states, each with its own amplitude. This works the same way as single-qubit states, just with more basis states involved.
We won’t go deep into the math behind combining qubit spaces here. The key idea is simple: more qubits mean more basis states, and more possible combinations.
Simple Two-Qubit Example
Here’s a well-known two-qubit state:
|ψ⟩ = (1/√2)|00⟩ + (1/√2)|11⟩
In plain words, this state is a combination of |00⟩ and |11⟩, each with equal amplitude.
This specific state is called a Bell state, and it’s a clear example of an entangled state. Not every two-qubit superposition works this way, though. Many superpositions are not entangled at all.
Product States vs Entangled States
There’s an important difference between these two types of states.
Product State
This is a state that can be described as separate, independent states for each qubit. You could write each qubit’s state on its own, and combine them.
Entangled State
This is a state where the qubits can’t be described separately. The joint state carries information that isn’t captured by looking at each qubit alone.
Simple example: In the Bell state above, if you measure one qubit and get 0, you instantly know the other qubit will also give 0. This tight connection is a sign of entanglement.
Quantum State Representation in Quantum Programming
When writing quantum programs, these same ideas show up directly.
You’ll often work with:
- Qubits – The basic units your code manipulates.
- Quantum circuits – A sequence of steps applied to qubits.
- Quantum gates – Operations that change a qubit’s state.
- State vectors – The underlying math describing your qubits.
- Measurement – The step where you read out a classical result.
Most quantum programming tools let you build a circuit, apply gates, and then measure the result. This article isn’t a programming tutorial, but it’s worth knowing these ideas map directly onto the concepts covered here.
Quantum Gates and State Changes
Quantum gates are operations that change a qubit’s state.
Simple examples:
- The X gate changes |0⟩ into |1⟩, and |1⟩ into |0⟩. It works a bit like a classical NOT gate.
- The H gate (Hadamard gate) can turn |0⟩ into an equal superposition of |0⟩ and |1⟩.
Each gate moves a qubit’s state to a new point, whether you picture that as a new state vector or a new point on the Bloch sphere. We won’t cover the matrix math behind these gates here, but knowing what they do is a solid starting point.
Why Quantum State Representation Matters
Understanding how quantum states are written helps with several practical goals:
- Understanding what a qubit actually is
- Building and reading quantum circuits
- Following how quantum algorithms work
- Calculating the probability of measurement results
- Understanding what quantum gates actually do
- Learning quantum programming with real understanding, not just memorized steps
Every other topic in quantum computing builds on this foundation.
Common Beginner Mistakes
- Thinking a qubit is simply both 0 and 1 – The real idea is superposition, a specific combination of basis states.
- Confusing amplitudes with probabilities – Remember, you must square the amplitude’s magnitude to get a probability.
- Forgetting normalization – The probabilities from a valid quantum state always add up to 1.
- Assuming every superposition is entangled – Entanglement is specific to multi-qubit states with a particular kind of connection.
- Thinking measurement gives a superposition result – Measurement always gives one classical result, 0 or 1.
- Ignoring phase – The angle φ in the Bloch sphere formula matters, even though it’s easy to overlook at first.
- Trying to learn advanced formulas too early – Build a solid grasp of the basics first, then move to harder math.
These mistakes are common, and almost everyone runs into a few of them while learning.
Quantum State Representation: Simple Summary
| Concept | Simple Meaning |
|---|---|
| Qubit | Basic unit of quantum information |
| |0⟩ | One computational basis state |
| |1⟩ | Other computational basis state |
| Superposition | A combination of basis states |
| Amplitude | A number describing a state’s contribution |
| Probability | The likelihood of a measurement result |
| State vector | The mathematical description of a quantum state |
| Bloch sphere | A visual model for a single qubit’s state |
| Entanglement | A special connection between quantum systems |
FAQs
1. What is a quantum state?
A quantum state describes the condition of a quantum system, like a qubit, and predicts what happens when it’s measured.
2. How is a qubit’s state represented mathematically?
It’s written as |ψ⟩ = α|0⟩ + β|1⟩, where α and β are probability amplitudes attached to the basis states.
3. What does the symbol |0⟩ mean?
It represents one of the two basic states a qubit can be measured in, similar to the classical value 0.
4. What does the symbol |1⟩ mean?
It represents the other basic state a qubit can be measured in, similar to the classical value 1.
5. What is a state vector in quantum computing?
It’s the mathematical description of a quantum state, showing how much each basis state contributes.
6. What are probability amplitudes?
They are numbers attached to each basis state that determine, after squaring, the probability of each measurement result.
7. How are measurement probabilities calculated from amplitudes?
You square the magnitude of each amplitude. For example, P(0) equals the amplitude for |0⟩ squared.
8. What is superposition in simple terms?
It means a qubit’s state is described as a combination of basis states before measurement happens.
9. What is the Bloch sphere used for?
It gives a visual, geometric way to represent the state of a single qubit as a point on a sphere.
10. How are states of multiple qubits represented?
Multiple qubits use more basis states, like |00⟩, |01⟩, |10⟩, and |11⟩ for two qubits, combined with their own amplitudes.
Conclusion
Quantum state representation is the foundation for everything else in quantum computing. Once you understand how a qubit’s state gets written, using basis states, amplitudes, and vectors, ideas like superposition, measurement, and entanglement start to make much more sense.
Take these ideas one step at a time. Start with a single qubit, get comfortable with |0⟩, |1⟩, and superposition, then move on to multiple qubits and entanglement. The math can wait until the core ideas feel solid.
