First time studying this topic?

Launch the interactive walkthrough to discover each component, including the 3D Q-Sphere Lab & Python in Colab.

Back to Quantum Circuits and Gates
Topic 6.6

The Pauli-Z Gate: The Phase-Flip Operator

Master the phase-flip gate: leaving |0> unchanged while multiplying |1> by -1, rotating 180 degrees around the Z-axis.

Learning Objectives

  • βœ“Define the Pauli-Z matrix: [[1, 0], [0, -1]]
  • βœ“Understand the Phase Flip: Z|0> = |0> and Z|1> = -|1>
  • βœ“Examine how phase flips convert |+> to |-> without altering measurement probabilities in the Z-basis

πŸ“–Let's Begin with a Story

Suppose you have a light bulb in a dark room. If you flip the switch (an X gate), the light turns ON or OFF. Everyone in the room can see the change immediately. Now imagine a magical quantum switch called the Pauli-Z Gate. - If the bulb is OFF (∣0⟩|0\rangle), it does nothing (Z∣0⟩=∣0⟩Z|0\rangle = |0\rangle). - If the bulb is ON (∣1⟩|1\rangle), it keeps the light ON, but subtly changes its invisible quantum phase by 180 degrees (Z∣1⟩=βˆ’βˆ£1⟩Z|1\rangle = -|1\rangle)! If you look at the bulb with your naked eye (measuring in the classical Z-basis), you notice absolutely nothing! It still looks 100% ON (βˆ£βˆ’1∣2=1.0|-1|^2 = 1.0). The phase change is completely invisible to classical eyesβ€”until you collide it with another wave in a quantum interference circuit!

Why Should You Learn The Pauli-Z Gate: The Phase-Flip Operator?

🎯 Practical & Engineering Stakes

The secret weapon of quantum algorithms

In Grover’s search, Shor’s algorithm, and Quantum Fourier Transforms, the computer never flips bits directly; it marks answers by flipping their phase using Z gates.

What Is It?

Simple Explanation

The Pauli-Z gate is a Phase-Flip: - It leaves ∣0⟩|0\rangle completely untouched. - It attaches a minus sign (βˆ’1-1) to ∣1⟩|1\rangle. - It turns ∣+⟩|+\rangle into βˆ£βˆ’βŸ©|-\rangle! On the Bloch sphere globe, it spins the earth 180 degrees around the North-South axis (the Z-axis).

Technical Explanation

The Pauli-Z operator Οƒz∈C2Γ—2\sigma_z \in \mathbb{C}^{2 \times 2} is represented in the computational basis by the diagonal matrix: Z=(100βˆ’1)Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} It acts as Z∣x⟩=(βˆ’1)x∣x⟩Z|x\rangle = (-1)^x |x\rangle. It leaves the computational basis states invariant up to eigenvalue (Z∣0⟩=+1∣0⟩,Z∣1⟩=βˆ’1∣1⟩Z|0\rangle = +1|0\rangle, Z|1\rangle = -1|1\rangle), but maps transverse states Z∣+⟩=βˆ£βˆ’βŸ©Z|+\rangle = |-\rangle and Zβˆ£βˆ’βŸ©=∣+⟩Z|-\rangle = |+\rangle.

πŸ“š Key Terms

Pauli-Z Gate (Phase Flip)

Simple: Leaves 0 alone, but puts a minus sign on 1.
Technical: The diagonal Οƒz\sigma_z operator introducing a relative phase shift of Ο€\pi radians between computational basis states.

Phase Invariant

Simple: A state whose probability of measuring 0 and 1 doesn’t change after applying a phase gate.
Technical: An observable property where diagonal basis projections ∣⟨z∣ψ⟩∣2|\langle z | \psi \rangle|^2 remain invariant under ZZ.

Q-Sphere Lab: The Pauli-Z Gate: The Phase-Flip Operator

IBM Q-Sphere Model

Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 6.6

Azimuth: 45Β°Elevation: 25Β°
+Z |0⟩-Z |1⟩+X |+⟩+Y |+i⟩01|ψ⟩
Q-Sphere Phase Color:
0 Ο€/2 Ο€ 3Ο€/2

Quantum Statevector

dim(H) = 2
|ψ⟩ = (1.000 + 0.000i)|0⟩
     + (0.000 + 0.000i)|1⟩
Polar Angle (ΞΈ):0.0Β° (0.000Ο€ rad)
Phase Angle (Ο•):0.0Β° (0.000Ο€ rad)

Born Rule Probabilities: P(x) = |⟨x|ψ⟩|²Σ P = 1.00

P(|0⟩) = |α|²100.0%
P(|1⟩) = |β|²0.0%
Quantum Measurement

Apply Single-Qubit Unitary Gates

Presets:
Continuous Polar Angle θ (0° = |0⟩, 180° = |1⟩):0.0°
Continuous Phase Angle Ο• (0Β° to 360Β°):0.0Β°
Recent Operations Log:
#1Initial state: |0⟩

πŸ“ Mathematical Foundation

LaTeX KaTeX
Z=(100βˆ’1),Z∣0⟩=∣0⟩,Z∣1⟩=βˆ’βˆ£1⟩,Z∣+⟩=βˆ£βˆ’βŸ©Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}, \quad Z |0\rangle = |0\rangle, \quad Z |1\rangle = -|1\rangle, \quad Z |+\rangle = |-\rangle

What does it mean?

The Pauli-Z Phase-Flip Gate: Leaves basis state ∣0⟩|0\rangle untouched (Z∣0⟩|0\rangle = ∣0⟩|0\rangle), but inverts the sign of basis state ∣1⟩|1\rangle (Z∣1⟩|1\rangle = -∣1⟩|1\rangle). It acts as the fundamental phase-manipulation tool, converting in-phase superposition ∣+⟩|+\rangle into out-of-phase superposition |β€“βŸ©.

Understanding the Symbols

Symbol / TermMeaningBeginner Interpretation
ZZPauli-Z matrixDiagonal phase-inversion operator [[1, 0], [0, -1]]
Z∣0⟩=∣0⟩Z |0\rangle = |0\rangleZero invarianceBasis state 0 experiences zero phase shift
Z∣1⟩=βˆ’βˆ£1⟩Z |1\rangle = -|1\ranglePhase flip on 1Basis state 1 is multiplied by -1 (180-degree phase shift)
Z∣+⟩=βˆ£βˆ’βŸ©Z |+\rangle = |-\rangleSuperposition phase toggleTransforms (∣0⟩+∣1⟩)/2(|0\rangle+|1\rangle)/\sqrt{2} into (∣0βŸ©βˆ’βˆ£1⟩)/2(|0\rangle-|1\rangle)/\sqrt{2}

πŸ“Š Numerical Example

Applying Pauli-Z to equal superposition state |+⟩ = [1/√2, 1/√2]^T:

Step 1: Write input vector: ∣+⟩|+\rangle = [1/√2, 1/√2]^T Step 2: Multiply by Z matrix: Z ∣+⟩|+\rangle = [[1, 0], [0, -1]] Γ— [1/√2, 1/√2]^T = [(1 Γ— 1/√2 + 0 Γ— 1/√2), (0 Γ— 1/√2 + (-1) Γ— 1/√2)]^T = [1/√2, -1/√2]^T = (∣0⟩|0\rangle - ∣1⟩|1\rangle)/√2 = βˆ£βˆ’βŸ©|-\rangle Step 3: Measure in computational basis: P(0) = |1/√2|^2 = 0.50 (50%) P(1) = |-1/√2|^2 = (-1/√2)^2 = 0.50 (50%)

Result: Probabilities remain 50/50, but the internal quantum phase is flipped from + to -, ready for interference.

βš™οΈ How Does It Work?

1

Diagonal Action

Leaves |0> amplitude unchanged (multiplies by +1).

2

Phase Inversion

Multiplies |1> amplitude by -1.

3

Z-Axis Rotation

Rotates equator coordinates by 180 degrees around vertical Z-axis.

🌍 Where Is It Used?

The Oracle in Grover’s Algorithm

Problem: Marking the winning item in an unsorted database without destroying the superposition.

Solution: The Grover Oracle applies a controlled-Z gate that flips the phase of the winning solution to negative: -|winner>.

🎯 Try It Yourself

If you have a qubit in state |1>, and you apply a Pauli-Z gate, what is the resulting state vector?

Interactive activity component

🐍 Python Hands-On: Simulating the Pauli-Z Phase-Flip Gate in Qiskit

Demonstrate the quantum phase-flip gate: show that Z leaves |0> unaffected while flipping the relative phase of |1> to -|1>.

Open Colab

1Install Required Packages

For Google Colab or Jupyter notebooks, run this shell command to install the required dependencies:

Terminal / Notebook Install Commandbash
!pip install qiskit
Packages:
qiskit

2Import Libraries

Import Statementspython
1from qiskit import QuantumCircuit
2from qiskit.quantum_info import Statevector

from qiskit import QuantumCircuit β†’ Circuit module

from qiskit.quantum_info import Statevector β†’ Statevector module

3Demonstration Code & Logic

Python Execution Codepython
1# 1. Action on Basis States: Z|0> = |0>, Z|1> = -|1>
2qc_basis = QuantumCircuit(1)
3qc_basis.z(0)  # Z on |0>
4print('Z on |0> -> Leaves state unchanged:', Statevector.from_instruction(qc_basis).data.round(2))
5 
6# 2. Action on Superposition: Z|+> = |->
7qc_super = QuantumCircuit(1)
8qc_super.h(0)  # Create |+> = (|0> + |1>)/sqrt(2)
9print('Before Z (State |+>):', Statevector.from_instruction(qc_super).data.round(3))
10qc_super.z(0)  # Apply Z -> transforms to |-> = (|0> - |1>)/sqrt(2)
11sv_minus = Statevector.from_instruction(qc_super)
12print('After Z  (State |->):', sv_minus.data.round(3))
13print('Notice: Probabilities for both |+> and |-> are 50/50, but relative phase is flipped!')
Step-by-Step Code Breakdown:

# 1. Action on Basis States: Z|0> = |0>, Z|1> = -|1>

Basis action

qc_basis = QuantumCircuit(1)

Init |0>

qc_basis.z(0) # Z on |0>

Apply Z to 0

print('Z on |0> -> Leaves state unchanged:', Statevector.from_instruction(qc_basis).data.round(2))

Result [1, 0]

# 2. Action on Superposition: Z|+> = |->

Superposition action

qc_super = QuantumCircuit(1)

Init qubit

qc_super.h(0) # Create |+> = (|0> + |1>)/sqrt(2)

Put in |+>

print('Before Z (State |+>):', Statevector.from_instruction(qc_super).data.round(3))

[0.707, 0.707]

qc_super.z(0) # Apply Z -> transforms to |-> = (|0> - |1>)/sqrt(2)

Apply Z

sv_minus = Statevector.from_instruction(qc_super)

Extract state

print('After Z (State |->):', sv_minus.data.round(3))

[0.707, -0.707]

print('Notice: Probabilities for both |+> and |-> are 50/50, but relative phase is flipped!')

Phase insight

πŸ“‹ Complete Script (All-in-One)

Click "Copy for Colab", open Google Colab, paste into a single cell, and run.

Google Colab Notebook Scriptpython
1# =========================================================
2# Simulating the Pauli-Z Phase-Flip Gate in Qiskit
3# Prepared for Google Colab (Run with Shift + Enter)
4# =========================================================
5 
6# Step 1: Install required packages
7!pip install qiskit
8 
9# Step 2: Import libraries
10from qiskit import QuantumCircuit
11from qiskit.quantum_info import Statevector
12 
13# Step 3: Run Demonstration
14# 1. Action on Basis States: Z|0> = |0>, Z|1> = -|1>
15qc_basis = QuantumCircuit(1)
16qc_basis.z(0)  # Z on |0>
17print('Z on |0> -> Leaves state unchanged:', Statevector.from_instruction(qc_basis).data.round(2))
18 
19# 2. Action on Superposition: Z|+> = |->
20qc_super = QuantumCircuit(1)
21qc_super.h(0)  # Create |+> = (|0> + |1>)/sqrt(2)
22print('Before Z (State |+>):', Statevector.from_instruction(qc_super).data.round(3))
23qc_super.z(0)  # Apply Z -> transforms to |-> = (|0> - |1>)/sqrt(2)
24sv_minus = Statevector.from_instruction(qc_super)
25print('After Z  (State |->):', sv_minus.data.round(3))
26print('Notice: Probabilities for both |+> and |-> are 50/50, but relative phase is flipped!')
⚑ How to Run in Google Colab (3 Quick Steps)
  1. Click "Copy for Google Colab" above.
  2. Click Open New Google Colab Notebook (opens in a new tab).
  3. Click on the first empty code cell, press Ctrl + V (or Cmd + V) to paste, then press Shift + Enter to execute!
Launch Blank Colab Notebook

πŸ”„ Algorithmic Execution Flow

1
Apply Z to |0>

Verify that basis state |0> is an eigenstate with eigenvalue +1.

β†’
2
Apply Z to |+>

Verify that relative phase flips, transforming |+> into |-> with eigenvalue -1 on the |1> component.

β†’
3
Compare Probabilities

Observe that measurement probabilities remain 50/50, demonstrating phase sensitivity.

πŸ“₯ Input / Initial State
Quantum circuits applying Z to |0> and |+>.
πŸ“€ Expected Output
Z on |0> -> [1.0, 0.0]
Before Z (|+>): [0.707, 0.707]
After Z (|->): [0.707, -0.707]
πŸ’‘ What Does This Demonstration Show?

The Pauli-Z gate has no classical equivalent: it leaves classical probabilities unchanged while altering the relative quantum phase that drives wave interference in quantum algorithms.

Course Learning Resource β€’ Slide DeckLesson 810 Slides

Lesson 8: Two Qubits and Entanglement

Hadamard, CNOT, Bell-state intuition, and correlated quantum circuits.

Author: Dr. Syed Muzamil Bashaβ€’ FDP Approved Curriculum
Open in New Tab

πŸ“ Learning Check

Test your understanding with these questions. Remember, this is for learning, not examination!

Question 1: Which of the following describes the difference between a Pauli-X gate and a Pauli-Z gate?

Question 2: What operation does the Pauli-Z gate perform?

Question 3: What is the matrix representation of the Pauli-Z gate?

Question 4: Why doesn't the Z gate appear to change |0⟩ or |1⟩ when measured?

Question 5: What is an important application of the Z gate?

Previous: The Pauli-Y Gate: Bit and Phase Flip with Complex NumbersNext: The Hadamard Gate: The Superposition Generator