WorksMathematics
Balancing Exploration and Exploitation in Constrained Combinatorial Optimization with U(1)-Symmetric Tensor Trains
Abstract
Tensor Train (TT) decomposition has emerged as a powerful tool for mitigating the curse of dimensionality in a variety of machine learning and combinatorial optimization tasks. Recent advances show that TT-based generative models can efficiently represent and explore high-dimensional discrete spaces, even when the cost function structure is unknown. However, incorporating hard linear constraints into TT-based optimization remains challenging, as existing interpolation and sampling approaches often fail when feasible points are rare. In this work, we develop a general TT-based framework for constrained combinatorial optimization built upon U(1)-symmetric tensor networks. Our method introduces an expressibility-enhancement mechanism for constructing sparse symmetric tensors and a graph-based diversity measure that guides sample selection during training. On assignment benchmarks, expressibility enhancement and diversity-aware selection improve mean solution quality over their respective baselines. The assignment-selected diversifying strategy also extends to nonpolynomial Set Partitioning, with larger relative gains observed in the higher-tensor-rank data families. Separate runtime benchmarks show substantial speedups over ConstrainTNet and PROTES on non-degenerate assignment workloads; comparisons with simulated annealing depend on constraint information and computational budget, but, overall, support the practicality of the current implementation.
Introduction
Tensor Train (TT) decomposition has become a powerful tool in the domains of Artificial Intelligence and Combinatorial Optimization in recent years. The idea of squeezing high-dimensional data via tensor train decomposition originated in the field of quantum mechanics ([1, 26]), where many-dimensional systems naturally arise from particle interactions. In 2011, Oseledets formalized the approach and brought these ideas into computational mathematics ([21]). To date, TT decomposition was applied to low-rank network layer approximation ([20]), LLM fine-tuning ([27]), optimization ([3, 18]), options pricing ([4]), and some others ([7, 11, 25, 24])
This paper focuses on applications of TT in combinatorial optimization. In comparison to classical mixed-integer linear programming (MILP) TT is not limited to linear cost functions and does not use any integrality relaxation. In comparison to Constraint Programming (CP) solvers ([6]) and QAOA ([8]), the cost function structure may be unknown. Compared with Bayesian optimization ([12]), TT can offer favorable scaling when the required ranks remain moderate .
We know two paradigms for TT-based optimization. First, we may request cost function values at specific grid points, then interpolate the entire landscape using a low TT-rank assumption ([28, 23]). Second, we may apply a generative approach ([5]): based on some data, learn a probability distribution that encourages low-cost values, and store it as TT. Then we may sample new data from it and use the data for further training until a stopping criterion is reached. TT-format speeds up both the training and sampling phases, making high-dimensional distribution tractable.
The challenge of applying TT to combinatorial optimization appears when variables are constrained to a feasible region (e.g., by linear equalities). In such a case, building a TT surrogate for the cost function is difficult due to a large fraction of infeasible grid points. The probability of finding any feasible point is small, and interpolation based on infeasible points is not informative. On the contrary, even a straightforward generative approach may be pre-trained on feasible data, and in a sampling phase, all infeasible samples may be eliminated. However, if the constraints are hard to satisfy, the algorithm’s efficiency may decrease significantly. To address the challenge of constraint embedding, the authors in Nakada et al., [19] used the method of nilpotent matrices. While effective for some practical cases, it is not generalizable to arbitrary linear equations because of exponential scaling with the number of constraints. In Ryzhakov & Oseledets, [22], the authors represent the method of exact constraints encoding, but only for constraints that have a particular structure, which is consistent with the tensor train linear topology and locality of interactions. The paper Lopez-Piqueres et al., [17] suggests using -symmetric tensor networks for problems with linear constraints. The available feasible dataset was used to build a sparse probability distribution tensor, assigning zero probability to all infeasible vectors. Later, an exact framework for incorporating any linear inequalities into a symmetric TT structure was developed Lopez-Piqueres & Chen, [16], with a code available on git Lopez-Piqueres, [15].
Main contributions. We developed a library for constrained optimization, using tensor trains. Our approach is based on a generative -symmetric paradigm, which accommodates arbitrary integer linear equalities, although computational cost depends on the resulting charge structure. Two major contributions expand the paradigm: i) We suggested the expressibility enhancement step, increasing feasible dataset exploitation. Thus, instead of only two strategies of building a sparse -symmetric tensor from the feasible data, as in the pioneer paper, we suggest a family of such strategies, controlled by a parameter (exploitation power). The tested enhancement improves mean assignment solution quality over the original construction. ii) We represented a sparse symmetric tensor train as a graph of charges, and suggested a graph diversity measure, which helps to choose which samples to use for training on the next algorithm iteration (increasing exploration). The assignment-selected diversifying strategy also improves mean quality on entropic Set Partitioning, with benefits concentrated in higher-tensor-rank data families. Our Julia implementation achieves 77–448× speedups over ConstrainTNet Lopez-Piqueres, [15] on the specified non-degenerate assignment kernel benchmark, depending on size and sampling backend.
Problem Statement
We consider a similar class of optimization problems as in Lopez-Piqueres et al., [17]:
where is a black-box objective function, and are integer-valued. We emphasize that the domain of the variable may be, in principle, any finite integer domain; also, and may be rational, if they are obtained from an integer by dividing by some scaling factor.
Generic black-box solvers can struggle with hard constraints. E.g., Simulated Annealing (SA) Kirkpatrick et al., [13] requires a random step implementation that maintains feasibility. Or constraints may be implemented as penalties of the form , but this may be even more problematic, because of the necessity to choose a value for and probably a low fraction of feasible solutions evaluated. In this work, we assume that some feasible data for hard constraints is available. This may be due to one of the following reasons: i) There is a feasible dataset sampler available, which may produce diverse feasible samples using some knowledge about the matrix and vector . The optimization itself may still be very challenging due to the black-box function , which, in the worst case, takes a long time to evaluate. ii) Feasible space may be explored in some other way, e.g., with a random search / MILP / CP solver, etc.
Tensor Train Generative Modeling
Algorithm 1 describes a family of generative optimization procedures based on tensor-train (TT) probability models. The method maintains a distribution for an integer vector :
The first choice is a Born machine; the second requires a nonnegative, normalized TT. The implementations considered below use the Born rule. An initial feasible dataset supplies a starting model and a best-so-far solution. At each iteration, the model generates candidates, a selection policy constructs the next training set, and a weighted likelihood update biases the model toward promising solutions. The incumbent is maintained separately from training data and is never discarded by diversification.
Selection and memory. The candidate pool may contain only current TT samples, or also externally generated feasible points and retained data. The selection policy may favor low cost, charge diversity, or their combination; it also specifies whether initial points or a history participate. Neither elite-only selection nor cumulative retention is intrinsic to the framework. For finite computational cost, experiments specify a selection quota and a memory policy explicitly.
Optional diversification. Before fitting the selected data, an operator may leave the TT unchanged, reset its amplitudes, or apply a preliminary sweep with equal sample weights. The last choice flattens the empirical training target; a single sweep does not guarantee a uniform model over its entire feasible support. Diversification can be periodic or triggered by stagnation. It must preserve feasibility and provide nonzero support for positive-weight training points. These options define different algorithms, not interchangeable implementations of the same experiment. With equal to the identity, learned amplitudes persist across iterations. The comparison in § 3.2 uses this choice; in § 2.5, algorithm rebuilds the model after selection, while the SA comparison in § 4.1 uses the explicitly stated reset/rebuild variant. The schematic loop can be cyclically organized as train–sample–select when the initial dataset is trained before the first sampling phase.
For the constrained problem (1), it is much more effective to initialize the tensor with some sparse structure, with zero probabilities for vectors that violate constraints. It helps avoid generating such samples that violate the problem’s hard constraints. For this purpose, we exploit properties of -symmetry. Let us define it carefully, but first, give some preliminary definitions. We consider a tensor for which the following holds:
Each index has one of two possible orientations (directions): or . We call a set of incoming indices and a set of outgoing indices.
Each value of index may be decomposed into the pair of values , where we call a charge index, and a degeneracy index. In this paper, the charges may be integers or integer vectors. More formally, for each linear space (associated with index ) is a direct sum of charge subspaces:
Let , and . We say that the set of index values conserves the charge if . Finally, we call the tensor -symmetric if the following holds for some charge and all possible values of indices :
where is the Kronecker delta symbol, and is a tensor indexed only by charges. Informally, that means that becomes block-sparse. If is -symmetric, then for all sets of values that do not conserve the charge . In such cases, is called a flux of the tensor. We will also call (4) a charge conservation law.
| Algorithm 1 | Generative optimization with a tensor train |
| Require: | Initial feasible data , sampling budget , iteration budget , selection/memory policy , optional diversification |
| 1: | Initialize and incumbent from ; initialize history state |
| 2: | for do |
| 3: | Sample candidates from ; optionally augment the pool from available feasible-data sources |
| 4: | Evaluate candidates as prescribed; update using evaluated feasible points |
| 5: | |
| 6: | {Identity if omitted} |
| 7: | Assign normalized weights to |
| 8: | Update by minimizing |
| 9: | end for |
| 10: | return |
Table 1.
Generative modeling with -symmetry
The rigorous description of a generative algorithm based on -symmetric tensor trains may be found in Lopez-Piqueres et al., [17]. All crucial steps from Algorithm 1 remain the same, but require less memory for storing , as only nonzero blocks are stored. Also, the big saving of computational resources takes place while calculating the gradients of and applying gradient descent steps, because all these operations are done on sparse tensors.
In detail, we describe only initialization from the training data. The idea is to associate each variable in problem (1) with a charge , where is the -th column of the constraints matrix . Then, the probability amplitude is given as a symmetric TT with the flux , and each TT-core is a -symmetric tensor of rank 3. Then, for each TT-core, we choose the direction of the indices. Left (virtual) link index , (site) index , right (virtual) link index :

Figure 1.
By convention, we put the flux on the 1-st TT-core, on the first virtual index of . Thus, the example TT, which encodes the probability distribution for the problem with 4 binary variables, is:

Figure 1 (PDF p. 4). One step of the EELS algorithm for .
The charge conservation law (4) is then equivalent to constraints in (1), because it says, that only if
Building on an exact symmetric TT for the problem (1) may be exponentially hard, because it requires an exponentially large number of link charges (thus, exponentially large rank of tensor train). In Lopez-Piqueres et al. [17], heuristic strategies are suggested, which limit the minimum required rank to construct a symmetric tensor train, but also build only the approximation of the required tensor. The two constructions are described below. We chose Method (ii) (the most expressive) for this paper as the baseline:
Method (i): Given the feasible dataset , for each , we calculate all the link charges by propagating: , . It requires operations, where is the number of (unique) feasible samples, and is the number of equalities in the problem. Then, we initialize each TT-core with non-zero blocks for subspace with charges .
Method (ii): Given the feasible dataset , for each , we calculate all the link charges by propagating: , . It requires operations, where is the number of (unique) feasible samples, and is the number of equalities in the problem. Then, for each , we search for consistent (with the left link charges and right link charges ) site charges . This step requires checking for all and , if . We store as a hash-table based type, thus all the checks take operations on average, and in the worst case (many hash collisions). TT-rank grows with the dataset size as .
The process of building a nonzero subspace of the tensor train may be interpreted as building a directed acyclic charge graph, with nodes corresponding to link charges, edges corresponding to values of , and paths in this graph from the initial node to the final node corresponding to feasible solutions to . For instance, look at the Figure 2 (a). In these terms, the algorithm of encoding constraints in -symmetric TT is expressive if it generates many feasible paths in the charge graph.

Figure 2. Example problem, where EELS reveals new samples, while standard approaches do not find any new feasible solutions. a) Charge graph of the problem. Cyan paths correspond to the training data, green and yellow lines show new feasible samples after local search. Red charge is a "newborn" charge. b) TT and the link charges nodes, obtained from the training data (black) and found by local search (red). c) Problem constraints and initial feasible dataset. d) Four illustrated feasible samples; the constraint has six feasible binary solutions in total. The sample color in matches the color of the corresponding path in the graph.
Training the symmetric Born machine
We use the Born parametrization with real TT cores and . Training follows the two-site, DMRG-like likelihood optimization of Lopez-Piqueres et al. [17], Sec. IV B. For a fixed selected dataset (the selected in Algorithm 1, with retention determined by the experiment), define
where is a numerical shift that cancels in the ratio. The training objective is
The data and weights are held fixed throughout the inner training sweeps. This objective fits the reweighted empirical distribution; it does not require evaluating outside the selected data during a sweep.
Merge and differentiate. Put the TT in mixed canonical form with the orthogonality center at site (or for a leftward update). Contract the shared bond of the two adjacent cores:
Here are physical values and are virtual indices, including their charge and degeneracy labels. All cores outside this pair are isometries. Writing for the Frobenius norm, we have . Let and be the contractions of the fixed sample with the cores strictly to the left and right of the pair, respectively. Removing the pair leaves the sample environment
For real parameters the gradient and local update are
where is the learning rate and the amplitudes and environments are evaluated before the update. In particular, the norm term must be retained even if the state was normalized before training.
Split and sweep. Reshape with row index and column index . Charge conservation separates this matrix into blocks labeled by the intermediate residual charge . For each retained charge compute , truncate within the block, and reshape back to cores. On a rightward pass use ; on a leftward pass use . Thus the orthogonality center moves one site and forbidden charge sectors remain zero (Figure 3). One full sweep visits and then . Repeat for the prescribed number of sweeps, normalize the center core, and sample sequentially

Figure 3. One two-site training update, following Lopez-Piqueres et al. [17]. Lines are tensor indices; connected lines are contracted. Orange marks the canonical center. In (b), the physical legs are fixed to the training sample by Kronecker deltas; the dashed slot is not a tensor. In (d), factors are reshaped into TT cores. The leftward update instead puts into the left core.
from the trained model.
Specialization used here. During a training sweep, our current kernels keep the existing charge sets fixed and retain only the largest singular value in each block, i.e., virtual charge degeneracy one. This does not mean total TT rank one: the bond dimension is the number of retained charges. Consequently, training changes weights on the existing charge graph.
Expressibility Enhancement Local Search (EELS)
We noticed that all methods for building symmetric TT from data, as suggested in [17], may fail for the same reason. Methods take link charges only from the data but do not apply any strategy to search for unknown charges. If the training data is too small or not diverse enough, then the required link charges, which encode near-optimal solutions, simply do not appear in TT. Moreover, this disadvantage may not be compensated during the training step, because the charge structure pre-defines all samples, which may be sampled from symmetric TT in principle, and the learning procedure updates only the probabilities of principally possible samples.
For example, look at the combinatorial problem and dataset on Figure 2 (c). Method (ii) fails to find any new samples that do not appear in . On Figure 2 (a), black circles are the link charges obtained from , and cyan arrows are all paths in the graph, which encode the dataset samples. Obviously, no new path exists through the black charges, which satisfy the charge conservation law on each edge; thus, no new samples were obtained in TT.
We propose a new parameterized family of methods for initializing symmetric TT, called Expressibility Enhancement Local Search (EELS). First, we initialize symmetric TT with Method (ii). Then, we apply the expressibility enhancement phase. The Figure 1 illustrates the main idea of this phase: we fix the -th link of TT, and then search for such charges , which i) do not appear at the -th link; ii) may connect the charges at the -th link with the charges at the -th link, satisfying charge conservation law for some . Thus, we "jump" over the -th link, and conduct a local search in a charge graph, finding such , , , which satisfy the -symmetry. Sometimes this procedure spawns new charges, which may be assigned to the -th link. The length of the "jump" may be regulated with the parameter , which is equal to the number of links we jump over. At the Figure 1, , and the Algorithm 2 also provides the detailed description for . Method (ii) may be associated with . For , we search for new charges at the links , , ..., simultaneously, by considering all possible combinations of , , ..., , thus, the complexity of the
algorithm is on average. Figure 2 shows that even for , our expressibility enhancement procedure may find some new charges, and thus, new paths in the charge graph, corresponding to feasible samples.
We emphasize that EELS is not a regular local search, which may be applied to the data samples to obtain new solution candidates. It acts more like a crossover operator, entangling all the samples from . On Figure 2(a), EELS obtains the solution, which takes the first bit of the solution 1100, and the last bit from the solution 0011, and the bits 00 in the middle are found using the charge conservation law. Similarly, EELS also finds a feasible solution, taking the first bit from 0011 and the last bit from 1100, filling the middle with a guess of 11. For large datasets, EELS may generate new feasible candidates by mixing all samples from , producing unpredictable bit concatenations with some "guessed" fillers.
Amplification of Data Diversity (ADD)
EELS from Section 3.3 is useful when we lack training data or want to better exploit existing data. In this section, we consider the special case of constraints when a
Algorithm 2 EELS algorithm,
Require: - Sets of link charges, defined from data; - constraints for the problem; - TT-cores;
,
for to do
for do
for do
for do
if then
Insert new nonzero blocks:
end if
end for
end for
end for
end for
feasible dataset sampler is available, or it is easy to construct a large dataset using extra knowledge. Such situations include, for instance, cardinality constraints . In this case, because tensor train optimization trains on the fly, we probably should not use the entire available data but rather pick a good, diverse subset. Otherwise, the complexity of the training step may be (too) large.
We formulate a problem as follows. Let be a data, available at the -th iteration of the Algorithm 1. This data includes samples from TT and other feasible solutions generated by the feasible data sampler. How to choose a subset , such that , to achieve exploration-exploitation trade-off, and keep the complexity of the training step manageable? We need to define the measure of the sample’s novelty relative to what the generative scheme has already explored. To do this, we give a formal definition of the charge graph for the problem (1), which we discuss informally in § 2.4. Let be the number of equalities in problem (1) and the number of binary variables. Let consider a DAG , with and . Here is a charge of the vertex , and the set of all vertices consists of several layers: . We call such a graph a charge graph of problem (1) if all of the following stand:
, ,
for some
If , and , then or , where is a -th column of the matrix
, if , else if , or if .
Charge graph on Figure 2(a) satisfies all conditions from the definition. On each path with edges from to , we define the operation of feasible subset evaluation: , where "" is the Cartesian product. We call a charge graph full if the set coincides with all the solutions of , where is a set of all the paths from to . We define the width of the charge graph as .
The search for the full graph charge may be exponentially hard, and the same is true for storing such a graph. That is why Method (ii) from § 2.2 builds only a subgraph with a limited width . The goal of the -generative approach is to find such , that for the optimal solution of problem (1). For the ADD selection-and-rebuild variant of Algorithm 1, the graph is rebuilt from the selected feasible data after external candidates are introduced. This makes the choice of samples control the charge topology as well as the training weights. The articles Alcazar et al., [2] and Lopez-Piqueres et al., [17] suggest only the selection of samples with the best cost function , or picking up some rare samples from for diversity. We suggest using graph distance as a diversity measure. Let be a charge graph for some feasible solution . Let . On each step of the generative optimization, we store a charge graph of already seen samples , as the sets of charges for each vertex layer: . Then the graph distance between and is:
where is an indicator function of the condition in brackets. Thus, we count the number of new charges that appear in the solution and were not previously seen by the algorithm. In § 3 we discuss how to balance this novelty measure with exploitation of the near-optimal samples.
Results
We used DeepSeek-V4.1-Flash to help write the scripts that plot benchmark results from the saved experiment outputs.
Comparison of EELS with other methods
We may compare the expressibility of the methods of building -symmetric tensor trains by fixing the dataset , defining all link charges degeneracy ranks in (3) and then, calculating the number of nonzero elements. If we initialize for all positions, preserving -symmetry, then for all , conserving charge . Thus, the number of unique samples in tensor train is just a Frobenius norm squared, which may be calculated efficiently in TT-format.
Figure 5 shows the group of experiments for the problem (1) with the random matrices of size and random vector , both sampled from the uniform distribution on . Figure 5a shows the dependency of the number of unique samples in -symmetric TT as the function of training dataset size. With EELS, the number of unique samples grows as for , while applying only the baseline method (Method (ii) from § 2.2) encodes only possible feasible solutions. EELS improves the baseline with a small increase in computational time to build an initial -symmetric TT, as shown in Figure 5b. Other experiments on Figure 5 demonstrate that the benefit Figure 6. EELS () versus Method (ii), both with Best Cost selection and persistent learned amplitudes. Each box contains 50 paired instances. Purple curves mark group medians and orange curves group arithmetic means. Box edges are the 25th and 75th percentiles; whiskers extend to the most extreme observations within 1.5 interquartile ranges of the box. Outliers are shown individually. Both panels use identical axes. Positive values favor EELS.
Figure 5. Comparison of -symmetric TT building strategies on random problems with binary variables, linear equalities and constraints matrix sampled from uniform distribution in range . (a) Number of samples dependency on training dataset size. (b) Wall time to build initial -symmetric TT. (c),(d) Sample-count ratio versus matrix sparsity.
Figure 6. (a) Linear objective.
| Objective | W/T/L | Mean (%) | Median (%) | Raw | Holm |
| Linear | 125/116/9 | 3.1 | 0.0 | ||
| Quadratic | 128/100/22 | 3.1 | 0.2 |
Table 1 (PDF p. 9). Persistent-TT EELS versus Method (ii), with Best Cost selection in both arms: 250 paired instances per objective. W/T/L denotes EELS wins, exact ties, and losses. Means and medians refer to the paired relative improvement (%). Holm correction covers the two one-sided tests; percentages are rounded to one decimal place.
Figure 6b. (b) Quadratic objective.
of using EELS depends a lot on the sparsity of the matrix , the number of constraints, and the value of parameter . Generally, if is big, or the number of constraints is huge, then it is hard to satisfy the if-condition in line 7 of Algorithm 2, and EELS spawns only a small fraction of new link charges , if it spawns any at all. In contrast, if the matrix is sparse, EELS may be an efficient strategy for several dozen constraints. For example, we consider an assignment problem [14]. This is NP-hard problem for a quadratic/black-box oracle . The constraints matrix of size is given by the rule:
and . The density of matrix scales as . Figure 4 shows the group of experiments with the assignment problem. The total number of feasible samples grows monotonically with the problem size as ; however, for large problems, building symmetric TT methods struggle to find new feasible samples when the training data is insufficiently expressive. That is why the number of samples in TT saturates and then decreases. The peak of saturation shifts to the right as the initial dataset size grows. EELS provides approximately 3 − 6 times more samples at the peak point than Method (ii) from § 2.2.

Figure 4. Number of unique samples in TT for different -symmetric TT building strategies on the assignment problem.
EELS impact on optimization results
To test whether enhanced expressibility translates into lower objective values, we compare EELS with against Method (ii), using Best Cost selection in both arms. For each of the linear and quadratic objective families, we use 50 assignment instances at each : 250 paired comparisons with binary variables.
For each pair, 400 feasible assignments are drawn uniformly from random permutations. Both arms receive the same deduplicated, cost-sorted initial matrix. Both initialize their TT once, with EELS applied only at initialization in the enhanced arm. Each of 20 outer iterations first draws 10,000 samples, then trains the existing TT on the best at most 400 distinct assignments from each new batch alone. Training uses one complete right–left sweep, learning rate 0.05, and virtual charge degeneracy one. Boltzmann weights use the standard deviation of the current elite costs as temperature, with uniform weights when this deviation is zero. Learned amplitudes and structural charge sets persist across iterations. Initial and historical points are not merged into subsequent training batches; the best evaluated solution is retained separately. No external data, restarts, or subsequent TT reinitializations are used.
For best recorded costs and , define
All baseline costs are nonzero; positive favors EELS. Figure 6 shows the distributions by size, including group medians and arithmetic means. A one-sided paired Wilcoxon signed-rank test is applied to unscaled final costs, pooled over the five sizes within each objective. Table 1 reports raw -values and Holm adjustment across the two objective-level comparisons.
The mean improvement is 3.1% for linear and 3.1% for quadratic objectives, with 125 and 128 wins out of 250 pairs, respectively. Both advantages remain significant after the Holm correction. However, there are 116 and 100 exact ties, and the pooled medians are only 0.0% and 0.2% after rounding. Thus the improvement is heterogeneous, not a uniform gain on every instance. These results support the one-time expressibility enhancement under equal sampling and iteration settings. Improvements also persist at a fixed 200 s budget (Figure 8 and § 4).
Figure 8. EELS () versus Best Cost with a 200 s budget per arm: linear (left) and quadratic (right) assignment, 50 paired instances per size. Boxes show quartiles and medians; whiskers extend to observations within 1.5 interquartile ranges, with other observations plotted individually. The labelled curves show group medians and means. Positive relative improvement favors EELS. Both panels share axis limits. The training protocol and paired tests are given in § 4 and Table 2.
ADD impact on optimization results
We use graph distance (Equation (10)) to balance cost-based selection with exploration of the charge graph. Assignment admits a simple uniform feasible sampler based on random permutations, so this experiment examines which available data to learn from, rather than how to obtain feasible data. In the ADD variant of Algorithm 1, we reconstruct the TT from the selected data at every outer iteration. We compare the following selection rules on a candidate pool , with selection quota and charge history :
Best Cost: select the candidates with lowest cost.
Best Cost + Graph Distance Filter (GDF): first select candidates by cost, then select up to lowest-cost remaining candidates satisfying . If no such candidates remain, use Best Cost as a fallback.
Mixed Selection: select candidates with largest graph distance and fill the remaining quota by cost from the other candidates.
Weighted Rank: select the candidates with smallest , where rank one denotes lowest cost or largest graph distance, respectively.
The history stores charge sets at each TT link. Computing one graph distance requires operations on average with hashed charge sets; history storage is an additional cost of the diversity-aware rules.
For each of the linear and quadratic objectives we use 50 instances at each , with binary variables. Every configuration receives the same 1K initial feasible assignments for each instance, verified by stored hashes. Each run performs 20 outer iterations, one training sweep per iteration, learning rate 0.05 and bond degeneracy one. After training a newly initialized TT, we draw 10K TT samples, deduplicate them together with 50 retained elite assignments, and supplement the pool with fresh uniform feasible samples to reach 20K candidates. Each rule selects up to candidates; retaining the 50 elites can increase the next training set to at most 1.05K distinct assignments. No worst-sample retention, EELS enhancement or barrier filter is used. All methods, including Best Cost, receive external candidates.
We evaluate for Mixed Selection and GDF, and for Weighted Rank. For each strategy and objective, we select the weight with the largest mean per-instance relative improvement . Figure 7 shows all six selected configurations; the complete grid and paired statistics are in Supplementary Section S1.
Figure 7. ADD versus Best Cost on the parameter-screening instances. Columns show linear (left) and quadratic (right) objectives; rows show GDF (), Mixed Selection (), and Weighted Rank (). Each box contains 50 paired relative improvements at the indicated number of binary variables. Positive values favor ADD. Box edges are the first and third quartiles; whiskers extend to observations within 1.5 interquartile ranges and remaining observations are shown as points. Green curves with diamond markers and orange curves with circle markers show group medians and arithmetic means, respectively. All panels share axis limits. Each displayed weight maximizes mean relative improvement within its strategy on these same instances.
All three strategies improve on Best Cost at their selected weights. The mean gains for Mixed Selection, Weighted Rank and GDF are, respectively, 2.8%, 5.6% and 6.9% for linear objectives, and 2.7%, 5.9% and 6.6% for quadratic objectives. GDF with gives the largest mean improvement in both families. It wins, ties and loses on 235/14/1 linear instances and 209/26/15 quadratic instances; its pooled median improvements are 5.9% and 6.2%. One-sided paired Wilcoxon tests on raw final costs give and , respectively; Holm adjustment over all 24 baseline comparisons gives and . The mean linear improvement of GDF increases from 2.5% at to 11.2% at ; its quadratic mean improves from 3.8% to 7.9%. This pattern is consistent with a benefit from charge-space exploration as problem size grows.
A separate held-out comparison also supports the selected GDF rule at a fixed 200 s budget (Figure 9 and § 4). These are within-benchmark comparisons with weights selected on the same instances. They support GDF with as a practical choice for this setting.
Figure 9. ADD–GDF () versus Best Cost with a 200 s budget per arm: linear (left) and quadratic (right) assignment, 50 paired instances per size. Boxes show quartiles and medians; whiskers extend to observations within 1.5 interquartile ranges, with other observations plotted individually. The labelled curves show group medians and means. Positive relative improvement favors ADD. Both panels share axis limits. The training protocol and paired tests are given in § 4 and Table 2.
ADD transfer to nonpolynomial Set Partitioning
To study a feasible space distinct from assignment, consider a collection of tiles , one per binary variable . Set Partitioning selects disjoint tiles covering every element exactly once: and . Singleton tiles guarantee feasibility. We use variables; here is a size label, not the number of equalities or binary variables. An exact counting sampler generates uniform feasible covers, without solving the objective or constructing the TT; its recurrence is given in Supplementary Section S2.
For transfer of the assignment-selected ADD rule, the fixed
locality grid has , and . Tiles have one to four elements and span at most consecutive element positions. Each cell contains 15 instances: 945 in total, or 135 for each . A fixed spatial variable order processes tiles by their smallest element, with the corresponding singleton last. It allows completed element constraints to leave the active frontier. Small therefore limits the number of simultaneous charge states; increasing broadens the exact-indicator rank profiles. Mean maximum ranks range from 24.0 at to 19,962.3 at over the balanced parameter grid (Supplementary Table S3). These are full-indicator ranks, not the ranks of a TT learned from 500 points. Locality also changes the feasible covers, so rank is a descriptive covariate rather than an isolated causal treatment.
The nonpolynomial objective is a linear cost plus entropic scenario risk:
with , independent and . The second term smoothly emphasizes adverse scenario costs; the factor makes it an empirical exponential-utility risk rather than a sum depending on scenario count. Log-sum-exp is evaluated stably. The transfer protocol fixes GDF at , selected on assignment, and compares it with Best Cost using matched initial and external feasible draws, without retuning on this grid (Supplementary § 8). Each pair uses 500 initial feasible draws, 15 iterations, and 5K TT plus 5K fresh external draws per iteration. Both methods rebuild the TT after selection and train with one full sweep, learning rate 0.05 and charge degeneracy one, using the table sampler. The budgets match iterations and requested samples.
Transfer and rank dependence. Across all 945 pairs, ADD wins on 305 tasks, ties on 628 and loses on 12. Mean relative improvement is 1.6% (stratified bootstrap 95% interval 1.4–1.8%); the median is 0.0%. Thus the assignment-selected rule transfers to a nonpolynomial objective and different constraint matrices, but its benefit is concentrated in a subset of tasks. In Figure 10, the mean gain rises from less than 0.1% at to 3.1% at , then levels off at 2.9% for . The paired one-sided Wilcoxon tests support an advantage for every group from onward after Holm correction across seven groups, but not for (Supplementary Table S4).
Figure 10. Transfer of assignment-selected GDF () to entropic Set Partitioning. Each locality group contains 135 paired tasks, balanced across nine combinations. Top: maximum internal rank of the full structural indicator, on a logarithmic axis. Thin gray intervals show minima–maxima; thick purple intervals show the arithmetic mean sample SD; hollow points mark means. These describe task dispersion, not uncertainty in the mean. The orange line uses the independent top axis and gives exact row-major assignment ranks for ; horizontal positions do not identify matched tasks across families. Bottom: relative final-cost improvement . Boxes span the first and third quartiles, with median lines; whiskers reach the most extreme observations within 1.5 interquartile ranges and other observations are points. Green diamonds and orange circles denote group medians and means. Positive values favor ADD. Training uses data-built TTs, not the full indicators whose ranks are shown above.
This pattern is consistent with the limitation of cost-only selection: it can repeatedly favor already represented charge paths and neglect structurally novel candidates. A larger charge graph is harder to cover with a fixed training quota, plausibly aggravating this limitation. Best Cost consequently falls further behind ADD on average in the higher-rank families, where the diversity filter can help compensate for incomplete exploration. The positive rank–gain association persists within each fixed group. We therefore infer greater usefulness of ADD in the higher-rank families studied. The improvement also persists at a fixed 10 s budget (Figure 11 and § 4).
Figure 11. ADD–GDF versus Best Cost on entropic Set Partitioning at 10 s per arm, with 135 pairs per locality group. Boxplot conventions and the relative-improvement definition match Figure 10. Curves show group medians and means; positive values favor ADD.
Improvement under fixed time budgets
The preceding comparisons fix the sampling and iteration settings. We add equal-time comparisons to account for the cost of diversity filtering and TT training. Each arm runs on one pinned CPU with one Julia and BLAS thread.
Paired arms share their initial feasible sample and execute sequentially, with their order alternated across instances. Checkpoints at 10, 50 and 200 s belong to the same continuous run; only improvements completed before the corresponding deadline are retained. Loading, warm-up and common input preparation are excluded, whereas initial objective evaluation, TT construction and optimization are timed. There is no fixed iteration cap.
For ADD assignment, the initial and retained training quotas are 1K, with 10K TT draws and a candidate pool of 20K completed from the external feasible sampler; 50 elites are retained. A new TT is built each iteration. The selected rule is GDF with ; the comparison uses 250 held-out instances per objective, balanced over . For EELS, the initial quota is 400, each iteration draws 10K samples and trains on at most 400 best unique current samples. The TT is initialized once, with or without one-time EELS (), and its learned amplitudes persist; there are no external samples or restarts. Each objective again has 250 pairs. Initial random samples differ from those of the earlier fixed-iteration experiment, so the two experiments do not isolate time budget as their only difference.
The Set Partitioning comparison reuses the 945-instance locality grid and its fixed initial samples: quota 500, 5K TT draws plus 5K external feasible samples, a 5% elite fraction and TT reconstruction each iteration. All three comparisons use one training sweep per iteration with learning rate 0.05. ADD uses the table sampling backend; EELS uses legacy. Objective caching is enabled for both arms of EELS and Set Partitioning, and disabled for both assignment ADD arms. Analysis-only graph diagnostics are excluded from the timed Set Partitioning runs; selection is unchanged.
Quality and budget. At 200 s, ADD improves mean assignment costs by 3.1% and 3.8% for linear and quadratic objectives; EELS improves them by 2.7% and 3.6% (Figure 8 and Figure 9 and Table 2). At 10 s, ADD improves mean entropic Set Partitioning costs by 1.0%. Zero medians coexist with positive mean gains because many pairs tie.
| Comparison | Objective | Seconds | W/T/L | Mean (%) | Median (%) | Raw | Holm |
| ADD: assignment | Linear | 200 | 179/58/13 | 3.1 | 2.4 | ||
| ADD: assignment | Quadratic | 200 | 158/41/51 | 3.8 | 2.7 | ||
| EELS: assignment | Linear | 200 | 120/122/8 | 2.7 | 0.0 | ||
| EELS: assignment | Quadratic | 200 | 113/112/25 | 3.6 | 0.0 | ||
| ADD: Set Partitioning | Entropic | 10 | 244/656/45 | 1.0 | 0.0 |
Table 2. Paired equal-time comparisons with Best Cost. W/T/L denotes wins, exact ties and losses. One-sided paired Wilcoxon signed-rank tests use objective values; descriptive gains are relative percentages. Holm correction covers all 15 pooled tests (five comparisons at three budgets), including those not selected for this table. Assignment rows contain 250 pairs each; Set Partitioning contains 945.
Figure 12 reveals contrasting ADD dynamics. On assignment, the filtering overhead is not repaid at 10 s, but an advantage emerges at 50–200 s. On entropic Set Partitioning, the advantage diminishes as Best Cost catches up. EELS reaches the same recorded incumbents at 50 and 200 s in this experiment.
Figure 12. Mean relative improvement over Best Cost versus elapsed-time budget: ADD assignment, EELS assignment, and ADD entropic Set Partitioning. Bars are asymmetric pointwise 95% paired-bootstrap intervals, stratified by problem size and, for Set Partitioning, by . Checkpoints share runs and are not independent repetitions.
Rank–budget trade-off. At 10 and 50 s the larger-rank Set Partitioning groups exhibit larger mean gains (Figure 13). Even at 200 s a weak upward tendency remains, reaching about 0.2% at the largest locality, but it is not strictly monotone: the pooled gain is only 0.1%. A plausible interpretation is that cost-only selection covers the relevant paths more readily in compact feasible spaces when external samples and sufficient time are available. Diversity filtering can then offer little extra benefit. Harder-to-cover spaces may benefit more from ADD once the budget absorbs filtering and training overhead. The rank comparison in Figure 10 gives context: assignment maximum ranks are approximately 1.7K–24K for –16, while the Set Partitioning group means span roughly 24–20K. The results suggest a rank–budget–selection trade-off.
Figure 13. Entropic Set Partitioning: mean ADD gain against the mean maximum rank of the full indicator, one point per locality group and 135 pairs per point. Colors denote elapsed-time budgets; bars are pointwise stratified paired-bootstrap 95% intervals. Lines connect group summaries and do not represent a fitted causal relationship.
Comparison with simulated annealing
For the completed SA experiment we use a separate low-rank Set Partitioning family: connected tiles on a strip, with and . These instances are not the locality grid. Their fixed spatial order and short tiles yield geometric mean maximum exact ranks 27.7, 36.1 and 45.4, respectively. Both quadratic and the entropic objective are used. The two constructions and their fixed input datasets are distinguished in Supplementary Section S2 and Supplementary Section S3.
We compare two symmetric-TT variants with two simulated annealing (SA) baselines on assignment and the low-rank strip Set Partitioning family. Each family and size contains 40 paired instances with the same 400 initial feasible draws. Separate runs use 10, 50 and 200-second budgets on one CPU core per solver; both quadratic and entropic objectives are evaluated as black boxes. We show , 200-second trajectories in Figure 14 and Figure 15; the corresponding curves and complete protocol appear in Supplementary Section S3.
Figure 14. Mean feasible-objective gain versus optimization time at (), with 40 paired tasks per panel and a 200-second nominal budget. Top: assignment; bottom: spatial Set Partitioning. Left: quadratic cost; right: entropic risk. Gain is per task, then averaged. Shading gives pointwise asymmetric 95% bootstrap intervals for the mean, not task standard deviations. The same initial data are used by all four methods; penalized or infeasible costs never enter the ordinate. EELS and full-indicator TT use the reset/rebuild protocol described in Supplementary § 9, not persistent-amplitude training.
Figure 15. The same , 200-second runs as Figure 14, plotted against cumulative objective calls (logarithmic axis). Calls include the initial evaluations, duplicates, and infeasible penalty-SA points. Each method stops at the smallest final call count among its 40 tasks (endpoint marker); no stopped trajectory is extrapolated. Comparisons are meaningful only on overlapping query ranges. Confidence intervals and gain normalization match Figure 14. These curves describe query efficiency under time-based cooling, rather than a fixed-query benchmark.
Information and model variants. Data-initialized EELS builds a symmetric TT from the current selected data and expands its graph chain by . Full-indicator TT starts from the exact indicator of all feasible solutions. In this experiment EELS rebuilds its model, and full-indicator TT resets its amplitudes, at every outer iteration; this differs from the persistent-amplitude EELS–Best Cost comparison in Section 4.2. Informed SA receives explicit feasibility-preserving moves. Penalty SA receives no such moves: it flips a random bit and minimizes with a fixed scale-based choice of . EELS and penalty SA both use the constraints , and the initial data, but exploit them differently: EELS enforces feasibility structurally, whereas penalty SA explores infeasible points.
Finite-time quality. EELS outperforms the tested penalty-SA configuration in every 200-second group in mean paired final quality (Supplementary Table S6). Penalty SA does improve its initial feasible best in 630 of 1,440 runs, including improvements in all twelve 200-second groups, but is substantially less effective within these budgets.
The EELS curves typically gain quickly and then plateau, whereas penalty SA continues to make slower gains on the displayed horizon. This is consistent with EELS acting as a rapid intensification step on data-defined support. A flat incumbent curve does not prove a local optimum, and an improving mean does not establish that individual SA chains never stagnate. A possible hybrid would supply feasible solutions from SA to a subsequent EELS stage. Such complementarity is motivated by the SA-seeded TN-GEO booster studied by Alcazar et al. [2], but the proposed SA–EELS hybrid is not tested here.
Rank and informed SA. On assignment, informed SA has better final cost on average in every group, with no individual TT wins (some ties). Its transpositions encode the permutation structure directly, while EELS receives no feasible-move oracle. Full-indicator TT approaches informed SA at , but loses more at larger sizes. For row-major assignment, the full indicator has maximum TT ranks 461, 1,715 and 6,434 at , respectively; construction and training overhead are consistent with reduced search throughput. On low-rank Set Partitioning, the TT endpoints are much closer to informed SA, particularly for the entropic objective, with many paired ties and some TT wins. The observed rank contrast explains a plausible computational mechanism.
Objective-query efficiency. The evaluation-axis curves tell a different story from wall time. On Set Partitioning the TT methods commonly reach comparable mean gains with far fewer objective calls; for example, in the entropic 200-second runs, informed SA averages 58.3 million calls versus 0.66 million for EELS and 0.54 million for full-indicator TT. Both TT variants also have higher mean gains than informed SA at the 100,000-call slice on every Set Partitioning group of the 200-second runs. Full-indicator TT has this advantage on assignment at , while EELS does not. These are descriptive slices of time-limited trajectories: SA cooling depends on elapsed time, and every curve is truncated to a query range reached by all 40 tasks. All calls, including repeats and infeasible penalty-SA queries, are counted.
Benchmarking library performance
The implementation of [17] is not open-source. However, the more recent article by the same authors has an accompanying GitHub repository, ConstrainTNet [15]. It implements an exact construction of a -symmetric tensor train: no data are needed for initialization, although the construction itself may become intractable for difficult constraint systems. ConstrainTNet also depends on ITensors [9], whereas OhMyU1 uses a specialized Julia back-end for non-degenerate charge sectors.
We compared one right–left training sweep and 400 samples on assignment instances with , using identical full-indicator initial states and training data. Both OhMyU1 sampling backends were measured on one CPU; construction and compilation were excluded. The two libraries use two-site and one-site updates, respectively. The complete input, backend and timing protocol is provided in Supplementary § 10.
The results are shown in Figure 16, and detailed comparison is in Supplementary § 10. OhMyU1 is between 77× and 211× faster with legacy, and between 85× and 448× with table, on the measured grid. The speedup is not a universal comparison of the feature sets of the packages: ConstrainTNet supports inequalities and degenerate charge subspaces, while the present OhMyU1 kernels are specialized for non-degenerate equality-constrained problems. The result instead quantifies the advantage of the specialized back-end for this non-degenerate assignment workload. The two libraries use two-site and one-site updates, respectively, so equal sweep counts do not imply equal learning progress. The benchmark does not isolate the effect of individual implementation choices. All benchmark code and raw measurements are provided with OhMyU1 [10].
Figure 16. Median wall time for one right–left training sweep and 400 sequential samples on the assignment problem. Both methods receive the same training matrix and start from the same exact uniform feasible state. Initial-state construction is excluded. Both OhMyU1 samplers are shown. The degeneracy of the block for each link index.
Two PROTES access models. We additionally compare with PROTES [5], separating access to an exact feasible-set indicator from initialization using only feasible observations. These experiments concern binary assignment, with variables in row-major order. They are distinct from the preceding trained-kernel comparison with ConstrainTNet. All runs use float64 and one logical CPU on the same local machine; Supplementary Section S5 specifies the construction, timing, training, software versions, and recorded sample and iteration counts.
Exact full indicator: storage and sampling. When all feasible charge states are known, both representations describe the complete set of assignments. Their minimal total bond dimensions coincide; the advantage of the symmetric representation is its block sparsity, not a smaller total exact TT rank. In Figure 17, dense storage grows substantially faster than storage of the permitted scalar blocks. Actual Julia object sizes include substantial metadata: at , the full object occupies 1.59 GiB, compared with 18.0 MiB of numerical blocks. The corresponding dense variable-rank cores would require approximately 472 GiB; this last number is a storage calculation, not an allocation.
Figure 17. (a) Storage of the full assignment indicator. (b) Sampling from the full uniform feasible distribution.
Figure 17 (PDF p. 18). Exact-indicator benchmarks, with no training or finite-data initialization. (a) The two PROTES curves count float64 coefficients in dense TT cores with uniform or minimal variable ranks; the scalar-block curve counts only allowed coefficients. Markers measure the complete Julia object, including charges and dictionaries, through . These are storage sizes, not peak training memory. (b) Median sampling throughput over three seeds; shading shows the observed minimum–maximum range. Each trial accumulates at least one second of timed generation in batches of 100. Counts include repeated draws. Construction, canonicalization, compilation, and diagnostic bookkeeping are excluded. Complete dense models are actually constructed only for ; complete models are constructed through . The distributions and binary variable order are identical. Both OhMyU1 sampling backends are shown.
For sampling we construct the complete indicator in both libraries and use the same uniform distribution over assignments, with no training. All observed samples are feasible. At and , OhMyU1 with the legacy sampler generates approximately and samples per second, respectively, versus and for the more memory-efficient protes_general. The resulting speedups are approximately and . Small instances do not exhibit universal superiority. The table sampler yields approximately 12K and 1.9K samples per second at these sizes; its per-call preparation is included. Both variants are shown. These measurements compare particular dense and block-sparse implementations, rather than establishing a lower bound on all possible PROTES implementations.
Initialization from feasible observations
We next provide the same 400 feasible observations and objective instance to PROTES and -EELS, without providing an indicator or permutation encoding to PROTES. OhMyU1 retains access to , an intentional difference in structural information. EELS uses , sector degeneracy one, one training sweep at learning rate 0.05, and up to 10K generated points per outer iteration. All methods run until a common time budget, including initial fitting; the number of iterations is not fixed. Five prespecified PROTES configurations vary rank, learning rate, batch size, Adam steps, and initial-data passes (Supplementary Table S8).
Figure 18 and Supplementary Figure S5 count distinct feasible points absent from the initial dataset, rather than repeated draws. The 50-second, three-seed comparison in Supplementary Figure S5 shows that longer initial fitting improves PROTES. Thus, inability to generate any feasible point is not a robust conclusion; the observed limitation is rare feasible generation under this data-based initialization and update rule. New points need not improve the objective.
Figure 18. New distinct feasible assignments within a 5-second budget, for linear (left) and quadratic (right) objectives, versus assignment size . Each point is one matched diagnostic instance/seed; all methods receive the same 400 initial observations. PROTES settings are in Supplementary Table S8; -EELS uses the fixed settings above, with both sampling backends shown. Initialization, fitting, sampling, and scoring count toward the budget. At the initial data already cover all 24 solutions, so zero novelty is unavoidable. Both panels share the ordinate transformation , with ticks labelled by the original count , allowing zeros to be shown. No uncertainty estimate can be obtained from this single-seed screen.
Acknowledgements
We thank Margarita Veshchezerova for providing the initial impetus for this research. We are grateful to Dmitry Gribanov, Elizaveta Iarovikova, Maxim Klimenko, and Ivan Samoylenko for insightful discussions. We appreciate the anonymous reviewers for their helpful feedback.
Declaration of generative AI and AI-assisted technologies
During the preparation of this work, the authors used DeepSeek-V4.1-Flash to assist with code review and debugging, test development, experiment automation, performance exploration, reproducible data visualization, preparation of selected manuscript passages, and language and formatting revisions. The mathematical formulation and core methodological ideas were developed by the human authors. The authors reviewed and edited the AI-assisted outputs and take responsibility for the content of this work.
Balancing Exploration and Exploitation in Constrained Combinatorial Optimization with -Symmetric Tensor Trains
Sergei Iudin; Mikhail Podobrii; Dmitry Zheltkov; Stanislav Moiseev
This document provides the complete strategy screening, benchmark construction, experimental protocols and additional comparisons accompanying the main article. Sections, figures, tables and equations prefixed with S belong to this supplement; references to the main article are identified explicitly.
Complete ADD strategy and weight comparison
Table S1 and Table S2 report every configuration under the protocol of Section 4.3 of the main article, using the same 250 paired objective instances per table. Best Cost was computed once per instance and objective (500 baseline runs); each of the 12 ADD configurations was run on the corresponding 250 instances (6,000 ADD runs). All 6,500 outcomes were checked for completeness, feasibility and consistency of the stored final objective.
| Strategy | Weight | W/T/L | Win (%) | Mean (%) | Median (%) | Holm (12) | Holm (24) | ||
| GDF | 235/14/1 | 94.0 | 6.9 | 5.9 | 27963 | ||||
| GDF | 239/10/1 | 95.6 | 6.5 | 6.0 | 28908 | ||||
| GDF | 232/18/0 | 92.8 | 5.8 | 5.1 | 27028 | ||||
| Weighted Rank | 222/21/7 | 88.8 | 5.6 | 5.0 | 26207 | ||||
| Weighted Rank | 227/15/8 | 90.8 | 5.5 | 5.0 | 27531 | ||||
| Weighted Rank | 225/18/7 | 90.0 | 4.9 | 4.2 | 26746 | ||||
| GDF | 214/33/3 | 85.6 | 4.3 | 3.7 | 23630 | ||||
| Mixed | 189/38/23 | 75.6 | 2.8 | 2.4 | 20727 | ||||
| Mixed | 178/36/36 | 71.2 | 2.1 | 1.7 | 19522 | ||||
| Weighted Rank | 157/74/19 | 62.8 | 2.0 | 1.2 | 14457 | ||||
| Mixed | 139/62/49 | 55.6 | 1.3 | 0.6 | 13656 | ||||
| Mixed | 94/109/47 | 37.6 | 0.6 | 0.0 | 6813 |
Table S1. Linear: every strategy and weight. All rows contain 250 pairs against Best Cost. W/T/L denotes wins/ties/losses for ADD; win rate, mean and median gains are percentages. Holm (12) and Holm (24) adjust the one-sided baseline comparisons within this objective and across both objectives, respectively.
| Strategy | Weight | W/T/L | Win (%) | Mean (%) | Median (%) | Holm (12) | Holm (24) | ||
| GDF | 209/26/15 | 83.6 | 6.6 | 6.2 | 24425 | ||||
| GDF | 197/33/20 | 78.8 | 5.9 | 5.4 | 22423 | ||||
| Weighted Rank | 189/28/33 | 75.6 | 5.9 | 5.4 | 22988 | ||||
| Weighted Rank | 184/23/43 | 73.6 | 5.2 | 4.2 | 22510 | ||||
| GDF | 179/44/27 | 71.6 | 4.6 | 3.5 | 19655 | ||||
| Weighted Rank | 151/28/71 | 60.4 | 3.5 | 2.0 | 19289 | ||||
| Mixed | 165/35/50 | 66.0 | 2.7 | 1.8 | 18031 | ||||
| GDF | 145/73/32 | 58.0 | 2.5 | 1.1 | 13019 | ||||
| Mixed | 140/45/65 | 56.0 | 2.1 | 1.3 | 15044 | ||||
| Weighted Rank | 137/71/42 | 54.8 | 1.9 | 0.5 | 12589 | ||||
| Mixed | 122/57/71 | 48.8 | 1.4 | 0.0 | 12125 | ||||
| Mixed | 98/73/79 | 39.2 | 0.5 | 0.0 | 8810 | 0.086 | 0.086 | 0.086 |
Table S2. Quadratic: every strategy and weight. All rows contain 250 pairs against Best Cost. W/T/L denotes wins/ties/losses for ADD; win rate, mean and median gains are percentages. Holm (12) and Holm (24) adjust the one-sided baseline comparisons within this objective and across both objectives, respectively.
The linear coefficients follow . For the quadratic family a matrix is generated with independent entries from and symmetrized as ; hence off-diagonal entries of are averages of two uniform draws, rather than uniform themselves. The cost is , including both off-diagonal directions and the diagonal. The source objective files are fixed across strategies. For objective index (linear) or (quadratic), instance index and size , the initial/external source uses a Mersenne Twister seeded by ; the model sampling stream is seeded by this value plus . The source stream is independent of MPS sampling. Subsequent source batch sizes can differ because the number of unique MPS samples differs; identical starting data therefore do not imply identical full adaptive trajectories.
We apply the paired Wilcoxon signed-rank test to raw differences , with the right-tailed alternative favoring ADD, as implemented by SignedRankTest in HypothesisTests.jl. Zeros are handled by that implementation; win/tie/loss counts use strict comparisons and exact equality of stored costs. The tables give the positive-rank sum , the unadjusted one-sided , Holm-adjusted over the 12 comparisons in that objective family, and the more conservative adjustment over all 24 baseline comparisons. Mean and median gains use the per-instance relative improvement ; Rows are ordered by mean relative improvement, matching the weight-selection criterion. Of the 24 baseline comparisons, 23 remain significant at 0.05 after the joint Holm adjustment; Mixed Selection with on quadratic objectives is the exception ().
Set Partitioning construction and ADD transfer protocol
Elements, tiles and binary variables. Start with the ordered set . A candidate tile is a nonempty subset of these elements, not necessarily a contiguous interval. The binary variable indicates whether this tile is selected. Defining and , the constraint requires the selected tiles to be disjoint and to cover every element exactly once. There are equalities and binary variables. We set only to retain the size labels of the assignment experiments.
Locality and the tile catalogue. Each tile contains at most four elements. Its span is , where and are its smallest and largest element labels. For example, has size three and span four: it lies inside the interval . We admit only tiles with span at most . Increasing allows more distant elements to occur in the same tile, without increasing the maximum tile size.
The tile-size proportions come from the reference case , , . For a tile of size and span exactly , its containing interval has possible positions. Both endpoints belong to the tile, and of the interior elements are chosen. Consequently the number of eligible size- tiles is
At the reference setting, the catalogue contains 18 singletons, 62 pairs, 88 triples and 57 quadruples: exactly 225 = tiles.
Generating one instance. For each , include all singletons, guaranteeing that at least one exact cover exists. Allocate the remaining columns to sizes 2, 3 and 4 in proportions 62 : 88 : 57. Take the floor of each quota and assign the leftover columns to the largest fractional remainders. Include all adjacent pairs within the size-two quota. Fill the remaining quotas by uniform sampling without replacement from the eligible, not-yet-selected tiles of each size. Thus columns are distinct; the algorithm checks that each catalogue is large enough. When a quota exhausts its catalogue, that part of the matrix is deterministic. In particular, the reference matrix at is deterministic, although its objective arrays and initial draws vary between instances.
Sort columns by the smallest element of their tile. Within each such group, put nonsingletons in lexicographic order and the singleton last. For example, all tiles starting at element 3 precede tiles starting at element 4, and is processed last in its group. This spatial ordering is fixed by construction and is not selected by optimization performance. The grid uses , and , with 15 instances per cell: 945 tasks, or 135 per locality group. Constraints are generated independently of the objective values.
Exact uniform feasible sampling. Let be the elements already covered, and let count the ways to complete their cover using available tiles. Set . Otherwise choose the smallest uncovered element and compute
Every completion must contain exactly one tile covering . Its other elements must be uncovered, which explains the two restrictions in the sum. Memoization stores these counts as arbitrary-precision integers. To draw a cover, choose each next tile with probability . Each exact cover has one path under this smallest-uncovered-element rule, and its probability telescopes to . The resulting binary vectors are therefore exactly uniform over feasible solutions, with replacement. Integer rejection sampling avoids converting large counts to floating point. The saved inputs contain 500 initial draws, objective arrays and random seeds. The solver verifies input hashes and ; external batches are also checked for feasibility and identity between the paired arms.
Left-to-right construction of the full indicator and its exact ranks. The task is to determine which virtual charges can occur in a complete feasible solution, before assigning entries to the TT cores. We process the binary decisions from left to right in the fixed spatial column order. After the first decisions, the residual charge is
An entry equal to one denotes an uncovered element; zero denotes an element already covered. Let be the set of distinct residual charges that are reachable by a prefix and admit at least one feasible suffix . Initially , and at the end . The central issue is how to construct these sets without enumerating complete solutions or solving a separate completion problem for each charge.
State enumeration and the role of singletons. Variables are grouped by the smallest element of their tile. In the group with minimum element , all multielement tiles precede the singleton . Every singleton is present. From each , consider the two decisions for tile :
If , the candidate residual is .
If , the candidate is . Allow this transition only when for every , so no element is covered twice.
At the singleton , also require . After this variable no later tile contains , so leaving it uncovered cannot lead to a feasible solution.
Merge equal surviving residuals to obtain , retaining the allowed transitions between successive layers. Reachability is automatic because each candidate comes from a retained state of the preceding layer. Completion is also guaranteed: before the singleton , every uncovered element still has its singleton among the unprocessed variables; after it, the same is true once has been covered. Skip all remaining multielement tiles and select exactly the singletons of uncovered elements.
This gives an explicit feasible suffix for every retained state. Conversely, every feasible solution obeys the transition rules, so none is lost. Thus the forward pass constructs exactly , rather than a superset requiring a later backward feasibility search. This argument depends on the singleton-last order and the presence of all singletons; it does not apply to arbitrary constraint matrices or variable orders.
From states and transitions to the indicator TT. The forward pass determines and its incoming transitions at every binary variable, including those before a singleton. No waiting until the end of a group or backward pruning of earlier layers is required. To form the corresponding core, assign one virtual index to each charge in and set
The boundary indices are fixed to and . A fixed binary vector determines at most one state path; it has a complete path precisely when it is an exact cover. Contracting the cores therefore gives one for every feasible vector and zero otherwise. For the rank measurements reported here, the implementation only enumerates states, counts transitions and accumulates prefix-path counts; it does not allocate TT cores. Its final path count provides an independent check of the sampler’s .
Why locality bounds the work. While processing the group with minimum element , all earlier elements have been covered, and elements beyond have not yet been touched. Only the coverage of at most consecutive elements can vary. Store it as a bit mask, with one bit for a covered element (the complement of the residual convention above). After processing , drop its coordinate and advance this active window. At any fixed cut, the mask and the window position determine the full residual uniquely. Consequently,
Each state has at most two outgoing transitions. With machine-word masks and constant-time state lookup, the forward traversal takes operations, where . The current implementation uses two mask-indexed count arrays of length , where is the actual maximum tile span, as well as lists of occupied masks. Including initialization of these arrays, its state-enumeration cost is bounded by
with working memory.
These bounds concern the state pass after preparing the input and masks; the code uses fixed-width masks and path counts for the benchmark sizes. Retaining the entire transition graph or the sparse cores additionally requires storage. Dense cores would instead store entries per site. The sparse traversal is therefore linear in the number of visited states, not quadratic in adjacent ranks, but it is not a polynomial-time guarantee in : the ranks themselves may grow exponentially.
A complete three-element example. Take and the ordered tiles
Here the maximum span is two. Start with . At the first variable, skipping leaves , while selecting it gives . Thus . Both states have a singleton completion. Next process :
From , skipping leaves element 1 uncovered after its last available tile, so discard that transition. Selecting gives .
From , selecting would cover element 1 twice, so disallow it. Skipping gives and closes the group correctly.
Hence . The transitions at the first two variables correspond, for example, to the core entries and .
At , state allows both skipping and selecting, giving and ; state allows only skipping. Thus . At singleton , state must select, whereas and must skip it. Merge the identical resulting residuals to obtain . Finally, singleton is skipped from and selected from , yielding . The layer sizes are , all at most . There are exactly three complete paths, with binary vectors , and . In particular, at cut 2 the charge has one feasible suffix and has two: the bond has two states, although the indicator contains three nonzero entries. Multiplying the layer sizes would not count solutions, because only the recorded transitions connect layers.
Why these state counts are the exact TT ranks. At cut , unfold the full indicator into a matrix with binary prefixes as rows and binary suffixes as columns. A reachable prefix with residual is compatible with a suffix exactly when . All prefixes with the same residual therefore have identical compatible suffix sets, and different residuals have disjoint suffix sets. Grouping rows and columns by residual produces one all-ones rectangle per , with zeros between these rectangles and possibly additional zero rows or columns. Every rectangle is nonempty: reachability supplies a prefix and the singleton completion supplies a suffix. Each rectangle has matrix rank one, and their row and column supports are disjoint. The unfolding rank is consequently exactly . This is the minimal ordinary TT bond dimension for the specified variable order, not merely an upper bound from a particular construction. The symmetric representation has the same total bond dimension, with charge degeneracy one. Maximum and mean ranks refer to the internal cuts. Table S3 pools 135 instances per locality group; its SD includes variation across the nine combinations, not only within each cell. The bound limits the number of charge states at a cut, not the number of feasible solution paths.
| Maximum internal rank | Mean internal rank | |
| 5 | ||
| 6 | ||
| 8 | ||
| 10 | ||
| 12 | ||
| 15 | ||
| 18 |
Table S3. Exact-indicator ranks in the fixed locality grid: mean sample SD over all 135 instances at each span.
Transfer configuration. We transfer Best Cost + GDF with , the shared assignment-selected choice, to the entropic objective in Equation (13) of the main article. Both arms start from the same 500 feasible draws and use 15 outer iterations, one training sweep at learning rate 0.05, charge degeneracy one, 5K TT samples and 5K independent exact-uniform external draws per iteration. Five percent of the initial distinct training size is retained as an elite, with a minimum of one point; no worst-point retention is used. The model is rebuilt from selected data each iteration, without EELS. Boltzmann temperature is the standard deviation of current training costs, with uniform weights when it is zero. The table sampling backend is explicit. External RNG streams are matched by instance and iteration and separate from model sampling; matching seeds do not imply identical TT samples after the distributions diverge. Graph-history diagnostics record the fraction of externally drawn solutions with zero novelty.
There are 945 pairs, or 1,890 solver runs. Four Slurm allocations each execute 32 isolated one-core processes, with one BLAS thread and private per-instance checkpoints. The completed comparison uses equal iteration and requested-sample budgets, not equal runtime or objective-call budgets.
Statistical analysis. We apply one-sided paired Wilcoxon signed-rank tests to raw final-cost differences, excluding exact ties, with Holm adjustment over the seven locality groups. A location-shift interpretation assumes symmetric paired differences. The overall test gives ; a paired sign test also supports the advantage (). Wins/ties/losses are unchanged by an absolute tolerance of . The smallest absolute baseline cost is 0.842, so the relative gains do not arise from nearly zero denominators. Mean-gain intervals use 5K paired bootstrap resamples stratified by the 63 design cells; these are pointwise intervals.
The individual-task Spearman correlation between exact maximum rank and relative gain is 0.435. It is positive within all nine groups, with Holm-adjusted in each. A regression controlling for these nine groups estimates 0.3 percentage points of additional gain per rank doubling (95% HC3 interval 0.3–0.4 percentage points, rounded). The accompanying analysis notebook reports all 63 cell-level A/B summaries, including losses and nonsignificant cells.
| W/T/L | Mean | 95% interval | Median | Holm | |
| 5 | 3/132/0 | 0.0 | [0.0, 0.1] | 0.0 | 0.125 |
| 6 | 14/121/0 | 0.3 | [0.1, 0.5] | 0.0 | |
| 8 | 27/107/1 | 0.6 | [0.3, 0.9] | 0.0 | |
| 10 | 44/91/0 | 1.7 | [1.2, 2.2] | 0.0 | |
| 12 | 63/69/3 | 2.5 | [1.9, 3.2] | 0.0 | |
| 15 | 75/56/4 | 3.1 | [2.5, 3.8] | 1.1 | |
| 18 | 79/52/4 | 2.9 | [2.2, 3.6] | 0.9 |
Table S4. ADD transfer: 135 pairs per locality. Relative gains and pointwise bootstrap intervals are percentages. W/T/L denotes wins, exact ties and losses; Holm adjustment covers seven one-sided Wilcoxon tests.
Separate strip family used for SA. The SA comparison uses a different construction: cells on a rectangular strip, and binary tile-selection variables. Eligible tiles are connected sets of one to four cells, with connectivity through shared cell edges, spanning at most three strip columns. All singletons are mandatory. We also include the dominoes corresponding to every vertical edge and to the horizontal edges along the top row; together these edges form a spanning tree of the strip.
Select the remaining tiles without replacement using size weights , where is the number of cells in a tile. Among optional tiles, pairs thus have weight 1, triples and quadruples . The coefficient is a fixed generator choice favouring small tiles (the code’s light setting), not a Boltzmann temperature, a learned parameter, or a consequence of the objective. The implementation draws independent , forms exponential keys , and selects the required number of tiles with the smallest keys.
The benchmark inputs are generated and saved before optimization, then reused unchanged for all methods. Spatial cell labels are restored and tiles use the singleton-last order described above; the corresponding variable permutation is also applied to the objective arrays. There is no search over variable order. This family is a deliberately low-rank contrast to row-major assignment, not a sample from the adjustable-locality grid. Full-indicator states and ranks are obtained from feasible prefix charges as above, and feasible covers are sampled using Equation (14).
Simulated annealing comparison: full protocol and additional sizes
Instances, objectives and initialization. For each of assignment and strip Set Partitioning, we use 40 previously generated and saved instances at each , with binary variables. Assignment uses its row-major permutation encoding ( equality rows); the strip construction and its equalities are specified in § 8. Each instance is evaluated separately with and the 32-scenario entropic objective. The symmetric quadratic arrays are formed by symmetrizing matrices with independent uniform entries in . Within each , both families use the same saved objective coefficient arrays and entropic scale , although their feasible spaces differ. Initial data are 400 independent uniform feasible draws, with replacement: random permutations for assignment and exact counting for Set Partitioning. All four methods use the same initial draw matrix within a problem, objective and budget. The experiment comprises 5,760 runs: two families, two objectives, three sizes, 40 instances, three budgets and four methods.
Data-initialized EELS and full-indicator TT. Both start by deduplicating and evaluating the initial data. At every outer iteration EELS rebuilds from the current training set and enhances the graph with . The full TT constructs the exact complete indicator once inside the timed run, then copies its uniformly normalized amplitudes at each iteration. Both variants train for one sweep, using learning rate 0.05, charge degeneracy one, and normalized Boltzmann weights with temperature equal to the current cost standard deviation (uniform weights at zero spread). After training they draw up to 10K samples, using the legacy backend in batches of 100 for deadline checks. The next training set contains at most 400 distinct lowest-cost points from the previous training set and the new batch; no external feasible samples are injected. The incumbent records all evaluated feasible points, including a partially completed final batch. The number of iterations is time-limited rather than fixed.
Informed SA. Optim.jl’s SimulatedAnnealing runs ten equally timed chains from the ten best distinct initial points. For assignment a proposal swaps the assigned columns of two distinct, uniformly chosen rows. For Set Partitioning a fixed patch is chosen uniformly from the tile supports. If an occupied tile crosses its boundary, the proposal is a self-loop; otherwise the current patch cover is replaced by a uniformly chosen exact cover of that patch. Patch covers are precomputed. These proposals are symmetric and preserve feasibility. Each chain cools geometrically in wall time from the standard deviation of initial costs to times that value, with a machine-epsilon floor. The moves and patch catalogue provide problem-specific information beyond the explicit constraints and initial examples given to data-initialized EELS.
Penalty SA. The same Optim implementation and ten starting points minimize on the whole binary cube, proposing one uniformly chosen bit flip. There is no repair or feasibility-preserving move catalogue. With and the range and sample SD of initial costs, set
Geometric cooling is restarted within each chain. Ignoring the objective change, gives a typical constraint-violating one-bit proposal approximately one-half acceptance probability, rather than freezing every move at a feasible start. The multiplier is fixed across all instances and objectives. Only feasible raw costs update the reported incumbent. Every objective evaluation on an infeasible state nevertheless consumes a call and time. Residual computation, penalty setup, feasible/infeasible counters and best penalized states are recorded. No infeasible evaluated point had a penalized value below the initial feasible best.
Timing, counters and reproducibility. Separate 10, 50 and 200-second runs reuse fixed per-instance seeds. The source seed plus initializes SA’s default RNG, plus its proposal RNG, and plus the TT RNG. The cluster used Intel Xeon Gold 6226R CPUs at 2.90 GHz, Julia 1.12.5 and Optim.jl 2.3.2. Each solver process has one Julia compute thread and one BLAS thread; 32 independent processes share each exclusive allocation, with four allocations at a time. Timed work includes initial objective calls, TT construction, resets, training, sampling, penalty evaluation and search. Loading, JIT warmup, pre-run validation and informed-SA patch-catalogue construction are excluded; this last exclusion favors informed SA and limits end-to-end runtime interpretation.
Termination is cooperative. Improvements after the requested deadline are excluded, while actual elapsed times are retained. In particular, for quadratic assignment at with a nominal 10-second budget, full TT averages 22.8 seconds (maximum 27.7) and completes no iteration on any task. At 200 seconds all methods perform search. Exact objective counters include initial calls, duplicates, repeated Optim evaluations, self-loops and penalty-SA infeasible points. The same evaluator is used by all methods: quadratic costs sum the active submatrix of , while the entropic cost uses stable log-mean-exp.
Aggregation and inference. For each panel, average the per-task gain equally over its 40 instances. The curve uses the exact union of improvement events with stepwise interpolation. Pointwise asymmetric 95% percentile-bootstrap intervals resample the 40 tasks 2,000 times (seed 20261014), using the same weights across time and methods. For the objective-call axis, each method stops at the minimum final count over all 40 tasks; endpoints from slower tasks are not extrapolated. The 100,000-call diagnostic is a post hoc slice of the 200-second trajectories, not a separately tuned fixed-query test. Full assignment at does not reach that slice on all tasks.
Paired tests use one-sided Wilcoxon signed ranks of raw baseline-minus-TT cost differences; differences below are numerical ties. Tests versus penalty SA form a Holm family of 72 comparisons (36 groups times two TT variants). The original informed-SA analysis, extended to include penalty SA as a third candidate, uses 108 comparisons in a separate Holm family. Both are exploratory analyses of this benchmark, with one seed per task.
Table S5. 200-second endpoints. Each cell is mean feasible-objective gain (%) / mean objective calls (millions), over 40 tasks. Means include unsuccessful runs.
| Family | Objective | Informed SA | Penalty SA | EELS | Full TT | |
| Assignment | Quadratic | 10 | 73.5 / 368.6 | 24.7 / 103.9 | 52.4 / 1.6 | 71.3 / 1.2 |
| Assignment | Quadratic | 12 | 102.8 / 303.3 | 15.8 / 70.1 | 55.5 / 0.92 | 85.1 / 0.34 |
| Assignment | Quadratic | 14 | 132.9 / 252.5 | 9.8 / 48.1 | 45.9 / 0.53 | 75.2 / 0.064 |
| Assignment | Entropic | 10 | 93.3 / 125.2 | 27.7 / 62.7 | 76.4 / 1.7 | 92.7 / 1.2 |
| Assignment | Entropic | 12 | 115.6 / 108.1 | 18.6 / 45.1 | 73.9 / 0.98 | 109.5 / 0.35 |
| Assignment | Entropic | 14 | 141.1 / 95.6 | 11.7 / 32.4 | 54.6 / 0.57 | 106.2 / 0.067 |
| Set Partitioning | Quadratic | 10 | 87.8 / 86.7 | 22.2 / 65.3 | 87.1 / 1.7 | 87.2 / 1.6 |
| Set Partitioning | Quadratic | 12 | 117.2 / 79.7 | 17.3 / 59.8 | 115.9 / 1.0 | 116.7 / 0.88 |
| Set Partitioning | Quadratic | 14 | 139.6 / 67.8 | 6.2 / 39.2 | 134.4 / 0.63 | 137.1 / 0.5 |
| Set Partitioning | Entropic | 10 | 200.7 / 69.8 | 46.1 / 49.0 | 199.8 / 1.8 | 200.7 / 1.7 |
| Set Partitioning | Entropic | 12 | 201.6 / 64.1 | 31.8 / 46.0 | 200.8 / 1.1 | 201.6 / 0.93 |
| Set Partitioning | Entropic | 14 | 210.6 / 58.3 | 19.5 / 31.1 | 210.0 / 0.66 | 210.6 / 0.54 |
Table S5.
Table S6. Paired improvements over penalty SA at 200 seconds: mean (%), wins/ties/losses, and one-sided Wilcoxon after Holm correction over all 72 TT–penalty comparisons (including 10 and 50 seconds).
| Family | Objective | EELS (%) | W/T/L | Holm | Full TT (%) | W/T/L | Holm | |
| Assignment | Quadratic | 10 | 23.3 | 40/0/0 | 38.5 | 40/0/0 | ||
| Assignment | Quadratic | 12 | 35.0 | 39/0/1 | 60.7 | 40/0/0 | ||
| Assignment | Quadratic | 14 | 33.5 | 40/0/0 | 60.0 | 40/0/0 | ||
| Assignment | Entropic | 10 | 38.3 | 40/0/0 | 51.3 | 40/0/0 | ||
| Assignment | Entropic | 12 | 48.4 | 38/1/1 | 78.8 | 40/0/0 | ||
| Assignment | Entropic | 14 | 41.2 | 39/0/1 | 87.9 | 40/0/0 | ||
| Set Partitioning | Quadratic | 10 | 53.7 | 40/0/0 | 53.8 | 40/0/0 | ||
| Set Partitioning | Quadratic | 12 | 85.4 | 40/0/0 | 86.0 | 40/0/0 | ||
| Set Partitioning | Quadratic | 14 | 121.8 | 40/0/0 | 124.3 | 40/0/0 | ||
| Set Partitioning | Entropic | 10 | 109.3 | 40/0/0 | 109.7 | 40/0/0 | ||
| Set Partitioning | Entropic | 12 | 125.5 | 40/0/0 | 126.1 | 40/0/0 | ||
| Set Partitioning | Entropic | 14 | 159.1 | 40/0/0 | 159.6 | 40/0/0 |
Table S6.
Figure S1. Additional size (): 200-second runs, 40 tasks per panel. Gain versus optimization time; conventions match Figure 14 of the main article. Top: assignment; bottom: strip Set Partitioning. Left: quadratic; right: entropic. All four methods use matched initial data; TT amplitudes are reset/rebuilt each iteration. Shading denotes pointwise 95% bootstrap intervals for mean per-task gain.
Figure S2. Additional size (): 200-second runs, 40 tasks per panel. Gain versus objective calls; conventions and common-support truncation match Figure 15 of the main article. Top: assignment; bottom: strip Set Partitioning. Left: quadratic; right: entropic. All four methods use matched initial data; TT amplitudes are reset/rebuilt each iteration. Shading denotes pointwise 95% bootstrap intervals for mean per-task gain.
Figure S3. Additional size (): 200-second runs, 40 tasks per panel. Gain versus optimization time; conventions match Figure 14 of the main article. Top: assignment; bottom: strip Set Partitioning. Left: quadratic; right: entropic. All four methods use matched initial data; TT amplitudes are reset/rebuilt each iteration. Shading denotes pointwise 95% bootstrap intervals for mean per-task gain.
Figure S4. Additional size (): 200-second runs, 40 tasks per panel. Gain versus objective calls; conventions and common-support truncation match Figure 15 of the main article. Top: assignment; bottom: strip Set Partitioning. Left: quadratic; right: entropic. All four methods use matched initial data; TT amplitudes are reset/rebuilt each iteration. Shading denotes pointwise 95% bootstrap intervals for mean per-task gain.
Detailed library performance benchmarking
Matched inputs and benchmark protocol
We compared the training and sampling kernels of the two libraries on the binary assignment problem. For an assignment instance there are binary variables and linear equality constraints. We used , one complete right–left training sweep, one batch of samples after training, bond degeneracy one, and learning rate 0.05. A deterministic dense quadratic cost matrix with entries in was generated for every . Four hundred random feasible assignments were generated and resampled once according to their Boltzmann weights. The resulting empirical training matrix, including repeated rows, was passed unchanged to both implementations. Thus, both libraries were trained on exactly the same data. OhMyU1 is measured with two sampling backends. The legacy backend follows sampled charge paths using the block dictionaries; table first constructs transition tables for all charge states on each sampling call, then amortizes that preparation over the batch. Both implement the same conditional probabilities. Training is unchanged; the recorded training-time differences between runs reflect timing variation, not a different training algorithm.
The initial tensors represented the same mathematical state: the uniform superposition of all feasible assignments. ConstrainTNet constructed its state exactly from the constraints. For OhMyU1, the complete set of reachable charge sectors at every cut was enumerated exactly by a dynamic construction specific to the assignment variable order; no finite random initialization sample was used. The maximum bond supports were identical in both representations and ranged from 9 at to 461 at .
Tensor construction, initial-state canonicalization and normalization, Julia compilation, and copying of the prepared state were excluded from the reported time. Each kernel was executed once as a warm-up, followed by three measured repetitions; the median wall time is reported. The primary metric is the sum of the median time for one training sweep and the median time for exactly 400 sequential samples from the trained state. All runs used Julia 1.12.5, one default Julia thread, one BLAS thread, and the same Intel Core i5-10210U CPU.
Implementation details and validation
The refreshed benchmark uses OhMyU1 revision e23712d and ConstrainTNet revision 77d8c26 (latest upstream checked on 12 October 2026). ConstrainTNet’s algorithm sources are unmodified; vendored ITensors 0.3.41/NDTensors 0.1.50 are retained. The sole source adjustment increases ITensors’ fixed charge capacity from 20 to 21: at 20 equalities, comparison with an empty charge attempts to insert an inactive component and otherwise fails. The spare slot avoids this boundary error.
The random seed for each problem is . The Boltzmann temperature is the sample standard deviation of the 400 candidate costs; 400 draws with replacement form the common empirical training multiset.
One default Julia thread, no interactive thread, and one BLAS thread are used on Windows with an Intel Core i5-10210U processor. The two backends run in separate sequential processes. Each timing starts from a fresh copy, with garbage collection outside the timed region. Compilation, construction, initial-state canonicalization/normalization, and copying are excluded. Each kernel is warmed up and timed three times; the table adds the two kernel medians rather than timing a high-level optimizer wrapper. This avoids the extra pre-training sampling batch in ConstrainTNet.optimizer.
OhMyU1 performs projected two-site updates, whereas ConstrainTNet performs one-site updates. Internal canonicalization, environment construction, and loss evaluation performed by the public ConstrainTNet training routine remain inside its timing. Thus, the measurements compare the cost of the available training and sampling routines for the same inputs and sweep count.
| Train L | Sample L | Total L | Train T | Sample T | Total T | ConstrainTNet | |
| 4 | 0.0025 | 0.0033 | 0.0058 | 0.0024 | 0.0004 | 0.0028 | 1.2 |
| 5 | 0.0061 | 0.0059 | 0.012 | 0.0058 | 0.0008 | 0.0066 | 2.2 |
| 6 | 0.013 | 0.0096 | 0.023 | 0.013 | 0.0018 | 0.015 | 3.4 |
| 7 | 0.028 | 0.013 | 0.041 | 0.028 | 0.0042 | 0.032 | 5.2 |
| 8 | 0.059 | 0.019 | 0.078 | 0.055 | 0.0091 | 0.064 | 8.5 |
| 9 | 0.15 | 0.029 | 0.18 | 0.14 | 0.021 | 0.16 | 14 |
| 10 | 0.3 | 0.044 | 0.34 | 0.31 | 0.045 | 0.36 | 47 |
Table S7. Median times (seconds) for one training sweep and 400 serial samples. L and T denote legacy and table. Total is the sum of the two kernel medians. ConstrainTNet measurements are retained; both OhMyU1 variants use the same inputs. Construction, warm-up, and copying are excluded.
PROTES comparison: exact indicators and data-based initialization
OhMyU1 measurements were repeated on 12 October 2026 using revision e23712d, with unchanged inputs, seeds, CPU affinity, batch sizes, and time budgets. The PROTES measurements were retained. The source hashes and separate memory-audit and timing runs are archived. OhMyU1 uses the serial sample_nondeg! routine, with both backend=:legacy and backend=:table reported separately. Full-indicator table timings are the archived repeat after the memory audit; data-initialized table runs were measured separately with identical inputs.
Exact assignment indicator, ranks, and storage
The full structural tensor is . For assignment, reshape the binary variables as with exactly one selected entry in every row and column. Process these bits row by row. At a cut after bits, rows are complete and bits of the next row have been processed, with .
A dynamic-programming state records the set of columns already used by selected entries and the flag indicating whether the current, partially processed row already has its selected entry. The completed rows contribute exactly selected entries, so . For example, for at we have . State means that the first row selected column 2 and the second row skipped column 1. State means that the second row has already selected column 1. These states have different sets of feasible suffixes.
To process the next bit in column , choosing zero leaves unchanged; choosing one is allowed only if and , and adds that column to . At the end of each row require exactly one selected entry and reset the flag for the next row. Merge identical states. Keep only states reachable from the empty prefix and extendable to a complete assignment. For , an unoccupied column must remain among . For , at least one occupied column must be among , so the current row’s selection can lie in the processed prefix. At the endpoints, and .
Each retained state labels a virtual index. Set a core entry to one for each permitted state transition and to zero otherwise. Every permutation has exactly one binary path, hence unit amplitude; all other binary vectors have zero amplitude. This constructs the full indicator without enumerating permutations. The symmetric and dense representations encode this same graph; the dense one additionally stores forbidden transitions as zero coefficients. Let denote the total virtual dimension at cut , equivalently the number of retained charge states, as in the Set Partitioning construction.
With out-of-range binomial coefficients interpreted as zero, the number of states at an internal cut is
Here is the number of completed rows and the number of processed bits in the current row. The first pair of terms counts states and the second counts states. After grouping prefixes and suffixes by residual constraint charge, the indicator unfolding consists of disjoint nonempty all-ones blocks, each of rank one. Consequently is the exact minimal ordinary TT rank for this ordering. The maximum is (e.g., 125 at , 461 at , and 24309 at $n = 16). The representation has the same total link dimension, but every sector has degeneracy one. This exact-rank statement concerns the full indicator; an optimizer’s distribution concentrated on a smaller feasible subset need not have these ranks.
The two dense float64 storage counts in Figure 17 of the main article are
They describe the fast PROTES core layout and the variable-rank protes_general layout, respectively. For , the number of allowed scalar transitions at position is
The first term counts transitions assigning one and the remaining terms count transitions assigning zero. Thus numerical block storage is bytes. These counts were checked against the constructed blocks and dense arrays. MiB and GiB denote and bytes. Full objects were constructed and measured through using Base.summarysize, including dictionaries, charge vectors, the constraint matrix, and other reachable fields. The measurement excludes process/runtime memory and temporary buffers; it depends on object sharing in this constructor. Dense curves count coefficient arrays only. Adam states, gradients, and training workspaces are excluded from all storage claims.
Untrained full-indicator sampling protocol
Both models sample uniformly over the same full feasible set. PROTES uses the above zero/one transition cores, padded to a common internal rank for its fast implementation and left at their exact ranks for protes_general. For OhMyU1, backward dynamic programming computes the completion count at every link: is the number of processed binary variables and is the residual constraint vector. Thus counts suffixes whose contribution equals . Starting with , compute backwards
where the sum includes only retained feasible transitions. For example, at a row boundary of assignment, after completed rows: the remaining rows can be matched bijectively to the unoccupied columns. The scalar on an allowed edge is replaced by . Products telescope to , giving an exact right-canonical normalized amplitude. Its squared amplitudes and the PROTES probability indicator therefore induce the same uniform law.
We call the unchanged OhMyU1 serial sample_nondeg! and the upstream PROTES sampling kernels with their usual JAX vectorization. Batches contain 100 samples. Each of three seeds runs until cumulative timed generator calls reach at least one second; a final batch can exceed that duration. Throughput divides the actual generated count by actual timed duration, and counts repetitions. Construction, canonicalization, JIT warm-up, feasibility checks, and unique-point bookkeeping are excluded. PROTES timing includes materializing the output and recomputing right environments per batch, as in its normal sampling loop. The feasible fraction is 100.0% in all recorded batches. Raw per-trial batch counts, times, warm-up/construction times, and distinct-point counts are retained in the accompanying results snapshot. Full dense models are allocated for ; beyond this grid their storage curves are analytical, not timing measurements. OhMyU1 is measured for .
The large object traversal initially caused memory pressure at on the local machine. Final sampling measurements were repeated without repeating that deep traversal and with garbage collection before warm-up; the initial memory-audit runs are retained separately. The shaded ranges report run-to-run variation, not confidence intervals or an asymptotic complexity result.
Paired, data-initialized optimization protocol
Longer initial fitting improves PROTES: at , fit20 finds 12–25 new points for linear objectives and 17–25 for quadratic objectives in 50 seconds, while EELS with the legacy sampler finds 6.9K–7.3K and 9.3K–10K, respectively. Thus, inability to generate any feasible point is not a robust conclusion; the observed limitation is rare feasible generation under this data-initialization and update rule. New points need not improve the objective. With the table sampler the corresponding EELS ranges are 6.9K–7.3K and 9.4K–10K.
Figure S5. The same data-initialized comparison at (), with a 50-second budget and three matched instance/seed pairs for each objective. Dots are individual counts of new distinct feasible points; orange bars and red diamonds show the arithmetic mean and median of the original counts. Both panels use the same ordinate and limits. All five PROTES configurations and both EELS sampling backends are reported, not only the best observed configuration. These are trained, time-limited runs, unlike the untrained full-indicator sampling experiment in Figure 17 of the main article.
These diagnostic instances are separate from the article’s objective files. For each , with repetition index and objective family , NumPy’s generator uses seed . It first draws 400 independent random permutations and converts them to row-major binary assignments. It then draws either independent , with cost , or a matrix with independent , sets , and uses cost . Exactly the same arrays are exported to Julia.
Define novelty as the number of distinct generated feasible points outside the set of initial observations. Initial duplicates are not new, repeated generated points count once, and the initial best cost is retained in every method. The 5-second screen uses and ; the 50-second comparison uses and , for both objective families. All five PROTES configurations in Table S8 are included at both budgets. At the particular initial datasets cover all 24 solutions.
| Configuration | Rank | Learning rate | Initial updates | ||||
| default | 5 | 100 | 10 | 1 | 0.05 | 1 | 4 |
| rank20 | 20 | 100 | 10 | 1 | 0.05 | 1 | 4 |
| slow10 | 5 | 100 | 10 | 10 | 0.01 | 1 | 40 |
| batch400 | 10 | 400 | 40 | 10 | 0.01 | 1 | 10 |
| fit20 | 5 | 100 | 10 | 1 | 0.05 | 20 | 80 |
Table S8. PROTES settings. is the input/generated batch size, the elite count, the number of Adam steps per accepted batch, and the number of passes through the initial 400 observations. The last column is the number of initial Adam updates, .
PROTES starts from its ordinary random dense cores, receives the initial observations through its external-sample interface in deterministically shuffled passes, and applies its normal elite update. Thus only the best 10.0% of each input batch contributes to the likelihood update, not all 400 observations simultaneously. After initialization no more external observations are injected. The external evaluator assigns valid points score and invalid points score 2, preserving the ordering of feasible costs. An entirely infeasible batch uses the upstream pick-update path. If fewer than points are feasible, the unchanged elite rule also includes penalized infeasible points. No mask, repair, indicator, , , or permutation encoding is given to PROTES.
OhMyU1 receives , , deduplicates and cost-sorts the same initial data, and rebuilds its TT from the retained data at each outer iteration, applying EELS with and sector degeneracy one before canonicalization. Training uses one right–left sweep, learning rate 0.05, and normalized weights proportional to , with the sample standard deviation of the current costs; weights are uniform if . The normalized trained TT supplies up to 10K samples, processed in batches of 100 for deadline checks. The next dataset contains up to 400 lowest-cost distinct points from the union of retained and newly generated points. No external feasible generator is called after initialization. The number of iterations is set by the wall-time limit and reported below.
Initial model construction/fitting, subsequent training, sampling, novelty bookkeeping, and objective evaluation all count toward the 5/50-second budgets. Explicit warm-up and file loading do not: PROTES warms its kernels on a synthetic binary objective at the same dimension, while OhMyU1 warms one full outer iteration and discards its model. Residual compilation counts toward the measured budget. Deadlines are cooperative: a current sample or training operation can overrun, and a batch arriving after the deadline is not accepted. All initial fits completed. There is no fixed number of PROTES optimization iterations; generated counts and batch sizes determine the sampling workload, whereas only batches containing feasible points trigger further Adam steps. Total post-initialization Adam-update counts were not separately logged. The result tables give generated counts rather than implying equal iteration counts; actual elapsed times remain available in the archived results.
| Configuration | Objective | New points | Generated draws (range) |
| default | linear | 0, 0, 0 | 3.3M–3.4M |
| default | quadratic | 0, 0, 0 | 3.1M–3.4M |
| rank20 | linear | 0, 0, 0 | 1.2M–1.5M |
| rank20 | quadratic | 0, 0, 0 | 1.4M–1.6M |
| slow10 | linear | 13, 9, 4 | 3M–3.1M |
| slow10 | quadratic | 6, 3, 6 | 2.7M–2.9M |
| batch400 | linear | 0, 0, 0 | 3.4M–3.6M |
| batch400 | quadratic | 0, 0, 0 | 3.5M–3.5M |
| fit20 | linear | 22, 12, 25 | 2.9M–3.3M |
| fit20 | quadratic | 17, 18, 25 | 3.3M–3.4M |
Table S9. Recorded 50-second PROTES runs at . Triples are new distinct feasible points in seed order ; ranges cover the three runs. Generated counts include infeasible draws.
| Objective | Budget (s) | Iterations | Draws | New points | ||
| 4 | linear | 0 | 5 | 38/39 | 380K | 0 |
| 4 | quadratic | 0 | 5 | 39/40 | 390K | 0 |
| 5 | linear | 0 | 5 | 25/26 | 260K | 6 |
| 5 | quadratic | 0 | 5 | 26/27 | 270K | 3 |
| 6 | linear | 0 | 5 | 16/17 | 170K | 418 |
| 6 | quadratic | 0 | 5 | 15/16 | 160K | 406 |
| 7 | linear | 0 | 5 | 10/11 | 110K | 3K |
| 7 | quadratic | 0 | 5 | 10/11 | 100K | 3.5K |
| 8 | linear | 0 | 5 | 7/8 | 77K | 6.6K |
| 8 | quadratic | 0 | 5 | 6/7 | 60K | 7.9K |
| 9 | linear | 0 | 5 | 4/5 | 41K | 8K |
| 9 | quadratic | 0 | 5 | 3/4 | 34K | 11K |
| 10 | linear | 0 | 5 | 3/4 | 34K | 8.4K |
| 10 | quadratic | 0 | 5 | 3/4 | 32K | 11K |
| 8 | linear | 0 | 50 | 72/73 | 720K | 6.9K |
| 8 | linear | 1 | 50 | 59/60 | 590K | 7.3K |
| 8 | linear | 2 | 50 | 60/61 | 610K | 7.2K |
| 8 | quadratic | 0 | 50 | 55/56 | 560K | 9.3K |
| 8 | quadratic | 1 | 50 | 56/57 | 560K | 9.7K |
| 8 | quadratic | 2 | 50 | 56/57 | 570K | 10K |
Table S10. Recorded EELS workloads with the legacy sampler. Iterations are completed/started outer iterations; the last started iteration may be interrupted. All generated draws counted here are feasible. Novelty excludes the initial observations.
All experiments ran locally on an Intel Core i5-10210U (four physical cores, eight logical processors, approximately 8 GB RAM), Windows 11, with each process pinned to logical CPU 0 and BLAS restricted to one thread. OhMyU1 uses Julia 1.12.5 with one thread; PROTES uses Python 3.12.14, NumPy 1.26.4, JAX 0.4.38 (CPU/x64), and Optax 0.2.4. The upstream revision is 06d447845dd26ffccb8e95c7545fa1d2617940e. The scripts, compact results, hashes, and Julia plotting code accompany the notebook examples/PROTES_assignment_scaling.ipynb.
| Objective | Budget (s) | Iterations | Draws | New points | ||
| 4 | linear | 0 | 5 | 90/91 | 900K | 0 |
| 4 | quadratic | 0 | 5 | 74/74 | 740K | 0 |
| 5 | linear | 0 | 5 | 42/43 | 430K | 6 |
| 5 | quadratic | 0 | 5 | 43/44 | 440K | 3 |
| 6 | linear | 0 | 5 | 18/19 | 180K | 418 |
| 6 | quadratic | 0 | 5 | 20/21 | 210K | 406 |
| 7 | linear | 0 | 5 | 10/11 | 110K | 3K |
| 7 | quadratic | 0 | 5 | 9/10 | 91K | 3.4K |
| 8 | linear | 0 | 5 | 6/7 | 65K | 6.5K |
| 8 | quadratic | 0 | 5 | 5/6 | 50K | 7.7K |
| 9 | linear | 0 | 5 | 3/4 | 30K | 7.9K |
| 9 | quadratic | 0 | 5 | 2/3 | 29K | 11K |
| 10 | linear | 0 | 5 | 1/2 | 15K | 7.7K |
| 10 | quadratic | 0 | 5 | 1/2 | 13K | 8K |
| 8 | linear | 0 | 50 | 73/74 | 730K | 6.9K |
| 8 | linear | 1 | 50 | 66/67 | 660K | 7.3K |
| 8 | linear | 2 | 50 | 61/62 | 620K | 7.2K |
| 8 | quadratic | 0 | 50 | 58/59 | 580K | 9.4K |
| 8 | quadratic | 1 | 50 | 51/52 | 510K | 9.6K |
| 8 | quadratic | 2 | 50 | 56/57 | 570K | 10K |
Table S11. Table S11. EELS workloads with the table sampler under the same inputs and budgets as the legacy runs. Iterations are completed/started; novelty excludes initial observations. All counted draws are feasible.
| Configuration | Generated draws (range) |
| default | 34K–390K |
| rank20 | 54K–140K |
| slow10 | 28K–260K |
| batch400 | 78K–470K |
| fit20 | 120K–340K |
Table S12. Table S12. PROTES 5-second screen: workload ranges over the 14 size/objective pairs per configuration. Each pair uses one seed. Exact per-instance counts and times are stored in the results snapshot.
References
- [1]Affleck, I., Kennedy, T., Lieb, E. H., and Tasaki, H. Rigorous results on valence-bond ground states in antiferromagnets. Physical review letters, 59(7):799, 1987.
- [2]Alcazar, J., Ghazi Vakili, M., Kalayci, C. B., and Perdomo-Ortiz, A. Enhancing combinatorial optimization with classical and quantum generative models. Nature Communications, 15(1):2761, 2024.
- [3]Antil, H., Dolgov, S., and Onwunta, A. Trisk: Tensor train decomposition algorithm for risk averse optimization. Numerical Linear Algebra with Applications, 30(3):e2481, 2023.arxiv.org/abs/2111.05180
- [4]Arenstein, L. and Kastoryano, M. Full grid solution for multi-asset options pricing with tensor networks. arXiv preprint arXiv:2601.00009, 2025.arxiv.org/abs/2601.00009
- [5]Batsheva, A., Chertkov, A., Ryzhakov, G., and Oseledets, I. PROTES: probabilistic optimization with tensor sampling. Advances in Neural Information Processing Systems, 36: 808–823, 2023.arxiv.org/abs/2301.12162
- [6]Biere, A., van Maaren, H., and Walsh, T. Handbook of satisfiability. SAGE Publications Limited, 2009.
- [7]Dolgov, S. and Savostyanov, D. Parallel cross interpolation for high-precision calculation of high-dimensional integrals. Computer Physics Communications, 246:106869, 2020.DOI
- [8]Farhi, E., Goldstone, J., and Gutmann, S. A quantum approximate optimization algorithm. arXiv preprint arXiv:1411.4028, 2014.arxiv.org/abs/1411.4028
- [9]Fishman, M., White, S. R., and Stoudenmire, E. M. The ITensor software library for tensor network calculations. SciPost Phys. Codebases, pp. 4, 2022. doi: 10.21468/SciPostPhysCodeb.4.DOI
- [10]Iudin, S. OhMyUI: Repository for the paper "exploration-exploitation generative framework for constrained combinatorial optimization with tensor-trains", 2026. URL https://github.com/antientropic-guy/OhMyUI_public.
- [11]Iudin, S., Veshchezerova, M., Tsarova, K., Tadumadze, G., Shete, V., Hao, J.-K., and Perelshtein, M. A parameter-guided two-stage heuristic for liquefied natural gas transportation and trading over long-term horizons. Algorithms, 19(10):822, 2026. doi: 10.3390/a19100822. URL https://www.mdpi.com/1999-4893/19/10/822.DOI
- [12]Jones, D. R., Schonlau, M., and Welch, W. J. Efficient global optimization of expensive black-box functions. Journal of Global optimization, 13(4):455–492, 1998.DOI
- [13]Kirkpatrick, S., Gelatt Jr, C. D., and Vecchi, M. P. Optimization by simulated annealing. science, 220(4598):671–680, 1983.
- [14]Koopmans, T. C. and Beckmann, M. Assignment problems and the location of economic activities. Econometrica: journal of the Econometric Society, pp. 53–76, 1957.DOI
- [15]Lopez-Piqueres, J. Constraintnet.jl: Repository for the paper “cons-training tensor networks”, 2024. URL https://github.com/JaviLioPiq/ConstraintNet.jl.
- [16]Lopez-Piqueres, J. and Chen, J. Cons-training tensor networks: Embedding and optimization over discrete linear constraints. SciPost Phys., 18:192, 2025.
- [17]Lopez-Piqueres, J., Chen, J., and Perdomo-Ortiz, A. Symmetric tensor networks for generative modeling and constrained combinatorial optimization. Machine Learning: Science and Technology, 4(3):035009, 2023.
- [18]Mugel, S., Kuchkovsky, C., Sánchez, E., Fernández-Lorenzo, S., Luis-Hita, J., Lizaso, E., and Orús, R. Dynamic portfolio optimization with real datasets using quantum processors and quantum-inspired tensor networks. Physical Review Research, 4(1):013006, 2022.DOI
- [19]Nakada, H., Tanahashi, K., and Tanaka, S. Quick design of feasible tensor networks for constrained combinatorial optimization. Quantum, 9:1799, 2025.DOI
- [20]Novikov, A., Podoprikhin, D., Osokin, A., and Vetrov, D. Tensorizing neural networks. In Proceedings of the 29th International Conference on Neural Information Processing Systems - Volume 1, pp. 442–450, Cambridge, MA, USA, 2015. MIT Press.arxiv.org/abs/1509.06569
- [21]Oseledets, I. V. Tensor-train decomposition. SIAM Journal on Scientific Computing, 33(5):2295–2317, 2011.DOI
- [22]Ryzhakov, G. and Oseledets, I. Constructive tt-representation of the tensors given as index interaction functions with applications. In International Conference on Learning Representations (ICLR), 2023. URL https://openreview.net/forum?id=yLzLmF-Esnu.arxiv.org/abs/2206.03832
- [23]Sozykin, K., Chertkov, A., Schutski, R., Phan, A.-H., Cichocki, A. S., and Oseledets, I. TTOpt: A maximum volume quantized tensor train-based optimization and its application to reinforcement learning. Advances in neural information processing systems, 35:26052–26065, 2022.arxiv.org/abs/2205.00293
- [24]Sozykin, K., Rybin, N., Chertkov, A., Phan, A.-H., Oseledets, I., Shapeev, A., Novikov, I., and Ryzhakov, G. Global optimization of atomic clusters via physically-constrained tensor train decomposition. arXiv preprint arXiv:2601.18592, 2026.arxiv.org/abs/2601.18592
- [25]Sulimov, A. V., Zheltkov, D. A., Oferkin, I. V., Kutov, D. C., Katkova, E. V., Tyrtyshnikov, E. E., and Sulimov, V. B. Evaluation of the novel algorithm of flexible ligand docking with moveable target-protein atoms. Computational and Structural Biotechnology Journal, 15:275–285, 2017.DOI
- [26]White, S. R. Density matrix formulation for quantum renormalization groups. Physical review letters, 69(19):2863, 1992.pubmed.ncbi.nlm.nih.gov/10046608
- [27]Yang, Y., Zhou, J., Wong, N., and Zhang, Z. Loretta: Low-rank economic tensor-train adaptation for ultra-low-parameter fine-tuning of large language models. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pp. 3161–3176, 2024.
- [28]Zheltkov, D. A. and Osinsky, A. Global optimization algorithms using tensor trains. In International Conference on Large-Scale Scientific Computing, pp. 197–202. Springer, 2019.DOI




















