Preprint
Technical Note

This version is not peer-reviewed.

Round Complexity of Iterated Prefix-Counting Programs—Tight Bounds for Multiplication and Montgomery Reduction

Submitted:

12 October 2026

Posted:

14 October 2026

You are already at the latest version

Abstract
We investigate the round complexity of deterministic sequence programs with a fixed finite state per position, pointwise operations, prefix counts, and fixed-radius backward Boolean lookups. We establish a cut-capacity inequality: the number of distinct rows of the communication matrix for any admissible right-side output is at most the product of the per-round cut-message alphabets. We then determine exact row counts for binary multiplication and for two precisely specified versions of Montgomery reduction. For bounded-support counting, these lower bounds imply linear round complexity. Explicit, uniform constructions attain linear upper bounds using a constant-size step with support-one counters for multiplication and lazy Montgomery reduction, and a fixed four-phase public schedule for canonical reduction. We give exact encoding contracts, distinguish one-way cut information from ordinary circuit depth, and describe computational verification of finite instances. The theorem concerns a defined symbolic model and does not assert a lower bound for arbitrary softmax transformers.
Keywords: 
;  ;  ;  ;  ;  

1. Introduction

A compiler from arithmetic algorithms to sequence-processing or transformer-like machines changes the distribution of computational cost. An instruction that looks constant-time under a word-arithmetic abstraction may become a sequence of local operations, while a richer communication primitive can exchange more information per step. Consequently, counting rounds alone is meaningful only relative to an explicit communication budget per round.
This note studies one precisely delimited class: iterated prefix-counting programs with local backward lookups. Within this class, a cut between positions has a bounded message alphabet that can be characterized from the syntax of a step and invariants of its reachable states. The accumulated message capacity gives lower bounds on the number of iterations needed for exact arithmetic under a specified input/output placement.
Our contributions are as follows. First, we prove a product bound on the number of communication-matrix rows for public sequences of program steps. Second, we derive exact row counts for multiplication and Montgomery reduction, including a distinction between lazy and canonical reduction when the modulus resides on the left side of the cut. Third, we give uniform linear-time constructions and explicit support invariants. These are statements about the model defined below, not about arbitrary trained neural networks.
The cut-simulation technique itself has antecedents in the transformer and communication-complexity literature, particularly Huang et al. [1]. The intended contribution here is the support-sensitive capacity bound across iterations, its exact arithmetic instantiations, and matching program witnesses under one encoding contract. We do not assert priority for the general idea of cut communication.

2. Program Model and Resource Contract

For each input length choose a tape of positions 0,…,L − 1 and a cut p separating Alice’s positions 0,…,p − 1 from Bob’s positions p,…,L − 1. Tape length, cut position, position masks, output locations, and any phase budgets are public functions of the input length, independent of the private input values.
Definition 2.1 (Step language). A state is a word s ∈ ΣL over a fixed finite alphabet. A step P consists of a finite acyclic sequence of register definitions evaluated at each position. Permitted operations are letter tests; public position predicates; Boolean connectives; pointwise integer constants, addition, subtraction, minimum, maximum, comparisons and conditionals; and the two primitives
Count B i = ∑ 0 ≤ j ≤ i B j ,     Prev B , d i = B i − d ,   d ≥ 1 .
Here B is Boolean; positions with negative indices return false; and the backward distance d is an instruction constant. The output symbol at each position is a fixed function of its Boolean registers. Integer-valued registers are intermediate values within a step and are not arbitrary-precision state cells carried freely between steps. A constant number of Boolean tracks per position is equivalent to a single fixed finite alphabet.
We call this an iterated prefix-counting program with local backward lookups. It is C-RASP-like, but its operative definition is the one above. We do not identify it with the unrestricted transformer model. Connections between counting logics and specific transformer models are explored in [1,2].
Definition 2.2 (Public rounds and cut-respecting encoding). Fix a Cartesian rectangle XA × XB of valid inputs and maps EA,EB,DB satisfying
s A 0 = E A x A ,     s B 0 = E B x B ,     f B x A , x B = D B ​ s B R .
Here subscripts A and B indicate the respective left and right tape segments. A public sequence P0,…,PR−1 updates s(t+1) = Pt(s(t)). The sequence, including phase changes and its length, may depend on input length but not on private input values. Input-dependent precomputed advice must not be placed on the opposite side of the cut. Bob’s decoder accesses only his final state and public parameters. Early termination may be padded with genuine absorbing states, never with a free input-dependent external stop signal.
Definition 2.3 (Counting support and cut capacity). A counting instruction c = CountBhas support bound kc if the predicate B holds at no more than kc positions in every relevant reachable state, including its within-step intermediate registers. Put kc = ∞ if no sharper bound is established. If D(P) is the sum of the backward distances of all local lookups in the definition graph of P, set
M p P = 2 D P ∏ c ∈ Count P min p , k c + 1 ,     μ p P = log 2 M p P .
This is an upper bound on the size of a descriptor alphabet, not a statement that a message has a fractional optimal bit length. Dependence among descriptor components can make the real alphabet smaller. For the asymptotic bounded-capacity class, the alphabet, the finite repertoire of steps, the number of counts and lookup distances, and the support bounds are uniform constants independent of n. Public masks and tape lengths may vary with n; no private values may be encoded in those masks.

3. Cut Simulation and the Product Theorem

Lemma 3.1 (Causality). For each within-step register v and tape position i, the value v(s)(i) depends only on s0,…,si and public parameters. In particular, the next left state depends only on the current left state.
Proof. Induct simultaneously over register definitions and positions. Pointwise operations preserve the property. A prefix count at i aggregates predicates only at j ≤ i, and each predicate at j depends on positions at most j. A backward lookup refers to a strictly earlier position or to a fixed out-of-range value. The symbol decoder is pointwise. □
For a step P, let mp(s) be the tuple containing CountB(p − 1) for every count instruction and, for each backward lookup of distance d, the Boolean values B(p − d),…,B(p − 1). Entries at negative positions are false.
Lemma 3.2 (Right-side reconstruction). The descriptor mp(s) depends only on the left state, has at most Mp(P) distinct values over relevant reachable states, and, together with the right state, determines all right-side intermediate registers and the next right state.
Proof. Causality proves left dependence. Each count contributes an integer in {0,…,min(p,kc)}; lookup boundary windows contribute at most D(P) Boolean bits in total. Counting all combinations gives (1). Reconstruct intermediate registers in their definition order, simultaneously over the positions i ≥ p. For a count, write
Count B i = Count B p − 1 + ∑ p ≤ j ≤ i B j .
The first summand comes from the descriptor, and the second from already reconstructed right predicates. A backward lookup reads either a reconstructed right value, a supplied left boundary value, or a fixed false value. Pointwise operations complete the induction, including nested counting and lookups. □
Definition 3.3 (Row information). Let Np(f) denote the number of distinct maps xB ↦ fB(xA,xB) as xA varies over XA. Write Ip(f) = log2Np(f). This is the logarithm of the number of communication-matrix rows, not matrix rank or Shannon entropy. Deterministic one-way communication with fixed-length binary messages needs ⌈Ip(f)⌉ bits for this rectangle.
Theorem 3.4 (Accumulated cut-capacity bound). Every public sequence of R steps satisfying Definition 2.2 obeys
N p f ≤ ∏ t = 0 R − 1 M p P t ,     I p f ≤ ∑ t = 0 R − 1 μ p P t .
For a repeated step P, this reduces to Rμp(P) ≥ Ip(f).
Proof. Alice simulates her own state sequence using xA alone (Lemma 3.1), so the entire descriptor sequence is a function of xA. Bob begins with EB(xB) and reconstructs each successive right state from his preceding state and the next descriptor (Lemma 3.2). Thus identical descriptor sequences for two left inputs produce identical output for every xB and hence identical rows. The number of descriptor sequences is at most the product of their alphabet sizes. Taking binary logarithms yields (3). □
Corollary 3.5 (Round lower bounds). If every step has at most K counts, total lookup radius at most D, and count supports at most k, then
R ≥ I p f K log 2 k + 1 + D .
Without a bounded-support assumption, replace k with p. In particular, if Ip(f) = Ω(n) and p(n) is polynomially bounded, arbitrary counts yield R = Ω(n/logn) under a fixed step-size budget, whereas uniformly bounded-support counts yield R = Ω(n). If the denominator is zero and the information is positive, the required computation cannot be carried out in the indicated class.
The invariant measured by (3) is total capacity over the cut across rounds. The theorem alone does not lower-bound rounds when the program is allowed to increase the number of instructions, support, or lookup radius without accounting for that increase.

4. Exact Row Information for Arithmetic

4.1. Fixed-Width Binary Multiplication

Let a,b ∈ {0,…,2n − 1} for n ≥ 2, allowing leading zero bits. Use least-significant-bit-first tracks and set c = n − 1, H = 2c,
a = aL + HaH,  b = bL + HbH.
Alice holds (aL,bL) ∈ {0,…,H − 1}2 and Bob holds (aH,bH) ∈ {0,1}2. The right output must determine F=⌊ab/H⌋, for instance by holding the product bits of weight at least c.
Proposition 4.1. On this rectangle, Nc(MULT) = H2 = 22n−2 and Ic(MULT) = 2n − 2.
Proof. We have
F a H , b H = ⌊ a L b L H ⌋ + a L b H + a H b L + H a H b H .
Hence aL = F(0,1) − F(0,0) and bL = F(1,0) − F(0,0). Each pair (aL,bL) generates a distinct row and there are only H2 such pairs. □
This argument needs fixed-width numbers with leading zeros permitted: requiring both top bits to be one would invalidate the selected rectangle.

4.2. Lazy and Canonical Montgomery Functions

Let B = 2n, let 1 < N < B be odd, and let 0 ≤ T < NB. Define
q = − T N − 1   mod   B ,   u lazy = T + qN B ,   u can = u lazy , u lazy < N , u lazy − N , u lazy ≥ N .
The numerator is divisible by B, and
0 ≤ ulazy < 2N,  0 ≤ ucan < N,  ucan≡TB−1 (mod N).
The term lazy refers to this precise integer, not an arbitrary representative congruent to it. A frequently assumed bound ulazy ≤ N is false on the full domain: N = 3, B = 4, T = 11 gives q = 3 and ulazy = 5. The stronger bound holds for T < B.
Proposition 4.2 (Fixed modulus, fixed high input). Fix odd N and take TH = 0, T = TL ∈ {0,…,B − 1}. Then
{ucan(TL)} = {0,…,N − 1},  {ulazy(TL)} = {0,…,N}.
Proof. Multiplication by B−1 permutes residues modulo odd N, and TL = 0,…,N − 1 already reaches all canonical residues. The map TL ↦ q permutes {0,…,B − 1} and implies ulazy=⌈qN/B⌉. As q increases from zero to B − 1, this monotone sequence begins at zero, ends at N, and changes by at most one, because N < B. It thus reaches every integer in {0,…,N}. □

4.3. Variable Modulus and an Exact Separation

Set H = 2n−1, B = 2H and choose the rectangle
XA = {(N,TL):N ∈ {H + 1,H + 3,…,2H − 1}, 0 ≤ TL < B},
XB = {h:0 ≤ h < H},  T = TL + Bh.
Alice holds the variable odd modulus N and the low input bits TL; Bob holds h = TH and must receive the entire result. This is a valid Cartesian rectangle, since T < BH < BN for every permitted modulus. The modulus is not public in this comparison.
Proposition 4.3 (Exact Montgomery row counts).On (7)-(8),
N p REDC can = H H + 1 2 = 2 2 n − 3 + 2 n − 2 ,     N p REDC lazy = B = 2 n .
Consequently the respective row-information values are 2n − 3 + log2(1 + 21−n) and n.
Proof. For each fixed N, let r = TLB−1 mod N; all values 0 ≤ r < N occur. The canonical row is
gN,r(h) = (r + h) mod N,  0 ≤ h < H.
As H < N, a row wraps around the modulus at most once. The no-wrap rows have r ≤ N − H and are the increasing sequences (r,r + 1,…,r + H − 1). Across the permitted moduli, they realize exactly r = 0,…,H − 1, yielding H different rows. For any particular modulus, the wrapping rows have r = N − H + 1,…,N − 1, giving H − 1 rows. Their first value reveals r, while the first wrap position hwrap = N − r reveals N = r + hwrap. Therefore different wrapping pairs (N,r) give different rows, none coinciding with a no-wrap row. There are H/2 moduli and hence H + (H/2)(H − 1) = H(H + 1)/2 canonical rows.
For lazy reduction, q depends only on TL, so the row has the form h ↦ h + u0, with u0 = ulazy(TL). Proposition 4.2 gives 0 ≤ u0 ≤ N. Choosing N = B − 1 realizes every u0 = 0,…,B − 1, and no other value can occur. Thus there are exactly B lazy rows. □
The distinction between the two contracts is an information-placement effect. It does not mean that canonical REDC takes twice the time of lazy REDC on every machine. In particular, the result changes when the modulus is publicly known to Bob.

5. Explicit Uniform Linear-Round Constructions

All registers on the right side of an update are read from the old state; tracks not mentioned remain unchanged. For any Boolean track A, write σA(i) = A(i − 1) and Seen A i = 1 { Count A i > 0 } . Let Maj(A,B,C) = (A∧B)∨(A∧C)∨(B∧C). XOR denotes a fixed Boolean formula. Public zone masks have no operand-dependent contents. The analytical quantity val A = ∑ i A i 2 i is not a run-time instruction.

5.1. Carry-Save Identity and Normalization

Lemma 5.1 (Value preservation). The pointwise update
S' = S⊕C⊕X,  C' = σMaj(S,C,X)
satisfies val(S') + val(C') = val(S) + val(C) + val(X) if no carry is truncated at the right boundary. When X = 0, all carry bits vanish after at most L iterations on a tape of length L, after which the state is fixed.
Proof. The Boolean identity s + c + x = (s⊕c⊕x) + 2Maj(s,c,x) holds in every bit position. Sum it with weights 2i. With X = 0, the carry recurrence becomes C' = σ(S∧C), so the smallest possible position of a nonzero carry strictly increases each round. It disappears after at most L rounds. The truncated version preserves value modulo 2L. □

5.2. Multiplication in 3n + 2 Rounds

Use L = 2n + 2 positions and initialize the binary tracks A = a, BM = b, S = C = 0, marker M = e0, and the public mask Zlo = {0,…,n − 1}. All numbers are stored least-significant-bit first. Define one constant-size step:
𝓁 = Seen(M), q = Seen(M∧A), X = q∧BM,
S' = S⊕C⊕X,  C' = σMaj(S,C,X).
BM' = (σBM∧𝓁)∨(BM∧¬𝓁),  M' = σM∧Zlo.
Proposition 5.2. Iterating (11) for n + L = 3n + 2 rounds yields val(S) = ab and C = 0, followed by a fixed point. Both counted predicates have support at most one; K = 2, D = 3, so μp ≤ 5 for every cut.
Proof. Before active round t < n, marker M = et, val(BM) = b2t and BM has no support below t. The predicate q is therefore equal to the bit at wherever BM can be nonzero. Induction with Lemma 5.1 gives
val(St) + val(Ct) = b(a mod 2t),  0 ≤ t ≤ n.
The accumulated value is less than 22n < 2L, so carries are never truncated. After round n, the marker vanishes and BM is frozen. A further L carry-normalization rounds yield ab. The two counted predicates, M and M∧A, have support at most one on all reachable states, by the marker invariant. The three unit-distance lookups are shifts of the majority result, BM, and M. The product bits at positions 0,…,2n − 1 satisfy the cut/output placement of Proposition 4.1. □

5.3. Lazy Montgomery in 3n + 2 Rounds

Initialize S = T, C = 0, NM = N, M = e0, and Zlo = {0,…,n − 1}. Define
𝓁 = Seen(M), q = Seen(M∧(S⊕C)), X = q∧NM,
S' = S⊕C⊕X,  C' = σMaj(S,C,X).
NM' = (σNM∧𝓁)∨(NM∧¬𝓁),  M' = σM∧Zlo.
Lemma 5.3 (Montgomery injection invariant). After t active rounds, for 0 ≤ t ≤ n, there is an integer Qt ∈ {0,…,2t − 1} with
val(St) + val(Ct) = T + NQt, St(i) = Ct(i) = 0 for i < t, val(NM,t) = N2t.
For t < n the marker is et. At t = n the marker vanishes, Qn = (−TN−1) mod 2n, and NM freezes at N2n.
Proof. At t = 0, take Q0 = 0. Suppose (13) holds before round t < n. The shifted odd modulus NM has no set bits below t and has its bit at t equal to one. Write qt = St(t)⊕Ct(t). The prefix predicate q equals qt throughout the support of NM, adding precisely qtN2t. At bit t, the next sum bit is St(t)⊕Ct(t)⊕qt = 0, and the carry bit is zero because there was no carry from the previous lower position. Smaller bits stay zero. Thus Qt+1 = Qt + qt2t, while marker shift gives the next modulus position. The quantity T + NQt < 2N2n < 22n+1 fits in 2n + 2 bits. At t = n, the sum is divisible by 2n, so uniqueness of the residue modulo 2n gives Qn = (−TN−1) mod 2n. With M = 0, injection stops and the modulus freezes. □
Proposition 5.4. On L = 2n + 2 positions, 3n + 2 rounds of (12) yield C = 0 and the exact ulazy in S at positions n,…,2n. Both counted predicates are marker-supported, K = 2, D = 3, and kc = 1.
Proof. Apply Lemma 5.3 for n injections and Lemma 5.1 for the remaining L normalization rounds. Then val(S) = 2nulazy. Since ulazy < 2N < 2n+1, the output fits the stated positions. For cut p = n, N and TL reside left, TH resides right, and no inverse or input-dependent advice is supplied to Bob. □

5.4. Canonical Montgomery in 6n + 8 Publicly Scheduled Rounds

Set W = n + 2, o = 2n + 2, and L = 3n + 2. Add zero-initialized tracks S1,C1,OUT, public zone Z = {n,…,n + W − 1}, sign marker G = en+W−1, and scan markers MB = en, MC = eo. All masks and markers are operand-independent.
Phase 1: injection and carry normalization. Run (12) for n + L = 4n + 2 rounds. At the end, C = 0, val(S) = 2nulazy, and val(NM) = 2nN. The modulus has reached the middle zone through the program itself.
Phase 2: subtraction candidate. For one round define
F = Z∧¬σZ,  S1' = (S⊕¬NM)∧Z,
C1' = (σ(S∧¬NM∧Z)∧Z)∨F.
The injected low one in F does not overlap a shifted carry at the lowest zone position. Relative to the base of the zone, the sum has the value ulazy − N (mod 2W).
Phase 3: subtraction normalization. For W rounds update
S1' = S1⊕C1,  C1' = σ(S1∧C1)∧Z.
After these rounds C1 = 0 and S1 encodes v = (ulazy − N) mod 2W. Because −N ≤ ulazy − N < N and N < 2n < 2W−1, the bit at sign marker G is an exact test of ulazy < N.
Phase 4: select and write to the right. For W + 1 rounds define
e = Seen(G∧S1), a = Seen(MB∧S), b = Seen(MB∧S1), z = (e∧a)∨(¬e∧b),
OUT' = (OUT∧¬MC)∨(MC∧z).
MB' = σMB∧Z,  MC' = σMC.
The sign test is performed before selecting the output in the region {o,…,o + n − 1}, strictly to the right of the sign marker. No forbidden backward transmission is needed.
Proposition 5.5 (Canonical upper bound). These four public phases compute ucan exactly in 6n + 8 rounds. The result occupies the n positions beginning at o. Each phase has constant program size; all counted predicates have support at most one in every reachable state; all phases reach fixed points at their publicly specified budget endpoints.
Proof. Phase 1 follows from Lemmas 5.1 and 5.3. Phase 2 implements the two’s-complement difference within W bits, and Phase 3 normalizes its carry representation. Phase 4’s marker MB traverses the source zone while MC traverses the output zone. At the rth scan step, a and b reproduce the rth bits of ulazy and v; e selects the former precisely when the difference is negative and the latter otherwise. Induction over r proves all n result bits are correct. The result is less than N < 2n and fits the output. The counting supports in Phase 1 are M and a subpredicate thereof; those in Phase 4 are subpredicates of the single sign marker and single scan marker. The remaining phases use no counts. The marker shift/mask recurrences keep these supports at most one for every n. The first phase normalizes carries, Phase 2 leaves its read-only source tracks unchanged and is idempotent, Phase 3 reaches C1 = 0, and Phase 4 exhausts its scan markers. The total number of rounds is
(4n + 2) + 1 + (n + 2) + (n + 3) = 6n + 8.
The initial right state at cut p = n contains only TH, public masks/markers, and zeros, with no right-side modulus-dependent advice. □
Table 1. Per-phase resource contract for the canonical witness. The accumulated upper-capacity budget is 26n + 29; a weaker bound using the maximum per-round capacity gives 5(6n + 8).
Table 1. Per-phase resource contract for the canonical witness. The accumulated upper-capacity budget is 26n + 29; a weaker bound using the maximum per-round capacity gives 5(6n + 8).
Phase Public rounds CountsK Lookup radiusD Capacityμp ≤ K + D
Injection and normalization 4n + 2 2 3 5
Subtraction candidate 1 0 2 2
Carry normalization n + 2 0 1 1
Output scan n + 3 3 2 5

6. Tight Round Order and an Extension to Global Counts

Theorem 6.1 (Linear round order). For the exact cut-respecting binary input/output contracts specified above, every uniform bounded-cut-capacity family computing multiplication, lazy Montgomery reduction, or canonical Montgomery reduction uses Ω(n) rounds. In the same model there are uniform constructions with at most 3n + 2, 3n + 2, and 6n + 8 rounds, respectively, the last with four publicly scheduled phases. The optimal asymptotic round order within the specified model is therefore Θ(n).
Proof. Apply Theorem 3.4 to Propositions 4.1 and 4.3 for the lower bounds, using capacity bounded uniformly with respect to n. Propositions 5.2, 5.4 and 5.5 give the corresponding upper bounds under the same input/output placements. □
The implicit constant in the lower bound depends on the allowed program-family capacity constant. The conclusion does not apply unchanged if instruction count, word size, lookup range, or other bandwidth may grow without being charged. The canonical upper bound uses public phase control; an autonomous single-step simulation of those phases is not established here.
Proposition 6.2 (Fixed right input with global counts). Suppose global counts GlobalCount B = ∑ j = 0 L − 1 B j are also permitted, still with a bounded left contribution and fixed program description. For each fixed xB = b0,
card { f B x A , b 0 : x A ∈ X A } ≤ ∏ t = 0 R − 1 M p A → B P t ,
where M p A → B counts possible left contributions to counts and boundary-window values, not the full global sums.
Proof. For fixed b0, Bob can reconstruct each right-side register from his known right state and successive transmitted left partial sums. In a global count the remaining term is exactly the right partial sum reconstructed from his registers. This induction works in definition order, even if the left descriptor in subsequent steps depends on Bob’s state. Hence two computations with the same left-to-right descriptor sequence yield the same right output for the fixed b0, proving the cardinality bound. Such simulation may be interactive at intermediate stages; it does not imply the general distinct-row product bound. □
For multiplication, fix (aH,bH) = (1,0) and aL = 0 while varying bL, which produces H distinct right outputs. For canonical Montgomery, take TH = 0 and vary N,TL; there are B − 1 possible canonical outputs. The corresponding lazy image has B values. Thus the linear lower bound remains available with bounded-capacity global counts via this weaker fixed-right-input argument. The larger canonical row count in Proposition 4.3 does not transfer by the same reasoning.

7. Relation to Earlier Work and Limitations

The central assumption is that a count’s left-side contribution is a single query-independent value. General query-dependent softmax attention does not satisfy this descriptor contract. We therefore do not claim a universal depth lower bound for standard transformers, nor a statement about what a learned transformer will represent or generalize to.
Huang et al. [1], especially Theorem 12 and Appendix B.3, established related logarithmic cut-communication bounds for particular limit-transformer models under Periodic and Local conditions; they also discuss multiplication through a copying reduction. This note specializes the method to support-dependent capacities across iterated steps and determines exact arithmetic row counts with explicit upper witnesses. Yang and Chiang [2] establish a counting-logic/softmax-transformer connection that motivates, but does not automatically extend, the present model.
Chen, Peng and Wu [3] study other transformer lower bounds with layer, width, and precision parameters. Classic communication-round work [4] separates message rounds from message lengths. Our R counts program iterations, and in the causal case Alice could send all descriptors as one ordinary message. Thus our bound is a product of capacity per iteration, not a new generic round hierarchy. Hesse, Allender and Barrington [5] show division and iterated multiplication in uniform TC0; there is no contradiction, because constant-depth threshold circuits can use growing numbers of gates and wires across a cut. Montgomery’s original paper is [6].
Two additional constraints matter. First, O(n) rounds here is not O(n) total bit work: each round updates O(n) tape positions in parallel. Second, a lower bound for a specified encoder/decoder does not immediately transfer to a different representation, a more powerful addressing primitive, or a compiler that places input-dependent advice on both sides.

8. Verification, Provenance and Outlook

The companion verification code tests the arithmetic identities, the cut reconstruction property, the support-one marker invariants, and the explicit witnesses on finite input domains. These tests are valuable regression checks but cannot establish a universal theorem for all tape lengths. The asymptotic claims rely on the preceding mathematical induction arguments. The original project sources behind an earlier witness comparison were not all available, so the explicit witnesses in Section 5 are specified independently of those external imports.
A useful next direction is a compiler-level resource contract that charges every transformation for additional support, lookup range, precision, advice, and state memory. The cut-capacity product may then serve as an invariant that constrains tradeoffs between program rounds and communication bandwidth without pretending to characterize arbitrary softmax transformers.

Funding

No specific funding acknowledgement has been supplied for this manuscript; the author should update this statement before submission if applicable.

Data Availability Statement

Companion exact-integer verification scripts and finite-run reports are available in the associated research package. Insert a permanent public repository or archival DOI when the package is released.

Use of Artificial Intelligence

Generative AI tools assisted with language drafting, translation, exploratory mathematical checking for references, and preparation of code and publication files. Such tools are not authors. The named author is responsible for independently validating the claims, references, calculations, code and compliance with the submission platform’s AI policy prior to public release.

Conflicts of Interest

The author should review and complete the competing-interest declaration prior to posting.

Review status

Not peer reviewed; not proof-assistant-verified. External expert review is recommended before posting.

References

  1. Huang, X.; Yang, A.; Bhattamishra, S.; Sarrof, Y.; Krebs, A.; Zhou, H.; Nakkiran, P.; Hahn, M. Formal Framework for Understanding Length Generalization in Transformers. International Conference on Learning Representations. 2025. Available online: https://arxiv.org/abs/2410.02140.
  2. Yang, A.; Chiang, D. >Counting Like Transformers: Compiling Temporal Counting Logic Into Softmax Transformers. Conf. Lang. Model. 2024, arXiv:2404.04393. [Google Scholar]
  3. Chen, L.; Peng, B.; Wu, H. Theoretical Limitations of Multi-Layer Transformer . arXiv. 2024. Available online: https://arxiv.org/abs/2412.02975.
  4. Nisan, N.; Wigderson, A. Rounds in Communication Complexity Revisited . SIAM J. Comput. 1993, 22(1), 211–219. [Google Scholar] [CrossRef]
  5. Hesse, W.; Allender, E.; Barrington, D. A. M. Uniform Constant-Depth Threshold Circuits for Division and Iterated Multiplication . J. Comput. Syst. Sci. 2002, 65(4), 695–716. [Google Scholar] [CrossRef]
  6. Montgomery, P. L. Modular Multiplication Without Trial Division . Math. Comput. 1985, 44(170), 519–521. [Google Scholar] [CrossRef]
  7. Zhang, H. Chain-of-Thought and Compressed Looped Transformers: A Memory-Budget Separation . arXiv 2026, arXiv:2605.30757. [Google Scholar]
  8. Rizvi-Martel, M.; Bhattamishra, S.; Rabusseau, G.; Hahn, M. From Expressivity to Sample Complexity: Narrow Teachers for Transformers via C-RASP . arXiv. 2026. Available online: https://arxiv.org/abs/2607.11760.
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.