Using GPU-based HPC platforms efficiently for coupled cluster computations is a challenge due to heterogeneous hardware structures. The constant need to adapt software to these structures and the required man-hours makes the systematization of high-performance code development desirable, even more so for higher-order coupled cluster. This is generally achieved by introducing a high-level representation of the problem, which is then translated into low-level instructions for the hardware using a compiler/translator component. Designing such software comes with another challenge: Allowing efficient implementation by capturing key symmetries of tensors while retaining abstraction from the hardware. We review ways to address these two challenges while presenting the design decisions that led us to the development of a general-order coupled cluster code generator. The systematically produced code shows excellent weak scaling behavior, running on up to 1200 GPUs using the distributed memory tensor library ExaTENSOR. We present an open-source modular tensor framework ″tenpi″ for coupled cluster code development with diagrammatic derivation, visualization module, symbolic algebra, intermediate optimization, and support for multiple tensor backends. Tenpi brings higher-order CC functionality to the massively parallel ExaCorr module of the DIRAC code for relativistic molecular calculations.
Using GPU-based HPC platforms efficiently for coupled cluster computations is a challenge due to heterogeneous hardware structures. The constant need to adapt software to these structures and the required man-hours makes the systematization of high-performance code development desirable, even more so for higher-order coupled cluster. This is generally achieved by introducing a high-level representation of the problem, which is then translated into low-level instructions for the hardware using a compiler/translator component. Designing such software comes with another challenge: Allowing efficient implementation by capturing key symmetries of tensors while retaining abstraction from the hardware. We review ways to address these two challenges while presenting the design decisions that led us to the development of a general-order coupled cluster code generator. The systematically produced code shows excellent weak scaling behavior, running on up to 1200 GPUs using the distributed memory tensor library ExaTENSOR. We present an open-source modular tensor framework ″tenpi″ for coupled cluster code development with diagrammatic derivation, visualization module, symbolic algebra, intermediate optimization, and support for multiple tensor backends. Tenpi brings higher-order CC functionality to the massively parallel ExaCorr module of the DIRAC code for relativistic molecular calculations.
Coupled-cluster theory (CC) is a highly accurate and versatile method for simulating complex interactions within quantum systems. The extension of CC theory to model mixed electron-photon processes with quantum electrodynamics (QED) has improved our capability to predict cavity-modified chemistry, a field where photons are used as cost-effective and eco-friendly alternatives to catalyze/inhibit chemical reactions. However, calculations with CC methods, even without incorporating QED effects, are often prohibitively expensive. Simulations of larger systems require scalable infrastructures that exist for traditional CC methods but not for QED-CC methods. As such, we present a GPU-enabled, high-performance, open-source implementation of the quantum electrodynamics coupled-cluster method with single and double excitations (QED-CCSD) within the ExaChem quantum chemistry software package. ExaChem relies on the Tensor Algebra for Many-body Methods (TAMM) infrastructure: a parallel heterogeneous tensor library designed to achieve scalable performance on modern heterogeneous supercomputing platforms. We discuss theoretical foundations, algorithmic details, and numerical benchmarks to showcase the larger systems that ExaChem can simulate and how the integration of photonic degrees-of-freedom alters their ground-state properties.
The ultimate goal of electronic structure theory is solving the electronic Schr¨odinger Equation. However, even accurate approximations of solving Schr¨odinger Equation, such as high order coupled cluster theories, require computational efforts that are too demanding to be applied on large chemical systems. This thesis tackles the problem of curse of dimensionality: how to reduce the time complexity of high-accuracy coupled cluster methods in order to accelerate computations of molecular energy. On one hand, we believe that low-rank approximation (i.e. Tensor HyperContraction) of high-order tensors appearing in coupled cluster theory is a promising way to achieve rank-reduced coupled cluster theory. On the other hand, we think that the work of deriving, optimizing and implementing low-rank approximated coupled cluster theory is both tedious and repetitious, and shall be performed by an automatic code engine other than chemists. In this thesis, we introduce our chemistry equation compiler, Autom: a code engine that is designed for automatically deriving, optimizing and implementing low-rank approximated coupled cluster theories. With Autom, the development of electronic theories is greatly simplified. Autom can easily generate runnable codes in minutes for tensor-algebra based chemistry equations with customized low-rank approximation rules; conventionally, such procedure may take an expert weeks or even months to manually program. This thesis roughly consists of two parts. In the first part, we aim to cover the lowrank approximation techniques for high-accuracy coupled cluster theories, emphasizing on two new factorization techniques we developed especially for several coupled cluster theories including triple contributions. In the second part, we demonstrate the algorithms of our automatic code engine. We also summarize recent advances of domain specific compilers in Machine Learning community and discuss future directions for compute graph optimization. We believe that this new software infrastructure holds great promise for future chemistry package designs.
The continuous demand for higher accuracy in computational chemistry necessitates the development of advanced many-body electronic structure methods. However, the derivation and efficient implementation of these theories constitute a significant bottleneck. As the rank of the associated tensors increases, the governing equations explode in complexity, rendering manual implementation labor-intensive, error-prone, and difficult to optimize for modern hardware. To address this challenge, this dissertation presents SeQuant, a comprehensive framework for the automated derivation and parallel implementation of many-body quantum chemistry methods. Built upon a robust symbolic algebra engine, SeQuant allows for the expression of theories in the natural language of second quantization. It automates the transformation of high-level theoretical ansatzes into explicit tensor contraction expressions and subsequently generates optimized, high-performance C++ code. A central innovation of this work is the extension of automated implementation to reduced-scaling methods, which exploit the sparsity inherent in electronic correlation. We introduce a novel "tensor-of-tensors" data structure designed to manage the irregular sparsity patterns of Pair Natural Orbital (PNO) formulations. This development enables the first fully automated implementation of PNO-Coupled Cluster (PNO-CC) methods, bridging the gap between symbolic abstraction and the runtime requirements of sparse tensor algebra. The results demonstrate that SeQuant not only reproduces established dense methods (such as CCSD and CCSDT) with high fidelity but also effectively handles the complexity of sparse, local correlation approaches. By decoupling the complexity of the physics from the details of the implementation, this framework establishes a new paradigm for method development, dramatically accelerating the translation of theoretical insights into computational reality.
Tensor networks (TNs) are a central computational tool in quantum science and artificial intelligence. However, the lack of a unified software interface across tensor-computing frameworks severely limits the portability of TN applications, coupling algorithmic development to specific hardware and software back ends. To address this challenge, we introduce the Tensor Computing Application Programming Interface (TCAPI)---an application-oriented, lightweight API designed to enable framework-independent, high-performance TN applications, currently specified for \texttt{C++} and \texttt{Python}. TCAPI provides well-defined type-system conventions that abstract tensor objects, together with a minimal yet expressive set of core functions for essential tensor manipulations and tensor linear-algebra operations, with operation semantics shared across language specifications. Through numerical demonstrations of representative tensor-network applications implemented in \texttt{C++} using TCAPI, we show that code written against TCAPI can be migrated seamlessly across heterogeneous hardware and software platforms while achieving performance comparable to native framework implementations. We further provide open-source implementations of TCAPI based on \textit{Cytnx} and \textit{ITensor} in \texttt{C++}, and on \textit{NumPy} in \texttt{Python}, demonstrating its practicality and ease of integration with existing tensor-computing frameworks.
Tensor contractions form the fundamental computational operation of computational chemistry, and these contractions dictate the performance of widely used coupled-cluster (CC) methods in computational chemistry. In this work, we study a single-source, cross-platform C++ abstraction layer programming model, SYCL, for applications related to the computational chemistry methods such as CCSD(T) coupled-cluster formalism. An existing optimized CUDA implementation was migrated to SYCL to make use of the novel algorithm that provides tractable GPU memory needs for solving high-dimensional tensor contractions for accelerating CCSD(T). We present the cross-platform performance achieved using SYCL implementations for the non-iterative triples contribution of the CCSD(T) formalism which is considered as the performance bottle neck on NVIDIA A100 and AMD Instinct MI250X. Additionally, we also draw comparisons of similar performance metrics from vendor-based native programming models such as CUDA and ROCm HIP. Our results indicate that the performance of SYCL measured at-scale was on-par with the code written in HIP for AMD MI250X GPUs while the performance is slightly lacking on NVIDIA A100 GPUs in comparison to CUDA.