quantum-tensor-network-ml - SKILL.md Agent Skill

name: quantum-tensor-network-ml description: "Quantum tensor network methods for many-body quantum systems analysis. Combines belief propagation algorithms, tensor network expansions, and machine learning for efficient quantum state representation and computation. Use when: (1) analyzing many-body quantum systems, (2) designing tensor network architectures, (3) implementing belief propagation for quantum states, (4) compressing quantum state representations, (5) studying quantum entanglement patterns."

Quantum Tensor Network ML

Overview

Quantum tensor network methods provide efficient representations and computational tools for many-body quantum systems, combining belief propagation algorithms with tensor network architectures.

Activation Keywords

quantum tensor network
belief propagation quantum
tensor network expansion
many-body quantum systems
quantum entanglement tensor
tensor network ML
quantum state compression
PEPS tensor network
MPS tensor network
张量网络量子

Tools Used

exec: Run Python tensor network simulations
read: Load research papers, reference materials
write: Save tensor network configurations, analysis results
memory_search: Search knowledge graph for related concepts

Core Concepts

1. Tensor Networks

Matrix Product States (MPS):

|ψ⟩ = Σ_{i_1,...,i_N} Tr(A_1^{i_1} · A_2^{i_2} · ... · A_N^{i_N}) |i_1,...,i_N⟩

Projected Entangled Pair States (PEPS):

|ψ⟩ = Σ_{i} Tr(Σ_{r} A_1^{i_1,r} · A_2^{i_2,r} · ... · A_N^{i_N,r}) |i⟩

2. Belief Propagation (BP)

Message-passing algorithm for quantum systems:

Message update: m_{i→j}(x_j) = Σ_{x_i} P(x_i|x_j) · Π_{k∈N(i)\j} m_{k→i}(x_i)

Belief update: b_i(x_i) = Π_{j∈N(i)} m_{j→i}(x_i)

3. Tensor Network Expansions

Systematic expansion of quantum operators:

H = Σ_{α} h_α · O_α  → Tensor network representation

Key Papers

arXiv:2604.03228 (2026-04-06)

Belief Propagation and Tensor Network Expansions for Many-Body Quantum Systems: Rigorous Results and Fundamental Limits

Key contributions:

Rigorous convergence analysis for BP on tensor networks
Fundamental limits of tensor network expressiveness
Applications to quantum phase transitions
Connection to machine learning tensor networks

Other References

Verstraete, Cirac (2004): PEPS renormalization
Eisert, Cramer (2010): State compression limits
Orus (2014): Tensor network review

Workflow

Pattern 1: Many-Body System Analysis

1. Identify quantum system (spin chain, lattice, etc.)
2. Choose tensor network architecture (MPS/PEPS/MERA)
3. Initialize tensor network representation
4. Apply belief propagation for optimization
5. Extract physical properties (correlation functions, entanglement)

Pattern 2: Tensor Network Compression

1. Represent quantum state as tensor network
2. Determine bond dimension requirements
3. Apply tensor decomposition algorithms
4. Verify fidelity of compressed representation
5. Optimize for computational efficiency

Pattern 3: Quantum Phase Detection

1. Initialize tensor network for system
2. Run belief propagation across lattice
3. Monitor message convergence patterns
4. Detect phase transitions via message behavior
5. Classify quantum phases (topological, critical, etc.)

Implementation

Belief Propagation for Tensor Networks

import numpy as np

def belief_propagation_tensor_network(
    tensors: List[np.ndarray],
    connections: List[Tuple[int, int]],
    n_iterations: int = 100,
    tolerance: float = 1e-6
) -> Tuple[List[np.ndarray], float]:
    """
    Run belief propagation on tensor network.
    
    Args:
        tensors: List of tensor network tensors
        connections: List of (tensor_i, tensor_j) connections
        n_iterations: Maximum iterations
        tolerance: Convergence tolerance
    
    Returns:
        messages: Updated messages
        error: Final convergence error
    """
    # Initialize messages
    messages = initialize_messages(tensors, connections)
    
    for iteration in range(n_iterations):
        new_messages = []
        
        for (i, j) in connections:
            # Message from tensor i to tensor j
            m_new = update_message(tensors[i], messages, i, j)
            new_messages.append(m_new)
        
        # Check convergence
        error = compute_message_error(messages, new_messages)
        if error < tolerance:
            break
        
        messages = new_messages
    
    return messages, error

def update_message(
    tensor: np.ndarray,
    messages: List[np.ndarray],
    source_idx: int,
    target_idx: int
) -> np.ndarray:
    """Update message based on tensor contraction."""
    
    # Contract tensor with incoming messages (excluding target)
    contracted = tensor
    for (i, j), m in enumerate(messages):
        if j == source_idx and i != target_idx:
            contracted = np.tensordot(contracted, m, axes=1)
    
    # Normalize message
    new_message = contracted / np.linalg.norm(contracted)
    
    return new_message

Tensor Network State Compression

def compress_quantum_state(
    state_vector: np.ndarray,
    max_bond_dimension: int,
    threshold: float = 1e-8
) -> Tuple[List[np.ndarray], float]:
    """
    Compress quantum state into MPS tensor network.
    
    Args:
        state_vector: Full quantum state vector
        max_bond_dimension: Maximum bond dimension
        threshold: SVD truncation threshold
    
    Returns:
        tensors: MPS tensor list
        fidelity: Compression fidelity
    """
    n_qubits = int(np.log2(len(state_vector)))
    tensors = []
    
    # Sequential SVD decomposition
    residual = state_vector.reshape(2, -1)
    
    for i in range(n_qubits - 1):
        # SVD decomposition
        U, S, Vh = np.linalg.svd(residual, full_matrices=False)
        
        # Truncate small singular values
        S_truncated = S[S > threshold]
        bond_dim = min(len(S_truncated), max_bond_dimension)
        
        U_truncated = U[:, :bond_dim]
        S_truncated = S[:bond_dim]
        Vh_truncated = Vh[:bond_dim, :]
        
        # Form tensor
        tensor = U_truncated @ np.diag(S_truncated)
        tensors.append(tensor.reshape(2, bond_dim))
        
        # Update residual
        residual = Vh_truncated
        
    # Final tensor
    tensors.append(residual.reshape(2, -1))
    
    # Compute fidelity
    reconstructed = reconstruct_mps(tensors)
    fidelity = np.abs(np.vdot(state_vector, reconstructed))**2
    
    return tensors, fidelity

def reconstruct_mps(tensors: List[np.ndarray]) -> np.ndarray:
    """Reconstruct state vector from MPS."""
    state = tensors[0]
    
    for tensor in tensors[1:]:
        state = np.tensordot(state, tensor, axes=1)
    
    return state.flatten()

Applications

1. Quantum Simulation

Ground state finding for many-body Hamiltonians
Quantum dynamics simulation
Finite temperature states

2. Quantum Machine Learning

Tensor network quantum classifiers
Quantum autoencoders
Variational quantum eigensolvers

3. Entanglement Analysis

Entanglement entropy calculation
Entanglement spectrum analysis
Area law verification

4. Phase Transition Detection

Critical point identification
Topological order classification
Symmetry breaking detection

Mathematical Foundations

Area Law

For gapped quantum systems:

S(ρ_A) ≤ c · |∂A|  [entanglement entropy bounded by boundary area]

Tensor networks naturally satisfy area law.

Tensor Network Expressiveness

Fundamental limits (arXiv:2604.03228):

PEPS bond dimension: D = exp(O(N)) for worst-case states
BP convergence: Requires specific graph structures
Approximation error: Lower bounded by state complexity

Convergence Criteria

BP converges when:

Graph is locally tree-like
Tensor network has sufficient symmetry
Messages avoid phase transition regions

Resources

References Directory

Key papers and tutorials on tensor networks:

references/belief_propagation_quantum.md: BP algorithm details
references/tensor_network_fundamentals.md: MPS/PEPS/MERA overview
references/rigorous_results.md: Convergence and limits proofs

Scripts Directory

Tensor network implementation tools:

scripts/belief_propagation.py: BP algorithm implementation
scripts/mps_compression.py: MPS compression utilities
scripts/tensor_network_simulation.py: Simulation framework

Related Skills

quantum-topological-data-analysis: Topological aspects of tensor networks
quantum-neural-topology: Quantum neural network connections
quantum-geometry-topology-research: Research workflow integration
quantum-algorithm-framework-designer: Algorithm design integration

Notes

Tensor networks provide exponential compression for many quantum states
Belief propagation enables efficient tensor optimization
Fundamental limits exist for tensor network expressiveness
Applications range from simulation to machine learning
Area law is key property satisfied by tensor networks

Open Questions

BP Convergence: Exact conditions for BP convergence on tensor networks?
Expressiveness: Optimal bond dimension for specific quantum states?
Topological Tensors: Tensor networks for topological quantum computing?
ML Integration: Optimal quantum tensor network architectures for ML?