Inner and Outer Products

Quantum states are represented as vectors in a Hilbert space. Defining how these vectors interact is fundamental for analyzing quantum systems. In classical mechanics, vectors are often compared using the dot product to determine angles or projection. Quantum mechanics utilizes two specific operations to extract information from a system or transform it: the inner product and the outer product.

These operations act as the computational engine for quantum algorithms. The inner product allows us to calculate probabilities and check if states are distinct. The outer product allows us to build operators (matrices) from vectors, which is how we construct quantum gates and measurements.

The Inner Product

The inner product is a scalar multiplication of two vectors. In Dirac notation, it combines a bra $\langle \psi |$ and a ket $| \phi \rangle$ to form the bracket $\langle \psi | \phi \rangle$. The result of this operation is a single complex number, not a vector.

Mathematically, to calculate the inner product of two vectors $a$ and $b$, you calculate the conjugate transpose of the first vector and multiply it by the second vector. If we have two column vectors:

$$|a\rangle = \begin{bmatrix} a_1 \\ a_2 \end{bmatrix}, \quad |b\rangle = \begin{bmatrix} b_1 \\ b_2 \end{bmatrix}$$

The inner product $\langle a | b \rangle$ is:

$$\langle a | b \rangle = \begin{bmatrix} a_1^* & a_2^* \end{bmatrix} \begin{bmatrix} b_1 \\ b_2 \end{bmatrix} = a_1^* b_1 + a_2^* b_2$$

The symbol $*$ denotes the complex conjugate. This means if an element is $x + iy$, it becomes $x - iy$. This conjugation is strictly required. Unlike the standard dot product in real Euclidean space, the order matters in complex vector spaces. $\langle a | b \rangle$ is the complex conjugate of $\langle b | a \rangle$.

Visualizing Vector Multiplication

The structural difference between inner and outer products relies on the order of multiplication. The inner product "collapses" the dimensions into a single value.

Dimensionality reduction in the inner product calculation.

Physical Significance: Probability Amplitude

The inner product provides the probability amplitude of measuring a system in a specific state. If you have a qubit in state $|\psi\rangle$ and you want to know the probability of finding it in state $|0\rangle$, you compute the inner product $\langle 0 | \psi \rangle$.

To get the actual probability (a real number between 0 and 1), you take the squared magnitude of this result:

$$P = |\langle 0 | \psi \rangle|^2$$

If the inner product is 0, the states are orthogonal. This means they are mutually exclusive. If the system is in one state, it has zero probability of being measured as the other.

Python Implementation

In Python, we use NumPy to handle these operations. While np.dot works for real numbers, quantum mechanics requires careful handling of complex conjugates. For 1D arrays, np.vdot is often preferred because it automatically handles the complex conjugation of the first argument. However, when working with explicit matrices (column vectors), we usually define the conjugate transpose manually to maintain clarity.

import numpy as np

# Define a standard state |0>
ket_0 = np.array([[1], [0]])

# Define a state |+> (superposition)
# 1/sqrt(2) * [1, 1]
ket_plus = np.array([[1], [1]]) / np.sqrt(2)

# Calculate Inner Product <0|+>
# Step 1: Create the bra (conjugate transpose of ket_0)
bra_0 = ket_0.conj().T

# Step 2: Matrix multiplication
overlap = np.dot(bra_0, ket_plus)

print(f"Amplitude: {overlap[0][0]}")
print(f"Probability: {abs(overlap[0][0])**2:.2f}")

Running this code yields a probability of approximately 0.5, confirming that the state $|+\rangle$ has a 50% chance of collapsing to $|0\rangle$.

The Outer Product

While the inner product creates a scalar, the outer product creates a matrix (an operator). In Dirac notation, this is written as $| \psi \rangle \langle \phi |$. Note that the ket comes first, followed by the bra.

If we take the same vectors from before, the multiplication order changes:

$$|a\rangle \langle b| = \begin{bmatrix} a_1 \\ a_2 \end{bmatrix} \begin{bmatrix} b_1^* & b_2^* \end{bmatrix} = \begin{bmatrix} a_1 b_1^* & a_1 b_2^* \\ a_2 b_1^* & a_2 b_2^* \end{bmatrix}$$

The result is an $N \times N$ matrix. In quantum computing, matrices represent operators or gates. The outer product is useful for constructing projection operators and density matrices, which are required for advanced noise modeling.

Dimensionality Expansion

The outer product expands two vectors into a matrix representation.

Dimensionality expansion in the outer product calculation.

Use Case: Projections

A primary application of the outer product is creating projection operators. A projector allows us to filter a state. For example, the operator that projects a generic qubit state onto the $|0\rangle$ axis is defined as:

$$P_0 = |0\rangle \langle 0| = \begin{bmatrix} 1 \\ 0 \end{bmatrix} \begin{bmatrix} 1 & 0 \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & 0 \end{bmatrix}$$

When you apply this matrix to a vector, it eliminates the component associated with $|1\rangle$, leaving only the component associated with $|0\rangle$.

The following chart illustrates the result of the outer product $|+\rangle \langle +|$. Since $|+\rangle$ is an equal superposition, the resulting density matrix has equal values of 0.5 distributed across all elements.

Heatmap representation of the matrix resulting from the outer product of the plus state with itself.

Python Implementation

We use the function np.outer or standard matrix multiplication to compute this. Note that np.outer in NumPy does not automatically take the complex conjugate of the second vector, so you must pass the conjugate explicitly if you are not constructing the bra manually.

Here is the way to do it using standard matrix multiplication logic ($Col \times Row$):

# Define state |1>
ket_1 = np.array([[0], [1]])

# Create the projector |1><1|
# We need ket_1 (column) multiplied by bra_1 (row)
bra_1 = ket_1.conj().T

projector_1 = np.dot(ket_1, bra_1)

print("Projector for |1>:")
print(projector_1)

Norms and Normalization

A fundamental axiom of quantum mechanics is that probabilities must sum to 1. This leads to the concept of normalization.

For a state $|\psi\rangle$ to be a valid physical state, the inner product with itself must equal 1:

$$\langle \psi | \psi \rangle = 1$$

This quantity is also known as the squared L2 norm of the vector. If you perform a calculation and the resulting vector has an inner product greater or less than 1, the vector is unnormalized and does not represent a valid closed quantum system.

When you initialize a qubit in a simulator, it usually starts in $|0\rangle$.

1. $\langle 0 | 0 \rangle = 1$ (Normalized)
2. $\langle 0 | 1 \rangle = 0$ (Orthogonal)

Understanding these two checks is important for debugging quantum circuits. If your inner product is non-zero for states that should be orthogonal, your phases are misaligned. If your self-inner product is not 1, your system has lost probability (non-unitary error).

In the next section, we will look at Unitary Matrices, which are the specific type of matrices that ensure the length of our state vectors, and thus the total probability, always stays equal to 1.