Mass-Shifting Enumeration Algorithm

• Mass-Shifting Enumeration Algorithm is a combinatorial method that organizes generation by shifting a seed pattern through a constrained state space, ensuring unique outputs through symmetry.
• It utilizes techniques such as cyclic star-transposition for binary strings, cardinality tuple adjustments in trinomial trees, and spiral operators on ℕ^d to encode structured transitions.
• The approach optimizes enumeration by reducing computational complexity through amortization and modular updates, outperforming naïve exhaustive methods.

Searching arXiv for the cited papers and related “mass-shifting” enumeration work. arXiv search query: "mass-shifting enumeration algorithm trinomial trees" Mass-shifting enumeration algorithm denotes, in the cited literature, a class of combinatorial generation procedures in which enumeration is organized by systematically shifting a base combinatorial pattern or by redistributing integer “mass” across a constrained state vector. Two explicit arXiv instantiations are a cyclic star-transposition Gray code for all binary strings of length $2(n+1)$ with $n+1$ ones, obtained by repeating a base flip-sequence under modular shifts (Merino et al., 2020), and the enumeration of unique path-equivalence classes in recombining trinomial trees, obtained by sliding mass through a cardinality tuple that encodes occupation counts (Torres et al., 3 Oct 2025). A related combinatorial mechanism is the family of spiral-shifting operators on $\mathbb N^d$, which produce a free and transitive action, a nontrivial self-bijection of $\mathbb N^d$, and rational generating functions (Huang et al., 2022).

1. Structural pattern and scope

The cited papers do not present a single universal formalism under one definition of “mass-shifting.” Rather, they exhibit several closely related constructions in which the enumeration order is induced by controlled displacement inside a highly structured state space. This suggests a common pattern: a seed object or seed tuple is chosen, a shift rule propagates it through a family of admissible states, and symmetry or commutativity guarantees that outputs are produced without repetition.

Setting	State representation	Shift mechanism
Star-transposition Gray code	Blocks $\alpha_i\in\{1,\dots,L\}^{\ell}$	$\alpha_i=\alpha_0+i\cdot s \pmod L$
Recombining trinomial trees	Cardinality tuple $\hat C(p)$	tickDownThenSweep within a stage; shiftWindowLeft between stages
Spiral shifting on $\mathbb N^d$	$x\in X=\mathbb N^d$, with ordered points $\Delta(x)$	Freeze the lowest $n+1$0 points and rotate the top $n+1$1 points one step forward along the spiral

In the Gray-code setting, the shift acts on swap positions and preserves the star-transposition form of each transition. In the trinomial-tree setting, the shift acts on occupation counts rather than on paths directly, so the algorithm enumerates exactly one representative per path-equivalence class. In the spiral-shifting setting, commuting operators act on $n+1$2 itself and induce unique factorization from a distinguished base point (Merino et al., 2020, Torres et al., 3 Oct 2025, Huang et al., 2022).

2. Star-transposition mass-shifting for balanced binary strings

The problem addressed by Merino–Mička–Mütze is to generate all binary strings of length $n+1$3 with exactly $n+1$4 many $n+1$5s and $n+1$6s in a single cyclic star-transposition Gray code, meaning that each successor is obtained by swapping the first bit with one later bit, and the last string returns to the first by the same rule. Equivalently, the construction yields a Hamilton cycle in the middle-levels subgraph of the $n+1$7-cube (Merino et al., 2020).

The key parameters are

$n+1$8

Knuth’s strengthened formulation requires a cyclic flip-sequence

$n+1$9

where each block $\mathbb N^d$0 has length $\mathbb N^d$1, and where the blocks satisfy

$\mathbb N^d$2

entry-wise for a shift $\mathbb N^d$3 with $\mathbb N^d$4. The main theorem states that for every $\mathbb N^d$5 and every such $\mathbb N^d$6, there exists a cyclic star-transposition Gray code of length $\mathbb N^d$7 with precisely this block-shift structure (Merino et al., 2020).

The construction proceeds in two steps. First, one omits the first bit, works on strings of length $\mathbb N^d$8, and builds a single base block $\mathbb N^d$9 that realizes a Hamilton cycle $\mathbb N^d$0 through the quotient graph of length-$\mathbb N^d$1 strings under rotation, the necklace graph. This block visits exactly one representative of each rotation-class of strings in levels $\mathbb N^d$2 of the $\mathbb N^d$3-cube and returns to a rotated copy of the start. Second, one mass-shifts that block by $\mathbb N^d$4: for $\mathbb N^d$5, set $\mathbb N^d$6, and concatenate the resulting blocks. Because $\mathbb N^d$7 and $\mathbb N^d$8 are coprime, those $\mathbb N^d$9 blocks align exactly once through each rotation of the necklace representatives, producing all $\alpha_i\in\{1,\dots,L\}^{\ell}$0 distinct strings (Merino et al., 2020).

At the bit-string level, the algorithm maintains the current string curr[L+1], the base block block[1..\ell], and the integers $\alpha_i\in\{1,\dots,L\}^{\ell}$1. Initialization computes $\alpha_i\in\{1,\dots,L\}^{\ell}$2, computes the base block array by the necklace-gluing construction, computes the shift $\alpha_i\in\{1,\dots,L\}^{\ell}$3, and, if necessary, applies $\alpha_i\in\{1,\dots,L\}^{\ell}$4 or $\alpha_i\in\{1,\dots,L\}^{\ell}$5 local “switch” operations to correct $\alpha_i\in\{1,\dots,L\}^{\ell}$6 so that $\alpha_i\in\{1,\dots,L\}^{\ell}$7. The generation loop then computes

$\alpha_i\in\{1,\dots,L\}^{\ell}$8

and performs the star transposition $\alpha_i\in\{1,\dots,L\}^{\ell}$9. Each swap costs $\alpha_i=\alpha_0+i\cdot s \pmod L$0; printing or processing each new length-$\alpha_i=\alpha_0+i\cdot s \pmod L$1 string costs $\alpha_i=\alpha_0+i\cdot s \pmod L$2. Initialization takes $\alpha_i=\alpha_0+i\cdot s \pmod L$3 time, and the total working memory is $\alpha_i=\alpha_0+i\cdot s \pmod L$4 when $\alpha_i=\alpha_0+i\cdot s \pmod L$5 is generated on the fly (Merino et al., 2020).

The correctness argument has four components: the base block defines a cycle in the necklace graph; coprimality of $\alpha_i=\alpha_0+i\cdot s \pmod L$6 ensures that the shifted blocks visit distinct rotations; star transpositions are preserved under constant addition modulo $\alpha_i=\alpha_0+i\cdot s \pmod L$7; and the total length is $\alpha_i=\alpha_0+i\cdot s \pmod L$8, so cyclic return to the start is automatic after $\alpha_i=\alpha_0+i\cdot s \pmod L$9 blocks. For the worked case $\hat C(p)$0, $\hat C(p)$1, one has $\hat C(p)$2, $\hat C(p)$3, $\hat C(p)$4, $\hat C(p)$5, and a valid base block is $\hat C(p)$6; after $\hat C(p)$7 swaps the cycle returns to $\hat C(p)$8, having generated all $\hat C(p)$9 distinct strings with three $\mathbb N^d$0s (Merino et al., 2020).

3. Mass-shifting for unique-path enumeration in recombining trinomial trees

In recombining trinomial trees, a depth-$\mathbb N^d$1 model naively gives $\mathbb N^d$2 trajectories. The 2025 construction exploits two symmetries under time-homogeneous dynamics: translational invariance of nodes and a canonical bijection between admissible paths and ordered tuples encoding weak compositions. The tree is the directed graph

$\mathbb N^d$3

Under translation in $\mathbb N^d$4, each local neighborhood looks identical; consequently, a path’s pattern of visits depends only on how often it visits each horizontal level, not on the order of those visits (Torres et al., 3 Oct 2025).

Fix a terminal position $\mathbb N^d$5. For a path $\mathbb N^d$6 with position-sequence $\mathbb N^d$7, define the occupation counts

$\mathbb N^d$8

and the cardinality tuple

$\mathbb N^d$9

where $x\in X=\mathbb N^d$0 and $x\in X=\mathbb N^d$1 are the minimum and maximum visited levels along a path to $x\in X=\mathbb N^d$2. By construction, $x\in X=\mathbb N^d$3; two paths satisfy $x\in X=\mathbb N^d$4 if and only if they differ only by a permutation of their visits; and each tuple indexes exactly one equivalence class of paths. If

$x\in X=\mathbb N^d$5

then $x\in X=\mathbb N^d$6 is exactly the number of equivalence classes of paths to $x\in X=\mathbb N^d$7 (Torres et al., 3 Oct 2025).

The counting problem is reduced to weak compositions of the total mass $x\in X=\mathbb N^d$8 into $x\in X=\mathbb N^d$9 slots with lower-bound constraints. A compact closed form is

$\Delta(x)$0

with

$\Delta(x)$1

The two binomial terms arise from the Pascal-identity split when one enforces lower bounds of “1” or “2” visits at certain levels (Torres et al., 3 Oct 2025).

The enumeration algorithm is staged. Stage $\Delta(x)$2 initializes a maximal cardinality tuple $\Delta(x)$3 with the largest possible counts pushed as far to the right as parity permits. Inside a fixed stage, the algorithm treats the current tuple as a reservoir of mass and marches in lexicographic order by “ticking down” one unit from the rightmost non-locked slot and then “sweeping” that unit left as far as allowed. When the inner loop exhausts its horizon, a stage shift removes a fixed number $\Delta(x)$4 from the current rightmost slot, prepends them as a new “1” at the left boundary, and retranslates the window one step left. The code-like description uses tickDownThenSweep(tuple, β) and shiftWindowLeft(s, β) to realize these updates (Torres et al., 3 Oct 2025).

The complexity analysis is asymptotic and output-sensitive with respect to equivalence classes rather than raw walks. For a stage $\Delta(x)$5, the number of tuples is bounded by a sum of binomial coefficients $\Delta(x)$6, where $\Delta(x)$7 and $\Delta(x)$8. Stirling/entropy bounds yield

$\Delta(x)$9

so the total running time becomes

$n+1$00

By contrast, naïve recursion visits all $n+1$01 walks in $n+1$02 time, and the ratio

$n+1$03

grows exponentially (Torres et al., 3 Oct 2025).

4. Spiral-shifting operators and enumeration on $n+1$04

A related but differently framed construction appears in the enumeration of finite-index submodules of $n+1$05. The combinatorial state space is

$n+1$06

For $n+1$07, define

$n+1$08

for $n+1$09. If

$n+1$10

denotes the ordering by increasing height, then the total-distance statistic is

$n+1$11

equivalently

$n+1$12

The associated operators $n+1$13 are defined in the point picture by freezing the lowest $n+1$14 points in height order and rotating the top $n+1$15 points one step forward along the spiral that wraps the cylinder $n+1$16. In particular,

$n+1$17

These operators satisfy

$n+1$18

for every $n+1$19 and $n+1$20 (Huang et al., 2022).

The central algebraic property is commutativity: $n+1$21 Hence the free abelian semigroup $n+1$22 acts on $n+1$23 by

$n+1$24

Moreover, this action is free and transitive on $n+1$25: starting from the base point $n+1$26, every $n+1$27 is reached by a unique $n+1$28 such that $n+1$29. Therefore $n+1$30 is a bijection $n+1$31, giving a nontrivial self-bijection on $n+1$32 (Huang et al., 2022).

This yields an immediate enumeration algorithm. Because $n+1$33 acts transitively, one may enumerate $n+1$34 through the unique factorization

$n+1$35

Equivalently, nested loops over $n+1$36 output every $n+1$37 exactly once, since the $n+1$38 commute and each multi-index appears exactly once. The same shift structure gives rational generating functions. If

$n+1$39

then for any finitely generated free subsemigroup $n+1$40 generated by $n+1$41,

$n+1$42

Specializing to $n+1$43 and $n+1$44 gives

$n+1$45

The paper explicitly states that these combinatorial structures are of independent interest (Huang et al., 2022).

5. Complexity, output models, and amortization

The computational profile of mass-shifting depends strongly on what is being enumerated. In the star-transposition Gray code, the outputs are all $n+1$46 bitstrings, and the generator achieves $n+1$47 work per swap together with $n+1$48 work per string output, after $n+1$49 initialization (Merino et al., 2020). In the trinomial-tree setting, the outputs are equivalence classes indexed by cardinality tuples rather than all raw walks, and the running time is $n+1$50, compared with naïve $n+1$51 traversal (Torres et al., 3 Oct 2025).

A separate but terminologically relevant line of work uses “traditional mass-shifting ideas in enumeration” to describe an amortization style rather than a state-update rule. In Push-Out Amortization, each recursive iteration $n+1$52 has local cost $n+1$53, child set $n+1$54, and leaf-cost bound

$n+1$55

The local Push-Out condition requires constants $n+1$56 and $n+1$57 such that

$n+1$58

If every inner iteration satisfies this inequality, then the amortized local cost per iteration is $n+1$59; in particular, $n+1$60 implies $n+1$61 time per iteration and hence per output (Uno, 2014).

The distinction drawn there is explicit. Traditional amortized mass-shifting analyses typically charge the cost of a “heavy” iteration only to its immediate children, and perhaps grandchildren, and rely on an enumeration-specific counting argument to show that the charges cancel when summed over the recursion tree. Push-Out instead allows an inner iteration to push all of its local cost, minus a small reserve, proportionally across all of its descendants, while requiring only a local lower bound on the sum of the direct children’s costs. The token movement is top-down and proportional to $n+1$62, which simplifies the inductive proof (Uno, 2014).

6. Interpretation, misconceptions, and research connections

A common misunderstanding is to treat mass-shifting as a synonym for exhaustive traversal of raw combinatorial objects. The cited literature shows two distinct behaviors. The Gray-code construction produces all $n+1$63 bitstrings of the target Hamming weight exactly once in cyclic star-transposition order, whereas the trinomial-tree construction produces exactly one representative per path-equivalence class via the cardinality tuple $n+1$64 (Merino et al., 2020, Torres et al., 3 Oct 2025). A plausible implication is that mass-shifting can function either as a generation order on the original objects or as a traversal of a symmetry-reduced quotient space.

A second source of confusion is terminological. The literature spans “mass-shifting,” “spiral shifting,” and “traditional mass-shifting ideas in enumeration.” These are not identical mechanisms. In the Gray-code paper, the shift is modular addition on blocks of swap positions. In the trinomial-tree paper, the shift redistributes integer mass through constrained bins. In the spiral-shifting paper, the shift acts on the ordered point set $n+1$65 and yields commuting operators on $n+1$66. In the amortization paper, mass-shifting denotes a charging argument on a recursion tree rather than a combinatorial iterator (Merino et al., 2020, Torres et al., 3 Oct 2025, Huang et al., 2022, Uno, 2014).

The broader combinatorial connections are explicit. The star-transposition construction resolves Knuth’s stronger form of the middle-levels conjecture in a more general form allowing arbitrary shifts $n+1$67 coprime to $n+1$68 (Merino et al., 2020). The trinomial-tree construction highlights structural links between its algorithmic/combinatorial framework and Motzkin paths with Narayana-type refinements, and raises open questions about multivariate coefficient extraction from known $n+1$69-fractions and about the relation between occupancy profiles and Narayana- or Fine-type peaks/returns refinements (Torres et al., 3 Oct 2025). The spiral-shifting construction connects shift operators, total-distance statistics, self-bijections of $n+1$70, and rational generating functions in a setting originally motivated by the enumeration of finite-index submodules of $n+1$71 (Huang et al., 2022).

Taken together, these results show that mass-shifting is not merely an implementation trick. In the cited work it serves as a mechanism for encoding symmetry, organizing state spaces, proving uniqueness of generation, and deriving closed-form or rational counting formulas.