This post is part of my 21-day quantum computing learning journey, focusing on the mathematical foundations that drive quantum operations. I cover unitary matrices, tensor products, and inner/outer products - the fundamental linear algebra tools without which no true quantum revolution would be possible.

Progress: 5/21 days completed. Linear algebra foundations: systematically mapped. Mathematical fundamentals of quantum computing: being established.

Table of contents:

Unitary matrices: Reversible magic of quantum operations {#unitary-matrices} In the world of quantum computing, one inviolable rule applies: all operations must be reversible. That’s precisely why we use unitary matrices - mathematical tools that guarantee information preservation.

A matrix \(\mathbf{U}\) is unitary when it satisfies the condition:

\[\mathbf{U}^\dagger \cdot \mathbf{U} = \mathbf{I} \quad \text{or} \quad \mathbf{U} \cdot \mathbf{U}^\dagger = \mathbf{I}\]

where:

\(\mathbf{U}^\dagger = \text{conjugate transpose of } \mathbf{U} \\ \mathbf{I} = \text{identity matrix}\)

Math for Quantum Computing
Math for Quantum Computing

Unitary matrices - basic quantum gates

  • Preserves probabilities in the quantum system
  • Guarantees reversibility of all operations
  • Enables precise manipulation of quantum states
  • Forms the foundation of all quantum gates

Unlike classical logic gates, which are often irreversible (like the AND gate), quantum operations never lose information.

Mathematical reality of quantum operations

Quantum operations work in complex vector space:

\(|\psi\rangle \in \mathbb{C}^2\) - (for a qubit)

\(U|\psi\rangle = |\psi'\rangle\) - (unitary transformation)

\(\langle\psi'|\psi'\rangle = 1\) - (norm preservation)

Tensor product vs classical bit combination: The fundamental difference

The tensor product is a mathematical operation that combines two quantum states into one joint system. If |u⟩ and |v⟩ are two vectors (quantum states), their tensor product is written as:

\(|u\rangle \otimes |v\rangle\)

Key characteristics of tensor products:

  • Dimensionality: Combining n-dimensional and m-dimensional systems yields an (n×m)-dimensional system
  • Entanglement: Enables creation of states that cannot be decomposed into independent components
  • Scalability: Each additional qubit doubles the state space size
Aspect Classical Combination Tensor Product (Quantum)
Bit states Independent values Entangled amplitudes
Dimensionality Linear (n + m) Exponential (n × m)
Correlations Local Non-local
Information Additive Multiplicative

Some fundamental insights developed. It was necessary to understand how tensor products enable exponential scalability of quantum computations while introducing entirely new computational possibilities.

Inner product: Measuring state similarity

The inner product (bra-ket notation) is a scalar that measures similarity between two quantum states.

Pauli-like operations: Quantum similarity measurements

Basic inner product: For two vectors |u⟩ and |v⟩: ⟨u|v⟩

Geometric interpretation:

  • Result = 1: identical states (up to global phase)
  • Result = 0: orthogonal states (completely distinguishable)
  • 0 < |⟨u|v⟩| < 1: partial similarity

Measurement probabilities: The probability of measuring state |v⟩ in system |u⟩ is |⟨v|u⟩|²

Phase operations: Quantum similarity manipulation

The inner product preserves information about:

  • Amplitudes: Magnitudes of state components
  • Phases: Relative phase shifts between components
  • Interference: Constructive and destructive between states

Outer product: Building quantum operators

The outer product of two states creates an operator (matrix) from a column vector |u⟩ and a row vector ⟨v|:|u⟩⟨v|

Controlled operations: Conditional quantum transformations

Projectors: |u⟩⟨u| - extract state components consistent with |u⟩ Density matrices: Describe systems in mixed quantum states Evolution operators: Construct complex unitary transformations

Universal operator sets: Complete computational power Until proper quantum operator universality was understood, several critical questions remained:

What makes an operator set computationally universal? Combinations of outer products can approximate any quantum operation to arbitrary accuracy. Which combinations provide complete quantum computation?

How do outer products bridge classical and quantum computation? Some operators have classical counterparts, but in quantum space they gain additional properties related to superposition and entanglement.

Practical applications: Code implementing concepts {#code-implementation} pythonimport numpy as np

Unitary matrices - basic quantum gates

def create_unitary_gates():
    """Basic quantum gates as unitary matrices"""
    
    # Pauli-X gate (quantum NOT gate)
    X_gate = np.array([[0, 1],
                       [1, 0]])
    
    # Hadamard gate (creates superposition)
    H_gate = np.array([[1, 1],
                       [1, -1]]) / np.sqrt(2)
    
    # Phase gate S
    S_gate = np.array([[1, 0],
                       [0, 1j]])
    
    return X_gate, H_gate, S_gate

# Tensor products - multi-qubit systems
def tensor_product_demo():
    """Demonstration of tensor products"""
    
    # Single qubit states
    qubit_0 = np.array([1, 0])  # |0⟩
    qubit_1 = np.array([0, 1])  # |1⟩
    
    # Tensor product - two-qubit system
    two_qubit_00 = np.kron(qubit_0, qubit_0)  # |00⟩
    two_qubit_01 = np.kron(qubit_0, qubit_1)  # |01⟩
    
    print(f"State |00⟩: {two_qubit_00}")
    print(f"State |01⟩: {two_qubit_01}")
    
    return two_qubit_00, two_qubit_01

# Inner product - similarity measurements
def inner_product_measurements():
    """Calculating measurement probabilities"""
    
    # Quantum states
    state_plus = np.array([1, 1]) / np.sqrt(2)   # |+⟩
    state_minus = np.array([1, -1]) / np.sqrt(2)  # |-⟩
    state_0 = np.array([1, 0])                    # |0⟩
    
    # Inner products
    overlap_plus_minus = np.conj(state_plus) @ state_minus
    overlap_plus_0 = np.conj(state_plus) @ state_0
    
    print(f"⟨+|-⟩ = {overlap_plus_minus}")
    print(f"⟨+|0⟩ = {overlap_plus_0}")
    print(f"Probability of measuring |0⟩ in state |+⟩: {abs(overlap_plus_0)**2}")

# Outer product - operators and projectors
def outer_product_operators():
    """Creating operators from outer products"""
    
    # Basis states
    state_0 = np.array([[1], [0]])  # |0⟩ as column vector
    state_1 = np.array([[0], [1]])  # |1⟩ as column vector
    
    # Projectors
    P_0 = state_0 @ state_0.conj().T  # |0⟩⟨0|
    P_1 = state_1 @ state_1.conj().T  # |1⟩⟨1|
    
    print(f"Projector P_0:\n{P_0}")
    print(f"Projector P_1:\n{P_1}")
    print(f"P_0 + P_1 = I:\n{P_0 + P_1}")  # Completeness

# Complete system demonstration
if __name__ == "__main__":
    print("=== Unitary matrices ===")
    X, H, S = create_unitary_gates()
    
    # Unitarity verification
    print(f"H† × H = I: {np.allclose(H.conj().T @ H, np.eye(2))}")
    
    print("\n=== Tensor products ===")
    tensor_product_demo()
    
    print("\n=== Inner products ===")
    inner_product_measurements()
    
    print("\n=== Outer products ===")
    outer_product_operators()

Bridging classical and quantum mathematics

Universality foundations: Combinations of these mathematical operations can approximate any quantum transformation, demonstrating how linear algebra becomes the language of quantum computation.

Transition from classical to quantum computational reality

# Classical vs quantum comparison
def classical_vs_quantum_operations():
    """Demonstration of differences between classical and quantum logic"""
    
    # Classical gates (irreversible)
    def classical_and(a, b):
        return a & b
    
    # Quantum gates (reversible, unitary)
    def quantum_cnot():
        return np.array([[1, 0, 0, 0],
                        [0, 1, 0, 0], 
                        [0, 0, 0, 1],
                        [0, 0, 1, 0]])
    
    # This demonstrates how quantum mathematics
    # generalizes classical operations while
    # introducing fundamentally new possibilities

# Quantum Gate Universality
def demonstrate_universality():
    """Show how basic operations combine for universal computation"""
    
    # Toffoli gate - classical reversible gate with quantum equivalent
    def classical_toffoli(a, b, c):
        """Classical Toffoli gate - reversible CCNOT"""
        return (a, b, c ^ (a & b))
    
    # Quantum Toffoli gate matrix (8x8 for 3 qubits)
    toffoli_matrix = np.eye(8)
    toffoli_matrix[6, 6] = 0
    toffoli_matrix[7, 7] = 0
    toffoli_matrix[6, 7] = 1
    toffoli_matrix[7, 6] = 1
    
    # This demonstrates classical-quantum gate correspondence
    # Some quantum gates have direct classical analogues
    # but operate in complex vector spaces with superposition

My site is free of ads and trackers. Was this post helpful to you? Why not BuyMeACoffee

Reference:

  1. Microsoft Quantum Development Kit Documentation. Linear Algebra for Quantum Computing
  2. Qiskit Textbook. (2020). Linear Algebra for Quantum Computing. IBM Quantum