SeQuant Framework for Symbolic and Numerical Tensor Algebra. I. Core Capabilities

SeQuant is an open-source library that employs a novel graph-theoretic tensor network canonicalizer to unify symbolic and numerical tensor algebra, enabling efficient handling of complex expressions involving symmetries, non-commutative operators, and parametric mode dependencies for applications in quantum simulation and data science.

The Gist

Imagine you are a chef trying to write a recipe for a dish so complex that it involves thousands of ingredients, some of which interact in mysterious ways, and others that change their identity depending on which other ingredients they are near. Now, imagine you have to write this recipe not just once, but millions of times, tweaking it slightly each time to see if it tastes better. If you tried to do this by hand, you'd go crazy. You'd make mistakes, you'd get lost, and you'd never finish.

This is the problem scientists face when simulating the behavior of electrons in molecules (quantum chemistry). The math involved is a giant, tangled mess of "tensors" (which are like multi-dimensional spreadsheets of numbers) and operators (mathematical tools that change these numbers).

SeQuant is a new, open-source software tool designed to be the ultimate "smart sous-chef" for these scientists. It doesn't just do the math; it understands the structure of the math, simplifies it, and then actually cooks the meal (runs the numbers) for you.

Here is how SeQuant works, broken down into simple concepts:

1. The "Tangled Yarn" Problem (Tensor Networks)

Think of a tensor network as a giant ball of yarn where different colored strings (indices) are knotted together.

• The Problem: In the old days, if you had two balls of yarn that looked different but were actually the same knot just tied in a different order, a computer would think they were totally different. It would try to solve both, wasting huge amounts of time.
• SeQuant's Solution: SeQuant has a magical "knot detector." It uses a graph-theoretic canonicalizer. Imagine taking a photo of the yarn ball and turning it into a unique barcode. No matter how you twist the yarn, if the underlying knot is the same, the barcode is identical. This allows SeQuant to instantly recognize, "Hey, I've seen this knot before! I don't need to solve it again; I already know the answer." This is much faster than the old methods used by other tools.

2. The "Russian Doll" Problem (Nested Indices)

Sometimes, in modern science, the rules change. You might have a box of toys, and inside each toy is another box, and inside that box is a specific set of instructions that only make sense if you know which outer box you are in.

• The Problem: Traditional math tools get confused when a variable depends on another variable in a nested way (like a "tensor of tensors"). They assume everything is flat and simple.
• SeQuant's Solution: SeQuant understands nested dependencies. It treats these complex structures like a set of Russian nesting dolls, keeping track of which doll is inside which, and how the rules change as you go deeper. This is crucial for new, high-speed methods in quantum simulation that were previously too hard to write down on paper.

3. The "Wick's Theorem" Engine (The Magic Recipe Book)

In quantum physics, there is a rule called Wick's Theorem. It's like a rulebook for how to break down a complex interaction between particles into simpler steps.

• The Problem: If you have 10 particles interacting, the rulebook says you have to write down millions of possible combinations. Most of these are duplicates or just the same thing written in a different order. Doing this manually is impossible.
• SeQuant's Solution: SeQuant has a super-fast engine that applies these rules. Because it uses the "knot detector" mentioned earlier, it can instantly spot the duplicates and throw them away while it's working. It's like having a chef who can read a recipe, instantly realize "I don't need to chop these onions twice," and skip the step, saving hours of work.

4. The "Live Translator" (Interpretation vs. Code Generation)

Usually, when you use a tool like this, it writes a new computer program (code) for you, which you then have to compile and run. This is slow. Every time you change a variable, you have to re-write the code and re-compile it.

• SeQuant's Solution: SeQuant acts more like a live translator. Instead of writing a new book (code) every time, it reads the math recipe and immediately starts cooking (calculating) it on the fly.
  • Why is this cool? It means scientists can change their theory, hit "run," and see the result instantly. No waiting for compilation. It also allows SeQuant to look at the specific ingredients you have (the size of your molecule, the memory on your computer) and adjust the cooking method in real-time for maximum speed.

The Big Picture

SeQuant is a bridge between theory (the messy, abstract math on a whiteboard) and reality (the fast, numerical results on a supercomputer).

• Before SeQuant: Scientists spent months writing code to derive equations, only to find a typo, forcing them to start over.
• With SeQuant: They can derive the equations in minutes, let the software handle the messy simplification, and get the numerical answer almost instantly.

In short, SeQuant is the tool that lets scientists stop wrestling with the math and start focusing on the science, turning a tangled mess of quantum equations into a clear, efficient, and fast-running recipe for discovery.

Technical Summary

1. Problem Statement

The development of approximate simulation methods for quantum many-body problems (e.g., Coupled-Cluster, Many-Body Perturbation Theory) traditionally relies on manual derivation of complex tensor equations, often using diagrammatic techniques. While computer algebra systems (CAS) like Mathematica or SymPy exist, they lack specialized capabilities for handling the specific algebraic structures required in quantum field theory and electronic structure:

• Non-uniqueness of Tensor Networks (TNs): Tensor expressions involving sums over indices (Einstein summation) suffer from non-unique representations due to dummy index renaming and tensor symmetries.
• Complex Symmetries: Standard CAS tools struggle with non-abelian symmetries, non-covariant tensor networks (involving hyperedges or summations over >2 indices), and nested index dependencies (tensors of tensors).
• Inefficiency in Wick's Theorem: Naive application of Wick's theorem to operator products generates a factorial number of redundant terms that must be canonicalized, leading to severe performance bottlenecks.
• Symbolic vs. Numerical Gap: There is often a disconnect between symbolic derivation and numerical evaluation. Code generation approaches slow down development cycles due to recompilation, while pure interpretation often lacks performance.

2. Methodology and Architecture

SeQuant is an open-source C++ library designed to bridge symbolic manipulation and numerical evaluation. Its architecture is divided into core modules:

A. Symbolic Layer (SQ/symb)

• Expression Layer (SQ/expr): Uses a recursive, tree-based representation of algebraic expressions (atoms, sums, products). It supports user-defined expression types to create Domain-Specific Languages (DSLs).
• Tensor Algebra (SQ/tensor):
  • AbstractTensor: Represents tensors with abstract indices (bra/ket/aux modes) rather than fixed numerical arrays. It supports nested index dependencies (e.g., indices dependent on other indices, common in Pair-Natural Orbital methods) and non-covariant networks (hyperedges).
  • NormalOperator: Specialized for normal-ordered operators (creation/annihilation) over Fock space, handling both bosonic and fermionic commutation relations.

B. The Core Innovation: Graph-Theoretic Tensor Network Canonicalizer

The paper introduces a novel approach to canonicalizing tensor networks, which is the foundation of SeQuant's efficiency:

• Colored Graph Mapping: Tensor networks are mapped to colored graphs where vertices represent indices, slots, slot bundles, and tensor cores. Edges represent relationships (occupancy, composition).
• Symmetry Encoding: Vertex colors encode object identities and symmetries (e.g., antisymmetry of fermionic operators).
• Canonicalization: The library uses established graph isomorphism solvers (specifically bliss) to compute the automorphism group and a unique canonical ordering of the graph.
• Advantages: This approach handles non-covariant networks and nested dependencies better than traditional group-theoretic methods (like Butler-Portugal). It achieves polynomial time complexity ($O(n^2)$) for typical cases, outperforming the factorial scaling of naive approaches.

C. Wick's Theorem Engine (SQ/tensor)

SeQuant implements a highly optimized engine for applying Wick's theorem to products of operators:

• Topological Optimization: Instead of generating all permutations and filtering, the engine uses the graph canonicalizer to identify topologically equivalent slots and operators before contraction. This avoids generating redundant terms.
• Degeneracy Factors: It calculates degeneracy factors for equivalent contractions (e.g., contracting to index $t$ vs. $x$ when they are equivalent) to scale results correctly without generating duplicate terms.
• Connectivity Constraints: Users can define constraints to prune the search space dynamically.

D. Numerical Evaluation (SQ/eval)

SeQuant employs a runtime interpretation model rather than relying solely on code generation:

• Intermediate Representation (IR): Expressions are lowered to a binary tree IR. The canonical graph ordering determines the physical memory layout (index permutation) of tensors to ensure consistent data structures.
• Optimizations:
  • Tensor Network Contraction Ordering (TNCO): Uses dynamic programming to find the optimal sequence of binary contractions to minimize operation counts.
  • Common Subexpression Elimination (CSE): Identifies identical sub-networks using the canonicalizer and caches their results at runtime.
  • Fusion: Supports factoring out common sub-networks in sums.
• Backend Agnostic: The interpreter uses a Result interface to delegate operations to external numerical backends (e.g., TiledArray, BTAS), allowing SeQuant to act as a domain-specific front-end.

3. Key Contributions

1. Graph-Theoretic Canonicalizer: A fast, robust method for canonicalizing tensor networks with complex symmetries, non-covariant structures (hyperedges), and nested index dependencies, outperforming traditional group-theoretic approaches.
2. Support for Advanced Tensor Structures: First symbolic framework to natively support "tensors of tensors" (nested indices) and non-covariant products arising from tensor decompositions (e.g., CP, Tensor Hypercontraction).
3. Optimized Wick's Theorem: A topological optimization strategy that reduces the complexity of deriving coupled-cluster equations from factorial to polynomial scaling, enabling derivation of high-rank equations (up to rank 8) in seconds.
4. Hybrid Symbolic-Numerical Workflow: A design that blurs the line between symbolic derivation and numerical execution, utilizing runtime interpretation with caching and dynamic optimization to accelerate method development.

4. Results

• Performance:
  • Canonicalization: SeQuant's graph-based canonicalizer scales approximately as $n^2$ with the number of slots, significantly faster than the Butler-Portugal algorithm for symmetric tensors and networks with many identical factors.
  • Wick's Theorem: Deriving Coupled-Cluster equations (e.g., CCSDTQ) is accelerated by 3 orders of magnitude when topological optimizations are enabled compared to naive implementations. Equations up to rank 8 are derived in under one second on a laptop.
  • Comparison: SeQuant's Wick engine is estimated to be 10–100 times faster than C++ implementations in other tools (e.g., Wick&d).
• Scalability: The framework successfully handles complex, high-rank cluster operators and PNO-based (Pair-Natural Orbital) variants, which involve intricate index dependencies.

5. Significance

• Accelerated Scientific Discovery: By automating the derivation of complex quantum many-body equations and correcting manual errors, SeQuant significantly shortens the cycle from theoretical formulation to high-performance numerical implementation.
• Generalizability: While motivated by quantum chemistry, the framework's support for non-covariant networks and nested dependencies makes it applicable to data science (block-wise compressions) and other field-theoretic domains.
• Community Framework: SeQuant aims to serve as a reusable, domain-neutral foundation for symbolic tensor algebra, potentially replacing the need for custom, slow, or monolithic CAS solutions in scientific computing.
• Modern Workflow: The shift from code generation to runtime interpretation allows for rapid prototyping, easier debugging, and the exploitation of runtime metadata (e.g., specific molecule dimensions) for optimization, which static code generation cannot easily achieve.

In summary, SeQuant represents a paradigm shift in symbolic tensor algebra, moving from manual or inefficient group-theoretic methods to a graph-theoretic, compiler-like framework that seamlessly integrates symbolic derivation with efficient numerical evaluation.