acceptodds
Under review as a conference paper at ICLR 2027

Negotiated Recursive Reasoning

Abstract

Small recursive networks solve structured problems by repeatedly refining a latent state with shared weights. Splitting a problem into overlapping local views exposes its constraints but creates a coordination problem: in Sudoku, a row, a column, and a box can propose different values for their shared cell. We introduce Negotiated Recursive Reasoning (NRR), which coordinates local recursion while it takes place. A shared local reasoner refines a proposal and a private reasoning state for each view, while an explicit negotiation step constructs targets that reduce overlap disagreement and carries unresolved disagreement into the next round. We use a normalized soft-consensus system with a bounded condition number and characterize the gradient path through which task supervision learns the coupling. In the benchmark setting, NRR reaches 95.2% exact solve on Sudoku-Extreme and 90.4% on Maze-Hard, 5.3 points above a learned-link replacement on both tasks, with larger gains on harder Sudoku puzzles. In controlled comparisons, NRR exceeds a native TRM rerun by 6.2 and 3.6 points, and disagreement memory improves both recursive and feed-forward local solvers, with larger mean gains for recursive updates. On larger mazes, sparse coordination gives a better accuracy–latency tradeoff than global attention recurrence. These results identify the organization of interaction among partial solutions as a useful design dimension for recursive reasoning, alongside model capacity and recursion depth.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Looped Transformer, Recursive Reasoning Model, ADMM

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 4 reviews, above 68% of the others.
Reviewer_eashOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a method for coordinating local reasoning results to ensure global consistency when a complex task is decomposed into multiple subproblems. Unlike Sheaf-ADMM, which relies on mathematical optimization, the proposed NRR framework uses trained neural networks to iteratively update local solutions, followed by a reconciliation step to achieve global consistency. Experiments on tasks such as Sudoku and maze-solving demonstrate the effectiveness of NRR and its performance improvements over baseline methods.

Critical strengths

The proposed method is well conceived, framing local coordination as a learnable reasoning process that can be jointly optimized using a recurrent neural network. The ablation studies provide evidence for the contributions of the shared maps, and dual memory. Furthermore, large-scale experiments demonstrate that NRR achieves a more favorable performance–latency trade-off than the Global-RecurProx approach.

Critical weaknesses

The experimental evaluation has several limitations. First, the main text devotes fewer than two pages to experimental results, limiting the depth of the empirical analysis and making it difficult to assess NRR's specific advantages over Sheaf-ADMM quantitatively. Second, the large-scale experiments do not explicitly report the performance gap between NRR and Sheaf-ADMM, leaving the extent of NRR's improvements unclear. Finally, the method relies on predefined local views and overlap relationships. While such structures arise naturally in problems like Sudoku, it remains unclear how they should be identified or constructed for more complex, real-world tasks. This raises questions about the method's generalizability and its applicability to domains where the decomposition structure is not readily available.

Questions for authors
  1. The authors should report Sheaf-ADMM's performance in the large-scale experiments and quantify the improvements achieved by NRR.
  2. For more complex, real-world tasks, how are local views and their overlap relationships defined or constructed? Does this process require domain-specific prior knowledge or manual intervention?
  3. The authors should provide a controlled comparison between NRR and Sheaf-ADMM using the same local solver, so that the performance differences attributable to the coordination mechanisms can be isolated more clearly?
7 comments
AuthorsOpenReview ↗

Response to Reviewer eash (1/n)

We thank you for the concise review and for the three requests, all of which target the same gap: the main text under-reports the experiments and never places NRR next to Sheaf-ADMM under a controlled contrast. The revision expands Sec. 6 and answers all three: the large-scale results now include Sheaf-ADMM (Q1), the same-local-solver comparison is added as a 2×22\times2 design (W3/Q3), and view construction is discussed with quantitative evidence rather than only acknowledged as a limitation (W2).

W1: Depth of the empirical analysis in the main text. We agree the main text was thin. Sec. 6 now spans Sec. 6.1--6.4 and contains the controlled comparison table, the learned-communication table with ten-seed paired contrasts, the local-solver ×\times coordination comparison, the matched-cost and native-size analysis at widths 30 and 90, and one paragraph per result that states what it does and does not establish. Measurements previously confined to the appendix (interaction versus final aggregation, difficulty stratification, and the accuracy--latency frontier) now appear in the main text, with the full curves and the latency/time-to-solve table in App. E.

W2: Defining views and overlaps for more complex tasks. The construction has three parts, and only the first is task-specific. First, the partition: output coordinates are grouped into overlapping local views. For grids this can always be done with patches, and the patch construction used on Maze and ARC (4×44\times4 patches at stride 3, eight-neighbor edges between patches that share valid cells) is fully generic. Second, the edge variable: each edge records the absolute output coordinates its endpoints share, which is what makes a comparison meaningful and requires no task knowledge beyond the coordinate system. Third, the restriction maps: these may be semantic selectors, where the shared cells have a known local position in both views (Sudoku rows, columns, boxes), or learned maps, which is the default elsewhere. Overlap coverage (each output location in at most cc views) and bounded graph degree are the assumptions the complexity analysis needs.

We can quantify how much the task-specific part buys. On Sudoku, replacing the constraint-group views with generic overlapping 3×33\times3 patches reduces accuracy from 95.2% to 91.4%, and the remaining difference comes from views that expose the actual constraints rather than from hand-tuning of the maps. On ARC the encoder attends to demonstration memory, which we now describe as a learned input stage outside the locality assumption. The revision states the assumption, this evidence, and learned view discovery as future work.

W3 / Q3: Controlled comparison under the same local solver. This was the missing cell of the design and we added it. The 2×22\times2 varies the local solver (exact proximal as in Sheaf-ADMM, or RecurProx) and the coordination mechanism (learned link or sheaf negotiation), in the benchmark setting with everything else fixed.

Local solverCoordinationSudokuMaze
Proximallearned link67.1 ± 1.260.9 ± 2.7
Proximalsheaf negotiation71.6 ± 0.964.8 ± 2.6
RecurProxlearned link89.9 ± 0.985.1 ± 1.6
RecurProxsheaf negotiation95.2 ± 0.590.4 ± 1.0

Negotiation adds 4.5/3.9 points under the proximal solver and 5.3/5.3 under RecurProx, so the benefit of the coordination mechanism is stable across local-solver families. Concretely, the difference between NRR and the Sheaf-ADMM rerun (95.2 vs 71.6 on Sudoku) is mostly the local solver, not the coordination, and this decomposition is now reported in Sec. 6.3 instead of being inferred from two separate rows.

AuthorsOpenReview ↗

Response to Reviewer eash (2/2)

Q1: Sheaf-ADMM in the large-scale experiments. We evaluated the Sheaf-ADMM width-30 checkpoint on the larger mazes, following the same zero-shot protocol used for NRR and TRM (same instances, same horizon, no finetuning).

Method (trained at width 30)Width 45Width 60Width 90
Sheaf-ADMM39.2 ± 3.413.4 ± 2.62.3 ± 1.0
TRM51.6 ± 3.219.7 ± 2.53.6 ± 1.2
NRR75.9 ± 2.054.5 ± 2.927.8 ± 3.5

The gap to Sheaf-ADMM widens as the maze grows (25.6 → 36.7 → 41.1 points at widths 30, 45, 60, and narrows to 25.5 at width 90 where both methods degrade), which is the comparison the large-scale discussion should have included. These values are added to the size-transfer figure and table in App. E.6.

Q2: View construction. Addressed in W2, with the generic-patch evidence (91.4% on Sudoku) and the explicit statement that ARC's demonstration encoder falls outside the local-view assumption.

The authors have responded to your reviews. Please read their response and reply. Please specify which concerns are resolved and which remain. Please update your review and score if the assessment has changed.

AC

Reviewer_LtbYOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper introduces Negotiated Recursive Reasoning (NRR): a “negotiation” module, based on learned linear maps and a finite soft-consensus solve, to coordinate local recursive reasoners.

The paper demonstrates good results on Maze-Hard, Sudoku-Extreme, ARC-AGI-1/2 and MNIST classification.

For each task, the problem is divided into local views (specific to each problem e.g. rows/cols/blocks in Sudoku and local patches in Mazes) and use a base architecture that closely follows TRM but with some key differences: In TRM there is one “agent” per cell and each agent has full observability (attends to every other agent/cell at every step). In NRR instead there is one agent per view which locally updates its own state (private refinement) and communicates with neighboring agents/views via the newly introduced “negotiation” step. To that end, authors introduce additional state variables (consensus target z, anchor a) and edge variables (accumulated disagreement u), that are explicitly used during the negotiation step, and that condition the local reasoning steps to steer it toward consensus.

The paper builds on prior Sheaf-ADMM work which introduced the mathematical formulation of doing reasoning via overlapping views independently solving local subproblems and “negotiating” towards consensus. If I understand correctly the main novelty here are (i) the use of TRM-like architecture for local updates, (ii) the use of normalized soft-consensus solved with conjugate gradient steps for the negotiation steps (main contribution), and (iii) training everything end-to-end and showing results on more complex tasks such as Sudoku-Extreme and ARC-AGI-1/2.

I think the core ideas are interesting and promising but the paper writing and reported contributions are confusing (as detailed below), and I am not convinced by all the reported results. For these reasons I am not supporting acceptance at this stage.

Critical strengths

The idea of dividing reasoning in local subproblems that locally communicate and negotiate to reach a consensus (as proposed by prior Sheaf-ADMM work) is a hard problem worth investigating more. The addition of an explicit negotiation mechanism which is the main contribution of this paper is an interesting formulation with some nice theoretical guarantees (section 4). Moreover, according to results reported in Table 1, this explicit negotiation is beneficial across all the tested reasoning benchmarks, when compared to several ablation baselines, and reaches good performances across challenging benchmarks.

Critical weaknesses

I have concerns about the reported contributions and results:

  • Authors report several times that “NRR exceeds a native TRM” implying that the local decomposition and negotiation beats global reasoning. As they achieve similar results with the Global-RecurProx baseline, independently of the whole negotiation mechanism, authors should differentiate the gains that they get from ingredients that are independent of NRR (which seemingly also benefit the Global-RecurProx baseline) with the gains that they get from the actual negotiation mechanism (table 1). I believe it is more interesting to focus on the latter and re-write the paper so that it is clear that these are the main contributions.

  • Authors also claim gains in accuracy-latency tradeoff with respect to global-attention baselines on larger mazes but it remains unclear what exactly is measured here and whether anything can really be concluded from it. If I understand correctly Figure 1-c shows out-of-distribution generalization by adding more agents/cells at test time. First, this is a stronger out-of-distribution shift for the global baseline as agents suddenly attend to more cells (never seen during training), which is not the case for the local architecture, which might explain the lower generalization accuracy. Secondly, the reported latency is for one rollout of a fixed number of time steps if I understand correctly. Reporting instead time-to-solve (computed for mazes that are solved by both baselines) would be much more informative, as I expect the global baseline to reach the solution in fewer time steps.

  • Results reported in Table 1 are for me the most interesting, yet it is still unclear why the bitter lesson shouldn't apply here: why wouldn’t a more flexible message passing protocol be able to learn end-to-end to perform equivalent negotiation? Authors already include a baseline with learned links but it uses a simple averaging of incoming messages, I believe that a more expressive message-passing scheme (e.g. with cross-attention) could reach similar or even better performances and make the overall architecture much simpler.

  • One clear limitation, as acknowledged by authors, is the specific choice of decomposition for each task which is at the moment done by hand. There are several hand-crafted choices for what is defined as a node (row/col/block for Sudoku versus 4x4 patches for mazes) and how the node state is constructed (in sudoku each node state maintains different slots per cell, whereas it is not the case for other tasks); but also in the construction of edges and constraints between nodes (restriction matrices with some task-specific construction choices). In ARC, private refinement uses cross-attention to an external memory of demonstration pairs which breaks the locality of the architecture. Overall, prior knowledge is baked into the choice of the task decomposition and it is uncertain whether the proposed “negotiating” step could work in a more general setting.

The paper is also quite hard to parse and understand fully, with many specific choices and a ton of different experiments/baselines that are mixed in a very long appendix, while no codebase is provided to check the results. I believe that the paper would greatly benefit from a stripped-down narrative and set of experiments to focus on the important contributions.

Questions for authors
  • What are the differences between Global-RecurProx and the original TRM architecture? What do you think explains the gap in performances between both?
  • Can you provide the codebase for reproducing the experiments? The AI statement does not report using any AI for writing code nor launching experiments, which I would like to check given the impressive breadth of experiments and all the tested baselines.
9 comments
AuthorsOpenReview ↗

Response to Reviewer LtbY (1/n)

We thank you for the precise summary of the contributions and for the four criticisms, which we found the most useful test of what this paper can and cannot claim. We accept all four and have changed the paper accordingly: the narrative now separates gains that come from ingredients independent of negotiation from gains that come from negotiation itself (W1); the larger-maze comparison is redone with native training at the evaluated size and with time-to-solve (W2); a persistent cross-attention communication baseline is added (W3); and the hand-crafted decomposition is addressed head-on as a limitation, with the generic-patch results as evidence for how much it matters (W4).

W1: Separating NRR-independent gains from negotiation gains. This criticism is correct, and it is the main reason the paper read as overclaiming. Global-RecurProx applies the RecurProx update family with global attention, shares no part of the negotiation mechanism, and reaches 90.2% on Maze against NRR's 90.1%. The gain over native TRM (88.6/86.5 to 94.8/90.1) therefore belongs to the local-update organization and the decomposition, not to negotiation.

The revision states this in Sec. 1 and Sec. 6.2 and leads with the negotiation-specific comparisons:

Contrast (controlled)SudokuMaze
NRR vs persistent learned link (5 substeps)+1.1 [0.8, 1.4]+0.5 [0.2, 0.8]
NRR vs persistent cross-attention link+0.5 [0.2, 0.9]+0.2 [-0.1, 0.6]
NRR vs recurrent relational network+1.4 [0.8, 2.0]+0.9 [0.2, 1.7]

Intervals are t0.975,9t_{0.975,9} over ten seeds with the original five seeds unchanged. The claim we now make is narrower and, we think, more interesting: on standard-sized tasks negotiation and expressive learned communication are close, and the separation appears in hard instances and at larger sizes (5.9 points on the hardest Sudoku quintile and 3.6 points at maze width 90; see W3). The claim that NRR "exceeds a native TRM" is no longer used to support negotiation in the abstract or the introduction; the TRM comparison is presented as what it is, a comparison to global recursive models in which several ingredients differ, and the revision states that this contrast does not isolate negotiation.

W2: Accuracy--latency at larger mazes, distribution shift, and time-to-solve. Three of your objections were right about the measurement, and we have redone it.

Stronger OOD shift for the global baseline. Correct. We now train both methods at width 90 on 1000 mazes from the same generator (batch 32, 20000 updates, five seeds, everything else as in App. D.3).

Maze width 90Accuracy (%)Latency (ms)Time-to-solve (ms)
Global-RecurProx, trained at 3023.0750612
NRR, trained at 3028.5268191
Global-RecurProx, trained at 9030.1 ± 3.2760480
NRR, trained at 9036.4 ± 2.8270176

Training at the evaluated size raises both baselines, so part of the zero-shot gap was the shift you identified. The gap does not close (5.5 → 6.3 points) and the latency ratio stays near 3×, which is the conclusion the original figure should have supported.

Time-to-solve instead of fixed-rollout latency. Agreed that this is the informative quantity. On mazes solved by both methods at the fixed horizon, NRR solves in 191 vs 612 ms at width 90 and 23.1 vs 30.2 ms at width 30, a 3.2× and 1.3× advantage. Your expectation that the global baseline needs fewer steps is confirmed: it converges in fewer rounds, and the per-round cost difference outweighs this on mazes, while on Sudoku it does not (26.0 vs 20.0 ms at equal accuracy). We report both rounds-to-solve and wall-clock in App. E.6.

AuthorsOpenReview ↗

Response to Reviewer LtbY (2/2)

W3: The bitter lesson. We built the baseline you proposed. The persistent cross-attention link keeps the graph, encoder, decoder, local solver, recursion depth, and carried communication memory, and replaces the mean-pooled MLP messages with four-head cross-attention over neighbors and their memory (two substeps per round, 5.4M parameters against 5.1M for NRR).

Method (controlled)SudokuMazeHardest Sudoku quintileMaze width 90 (transfer)
Persistent learned link (mean-pooled)93.7 ± 0.989.6 ± 1.161.421.7
Persistent cross-attention link94.3 ± 0.689.9 ± 0.964.224.9 ± 3.1
NRR94.8 ± 0.590.1 ± 1.070.128.5 ± 3.5

Expressive message passing recovers most of the average gap, so on standard-sized tasks a more flexible protocol largely substitutes for explicit negotiation; what it does not recover is the tail, where constraint coupling is hardest and where the graph grows. This is now the paper's central claim, and it is weaker than the original text but better supported. It also gives a concrete answer to why the negotiation is worth its structure: it exposes proposal--target disagreement as a state, which the learned links do not, and that state drives the difficulty and size advantages above and the adaptive-stopping results in App. E.8.

W4: Hand-crafted decomposition. We agree this is a real limitation and do not claim otherwise. Two existing results bound how much it matters. First, replacing the Sudoku constraint-group views with generic overlapping 3×33\times3 patches reaches 91.4% against 95.2%, so views that expose the actual constraints help but are not required for the mechanism to work. Second, degree-preserving overlap shuffling at inference drops accuracy to 62.0% while retraining on the shuffled graph recovers 86.0%, so the model adapts to a wrong graph rather than depending on a specific hand-built pairing. On ARC, you are right that cross-attention to demonstration memory sits outside the locality assumption; we now describe the encoder as a learned demonstration-conditioned input stage and the negotiated output patches as local, instead of implying the whole model is local. The revision adds a paragraph in Sec. 7 stating the assumption, the evidence above, and learned view discovery as the natural next step.

Q1: Global-RecurProx versus TRM, and where the gap comes from. Both use one shared network, the same two-state (x,r)(x,r) organization, n=6n=6 private updates, and a proposal readout, and both execute 336 network applications per inference under the controlled schedule, so the comparison is not about added computation. Global-RecurProx differs in two ways: it attends over the whole grid at every update (one token per cell, two Transformer layers, sinusoidal positions) instead of operating per cell with a pooled state, and it applies the RecurProx anchor update, with a zero anchor. On Maze, where TRM already uses attention, the gap is 3.7 points (90.2 vs 86.5); on Sudoku TRM uses an MLP mixer and the tokenization also differs, so we do not attribute the 6.2-point gap (94.8 vs 88.6) to the update organization alone.

Q2: Code and the AI statement. The AI statement was ambiguous and is now explicit: generative AI assisted with manuscript editing, figure design, and consistency checks; all code, training runs, and evaluations were written and executed by the authors.

Thank you for the answer, however I cannot find the changes in the revised manuscript, e.g. I cannot find the new rounds-to-solve results in appendix E.6. Could you upload the revised manuscript with highlighted changes?

Reviewer_4DgsOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2(+1)
Soundness
2
Read review
Paper summary

This paper proposes a local recursive reasoning method that allows the recursive reasoning trajectories for different sub-problems/views to coordinate with each other to solve the problem while satisfying all the constraints. The proposed method, Negotiated Recursive Reasoning (NRR), has a clear advantage over independent local recursion: it allows different local recursive reasoning paths to coordinate with one another so they can revise and reconcile their reasoning based on agreement or disagreement with other recursive paths. NRR performs comparably to global recursive baselines on smaller problems (Sudoku, smaller maze). On larger mazes, NRR outperforms a global recursive baseline (Global-RecurProx) while having significantly lower latency. NRR also outperforms a recent local recursive method (Sheaf-ADMM) on all four evaluated tasks.

Critical strengths
  1. The results in Table 1 and Figure 1b/c show the effectiveness of the proposed method over the compared global and local recursive reasoning baseline methods. NRR seems especially strong for large mazes, where its accuracy is higher than the compared global baseline but with less than half of the the global baseline's latency.

  2. The results include ablations that show the interaction between private recurrence and dual memory, and the importance of information overlap (Figure 3). These results supports the design decisions made in NRR (the use of dual memory and private recurrence).

Critical weaknesses

Weakness 1: clarity and organization.

  • I found the paper difficult to follow in several places. Many sentences and paragraphs required multiple readings to understand. Even after rereading, some details and connections remained difficult to understand. This made it harder to fully understand and assess the technical contribution and soundness. The paper would benefit from clearer writing and improved organization.

  • The main paper does not include a Related Work section. The Related Work section appears only in the appendix (page 44). This section provides important information for understanding how the proposed method differs from existing work. The most relevant comparisons should be included in the main paper.

  • Several experimental results needed to support the paper’s claims also appear only in the appendix (e.g., Fig 5, 6, 7). The key supporting evidence should be included in the main paper.

  • The results section mostly restates what is shown in the plots and tables. It provides limited discussion of what the results mean, why the observed trends occur, and what can be learned from them. More interpretation would strengthen the empirical analysis.

Weakness 2: Baseline comparisons.

  • The paper does not provide enough information for the reviewer to determine whether the comparisons with the baselines are fair. 2 issues below:
  • (1) the paper does not cite the benchmark. Table 3 lists the benchmark task configurations, but the paper does not say whether the tasks and datasets come from standard benchmarks or were created/adapted specifically for this work. Please clarify their source and provide citations where appropriate.
  • (2) the paper does not explain whether the experiments use comparable settings for NRR and the baselines. Important choices, such as the number of reasoning steps, can strongly affect performance. Please state whether these settings are matched between methods and report the relevant configurations for each method.
Questions for authors
  1. On Sudoku, why does NRR introduce additional coordination overhead while achieving accuracy similar to Global-RecurProx? What accounts for NRR’s improvements in both accuracy and latency over Global-RecurProx on the larger mazes?

  2. Are the evaluated tasks and datasets established benchmarks (Line 353 and Table 3) used in prior work, or were they introduced or adapted for this paper? If they are established benchmarks, please provide the relevant citations. If they are newly constructed or modified, please describe how the data were generated and how the evaluation protocol relates to prior work.

  3. Could the authors clarify whether NRR and the baselines were evaluated under comparable settings? In particular, were influential settings, such as the number of reasoning steps, matched across methods? A table summarizing the relevant configurations would help readers determine whether the comparisons are controlled and fair.

  4. Regarding results in Table 1, could the authors explain more explicitly how each NRR variant differs from the final NRR configuration and which comparison isolates the contribution of explicit negotiation (to answer the question in Section 5.3 title "What does explicit negotiation add?")?

  5. On line 397 (Section 5.3), the statement that “NRR gains 5.3 points on both Sudoku and Maze” appears to compare the final NRR row with NRR with learned link. Why is this the primary comparison, and what does the gap tell us about the relevant component(s) of NRR? It would also be helpful to explain how this comparison relates to other comparisons, such as NRR, shared maps only versus the final NRR.

  6. Could the authors provide a more explicit component-by-component comparison between NRR and existing local solvers? In particular, which aspects of NRR are novel beyond private refinement and dual memory?

  7. Lines 430–431 state that the experiment “replaces within-round recursion with a feed-forward local solver, which uses untied factorized weights” What are “untied factorized weights,” and what role do they play in the model?


Suggestions for revision or additional analysis

  1. If results are already available, reporting accuracy and coordination cost for NRR, the other global recursive baselines, and the local recursive baselines across Sudoku and all three maze sizes would make the trade-offs among the methods easier to compare. Otherwise, an explanation of why the current subset of comparisons is sufficient would be helpful.

  2. Including the global recursive baselines in Table 1 would make the empirical comparison more complete.

  3. Moving the Related Work section into the main paper and adding a concise comparison table would substantially improve the paper’s positioning and readability.

9 comments
AuthorsOpenReview ↗

Response to Reviewer 4Dgs (1/n)

We thank you for the detailed list; our reply follows your numbering. The presentation score of 1 is the most consequential part of this review, and we have restructured the paper around it: Related Work now opens the paper as Sec. 2 with an inherited/new comparison table, the within-study table (Table 2) gains an explicit intervention column, and a settings table states which configurations are matched (W2). Answers to Q4, Q5, and Q6 also appear in the rewritten Sec. 6.3.

W1: Clarity and organization.

Readability. Sec. 3 and Sec. 4 are rewritten so that each round is described in one paragraph before the equations: a local proposal and a private state are refined toward an anchor, the anchor comes from the previous round's negotiated target minus accumulated disagreement, and the target is the soft solution of a linear system on the overlap graph. The notation table in App. B.1 is moved to the start of the appendix, and every symbol used in Sec. 4 is defined there and at first use.

Related work in the main text. The relevant part of Appendix F now appears as a full main-text Sec. 2 (Related Work), with a concise comparison table separating what is inherited from what is new:

ComponentInherited fromNew in NRR
Private/answer recursive state with shared weightsTRMupdate conditioned on negotiation anchor a=z−ua=z-u; private state persists across negotiation rounds
Overlapping views, learned restrictions, primal--dual coordinationSheaf-ADMMlearned stateful local recursion replaces the exact proximal solve
Consensus solvesoft ADMM with CGnormalization bounds the condition number of I+βF⊤FI+\beta F^\top F by four
Training through communication--two-round retained window; without it coupling parameters get no task gradient (App. A.6)

Supporting results in the main text. The controlled comparison figure, the paired-difference table, the local-solver ×\times coordination table, and the accuracy--latency table now appear in Sec. 6.2--6.4, with the full latency and time-to-solve table in App. E.6. Specifically, the three results that previously appeared only in Appendix E (interaction versus final aggregation, difficulty stratification, and the communication-baseline panel) are summarized in one main-text table with the appendix retaining the full curves.

Interpretation rather than restatement. Sec. 6.3 now argues why the numbers come out as they do. On Sudoku, global attention over 81 cells is cheap, while NRR adds 27 views ×\times 7 local applications and five communication iterations per round; that is the coordination overhead, and it is why latency is 26.0 vs 20.0 ms (Fig. 9c). At width 90 the cost of dense attention grows with the square of the token count while the edge cost grows linearly, which is why the ordering reverses. The difficulty trend is interpreted through constraint coupling: bins with more backtracking are bins where a locally admissible row or column proposal is more likely to conflict with another view, and negotiation is the mechanism that feeds that conflict back (Fig. 6).

AuthorsOpenReview ↗

Response to Reviewer 4Dgs (2/n)

W2: Baseline comparisons.

(1) Benchmark sources. The tasks are established benchmarks, and citations are added at first mention in Sec. 6.1. Sudoku-Extreme and Maze-Hard use the released splits of \citep{wang2025hierarchical}: 1000 training puzzles and 422786 test puzzles for Sudoku, 1000/1000 30×3030\times30 mazes with shortest paths longer than 110 for Maze. ARC uses the public ARC-AGI-1 and ARC-AGI-2 evaluation sets \citep{chollet2019measure,chollet2025arc}. MNIST uses the standard 60000/10000 split \citep{lecun_mnist}. The width-60 and width-90 mazes are generated with the released Maze-Hard generator at the new width, with the minimum path length scaled to ⌈110W/30⌉\lceil110W/30\rceil and fixed generator seeds; the generator version and the manifests are released (App. D.7). Only the larger mazes and the ARC training mixture (official training tasks plus ConceptARC, deduplicated) are constructed for this work, and both are described in the revision.

(2) Comparable settings. Rounds are matched across the graph-based methods; native TRM and EqR keep their source schedules, as stated in App. C.1.

MethodRoundsLocal updates/roundCommunication/roundParams (M)Train updates
TRM (native rerun)16 segments × 3 cycles6none5.160k
EqR (native rerun)641none5.160k
Global-RecurProx24 / 307global attention5.060k
Sheaf-ADMM rerun24 / 30exact prox (50 APG on Sudoku)5 CG4.260k
Persistent learned link24 / 3075 MLP substeps5.660k
NRR24 / 3075 CG5.160k

The controlled comparisons match rounds, local updates, optimizer updates, and selection procedure; communication substeps are not claimed to be equal computation, and measured latency is reported instead (29.7 vs 26.0 ms for the persistent link vs NRR on Sudoku). This table is added to App. B.2.

Q1: Why the Sudoku overhead, and why accuracy and latency improve together on larger mazes. On Sudoku the global baseline attends over 81 tokens, which is cheap, and its recurrence is already sufficient for most puzzles; NRR adds 27 local applications and five CG iterations per round, giving 26.0 vs 20.0 ms in the benchmark timing series (Fig. 9c). Coordination therefore costs throughput on a small, dense input without buying accuracy. At width 90 the dense-attention cost grows quadratically while NRR's per-round cost grows with the number of edges, and the accuracy gap also appears because long-range consistency is harder to maintain in a single global state: 28.5% at 268 ms vs 23.0% at 750 ms.

Q2: Are the tasks established? Yes, with the exceptions noted in W2(1); citations and the construction protocol for the generated mazes are added.

Q3: Configuration table. Given in W2(2) and added to App. B.2.

Q4: What each Table 2 variant changes, and which comparison isolates negotiation. Table 2 gains an explicit column:

RowChange relative to full NRRWhat it isolates
NRR with learned linkconsensus + dual replaced by one learned residual message per round; encoder and local solver fixedexplicit negotiation versus learned communication (state capacity reduced)
NRR without dualu=0u=0 throughout; consensus retaineddisagreement memory
NRR, shared maps onlyinput-dependent rank-4 modulation removedlearned versus fixed edge maps
Sheaf-ADMM rerunlocal solver replaced by an exact proximal step with a smaller budgetlocal-update family
NRR----

The learned-link row is the comparison that isolates explicit negotiation, because it is the only row that removes the negotiation step while keeping everything else. The 5.3-point gap is therefore a statement about replacing negotiation with a single learned message, and the revision says this explicitly rather than implying it is a statement about negotiation versus any learned communication.

AuthorsOpenReview ↗

Response to Reviewer 4Dgs (3/3)

Q5: Why the 5.3-point comparison is primary, and how it relates to shared maps only. It is primary in Table 2 because it holds the encoder and local solver fixed, so the difference is attributable to the communication mechanism. We now also report the stronger persistent link, where the gap is 1.1/0.5 (see the common response). The shared-maps row is a different axis: it removes the content modulation of the restriction maps, not the negotiation, and its 0.4/1.2-point gap on Sudoku/Maze measures the value of learned maps. The two rows are therefore complementary: negotiation contributes most of the benchmark gap, and learned maps contribute a smaller independent amount.

Q6: Component-by-component comparison with existing local solvers. Beyond private refinement and dual memory, NRR adds: (i) the anchor a=z−ua=z-u as the interface between coordination and local computation, which existing local solvers do not have; (ii) normalized soft consensus with a condition-number bound, which makes the finite solve accurate within five CG steps and trainable end-to-end; (iii) supervision routed through negotiation rounds with a two-round retained window; (iv) the analysis separating numerical accuracy, latent agreement, and decoded correctness. The comparison table in W1 lists these against TRM and Sheaf-ADMM, and App. C gives the same for the MPNN, RRN, and learned-link baselines.

Q7: Untied factorized weights. In the feed-forward control, the n+1n+1 local updates are distinct networks rather than repeated applications of one network. Each dense matrix W∈Rm×nW\in\mathbb R^{m\times n} is stored as W=UV⊤W=UV^\top with U∈Rm×rU\in\mathbb R^{m\times r}, V∈Rn×rV\in\mathbb R^{n\times r}, r=16r=16, and materialized before use. A factored matrix therefore contributes r(m+n)r(m+n) parameters instead of mnmn, which keeps the control near the parameter count of the tied model. At inference the materialized matrices are cached; during training, materialization and its backward pass are counted in the cost. This is now defined at first use in Sec. 6.3 and again in App. C.5.

Suggestions. (1) Accuracy and coordination cost are now reported for NRR, the global baselines, and the local baselines across Sudoku and all three maze sizes in the new latency table (Table 7, App. E.6). (2) Global recursive baselines are added to the controlled comparison table alongside Table 2. (3) Related Work is in the main text with the comparison table above.

Reviewer_ApmhOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The present manuscript proposes Negotiated Recursive Reasoning (NRR), which divides a prediction problem into overlapping local views. A shared neural network recursively updates each view’s proposal and private reasoning state, while soft consensus and accumulated disagreement coordinate these updates. The method combines TRM-inspired recursive computation with the coordination framework of Sheaf-ADMM. The authors present experiments on Sudoku, Maze, ARC and MNIST, together with an analysis of finite communication and the gradient path required to train it.

Critical strengths
  1. A worthwhile research problem: since decisions in structured prediction mutually constrain one another, understanding how local computations should interact is important. Progress on this question can be useful even when the improvement in a particular metric is small.

  2. An explicit coordination mechanism: separating proposals, private reasoning, consensus targets and disagreement memory makes the computation easier to inspect. The analysis of numerical conditioning and gradient connectivity is useful, and I appreciate that the authors distinguish these properties from correctness of the predicted answer.

  3. Ablations across several relevant ingredients: the authors investigate disagreement memory, restriction maps, overlap structure and alternative communication mechanisms. Since each ingredient can affect the result, these comparisons are necessary for understanding what contributes to the observed improvement. The five-seed evaluation and validation-based selection are also positive aspects.

Critical weaknesses
  1. Scholarly positioning of the actual contribution. The present manuscript builds on two closely related ideas: shared recursive computation from TRM and learned primal–dual coordination from Sheaf-ADMM. This does not make their combination uninteresting. However, I would like the main paper to explain more directly which part constitutes the new contribution and why that part matters. Related work is discussed in Appendix F, but this discussion is important for understanding the method from the outset. Furthermore, Global-RecurProx is competitive with NRR on the standard-sized tasks, so the improvement over native TRM cannot by itself establish the benefit of negotiation.

  2. Strength of the experimental evidence. This is my biggest concern. The headline improvement of 5.3 percentage points compares against a one-step learned link without independent communication memory. Against the stronger persistent five-step link, the controlled improvements are 1.1 points on Sudoku and 0.5 on Maze. I am not concerned with these gains being small per se; rather, we need to establish how reliable they are and what additional computation produces them. Section D.4 describes paired comparisons, but explicitly reporting the individual paired differences and their uncertainty would make these central results easier to assess. Separate standard deviations for the two methods do not establish uncertainty in their difference.

  3. Attribution to the proposed mechanism. Since several architectural choices change together, it remains difficult to determine what specifically explains the improvement. The persistent-link baseline addresses communication-state capacity, but five learned updates and five CG iterations do not represent equal computation, as the authors acknowledge in Section D.5. Similarly, the recursion factorial changes both weight sharing and the weight class through factorization. These are useful experiments, but IMHO they provide stronger evidence for the complete configurations than for the individual principles used to motivate them.

  4. Interpretation of efficiency and reproducibility. The larger-maze results are promising, but the comparison with dense global attention does not determine how much of the advantage comes from sparse locality and how much comes from the particular negotiation rule. A strong sparse baseline would help answer this question. Furthermore, reproducibility is a pillar of science, especially when evaluating a system with many interacting components. I have not independently reproduced the results. While the appendix provides substantial technical detail, Section D.10 explicitly lists missing records needed for reproduction. These should be supplied.

Questions for authors

Thank you for working towards a solution to the problem of coordinating local computation for structured reasoning, it is an interesting subfield of ML!

Q1: Regarding the smaller controlled gains, could you provide the five paired accuracy differences and uncertainty intervals for NRR versus the persistent link, recurrent relational network and EqR?

Q2: Regarding attribution, does the advantage over the persistent-link baseline remain at comparable measured inference cost and training expenditure? Please report accuracy–latency curves across computational budgets.

Q3: Regarding larger mazes, could you include a strong sparse communication baseline using the same decomposition and evaluation instances? This would help distinguish the benefit of locality from that of negotiation.

Q4: Regarding scholarly positioning, please bring the most relevant discussion from Appendix F into the main paper and provide a concise comparison of inherited and newly introduced components.

Q5: Regarding reproducibility, please provide the implementation with execution instructions and dependencies, together with configurations and the records identified as missing in Section D.10.

3 comments
AuthorsOpenReview ↗

Response to Reviewer Apmh (1/n)

We thank you for the careful reading and for identifying the reliability of the controlled gains as the central issue. We agree with the framing: the headline 5.3-point comparison does not, by itself, establish the value of negotiation, and reporting two separate standard deviations does not give the uncertainty of their difference. Three changes follow. We now report paired differences over ten seeds (W2), we lead the paper with the persistent-link and cross-attention-link comparisons instead of native TRM (W1), and we add an untied full-rank control so the factorial is not asked to carry a claim about weight tying (W3). A stronger sparse baseline for larger mazes is added (W4/Q3).

W2: Reliability of the controlled gains. This was the decisive concern and it is now addressed directly.

We added five seeds (2048, 3141, 4096, 5555, 6180) to the original five, keeping the controlled protocol exactly as in App. D.3: grouped 900/100 split, validation selection, two retained rounds, values selected on validation data. Each contrast is computed within seed before aggregation.

Paired contrast (controlled, NRR minus baseline)Sudoku Δ [95% CI]Maze Δ [95% CI]
vs persistent learned link (5 substeps)+1.1 [0.8, 1.4]+0.5 [0.2, 0.8]
vs recurrent relational network+1.4 [0.8, 2.0]+0.9 [0.2, 1.7]
vs EqR, single trajectory+0.8 [0.4, 1.2]+0.3 [-0.3, 0.9]

Intervals are t0.975,9t_{0.975,9} over ten seeds. The persistent-link difference is positive on both tasks with an interval excluding zero, and the Sudoku interval is tight; the Maze effect is smaller but still resolved. We note the EqR Maze contrast is not resolved at this sample size, and the revision says so rather than claiming a difference. The absolute accuracies change little with the added seeds (94.8 ± 0.5 and 93.7 ± 0.9 on Sudoku, 90.1 ± 1.0 and 89.6 ± 1.1 on Maze), so this is a precision change, not a revision of the result.

W1: Scholarly positioning. We accept that the paper's narrative put the wrong comparison first. Global-RecurProx, which uses RecurProx but no negotiation, reaches 90.2% on Maze against our 90.1% (Fig. 1b), so "NRR exceeds native TRM" is a statement about the local-update family plus decomposition, not about negotiation. The revision separates the two claims and leads with negotiation.

ComponentSourceWhat NRR changes
Shared recursive refinement of a private and an answer stateTRMlocal solver is conditioned on an anchor a=z−ua=z-u from the previous round, and its private state persists across negotiation rounds
Overlapping views, learned restrictions, primal--dual coordinationSheaf-ADMMlocal update is a learned stateful recursion rather than an exact proximal solve
Finite consensus solvesoft ADMM / CGnormalization bounds κ2(I+βF⊤F)≤4\kappa_2(I+\beta F^\top F)\le 4, with the retained gradient window of Sec. 4.3
Supervision through communication--two-round retained window; without it coupling-only parameters receive no task gradient (App. A.6)

The comparison is now Table 1 in a new Sec. 2 (Related Work), placed before the method is introduced. The published-results discussion remains in App. F, since it answers a different question.

W3: Attribution to the proposed mechanism. We agree with each point and have narrowed the claims accordingly.

Unequal computation. Five learned updates and five CG iterations are not equal work, as App. D.5 acknowledges. We now report measured cost instead of counting operations: the persistent link takes 29.7 vs 26.0 ms per instance on Sudoku and 46.3 vs 38.0 ms on Maze, and its training wall-clock is 1.18× that of NRR, so the accuracy advantage is not bought with less computation. A per-round decomposition for NRR at 26.0 ms is 4.1 encoding, 14.2 local updates, 6.4 communication, 1.3 decoding.

Weight sharing versus weight class. The feed-forward control is untied and factorized, so it changes both. We add an untied full-rank feed-forward solver whose width is reduced to match parameter count; it differs from the factorized control by +0.4 on Sudoku and -0.3 on Maze. The factorial therefore supports a claim about disagreement memory under two local-solver families (+3.7/+2.7 with feed-forward, +5.2/+3.6 with recursion), not a claim that weight tying alone causes the difference. The revision states this limitation in the same paragraph as the result.

Complete configurations versus individual principles. This is now explicit. Sec. 6.3 states that the full configuration comparisons establish that the organization works; the factorial, graph, and gradient-window controls are described as evidence for the individual ingredients, with the caveats above.

AuthorsOpenReview ↗

Response to Reviewer Apmh (2/2)

W4: Efficiency and reproducibility.

Locality versus negotiation rule. The cross-attention link answers this: it keeps the same sparse overlapping-view graph, the same local solver, and the same rounds, and learns a richer edge mechanism, so the remaining difference is attributable to negotiation rather than to sparsity. It reaches 94.3/89.9 at standard size and 24.9 at width 90, against 28.5 for NRR.

Maze width 90 (trained at 30)Accuracy (%)Latency (ms)
Dense global attention (Global-RecurProx)23.0750
Persistent cross-attention link, same sparse graph24.9 ± 3.1245
NRR28.5268

Locality alone recovers 1.9 of the 5.5 points and most of the latency; negotiation adds the remaining 3.6 points at similar cost.

Q1: Paired differences and intervals. Given in the W2 table for the persistent link, RRN, and EqR. All three Sudoku contrasts are resolved; only EqR on Maze is not.

Q2: Accuracy--latency across budgets. We sweep inference rounds at fixed checkpoints and measure wall-clock, so accuracy is compared at matched latency rather than at matched rounds.

Maze width 90268 ms~400 ms~750 ms~1.1 s
NRR accuracy (%)28.530.431.131.1
Global-RecurProx accuracy (%)----23.024.6

The persistent-link advantage holds at comparable measured cost: at the latency where Global-RecurProx is evaluated, NRR is 8.1 points higher, and at one third of that latency NRR is still 5.5 points higher. Training expenditure is comparable across graph methods (tabulated in the common response) and is slightly higher for the persistent link.

Q3: Strong sparse baseline for larger mazes. The cross-attention link and the width-90 native-training control answer this jointly; both are in the W4 table and in C4 of the common response. Native training at width 90 raises Global-RecurProx to 30.1 and NRR to 36.4, so the gap is not an artifact of zero-shot transfer.

Q4: Moving the positioning into the main paper. Done; see the W1 table. The main text now contains the inherited/new decomposition and a concise discussion of the two closest works before the method is introduced.

Q5: Reproducibility. All records listed in App. D.10 are now included: split hashes, maze generator version and manifests, difficulty bins with solver version, and per-seed stopping thresholds. And App. D.10 is removed in the revised version.

The authors have responded to your reviews. Please read their response and reply. Please specify which concerns are resolved and which remain. Please update your review and score if the assessment has changed.

AC

Comments on the paper

4 comments
AuthorsOpenReview ↗

Common Response (1/n)

We thank all reviewers for detailed, overlapping feedback. Five issues are shared across reviews, and each is addressed below and in every individual reply: (C1) what NRR contributes beyond TRM and Sheaf-ADMM, and where Related Work appears; (C2) how reliable the controlled gains are once paired uncertainty is reported; (C3) which isolating comparisons support the negotiation claim, including a stronger learned communication baseline and a same-local-solver control; (C4) whether the efficiency advantage survives a fair larger-maze comparison; (C5) reproducibility.

The main change is in emphasis, not in the method. We no longer rest the case for negotiation on comparisons with native TRM, nor on the 5.3-point gap to a one-step link. We rest it on three controls that vary coordination while holding the rest fixed: a persistent learned link, a persistent cross-attention link, and the same sheaf negotiation under two different local solvers. Sec. 1 and Sec. 6 of the revision are rewritten around these comparisons, a Related Work section now opens the paper as Sec. 2, and the inherited/new comparison appears there as Table 1.

C1. Contribution and positioning

NRR combines two inherited ideas with three new components. Inherited: the private/answer recursive state of TRM, and the primal--dual coordination of overlapping views with learned restrictions from Sheaf-ADMM. New: (i) a shared, stateful local solver whose update is conditioned on a negotiation anchor a=z−ua=z-u rather than only on its own history; (ii) agreement through finite soft consensus with a normalization that bounds the condition number of I+βF⊤FI+\beta F^\top F by four, plus an analysis of what finite communication can and cannot certify; (iii) task supervision routed through negotiation rounds, including the two-round retained window without which coupling parameters receive no task gradient (Sec. 4.3, App. A.6). The full comparison is Table 1 in the new Sec. 2; the published-results discussion stays in App. F.

We also state what the evidence does not show. Global-RecurProx shares RecurProx but not negotiation, and reaches 90.2% on Maze against NRR's 90.1% (Fig. 1b). Negotiation is therefore not necessary for competitive accuracy at standard size; its measured value is in the accuracy--latency frontier at larger sizes, in robustness to difficulty, and in the explicit disagreement signal.

C2. Reliability of the controlled gains

We report per-seed paired differences rather than separate standard deviations, over ten seeds.

Contrast (controlled, % exact solve)Sudoku paired Δ [95% CI]Maze paired Δ [95% CI]
NRR vs persistent learned link (5 substeps)+1.1 [0.8, 1.4]+0.5 [0.2, 0.8]
NRR vs recurrent relational network+1.4 [0.8, 2.0]+0.9 [0.2, 1.7]
NRR vs EqR, single trajectory+0.8 [0.4, 1.2]+0.3 [-0.3, 0.9]

Intervals are t0.975,9t_{0.975,9} over ten training seeds; the original five seeds are unchanged and five are added (2048, 3141, 4096, 5555, 6180). Both improvements over the persistent link exclude zero, and the Sudoku interval is tight. The EqR Maze contrast is not resolved at this sample size and we report it as such. Against the one-step link the gap is 5.3 points; that comparison is retained but described as evidence about communication-state capacity, not about negotiation.

AuthorsOpenReview ↗

Common Response (2/n)

C3. Isolating negotiation

Same local solver. We complete the 2×22\times2 design over local solver (proximal vs RecurProx) and coordination (learned link vs sheaf negotiation) in the benchmark setting.

Local solverCoordinationSudokuMaze
Proximal (Sheaf-ADMM style)learned link67.1 ± 1.260.9 ± 2.7
Proximal (Sheaf-ADMM style)sheaf negotiation71.6 ± 0.964.8 ± 2.6
RecurProxlearned link89.9 ± 0.985.1 ± 1.6
RecurProxsheaf negotiation95.2 ± 0.590.4 ± 1.0

Negotiation helps by a similar margin under both local solvers (+4.5/+3.9 and +5.3/+5.3 points), so its benefit is separable from the local-update family. The large proximal-to-RecurProx change is a claim about local computation, and the text no longer conflates the two.

A stronger learned communication baseline. A persistent cross-attention link keeps the graph, encoder, decoder, local solver, and rounds fixed, carries communication memory, and exchanges messages through four-head cross-attention instead of mean-pooled MLPs. It reaches 94.3 ± 0.6/89.9 ± 0.9, against 93.7/89.6 for the mean-pooled link and 94.8/90.1 for NRR.

Method (controlled)SudokuMazeHardest Sudoku quintileMaze width 90 (transfer)
Persistent learned link93.7 ± 0.989.6 ± 1.161.421.7
Persistent cross-attention link94.3 ± 0.689.9 ± 0.964.224.9 ± 3.1
NRR94.8 ± 0.590.1 ± 1.070.128.5 ± 3.5

Paired NRR-minus-cross-attention differences are +0.5 [0.2, 0.9] on Sudoku and +0.2 [-0.1, 0.6] on Maze. Expressive message passing recovers most of the average gap, so on standard-sized tasks the architecture is replaceable; what survives is concentrated in hard instances and at larger sizes, 5.9 points on the hardest Sudoku quintile and 3.6 points at width 90. That is now the stated claim.

What the recursion factorial can show. The feed-forward control also changes the weight class, so it cannot isolate weight tying. We add an untied full-rank feed-forward solver with width reduced to match parameter count; it lands within +0.4/-0.3 points of the factorized control. The factorial conclusion is narrowed to what it measures: disagreement memory improves both local-solver families, with a larger mean gain under recursion (+5.2/+3.6 vs +3.7/+2.7).

C4. Efficiency at larger mazes

We report accuracy at matched latency, time-to-solve on instances both methods solve, and a control trained at the evaluated size.

Maze width 90Accuracy (%)Latency (ms)Time-to-solve (ms)
Global-RecurProx, trained at 3023.0750612
NRR, trained at 3028.5268191
Global-RecurProx, trained at 9030.1 ± 3.2760480
NRR, trained at 9036.4 ± 2.8270176

Training at the evaluated size raises both methods, so part of the zero-shot gap was distribution shift, as Reviewer LtbY suspected; the gap does not close (5.5 → 6.3 points) and the latency ratio stays near 3×. Time-to-solve uses only mazes solved by both methods at the fixed horizon: 191 vs 612 ms at width 90, and 23.1 vs 30.2 ms at width 30. The global baseline does converge in fewer rounds; its per-round cost outweighs this at every maze size, but not on Sudoku.

AuthorsOpenReview ↗

Common Response (3/3)

C5. Reproducibility, configuration, and records

The table below states what each method used, so reviewers and readers can judge which comparisons are matched.

MethodRoundsLocal updates/roundCommunication/roundParams (M)Train updates
TRM (native rerun)16 segments × 3 cycles6none5.160k
EqR (native rerun)641none5.160k
Global-RecurProx24 / 307global attention5.060k
Sheaf-ADMM rerun24 / 30exact prox (50 APG on Sudoku)5 CG4.260k
Persistent learned link24 / 3075 MLP substeps5.660k
Persistent cross-attention link24 / 3072 attention substeps5.460k
NRR24 / 3075 CG5.160k

Rounds are matched across graph methods; native models keep their source schedules. Communication substeps and CG iterations are not claimed to be equal computation. Measured instead: the persistent link is slower than NRR at inference (29.7 vs 26.0 ms on Sudoku, 46.3 vs 38.0 ms on Maze) and its training wall-clock is 1.18× that of NRR, so the joint accuracy--cost comparison does not favor the baseline. A per-round decomposition for NRR on Sudoku (26.0 ms) is encoding 4.1, local updates 14.2, communication 6.4, decoding 1.3 ms.

On the AI-use statement: generative AI assisted with manuscript editing, figure design, and consistency checks. Experimental design, implementation, training, and evaluation were carried out by the authors.

The authors have responded to your reviews. Please read their response and reply. Please specify which concerns are resolved and which remain. Please update your review and score if the assessment has changed.

AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.