Quantum Gates Explained With Code: X, H, Z, CNOT, SWAP, and More

Overview

This article is a code-first reference for developers learning how quantum circuit gates work in practice. The goal is not to cover every mathematical detail. The goal is to help you answer the questions that usually matter when building or reading a circuit:

• What does this gate do to a qubit state?
• When would I use it in a circuit?
• How do I write it in code?
• What common mistakes should I watch for?

At a high level, a quantum gate is an operation applied to one or more qubits. In classical computing, you might think in terms of logic operations on bits. In quantum computing, gates manipulate amplitudes and phases, and when multiple qubits interact, they can create entanglement. That difference is why a short quantum circuit can look simple in code while behaving in a way that is not obvious from a classical mindset alone.

Before diving into individual gates, keep three practical ideas in mind:

1. Measurement is not the same as state. A qubit may be in a superposition before measurement, but you only observe a classical outcome when you measure.
2. Phase matters. Some gates appear to do nothing if you only look at raw measurement counts in the computational basis. They still matter because phase changes affect later interference.
3. Gate order matters. Quantum gates are not generally interchangeable. Reordering them can change the output.

If you are still getting comfortable with basic qubit ideas, it helps to pair this guide with a broader learning plan such as Quantum Computing Roadmap for Beginners: What to Learn First in 2026. And if you are deciding where to practice these examples, see Qiskit vs Cirq vs PennyLane: Which Quantum SDK Should Developers Learn First?.

Throughout this tutorial, we will use the standard basis states:

• |0⟩: the default qubit state
• |1⟩: the flipped basis state

And we will refer to two especially important superposition states:

• |+⟩ = (|0⟩ + |1⟩)/√2
• |−⟩ = (|0⟩ − |1⟩)/√2

Template structure

The most reusable way to learn a gate is to examine it with the same template each time: intuition, state effect, circuit role, code, and gotchas. Below, that structure is applied to the most common quantum circuit gates.

X gate: the quantum bit flip

The X gate is the easiest gate to understand first. It flips the computational basis states:

• X|0⟩ = |1⟩
• X|1⟩ = |0⟩

If you come from a classical programming background, X is the closest thing to a NOT gate. But remember that on a superposition state, it flips amplitudes between the basis states rather than simply toggling a stored classical value.

When it is useful: initializing a qubit into |1⟩, testing circuits, building controlled operations, and creating basis-state inputs for algorithms.

Qiskit:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.x(0)
qc.measure(0, 0)
print(qc)

Cirq:

import cirq

q = cirq.LineQubit(0)
circuit = cirq.Circuit(
    cirq.X(q),
    cirq.measure(q, key='m')
)
print(circuit)

Common mistake: assuming X is the only way to think about state change. It is easy to overuse basis-state intuition and miss what happens once superposition and phase enter the circuit.

H gate: the Hadamard gate

The Hadamard gate, usually written as H, is one of the most important gates in any quantum programming tutorial because it creates and reverses equal superposition in the computational basis.

• H|0⟩ = |+⟩
• H|1⟩ = |−⟩

Applied to |0⟩, H gives a 50/50 chance of measuring 0 or 1. That makes it a standard tool for introducing superposition. But its deeper value is not randomness by itself. It changes the basis in a way that enables interference later in the circuit.

When it is useful: creating superposition, preparing search spaces in Grover-style circuits, changing basis, and setting up interference patterns.

Qiskit:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0, 0)
print(qc)

Cirq:

import cirq

q = cirq.LineQubit(0)
circuit = cirq.Circuit(
    cirq.H(q),
    cirq.measure(q, key='m')
)
print(circuit)

Common mistake: equating H with “make it random.” That description is useful at first, but incomplete. H is more accurately a basis transformation that often enables structured interference, not just a randomness switch.

Z gate: phase flip

The Z gate leaves |0⟩ unchanged and flips the phase of |1⟩:

• Z|0⟩ = |0⟩
• Z|1⟩ = −|1⟩

If you only measure immediately after applying Z to a qubit in |0⟩ or |1⟩, it can appear as though nothing happened. That is why Z confuses many beginners. Its effect becomes visible when the qubit later interferes with other amplitudes.

For example, if a qubit is in |+⟩ and you apply Z, the state becomes |−⟩. The measurement probabilities in the computational basis are still 50/50, but the relative phase has changed.

When it is useful: phase kickback patterns, oracle construction, basis-sensitive circuit design, and understanding why amplitude interference works.

Qiskit:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.z(0)
qc.h(0)
qc.measure(0, 0)
print(qc)

This sequence is useful because H-Z-H acts like X on the computational basis.

Cirq:

import cirq

q = cirq.LineQubit(0)
circuit = cirq.Circuit(
    cirq.H(q),
    cirq.Z(q),
    cirq.H(q),
    cirq.measure(q, key='m')
)
print(circuit)

Common mistake: dismissing phase gates because they do not always change measurement counts immediately.

CNOT gate: controlled bit flip

The CNOT gate is one of the core two-qubit gates in quantum circuit design. It has a control qubit and a target qubit. If the control is |1⟩, it applies X to the target. If the control is |0⟩, it does nothing to the target.

On basis states:

• |00⟩ → |00⟩
• |01⟩ → |01⟩
• |10⟩ → |11⟩
• |11⟩ → |10⟩

Its real importance appears when the control is in superposition. If you apply H to the control qubit and then CNOT, you can create an entangled Bell state. This is a foundational circuit pattern in many quantum algorithms tutorials.

When it is useful: creating entanglement, implementing controlled logic, building Bell states, error-correction demonstrations, and many algorithm subroutines.

Qiskit Bell state example:

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
print(qc)

Cirq Bell state example:

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key='m')
)
print(circuit)

Common mistake: reading CNOT like a classical if-statement. In a quantum circuit, if the control is in superposition, the result can be entanglement, not a simple branch in execution.

SWAP gate: exchange two qubits

The SWAP gate exchanges the states of two qubits:

• |ab⟩ → |ba⟩

At first glance, SWAP may look less interesting than H or CNOT, but it becomes practical very quickly when hardware connectivity is limited or when a compiler needs to move logical qubits across a device layout.

When it is useful: routing states, adapting to connectivity constraints, reorganizing circuit layout, and understanding transpilation overhead.

Qiskit:

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)
qc.x(0)
qc.swap(0, 1)
qc.measure([0, 1], [0, 1])
print(qc)

Cirq:

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0),
    cirq.SWAP(q0, q1),
    cirq.measure(q0, q1, key='m')
)
print(circuit)

Common mistake: treating SWAP as only a conceptual teaching gate. In practice, it matters because real hardware topologies may force additional SWAPs during compilation. For more context on why implementation details matter beyond the abstract circuit, see From Quantum Hardware to Useful Output: Where Control, Readout, and Error Handling Fit.

Related gates worth knowing early

Once you understand X, H, Z, CNOT, and SWAP, a few nearby gates become easier:

• Y: combines bit and phase behavior.
• S and T: phase rotation gates commonly seen in compiled circuits.
• CZ: controlled phase flip, often interchangeable with CNOT up to basis changes.
• RX, RY, RZ: parameterized rotation gates used in variational circuits such as VQE and QAOA.

You do not need to master all of them before writing useful circuits, but you should recognize them when they appear in SDK output or algorithm examples.

How to customize

The best way to make this guide useful over time is to turn each gate into a repeatable inspection pattern in your own workflow. When you encounter a new circuit, ask the same five questions:

1. What is the input state? A gate can look trivial or powerful depending on the state it receives.
2. Does the gate change basis, phase, amplitude, or entanglement? This helps you classify its role quickly.
3. Will the effect be visible immediately in measurement counts? If not, look for later interference steps.
4. Is the gate native in my SDK or backend? Some gates are conceptual, while compilers decompose them into lower-level operations.
5. What is the nearest classical analogy, and where does it fail? This is a useful way to avoid carrying classical assumptions too far.

Developers often learn faster when they compare the same pattern across frameworks. Here is a practical customization strategy:

• Start with one-qubit circuits and print or draw them.
• Simulate before measuring so you can inspect statevectors when available.
• Add measurement only after you understand the pre-measurement state change.
• Run the same example in both Qiskit and Cirq if you are still choosing a stack.
• Keep a personal notebook of “same gate, different basis” examples.

Another useful customization is to separate conceptual learning circuits from hardware-aware circuits. In conceptual learning, you can focus on idealized behavior: H creates superposition, CNOT entangles, Z changes phase. In hardware-aware work, you also care about routing, coupling maps, native gate sets, transpilation, and noise. That is where a simple gate like SWAP becomes more than a textbook operation.

If you want to connect gate-level understanding to broader engineering decisions, these related reads can help:

• How to Evaluate Quantum Cloud Platforms Like an Engineering Manager
• Resource Estimation for Real Teams: What It Means to Budget a Quantum Workload
• Why Qubit State Space Matters More Than Qubit Count

When building your own quantum programming tutorial notes, a strong format is:

• Gate name
• Matrix only if needed
• Effect on |0⟩ and |1⟩
• Effect on |+⟩ and |−⟩
• One minimal code snippet
• One two-gate or three-gate pattern that reveals its real role
• One mistake to avoid

That structure keeps the topic concrete and reusable instead of overly abstract.

Examples

Below are a few compact circuit patterns that make the earlier gates easier to remember.

Example 1: H followed by H returns to the starting basis

The Hadamard gate is its own inverse. In practice, that means applying H twice restores the original computational basis state.

from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.h(0)
qc.measure(0, 0)

This is useful when you want to show that H is not “random forever.” It changes basis, and applying it again can undo that change.

Example 2: H + CNOT creates entanglement

This is the canonical Bell-state pattern:

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

Expected measurement behavior in an ideal simulation: mostly 00 and 11, with correlated outcomes. This is one of the cleanest CNOT gate examples because it shows why controlled gates matter beyond basis-state flipping.

Example 3: HZH behaves like X

This short pattern is a good reminder that basis changes can convert one kind of action into another:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.z(0)
qc.h(0)
qc.measure(0, 0)

If the qubit starts in |0⟩, this sequence produces |1⟩ after measurement in the ideal case. It is one of the best beginner examples for understanding phase through basis transformation instead of trying to reason about phase only through direct measurement.

Example 4: SWAP moves information, not just wires on paper

Suppose q0 holds |1⟩ and q1 holds |0⟩. After SWAP, those roles reverse.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0),
    cirq.SWAP(q0, q1),
    cirq.measure(q0, q1, key='m')
)

This example is simple, but the underlying lesson is important: in real quantum software tools, logical qubit placement can affect circuit cost.

Example 5: Controlled-Z and CNOT are close cousins

If you see CZ in a framework or backend, do not treat it as a completely different world. A common identity is that CNOT can be built from basis changes around CZ. Conceptually:

CNOT(control, target) = H(target) -> CZ(control, target) -> H(target)

This kind of equivalence matters when reading transpiled circuits or comparing SDK documentation.

When to update

Use this article as a living reference, and revisit it whenever your learning context changes. The core gate concepts are stable, but the most useful examples and code patterns can shift with your workflow.

Update your mental model when:

• You move from beginner simulations to hardware-oriented runs.
• You switch SDKs or start comparing Qiskit, Cirq, and PennyLane.
• You begin reading algorithm papers or notebooks that use phase-based reasoning heavily.
• You start working with transpilers, routing, or backend-native gate sets.
• You notice that measurement counts alone are no longer enough to explain a circuit.

Update your code reference when:

• SDK syntax changes.
• Preferred simulation tools change.
• Your team standardizes on a different framework.
• You begin using parameterized or compiled gates more often than textbook gates.

A practical next step is to build a small local notebook with one section per gate and three test circuits for each:

1. A basis-state example
2. A superposition or phase example
3. A multi-qubit example showing interaction with another gate

That notebook becomes your personal quantum SDK guide over time. It also makes debugging easier, because many circuit bugs come down to one of four issues: wrong qubit index, wrong gate order, misunderstanding phase, or measuring too early.

If you want to keep extending this reference, a sensible sequence is:

1. Master X, H, Z, CNOT, and SWAP
2. Add Y, S, T, and CZ
3. Learn RX, RY, and RZ for parameterized circuits
4. Study how these gates compose inside VQE, QAOA, and Grover-style patterns

The most useful takeaway is simple: do not memorize gate names in isolation. Learn them as circuit-building tools with predictable roles. Once you can recognize what a gate does to basis, phase, and qubit relationships, most quantum coding examples become easier to read, adapt, and debug.

And if you are choosing what to learn next after gate basics, revisit Quantum Computing Roadmap for Beginners: What to Learn First in 2026 and Qiskit vs Cirq vs PennyLane: Which Quantum SDK Should Developers Learn First? to map gate knowledge into a fuller developer workflow.