Answer: \(\mathrm{NP}\)-hard even for \(m=1\) and \(\tau=4\). Exact schedule and utility computation are also \(\mathrm{NP}\)-hard. The decision problem is in \(\mathrm{PSPACE}\), and exact outputs can be computed in polynomial space and time \((K+1)\operatorname{poly}(m,\tau,L,\log(K+1))\).
Proposition 3.2 — class: algorithmic
PDF text-layer excerpt — equations and symbol order may be approximateRPA converges within 2|𝑆𝑃|2 · |𝑆|2 iterations.
statement extracted from the paper’s text layer; consult the paper for the exact wording
Given finite rational provider and requester type sets \(P\) and \(R\), skills \(S\), type-level compatibility, capacities, workloads, time slots, deadlines, bid orders, and complete current-state descriptors including residual capacity, clock, and ordered service history, does the deterministic mass-RPA process reach a fixed point within \(K\) rounds, and what mass schedule and utility result?
A society is given by its support: disjoint nonempty provider and requester type lists \(P,R\), each type with positive binary-rational mass \(a_p,b_r\). Let \(\tau=|P|+|R|\) and \(m=|S|\); masses need not sum to one. Types are pooled: capacities and demands are \(a_pc_{ps}\) and \(b_rd_{rs}\), and workload is divisible.
The input specifies compatible triples \((p,r,s)\), positive per-unit capacities, demands and processing rates \(v_{ps}\), finite lists of nonnegative rational admissible start times, positive rational deadlines \(D_{rs}\), and nonnegative rational travel times depending on the provider's last destination. Serving aggregate workload \(x\) takes time \(x/(a_pv_{ps})\). A provider pool performs services sequentially; each triple occurs at most once in its trial schedule.
Proposal-quality functions \(Q_{rs}(w,t)\), bid functions \(B_{rs}(t)\), and requester schedule-utility functions \(U_r\) are given as explicit rational piecewise-affine circuits; utilities and qualities are nonnegative on feasible inputs. Require \(B_{rs}(t)>B_{rs}(t')\) exactly when \(t<t'\) on admissible times. Fixed input orders break every tie. Global utility is \(\sum_{r\in R}b_rU_r(\sigma_r/b_r)\), where normalization divides workloads and concurrent provider masses, but leaves times unchanged.
The supplied current state contains proposals, requests, residual workloads, clocks, last destinations and ordered trial schedules. A proposal records a compatible triple, offered workload and earliest admissible start time after the provider's clock plus travel; omit zero-workload proposals and triples with no such time. Deadlines constrain completion.
One synchronous round first resets requester demands. For each requester-skill pair, process previous proposals in descending \(Q_{rs}(w,t)\); request \(x=\min\{w,\text{remaining demand}\}\) at the proposed time, with bid \(B_{rs}(t)\), subtracting \(x\) from demand. Omit requests whose completion would miss the deadline.
Next reset each provider's capacities, clock and trial schedule to their original capacities, zero and empty. Process the new requests in descending bid order: accept a request only if its workload fits, its earliest admissible start is at most its requested start, and completion at the requested start meets the deadline; otherwise stop processing that provider's requests immediately. An accepted request is scheduled at its requested start, updates residual capacity and clock, and receives a new proposal recording capacity immediately before acceptance and the earliest admissible start computed for it.
For every compatible triple not already proposed during this provider phase, propose its final residual capacity and earliest admissible start after the final trial schedule. These proposals and the new requests and schedules form the next state. Schedules are rebuilt each round rather than executed cumulatively. A fixed point means exact equality of the entire state after one round.
Given binary-encoded \(K\geq0\), is deciding whether this deterministic mass-RPA process reaches a fixed point within \(K\) rounds in \(\mathrm{P}\), or is it NP-hard? What is the complexity of computing its schedule and utility at the first fixed point, or after \(K\) rounds if none has occurred, with running times stated in \(m,\tau,L\) and \(\log(K+1)\), where \(L\) is the total input bit length?
Discrete RPA has a stated convergence bound of \(2n^2m^2\) iterations under earlier-start bid preference and the service-repeat restriction; this is an iteration bound, without a general binary-bit complexity guarantee for arbitrary utility functions. [Verified source](https://arxiv.org/pdf/2302.14507). No complexity result for the mass process specified here was identified.
The bounded-round fixed-point problem is \(\mathrm{NP}\)-hard, even with one skill, two provider types, two requester types, unit masses, and zero travel times.
Computing the requested schedule or its exact utility is also \(\mathrm{NP}\)-hard. Both tasks admit exact algorithms using polynomial space and time
\[ (K+1)\operatorname{poly}\!\left(m,\tau,L,\log(K+1)\right). \]
Thus a running time polynomial in \(m,\tau,L,\log(K+1)\) would imply \(\mathrm{P}=\mathrm{NP}\).
Below, I prove the reduction and the bit-complexity bounds. The bounds do not assert a matching completeness classification.
Let \(F\) denote the specified synchronous transition, and let \(s_j=F^j(s_0)\). I interpret “reaches a fixed point within \(K\) rounds” as asking whether \(F(s_j)=s_j\) for some \(0\leq j\leq K\).
The literal requester rule can produce zero-workload requests after demand is exhausted. I retain these requests. The reduction also works if zero requests are omitted: the only difference is the removal of a zero-workload service from its absorbing schedule.
All start-time lists in the construction are the same two-element list. Consequently, the proof does not require provider-specific admissible-time domains.
Start with a Boolean CNF formula \(\varphi\) on \(n\geq1\) variables. Put \(M=2^n\). Boolean CNF satisfiability is \(\mathrm{NP}\)-complete.
Define the rational piecewise-affine function
\[ \operatorname{clip}(u)=\min\{1,\max\{0,u\}\}. \]
We construct a circuit that, at integer workloads \(w\in\{2,\ldots,M+1\}\), extracts the bits of \(w-2\).
Set \(u_n=w-2\). For \(j=n-1,\ldots,0\), define
\[ \beta_j(w)=\operatorname{clip}\!\left(u_{j+1}-(2^j-1)\right), \qquad u_j=u_{j+1}-2^j\beta_j(w). \]
To verify this construction, suppose \(u_{j+1}\) is an integer satisfying \(0\leq u_{j+1}<2^{j+1}\).
In either case, \(u_j\) is the remainder after removing the most significant bit and satisfies \(0\leq u_j<2^j\). Induction proves that the \(\beta_j\) are exactly the bits of \(w-2\).
Evaluate \(\varphi\) using these bits, replacing Boolean conjunction by minimum, disjunction by maximum, and negation by \(1-\beta_j\). Denote the resulting circuit by \(E(w)\). Then:
Define the halt predicate
\[ H(w)=\max\{\operatorname{clip}(2-w),E(w)\}. \]
Thus \(H(1)=1\), while \(H(w)=E(w)\) at integers \(w\geq2\).
These are explicit rational piecewise-affine circuits. Their total encoding length is polynomial in \(n+|\varphi|\): the bit extraction uses \(O(n)\) gates and constants with total bit length \(O(n^2)\).
There is one skill, suppressed from the notation. Let
\[ P=\{A,B\},\qquad R=\{X,Y\}. \]
All four provider-requester pairs are compatible. All masses and processing rates equal one.
Set
\[ N=M+10,\qquad T=N+1,\qquad K=2M+2. \]
Both providers have capacity \(N\). Requester demands are \(N\) for \(X\) and \(N-1\) for \(Y\). Every admissible-time list is \(\{0,T\}\), every deadline is \(2T\), and every travel time is zero.
Use the same bid function for both requesters:
\[ B_X(t)=B_Y(t)=2T-t. \]
It satisfies the required earlier-start preference. In particular, every request at time \(0\) precedes every request at time \(T\).
Put \(c(t)=\operatorname{clip}(t/T)\), and define qualities by
\[ Q_X(w,t)=1+c(t)-2\min\{c(t),H(w)\}, \qquad Q_Y(w,t)=c(t). \]
These qualities are nonnegative: since \(0\leq c,H\leq1\),
\[ Q_X(w,t)\geq1-c(t)\geq0. \]
At the admissible times:
\[ Q_X(w,0)=1,\qquad Q_X(w,T)=2-2H(w), \]
and
\[ Q_Y(w,0)=0,\qquad Q_Y(w,T)=1. \]
The initial proposals are:
| Triple | Offered workload | Proposed time |
|---|---:|---:|
| \(A,X\) | \(2\) | \(T\) |
| \(A,Y\) | \(N\) | \(0\) |
| \(B,X\) | \(N\) | \(0\) |
| \(B,Y\) | \(1\) | \(T\) |
To specify the rest of the supplied state concretely, use these ordered trial schedules:
| Provider | First service | Second service |
|---|---|---|
| \(A\) | \(Y\), workload \(N-2\), start \(0\) | \(X\), workload \(1\), start \(T\) |
| \(B\) | \(X\), workload \(N-1\), start \(0\) | \(Y\), workload \(1\), start \(T\) |
The requests are precisely these scheduled services, with their prescribed bids. Provider residual capacities are \(1\) and \(0\), respectively; both clocks are \(T+1\); last destinations are \(X\) and \(Y\). Both requester residual demands are zero.
The schedules are feasible. Their proposal records also have the correct capacities before acceptance: \(N,2\) for \(A\), and \(N,1\) for \(B\). The second service’s earliest admissible time is \(T\), because its first service completes strictly between \(0\) and \(T\).
The problem supplies the current state rather than requiring it to arise from a prescribed initialization. This construction uses that stated input convention.
Consider a state whose proposals have the form
\[ (A,Y,N,0),\quad(A,X,z,T),\quad(B,X,N,0),\quad(B,Y,y,T), \]
where \(z,y\) are positive integers satisfying
\[ y\leq z\leq y+1,\qquad z,y<N-1. \]
Suppose \(H(z)=0\).
Requester \(X\) ranks \(A\)'s proposal above \(B\)'s, because their qualities are \(2\) and \(1\). It requests:
\[ x_{AX}=z,\qquad x_{BX}=N-z. \]
Requester \(Y\) ranks \(B\)'s proposal first, because its proposed time is \(T\). It requests:
\[ x_{BY}=y,\qquad x_{AY}=N-1-y. \]
All these workloads are positive in the stated range.
Provider \(A\) processes \(Y\) at time \(0\), followed by \(X\) at time \(T\). Its capacity before the second acceptance is
\[ N-(N-1-y)=y+1. \]
Thus \(X\)'s request fits because \(z\leq y+1\).
Provider \(B\) processes \(X\) at time \(0\), followed by \(Y\) at time \(T\). Its capacity before the second acceptance is
\[ N-(N-z)=z. \]
Thus \(Y\)'s request fits because \(y\leq z\).
Each first service has duration strictly between \(0\) and \(N<T\), so the second service’s earliest admissible start is exactly \(T\). Every completion meets its deadline, since
\[ T+N<2T. \]
Therefore all four requests are accepted, and the new proposals have the same form with
\[ z'=y+1,\qquad y'=z. \]
Starting from \((z_0,y_0)=(2,1)\), induction gives, for as long as the halt predicate remains zero,
\[ z_j=2+\lfloor j/2\rfloor,\qquad y_j=1+\lceil j/2\rceil. \]
Every transition changes at least one proposal workload. Hence none of these states is fixed.
An additional property is essential: assignment \(u\) is first tested at round \(j=2u\), when
\[ z_j=2+u,\qquad y_j=1+u=z_j-1. \]
Suppose a satisfying assignment exists, and let \(u\) be its smallest integer encoding. By the preceding calculation, its first test occurs at round \(j=2u\), with
\[ z=2+u,\qquad y=z-1,\qquad H(z)=1. \]
Requester \(X\) now ranks \(B\) first: \(B\)'s quality is \(1\), whereas \(A\)'s is \(0\). Its requests are
\[ x_{BX}=N,\qquad x_{AX}=0. \]
Requester \(Y\)'s requests remain
\[ x_{BY}=y,\qquad x_{AY}=N-1-y=N-z. \]
Provider \(B\) accepts its full-capacity \(X\) request, then rejects \(Y\)'s positive request and stops. Its residual capacity is zero, so its \(Y\) proposal disappears.
Provider \(A\) accepts \(Y\)'s workload \(N-z\), leaving capacity \(z\), then accepts the zero-workload \(X\) request at time \(T\). Consequently, its \(X\) proposal remains exactly \((z,T)\).
This is why the first satisfying test must occur with \(z=y+1\): the tested workload remains unchanged for the next round.
In that next round, \(H(z)=1\) still holds. Requester \(X\) again requests all \(N\) units from \(B\). Requester \(Y\), having no proposal from \(B\), requests all \(N-1\) units from \(A\).
The resulting state has proposals
\[ (A,Y,N,0),\qquad(A,X,1,T),\qquad(B,X,N,0), \]
and schedules
\[ \sigma_A=((Y,N-1,0),(X,0,T)), \qquad \sigma_B=((X,N,0)). \]
Its provider residual capacities are \(1,0\), clocks are \(T,N\), and last destinations are both \(X\). Its requester residual demands are zero.
Because \(H(1)=1\), applying another round reproduces every proposal, request, schedule, residual, clock, and destination. This entire state is a fixed point.
It is reached at round
\[ 2u+2\leq2(M-1)+2=2M<K. \]
If zero requests are omitted, the zero service disappears from \(A\)'s schedule; its clock becomes \(N-1\) and last destination becomes \(Y\). That version is likewise an exact fixed point.
If \(\varphi\) is satisfiable, Section 5 proves that a fixed point is reached within \(K\) rounds.
If \(\varphi\) is unsatisfiable, \(H(w)=0\) at every integer \(w\geq2\). Thus the counter dynamics continue through round \(K+1\). Indeed, throughout this interval,
\[ z_j,y_j\leq M+3<N-1, \]
so every hypothesis used in Section 4 remains valid. Since every transition changes a proposal workload, no state through round \(K\) is fixed.
We have therefore proved
\[ \varphi\text{ is satisfiable} \quad\Longleftrightarrow\quad \text{the supplied process reaches a fixed point within }K\text{ rounds}. \]
All numbers have \(O(n)\) bits, and the circuits have polynomial encoding length. The construction is a polynomial-time many-one reduction. It proves \(\mathrm{NP}\)-hardness with \(m=1\) and \(\tau=4\).
For schedule and utility computation, set \(U_Y=0\), and let \(U_X\) be the workload scheduled for \(X\) by provider \(A\). This is a nonnegative linear function of the schedule; all masses equal one, so it is also the global utility.
Thus examining the returned schedule, or testing whether its exact utility is zero, decides satisfiability. Both requested computations are \(\mathrm{NP}\)-hard.
Let \(h\) be the number of compatible triples. Then
\[ h\leq m|P||R|\leq m\tau^2/4. \]
Let \(q\) be the square of the product of denominators of all rational constants in the input, including the supplied state. Then \(\log q=O(L)\).
Every initial offered workload, pooled capacity \(a_pc_{ps}\), and pooled demand \(b_rd_{rs}\) belongs to the lattice
\[ q^{-1}\mathbb Z. \]
All subsequent workload operations are resets to these constants, subtraction, and minimum. Consequently, all workload fields remain on this same lattice.
Generated workloads are bounded by pooled capacities or demands. These bounds are at most \(2^{O(L)}\). Therefore every workload can be stored as an integer numerator over \(q\), using \(O(L)\) bits, independently of the number of rounds.
Quality and bid circuit outputs influence ordering; they are never substituted into workload arithmetic.
Every generated proposed or requested start belongs to an explicit input list. After an acceptance, a provider’s clock is
\[ t+\frac{x}{a_pv_{ps}}, \]
where \(t\) is an input start time and \(x\) has the preceding \(O(L)\)-bit representation. Hence generated clocks, completion times, and travel comparisons also have \(O(L)\)-bit rational representations.
An explicit rational piecewise-affine circuit can be evaluated in polynomial time on rational inputs of polynomial bit length. For affine gates, rational addition and multiplication by encoded constants preserve polynomial bit length over the circuit’s polynomially many gates; minimum, maximum, and branch selection select existing rational values.
A round requires polynomially many circuit evaluations, comparisons, list scans, and sorting operations. Therefore one exact round takes
\[ \operatorname{poly}(m,\tau,L) \]
bit operations.
For the selected output schedule, dividing workloads and provider masses by the fixed requester masses preserves polynomial bit length. Concurrent masses, if required as circuit inputs, are obtained by summing fixed rational masses over the schedule’s polynomially many service intervals. Exact normalized utility evaluation is therefore polynomial-time as well.
Store the current state, its successor, and a binary round counter. Compare the complete states after each transition. An extra successor calculation checks whether the state at round \(K\) itself is fixed.
This yields decision and output algorithms with time
\[ (K+1)\operatorname{poly}\!\left(m,\tau,L,\log(K+1)\right) \]
and space
\[ \operatorname{poly}\!\left(m,\tau,L,\log(K+1)\right). \]
Equivalently, for \(\ell=\lceil\log_2(K+1)\rceil\), the time bound is
\[ 2^{O(\ell+1)}\operatorname{poly}(m,\tau,L). \]
The decision problem thus belongs to \(\mathrm{PSPACE}\). Exact schedule and utility computation belong to \(\mathrm{FPSPACE}\), with polynomial output length.
There is also a finite-state bound independent of the numerical value of \(K\).
Bid values can be represented implicitly by their requester-skill pair and requested-time index, because they are determined by those data. With this representation, a generated state has a binary description of length
\[ O\!\left((h+m\tau+\tau+1)L\right). \]
This accounts for workload fields, time indices, message presence and order, schedules, residuals, clocks, and destinations. Therefore the number of generated states is at most
\[ N_{\mathrm{st}}=2^{O((m\tau^2+\tau+1)L)}. \]
Standard deterministic cycle finding uses polynomial space and \(O(N_{\mathrm{st}})\) transitions to find the orbit’s preperiod and period.
A period-one cycle is a fixed point. A longer cycle cannot contain a fixed point, since a deterministic orbit cannot leave a fixed point. Once the preperiod and period are known, modular arithmetic determines the state at round \(K\).
Combining direct simulation and cycle finding gives the additional upper bound
\[ \min\{K+1,N_{\mathrm{st}}\} \operatorname{poly}\!\left(m,\tau,L,\log(K+1)\right). \]
The cited paper states its discrete RPA convergence bound in Proposition 3.2 under earlier-start bid preference and a service-repeat restriction. That is an iteration claim for its process. [Lavie et al., Section 3.1.1](https://arxiv.org/pdf/2302.14507)
The transition specified here admits the counter of Section 4. Taking \(H(w)=\operatorname{clip}(2-w)\) removes the assignment-testing circuit entirely. For arbitrarily large binary-encoded \(N\), the same four types undergo \(\Omega(N)\) changing rounds, with input length \(O(\log N)\).
Thus the present rules admit exponentially many changing rounds even with fixed \(m,\tau\). This alone does not prove computational hardness—such a counter might be accelerated—but the SAT-testing quality circuit supplies the rigorous hardness reduction.
⟨structured verdict parsed — rendered above⟩
The output resolves the assigned problem. The reduction is correct under the stated supplied-state convention, and the exact simulation and space bounds are justified. I found no major or minor mathematical issues.
The established classification is \(\mathrm{NP}\)-hardness, with a \(\mathrm{PSPACE}\) upper bound for decision and an \(\mathrm{FPSPACE}\) upper bound for exact output computation. The prover appropriately does not claim a matching completeness result.
The convention that a fixed point occurs within the bound when \(F(s_j)=s_j\) for some \(0\leq j\leq K\) is explicit and consistent with checking the supplied state as well as subsequent states. The extra successor calculation in Section 7.3 correctly checks the endpoint \(s_K\).
Retaining zero-workload requests follows the literal requester rule: only zero-workload proposals are explicitly omitted. Accepting such a request can still generate a positive-workload proposal because the recorded workload is capacity immediately before acceptance. The proof correctly distinguishes these two workloads.
At an integer input in the intended encoding interval, the extraction invariant is valid. An integer remainder below \(2^j\) makes the clip argument nonpositive; a remainder at least \(2^j\) makes it at least one. The subsequent subtraction leaves the required smaller remainder.
The assertion about integers outside the encoding interval is also correct: every intermediate remainder remains integral, so every clipped bit is either zero or one. Consequently, an unsatisfiable formula evaluates to zero at every integer workload, including workloads beyond the assignment range.
For arbitrary real inputs, the extracted bits lie in the unit interval. Minimum, maximum, and Boolean-literal negation therefore keep \(E\) in that interval. The stated behavior of \(H\), including \(H(1)=1\), follows.
The circuit uses polynomially many gates and polynomial total constant bit length. No enumeration of assignments is embedded in the input.
The construction satisfies the required compatibility, positivity, rationality, admissible-time, and deadline conditions. The bid function strictly prefers earlier admissible times. The displayed lower bound proves that the quality functions are nonnegative.
The initial schedules respect capacities, demands, sequential execution, deadlines, and the restriction of one occurrence per triple. Their capacity-before-acceptance records are exactly the offered workloads in the proposal table. The clocks, residual capacities, requester residual demands, and last destinations agree with those schedules.
The construction uses the task’s permission to supply a current state. It does not depend on proving reachability from an additional prescribed initialization.
When \(H(z)=0\), all requester rankings used in the proof are strict. The four requested workloads are positive in the stated range and exhaust the two requester demands.
Provider \(A\) has capacity \(y+1\) before its second request; provider \(B\) has capacity \(z\). Thus the two inequalities \(z\leq y+1\) and \(y\leq z\) establish acceptance. The first services finish strictly between the two admissible times, and every requested completion meets its deadline.
The resulting proposal update is exactly \(z'=y+1\), \(y'=z\). The displayed closed forms satisfy both the initial conditions and this recurrence. In particular, assignment \(u\) is first tested at state index \(2u\), with \(y=z-1\).
Every such transition changes a proposal workload, which suffices to rule out equality of the entire state.
At the first satisfying test, requester \(X\) strictly reverses its ranking. Provider \(B\) accepts its full-capacity request, rejects its positive remaining request, and generates no positive residual proposal.
Provider \(A\) retains offered workload \(z\) for its zero-workload \(X\) request. The relation \(y=z-1\) is essential here and has already been established at the first satisfying test.
In the following round, the absence of \(B\)’s proposal to \(Y\) makes \(A\) receive the entire demand of \(Y\). Its remaining capacity is then one, yielding the claimed proposal to \(X\).
At this resulting state, \(H(1)=1\) reproduces the same requests and ordered schedules. The residual capacities, requester residual demands, clocks, and destinations also reproduce exactly. Thus the proof establishes a fixed point of the entire state.
The omitted-zero-request variant is likewise consistent: its changed clock and destination give the same earliest admissible time for the final residual proposal.
In the satisfiable case, the fixed point is reached at index \(2u+2\leq 2M<K\).
In the unsatisfiable case, all tested workloads remain integers at least two, so \(H\) remains zero. Through index \(K+1\), the claimed bound \(z_j,y_j\leq M+3<N-1\) holds. Therefore the counter argument applies to every transition needed to rule out a fixed point through index \(K\).
The equivalence with satisfiability is valid, and the construction has polynomial encoding length despite the exponentially large numerical values of \(M\) and \(K\).
The schedule and utility reductions also work. At the fixed point, provider \(A\)’s scheduled workload for \(X\) is zero; in the unsatisfiable case, that workload after \(K\) rounds is positive. The specified utility extracts this workload through a permitted nonnegative linear function. Exact output computation therefore decides satisfiability by polynomial-time inspection.
The common workload lattice is valid. Squaring the product of input denominators accommodates the products forming pooled capacities and demands, as well as initial workloads. Reset, subtraction, and minimum preserve the lattice.
Generated workload magnitudes are bounded by input capacities or demands. Their rational representations consequently have bit length bounded independently of the round count.
Generated starts come from explicit input lists. A clock is an admissible start plus one service duration, so clocks do not accumulate an unbounded arithmetic history across rounds. Processing-rate division and travel-time addition preserve the claimed polynomial bit bounds.
Exact evaluation of the described rational affine and piecewise-selection gates has polynomial bit complexity. Circuit values affect ordering without feeding back into workload arithmetic. Sorting, admissible-time scans, and exact state comparisons therefore fit the per-round polynomial bound.
Normalizing the selected schedule and evaluating its utility also preserves polynomial bit complexity. The direct simulation consequently gives the stated time bound
\((K+1)\operatorname{poly}(m,\tau,L,\log(K+1))\)
and polynomial space. These support the claimed decision and function-space memberships.
The optional finite-state argument is also valid. Implicit bid representations preserve exact equality because generated bids are determined by their requester-skill pair and requested time. Cycle finding can identify whether the eventual cycle is a fixed point and recover the bounded-round output using the preperiod and period.
The source does state the cited iteration bound in Proposition 3.2 under the earlier-start and service-repeat assumptions. The prover cites that statement without applying it to the specified mass transition. [Verified paper](https://arxiv.org/pdf/2302.14507)
With the assignment test removed as described, the counter still gives a linear number of changing rounds in the numerical capacity while that capacity has logarithmic encoding length. This supports the claimed failure of a corresponding polynomial iteration bound for the present rules. The prover correctly distinguishes this observation from computational hardness.
No repair or additional clarification is needed to verify the argument.
⟨structured verdict parsed — rendered above⟩
Tier: machine-proved, adversarially reviewed by an independent model. No human has checked this proof. Generated from pipeline artifacts by tools/atlas_build.py.