acceptodds
Under review as a conference paper at ICLR 2027

Connected by Construction: Learning Tractable Near-Tour Marginals for Traveling Salesman Problems

Abstract

Learning-based methods for the traveling salesman problem (TSP) are often evaluated through the tours produced after decoding or search, but the learned object itself frequently lives in a surrogate space such as heatmaps, assignments, construction policies, or search-guidance scores. This obscures a basic question: which Hamiltonian structures can a model represent and learn tractably, and how does learning them directly lead to better tours? In this study, we directly answer this question by learning a structurally meaningful latent object for TSP, rather than leaving most of the Hamiltonian structure to the final decoding stage. Based on a connected-by-construction rooted 1-tree Gibbs family, we propose an end-to-end unsupervised learning pipeline called C2TSP. The pipeline learns residual edge perturbations from the penalty-free TSP cost through implicit differentiation. For structural correction, a smoothed Held-Karp layer restores expected degree balance, while certificate-guided sharpening further pushes the connected distribution toward more tour-like structures. Experiments show that C2TSP learns interpretable, tour-like structure, and ablations verify that edge perturbation and certificate-guided sharpening jointly improve both this structure and the tour cost. C2TSP also yields strong decoding performance, transfers zero-shot to metric non-Euclidean instances, and remains robust as a candidate source for the LKH heuristic.

Primary area:
optimization
Keywords:
Traveling Salesman Problem, Combinatorial Optimization, Tractable Inference, Held-Karp Relaxation, Differentiable Optimization, Unsupervised Learning

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_PESdOpenReview ↗
Rating
4
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

Authors propose an unsupervised learning pipeline for solving the traveling salesperson problem. Ideally, one would like to learn Gibbs distribution over Hamiltonian cycles, which is computationally intractable. Therefore, one would like to consider a tractable surrogate which captures some of the structure of the Hamiltonian cycles.

Authors consider Gibbs distribution over 1-trees -- an object frequently used in the classical TSP heuristics, which can be seen as a tractable surrogate. Any TSP tour is a 1-tree, but a 1-tree is a tour only if all its vertices have degree equal to 2. However, they resemble tours much better than arbitrary heatmaps, as they are connected. To make produced 1-trees resemble tours even more, they add additional terms based on the classical Held-Karp dual ensuring that the expected degree of each vertex is 2.

In empirical evaluation, authors show that the outputs of their model really resemble tours (connected and degrees close to 2). They also show performance improvements over previous works.

Critical strengths
  • I like the idea of unsupervised learning steered towards structured surrogates motivated by theory. Likely, incorporating theoretical knowledge about TSP in the learning pipelines will be needed for further progress.
  • performance improvements compared to the existing models are well visible in the empirical experiments
  • I appreciate that the authors considered also non-euclidean TSP instances, as the euclidean ones have very little structure and, moreover, the classical methods solve them very well.
Critical weaknesses
  • I find the comparison with the previous models somewhat dubious in the case of non-euclidean datasets, as the other models (due to their design) are run without access to the real distance matrix. I wonder if it would be better to present only the numbers corresponding to the model proposed in this paper.
Questions for authors

I see the overlap with the optimal tour in table 1. I am wondering what is the effect of the decoder here, since the decoder can deviate from the original heatmap when turning it into a tour. What would be the (weighted) coverage of the original heatmap?

2 comments

Summary of our response. We thank the reviewer for the constructive comments. We first summarize our responses to the two questions and then respond in detail:

  1. Response to the non-Euclidean comparison (W1): We accept the suggestion and will keep only the C2TSP numbers in the main text.

  2. Response to the effect of the decoder (Q1): The decoder has little effect, because the learned marginal already covers almost the same Concorde-tour edges as the decoded tour.

(W1) Should only the C2TSP numbers be reported on non-Euclidean instances?

We agree and will keep only the C2TSP numbers in the main text, moving the baseline numbers to the appendix and summarizing the comparison in words, since the baselines cannot access the distance matrix. This change does not weaken our design advantage: every C2TSP component, including edge-perturbation learning, HK equilibration, and certificate-guided sharpening, operates directly on the edge costs. Adding distance-matrix features to the baselines or retraining them on non-Euclidean instances would not necessarily remove this gap, because learning from a general cost structure remains difficult without a cost-aware algorithmic design.

(Q1) What is the effect of the decoder on the coverage in Table 1?

The decoder has little effect on coverage: the top-n edges of the learned marginal recover 87.80% of the Concorde-tour edges (82.87% cost-weighted), almost the same as the 87.51% (83.57%) recovered by the decoded tour in Table 1 (Table R1). The reason is that the structured MAP decoder (Appendix D) builds tours from MAP rooted 1-trees of the learned distribution and only repairs their degree defects, so it preserves the learned structure.

Table R1: Coverage of Concorde-tour edges on TSP-50 (P+S): top-n marginal edges versus the decoded tour.

Top-n Cov.Top-n Cost Cov.Decoded Cov.Decoded Cost Cov.
0.87800.82870.87510.8357

We hope these responses address the reviewer's concerns, and we are happy to answer any further questions during the discussion period.

thank you for your response. Similarly to Reviewer RWSX, I like the method proposed in your paper. Since I am not an experimentalist I consider this method your main contribution and I maintain my score. However, it would surely help to clarify the issues in the experimental section with RWSX.

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

The paper presents a novel method to train end-to-end models to generate valid TSP tours in an unsupervised way. The loss is computed directly on the expected tour costs and the tour is ensured to be a valid hamiltonian cycle using an implicitly differentiable Held-Karp layer.

Critical strengths
  • The paper provides an end-to-end way to train a model on the TSP. This is particularly useful in NCO as some domains of applications might lack the existence of a solver to learn from.
  • The mathematical formulations are strong and directly target a valid hamiltonian cycle construction. Some previous similar methods could not enforce that constraint and had a mismatch between inference and training objectives.
  • The work is very original.
Critical weaknesses
  • The results are of the method are not very promising. The trained model is weak. I do not have any issue with small models, but I am still expecting good performance on such a problem with a large number of strong baseline. I believe the small size and short training budget is the issue here.
  • Training the other baselines under the same training budget is not the method the most faithful to the original work. Taking the original model weights would be better.
  • There are some questions on the scalability of the method. There are no results on TSP-10,000, which might be linked to the scaling issue of the method.
  • The integration with LKH is a bit problematic. In real life scenarios, such solver would not exist. It also blurs the actual effectiveness of your method.
Questions for authors
  • Can you confirm that the main reason for your smaller model size and training budget is because the HK layer computations and implicit differentiation are too costly? Have you tried training larger models?
  • Could you present results on TSP-10,000?
  • Could you show the results of the non-perturbed model on larger TSP instances (TSP-500 and TSP-1000)?
5 comments

Summary of our response. We thank the reviewer for the constructive comments. We first summarize our responses to all concerns and then respond in detail:

  1. Response to the model size and training budget (W1, W2): The small model is a consequence of our design, because parameter-free layers build the structure into the output and the network only bridges the remaining gap to the final tour; all baselines are retrained under the same budget because their released checkpoints use more than two orders of magnitude more training.

  2. Response to scalability (W3, Q2): C2TSP performs structural inference, and its benefits are shown through structural metrics without very large instances.

  3. Response to the LKH integration (W4): Beyond decoding tours directly, the structure learned by C2TSP can guide LKH, a primal heuristic that relies on the Held–Karp dual information C2TSP also produces.

  4. Response to the cost of the HK layer (Q1): The cost of the HK layer is not the reason for the small model or the training budget.

  5. Response to the non-perturbed model on larger instances (Q3): The TSP-50 ablation conclusions largely carry over to TSP-500 and TSP-1000.

(W1 / W2) Is the model too small, and should the baselines use their released weights?

For W1: The small model is a consequence of our design rather than a limitation: parameter-free layers build the structure into the output, which is the core contribution of our method. The rooted 1-tree family guarantees connectivity, HK equilibration restores the expected degree balance, and certificate-guided sharpening reduces the non-tour mass. The network therefore only needs to bridge the gap between this structured distribution and the final tour, by learning a residual edge perturbation that tilts it toward low-cost tours, guided by the descent of the expected tour cost (Section 2.3). This agrees with the algorithmic-alignment view that a network needs fewer training samples when it only has to learn simple steps of an algorithm [2]; Parjadis et al. [3] similarly pair a small GNN with the classical Held–Karp bound. Table 12 compares all model sizes: C2TSP has 123,750 parameters, compared with 5.3M for DIFUSCO and Fast-T2T, yet it achieves the lowest gap in 20 of the 25 settings in Table 2. The small network also makes C2TSP lightweight to embed in downstream tasks that contain TSP as a subproblem, which could use its learned structural distribution directly.

For W2: We retrained all baselines under the same training budget as C2TSP, rather than using their released weights, because a fair comparison trains and tests all methods on the same data. On TSP-100, C2TSP is trained on 2,048 instances for 100 epochs, i.e., about 0.2M instance-epochs. The released checkpoints use far larger budgets: DIFUSCO is trained on 1,502,000 instances for 50 epochs (75.1M instance-epochs), and Fast-T2T on about 1.5M instances, with the number of epochs not reported in the paper. Using these checkpoints would therefore compare training budgets that differ by more than two orders of magnitude. The results in the manuscript compare all methods under the same number of training instances and epochs.

(W3 / Q2) Why are there no results on TSP-10,000?

We evaluate up to TSP-1000 because C2TSP performs structural inference rather than serving as a heuristic: its output is a marginal distribution over connected structures, so each component can be validated directly through structural metrics, not only through performance on ever larger benchmarks. Table 1 (TSP-50) and Tables R2 and R3 (TSP-500 and TSP-1000) show how edge perturbation and sharpening change edge concentration, optimal-edge coverage, and the gap, and Table 2 shows that this structure already yields the lowest gap in 20 of the 25 cells up to TSP-1000.

Demonstrating structural benefits does not require very large instances, and other methods that learn dual information are validated at a similar scale: learned Held–Karp multipliers for TSP on instances with up to 200 cities [3], and learned Lagrangian multipliers for mixed integer programs on network-design instances with up to 30 nodes and assignment instances with up to 400 items [5]. Very large instances such as TSP-10,000 are used mainly to validate heatmap-plus-search pipelines through end-to-end tour quality, as in DIFUSCO and DIMES, whereas UTSP and Fast-T2T, like C2TSP, evaluate up to TSP-1000. Finally, DIFUSCO already runs out of memory at TSP-2000 in our environment (a single NVIDIA RTX 5090; Table 4), so a fair comparison at TSP-10,000 would require memory optimization of the baselines, which is beyond the scope of this study.

(W4) Does the LKH integration blur the effectiveness of C2TSP?

LKH integration tests a second use of the structure C2TSP learns, which is the core contribution of our method: beyond decoding tours directly (Table 2), the learned distribution can guide a solver that takes structural information as input. LKH is such a solver: it is a primal heuristic that searches over tours but selects candidate edges using the Held–Karp dual, which C2TSP also produces. Specifically, LKH computes node penalties π by maximizing the 1-tree lower bound, transforms the edge costs to dᵢⱼ + πᵢ + πⱼ, and keeps the five edges per node with the smallest α-nearness in the resulting minimum 1-tree [4]. C2TSP approaches the same dual through learning: the HK prices λ are the smoothed counterpart of π, and the learned residual field Γ adds edge-level information that no node penalty can express (Section 2.3). Its edge marginal and its equilibrated cost D + Γ + Aλ, the counterpart of LKH's transformed cost, are therefore natural candidate inputs for LKH (H2–H3). Because LKH's search is identical across methods, the differences in Table 4 reflect the quality of the candidate information each method supplies.

NeuroLKH [1] follows the same principle by learning node penalties and edge scores for LKH, which shows that such integration is practical. In Table 4, C2TSP stays within about 1‱ of vanilla LKH at every size, whereas DIFUSCO, DIMES, and Fast-T2T degrade by one to three orders of magnitude at n ≥ 500. Table 9 in the appendix further shows that the improvement comes from the quality of the learned output, not merely from its compatibility with LKH's candidate input.

(Q1) Is the cost of the HK layer the reason for the small model and training budget?

No. The training budget is matched across all methods for a fair comparison, and the model is small because the HK layer and sharpening already provide the structure, so the network only needs to learn a residual edge perturbation (see our answer to W1 / W2). The HK layer and implicit differentiation are not a bottleneck either: under the same budget, the training time of C2TSP is comparable to that of Fast-T2T (Table 12). Because the structural design already yields a significant performance gain with a small model, we have not trained larger networks.

(Q3) Does the ablation hold for the non-perturbed model on TSP-500 and TSP-1000?

Yes. Tables R2 and R3 report the ablation on TSP-500 and TSP-1000 using the checkpoint trained on TSP-100. The conclusions of Table 1 still hold, except that perturbation alone does not improve the gap at TSP-1000 (P vs. N-P). This is consistent with the lower edge concentration at larger sizes: Top2 decreases from 0.90 at TSP-50 to 0.80 at TSP-1000. Consequently, at TSP-1000, perturbation improves tour quality only when combined with edge sharpening, which further reduces the bound on non-tour mass.

Table R2: TSP-500 ablation of the TSP-100-trained model (1,000 instances; metrics as in Table 1). P + S shows absolute values; other rows show the relative change with respect to P + S.

MethodGap (%)↓Top2↑Cov.↑Cost Cov.↑
P + S15.380.85530.75850.6975
P+24.5%−13.8%−15.6%−16.5%
N-P+65.2%−91.0%−29.1%−34.7%
N-P + S+57.3%−90.4%−26.5%−32.6%

Table R3: Same as Table R2, on TSP-1000.

MethodGap (%)↓Top2↑Cov.↑Cost Cov.↑
P + S21.960.80050.66540.6217
P+21.5%−15.3%−17.0%−16.9%
N-P+19.1%−91.1%−18.7%−26.5%
N-P + S+15.9%−90.8%−16.9%−25.3%

We hope this sufficiently resolves the reviewer's concerns, and we would appreciate it if the reviewer could reassess the score on this basis. We are confident in the contributions of our study and are happy to discuss and address any remaining concerns during the discussion period.

[1] L. Xin, W. Song, Z. Cao, and J. Zhang. NeuroLKH: Combining deep learning model with Lin–Kernighan–Helsgaun heuristic for solving the traveling salesman problem. In Advances in Neural Information Processing Systems, 2021.

[2] K. Xu, J. Li, M. Zhang, S. S. Du, K. Kawarabayashi, and S. Jegelka. What can neural networks reason about? In International Conference on Learning Representations, 2020.

[3] A. Parjadis, Q. Cappart, B. Dilkina, A. Ferber, and L.-M. Rousseau. Learning Lagrangian multipliers for the travelling salesman problem. In International Conference on Principles and Practice of Constraint Programming, 2024.

[4] K. Helsgaun. An effective implementation of the Lin–Kernighan traveling salesman heuristic. European Journal of Operational Research, 126(1):106–130, 2000.

[5] F. Demelas, J. Le Roux, M. Lacroix, and A. Parmentier. Predicting Lagrangian multipliers for mixed integer linear programs. In Proceedings of the 41st International Conference on Machine Learning, 2024.

Reviewer_RWSXOpenReview ↗

Concerns about the method's evaluation

I still have important concerns about Section 3 (Experiments) after the authors’ answers.

First, Table 2 is confusing, to say the least. The results reported for the baselines are very poor: as an example, for DIFUSCO, TSP-100 L1 is reported at 22.60% compared to ~0.1% in the original paper; for Fast-T2T, 14.31% on TSP-100 vs ~0.12%. I understand the motivation: the paper states that all models were retrained under an equal training budget, with the same number of training instances and epochs, which for the large baselines means less training than in their original papers. Matching training time is a reasonable goal, but reporting a large model in a regime where it has clearly not converged (DIFUSCO L1 reaches 141.05% on TSP-1000, worse than simple nearest-neighbor insertion), and potentially overfits, is not a fair representation of the baseline to its authors. A more convincing experiment would match both the training budget and the training data, or additionally report the baselines at their originally published settings as a sanity check. Without this, Table 2 cannot support a fair baseline comparison.

Second, the results of the submitted method itself are weak, independently of any baseline comparison. The strongest pure-decoding result on TSP-100 is 1.90% (L2×100); the headline L1 number is 9.44%. A paper claiming strong decoding performance should report sub-1% gaps on TSP-100 with its best decoder, and it is not clear that the model has learned much beyond what the decoder extracts.

Third, I do not fully see the interest of Section 3.3 and Table 4. C2TSP integrated with LKH (H2–H4) stays within ~1% of vanilla LKH-3 at every size. It shows a better robustness than other methods, but it does not outperform LKH-3, while using it. So, I do not see a scenario in which it would be useful to use it.

One more caveat on Table 3: the zero-shot non-Euclidean transfer is striking (1.4-2.1% vs ≥7% for all baselines at n=100), but as the paper itself notes, the baselines receive only node coordinates while C2TSP receives the full cost matrix D on these instances, so the comparison is not on equal input footing.

To summarize, I like the method proposed in the paper. However, without a convincing experimental section, i.e., fair baseline comparisons and decoding results that actually reach SOTA-level gaps, it reads as an interesting method that does not yet work.

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

This paper proposes C2TSP, an end-to-end unsupervised learning pipeline for the Traveling Salesman Problem (TSP) that addresses a fundamental limitation in current neural approaches: the lack of a tractable global distribution over connected combinatorial objects. The authors demonstrate that C2TSP learns interpretable, tour-like marginals and exhibits superior zero-shot transfer to non-Euclidean instances. Notably, the paper demonstrates robustness and synergy when integrated with the LKH heuristic, outperforming several state-of-the-art baselines in hybrid settings.

Critical strengths

The paper introduces a new paradigm for structuring TSP solutions by leveraging the rooted 1-tree family, which leads to improved candidate solutions. The logical progression from theoretical derivation to empirical validation is sound.

Critical weaknesses

While I can tell from the methodology section, the motivation is not well explain, especially in the introduction.

Questions for authors
  1. To better understand the motivation, regarding the limitation in line 48, shouldn't the gradient flow be designed to incorporate the distribution from the downstream decoding stage? Please clarify the logic behind the current approach.
  2. The proposed method has an O(n3)O(n^3) complexity. Please provide the wall-clock latency for C2TSP and clarify if the additional computation is justified by the improvement in solution quality.
  3. Since the problem sizes are small enough for exact solvers, adding a comparison with Concorde would help provide a clearer picture of the optimality gap.
  4. Is the C2TSP framework intended to be generalizable to other models, such as autoregressive or heatmap-based methods, or is it specifically designed for use with LKH?
3 comments

Summary of our response. We thank the reviewer for the constructive comments. We first summarize our responses to all concerns and then respond in detail:

  1. Response to the motivation (W1): The revised introduction now states the motivation explicitly, from the mean-field limitation of heatmap-based methods to the design of C2TSP.

  2. Response to the gradient flow through the decoder (Q1): Passing gradients through the decoder gives either a biased or an intractable gradient, so C2TSP differentiates the expected cost of a tractable connected distribution instead.

  3. Response to the latency (Q2): The extra computation is justified by solution quality, and the O(n³) part dominates the inference time only from TSP-500 onward.

  4. Response to the Concorde reference (Q3): All reported optimality gaps are already measured against Concorde's optimal tours.

  5. Response to the generality of C2TSP (Q4): C2TSP is not specific to LKH; it learns structural information that any method taking edge scores can use, and LKH is a natural primal heuristic to demonstrate this.

(W1 / Q1) Is the motivation clear, and should the gradient flow incorporate the decoding stage?

For W1: We have revised the introduction to state the motivation explicitly; all changes are marked in blue in the revised PDF. The limitation in line 48 is that heatmap-based methods treat edges as independent (a mean-field approximation), which discards the global constraint that the selected edges form a single connected cycle. The revised introduction also states why we adopt unsupervised learning, so that the motivation follows this chain:

unsupervised learning trains efficiently without labels → a structured marginal output is needed to attribute performance to the learned representation → the rooted 1-tree family is connected by construction and keeps the distribution and its gradient tractable → the Held–Karp layer restores the degree-two constraints in expectation → edge sharpening makes the distribution more tour-like by reducing the non-tour mass.

For Q1: Incorporating the decoding stage into the gradient flow would give either a biased gradient or an intractable one, so we instead differentiate the expected cost of a tractable connected distribution. First, the decoder outputs one tour at a time, so the decoded tour is piecewise constant in the network parameters: a small change of the parameters does not change the tour. Its gradient is therefore zero almost everywhere and undefined where the tour switches. Blackbox differentiation [1] obtains informative gradients by differentiating a piecewise-linear interpolation of the loss, but this surrogate trades faithfulness to the original objective for informativeness, so the resulting gradient is biased. Second, replacing the decoder with a smooth Gibbs distribution over tours does not help either, because its exact probabilities and gradients are intractable; this reason was given in the second paragraph of the introduction and is now also stated in the first paragraph. C2TSP avoids both issues: it outputs the exact edge marginal of the rooted 1-tree distribution, so the expected cost under this distribution is a differentiable function of the network parameters and is differentiated without passing through the decoder.

(Q2) What is the wall-clock latency, and is the additional computation justified?

Table 2 reports the per-instance wall-clock time of C2TSP and all baselines at every decoding level, and the additional computation is justified by solution quality: C2TSP achieves the lowest optimality gap in 20 of the 25 settings. Although HK equilibration and edge sharpening take extra time, C2TSP is still faster than DIFUSCO for n ≥ 100. The quality gain comes from the pipeline, which delivers a tractable, tour-like edge marginal.

Table R4 breaks down the inference time. The O(n³) part takes less than 5% of the time for n ≤ 100, and the total time stays between 0.14 and 0.19 s up to TSP-200; the O(n³) part dominates from TSP-500 onward and accounts for about 96% of the time at TSP-1000. This part can be accelerated without changing the method: C2TSP already down-weights edges outside a 32-nearest-neighbor candidate graph by a factor of about 10⁻⁵, so removing them makes the Laplacian sparse and enables sparse factorization or effective-resistance approximation [2], and the dense factorization, currently in double precision, can run in single precision with iterative refinement [3]. We leave these extensions to future work.

Table R4: Per-instance inference time of C2TSP and its O(n³) part.

nTotal (s)O(n³) part (s)Share
500.1370.0006≈0.5%
1000.1500.006≈4%
2000.1940.055≈30%
5000.9330.81–0.86≈87–92%
10007.196.9≈96%

(Q3) Are the optimality gaps measured against Concorde's optimal tours?

All reported optimality gaps are already computed against Concorde's optimal tours for n ≤ 1000, as stated in the second paragraph of Section 3:

Reference optimal tours are computed with Concorde (Applegate et al., 2011) for n ≤ 1000, and LKH solutions serve as references for n = 2000 in Table 4.

(Q4) Is C2TSP specifically designed for LKH?

C2TSP is not designed specifically for LKH: it learns structural information, the exact edge marginal of the learned rooted 1-tree distribution, which any method that takes edge scores as input can use. In the manuscript, this output is decoded with the same decoders as the heatmap baselines (L1–L3, Table 2) and also supplied to LKH at four levels (H1–H4, ''Connecting to LKH'' in Section 3). LKH derives its candidate edges from Held–Karp node penalties, the same dual quantity that the HK layer of C2TSP computes, so it can take the HK-equilibrated output of C2TSP directly. This makes LKH a natural choice to demonstrate that C2TSP can guide primal heuristics. Autoregressive methods could likewise use the marginal as edge scores to guide tour construction, although we have not evaluated this combination.

We hope this sufficiently resolves the reviewer's concerns, and we would appreciate it if the reviewer could reassess the score on this basis. We are confident in the contributions of our study and are happy to discuss and address any remaining concerns during the discussion period.

[1] M. Vlastelica, A. Paulus, V. Musil, G. Martius, and M. Rolínek. Differentiation of blackbox combinatorial solvers. In International Conference on Learning Representations, 2020.

[2] D. A. Spielman and N. Srivastava. Graph sparsification by effective resistances. SIAM Journal on Computing, 40(6):1913–1926, 2011.

[3] E. Carson and N. J. Higham. Accelerating the solution of linear systems by iterative refinement in three precisions. SIAM Journal on Scientific Computing, 40(2):A817–A847, 2018.

Thank you for the detailed responses yet my concern still remains. I would like to keep the current score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.