Tensor Computing Interface: An Application-Oriented, Lightweight Interface for Portable High-Performance Tensor Network Applications

TL;DR

The paper addresses the portability bottleneck in tensor-network applications by introducing the Tensor Computing Interface (TCI), a lightweight, application-oriented C++17 API with a unified TenT type system and core tensor operations. It demonstrates that TN algorithms written against TCI can be ported across diverse back ends (CPU, GPU, and HPC) with performance comparable to native framework APIs, using two representative TN applications: ground-state iTEBD for the TFIM and a 2dTNS-BP dynamics model for the kicked Ising model. The contributions include a formal tensor type system, a comprehensive set of tensor-manipulation and tensor-LA functions, and open-source implementations (TCI on Cytnx), validated by cross-back-end benchmarks and portability tests. The work has practical impact by enabling portable, high-performance TN software across current and future HPC architectures, thereby accelerating algorithm development without backend lock-in.

Abstract

Tensor networks (TNs) are a central computational tool in quantum science and artificial intelligence. However, the lack of 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 Interface (TCI) -- an application-oriented, lightweight application programming interface designed to enable framework-independent, high-performance TN applications. TCI provides a well-defined type system that abstracts tensor objects together with a minimal yet expressive set of core functions covering essential tensor manipulations and tensor linear-algebra operations. Through numerical demonstrations on representative tensor-network applications, we show that codes written against TCI can be migrated seamlessly across heterogeneous hardware and software platforms while achieving performance comparable to native framework implementations. We further release an open-source implementation of TCI based on \textit{Cytnx}, demonstrating its practicality and ease of integration with existing tensor-computing frameworks.

Figures (10)

• Figure 1: System architectures and development workflows for tensor-network (TN) applications. Arrows indicate dependency relations, with arrowheads pointing to the dependent components. (a) Typical software architecture of a TN application, in which the application logic and TN algorithms are directly tied to a specific tensor-computing framework (TCF). (b) Development workflow without TCI: TN applications must be reimplemented separately for each TCF, leading to duplicated development effort and limited portability. (c) Development workflow with TCI: application logic and TN algorithms are decoupled from back-end hardware and software through a uniform interface, enabling portable development across heterogeneous TCFs.
• Figure 2: Graphic representations of tensors. (a) Array representation of a third-order tensor $A_{ijk}$, where the entry at coordinates $(i,j,k)$ corresponds to the tensor element $A_{i,j,k}$. (b) Penrose diagram of a fourth-order tensor $A_{ijkl}$, in which the node represents the tensor and each incident leg corresponds to a tensor mode (bond).
• Figure 3: Typical tensor-manipulation operations. (a) Transpose, which reorders tensor bonds. (b) Concatenation, which combines multiple tensors along a specific bond. (c) Broadcasting, which applies a scalar function elementwise while preserving tensor order and shape.
• Figure 4: Representative tensor linear-algebra operations. (a) Tensor contraction over shared bonds. (b) Tensor decomposition, illustrated by the SVD as a representative example.
• Figure 5: Configuration used in Application B. (a) Heavy-hex lattice geometry corresponding to the 156-qubit superconducting chips, e.g., ibm_marrakesh and ibm_kobe, in IBM Quantum System Two. This connectivity is mapped directly onto the 2dTNS used in the simulation. (b) Representative portion of the quantum circuit implementing a single Floquet cycle of the KIM. Rectangles denote single-qubit $R^X$ gates, while wires connecting pairs of qubits represent two-qubit $R^{ZZ}$ gates. Gray vertical bands indicates groups of $R^{ZZ}$ gates executed concurrently by the parallel algorithm (see Appendix \ref{['app:bp-qc']}).