Learning to Rank Tensor Network Contraction Plans for GPU-Accelerated Quantum Circuit Simulation

# Learning to Rank Tensor Network Contraction Plans for GPU-Accelerated Quantum Circuit Simulation
Source: [https://arxiv.org/html/2608.05819](https://arxiv.org/html/2608.05819)
Alfred M\. Pastor[alfred\.pastor@uv\.es](https://arxiv.org/html/2608.05819v1/mailto:[email protected])Department of Computer Science, Universitat de València, 46100 Burjassot, SpainMaribel Castillo[castillo@uji\.es](https://arxiv.org/html/2608.05819v1/mailto:[email protected])Department of Computer Science and Engineering, Universitat Jaume I, 12071 Castelló de la Plana, SpainJose M\. Badia[badia@uji\.es](https://arxiv.org/html/2608.05819v1/mailto:[email protected])Department of Computer Science and Engineering, Universitat Jaume I, 12071 Castelló de la Plana, Spain

###### Abstract

Classical simulation remains essential for developing and validating quantum algorithms, but its cost grows rapidly with circuit size\. Tensor\-network contraction can reduce this cost by exploiting circuit structure, although its efficiency depends strongly on the chosen contraction plan\. On GPUs, plans with similar theoretical complexity may perform very differently because execution also depends on parallelism, reduction structure, memory traffic, and contraction geometry\.

We present a learning\-to\-rank framework for selecting efficient contraction plans before executing them\. Each plan is represented by structural features derived directly from its sequence of pairwise contractions, and gradient\-boosted rankers are trained from GPU measurements using listwise and pairwise objectives\. We evaluate the resulting models on diverse circuit families, using separate in\-distribution and circuit\-family\-shift test sets, and compare them with random and MinFill\-based baselines\.

The learned rankers generally identify better plans, with the listwise model providing the strongest overall decision quality\. We also study backend shift by comparing empirical plan orderings on two GPU architectures and evaluating the source\-trained models on the second device without retraining\. The rankings remain substantially, though not perfectly, stable across GPUs, and the models retain useful decision quality\. These results support Learning to Rank as a practical way to reduce contraction\-plan search, while showing that performance remains partly backend dependent\.

## 1Introduction

Classical simulation remains an important part of quantum\-computing research\. It supports the design and testing of algorithms, the validation of experiments, and the benchmarking of quantum hardware\. State\-vector simulation is general and conceptually simple, but its memory requirements grow exponentially with the number of qubits\. Tensor\-network methods provide an alternative when the circuit has exploitable structure, allowing some simulations to go beyond the sizes that can be handled by storing the complete quantum state\[[31](https://arxiv.org/html/2608.05819#bib.bib33),[37](https://arxiv.org/html/2608.05819#bib.bib39),[17](https://arxiv.org/html/2608.05819#bib.bib19)\]\.

The cost of a tensor\-network simulation depends strongly on the order in which its tensors are contracted\. A contraction plan expresses that order as a sequence of pairwise contractions, and different plans for the same network can have very different computational and memory requirements\[[41](https://arxiv.org/html/2608.05819#bib.bib43)\]\. Finding an optimal order is NP\-hard, so practical tools rely on heuristics such as MinFill, graph partitioning, community detection, and treewidth\-oriented search\[[5](https://arxiv.org/html/2608.05819#bib.bib8),[15](https://arxiv.org/html/2608.05819#bib.bib17),[19](https://arxiv.org/html/2608.05819#bib.bib21),[17](https://arxiv.org/html/2608.05819#bib.bib19)\]\. These methods produce useful candidates, but a plan that appears favorable according to a theoretical cost estimate is not necessarily the one that runs fastest on the target hardware\.

This distinction is particularly relevant on GPUs\. Pairwise tensor contractions can often be reduced to tensor permutations and matrix multiplications, operations that make effective use of GPU parallelism\. Their execution time, however, is not determined by floating\-point count alone\. Output dimensions, reduction size, contraction geometry, memory movement, kernel granularity, and the balance between many small operations and a few dominant contractions can all affect performance\[[10](https://arxiv.org/html/2608.05819#bib.bib13),[11](https://arxiv.org/html/2608.05819#bib.bib14)\]\. Plans with similar theoretical complexity may therefore behave differently when executed through a particular GPU and tensor\-library stack\.

The practical problem considered here is simple to state: given a quantum circuit and several candidate contraction plans, select the plan expected to minimize execution time, or a short list containing a near\-optimal candidate on the GPU\. Measuring all of them would reveal the fastest one, but it could require a substantial fraction of the computation that the selection stage is intended to save\. In many settings, an exact runtime estimate is also unnecessary\. The relevant decision is which plan should be executed, or which small set of plans is worth testing\.

We formulate this task as a grouped Learning to Rank \(LTR\) problem\. The candidates associated with one circuit form a ranking group, and the model assigns each plan a score used only to order the plans within that group\. The intended outputs are either a direct Top\-1 choice or a short Top\-kklist from which the best plan can be selected after a limited number of executions\. LTR is designed for this type of ordinal decision and has been used in quantum computing for related selection problems, including the ranking of logically equivalent circuit layouts for execution on quantum hardware\[[28](https://arxiv.org/html/2608.05819#bib.bib31),[20](https://arxiv.org/html/2608.05819#bib.bib22)\]\. Here, the ranked objects are tensor\-network contraction plans and the target ordering is determined by their measured GPU performance\.

Each plan is represented by structural descriptors computed from its sequence of pairwise contractions\. They summarize properties related to computational load, output\-side parallelism, reduction structure, contraction geometry, and plan granularity\. The representation requires neither preliminary execution nor profiling of the candidate plans\. It can therefore be evaluated before the expensive tensor contractions are carried out\.

The labels used for training are obtained from measured execution times\. For each circuit, the candidates are evaluated through their speedup relative to the corresponding MinFill plan, and this value is transformed into a graded relevance label\. The inputs are derived only from the contraction structure, but the labels reflect a particular GPU and software stack\. The resulting model is therefore not assumed to be hardware independent: backend dependence can enter through the supervision signal even when the backend is not explicitly encoded among the features\.

We train gradient\-boosted rankers with XGBoost\[[9](https://arxiv.org/html/2608.05819#bib.bib12)\], using its Normalized Discounted Cumulative Gain \(NDCG\) and pairwise ranking objectives\. The dataset contains 225 circuit groups and seven candidate plans per circuit, generated with several contraction\-order heuristics and measured on an NVIDIA RTX A6000\. All plans belonging to the same circuit are kept together during partitioning and validation\. Model development is followed by evaluation on a locked in\-distribution \(ID\) test set and on an out\-of\-distribution \(OOD\) set containing the complete quantum Fourier transform \(QFT\)\-based circuit family, comprising QFT circuits and QFT\-derived benchmark variants\. This family is entirely excluded from training and validation\. The models are compared with random and MinFill\-based ranking strategies using Top\-1, Top\-3, regret, and win rate\.

The NDCG\-oriented model includes the fastest plan among its first three recommendations for96%96\\%of the circuits in the locked in\-distribution test, with low decision regret\. When the complete QFT\-based family is withheld from development, its Top\-3 rate falls to62\.9%62\.9\\%\. The model therefore retains useful information for a circuit family it has not seen, but the loss under this form of domain shift is clear\.

We also study dependence on the execution backend\. The same candidate plans are measured on an NVIDIA Tesla V100, and the analysis separates two questions\. First, we compare the two empirical ground\-truth rankings without involving a learned model; the GPUs select the same fastest plan in84%84\\%of the 225 circuit groups\. Second, we keep the Ampere\-trained models and their predicted rankings fixed, but evaluate them on the locked test set using labels recomputed from the Volta measurements\. Under this zero\-shot backend shift, the NDCG\-oriented model retains a Top\-3 rate of92%92\\%\. These results show useful transfer for the two NVIDIA architectures considered, but they do not establish general hardware portability\.

The current evidence is limited to seven candidates per circuit, one held\-out circuit family, and two GPUs supported by closely related software stacks\. Within that scope, the experiments indicate that structural information from a contraction plan is sufficient to support useful ranking decisions, that an NDCG\-oriented objective gives the best balance of Top\-kkaccuracy and decision regret in the present dataset, and that part of the learned ordering survives both circuit\-family and backend shift\.

The main contributions of this work are:

- •We formulate GPU contraction\-plan selection as a grouped Learning to Rank problem, aimed at choosing either one candidate or a short list of candidates before execution\.
- •We define a fixed\-size structural representation of contraction plans that captures GPU\-relevant aspects of work, parallelism, reduction, geometry, and granularity without requiring timing measurements at inference time\.
- •We develop a group\-aware training and evaluation protocol for NDCG\-oriented and pairwise XGBoost rankers, using both ranking accuracy and decision\-oriented regret on locked in\-distribution and circuit\-family\-shift test sets\.
- •We examine backend dependence through two separate analyses: the stability of the empirical plan rankings across Ampere and Volta, and the zero\-shot evaluation of fixed Ampere\-trained models using labels measured on Volta\.

The remainder of the paper is organized as follows\. Section[2](https://arxiv.org/html/2608.05819#S2)reviews related uses of machine learning and LTR in quantum computing\. Section[3](https://arxiv.org/html/2608.05819#S3)introduces tensor\-network simulation, GPU execution of contraction plans, candidate\-generation heuristics, and gradient\-boosted ranking\. Section[4](https://arxiv.org/html/2608.05819#S4)presents the structural feature representation, with further details in Appendix[A](https://arxiv.org/html/2608.05819#A1)\. Section[5](https://arxiv.org/html/2608.05819#S5)describes data collection, grouped validation, feature selection, model optimization, and the experimental platform\. Section[6](https://arxiv.org/html/2608.05819#S6)reports the learning\-curve, in\-distribution, and circuit\-family\-shift results\. Section[7](https://arxiv.org/html/2608.05819#S7)studies ground\-truth ranking stability and zero\-shot model transfer across GPUs\. Section[8](https://arxiv.org/html/2608.05819#S8)presents the conclusions and planned extensions\.

## 2Related Work

The intersection of artificial intelligence \(AI\) and quantum computing is a bidirectional research frontier\. On one hand, quantum computing offers the potential to accelerate machine learning tasks, a field often referred to as Quantum Machine Learning \(QML\)\. Recent surveys have extensively covered the landscape of QML, highlighting algorithms such as quantum support vector machines, quantum neural networks, and variational quantum classifiers, along with their potential advantages and current limitations on near\-term quantum hardware\[[45](https://arxiv.org/html/2608.05819#bib.bib46),[55](https://arxiv.org/html/2608.05819#bib.bib55)\]\. On the other hand, classical machine learning is increasingly being employed to tackle core challenges in quantum computing\. This includes using neural networks for quantum error correction and decoding, as exemplified by the AlphaQubit recurrent\-transformer architecture, which learns to predict and correct errors in quantum processors\[[1](https://arxiv.org/html/2608.05819#bib.bib2)\]\. Such work underscores the growing synergy between the two fields, where classical learning algorithms help advance quantum hardware and simulation capabilities\.

Beyond quantum error correction, various machine learning techniques have been applied to quantum computing challenges\. For instance, support vector machines \(SVMs\) have been used for quantum state tomography\[[24](https://arxiv.org/html/2608.05819#bib.bib26)\]and to classify quantum phases of matter\[[52](https://arxiv.org/html/2608.05819#bib.bib53)\]\. Supervised learning has also been used to predict suitable device, compiler, and configuration choices for quantum\-circuit compilation, reducing the need for exhaustive exploration\[[44](https://arxiv.org/html/2608.05819#bib.bib45)\]\. Neural networks have been trained to learn the structure of quantum states\[[48](https://arxiv.org/html/2608.05819#bib.bib49)\], and to guide variational quantum eigensolvers\[[49](https://arxiv.org/html/2608.05819#bib.bib50)\]\.

One particularly suitable paradigm for candidate selection is LTR, a family of supervised learning techniques designed to optimize the ordering of a list of items rather than predicting their absolute values\. LTR methods are widely used in information retrieval, web search, recommendation systems, and natural language processing\[[28](https://arxiv.org/html/2608.05819#bib.bib31),[26](https://arxiv.org/html/2608.05819#bib.bib28)\]\. In recent years, LTR has also been successfully applied to a diverse range of problems, ranging from e\-commerce product search\[[23](https://arxiv.org/html/2608.05819#bib.bib25),[14](https://arxiv.org/html/2608.05819#bib.bib16)\]to search engine optimization and document retrieval\[[6](https://arxiv.org/html/2608.05819#bib.bib9),[18](https://arxiv.org/html/2608.05819#bib.bib20),[56](https://arxiv.org/html/2608.05819#bib.bib56)\]\.

Only a few studies have applied LTR techniques to quantum computing problems\. The most relevant to our research is the work by Li et al\.\[[27](https://arxiv.org/html/2608.05819#bib.bib30)\], who proposed QCDeploy, an LTR\-based method to rank different deployment strategies for quantum circuits on serverless platforms\. Another related study by Hartnett et al\.\[[20](https://arxiv.org/html/2608.05819#bib.bib22)\]introduced an LTR\-based approach to rank logically equivalent quantum circuits for hardware\-aware layout selection on IBM processors\. These studies demonstrate the potential of LTR for automating optimization decisions in quantum computing\.

To the best of our knowledge, prior work has not applied LTR to tensor\-network contraction or to the prediction of contraction\-plan efficiency on GPUs\. Motivated by this gap, the next section presents an LTR\-based framework that ranks candidate contraction plans and identifies the one expected to achieve the fastest execution on modern GPUs, with the aim of reducing the cost of contraction\-plan selection in large\-scale quantum circuit simulation\.

## 3Background

### 3\.1Tensor Networks for Quantum Circuit Simulation

Tensor networks provide a powerful framework for representing quantum many\-body states through networks of interconnected tensors\[[37](https://arxiv.org/html/2608.05819#bib.bib39)\]\. Quantum circuit simulation can be formulated as the contraction of a tensor network, where each quantum gate is represented by a tensor whose indices correspond to the input and output qubits on which it acts\[[37](https://arxiv.org/html/2608.05819#bib.bib39),[29](https://arxiv.org/html/2608.05819#bib.bib29)\]\. Computing probability amplitudes or observables amounts to contracting the internal indices of the resulting network\.

Compared with full state\-vector simulation, tensor networks exploit local entanglement to alleviate the exponential growth of memory requirements\[[31](https://arxiv.org/html/2608.05819#bib.bib33)\]\. Their efficiency, however, depends strongly on the contraction plan used to evaluate the network\. A contraction plan defines the sequence in which tensors are contracted and therefore determines both the computational cost and the memory footprint of the simulation\[[31](https://arxiv.org/html/2608.05819#bib.bib33)\]\. Since finding an optimal contraction order is NP\-hard, practical implementations rely on heuristic methods and must also contend with overheads associated with tensor transpositions and index reordering\[[36](https://arxiv.org/html/2608.05819#bib.bib38)\]\.

### 3\.2GPU Execution of Contraction Plans

In practice, tensor contractions can be decomposed into tensor permutations, reshaping operations, and matrix multiplications\[[46](https://arxiv.org/html/2608.05819#bib.bib47),[32](https://arxiv.org/html/2608.05819#bib.bib34)\]\. Consequently, matrix products dominate the arithmetic cost, whereas tensor permutations and memory movement constitute the main sources of overhead\.

These operations map naturally onto GPU architectures\. State\-of\-the\-art simulators such as cuQuantum\[[10](https://arxiv.org/html/2608.05819#bib.bib13)\]and qFlex\[[50](https://arxiv.org/html/2608.05819#bib.bib51)\]exploit optimized libraries, including cuBLAS and cuTENSOR, to accelerate tensor network simulation\. However, execution time depends not only on the number of floating\-point operations \(FLOPs\), but also on memory traffic, contraction geometry, intermediate tensor sizes, and the amount of exposed parallelism\. Consequently, contraction plans with similar asymptotic costs may exhibit substantially different runtimes on the same hardware\.

### 3\.3Candidate Contraction Plans

A wide variety of heuristics have been proposed to address the contraction\-order optimization problem\. Although they all pursue the same objective, reducing computational cost and memory consumption, they differ in the criteria used to guide the search and the graph structures they exploit\. Consequently, these methods can be broadly grouped into several families according to their underlying principles\[[17](https://arxiv.org/html/2608.05819#bib.bib19)\]\. Each family emphasizes different trade\-offs between computational cost, memory requirements, and graph structure, often producing contraction plans with similar asymptotic costs but different execution characteristics\.

A first family consists ofgreedy methods, which iteratively select contractions according to local criteria\. Depending on the objective, these heuristics may prioritize minimizing FLOPs\[[17](https://arxiv.org/html/2608.05819#bib.bib19),[36](https://arxiv.org/html/2608.05819#bib.bib38)\], intermediate tensor sizes\[[13](https://arxiv.org/html/2608.05819#bib.bib15)\], or balancing both factors\. Although computationally inexpensive, their local nature may prevent them from finding globally optimal orders\.

A second family is based ongraph elimination and treewidth heuristics\. Methods such as MinFill and Min\-Degree aim to reduce the effective treewidth of the network, which is closely related to contraction complexity\[[5](https://arxiv.org/html/2608.05819#bib.bib8),[13](https://arxiv.org/html/2608.05819#bib.bib15)\]\.

Another class relies ongraph partitioning and separator techniques\. Algorithms such as FlowCutter and community\-detection approaches exploit the graph structure to construct efficient contraction orders with favorable memory requirements and lower effective widths\[[19](https://arxiv.org/html/2608.05819#bib.bib21),[47](https://arxiv.org/html/2608.05819#bib.bib48),[15](https://arxiv.org/html/2608.05819#bib.bib17),[35](https://arxiv.org/html/2608.05819#bib.bib37)\]\.

Finally,hypergraph partitioning techniques, as employed bycotengra\[[17](https://arxiv.org/html/2608.05819#bib.bib19)\], recursively partition the network and can be combined with slicing strategies to further reduce memory consumption\. These approaches are among the most effective for large and complex tensor networks\.

Although these families often generate contraction plans with similar asymptotic costs, their execution times may differ substantially on GPU architectures\. Consequently, selecting the most efficient plan among a set of candidates becomes a decision problem\. Rather than generating new contraction orders, the objective of this work is to rank a pool of candidate plans and identify those most likely to achieve the best execution performance on the target GPU\.

### 3\.4Learning to Rank with Gradient Boosted Trees

#### 3\.4\.1Learning to Rank

LTR refers to a family of supervised learning techniques designed to optimize the ordering of items rather than their absolute values\[[28](https://arxiv.org/html/2608.05819#bib.bib31)\]\. LTR methods are commonly categorized into three paradigms:pointwise,pairwise, andlistwise\. Pointwise methods treat ranking as a regression or classification problem on individual items, pairwise methods learn relative preferences between pairs of items, and listwise methods directly optimize ranking\-quality metrics over the entire list\.

Since the objective of this work is to identify the best contraction plans among a set of candidates rather than predict their exact execution times, LTR provides a natural framework for contraction\-plan selection\. In particular, practical usage emphasizes ranking quality at the top positions, where selecting the best or near\-best plans is more important than accurately modeling the entire ordering\.

#### 3\.4\.2Gradient\-Boosted Trees for Ranking

Gradient\-boosted trees constitute one of the most effective approaches for LTR tasks\. In this work, we employ XGBoost\[[9](https://arxiv.org/html/2608.05819#bib.bib12)\], which combines multiple decision trees in an additive model and provides efficient implementations of ranking objectives with built\-in regularization\. XGBoost is particularly well suited for structured tabular data and can capture complex non\-linear relationships while maintaining computational efficiency\.

XGBoost supports both pairwise and listwise ranking objectives\. Therank:pairwiseobjective, rooted in RankNet\[[7](https://arxiv.org/html/2608.05819#bib.bib10)\], learns relative preferences between pairs of items and seeks to minimize ranking inversions\. In contrast, therank:ndcgobjective implements LambdaMART\[[8](https://arxiv.org/html/2608.05819#bib.bib11)\], directly optimizing ranking quality through NDCG\. Because NDCG emphasizes the top positions of the ranking, it naturally aligns with our goal of selecting reliable Top\-1 and Top\-3 contraction plans\.

Like other machine learning models, XGBoost’s performance depends on a set of hyperparameters controlling tree complexity, regularization, and learning behavior\. Table[1](https://arxiv.org/html/2608.05819#S3.T1)summarizes the most important hyperparameters for ranking tasks, while the hyperparameter optimization procedure and the selected configurations are described in Section[5](https://arxiv.org/html/2608.05819#S5)\.

Table 1:Main hyperparameters of XGBoost for learning\-to\-rank\.The choice of these parameters strongly influences the trade\-off between bias and variance\. For ranking tasks, a moderate learning rate \(e\.g\.,η=0\.01\\eta=0\.01\), shallow to medium trees \(e\.g\.,max\_depth=6\\texttt\{max\\\_depth\}=6\), and subsampling \(e\.g\.,subsample=0\.7\\texttt\{subsample\}=0\.7\) are commonly employed to avoid overfitting while maintaining high ranking accuracy\.

## 4Feature Engineering

The contraction path is the dominant algorithmic degree of freedom in exact tensor\-network simulation: changing only the order of pairwise contractions can alter both runtime and memory footprint by several orders of magnitude\. Classical width\-based reasoning explains part of this variability, but it is not sufficient for our setting\. In GPU\-accelerated contraction, runtime depends not only on the amount of work, but also on output size, reduction structure, contraction geometry, and the amount of exposed parallelism\. Our goal is therefore to construct a feature space that is computable directly from a contraction plan before execution, yet expressive enough to capture the structural factors that most influence measured runtime\.

### 4\.1Cost\-model overview

Consider theii\-th pairwise contraction step of a plan,

Oi=contractSi​\(Ai,Bi\),O\_\{i\}=\\mathrm\{contract\}\_\{S\_\{i\}\}\(A\_\{i\},B\_\{i\}\),\(1\)whereSiS\_\{i\}is the set of shared indices contracted between tensorsAiA\_\{i\}andBiB\_\{i\}\. For binary tensor networks, it is natural to work in base\-2 logarithmic coordinates\. Let

ki\\displaystyle k\_\{i\}=\|Si\|,\\displaystyle=\|S\_\{i\}\|,\(2\)mi\\displaystyle m\_\{i\}=rank​\(Ai\)−ki,\\displaystyle=\\mathrm\{rank\}\(A\_\{i\}\)\-k\_\{i\},\(3\)ni\\displaystyle n\_\{i\}=rank​\(Bi\)−ki\.\\displaystyle=\\mathrm\{rank\}\(B\_\{i\}\)\-k\_\{i\}\.\(4\)After a suitable permutation of modes, every pairwise contraction can be written in general matrix multiplication \(GEMM\)\-like form,

\(M×K\)⋅\(K×N\)→\(M×N\),M=2mi,K=2ki,N=2ni,\\begin\{split\}\(M\\times K\)\\cdot\(K\\times N\)\\rightarrow\(M\\times N\),\\\\ \\qquad M=2^\{m\_\{i\}\},\\;K=2^\{k\_\{i\}\},\\;N=2^\{n\_\{i\}\},\\end\{split\}\(5\)This representation provides a compact abstraction of the local contraction step, since it makes explicit the three structural ingredients that most strongly influence execution: the scale of the local work, the output size, and the reduction dimension\.

### 4\.2Step\-level primitives

From this local model, we define four step\-level primitives:

ci\\displaystyle c\_\{i\}=mi\+ni\+ki,\\displaystyle=m\_\{i\}\+n\_\{i\}\+k\_\{i\},\(6\)pi\\displaystyle p\_\{i\}=mi\+ni,\\displaystyle=m\_\{i\}\+n\_\{i\},\(7\)ki\\displaystyle k\_\{i\}=\|Si\|,\\displaystyle=\|S\_\{i\}\|,\(8\)di\\displaystyle d\_\{i\}=\|mi−ni\|mi\+ni\+ε,ε≪1\.\\displaystyle=\\frac\{\|m\_\{i\}\-n\_\{i\}\|\}\{m\_\{i\}\+n\_\{i\}\+\\varepsilon\},\\qquad\\varepsilon\\ll 1\.\(9\)
These four quantities form the irreducible basis of our feature space\. The exponentcic\_\{i\}is a proxy for the local computational burden and scales with the equivalent FLOP count\. The exponentpip\_\{i\}captures the output size of the step and therefore acts both as a proxy for local memory pressure and for output\-side data parallelism\. The quantitykik\_\{i\}isolates the reduction dimension and serves as a proxy for reuse and arithmetic intensity\. Finally,did\_\{i\}measures the imbalance of the equivalentM×NM\\times Ncontraction and acts as a compact descriptor of contraction geometry, which is relevant to mapping quality and memory\-access regularity\.

### 4\.3Plan\-level feature groups

A complete contraction planπ\\piis a variable\-length sequence ofSSpairwise steps and must therefore be mapped to a fixed\-size vector before it can be used in a tabular learning model\. We do this through a set of plan\-level aggregations that preserve the main structural aspects of the path\. To emphasize the dominant region of the plan, we define the bottleneck exponent

cmax=maxi⁡ci,c\_\{\\max\}=\\max\_\{i\}c\_\{i\},\(10\)and the FLOP\-weighted coefficients

wi=2ci−cmax∑ℓ=1S2cℓ−cmax\.w\_\{i\}=\\frac\{2^\{c\_\{i\}\-c\_\{\\max\}\}\}\{\\sum\_\{\\ell=1\}^\{S\}2^\{c\_\{\\ell\}\-c\_\{\\max\}\}\}\.\(11\)
The resulting aggregated features are organized into five interpretable groups\. The*complexity / critical\-load*block captures the bottleneck, total work, near\-critical tail, and overall heterogeneity of the plan\. The*sequence / granularity*block captures fragmentation and the presence of long tails of very small contractions\. The*parallelism dynamics*block measures how much output\-side parallelism is available globally and at the bottleneck\. The*reduction / intensity*block characterizes whether the expensive part of the plan is reduction\-rich and therefore more likely to benefit from reuse\. Finally, the*geometry / memory access*block summarizes how balanced or skewed the expensive contractions are, which is relevant to kernel efficiency and memory behavior\.

### 4\.4Final inventory and design principles

The final feature space therefore combines a small set of local primitives with a deliberately rich set of plan\-level aggregations\. This partial redundancy is intentional: several aggregated descriptors are correlated, but they encode different hypotheses about what limits runtime in practice, such as a single catastrophic step, a broad near\-critical tail, insufficient output parallelism in the dominant region, low reduction\-driven reuse, unfavorable contraction geometry, or an accumulation of fine\-grained overheads\. Keeping these hypotheses explicit at the feature\-design stage is useful because it allows subsequent ablation and feature\-selection stages to determine which structural mechanisms carry the most predictive signal\.

A key design choice is that the feature vector is derived entirely from the contraction plan\. Consequently, the same plan yields the same feature representation regardless of the GPU on which it is later executed\. What changes across backends is the measured runtime, and therefore the supervision signal used for learning and evaluation\.

Table[2](https://arxiv.org/html/2608.05819#S4.T2)summarizes the final fixed\-size representation used before feature selection\. Further technical details of the cost model and the feature blocks are provided in Appendix[A](https://arxiv.org/html/2608.05819#A1)\.

Table 2:Plan\-level features used to represent a contraction planπ\\pias a fixed\-size vector\. Feature groups are separated by horizontal rules\. Features marked†\\daggerare discarded after selection\.♭\\flatand♯\\sharpare exclusive toopt​\_​pair\\mathrm\{opt\\\_pair\}andopt​\_​ndcg\\mathrm\{opt\\\_ndcg\}, respectively; all other features are used by both optimized models\.Feature nameDefinitionBlockInterpretationmax​\_​cost†\\mathrm\{max\\\_cost\}^\{\\dagger\}maxi⁡ci\\max\_\{i\}c\_\{i\}Complexity / critical loadBottleneck work exponent\.log2​\_​sum​\_​flops†\\mathrm\{log2\\\_sum\\\_flops\}^\{\\dagger\}log2​∑i2ci\\log\_\{2\}\\sum\_\{i\}2^\{c\_\{i\}\}Complexity / critical loadAccumulated work over the full plan\.topq​\_​mean​\_​cost†\\mathrm\{topq\\\_mean\\\_cost\}^\{\\dagger\}\|Iq\|−1​∑i∈Iqci\|I\_\{q\}\|^\{\-1\}\\sum\_\{i\\in I\_\{q\}\}c\_\{i\}Complexity / critical loadSize of the near\-critical tail\.avg​\_​cost†\\mathrm\{avg\\\_cost\}^\{\\dagger\}S−1​∑iciS^\{\-1\}\\sum\_\{i\}c\_\{i\}Complexity / critical loadMean work level\.std​\_​cost♯\\mathrm\{std\\\_cost\}^\{\\sharp\}std⁡\(ci\)\\operatorname\{std\}\(c\_\{i\}\)Complexity / critical loadHeterogeneity of the cost profile\.n\_stepsSSSequence / granularityFragmentation of the plan and potential management overhead\.frac\_tiny\_stepsS−1​∑i𝟏\{ci≤cmax−τ\}S^\{\-1\}\\sum\_\{i\}\\mathbf\{1\}\_\{\\\{c\_\{i\}\\leq c\_\{\\max\}\-\\tau\\\}\}Sequence / granularityFraction of steps far below the bottleneck scale\.max\_out\_rankmaxi⁡pi\\max\_\{i\}p\_\{i\}Parallelism dynamicsPeak output size; proxy for peak local intermediate size and parallel exposure\.avg\_out\_rankS−1​∑ipiS^\{\-1\}\\sum\_\{i\}p\_\{i\}Parallelism dynamicsAverage output\-size level across the plan\.costw\_out\_rank∑iwi​pi\\sum\_\{i\}w\_\{i\}p\_\{i\}Parallelism dynamicsOutput parallelism in the expensive part of the plan\.p\_at\_max\_cost\|Imax\|−1​∑i∈Imaxpi\|I\_\{\\max\}\|^\{\-1\}\\sum\_\{i\\in I\_\{\\max\}\}p\_\{i\}Parallelism dynamicsParallel exposure at the bottleneck\.max\_red\_rankmaxi⁡ki\\max\_\{i\}k\_\{i\}Reduction / intensityLargest reduction dimension encountered\.costw​\_​red​\_​rank♭\\mathrm\{costw\\\_red\\\_rank\}^\{\\flat\}∑iwi​ki\\sum\_\{i\}w\_\{i\}k\_\{i\}Reduction / intensityReduction\-richness of the expensive region\.k\_at\_max\_cost\|Imax\|−1​∑i∈Imaxki\|I\_\{\\max\}\|^\{\-1\}\\sum\_\{i\\in I\_\{\\max\}\}k\_\{i\}Reduction / intensityArithmetic\-intensity proxy at the bottleneck\.max\_asymmaxi⁡di\\max\_\{i\}d\_\{i\}Geometry / memory accessWorst contraction imbalance in the plan\.avg\_asymS−1​∑idiS^\{\-1\}\\sum\_\{i\}d\_\{i\}Geometry / memory accessGlobal tendency toward skinny or square contractions\.costw\_asym∑iwi​di\\sum\_\{i\}w\_\{i\}d\_\{i\}Geometry / memory accessShape imbalance of the expensive region\.d\_at\_max\_cost\|Imax\|−1​∑i∈Imaxdi\|I\_\{\\max\}\|^\{\-1\}\\sum\_\{i\\in I\_\{\\max\}\}d\_\{i\}Geometry / memory accessMapping quality at the bottleneck\.

## 5Methodology

This section defines the common methodology used by the two experimental studies that follow\. It describes how the candidate plans and relevance labels are constructed, how the data are partitioned and evaluated without group leakage, how the feature set and ranking models are selected, and which hardware and software platforms are used\. Sections[6](https://arxiv.org/html/2608.05819#S6)and[7](https://arxiv.org/html/2608.05819#S7)then apply this common setup to source\-backend evaluation and backend\-shift evaluation, respectively\.

### 5\.1Dataset Construction and Relevance Labels

Execution time is backend\-dependent, as it varies with the GPU and software stack, whereas the model input is backend\-independent because it is computed solely from the contraction plan\. Backend dependence therefore enters through the target variable\.

LetT​\(Pi\)T\(P\_\{i\}\)denote the execution time of a candidate planPiP\_\{i\}on the target GPU, and letPmfP\_\{\\mathrm\{mf\}\}be the corresponding MinFill plan for the same tensor network\. We define the relative speedup

S​pi=T​\(Pmf\)T​\(Pi\),Sp\_\{i\}=\\frac\{T\(P\_\{\\mathrm\{mf\}\}\)\}\{T\(P\_\{i\}\)\},\(12\)and the relevance label

yi=log⁡\(1\+S​pi\)\.y\_\{i\}=\\log\(1\+Sp\_\{i\}\)\.\(13\)Since ranking is defined within each circuit\-specific group of plans, this target is aligned with the goal of selecting the fastest candidate while being less sensitive to global timing scale than absolute runtime\. The logarithm reduces the dynamic range of speedups, preserves their ordering, and yields non\-negative relevance values suitable for NDCG\-based objectives\.

We use MinFill as a baseline because it is a classical and widely adopted heuristic for elimination\-order problems closely related to treewidth, which in turn is a key proxy for tensor\-network contraction complexity\[[31](https://arxiv.org/html/2608.05819#bib.bib33),[17](https://arxiv.org/html/2608.05819#bib.bib19)\]\. In practice, it provides a simple, inexpensive, and reproducible reference that requires neither training data nor hyperparameter tuning, making it a natural point of comparison for learned ranking models\. Moreover, MinFill and related heuristics are commonly used as baselines in the literature on treewidth and sparse elimination\[[21](https://arxiv.org/html/2608.05819#bib.bib23),[3](https://arxiv.org/html/2608.05819#bib.bib6)\], so outperforming it offers a clear and interpretable measure of the added value of our LTR approach\.

To expose the model to a broad range of contraction behaviors, we built the dataset from a diverse set of quantum circuits, including both well\-known benchmarks, such as MQTBench\[[43](https://arxiv.org/html/2608.05819#bib.bib57)\], and more irregular instances generated using QXTools\. The goal was to induce as much variation as possible in the contraction plans produced by different heuristics and in their measured execution on the GPU\. Representative families include QFT\-based circuits, Greenberger–Horne–Zeilinger \(GHZ\), variational quantum eigensolver \(VQE\), and several classes of random circuits, including random quantum circuit \(RQC\), among many others\.

For each circuit, we generated seven candidate contraction plans using structurally diverse heuristics\. MinFill and FlowCutter were obtained through QXTools; the remaining candidates were produced using a Girvan–Newman community\-detection heuristic\[[15](https://arxiv.org/html/2608.05819#bib.bib17)\], the Jdrasil heuristic solver, the Tamaki local\-improvement heuristic, and two MinFill\-based heuristics submitted by Terrioux et al\. to the Parameterized Algorithms and Computational Experiments \(PACE\) 2017 treewidth challenge\[[12](https://arxiv.org/html/2608.05819#bib.bib59)\]\. Each plan was then executed on the target GPU to measure its wall\-clock timeT​\(Pi\)T\(P\_\{i\}\)\.

For each contraction plan, one warm\-up run was followed by 50 measured repetitions\. The reported runtime is the mean across these repetitions\. GPU synchronization was enforced immediately before and after each timed contraction\-plan execution usingCUDA\.synchronize\(\)\. All computations were performed in single\-precision \(Float32\) arithmetic\. Plans, caches, and workspace memory were reused across repetitions to amortize setup overheads\. Any out\-of\-memory or timeout event \(10 minutes\) caused the run to be aborted and marked as failed, and T those plans were excluded from the subsequent analyses\. Consequently, some circuit groups contain fewer than seven valid candidates\. CPU–GPU transfers, memory allocation, plan creation, and just\-in\-time \(JIT\) compilation times were excluded from the measurement, as they are not part of the contraction itself and would introduce backend\-dependent overheads that are not representative of the execution cost in the GPU\.

This protocol was applied consistently to all contraction plans on both GPU backends\.

### 5\.2Data Partitioning and Evaluation Protocol

The 225 circuit\-specific ranking groups were partitioned into three disjoint subsets: a development set containing 138 groups, a locked in\-distribution test set containing 25 groups, and an out\-of\-distribution set containing the 62 groups from the held\-out QFT\-based family\. The development set was used for feature selection, cross\-validation, hyperparameter optimization, learning\-curve analysis, and final model fitting\. The ID and OOD sets remained locked throughout model development\. All valid candidate plans associated with the same circuit instance were assigned to the same subset, thereby preventing circuit\-level data leakage\. The resulting partition is summarized in Table[3](https://arxiv.org/html/2608.05819#S5.T3)\.

Table 3:Partition of the 225 circuit groups used for model development and final evaluation\.
### 5\.3Feature Validation and Selection

The initial feature representation is first tested with a diagnostic ranking model and group\-aware validation\. Sanity checks and learning curves are then used to verify that the observed signal is not caused by leakage or trivial artifacts before redundant features are removed\. We trained the ranking models with XGBoost\.jl\[[9](https://arxiv.org/html/2608.05819#bib.bib12)\], using eitherrank:ndcgorrank:pairwiseas the objective\. Plans were grouped by circuit so that comparisons were restricted to candidates belonging to the same ranking problem\.

To evaluate the raw predictive value of the initial 18\-feature representation, we began with a simple heuristic configuration\. We selected a set of “rule\-of\-thumb” hyperparameters to evaluate the raw predictive power of the 18\-feature vector\(𝐱18\)\(\\mathbf\{x\}\_\{18\}\)\. These parameters were chosen based on established literature for gradient boosting on medium\-sized datasets\[[9](https://arxiv.org/html/2608.05819#bib.bib12),[34](https://arxiv.org/html/2608.05819#bib.bib36)\]to ensure a balance between learning capacity and training speed:

- •Objective \(rank:ndcgorrank:pairwise\):Selected to align the model with the LTR paradigm\.
- •Learning Rate \(eta=0\.01=0\.01\):A small learning rate was used to introduce gradual updates and reduce the risk of overfitting\.
- •Tree Depth \(max\_depth=6=6\):A moderate depth used to capture non\-linear interactions between computational cost and tensor shapes without inducing immediate overfitting\.
- •Tree Method \(gpu\_hist\):Employed to leverage the computational throughput of the GPU during the histogram construction of the trees\[[33](https://arxiv.org/html/2608.05819#bib.bib35)\]\.
- •Regularization \(λ=1,α=0\\lambda=1,\\alpha=0\):Standard L2 regularization to stabilize the initial weight updates\.
- •Subsampling \(subsample=0\.7\):A fraction of the training instances was sampled for each tree to reduce overfitting and improve robustness\.

We evaluated the diagnostic models using five\-fold grouped cross\-validation over the complete development set of 138 circuit groups\. In each iteration, four folds were used for training and the remaining fold for validation\. All candidate plans associated with the same circuit were assigned to the same fold, thereby preventing circuit\-level leakage and preserving the grouped ranking structure\. Validation and early stopping were based on NDCG@3 computed on the validation fold of the corresponding iteration\. The normalized discounted cumulative gain truncated at the top three positions \(NDCG@3\) measures how well the most relevant plans are placed near the top of each group\. Feature selection and the learning curves were performed using five\-fold grouped cross validation over the complete development set\.

We then subjected this initial model to standard sanity checks\. In particular, we verified that performance collapsed when the labels were randomly shuffled, confirming that the predictive signal did not arise from leakage or trivial dataset artifacts\. After this preliminary validation, we computed learning curves to assess the quality and generalization behavior of the initial model\. These curves revealed clear signs of overfitting, with training performance continuing to improve while validation performance saturated or degraded\. This diagnosis motivated the next stages of the protocol, aimed at improving robustness and reducing unnecessary model complexity\.

Feature selection was guided by two complementary importance analyses: Gain, which reflects the reduction in loss contributed by a feature during tree splits, and Shapley values, which provide a more global view of feature contribution\[[16](https://arxiv.org/html/2608.05819#bib.bib18),[30](https://arxiv.org/html/2608.05819#bib.bib32)\]\. This analysis showed that 4 of the original 18 features were either highly redundant or contributed negligible predictive signal, and they were therefore removed\. The union of the two selected feature sets contained 14 features\. Each optimized model used 13 features: 12 shared features and one objective\-specific feature, as indicated in Table[2](https://arxiv.org/html/2608.05819#S4.T2)\.

### 5\.4Model Optimization and Training

This stage selects the final hyperparameters, trains the two optimized rankers, and defines the comparison baselines used in the source\-backend evaluation\.

We optimized the XGBoost ranking models through a randomized hyperparameter search using the same five\-fold grouped cross\-validation protocol\. The search focused on a small set of parameters with the greatest impact on model capacity and regularization:max\_depth, which controls tree complexity;eta, which sets the learning rate; andlambda,alpha, andmin\_child\_weight, which regulate model smoothness and splitting conservativeness\. These parameters were explored for both therank:ndcgandrank:pairwiseobjectives\.

Each sampled configuration was evaluated using the mean validationNDCG​@​3\\mathrm\{NDCG\}@3across the five folds, with early stopping applied independently on the validation fold of each iteration to determine the appropriate number of boosting rounds\. The best\-performing configurations were retained as the final optimized models, whose main hyperparameters are summarized in Table[4](https://arxiv.org/html/2608.05819#S5.T4)\.

Our main comparison focuses on two optimized XGBoost rankers that differ only in the training objective\. The first,opt\_ndcg, usesrank:ndcg, whereas the second,opt\_pair, usesrank:pairwise\. Both models were obtained with the same protocol described above: the same data partitions, the same feature\-selection procedure, the same hyperparameter\-optimization pipeline, and the same validation metric,NDCG​@​3\\mathrm\{NDCG\}@3\. The comparison therefore isolates the effect of the training objective while keeping the rest of the pipeline fixed\.

This distinction is meaningful because the two objectives embody different ranking strategies\. Therank:ndcgobjective uses a LambdaMART formulation scaled toward NDCG, making it explicitly sensitive to the quality of the top part of the ranking, whereasrank:pairwiseuses the original pairwise RankNet\-style loss and focuses on reducing pairwise inversions\. XGBoost also provides a third built\-in ranking objective,rank:map, but this objective is primarily intended for binary relevance labels\. Since our target is graded rather than binary,rank:ndcgandrank:pairwiseare the two built\-in objectives most appropriate for the present study\. XGBoost does not provide a dedicated pointwise objective for grouped LTR, so the comparison is centered on the two ranking objectives that best match our task\.

Table 4:Main hyperparameters of the two optimized XGBoost ranking models\. A dash indicates that the parameter was not explicitly fixed and was left at the library default\. L1 and L2 denote two regularization techniques to control overfitting\.Parameteropt\_ndcgopt\_pairDescriptionobjectiverank:ndcgrank:pairwiseTraining objectiveeval\_metricndcg@3ndcg@3Validation metricmaximizetruetrueMaximize evaluation metriceta0\.010\.05Learning ratemax\_depth65Maximum tree depthsubsample0\.70\.5Fraction of samples used per treecolsample\_bytree–0\.5Fraction of features sampled per treemin\_child\_weight–3Minimum child\-node weightgamma–0\.5Minimum loss reduction for a splitlambda–0\.0L2 regularizationalpha––L1 regularizationseed4242Random seedTo contextualize the performance of the learned rankers, we compare them against three baselines\. The first,random, provides a lower bound by assigning the plan order uniformly at random\. The second,mf\_ndcg, is a hybrid baseline that forces the MinFill plan to the first position and usesopt\_ndcgonly to rank the remaining candidates\. The third,mf\_rand, also fixes MinFill at the first position but assigns the remaining plans randomly\.

These two MinFill\-based baselines are useful because the target speedup is defined relative to the MinFill plan\. As a result, they allow us to separate two effects: first, the value of allowing the learned model to challenge MinFill at the top of the ranking \(by comparingopt\_ndcgagainstmf\_ndcg\); and second, the value of learning a meaningful secondary ranking once MinFill is fixed at Top\-1 \(by comparingmf\_ndcgagainstmf\_rand\)\. Together, these comparisons clarify whether the gains of the learned models come mainly from improving the first recommendation, from improving the ordering of the remaining plans, or from both\.

After feature selection and hyperparameter optimization \(HPO\), the selected model configurations were retrained on the full development set,i\.e\., all 138 groups\.The resulting fixed models were then evaluated once on the locked ID and OOD sets\. Their robustness and generalization are assessed experimentally through the source\-backend and backend\-shift evaluations presented in Sections[6](https://arxiv.org/html/2608.05819#S6)and[7](https://arxiv.org/html/2608.05819#S7)\.

After completing the full experimental evaluation on the locked in\-distribution and OOD splits, a separate deployment model may be retrained using all labeled data to maximize practical utility\. This post\-evaluation refit is intended for downstream use only and should not be interpreted with the same reported test/OOD metrics, which apply to the evaluation protocol described above\.

### 5\.5Experimental Platform and Software

The following platform is shared by the experimental analyses in Sections[6](https://arxiv.org/html/2608.05819#S6)and[7](https://arxiv.org/html/2608.05819#S7)\. The RTX A6000 provides the source\-backend measurements used for model development and the main evaluation, while the Tesla V100 is reserved for the backend\-shift study\.

The primary execution environment was a high\-performance computing server with two AMD EPYC 7282 processors, each providing 16 cores at a base clock frequency of 2\.8 GHz, together with 256 GiB of DDR4 memory and 64 MiB of L3 cache\.

The NVIDIA RTX A6000 was used as the primary GPU backend to generate the labels employed during model development and to conduct all learning\-curve, in\-distribution, and out\-of\-distribution experiments reported in Section[6](https://arxiv.org/html/2608.05819#S6)\. The NVIDIA Tesla V100 was used only for the cross\-GPU analyses presented in Section[7](https://arxiv.org/html/2608.05819#S7)\. Measurements from the complete dataset were used to compare the GPU\-specific ground\-truth rankings, whereas the locked in\-distribution test subset was used to evaluate the zero\-shot transfer of the Ampere\-trained models\. The main characteristics of both GPU backends are summarized in Table[5](https://arxiv.org/html/2608.05819#S5.T5)\.

Table 5:GPU specifications used in the experimental study\.The simulations were implemented in Julia using QXTools\.jl to construct the tensor networks and candidate contraction plans\[[4](https://arxiv.org/html/2608.05819#bib.bib7)\], OMEinsum\.jl to execute the contractions, and CUDA\-enabled GPU execution\. The ranking models were trained with XGBoost\.jl\[[9](https://arxiv.org/html/2608.05819#bib.bib12),[54](https://arxiv.org/html/2608.05819#bib.bib1)\]\. The same software stack was used on both GPU backends\. Complete package versions, environment manifests, and system\-configuration details will be provided in the accompanying repository\.

## 6Source\-Backend Evaluation

This section evaluates the learning behavior and final decision quality of the optimized rankers on the RTX A6000, the source backend used to generate their training labels\. We first use learning curves to examine sample efficiency and train–validation behavior within the development data\. We then evaluate the fixed models on the locked in\-distribution test set and on the held\-out QFT\-based family, separating standard generalization from circuit\-family shift\.

### 6\.1Learning\-Curve Analysis

To assess the sample efficiency and generalization behavior of the two optimized models, we analyze learning curves built exclusively on the development set\. We report two complementary metrics\. The first isNDCG​@​3\\mathrm\{NDCG\}@3, which is the validation metric used throughout model selection and therefore provides the most direct view of how ranking quality evolves as additional training circuits are incorporated\. The second isRegret3\\mathrm\{Regret3\}, a decision\-oriented metric that measures the relative speedup loss incurred when the best plan within the model’s Top\-3 recommendations is selected\. WhileNDCG​@​3\\mathrm\{NDCG\}@3evaluates the quality of the ranking itself,Regret3\\mathrm\{Regret3\}captures the practical cost of imperfect ranking decisions\. For both metrics, we report values on the training subset and on a held\-out validation subset\.

![Refer to caption](https://arxiv.org/html/2608.05819v1/x1.png)\(a\)opt\_ndcg
![Refer to caption](https://arxiv.org/html/2608.05819v1/x2.png)\(b\)opt\_pair

Figure 1:Learning curves for the two optimized models\. Each subfigure reports training and validationNDCG​@​3\\mathrm\{NDCG\}@3\(top\) andRegret3\\mathrm\{Regret3\}\(bottom\) as a function of the number of training circuit groups\.Fig\.[1](https://arxiv.org/html/2608.05819#S6.F1)shows that both models maintain highNDCG​@​3\\mathrm\{NDCG\}@3values throughout the experiment and lowRegret3\\mathrm\{Regret3\}, with limited train–validation gaps after the final optimization stages\. The most visible improvements occur up to roughly 40–45 training circuits, after which the curves enter a broad plateau\. This behavior suggests that the selected features are already informative at moderate sample sizes and that additional data yields diminishing, although still positive, returns\.

The same figure also indicates that the strong overfitting observed in the earlier diagnostic models has been substantially reduced\. In both optimized models, the training and validation curves remain reasonably close across the full range of dataset sizes\. It would nevertheless be too strong to claim a complete absence of overfitting: a non\-negligible train–validation gap remains, especially at smaller training sizes, but it stays limited and does not widen as more data are added\.

In terms ofNDCG​@​3\\mathrm\{NDCG\}@3, bothopt\_ndcgandopt\_pairachieve high validation values, indicating strong ranking quality even with relatively small development subsets\. Because the curves remain close to the upper bound of the metric, the absolute gains are necessarily modest and should be interpreted as refinements near the performance ceiling rather than as large raw improvements\. Within this regime,opt\_ndcgfollows a slightly more regular validation trajectory and tends to maintain a somewhat smaller train–validation gap\. This is consistent with the fact that its training objective is directly aligned with the validation metric\.

The distinction becomes clearer inRegret3\\mathrm\{Regret3\}\. For both models, regret decreases noticeably as more training circuits are added, confirming that the learned rankings become increasingly useful for practical Top\-3 selection\. However,opt\_ndcgreaches consistently lower validation regret in the medium\- and large\-data regime, ending near3×10−33\\times 10^\{\-3\}to4×10−34\\times 10^\{\-3\}, whereasopt\_pairstabilizes around7×10−37\\times 10^\{\-3\}\. Thus, althoughopt\_pairremains competitive as a ranking model,opt\_ndcgyields better decision quality when the final goal is to minimize the speedup loss within the Top\-3 recommendations\.

The learning\-curve analysis supports two conclusions\. First, both optimized models are sample\-efficient and generalize reasonably well once feature selection and hyperparameter optimization have been applied\. Second, the NDCG\-aware objective provides a better trade\-off between ranking quality and downstream decision quality, which anticipates the stronger performance ofopt\_ndcgin the final test\-set comparisons\.

### 6\.2In\-Distribution and Circuit\-Family\-Shift Evaluation

We next compare the two optimized models,opt\_ndcgandopt\_pair, against the three baselines introduced above:random,mf\_ndcg, andmf\_rand\. We first evaluate them on the standard held\-out ID test split and then on a more challenging OOD domain\-shift split\. This two\-stage evaluation allows us to assess both the absolute quality of the learned rankings under standard conditions and their robustness when the test circuits differ more substantially from those seen during development\.

To characterize model performance, we report both hit\-based and decision\-oriented metrics\. Top\-1 and Top\-3 denote the percentage of groups in which the true best plan is ranked first or appears within the first three positions, respectively\. To quantify the practical cost of imperfect recommendations, we also reportRegret1\\mathrm\{Regret1\}andRegret3\\mathrm\{Regret3\}, defined as

Regret1\\displaystyle\\mathrm\{Regret1\}=1−S​p1S​p⋆,\\displaystyle=1\-\\frac\{Sp\_\{1\}\}\{Sp^\{\\star\}\},\(14\)Regret3\\displaystyle\\mathrm\{Regret3\}=1−maxi∈Top−3⁡S​piS​p⋆,\\displaystyle=1\-\\frac\{\\max\_\{i\\in\\mathrm\{Top\-3\}\}Sp\_\{i\}\}\{Sp^\{\\star\}\},\(15\)whereS​p⋆Sp^\{\\star\}is the optimal speedup in the group andS​p1Sp\_\{1\}is the speedup of the plan at rank 1\. Lower regret therefore indicates better decision quality\. Finally, we report*win rate*, defined as the fraction of groups in which the model’s top\-ranked plan achieves a higher speedup than the MinFill plan, with ties counted as half a win for each side\. Sincemf\_ndcgandmf\_randalways place MinFill at rank 1, their win rate is50%50\\%by construction\.

#### 6\.2\.1In\-distribution test

Table 6:ID test results \(N = 25 circuit groups\)\. Higher is better for Top\-1, Top\-3, andWin​rate\\mathrm\{Win\\ rate\}; lower is better forRegret1\\mathrm\{Regret1\}andRegret3\\mathrm\{Regret3\}\.Table[6](https://arxiv.org/html/2608.05819#S6.T6)reveals a clear hierarchy on the ID test split\. The two optimized models substantially outperform all baselines across the main decision metrics, confirming that the selected structural features capture non\-trivial patterns that generalize to unseen circuits from the same domain\. The comparison between the two optimized models is also consistent with the learning\-curve analysis: both achieve the same Top\-1 accuracy \(60%60\\%\), butopt\_ndcgattains better Top\-3 \(96%96\\%vs\.92%92\\%\), lowerRegret1\\mathrm\{Regret1\}\(0\.01410\.0141vs\.0\.02110\.0211\), and the same bestRegret3\\mathrm\{Regret3\}\(0\.00040\.0004\)\. Thus, both models usually place an excellent candidate near the top of the ranking, butopt\_ndcgis more reliable when only a single plan will ultimately be executed\.

The baselines help clarify where these gains come from\. Therandombaseline performs much worse than either optimized model in Top\-1, Top\-3, and regret, showing that the observed gains are not due to chance\. The two MinFill\-based baselines are more informative still\. Because they force MinFill to rank first, both inherit very poor Top\-1 andRegret1\\mathrm\{Regret1\}, which shows that MinFill is rarely the true optimum in this setting\. However, comparingmf\_ndcgagainstmf\_randisolates the value of ordering the remaining candidates well once MinFill is fixed at the top: Top\-3 rises from28%28\\%to84%84\\%, andRegret3\\mathrm\{Regret3\}drops from0\.03190\.0319to0\.00250\.0025\. This confirms that the secondary ranking still matters greatly when the user is willing to inspect a shortlist, although it cannot compensate for a systematically poor first recommendation\.

#### 6\.2\.2Circuit\-family\-shift evaluation

Table 7:OOD domain\-shift results \(N = 62 circuit groups\)\. Higher is better for Top\-1, Top\-3, andWin​rate\\mathrm\{Win\\ rate\}; lower is better forRegret1\\mathrm\{Regret1\}andRegret3\\mathrm\{Regret3\}\.For the OOD evaluation, we constructed a dedicated held\-out split by reserving all QFT\-based circuits, across the considered qubit counts, and excluding them entirely from training, validation, and the in\-distribution test set\. The OOD results in Table[7](https://arxiv.org/html/2608.05819#S6.T7)therefore measure the ability of the models to transfer to a circuit family not seen at any stage of model development\.

As expected, all models degrade under this domain shift\. The learned rankers retain useful ranking information, but their advantage over the baselines is no longer uniform across all decision metrics\.opt\_ndcgprovides the strongest OOD performance, achieving the best Top\-1, Regret1, and Regret3 values while tyingopt\_pairon Top\-3\. This indicates that it remains the most effective option when the goal is to get as close as possible to the true optimum on an unseen circuit family\.

Taken together, Tables[6](https://arxiv.org/html/2608.05819#S6.T6)and[7](https://arxiv.org/html/2608.05819#S6.T7)support three conclusions\. First, both learned models clearly outperform the random and MinFill\-based baselines in the standard ID setting\. Second,opt\_ndcgprovides the strongest overall trade\-off between ranking quality and decision quality, especially when a single recommendation must be trusted\. Third, the OOD experiment confirms that transfer performance is sensitive to the held\-out circuit family: although the learned rankers retain useful predictive signal, the degradation from in\-distribution to OOD indicates that generalization quality depends noticeably on which family is excluded during development\. In our case, holding out QFT\-based circuits provides a demanding but still single\-family domain\-shift test, so these results should be interpreted as evidence of non\-trivial sensitivity to unseen circuit structure rather than as a definitive limitation of the feature set\. This suggests that broader training distributions and additional family\-level hold\-out experiments would be valuable in future work\.

## 7Backend\-Shift Evaluation

Section[6](https://arxiv.org/html/2608.05819#S6)evaluated the rankers on the RTX A6000, which also supplied the measurements used during model development\. This section examines what changes when the same candidate plans are executed on the Tesla V100 and asks whether the Ampere\-trained rankings remain useful without retraining or target\-backend calibration\.

The study separates two questions\. First, using all circuit groups, we compare the empirical rankings obtained by executing the same candidate plans on both GPUs, which shows how much the ranking target itself changes across backends\. Second, on the locked in\-distribution test set, we keep the Ampere\-trained models and their predicted orderings unchanged and evaluate those orderings against speedups and relevance labels recomputed from the Volta measurements\. This isolates zero\-shot model transfer from changes in the candidate set or test composition\. The results describe one observed backend shift and should not be interpreted as evidence of general GPU portability\.

### 7\.1Ground\-Truth Ranking Stability Across GPUs

Before evaluating model transfer, we first examine whether changing the GPU alters the ranking target itself\. This analysis uses all 225 circuit groups in the dataset and does not involve model predictions\. For each circuit, the same set of successfully measured candidate plans were executed on the RTX A6000 and the Tesla V100, and the two empirical rankings were obtained from the corresponding execution measurements\.

We compare the complete rankings using Kendall’sτb\\tau\_\{b\}\[[25](https://arxiv.org/html/2608.05819#bib.bib27)\], computed independently within each circuit group\. This coefficient measures pairwise ordinal agreement and accounts for ties: a value of11corresponds to identical orderings, whereas lower values indicate that more pairwise preferences change between GPUs\.

To quantify the sampling variability of the aggregate cross\-GPU stability measures, we computed 95% percentile\-bootstrap confidence intervals by resampling complete circuit groups\. For each ofB=10,000B=10\{,\}000bootstrap replicates,N=225N=225groups were sampled with replacement from the observed dataset, and the mean Kendall’sτb\\tau\_\{b\}, same\-best\-plan rate, and mean Top\-3 overlap were recomputed\. The interval endpoints were defined by the 2\.5th and 97\.5th percentiles of the resulting bootstrap distribution\. Resampling was performed at the circuit\-group level \(base\_id\), rather than at the level of individual contraction plans, to preserve the dependence among candidate plans retained for the same circuit\. The random seed was fixed to 42 for reproducibility\. These intervals quantify variability across circuit groups under the assumption that the observed dataset is representative of the broader population of circuits of interest; they do not account for timing\-measurement uncertainty or for changes in circuit\-family composition\.

Table[8](https://arxiv.org/html/2608.05819#S7.T8)summarizes the distribution of the resulting coefficients\.

Table 8:Summary of Kendall’sτb\\tau\_\{b\}across the 225 circuit groups\.The upper part of the ranking is examined separately because it is the most relevant region for plan selection\. LetIg,A\(3\)I^\{\(3\)\}\_\{g,A\}andIg,B\(3\)I^\{\(3\)\}\_\{g,B\}denote the unordered sets of the three fastest plans for circuitggon the two GPUs\. The Top\-3 set overlap for that circuit is

Ov3,g=\|Ig,A\(3\)∩Ig,B\(3\)\|3,\\mathrm\{Ov\}\_\{3,g\}=\\frac\{\\left\|I^\{\(3\)\}\_\{g,A\}\\cap I^\{\(3\)\}\_\{g,B\}\\right\|\}\{3\},\(16\)
and the value reported in Table[9](https://arxiv.org/html/2608.05819#S7.T9)is its mean across theGGcircuit groups,

Ov3=1G​∑g=1GOv3,g\.\\mathrm\{Ov\}\_\{3\}=\\frac\{1\}\{G\}\\sum\_\{g=1\}^\{G\}\\mathrm\{Ov\}\_\{3,g\}\.\(17\)
The order of the plans within each Top\-3 set is ignored\. Thus, a circuit contributes11,2/32/3,1/31/3, or0, depending on whether the two GPUs share three, two, one, or none of their three fastest plans\. The same\-best\-plan rate is stricter at the first position and measures the fraction of circuits for which both GPUs identify the same fastest plan\.

Table 9:Stability of the decision\-relevant part of the rankings across the 225 circuit groups\.The results in Tables[8](https://arxiv.org/html/2608.05819#S7.T8)and[9](https://arxiv.org/html/2608.05819#S7.T9)indicate that most pairwise preferences are preserved when moving from Ampere to Volta, although the degree of stability varies among circuits\. The meanτb\\tau\_\{b\}is0\.850\.85, while the median of1\.01\.0means that at least half of the circuit groups retain the complete ordering of their common candidate plans\. The lower values found in some groups show that this stability is not universal and that the backend can substantially reorder the candidates in particular cases\.

Agreement is slightly weaker when only the fastest plan is considered\. The two GPUs select the same best plan in84%84\\%of the circuits, so local exchanges near the top of the ranking occur more often than complete changes in ranking structure\. The mean Top\-3 set overlap is89\.63%89\.63\\%, corresponding to an average of2\.692\.69shared plans out of three per circuit\. The short list of competitive plans is therefore more stable than the identity of the single fastest plan, which is useful when several recommendations can be tested on the target GPU\.

Stability also differs across circuit families, as reported in Table[10](https://arxiv.org/html/2608.05819#S7.T10)\. Quantum Walk circuits retain exactly the same rankings on both devices, while Grover and GHZ circuits also show high agreement\. RQC circuits occupy an intermediate position, and the lower values for the QFT\-based family indicate greater sensitivity to the backend\.

Table 10:Ground\-truth ranking stability by circuit family\.A plausible explanation is that the regular contraction structures produced by QWALK and GHZ circuits leave less room for hardware\-dependent trade\-offs to change the ordering\. More heterogeneous plans may contain closer balances between computational work, reduction size, parallelism, contraction geometry, and memory traffic, allowing architectural differences to affect their relative execution times\. The present experiment does not isolate these factors, so this interpretation should not be treated as a causal result\.

This analysis shows how much the empirical ranking target changes between the two GPUs\. It does not establish whether the Ampere\-trained models still make good recommendations on Volta, which is evaluated separately in the next subsection\.

### 7\.2Zero\-Shot Model Transfer under GPU Backend Shift

We next examine whether the rankers trained from Ampere measurements remain useful when plan quality is determined by execution on Volta\. This evaluation uses the same 25 circuit groups and the same candidate plans as the locked in\-distribution test\. The models are not retrained or calibrated for the target GPU\. Since their input features depend only on the contraction plans, the feature vectors and predicted rankings remain unchanged; only the runtimes, MinFill\-relative speedups, and relevance labels used to evaluate those predictions are recomputed from the Volta executions\.

Table[11](https://arxiv.org/html/2608.05819#S7.T11)compares the decision quality of both rankers when their fixed predictions are evaluated against the Ampere and Volta ground truths\. Top\-1, Top\-3, Regret1, Regret3, and win rate are computed in the same way as in the earlier in\-distribution evaluation, with MinFill executed separately on each backend\.

Table 11:Zero\-shot cross\-GPU performance on the locked in\-distribution test set \(N=25N=25\)\. Both models were trained using Ampere measurements\. The evaluation backend determines the runtimes, speedups, and relevance labels used to assess the fixed model predictions\.Both models retain a high Top\-3 rate on Volta, with a decrease of four percentage points in each case\. The shortlists obtained from the structural plan features therefore remain useful after the backend change\. The increase in regret reveals a loss that Top\-3 alone does not capture: when the fastest plan is absent from the shortlist, the best available recommendation can be farther from the optimum on Volta\.

The NDCG\-oriented model is less affected in this experiment\. Its Regret1 increases from0\.0140\.014to0\.0250\.025, whereas the pairwise model rises from0\.0210\.021to0\.0530\.053\. Regret3 follows the same pattern\. This suggests thatopt\_ndcgpreserves the quality of its highest\-ranked candidates better under the observed backend shift\. The comparison involves only one target architecture, however, and does not establish that the NDCG\-oriented objective is generally more robust across GPUs\.

The Top\-1 rate ofopt\_ndcgincreases from60%60\\%to64%64\\%, while that ofopt\_pairdecreases to52%52\\%\. The increase foropt\_ndcgcorresponds to one additional correct circuit among the 25 test groups and should not be interpreted as an improvement caused by the change of GPU\. With a small test set, an exchange between two closely performing plans can change the Top\-1 result for an entire circuit without representing a broad improvement in ranking quality\.

The win rate remains unchanged for both models:92%92\\%foropt\_ndcgand88%88\\%foropt\_pair\. Their first recommendations therefore continue to outperform the backend\-specific MinFill plan in a similar proportion of test circuits\. Identical aggregate percentages do not necessarily mean that the models win on the same circuits on both GPUs\.

The fixed Ampere\-trained rankings retain useful decision quality when assessed with Volta measurements, particularly when three candidate plans can be tested\. The higher regret also shows that the backend change is not neutral and that the relative cost of a wrong recommendation can increase even when Top\-3 and win rate remain high\. This experiment provides evidence for zero\-shot transfer between the two NVIDIA architectures considered here, not for general independence from the hardware and software backend\.

## 8Conclusions

The aim of this study was to select efficient contraction plans for GPU\-based quantum circuit simulation without executing every candidate beforehand\. We treated this as a ranking problem: for this application, identifying a good plan or a useful shortlist matters more than predicting exact runtimes\.

The rankers use structural descriptors extracted directly from the sequence of contractions\. These features capture properties related to computational load, parallelism, reductions, contraction geometry, and plan granularity, but require no preliminary execution or profiling on the GPU\. The resulting model can therefore be placed between plan generation and execution as a low\-cost selection stage\.

The experiments show that this representation contains enough information to distinguish useful plans\. On the locked in\-distribution test, the NDCG\-oriented model placed the fastest plan first in60%60\\%of the circuits and within its first three recommendations in96%96\\%, with a meanRegret1\\mathrm\{Regret1\}of0\.01410\.0141\. It gave the best balance between Top\-kkaccuracy and decision regret among the models considered\. When the complete QFT\-based family was excluded from model development, its Top\-3 rate fell to62\.9%62\.9\\%\. The drop is substantial, but the model still retained useful predictive information for a circuit family it had not seen during training or validation\.

The cross\-GPU results show a similar mixture of stability and change\. Across the full dataset, Ampere and Volta selected the same fastest plan in84%84\\%of the circuits, and their sets of three fastest plans had a mean overlap of89\.6%89\.6\\%\. On the locked test set, the Ampere\-trained NDCG model retained a Top\-3 rate of92%92\\%when evaluated with Volta measurements, although its regret increased\. Structural properties of the plans therefore transfer to some extent across these two architectures, but the observed backend shift is too limited to support a general claim of hardware independence\.

In practice, the method can reduce the candidate set to one plan or a short list that is then measured on the target GPU\. Its usefulness still depends on the quality and diversity of the plans supplied to the ranker; the method selects among existing candidates rather than generating new contraction orders\.

Our next step is to generate substantially larger and more varied candidate sets for each circuit, increasing both the dataset size and the range of plan structures represented in it\. This will make it possible to study how ranking quality changes as the candidate pool grows\. We also plan a stricter domain\-shift experiment in which complete plan\-generation methods or heuristic families are withheld from training and validation\. In a later stage, we intend to include more distinct GPU backends and investigate rankers conditioned on descriptors of the target hardware and software stack, possibly supported by a small calibration set\. That extension will depend on the portability of QXTools and its current CUDA\-based environment\.

## Author Contributions

A\.M\.P\.: Software, Investigation, and Visualization\. M\.C\. and J\.M\.B\.: Supervision and Funding acquisition\. All authors: Conceptualization, Methodology, Validation, Writing – original draft, and Writing – review & editing\. All authors discussed the results, approved the final version of the manuscript, and take responsibility for its content\.

ChatGPT \(OpenAI\) and Gemini \(Google\) were used as writing assistants for language editing, structural suggestions, and bibliographic and formal review\. All scientific claims, numerical results, interpretations, software, experimental results, and final wording were verified and approved by the authors, who take full responsibility for the manuscript\.

## Data and Code Availability

The circuit instances, candidate contraction plans, measured execution times, feature\-extraction scripts, and analysis code supporting this study will be made available in a public repository upon publication\.

## Acknowledgments

This work was supported by the research project PID2023\-146569NB\-C22 funded by MCIN/AEI/10\.13039/501100011033 and “ERDF A way of making Europe”\.

## References

- \[1\]J\. Bausch, A\. W\. Senior, F\. J\. H\. Heras, T\. Edlich, A\. Davies, M\. Newman, C\. Jones, K\. Satzinger, M\. Y\. Niu, S\. Blackwell, G\. Holland, D\. Kafri, J\. Atalaya, C\. Gidney, D\. Hassabis, S\. Boixo, H\. Neven, and P\. Kohli\(2024\)Learning high\-accuracy error decoding for quantum processors\.Nature635\(8040\),pp\. 834–840\.External Links:[Document](https://dx.doi.org/10.1038/s41586-024-08148-8)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p1.1)\.
- \[2\]\(2025\)Tensor networks for quantum computing\.Nature Reviews Physics7,pp\. 581–593\.External Links:[Document](https://dx.doi.org/10.1038/s42254-025-00853-1)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1)\.
- \[3\]J\. R\. S\. Blair and B\. W\. Peyton\(1993\)An introduction to chordal graphs and clique trees\.InGraph Theory and Sparse Matrix Computation,A\. George, J\. R\. Gilbert, and J\. W\. H\. Liu \(Eds\.\),The IMA Volumes in Mathematics and its Applications, Vol\.56,pp\. 1–29\.External Links:[Document](https://dx.doi.org/10.1007/978-1-4613-8369-7%5F1)Cited by:[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p3.1)\.
- \[4\]J\. Brennan, L\. O’Riordan, K\. Hanley, M\. Doyle, M\. Allalen, D\. Brayford, L\. Iapichino, and N\. Moran\(2022\)QXTools: a Julia framework for distributed quantum circuit simulation\.Journal of Open Source Software7\(70\),pp\. 3711\.External Links:[Document](https://dx.doi.org/10.21105/joss.03711)Cited by:[§5\.5](https://arxiv.org/html/2608.05819#S5.SS5.p4.1)\.
- \[5\]H\. J\. Broersma, E\. Dahlhaus, and T\. Kloks\(2000\)A linear time algorithm for minimum fill\-in and treewidth for distance hereditary graphs\.Discrete Applied Mathematics99\(1\-3\),pp\. 367–400\.External Links:[Document](https://dx.doi.org/10.1016/S0166-218X%2899%2900146-8),ISSN 0166\-218XCited by:[§1](https://arxiv.org/html/2608.05819#S1.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p3.1)\.
- \[6\]S\. Bruch, C\. Lucchese, and F\. M\. Nardini\(2023\)Efficient and effective tree\-based and neural learning to rank\.Foundations and Trends in Information Retrieval17\(1\),pp\. 1–131\.External Links:[Document](https://dx.doi.org/10.1561/1500000071)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p3.1)\.
- \[7\]C\. Burges, T\. Shaked, E\. Renshaw, A\. Lazier, M\. Deeds, N\. Hamilton, and G\. Hullender\(2005\)Learning to rank using gradient descent\.InProceedings of the 22nd International Conference on Machine Learning \(ICML\),New York, NY, USA,pp\. 89–96\.External Links:[Document](https://dx.doi.org/10.1145/1102351.1102363)Cited by:[§3\.4\.2](https://arxiv.org/html/2608.05819#S3.SS4.SSS2.p2.1),[Table 1](https://arxiv.org/html/2608.05819#S3.T1.1.3.1.3.1.1)\.
- \[8\]C\. J\. C\. Burges\(2010\)From RankNet to LambdaRank to LambdaMART: an overview\.Technical reportTechnical ReportMSR\-TR\-2010\-82,Microsoft Research\.Cited by:[§3\.4\.2](https://arxiv.org/html/2608.05819#S3.SS4.SSS2.p2.1),[Table 1](https://arxiv.org/html/2608.05819#S3.T1.1.3.1.3.1.1)\.
- \[9\]T\. Chen and C\. Guestrin\(2016\)XGBoost: a scalable tree boosting system\.InProceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining \(KDD\),New York, NY, USA,pp\. 785–794\.External Links:[Document](https://dx.doi.org/10.1145/2939672.2939785)Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p8.1),[§3\.4\.2](https://arxiv.org/html/2608.05819#S3.SS4.SSS2.p1.1),[§5\.3](https://arxiv.org/html/2608.05819#S5.SS3.p1.1),[§5\.3](https://arxiv.org/html/2608.05819#S5.SS3.p2.1),[§5\.5](https://arxiv.org/html/2608.05819#S5.SS5.p4.1)\.
- \[10\]N\. Corporation\(2024\)cuQuantum tensor network contraction documentation\.Note:Accessed 2026\-03\-31External Links:[Link](https://docs.nvidia.com/cuda/cuquantum/24.11/python/tensornet-contraction.html)Cited by:[§A\.11](https://arxiv.org/html/2608.05819#A1.SS11.p1.2),[§1](https://arxiv.org/html/2608.05819#S1.p3.1),[§3\.2](https://arxiv.org/html/2608.05819#S3.SS2.p2.1)\.
- \[11\]N\. Corporation\(2025\)cuTENSOR user guide\.Note:Accessed 2026\-03\-31External Links:[Link](https://docs.nvidia.com/cuda/cutensor/latest/user_guide.html)Cited by:[§A\.10](https://arxiv.org/html/2608.05819#A1.SS10.p2.4),[§A\.11](https://arxiv.org/html/2608.05819#A1.SS11.p1.2),[§A\.2](https://arxiv.org/html/2608.05819#A1.SS2.p2.1),[§A\.3](https://arxiv.org/html/2608.05819#A1.SS3.p5.4),[§A\.3](https://arxiv.org/html/2608.05819#A1.SS3.p6.2),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p3.3),[§1](https://arxiv.org/html/2608.05819#S1.p3.1)\.
- \[12\]H\. Dell, C\. Komusiewicz, N\. Talmon, and M\. Weller\(2018\)The PACE 2017 Parameterized Algorithms and Computational Experiments Challenge: The Second Iteration\.In12th International Symposium on Parameterized and Exact Computation \(IPEC 2017\),D\. Lokshtanov and N\. Nishimura \(Eds\.\),Leibniz International Proceedings in Informatics \(LIPIcs\), Vol\.89,Dagstuhl, Germany,pp\. 30:1–30:12\.External Links:[Document](https://dx.doi.org/10.4230/LIPIcs.IPEC.2017.30),ISBN 978\-3\-95977\-051\-4,ISSN 1868\-8969Cited by:[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p5.1)\.
- \[13\]E\. F\. Dumitrescu, A\. L\. Fisher, T\. D\. Goodrich, T\. S\. Humble, B\. D\. Sullivan, and A\. L\. Wright\(2018\)Benchmarking treewidth as a practical component of tensor network simulations\.PLOS ONE13\(12\),pp\. e0207827\.External Links:[Document](https://dx.doi.org/10.1371/journal.pone.0207827)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[Appendix A](https://arxiv.org/html/2608.05819#A1.p1.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p3.1)\.
- \[14\]A\. Gaydhani, G\. Xu, D\. Kamath, A\. Singh, and A\. Li\(2026\)Unified learning\-to\-rank for multi\-channel retrieval in large\-scale e\-commerce search\.arXiv preprint arXiv:2602\.23530\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.2602.23530),2602\.23530Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p3.1)\.
- \[15\]M\. Girvan and M\. E\. J\. Newman\(2002\)Community structure in social and biological networks\.Proceedings of the National Academy of Sciences99\(12\),pp\. 7821–7826\.External Links:[Document](https://dx.doi.org/10.1073/pnas.122653799),ISSN 0027\-8424Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p4.1),[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p5.1)\.
- \[16\]K\. Goyal, S\. Dumančić, and H\. Blockeel\(2020\)Feature interactions in XGBoost\.arXiv preprint arXiv:2007\.05758\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.2007.05758),2007\.05758Cited by:[§5\.3](https://arxiv.org/html/2608.05819#S5.SS3.p6.1)\.
- \[17\]J\. Gray and S\. Kourtis\(2021\)Hyper\-optimized tensor network contraction\.Quantum5,pp\. 410\.External Links:[Document](https://dx.doi.org/10.22331/q-2021-03-15-410)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.4](https://arxiv.org/html/2608.05819#A1.SS4.p1.2),[Appendix A](https://arxiv.org/html/2608.05819#A1.p1.1),[§1](https://arxiv.org/html/2608.05819#S1.p1.1),[§1](https://arxiv.org/html/2608.05819#S1.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p1.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p5.1),[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p3.1)\.
- \[18\]S\. Gupta, P\. Hager, J\. Huang, A\. Vardasbi, and H\. Oosterhuis\(2023\)Recent advances in the foundations and applications of unbiased learning to rank\.InProceedings of the 46th International ACM SIGIR Conference on Research and Development in Information Retrieval,pp\. 3440–3443\.External Links:[Document](https://dx.doi.org/10.1145/3539618.3594247),2305\.02914Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p3.1)\.
- \[19\]M\. Hamann and B\. Strasser\(2018\-02\)Graph bisection with pareto optimization\.ACM Journal of Experimental Algorithmics23\(1\),pp\. 1–34\.Note:Article 1\.2External Links:[Document](https://dx.doi.org/10.1145/3173045),ISSN 1084\-6654Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p4.1)\.
- \[20\]G\. S\. Hartnett, A\. Barbosa, P\. S\. Mundada, M\. Hush, M\. J\. Biercuk, and Y\. Baum\(2024\)Learning to rank quantum circuits for hardware\-optimized performance enhancement\.Quantum8,pp\. 1542\.External Links:[Document](https://dx.doi.org/10.22331/q-2024-11-27-1542),2404\.06535Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p5.1),[§2](https://arxiv.org/html/2608.05819#S2.p4.1)\.
- \[21\]P\. Heggernes\(2006\)Minimal triangulations of graphs: a survey\.Discrete Mathematics306\(3\),pp\. 297–317\.External Links:[Document](https://dx.doi.org/10.1016/j.disc.2005.12.003)Cited by:[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p3.1)\.
- \[22\]C\. Huang, F\. Zhang, M\. Newman, X\. Ni, D\. Ding, J\. Cai, X\. Gao, T\. Wang, F\. Wu, G\. Zhang, H\. Ku, Z\. Tian, J\. Wu, H\. Xu, H\. Yu, B\. Yuan, M\. Szegedy, Y\. Shi, H\. Zhao, C\. Deng, and J\. Chen\(2021\)Efficient parallelization of tensor network contraction for simulating quantum computation\.Nature Computational Science1\(9\),pp\. 578–587\.External Links:[Document](https://dx.doi.org/10.1038/s43588-021-00119-7)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p1.1)\.
- \[23\]Md\. A\. Kabir, M\. Al Hasan, A\. Mandal, D\. Tunkelang, and Z\. Wu\(2024\)A survey on e\-commerce learning to rank\.arXiv preprint arXiv:2412\.03581\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.2412.03581),2412\.03581Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p3.1)\.
- \[24\]M\. S\. Kazemi, Z\. Bakhshinezhad, and A\. T\. Rezakhani\(2020\)Support vector machines for quantum state tomography\.Physical Review A101\(4\),pp\. 042307\.External Links:[Document](https://dx.doi.org/10.1103/PhysRevA.101.042307)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p2.1)\.
- \[25\]M\. G\. Kendall and J\. D\. Gibbons\(1990\)Rank correlation methods\.5th edition,Oxford University Press,New York\.External Links:ISBN 978\-0\-19\-520837\-5,[Link](https://search.worldcat.org/title/21195423)Cited by:[§7\.1](https://arxiv.org/html/2608.05819#S7.SS1.p2.2)\.
- \[26\]J\. Lee, G\. Bernier\-Colborne, T\. Maharaj, and S\. Vajjala\(2024\-06\)Methods, applications, and directions of learning\-to\-rank in NLP research\.InFindings of the Association for Computational Linguistics: NAACL 2024,K\. Duh, H\. Gomez, and S\. Bethard \(Eds\.\),Mexico City, Mexico,pp\. 1900–1917\.External Links:[Document](https://dx.doi.org/10.18653/v1/2024.findings-naacl.123)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p3.1)\.
- \[27\]T\. Li, Z\. Zhao, and J\. Yin\(2025\)Empowering quantum serverless circuit deployment optimization via graph contrastive learning and learning\-to\-rank co\-designed approaches\.InProceedings of the Thirty\-Fourth International Joint Conference on Artificial Intelligence \(IJCAI\),pp\. 9250–9258\.External Links:[Document](https://dx.doi.org/10.24963/ijcai.2025/1028)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p4.1)\.
- \[28\]T\. Liu\(2009\)Learning to rank for information retrieval\.Foundations and Trends in Information Retrieval, Vol\.3,Now Publishers\.External Links:[Document](https://dx.doi.org/10.1561/1500000016)Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p5.1),[§2](https://arxiv.org/html/2608.05819#S2.p3.1),[§3\.4\.1](https://arxiv.org/html/2608.05819#S3.SS4.SSS1.p1.1)\.
- \[29\]V\. Lopez\-Oliva, J\. M\. Badia, and M\. Castillo\(2025\)Efficient quantum circuit contraction using tensor decision diagrams\.The Journal of Supercomputing81\(1\),pp\. 354\.External Links:[Document](https://dx.doi.org/10.1007/s11227-024-06836-w)Cited by:[§3\.1](https://arxiv.org/html/2608.05819#S3.SS1.p1.1)\.
- \[30\]S\. M\. Lundberg and S\. Lee\(2017\)A unified approach to interpreting model predictions\.InAdvances in Neural Information Processing Systems 30,I\. Guyon, U\. V\. Luxburg, S\. Bengio, H\. Wallach, R\. Fergus, S\. Vishwanathan, and R\. Garnett \(Eds\.\),pp\. 4765–4774\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.1705.07874)Cited by:[§5\.3](https://arxiv.org/html/2608.05819#S5.SS3.p6.1)\.
- \[31\]I\. L\. Markov and Y\. Shi\(2008\-01\)Simulating quantum computation by contracting tensor networks\.SIAM Journal on Computing38\(3\),pp\. 963–981\.External Links:[Document](https://dx.doi.org/10.1137/050644756)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[Appendix A](https://arxiv.org/html/2608.05819#A1.p1.1),[§1](https://arxiv.org/html/2608.05819#S1.p1.1),[§3\.1](https://arxiv.org/html/2608.05819#S3.SS1.p2.1),[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p3.1)\.
- \[32\]D\. A\. Matthews\(2018\)High\-performance tensor contraction without transposition\.SIAM Journal on Scientific Computing40\(1\),pp\. C1–C24\.External Links:[Document](https://dx.doi.org/10.1137/16m108968x)Cited by:[§A\.10](https://arxiv.org/html/2608.05819#A1.SS10.p2.4),[§A\.2](https://arxiv.org/html/2608.05819#A1.SS2.p2.1),[§A\.3](https://arxiv.org/html/2608.05819#A1.SS3.p6.2),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p3.3),[§3\.2](https://arxiv.org/html/2608.05819#S3.SS2.p1.1)\.
- \[33\]R\. Mitchell, E\. Frank, and G\. Holmes\(2018\)Accelerating the XGBoost algorithm using GPU computing\.PeerJ Computer Science3,pp\. e127\.External Links:[Document](https://dx.doi.org/10.7717/peerj-cs.127)Cited by:[4th item](https://arxiv.org/html/2608.05819#S5.I1.i4.p1.1)\.
- \[34\]A\. C\. Müller and S\. Guido\(2016\)Introduction to machine learning with python: a guide for data scientists\.1st edition,O’Reilly Media,Sebastopol, CA, USA\.External Links:ISBN 978\-1\-449\-36941\-5,[Link](https://www.oreilly.com/library/view/introduction-to-machine/9781449369880/)Cited by:[§5\.3](https://arxiv.org/html/2608.05819#S5.SS3.p2.1)\.
- \[35\]M\. E\. J\. Newman and M\. Girvan\(2004\)Finding and evaluating community structure in networks\.Physical Review E69\(2\),pp\. 026113\.External Links:[Document](https://dx.doi.org/10.1103/PhysRevE.69.026113),ISSN 1539\-3755Cited by:[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p4.1)\.
- \[36\]B\. O’Gorman\(2019\)Parameterization of tensor network contraction\.In14th Conference on the Theory of Quantum Computation, Communication and Cryptography \(TQC 2019\),Leibniz International Proceedings in Informatics \(LIPIcs\), Vol\.135,pp\. 10:1–10:19\.External Links:[Document](https://dx.doi.org/10.4230/lipics.tqc.2019.10)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.4](https://arxiv.org/html/2608.05819#A1.SS4.p1.2),[Appendix A](https://arxiv.org/html/2608.05819#A1.p1.1),[§3\.1](https://arxiv.org/html/2608.05819#S3.SS1.p2.1),[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p2.1)\.
- \[37\]R\. Orús\(2014\)A practical introduction to tensor networks: matrix product states and projected entangled pair states\.Annals of Physics349,pp\. 117–158\.External Links:[Document](https://dx.doi.org/10.1016/j.aop.2014.06.013)Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p1.1),[§3\.1](https://arxiv.org/html/2608.05819#S3.SS1.p1.1)\.
- \[38\]F\. Pan, H\. Gu, L\. Kuang, B\. Liu, and P\. Zhang\(2024\)Efficient quantum circuit simulation by tensor network methods on modern GPUs\.ACM Transactions on Quantum Computing5\(4\),pp\. 26:1–26:25\.External Links:[Document](https://dx.doi.org/10.1145/3696465)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.3](https://arxiv.org/html/2608.05819#A1.SS3.p5.4),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p1.1)\.
- \[39\]A\. M\. Pastor, J\. M\. Badia, and M\. Castillo\(2025\)A community detection\-based parallel algorithm for quantum circuit simulation using tensor networks\.The Journal of Supercomputing81,pp\. 450\.External Links:[Document](https://dx.doi.org/10.1007/s11227-025-06918-3)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p1.1)\.
- \[40\]A\. M\. Pastor, M\. Castillo, and J\. M\. Badia\(2025\)Parallel tensor network contraction for efficient quantum circuit simulation on multicore CPUs and GPUs\.InProceedings of the 1st International Conference on Quantum Software \(IQSOFT 2025\),pp\. 120–127\.External Links:[Document](https://dx.doi.org/10.5220/0013551400004525)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p1.1)\.
- \[41\]R\. N\. C\. Pfeifer, J\. Haegeman, and F\. Verstraete\(2014\)Faster identification of optimal contraction sequences for tensor networks\.Physical Review E90\(3\),pp\. 033315\.External Links:[Document](https://dx.doi.org/10.1103/PhysRevE.90.033315)Cited by:[§1](https://arxiv.org/html/2608.05819#S1.p2.1)\.
- \[42\]QuantumKitHub\(2025\)TensorOperations\.jl documentation\.Note:Documentation generated on 2025\-07\-29; accessed 2026\-03\-31External Links:[Link](https://quantumkithub.github.io/TensorOperations.jl/stable/)Cited by:[§A\.2](https://arxiv.org/html/2608.05819#A1.SS2.p2.1)\.
- \[43\]N\. Quetschlich, L\. Burgholzer, and R\. Wille\(2023\-07\)MQT Bench: benchmarking software and design automation tools for quantum computing\.Quantum7,pp\. 1062\.External Links:[Document](https://dx.doi.org/10.22331/q-2023-07-20-1062),ISSN 2521\-327XCited by:[§5\.1](https://arxiv.org/html/2608.05819#S5.SS1.p4.1)\.
- \[44\]N\. Quetschlich, L\. Burgholzer, and R\. Wille\(2023\)Predicting good quantum circuit compilation options\.InProceedings of the 2023 IEEE International Conference on Quantum Software \(QSW\),pp\. 43–53\.External Links:[Document](https://dx.doi.org/10.1109/QSW59989.2023.00015),2210\.08027Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p2.1)\.
- \[45\]M\. Schuld and F\. Petruccione\(2021\)Machine learning with quantum computers\.1st edition,Quantum Science and Technology, Vol\.676,Springer,Cham, Switzerland\.External Links:[Document](https://dx.doi.org/10.1007/978-3-030-83098-4),ISBN 978\-3\-030\-83098\-4Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p1.1)\.
- \[46\]P\. Springer and P\. Bientinesi\(2018\)Design of a high\-performance GEMM\-like tensor\-tensor multiplication\.ACM Transactions on Mathematical Software44\(3\),pp\. 1–29\.External Links:[Document](https://dx.doi.org/10.1145/3157733)Cited by:[§A\.10](https://arxiv.org/html/2608.05819#A1.SS10.p2.4),[§A\.2](https://arxiv.org/html/2608.05819#A1.SS2.p2.1),[§A\.3](https://arxiv.org/html/2608.05819#A1.SS3.p6.2),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p3.3),[§3\.2](https://arxiv.org/html/2608.05819#S3.SS2.p1.1)\.
- \[47\]B\. Strasser\(2017\)Computing tree decompositions with FlowCutter: PACE 2017 submission\.arXiv preprint arXiv:1709\.08949\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.1709.08949),1709\.08949Cited by:[§3\.3](https://arxiv.org/html/2608.05819#S3.SS3.p4.1)\.
- \[48\]G\. Torlai, G\. Mazzola, J\. Carrasquilla, M\. Troyer, R\. Melko, and G\. Carleo\(2018\)Neural\-network quantum state tomography\.Nature Physics14\(5\),pp\. 447–450\.External Links:[Document](https://dx.doi.org/10.1038/s41567-018-0048-5)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p2.1)\.
- \[49\]G\. Verdon, M\. Broughton, and J\. Biamonte\(2019\-07\)Learning to learn with quantum neural networks via classical neural networks\.arXiv preprintarXiv:1907\.05415\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.1907.05415),1907\.05415Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p2.1)\.
- \[50\]B\. Villalonga, S\. Boixo, B\. Nelson, C\. Henze, E\. Rieffel, R\. Biswas, and S\. Mandrà\(2019\)A flexible high\-performance simulator for verifying and benchmarking quantum circuits implemented on real hardware\.npj Quantum Information5\(1\),pp\. 86\.External Links:[Document](https://dx.doi.org/10.1038/s41534-019-0196-1)Cited by:[§3\.2](https://arxiv.org/html/2608.05819#S3.SS2.p2.1)\.
- \[51\]T\. Vincent, L\. J\. O’Riordan, M\. Andrenkov, J\. Brown, N\. Killoran, H\. Qi, and I\. Dhand\(2022\)Jet: fast quantum circuit simulations with parallel task\-based tensor\-network contraction\.Quantum6,pp\. 709\.External Links:[Document](https://dx.doi.org/10.22331/q-2022-05-09-709)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p1.1),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p1.1)\.
- \[52\]Y\. Wang, L\. Zhang, Q\. Wang, and Z\. Liu\(2019\)Support vector machine classification of topological phase transitions\.Physical Review B99\(11\),pp\. 115105\.External Links:[Document](https://dx.doi.org/10.1103/PhysRevB.99.115105)Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p2.1)\.
- \[53\]S\. Williams, A\. Waterman, and D\. Patterson\(2009\)Roofline: an insightful visual performance model for multicore architectures\.Communications of the ACM52\(4\),pp\. 65–76\.External Links:[Document](https://dx.doi.org/10.1145/1498765.1498785)Cited by:[§A\.1](https://arxiv.org/html/2608.05819#A1.SS1.p2.1),[§A\.3](https://arxiv.org/html/2608.05819#A1.SS3.p5.4),[§A\.7](https://arxiv.org/html/2608.05819#A1.SS7.p1.1)\.
- \[54\]XGBoost\.jl Contributors\(2026\)XGBoost\.jl: julia interface to XGBoost\.Note:[https://github\.com/dmlc/XGBoost\.jl/releases/tag/v2\.5\.3](https://github.com/dmlc/XGBoost.jl/releases/tag/v2.5.3)Version 2\.5\.3, accessed 5 August 2026Cited by:[§5\.5](https://arxiv.org/html/2608.05819#S5.SS5.p4.1)\.
- \[55\]K\. Zaman, A\. Marchisio, M\. A\. Hanif, and M\. Shafique\(2023\)A survey on quantum machine learning: current trends, challenges, opportunities, and the road ahead\.arXiv preprint arXiv:2310\.10315\.External Links:[Document](https://dx.doi.org/10.48550/arXiv.2310.10315),2310\.10315Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p1.1)\.
- \[56\]J\. Zilles, G\. Lucca, and E\. N\. Borges\(2022\)A literature review on methods for learning to rank\.InProceedings of the 24th International Conference on Enterprise Information Systems, Volume 1 \(ICEIS\),pp\. 545–552\.External Links:[Document](https://dx.doi.org/10.5220/0011065600003179),ISBN 978\-989\-758\-569\-2,ISSN 2184\-4992Cited by:[§2](https://arxiv.org/html/2608.05819#S2.p3.1)\.

## Appendix ADetailed cost model and feature\-block definitions

This appendix provides the technical detail underlying the feature design summarized in Section[4](https://arxiv.org/html/2608.05819#S4)\. The aim is not to reproduce the internal cost model of a specific tensor\-contraction library, but to define portable structural predictors that can be computed directly from a contraction plan before execution and that remain informative for GPU runtime\. The starting point is the well\-known observation that contraction cost is highly sensitive to path structure and that width\-based reasoning, i\.e\., reasoning based on contraction width and related bottleneck\-size proxies, while essential, is not sufficient to explain measured performance on current CPU/GPU tensor\-network simulators\[[31](https://arxiv.org/html/2608.05819#bib.bib33),[36](https://arxiv.org/html/2608.05819#bib.bib38),[13](https://arxiv.org/html/2608.05819#bib.bib15),[17](https://arxiv.org/html/2608.05819#bib.bib19)\]\.

### A\.1Why width alone is not sufficient

Width\-based theory explains why contraction order matters: simulation complexity is tightly linked to graph structure and, in particular, to treewidth\-related notions of difficulty\[[31](https://arxiv.org/html/2608.05819#bib.bib33),[36](https://arxiv.org/html/2608.05819#bib.bib38),[13](https://arxiv.org/html/2608.05819#bib.bib15)\]\. In the quantum\-circuit setting, this connection is also borne out empirically: treewidth\-oriented path search is often a strong practical proxy for contraction difficulty, although its effectiveness depends on the network family and on the optimization budget\[[17](https://arxiv.org/html/2608.05819#bib.bib19),[13](https://arxiv.org/html/2608.05819#bib.bib15)\]\. However, for feature engineering, width alone is not enough\. Two plans with comparable leading width can still differ substantially in total work, local intermediate sizes, contraction\-shape regularity, and parallel efficiency\. This is especially important in current tensor\-network simulators, where efficient execution relies on parallel tensor contractions on multicore CPUs and, increasingly, on GPUs\[[22](https://arxiv.org/html/2608.05819#bib.bib24),[51](https://arxiv.org/html/2608.05819#bib.bib52),[38](https://arxiv.org/html/2608.05819#bib.bib40),[40](https://arxiv.org/html/2608.05819#bib.bib42),[39](https://arxiv.org/html/2608.05819#bib.bib41),[2](https://arxiv.org/html/2608.05819#bib.bib3)\]\.

From the point of view of execution, the dominant factors are not only the computational burden of the bottleneck step, but also the amount of output\-side parallelism, the reduction structure that governs reuse and arithmetic intensity, the geometry of the equivalent dense kernel, and the overhead induced by fragmented plans\. This is consistent with Roofline\-style reasoning, which makes explicit that achievable performance depends on the balance between arithmetic throughput and bandwidth\-limited throughput rather than on FLOPs alone\[[53](https://arxiv.org/html/2608.05819#bib.bib54)\]\. Consequently, the cost model used to build the feature space must be actionable: it must be computable directly from the contraction plan before execution, yet expressive enough to reflect the structural properties that determine actual runtime on the target hardware\.

### A\.2Local contraction model

Consider again theii\-th binary contraction step

Oi=contractSi​\(Ai,Bi\),O\_\{i\}=\\mathrm\{contract\}\_\{S\_\{i\}\}\(A\_\{i\},B\_\{i\}\),whereSiS\_\{i\}is the set of shared indices eliminated in the contraction\. For binary tensor networks,

ki\\displaystyle k\_\{i\}=\|Si\|,\\displaystyle=\|S\_\{i\}\|,mi\\displaystyle m\_\{i\}=rank​\(Ai\)−ki,\\displaystyle=\\mathrm\{rank\}\(A\_\{i\}\)\-k\_\{i\},ni\\displaystyle n\_\{i\}=rank​\(Bi\)−ki,\\displaystyle=\\mathrm\{rank\}\(B\_\{i\}\)\-k\_\{i\},so thatmim\_\{i\}andnin\_\{i\}count the free indices inherited fromAiA\_\{i\}andBiB\_\{i\}, respectively, and

rank​\(Oi\)=mi\+ni\.\\mathrm\{rank\}\(O\_\{i\}\)=m\_\{i\}\+n\_\{i\}\.
After a suitable permutation of modes, every pairwise contraction can be expressed in the GEMM\-like form introduced in Eq\. \([5](https://arxiv.org/html/2608.05819#S4.E5)\)\. This abstraction is not merely pedagogical: it is exactly the type of decomposition exploited by modern tensor\-contraction libraries, whether through explicit transpose–GEMM strategies, fused packing\-and\-contraction schemes, or native tensor kernels\[[46](https://arxiv.org/html/2608.05819#bib.bib47),[32](https://arxiv.org/html/2608.05819#bib.bib34),[11](https://arxiv.org/html/2608.05819#bib.bib14),[42](https://arxiv.org/html/2608.05819#bib.bib44)\]\. It therefore provides a natural basis for feature design\.

### A\.3Step\-level primitives and their interpretation

At step level, we work with four primitives:

ci\\displaystyle c\_\{i\}=mi\+ni\+ki,\\displaystyle=m\_\{i\}\+n\_\{i\}\+k\_\{i\},pi\\displaystyle p\_\{i\}=mi\+ni,\\displaystyle=m\_\{i\}\+n\_\{i\},ki\\displaystyle k\_\{i\}=\|Si\|,\\displaystyle=\|S\_\{i\}\|,di\\displaystyle d\_\{i\}=\|mi−ni\|mi\+ni\+ε,ε≪1\.\\displaystyle=\\frac\{\|m\_\{i\}\-n\_\{i\}\|\}\{m\_\{i\}\+n\_\{i\}\+\\varepsilon\},\\qquad\\varepsilon\\ll 1\.
These four quantities form the irreducible basis of the feature space\.

The first quantity,cic\_\{i\}, is the work exponent\. For binary networks, the equivalent FLOP count satisfies

FLOPsi=Θ​\(2​M​N​K\)=Θ​\(21\+ci\),\\mathrm\{FLOPs\}\_\{i\}=\\Theta\(2MNK\)=\\Theta\(2^\{1\+c\_\{i\}\}\),\(18\)socic\_\{i\}is the natural logarithmic proxy for local computational effort\. It is the closest step\-level quantity to the classical complexity surrogates traditionally used in contraction\-path search\. If one only wanted a combinatorial estimate of difficulty,cic\_\{i\}would be the natural first candidate\.

The second quantity,pip\_\{i\}, is the output\-size exponent\. Since\|Oi\|=2pi\|O\_\{i\}\|=2^\{p\_\{i\}\}, it has a dual interpretation\. In the sequential regime it is a proxy for the immediate intermediate tensor size and hence for memory pressure, temporary workspace demand, and downstream data movement\. In the parallel regime, because the output containsM​N=2piMN=2^\{p\_\{i\}\}elements, it also acts as a proxy for exploitable data parallelism\. This is why it is preferable to exposepip\_\{i\}explicitly rather than absorb it into a more opaque memory surrogate\.

The third quantity,kik\_\{i\}, is the reduction exponent\. Although it appears insidecic\_\{i\}, it captures a different structural aspect of the contraction\. Two steps with the samecic\_\{i\}can have very different balances between output formation and inner reduction, and therefore very different reuse profiles\. In Roofline terms,kik\_\{i\}influences whether the step is more likely to be compute\-bound or memory\-bound\[[53](https://arxiv.org/html/2608.05819#bib.bib54)\]\. This is also consistent with practice in GPU tensor contraction, where higher useful reuse and Tensor\-Core\-friendly structure are repeatedly identified as central to performance\[[38](https://arxiv.org/html/2608.05819#bib.bib40),[11](https://arxiv.org/html/2608.05819#bib.bib14)\]\.

The fourth quantity,did\_\{i\}, is a geometry descriptor\. Values near zero correspond to roughly square contractions, whereas values near one indicate tall\-and\-skinny or short\-and\-wide cases\. This distinction matters because optimized dense kernels are not shape\-invariant: highly imbalanced contractions are more likely to suffer from poorer locality, weaker packing efficiency, less favorable stride structure, and lower sustained throughput\[[46](https://arxiv.org/html/2608.05819#bib.bib47),[32](https://arxiv.org/html/2608.05819#bib.bib34),[11](https://arxiv.org/html/2608.05819#bib.bib14)\]\. Thus,did\_\{i\}acts as a compact surrogate for contraction geometry and mapping quality\.

A minimal backend\-agnostic proxy for data movement also follows from the GEMM\-like form:

Bytesimin=Θ​\(M​K\+K​N\+M​N\)\.\\mathrm\{Bytes\}^\{\\min\}\_\{i\}=\\Theta\(MK\+KN\+MN\)\.This expression clarifies why separatingpip\_\{i\}andkik\_\{i\}is meaningful: steps with similar FLOP counts can still differ substantially in output size, reduction depth, and therefore in the balance between computation and memory traffic\.

### A\.4Plan\-level aggregation

A contraction planπ\\piwithSSpairwise contractions is a variable\-length sequence of local descriptors\. To use it in a tabular learning model, we map it to a fixed\-size vector through aggregations that preserve the physically relevant structure of the plan\. Simple averages are rarely sufficient\. In practical tensor\-network contractions, total runtime is often dominated by one or a few expensive steps, while the long tail of small steps contributes mainly through overhead, intermediate materialization, or cache\- and kernel\-unfriendly fragmentation\[[17](https://arxiv.org/html/2608.05819#bib.bib19),[36](https://arxiv.org/html/2608.05819#bib.bib38)\]\.

We therefore define the bottleneck exponent

cmax\\displaystyle c\_\{\\max\}=maxi⁡ci,\\displaystyle=\\max\_\{i\}c\_\{i\},Imax\\displaystyle I\_\{\\max\}=\{i:ci=cmax\},\\displaystyle=\\\{i:\\,c\_\{i\}=c\_\{\\max\}\\\},\(19\)and FLOP\-proportional weights

wi=2ci−cmax∑ℓ=1S2cℓ−cmax\.w\_\{i\}=\\frac\{2^\{c\_\{i\}\-c\_\{\\max\}\}\}\{\\sum\_\{\\ell=1\}^\{S\}2^\{c\_\{\\ell\}\-c\_\{\\max\}\}\}\.The subtraction ofcmaxc\_\{\\max\}is only for numerical stability; it does not change the weighting\.

The resulting features are grouped into blocks that capture distinct hypotheses about what limits runtime\. These blocks are not arbitrary\. They are designed to represent the dominant work region, the distribution of costs beyond the single bottleneck, and structural overhead effects that asymptotic complexity tends to ignore\.

### A\.5Complexity and critical\-load block

The first aggregation block captures the overall computational burden of the plan together with the structure of its bottleneck region\. It includes

max​\_​cost​\(π\)\\displaystyle\\mathrm\{max\\\_cost\}\(\\pi\)=cmax,\\displaystyle=c\_\{\\max\},\(20\)log2​\_​sum​\_​flops​\(π\)\\displaystyle\\mathrm\{log2\\\_sum\\\_flops\}\(\\pi\)=log2⁡\(∑i=1S2ci\),\\displaystyle=\\log\_\{2\}\\\!\\left\(\\sum\_\{i=1\}^\{S\}2^\{c\_\{i\}\}\\right\),\(21\)topq​\_​mean​\_​cost​\(π\)\\displaystyle\\mathrm\{topq\\\_mean\\\_cost\}\(\\pi\)=1\|Iq\|​∑i∈Iqci,\\displaystyle=\\frac\{1\}\{\|I\_\{q\}\|\}\\sum\_\{i\\in I\_\{q\}\}c\_\{i\},\(22\)whereIqI\_\{q\}denotes the set of indices corresponding to the⌈q​S⌉\\lceil qS\\rceillargest values ofcic\_\{i\}, together with

avg​\_​cost​\(π\)\\displaystyle\\mathrm\{avg\\\_cost\}\(\\pi\)=1S​∑i=1Sci,\\displaystyle=\\frac\{1\}\{S\}\\sum\_\{i=1\}^\{S\}c\_\{i\},\(23\)std​\_​cost​\(π\)\\displaystyle\\mathrm\{std\\\_cost\}\(\\pi\)=std​\(ci\)\.\\displaystyle=\\mathrm\{std\}\(c\_\{i\}\)\.\(24\)
These descriptors are correlated but not redundant\.max​\_​cost\\mathrm\{max\\\_cost\}is the direct descendant of width\-based reasoning and tracks the dominant contraction\.log2​\_​sum​\_​flops\\mathrm\{log2\\\_sum\\\_flops\}moves beyond the leading term and measures total accumulated work\.topq​\_​mean​\_​cost\\mathrm\{topq\\\_mean\\\_cost\}captures whether the plan is dominated by one isolated critical step or by a broader near\-critical tail\. This distinction is important in practice because a plan with many almost\-maximal steps can behave quite differently from a plan with one sharp peak and a cheap remainder\. Finally,avg​\_​cost\\mathrm\{avg\\\_cost\}andstd​\_​cost\\mathrm\{std\\\_cost\}summarize the global level and heterogeneity of the cost profile: a high standard deviation indicates a very uneven plan, whereas a lower value indicates a more homogeneous contraction sequence\.

### A\.6Sequence and granularity block

The second block captures structural fragmentation:

n​\_​steps​\(π\)\\displaystyle\\mathrm\{n\\\_steps\}\(\\pi\)=S,\\displaystyle=S,\(25\)frac​\_​tiny​\_​steps​\(π\)\\displaystyle\\mathrm\{frac\\\_tiny\\\_steps\}\(\\pi\)=1S​∑i=1S𝟏​\{ci≤cmax−τ\},\\displaystyle=\\frac\{1\}\{S\}\\sum\_\{i=1\}^\{S\}\\mathbf\{1\}\\\{c\_\{i\}\\leq c\_\{\\max\}\-\\tau\\\},\(26\)whereτ\\tauis a fixed threshold, e\.g\.τ=6\\tau=6, so that a “tiny” step is at least26=642^\{6\}=64times smaller in FLOP scale than the bottleneck\.

These variables matter because asymptotic work models ignore granularity\. A plan can have a reasonable bottleneck and moderate total work, yet still perform poorly if it decomposes the contraction into too many very small operations\. Such a plan tends to amplify loop and scheduling overhead, increase the number of intermediate tensors that must be created and consumed, and reduce the opportunity for sustained high\-efficiency execution\. In this sense,n​\_​steps\\mathrm\{n\\\_steps\}measures structural fragmentation, whilefrac​\_​tiny​\_​steps\\mathrm\{frac\\\_tiny\\\_steps\}identifies whether that fragmentation is concentrated in an extended tail of low\-value operations\.

### A\.7GPU\-oriented refinement

At this point, the sequential feature space already captures the main classical determinants of cost: bottleneck difficulty, total work, workload dispersion, and plan granularity\. However, selecting a good plan for GPUs requires a more refined view of how each step maps to parallel hardware\. Modern tensor\-network simulators increasingly rely on multicore and GPU backends because pairwise contractions expose large amounts of data parallelism and can often be executed through GEMM\-like kernels\[[22](https://arxiv.org/html/2608.05819#bib.bib24),[51](https://arxiv.org/html/2608.05819#bib.bib52),[38](https://arxiv.org/html/2608.05819#bib.bib40),[40](https://arxiv.org/html/2608.05819#bib.bib42),[39](https://arxiv.org/html/2608.05819#bib.bib41)\]\. On such hardware, runtime is not a monotone function of FLOPs\. The Roofline model makes this explicit: achievable performance is bounded by the minimum of peak arithmetic throughput and bandwidth\-limited throughput, so kernels with similar FLOP counts may fall into very different execution regimes depending on their arithmetic intensity\[[53](https://arxiv.org/html/2608.05819#bib.bib54)\]\.

For the local contraction in Eq\. \([5](https://arxiv.org/html/2608.05819#S4.E5)\), an intensity proxy is

Ii≈2​M​N​KM​K\+K​N\+M​N\.I\_\{i\}\\approx\\frac\{2MNK\}\{MK\+KN\+MN\}\.\(27\)For fixedMMandNN, the dominant driver ofIiI\_\{i\}isK=2kiK=2^\{k\_\{i\}\}\. This is whykik\_\{i\}is promoted from an internal term incic\_\{i\}to an explicit feature: it separates high\-reuse, compute\-friendly contractions from low\-reuse, memory\-sensitive ones\. The variablepip\_\{i\}also acquires a second interpretation in the GPU regime\. Since the output containsM​N=2piMN=2^\{p\_\{i\}\}elements,pip\_\{i\}becomes a direct proxy for exploitable data parallelism: a largepip\_\{i\}offers many independent output elements to distribute across threads and thread blocks, whereas a very smallpip\_\{i\}is more likely to underutilize the device even if the theoretical work exponent is large\.

The geometry descriptordid\_\{i\}is equally important\. High\-performance tensor libraries stress that memory layout and stride regularity are critical for performance\. On CPUs, fused packing and transpose\-avoidance are used to recover favorable access patterns\[[46](https://arxiv.org/html/2608.05819#bib.bib47),[32](https://arxiv.org/html/2608.05819#bib.bib34)\]\. On GPUs, the same issue appears as a requirement to align mode ordering across tensors, to keep batched modes in slow\-varying dimensions, and to preserve a large stride\-one extent whenever possible\[[11](https://arxiv.org/html/2608.05819#bib.bib14)\]\. This is whydid\_\{i\}matters: it is a compact surrogate for how square or skinny the effectiveM×NM\\times Ngeometry is, and therefore for how easily the step can be mapped to a high\-throughput kernel\.

### A\.8Parallelism\-dynamics block

This block summarizes how much useful output\-side parallelism is present in the plan, globally and at the bottleneck:

max​\_​out​\_​rank​\(π\)\\displaystyle\\mathrm\{max\\\_out\\\_rank\}\(\\pi\)=maxi⁡pi,\\displaystyle=\\max\_\{i\}p\_\{i\},\(28\)avg​\_​out​\_​rank​\(π\)\\displaystyle\\mathrm\{avg\\\_out\\\_rank\}\(\\pi\)=1S​∑ipi,\\displaystyle=\\frac\{1\}\{S\}\\sum\_\{i\}p\_\{i\},\(29\)costw​\_​out​\_​rank​\(π\)\\displaystyle\\mathrm\{costw\\\_out\\\_rank\}\(\\pi\)=∑iwi​pi,\\displaystyle=\\sum\_\{i\}w\_\{i\}p\_\{i\},\(30\)p​\_​at​\_​max​\_​cost​\(π\)\\displaystyle\\mathrm\{p\\\_at\\\_max\\\_cost\}\(\\pi\)=1\|Imax\|​∑i∈Imaxpi\.\\displaystyle=\\frac\{1\}\{\|I\_\{\\max\}\|\}\\sum\_\{i\\in I\_\{\\max\}\}p\_\{i\}\.\(31\)
Each of these quantities answers a slightly different question\.max​\_​out​\_​rank\\mathrm\{max\\\_out\\\_rank\}tells us how much output parallelism is ever exposed by the plan and also acts as a rough proxy for the largest immediate intermediate tensor\.avg​\_​out​\_​rank\\mathrm\{avg\\\_out\\\_rank\}summarizes the typical output scale of the plan, which is useful when discriminating between consistently parallel\-friendly plans and those that only occasionally expose large outputs\.costw​\_​out​\_​rank\\mathrm\{costw\\\_out\\\_rank\}is more selective: it asks whether the expensive part of the plan is also the parallel\-rich part\. This distinction is crucial because large output tensors in cheap steps do little to accelerate total runtime if the bottleneck itself remains poorly parallelized\. Finally,p​\_​at​\_​max​\_​cost\\mathrm\{p\\\_at\\\_max\\\_cost\}isolates that exact issue by measuring output parallelism at the critical step\.

### A\.9Reduction and arithmetic\-intensity block

This block isolates whether the heavy contractions of the plan are reduction\-rich or reduction\-poor:

max​\_​red​\_​rank​\(π\)\\displaystyle\\mathrm\{max\\\_red\\\_rank\}\(\\pi\)=maxi⁡ki,\\displaystyle=\\max\_\{i\}k\_\{i\},\(32\)costw​\_​red​\_​rank​\(π\)\\displaystyle\\mathrm\{costw\\\_red\\\_rank\}\(\\pi\)=∑iwi​ki,\\displaystyle=\\sum\_\{i\}w\_\{i\}k\_\{i\},\(33\)k​\_​at​\_​max​\_​cost​\(π\)\\displaystyle\\mathrm\{k\\\_at\\\_max\\\_cost\}\(\\pi\)=1\|Imax\|​∑i∈Imaxki\.\\displaystyle=\\frac\{1\}\{\|I\_\{\\max\}\|\}\\sum\_\{i\\in I\_\{\\max\}\}k\_\{i\}\.\(34\)
The purpose of this block is to make arithmetic intensity visible at plan level\.max​\_​red​\_​rank\\mathrm\{max\\\_red\\\_rank\}records the largest reduction dimension encountered anywhere in the path\. On its own, that feature says little about total runtime, but it does indicate whether the plan contains potentially high\-reuse contractions\.costw​\_​red​\_​rank\\mathrm\{costw\\\_red\\\_rank\}is more informative because it measures the reduction\-richness of the expensive region rather than of the path as a whole\.k​\_​at​\_​max​\_​cost\\mathrm\{k\\\_at\\\_max\\\_cost\}goes one step further and characterizes the bottleneck directly\. Plans with similarmax​\_​cost\\mathrm\{max\\\_cost\}can differ markedly ink​\_​at​\_​max​\_​cost\\mathrm\{k\\\_at\\\_max\\\_cost\}, and therefore in whether their dominant contraction is more likely to be compute\-bound or memory\-bound\.

### A\.10Geometry and memory\-access block

This block summarizes contraction shape both globally and at the bottleneck:

max​\_​asym​\(π\)\\displaystyle\\mathrm\{max\\\_asym\}\(\\pi\)=maxi⁡di,\\displaystyle=\\max\_\{i\}d\_\{i\},\(35\)avg​\_​asym​\(π\)\\displaystyle\\mathrm\{avg\\\_asym\}\(\\pi\)=1S​∑idi,\\displaystyle=\\frac\{1\}\{S\}\\sum\_\{i\}d\_\{i\},\(36\)costw​\_​asym​\(π\)\\displaystyle\\mathrm\{costw\\\_asym\}\(\\pi\)=∑iwi​di,\\displaystyle=\\sum\_\{i\}w\_\{i\}d\_\{i\},\(37\)d​\_​at​\_​max​\_​cost​\(π\)\\displaystyle\\mathrm\{d\\\_at\\\_max\\\_cost\}\(\\pi\)=1\|Imax\|​∑i∈Imaxdi\.\\displaystyle=\\frac\{1\}\{\|I\_\{\\max\}\|\}\\sum\_\{i\\in I\_\{\\max\}\}d\_\{i\}\.\(38\)
These descriptors become particularly important when two plans have similar bottleneck FLOP exponents but very different effective GEMM geometries\.max​\_​asym\\mathrm\{max\\\_asym\}identifies whether the plan ever enters an extremely unbalanced regime\.avg​\_​asym\\mathrm\{avg\\\_asym\}measures the overall geometric tendency of the path\.costw​\_​asym\\mathrm\{costw\\\_asym\}asks whether the expensive part of the plan is also the geometrically awkward part, andd​\_​at​\_​max​\_​cost\\mathrm\{d\\\_at\\\_max\\\_cost\}makes that question explicit at the bottleneck\. Their common justification is that shape regularity is a first\-order determinant of memory\-access quality and kernel efficiency, particularly on GPUs where stride structure, packing efficiency, and Tensor Core utilization are strongly shape\-dependent\[[46](https://arxiv.org/html/2608.05819#bib.bib47),[32](https://arxiv.org/html/2608.05819#bib.bib34),[11](https://arxiv.org/html/2608.05819#bib.bib14)\]\.

### A\.11Kernel\-management and overhead block

The previously introduced featuresn​\_​steps\\mathrm\{n\\\_steps\}andfrac​\_​tiny​\_​steps\\mathrm\{frac\\\_tiny\\\_steps\}remain relevant here, but their interpretation sharpens on GPUs\. Launch cost, plan creation, autotuning, and workspace management are non\-negligible for fine\-grained contractions, especially if the plan contains many steps far below the critical\-load scale\. Modern GPU libraries explicitly address these effects with planning stages, plan caches, JIT compilation, and resource reuse mechanisms\[[11](https://arxiv.org/html/2608.05819#bib.bib14),[10](https://arxiv.org/html/2608.05819#bib.bib13)\]\. Since such overheads are backend\- and version\-dependent, we do not expose them as explicit library\-specific features; instead, we retain structural surrogates that remain portable across software stacks\.

This design choice deserves emphasis\. The goal is not to reproduce the private internal cost model of a specific library, but to define portable predictors of when library overhead is likely to matter\. A high value ofn​\_​steps\\mathrm\{n\\\_steps\}indicates a fragmented path that repeatedly re\-enters the runtime system, while a high value offrac​\_​tiny​\_​steps\\mathrm\{frac\\\_tiny\\\_steps\}suggests a long tail of steps whose useful numerical work may be small compared with their execution\-management cost\. These are precisely the kinds of effects that asymptotic complexity neglects but measured runtime reveals\.

### A\.12Final design principles and portability

The final feature space is deliberately richer than a minimal cost summary\. Several aggregated descriptors are correlated, but they encode distinct hypotheses about what actually limits runtime: a single catastrophic step, a broad near\-critical tail, insufficient output parallelism in the dominant region, low reduction\-driven reuse, unfavorable contraction geometry, or an accumulation of tiny\-kernel overheads\. Retaining this partial redundancy is preferable at the feature\-design stage because it allows the downstream learning model, together with feature\-importance analyses and ablations, to determine which structural mechanisms carry predictive signal on a given hardware/software stack\.

Importantly, the feature vector is derived entirely from the contraction plan and therefore does not change when the same plan is executed on a different GPU\. What changes across backends is the measured runtime, and therefore the supervision signal used for learning and evaluation\. Finally, although the present work targets binary tensor networks induced by qubit circuits, the construction extends directly to heterogeneous bond dimensions by replacing rank counts with base\-2 logarithms of the corresponding dimension products\. For example,pip\_\{i\}becomeslog2⁡\|Oi\|\\log\_\{2\}\|O\_\{i\}\|, whileMM,NN, andKKin Eq\. \([5](https://arxiv.org/html/2608.05819#S4.E5)\) become the true grouped dimensions of the equivalent matrix multiplication\. The feature design is therefore specific to the circuit\-simulation setting, but not tied to binary tensors in any essential way\.