acceptodds
Under review as a conference paper at ICLR 2027

Learning-Augmented Algorithms for TSP and Vehicle Routing Problems

Abstract

We consider a canonical vehicle-routing problem in which a sequence of point-to-point requests arrives online and must be inserted into the schedule to minimize the total travel time required to serve them. This captures classical problems such as the online Traveling Salesperson Problem (TSP) and the online Stacker Crane Problem. Our main result is a learning-augmented algorithm with a competitive ratio of when the input requests are drawn from (possibly non-identical) distributions, given just a *single sample* from each distribution as offline predictions. This is in sharp contrast to the best-known logarithmic bounds without offline predictions. We further extend this result in two directions: first, by showing that the algorithm can be made *robust* to adversarial noise in the samples, and second, by considering a fleet of vehicles rather than a single vehicle. Finally, we complement our theoretical results with empirical evaluations.

Primary area:
learning theory
Keywords:
Algorithms with predictions, Learning-augmented algorithms, Online algorithms, Approximation algorithms

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 2 reviews, above 68% of the others.
Reviewer_9nQtOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies incremental metric routing, where each arriving transportation request must be inserted without changing the relative order of earlier requests. Before arrivals begin, the algorithm receives one independent sample from each request distribution. A sample-based backbone and local excursions yield a 3.53.5 expected competitive ratio for one vehicle and a 44 guarantee for multiple vehicles. A separate budget-doubling algorithm is analyzed for adversarial sample corruption, with logarithmic dependence on the number of corrupted samples. Experiments use a fixed adversarial request sequence and synthetically generated predictions.

Critical strengths

The reliable-sample result is a meaningful theoretical contribution. One independent sample per request distribution suffices for a constant expected guarantee in arbitrary symmetric metrics, without requiring identical distributions or distributional regularity. The backbone-plus-excursion analysis, particularly the exchange argument excluding a request's own sample, explains why this limited information is useful. The multi-vehicle extension broadens the result beyond a single route.

Critical weaknesses
  1. The robustness extension does not establish the main quantitative guarantee for a single robust algorithm, and its implementation and analysis contain unresolved gaps.

    The 3.53.5 guarantee applies to Algorithm 1, whereas the corruption-dependent guarantee applies to Algorithm 2. The paper does not establish that one algorithm retains the 3.53.5 guarantee when k=0k=0 while degrading logarithmically with corruption. An asymptotic constant at k=0k=0 is not the same quantitative guarantee. Although this is not a contradiction between the individual theorem statements, it materially limits the interpretation that the main result has been preserved under a robust extension. The no-corruption constant of Algorithm 2 should be stated explicitly.

    Moreover, Algorithm 2, lines 7–10, observes an initial prefix through index ℓ\ell, sets i=ℓ+1i=\ell+1, and initializes M=∅M=\varnothing, without inserting that prefix into the output. For two TSP requests at distinct locations, the first positive-cost prefix contains both requests; the loop is then skipped and the pseudocode returns an empty graph. The prose suggests that the prefix is processed, but neither its route nor its cost is incorporated explicitly. Lemma 7 also assumes a preceding budget-doubling phase and does not address termination at the initial budget. A corrected algorithm and complete accounting of the initialization are necessary to substantiate the robust guarantee.

  2. The experimental sampling protocol does not match the independence assumption underlying the main theorem.

    Section 2 assumes independent draws Ri,Ri′∼PiR_i,R'_i\sim P_i. In Section 5, the actual requests are fixed, while each sample is generated around the corresponding realized request: it remains at that location with probability 0.50.5 and otherwise moves according to an inverse-distance distribution. This is a different prediction model. Repeating sample generation around one fixed sequence does not evaluate the expectation over independent actual requests and samples required by the theorem.

    The experiments may demonstrate usefulness under spatially correlated forecasts, but they do not validate the stated single-sample guarantee. Consequently, the claim that Figure 2 confirms the theoretical constant-factor guarantee is unsupported by this protocol. Additionally, the offline reference is a 1.81.8-approximation, so proximity to this reference does not establish proximity to the true offline optimum.

Questions for authors
  1. Please state the guarantees of each algorithm separately, including the no-corruption constant of Algorithm 2. Does any algorithm simultaneously achieve the 3.53.5 reliable-sample guarantee and the corruption-dependent bound? Please also provide a corrected initialization and an analysis accounting for the initial prefix and initial budget.

  2. How can the experimental protocol be reconciled with the assumption that actual requests and samples are independent draws from the same distributions? Is there validation under the stated model? Otherwise, which empirical conclusions remain justified, particularly the claimed confirmation of the theoretical guarantee?

2 comments

Thank you for your review. Below we provide responses to your questions and concerns.

Q1(a): Please state the guarantees of each algorithm separately, including the no-corruption constant of Algorithm 2. Does any algorithm simultaneously achieve the reliable-sample guarantee and the corruption-dependent bound?

No, Algorithm 1 achieves an expected competitive ratio of 3.5 when all samples are reliable, whereas Algorithm 2 achieves O(log⁡(pn))O(\log(pn)) (i.e., O(log⁡k)O(\log k)) under kk corrupted samples and an explicit constant of 41 when k=0k=0. Trading off a looser consistency constant to gain worst-case robustness against unknown adversarial errors is standard in learning-augmented algorithms (e.g., Lykouris & Vassilvitskii, 2018; Purohit et al., 2018; Mitzenmacher & Vassilvitskii, 2020). Because Algorithm 2 does not know kk in advance, it replaces Algorithm 1's single 1.51.5-approximate TSP tour with an online budget-doubling search using 22-approximate rooted kk-TSP backbones. Moreover, in Section 4 we prioritized proof simplicity rather than optimizing the leading constant at k=0k=0 (which can be tightened—for example, by tuning the phase-scaling multiplier and phase threshold—without changing the algorithmic framework). When samples are known to be reliable, the simpler Algorithm 1 is specifically designed for that regime. At the same time, as shown in Figure 2a (p=0.0p = 0.0), in practice Algorithm 2's tour cost without corruption is nearly indistinguishable from Algorithm 1's, indicating that the analytical constant from worst-case doubling is conservative. For this reason, although we provide the explicit bound of 41 here in response to the reviewer’s question, we have not included this numerical constant in the paper. The goal of our robustness result is to establish that a single algorithm retains a constant competitive ratio with reliable samples while degrading only logarithmically with corruption; optimizing the particular constant in the no-corruption case is outside the scope of this work, and the bound of 41 is not intended to be tight.

Q1(b): Please also provide a corrected initialization and an analysis accounting for the initial prefix and initial budget.

We thank the reviewer for catching that we set M←∅M \gets \emptyset instead of initializing MM with the prefix tour in Algorithm 2. We have updated Lines 7–10 so that MM is initialized with the tour serving R1,…,RℓR_1, \dots, R_\ell in arrival order until c(M)>0c(M) > 0 (or ℓ=n\ell = n), with i←ℓ+1i \gets \ell + 1 and T←c(M)T \gets c(M). This directly resolves the boundary cases as well: whenever ℓ=n\ell = n (such as two TSP requests at distinct locations, or when all requests have zero cost), i=n+1i = n + 1 skips the while loop and returns MM covering all nn requests. Finally, because the tour on R1,…,Rℓ−1R_1, \dots, R_{\ell-1} has zero cost, all vertices in V(R<ℓ)V(R_{<\ell}) have distance zero to s1s_1, so this initial tour has cost T0≤c(OPT(R))T_0 \le c(\text{OPT}(R)) by the triangle inequality. Carrying T0T_0 through Lemma 7 (Tfinal≤T0+2T∗+Wmax⁡T_{\text{final}} \le T_0 + 2T^* + W_{\max}, which also covers termination at the initial budget without a preceding doubling phase) and Lemma 8 (ALG≤T0+8Tfinal≤9T0+16T∗+8Wmax⁡\text{ALG} \le T_0 + 8T_{\text{final}} \le 9T_0 + 16T^* + 8W_{\max}) adds at most 9E[c(OPT(R))]9\mathbb{E}[c(\text{OPT}(R))] and leaves our O(log⁡(pn))O(\log(pn)) guarantee unchanged.

Q2: How can the experimental protocol be reconciled with the assumption that actual requests and samples are independent draws from the same distributions? Is there validation under the stated model? Otherwise, which empirical conclusions remain justified, particularly the claimed confirmation of the theoretical guarantee?

Thank you for this careful reading. You are right on both points, and we have redone the experiments accordingly.

  • Protocol: In the submission the Azar sequence was fixed and only the samples were redrawn, so it was a conditional perturbation study rather than an evaluation of the model in our theorems. In the revision we first fix the distributions P_i and then draw both the online request R_i and the sample R'_i independently from P_i, in every one of the 100 runs.
  • Offline reference: We now compute the true offline optimum with an exact integer program and report ratios against it. Match & Route is kept only as a second offline curve; it turns out to be within 0.5% of the optimum on these instances.
  • Empirical conclusion: We also agree that the experimental results should be distinguished from the theoretical guarantees. Our revised experiments are now conducted under the independent-sampling model assumed in our theorems, and therefore provide empirical evidence of the effectiveness of our algorithms under this model.

Dear Reviewer,

Thank you again for your review and feedback. As the discussion period continues, we would like to follow up to ensure that our rebuttal adequately addressed the technical concerns you raised.

Please do not hesitate to let us know if any further clarifications would be helpful. We greatly appreciate your time and dedication to reviewing our work.

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

The paper studies the Online Stacker Crane Problem (SCP), including Online TSP as a special case, where requests arrive sequentially and must be served. It proposes a learning-augmented algorithm that uses a single offline sample from each request distribution to construct a backbone tour and serve arriving requests through star excursions. The authors claim an expected competitive ratio of 3.5 for a single vehicle, a ratio of 4 for multiple vehicles, and an O(log k) robustness guarantee when k samples are corrupted. The proposed algorithms are evaluated on a synthetic adversarial instance with 85 requests and different corruption levels.

Critical strengths
  1. The theoretical contribution, if correct, is significant (I could not completely verify the correctness of the proof). Achieving a constant expected competitive ratio using only one sample per request distribution, without requiring identical distributions or additional smoothness assumptions, is an important improvement over prediction-free online guarantees. The proposed backbone and star-excursion construction provides a relatively simple algorithmic approach.

  2. The robustness extension addresses an important limitation of learning-augmented algorithms. The proposed budget-doubling method aims to tolerate corrupted samples while maintaining performance guarantees that depend on the corruption level. The reported experiments support the potential effectiveness of this approach.

Critical weaknesses
  1. The experimental evaluation is rather limited. The experiments consider only one synthetic adversarial construction with 85 requests and a specific sampling and corruption mechanism. The authors need to evaluate the proposed solution under different network topologies, larger problem sizes, and realistic routing scenarios to demonstrate its generalizability.

  2. The computational complexity and practical applicability of the robust solution need further investigation. The robust algorithm repeatedly invokes an approximation procedure for the Rooted k-TSP problem, which may introduce significant computational overhead.

Questions for authors
  1. How does the proposed solution perform under different network topologies, larger request sets, and stronger adversarial corruption patterns?

  2. What is the exact computational complexity of the robust algorithm, including the repeated Rooted k-TSP approximations, and how does its execution time scale with the number of requests?

2 comments

Thank you for your thoughtful review of our paper. We greatly appreciate your constructive comment about experiments and we address it with adding experiments on different topologies. Here is our response to your questions and concerns.

Q1: How does the proposed solution perform under different network topologies, larger request sets, and stronger adversarial corruption patterns?

Thank you for these suggestions. We have substantially extended the experimental evaluation.

Larger problem sizes. The main experiment now uses the first 788 points of Azar's construction, where we can also compute the exact offline optimum, and the full construction with 21,201 requests. At n = 788 with reliable samples, Star Excursions ends at 1.05× the optimum while Greedy ends at 1.35×. At n = 21,201, the cost of Star Excursions is 0.75–0.81 of Greedy's and that of the robust algorithm 0.82–0.88, across all corruption levels.

Different network topologies. A new appendix section reports the same experiment on three further graphs: a road-like network with shortest-path distances, the TSPLIB instance d493, and uniformly random points in the plane. With requests spreading outward from a corner vertex, Star Excursions costs 0.83–0.96 of Greedy and ends at 1.14–1.25× the best offline tour, against 1.25–1.45× for Greedy.

Sampling and corruption mechanism. The sampling model now matches the model of our theorems: the distributions are fixed first, and requests and samples are independent draws from them, redrawn in every run. Each sample is corrupted independently with probability p ∈ {0, 0.05, 0.1, 0.2} by replacing it with a uniformly random vertex. The cost of the sample-based algorithms increases gradually with p: at n = 788, Star Excursions goes from 1.05× to 1.12× the optimum.

Q2: What is the exact computational complexity of the robust algorithm, including the repeated Rooted k-TSP approximations, and how does its execution time scale with the number of requests?

The computationally expensive rooted k-TSP subroutine is invoked only during preprocessing, after observing the first request, and not during the subsequent online budget-doubling phases. As written, Algorithm 2 (lines 4–6) invokes this subroutine n times, once for each target size j∈[n]j\in[n]. Let P(n)P(n) denote the running time of a rooted k-TSP approximation on n vertices, and let H denote the number of budget-doubling phases. Using a straightforward implementation, our preprocess model would require O(nP(n))O(n P(n)) which can be improved to O(log(n)P(n))O(log(n) P(n)) by only running k-TSP only for j c∈ {n, n-1, n-2, n-4, n-8,..., 1} and only consider these tours as a candidate for the backbone which does not change the asymptotic competitive guarantee. For the rooted k-TSP subroutine, we referred to the polynomial-time 2-approximation of Garg (2005), but its running time is O~(n3)\widetilde O(n^3) . However, any polynomial-time constant-factor approximation algorithm for rooted k-TSP can be substituted, with corresponding changes to the constant factors in our analysis.

Additionally, the online phase is considerably simpler than the preprocessing phase. Its main operation is finding the closest vertex to the new request among the backbone vertices and previously arrived requests. A straightforward implementation scans all candidate vertices, requiring O(n)O(n) time per request and O(n2)O(n^2) time overall, comparable to the standard greedy insertion algorithm.

Moreover, we can further improve the online running time by allowing constant-factor approximate nearest-neighbor searches, at the expense of only a constant-factor loss in the competitive ratio. In particular, assuming the distance matrix of the metric space V is available, a simple randomized landmark-based data structure achieves a 3-approximation to the nearest active vertex in O~(n)\widetilde O(\sqrt{n}) time per request, including insertion, after O(n2)O(n^2) preprocessing. More generally, dynamic vertex-label distance oracles (Chechik, 2012) support O~(nϵ)\widetilde O(n^\epsilon) update time with stretch O(1/ϵ)O(1/\epsilon) for any fixed ϵ>0\epsilon>0. Since our robustness analysis bounds the cost of nearest-anchor excursions, replacing exact nearest anchors with constant-factor approximations changes only constant factors, preserving the asymptotic logarithmic robustness guarantee. These improvements are optional; our stated algorithm uses exact nearest-anchor searches.

Thank you for your response. Please ensure that these new results are incorporated into the revised manuscript.

I will maintain my positive score for now. However, I would also like to see whether Reviewer iYo7 is satisfied with the authors' response, as I believe the concerns raised by this reviewer are important and deserve careful consideration.

Comments on the paper

4 comments

Thank you for your review. Below we provide responses to your questions and concerns.

W1: The single-vehicle robustness result needs a complete initialization and cost-accounting argument...

We thank the reviewer for catching that we set M←∅M \gets \emptyset instead of initializing MM with the prefix tour in Algorithm 2. We have updated Lines 7–10 so that MM is initialized with the tour serving R1,…,RℓR_1, \dots, R_\ell in arrival order until c(M)>0c(M) > 0 (or ℓ=n\ell = n), with i←ℓ+1i \gets \ell + 1 and T←c(M)T \gets c(M). This directly resolves the boundary cases as well: whenever ℓ=n\ell = n (including the all-zero-cost case), i=n+1i = n + 1 skips the while loop and returns MM covering all nn requests. Finally, because the tour on R1,…,Rℓ−1R_1, \dots, R_{\ell-1} has zero cost, all vertices in R<ℓR_{<\ell} have distance zero to s1s_1, so this initial tour has cost T0≤c(OPT(R))T_0 \le c(\text{OPT}(R)). Carrying T0T_0 through Lemmas 7 and 8 (which also covers termination without a doubling phase, as in Appendix C.2) adds only a constant times E[c(OPT(R))]\mathbb{E}[c(\text{OPT}(R))] and leaves our O(log⁡(pn))\mathcal{O}(\log(pn)) guarantee unchanged.

Q1: Algorithm and proof clarification: How is the initialization prefix served, retained in M, and charged in Lemma 8? ...

For the first part regarding prefix initialization in MM, cost accounting in Lemma 8, and the boundary cases (ℓ=n\ell = n, all-zero-cost, and first-phase termination without doubling), please see our response above—initializing MM with the arrival-order tour on R1,…,RℓR_1, \dots, R_\ell (with cost T0≤c(OPT(R))T_0 \le c(\text{OPT}(R))) and carrying T0T_0 into Lemmas 7 and 8 handles all of these cases directly.

Regarding R1′←R1R'_1 \gets R_1, UU, and T* in Lemma 10: After observing R1∼P1R_1 \sim \mathcal{P}_1 and setting R1′←R1R'_1 \gets R_1 in Line 2, index 11 holds a genuine draw from P1\mathcal{P}_1 independent of other samples and requests. Defining the uncorrupted set UU after this replacement (so R1∈UR_1 \in U along with all uncorrupted indices in {2,…,n}\{2, \dots, n\}) guarantees ∣U∣≥(1−p)n|U| \ge (1-p)n, ∣R∖U∣≤pn|R \setminus U| \le pn, and crucially s1=s1′∈UP′s_1 = s'_1 \in U'_P. Because s1∈UP′s_1 \in U'_P, the optimal tour covering UP′U'_P—whose cost defines T*—automatically contains the root s1s_1, making it a valid root-containing tour covering at least (1−p)n(1-p)n sample vertices for Lemma 10. Moreover, R1,R2′,R3′,…,Rn′R_1, R'_2, R'_3, \dots, R'_n has the exact joint distribution of independent draws from P\mathcal{P}, so E[T∗]≤E[c(OPT(R))]\mathbb{E}[T^*] \le \mathbb{E}[c(\text{OPT}(R))] and the expectation identity in Theorem 2 hold unchanged (trivially for i=1i=1 since t1′=t1t'_1 = t_1, and by independence of Ri,Ri′R_i, R'_i from UP′∖{si′}U'_P \setminus \{s'_i\} for i≥2i \ge 2).

W2 and Q2: Experimental clarification: Are the actual online requests independently resampled across runs, or is the Azar sequence fixed? What empirical conclusion is intended if only the samples are redrawn? ...

Thank you for this careful reading. You are right on both points, and we have redone the experiments accordingly.

  • Protocol: In the submission the Azar sequence was fixed and only the samples were redrawn, so it was a conditional perturbation study rather than an evaluation of the model in our theorems. In the revision we first fix the distributions P_i and then draw both the online request R_i and the sample R'_i independently from P_i, in every one of the 100 runs.
  • Single request sequence: Requests are now random draws rather than one fixed sequence, but they are still built on Azar's construction.
  • Offline reference: We now compute the true offline optimum with an exact integer program and report ratios against it. Match & Route is kept only as a second offline curve; it turns out to be within 0.5% of the optimum on these instances.
  • Scale: We moved from n = 85 to n = 788 (with the exact optimum) and to the full construction with n = 21,201.
  • Sample-based baseline: To the best of our knowledge, there is no existing sample-augmented algorithm for the incremental Stacker Crane problem under our model, where one independent sample is provided for each request distribution and the relative order of previously inserted requests must be preserved. In particular, there is no established same-sample baseline that can be directly applied to our setting. Designing a meaningful alternative would require introducing a new sample-based online routing rule, which is beyond the scope of this work. We therefore compare our algorithms against the classical greedy online algorithm, which is the standard prediction-free baseline, as well as the offline optimum and the offline Match & Route algorithm. These comparisons allow us to quantify the improvement over established online methods and evaluate the quality of the resulting solutions relative to the optimal offline cost.

Q3: Output and measurement clarification: Section 2 defines a cyclic ordering π of real requests, whereas Algorithm 1 returns an auxiliary Eulerian structure M containing sample-backbone vertices. How does its traversal produce π while preserving earlier request order and each directed, uninterrupted service trip? Shortcutting the empty travel between services gives c(π)≤c(M), generally not equality. Does Figure 2 report the expanded traversal cost c(M) or the resulting ordering cost c(π), and are all methods measured consistently? This distinction affects the interpretation of the experiments; an upper bound on c(M) can still establish the competitive guarantee.

We thank the reviewer for pointing out this distinction. Algorithm 1 returns the auxiliary Eulerian graph M, which represents the maintained routing structure; the feasible solution in the problem definition is the cyclic ordering of real requests induced by its traversal. As already explained in Section 3 (Page 5), the structure is traversed in a DFS manner. Recording the directed service trips (siti) in that traversal order produces , while the auxiliary backbone edges and empty-return walks are omitted from the final request ordering. The triangle inequality then gives c(π)≤c(M), not necessarily equality. Accordingly, Section 3 uses ALG=c(M) as an upper bound in the competitive analysis, which also bounds the actual cost c(π).

  • Preserving request order and uninterrupted service: Each arriving request Ri=(si,ti)R_i=(s_i,t_i) contributes a closed excursion (vi,si,ti,vi)(v_i,s_i,t_i,v_i) anchored at viv_i. These excursions are inserted at vertices in the maintained DFS traversal, not in the middle of an existing directed service trip. Thus, every service trip remains uninterrupted and is traversed from its source to its destination. Section 3 already specifies that, when several nested branches originate at the same vertex, earlier requests and their sub-branches are traversed before later ones. Consequently, inserting the new excursion does not change the relative cyclic order of previously scheduled service trips. This is why the sequence of directed service trips extracted from the traversal is a feasible online ordering , even though the pseudocode outputs its auxiliary graph representation M.

  • Experimental measurement (Figure 2): Figure 2 reports the actual cost c(π) of the shortcut cyclic request ordering, not the expanded traversal cost c(M). All methods shown in the experiments, including the offline references, Greedy, and both proposed algorithms (as well as the high-initial-budget variant), are evaluated using the same objective defined in Section 2. Therefore, the reported comparison is between feasible request orderings, whereas c(M) is used for the theoretical upper bound.

Q4: Contribution positioning: Section 1.2 attributes an unavoidable nonconstant lower bound for arbitrary insertion strategies to Azar (1994). That paper's insertion methods place each arriving vertex at a minimum-increment edge; its lower bound is not a lower bound for every online algorithm allowed to choose an insertion position. Section 1.2 of Azar et al. (2026), already cited in the manuscript, also distinguishes these restricted lower bounds from the unresolved general case. Is the intended claim an improvement over the best-known prediction-free upper bound? Please clarify this distinction, since it changes the interpretation of what barrier the sample-based result overcomes.

Yes, our intended claim, as stated in the Abstract, Introduction, and Section 1.1, is that a single sample per distribution improves over the best-known prediction-free O(log⁡n)\mathcal{O}(\log n) upper bound (standing since Rosenkrantz et al., 1977), while also overcoming the Ω(log⁡n/log⁡log⁡n)\Omega(\log n / \log \log n) barrier for greedy minimum-increment insertion heuristics.

We thank the reviewer for catching the imprecise phrasing in Section 1.2: in Rosenkrantz et al. (1977) and Azar (1994), "arbitrary insertion" refers to an arbitrary arrival order paired with minimum-increment edge placement, rather than arbitrary online insertion positions, for which closing the gap below O(log⁡n)\mathcal{O}(\log n) remains open (as discussed in Azar et al., 2026). We have updated that sentence in Section 1.2 so it accurately attributes Azar (1994)'s Ω(log⁡n/log⁡log⁡n)\Omega(\log n / \log \log n) lower bound to greedy minimum-increment insertion and matches the "best-known upper bound" framing used throughout the rest of the paper.

Dear reviewers,

please acknowledge the rebuttal and, if possible, have a look at the revised version. Decide whether the changes and the rebuttal affect your assessment and your score.

AC

Dear Reviewer,

Thank you again for your review and feedback. As the discussion period continues, we would like to follow up to ensure that our rebuttal adequately addressed the technical concerns you raised.

Please do not hesitate to let us know if any further clarifications would be helpful. We greatly appreciate your time and dedication to reviewing our work.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.