{"id":"3b8f4f8a-d875-4192-8089-eaf49c47ea38","arxiv_id":"2607.08735","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"unknown","formal_verification":"none","parameter_count":10,"one_line_summary":"A learned feedback policy replaces manual parameter tuning in distributed Riemannian optimization over matrix Lie groups, achieving lower objective values on multi-robot mapping benchmarks.","lead":"This paper trains a neural network to automatically tune the parameters of a distributed optimization solver for multi-robot 3D mapping problems. It matters because it removes the need for manual parameter tuning, making multi-robot mapping systems more robust and easier to deploy in real-world scenarios.","discovery_kind":"unclear","skeptic_critique":{"model":"glm-5.2","headline":"Policy trained on simplified ODE (Eq. 8) but evaluated on full CORD dynamics (Eq. 4) with co-adjoint term — train-test dynamics mismatch is untested and could affect parameter optimality, especially on SL(4).","rationale":"The reader identifies generalization across iteration count and graph scale as the weakest assumption. This is a legitimate concern, but it is empirically addressed by the Rim dataset (10,195 nodes, trained on ~500) and the 500-iteration performance profiles (Fig. 5). The dynamics mismatch I identify is more subtle and less directly tested: the policy never sees co-adjoint-term-influenced state trajectories during training, yet its predicted parameters are plugged into dynamics that include this term at test time. This is a real gap, but the empirical results are strong enough that it does not clearly invalidate the central claim — hence UNCHANGED. The concern does suggest a specific follow-up (train on full dynamics, compare) that would either confirm robustness or reveal a hidden limitation. The reader's CONDITIONAL verdict is reasonable given the lack of convergence guarantees and code, and my concern does not move the needle further. Both concerns stem from train-test gaps but target different mechanisms: the reader focuses on scale/temporal generalization, I focus on dynamics fidelity. The SL(4) results in Table 2, where DeepCORD remains far from the centralized reference, are where this concern is most visible, though severe initial perturbations provide a partial confound.","tokens_in":18803,"tokens_out":3729,"duration_ms":231884,"concrete_test":"Train a DeepCORD model using the full CORD dynamics (including co-adjoint and time-varying mass terms) during unrolling, with all other training settings identical. Compare test-time performance against the current simplified-dynamics model on the same SL(4) and SE(3) benchmarks. If the full-dynamics model achieves materially lower cost (e.g., >10% improvement on TUM1/TUM3 or on asynchronous S3E sequences), the train-test dynamics mismatch is a real limitation; if performance is statistically indistinguishable, the mismatch is benign.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central empirical claim requires that parameters predicted by the learned policy lead to good convergence under the full CORD dynamics (Eq. 4) at test time. However, training unrolls a simplified ODE (Eq. 8 / Appendix D) that omits the co-adjoint term ad*_ξ(Mξ) and the time-varying mass term ˙Mξ. The co-adjoint term captures Lie-group non-commutativity and can be non-negligible for SE(3) (coupling rotation/translation) and especially SL(4) (15-dimensional algebra). Because the policy conditions on state features (body velocity ξ, gradient g, residuals) whose trajectories differ between simplified and full dynamics, the policy may encounter state distributions at test time that it never saw during training. Appendix D shows the simplified dynamics preserves energy dissipation qualitatively, but this does not establish that parameters optimal for simplified dynamics remain near-optimal under full dynamics. The concern is most acute for SL(4), where the co-adjoint structure is richer and the empirical gap to centralized GTSAM is large (Table 2: DeepCORD 2.304 vs. reference 0.876 on TUM1), making it unclear whether the policy is limited by the dynamics mismatch or by fundamental problem difficulty.","agreement_with_reader":"partial"},"referee_report":{"model":"glm-5.2","summary":"The paper presents DeepCORD, a learning-augmented framework for distributed factor graph optimization over general matrix Lie groups. The method unfolds the CORD distributed Riemannian optimizer into differentiable iterations and trains a GNN-based feedback policy to predict adaptive solver parameters (mass, damping, step size) from local optimization context. Training is self-supervised via deep unfolding, minimizing unrolled objectives without requiring optimal solutions. The method is evaluated on SE(3) pose graph optimization (13 benchmark sequences under synchronous and asynchronous communication) and SL(4) projective submap alignment (3 TUM RGB-D sequences), demonstrating lower objective values than distributed baselines on most benchmarks. The approach is principled in preserving the geometric structure of the underlying optimizer while replacing manual parameter tuning with a learned policy.","tokens_in":19061,"tokens_out":2825,"duration_ms":224761,"significance":"The problem addressed—parameter sensitivity in distributed geometric optimization—is practically important for multi-robot SLAM and 3D reconstruction systems. The contribution of extending learning-to-optimize to distributed optimization over general matrix Lie groups, including under asynchronous communication, is novel and fills a genuine gap in the literature. The self-supervised training formulation (Eq. 7) that avoids dependence on optimal solutions is a strength, as is the demonstration of generalization to graphs larger than those in training (Rim: 10,195 nodes vs. training at ~500 nodes). The extension beyond SE(3) to SL(4) projective alignment, motivated by recent feed-forward SLAM systems, is timely. The extensive experimental evaluation across 26 PGO instances and 3 SL(4) datasets, with both synchronous and asynchronous protocols, provides substantial empirical support for the central claim.","major_comments":[{"comment":"Train-test dynamics mismatch (§4, Eq. 4 vs. Eq. 8/Appendix D). The policy is trained by unrolling a simplified ODE (Eq. 8) that omits the co-adjoint term ad*_ξ(Mξ) and the time-varying mass term Ṁξ, but at test time the full CORD dynamics (Eq. 4) are used. The co-adjoint term captures Lie-group non-commutativity and is potentially non-negligible for SE(3) (rotation-translation coupling) and especially SL(4) (15-dimensional algebra). Appendix D shows the simplified dynamics preserves energy dissipation qualitatively, but this does not establish that parameters optimal for the simplified dynamics remain near-optimal under the full dynamics. The paper should provide at least one of the following: (a) an ablation comparing test-time performance when the policy is trained on full vs. simplified dynamics, (b) empirical evidence that state distributions (ξ, gradient, residuals) encountered at测试","section":null},{"comment":"SL(4) results show a large gap to centralized reference (Table 2). On TUM1, DeepCORD achieves cost 2.304 vs. reference 0.876—a gap of ~2.6×. While the paper attributes this to 'severe initial perturbations' (0.2 rad rotation, 0.1 m translation), it is unclear whether the dynamics mismatch described above contributes to this gap, or whether the gap reflects a fundamental limitation of the distributed approach under such perturbations. A sensitivity analysis varying the perturbation magnitude on SL(4) (analogous to Appendix A.3 for SE(3)) would help disentangle these factors and clarify whether the learned policy is limited by the training simplification or by problem difficulty.","section":null},{"comment":"Generalization horizon (§4, §7). The policy is trained on K=50 unrolled iterations but evaluated over 500 iterations (Fig. 5). While the performance profiles show stable convergence, the paper does not report whether the predicted parameters remain well-behaved beyond 100 iterations or whether the policy enters degenerate regimes (e.g., vanishing step sizes) over very long horizons. Reporting the distribution of predicted parameters over the full 500-iteration horizon (extending Fig. 6) would strengthen the claim of stable long-horizon generalization.","section":null}],"minor_comments":[{"comment":"§4, Eq. (6): The policy outputs (m_k^i, d_k^i, Δt_k^i) are robot-level scalars, but the CORD update in Eq. (4) uses block-diagonal M_i = mH_i and D_i = dH_i where H_i varies per robot. It would help to clarify whether the policy predicts a single scalar per parameter per robot, or per-node values that are aggregated.","section":null},{"comment":"Table 1: The 'Ref.' column is described as obtained from SE-Sync, but for some datasets (e.g., S3E sequences) the reference cost is much lower than any distributed method. Clarifying whether SE-Sync was run to global optimality or to a tolerance would help interpret the gaps.","section":null},{"comment":"Appendix B.1: The communication feature c_u^k for asynchronous communication is defined as qΔt_{k-q}^j, but the units and interpretation are unclear. Is this the product of delay (in iterations) and the delayed step size? A brief clarification would help reproducibility.","section":null},{"comment":"§5.2: The SL(4) evaluation uses only 3 datasets with relatively small graphs (89–249 nodes). Given that the SE(3) evaluation includes graphs up to 10,195 nodes, the SL(4) evaluation would benefit from at least one larger-scale example to support the generalization claim.","section":null},{"comment":"Figure 4: The architecture diagram is dense and some labels are difficult to read. Consider simplifying or enlarging key components for clarity.","section":null},{"comment":"Appendix C.1: The downsampling procedure for real-trajectory graphs is described in detail, but the rationale for the specific thresholds (5 m for loop closures, 1.4 m for grid/helix, etc.) is not provided. A brief justification would improve reproducibility.","section":null},{"comment":"§7 (Limitations): The discussion of overly conservative behavior on CampusRoad3 is useful but brief. Quantifying the 'premature refinement regime' (e.g., showing the predicted parameter trajectories for this specific case) would make the limitation more concrete and actionable.","section":null}],"recommendation":"minor_revision","confidential_remarks":"The paper builds on CORD [45], which is co-authored by the present authors. This is disclosed transparently and the contribution of DeepCORD (learned adaptive parameters) is conceptually independent of CORD's theoretical foundations. The self-supervised training does not rely on CORD's convergence proofs. I do not see a circularity issue. The train-test dynamics mismatch is the most substantive concern; if the authors can provide even a simple ablation showing that full-dynamics training does not substantially change results, this would resolve the concern cleanly. The SL(4) results, while showing improvement over baselines, are the weakest part of the evaluation and would benefit from additional analysis."},"author_rebuttal":null,"desk_editor":{"model":"glm-5.2","letter":"Here's the short version: DeepCORD learns adaptive solver parameters (mass, damping, step size) for distributed factor graph optimization on matrix Lie groups by unfolding CORD into differentiable iterations and training a GNN-based feedback policy self-supervised. The experimental results are strong — best or tied-best on 21 of 26 PGO benchmarks and all 3 SL(4) datasets — and the generalization from 500-node training graphs to the 10,000-node Rim graph is genuinely impressive. The main soft spot is a train-test dynamics mismatch that the paper acknowledges but doesn't fully resolve, and it matters most for the SL(4) results where the gap to centralized solvers is large. I think this deserves a serious referee. The core contribution is real and the execution is careful. The paper extends deep unfolding to distributed Riemannian optimization on general Lie groups under asynchronous communication, which is a new and useful combination. The self-supervised training (minimizing unrolled objectives without optimal-solution supervision) is clean, and the parameter analysis in Figure 6 showing phase-specific and delay-aware adaptation is insightful — the policy genuinely learns to be conservative early and aggressive late, and to adjust for communication staleness. The honest limitations section is a plus. Now the soft spots, in proportion. The stress-test concern about training on the simplified ODE (Eq. 8, no co-adjoint or time-varying mass terms) while evaluating on full CORD dynamics (Eq. 4) is legitimate. Appendix D shows the simplified dynamics preserves energy dissipation qualitatively, but that doesn't prove parameters optimal for simplified dynamics remain near-optimal under full dynamics. This is most acute for SL(4), where the 15-dimensional algebra has richer co-adjoint structure and the empirical gap to GTSAM is large (2.304 vs 0.876 on TUM1). That said, DeepCORD still beats CORD and DJ on SL(4), so the policy isn't failing — it's just unclear how much of the gap is dynamics mismatch versus problem difficulty from severe initial perturbations. The reader flagged this correctly. The generalization from 50 training iterations to 500 evaluation iterations is empirically supported by the performance profiles (Figure 5 shows stable convergence), but theoretically unguaranteed. No code is shipped, which hurts reproducibility. No convergence guarantee, honestly acknowledged. These are real but proportionate concerns — the central empirical claim is well-supported and the method is a genuine advance over hand-tuned distributed solvers. Recommend accepting for peer review.","headline":"Solid L2O approach to distributed Lie-group optimization; train-test dynamics mismatch is a real but non-fatal gap","tokens_in":19510,"tokens_out":1744,"would_cite":true,"duration_ms":96592,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"glm-5.2","headline":"Learned policy replaces hand-tuning in distributed robot optimization","keywords":[],"falsifier":"If the learned policy fails to outperform well-tuned fixed parameters on problem instances whose topology, noise level, or communication regime differs substantially from training data, the core claim of robust generalization would be undermined. The CampusRoad3 synchronous result, where the policy enters premature refinement due to small local gradients despite large global error, is a concrete instance of this failure mode.","tokens_in":19121,"feed_emoji":"🤖","tokens_out":901,"duration_ms":176177,"temperature":0.7,"pith_summary":"The paper claims that the parameters governing distributed geometric optimization over matrix Lie groups can be replaced by a learned feedback policy. Instead of manually setting mass, damping, and step size for a Riemannian optimizer, the authors unfold the optimizer's iterations into a differentiable computation graph and train a graph neural network to predict these parameters from local optimization context. The network sees local velocities, gradients, residuals, and communication delay statistics, and outputs per-robot, per-iteration parameters. Trained self-supervised by minimizing the optimization cost along 50 unrolled iterations, the resulting solver generalizes to graphs of 10,000+ nodes, 500+ iterations, and communication regimes with random delays and packet loss. On 21 of 26 pose graph benchmarks and all three projective alignment benchmarks, it achieves lower objective values than hand-tuned distributed baselines.","feed_headline":"","feed_subtitle":"","key_machinery":"The load-bearing machinery is the deep unfolding of the CORD Riemannian optimizer: each iteration's parameter selection is made differentiable, gradients of the final optimization cost flow back through 50 iterations of solver steps, and a graph neural network learns to map local optimization state to solver parameters. Implicit differentiation through a preconditioned conjugate gradient solver avoids memory blowup from backpropagating through linear solves.","core_discovery":"The central mechanism is the replacement of fixed solver hyperparameters with a shared, locally-computed feedback policy. Each robot constructs a two-hop augmented graph from its own variables and the most recently received neighbor states, attaches node-level features (body velocity, gradient, communication staleness), edge-level features (residuals, precision weights), and graph-level features (intra/inter-robot residual norms, update magnitudes), and feeds these through a GPS graph transformer with a parameter prediction head. The predicted mass, damping, and step size are then consumed by the underlying Riemannian optimizer update. The key empirical finding is that this policy, trained只在","pith_inferences":["The paper trains separate models for SE(3) and SL(4), leaving open whether a unified policy across Lie groups is feasible or whether group-specific dynamics require separate learned components.","The conservatism on CampusRoad3 (where small local gradients cause premature refinement) suggests that purely local features may be fundamentally insufficient for detecting global optimality, and that some form of global or dual information may be necessary for robust convergence detection.","The energy dissipation argument for the simplified training dynamics (Appendix D) suggests that the learned parameters preserve convergence properties of the underlying ODE, but this is shown only for the simplified system used during training, not for the full dynamics used at inference."],"forward_implications":["If a learned policy can replace hand-tuned parameters for distributed Lie group optimization, the same approach could extend to other distributed iterative solvers where parameter sensitivity is the main deployment bottleneck.","The finding that parameters trained on 500-node, 50-iteration graphs transfer to 10,000-node, 500-iteration settings suggests that optimization dynamics have transferable structure that a policy can capture without problem-specific retraining.","The phase-specific parameter schedules discovered by the policy (conservative early, aggressive late, communication-aware) provide empirical priors that could inform the design of non-learned adaptive solvers.","Generalization beyond SE(3) to SL(4) projective alignment with a separate trained model suggests the framework is group-agnostic in principle, though whether a single policy could span multiple groups remains open."],"fun_headline_variants":["DeepCORD learns solver parameters for distributed factor graph optimization","Learned feedback policy replaces hand-tuned parameters in distributed solvers","Graph transformer predicts Riemannian optimizer parameters for multi-robot SLAM","Adaptive distributed optimization on matrix Lie groups via learned policy","Self-supervised policy adapts distributed solver to communication conditions"],"cache_read_input_tokens":0,"weakest_assumption_plain":"The central assumption is that a policy trained on small graphs (~500 nodes) and short horizons (50 iterations) will generalize to graphs with 10,000+ nodes and 500+ iterations. The paper acknowledges this limitation but the empirical results on the Rim dataset provide the main evidence that it holds.","fun_headline_variants_meta":{"raw":{"variants":["DeepCORD learns solver parameters for distributed factor graph optimization","Learned feedback policy replaces hand-tuned parameters in distributed solvers","Graph transformer predicts Riemannian optimizer parameters for multi-robot SLAM","Adaptive distributed optimization on matrix Lie groups via learned policy","Self-supervised policy adapts distributed solver to communication conditions","DeepCORD predicts mass, damping, step size for distributed geometric optimization","Graph transformer feedback replaces manual tuning in distributed Lie group solvers"]},"model":"glm-5.2","effort":"low","cost_usd":0.0,"raw_usage":{"total_tokens":1539,"prompt_tokens":426,"completion_tokens":1113,"prompt_tokens_details":null},"tokens_in":426,"tokens_out":1113,"duration_ms":65241,"temperature":1.0,"reasoning_tokens":1165,"cache_read_input_tokens":0,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-07-10T02:05:27.209942+00:00","model_set":{"reader":"glm-5.2"},"falsifier":"If the learned policy fails to outperform well-tuned fixed parameters on problem instances whose topology, noise level, or communication regime differs substantially from training data, the core claim of robust generalization would be undermined. The CampusRoad3 synchronous result, where the policy enters premature refinement due to small local gradients despite large global error, is a concrete instance of this failure mode.","supporting_citations":[],"review_version":1}