acceptodds
Withdrawn from ICLR 2027

Survivable Directed Supports for Synchronous Learning

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

We study minimum-cost directed communication supports that retain prescribed coordinator–worker connections after bounded arc failures, subject to a limit of provisioned arcs. For requirements of multiplicities , an integral-flow dynamic program stores only boundary imbalances and the number of selected arcs. On a supplied width- decomposition, its running time is . The bounded state is complete because each requirement admits a witness consisting of simple arc-disjoint paths, even though the algorithm permits circulations. Rooted localization then gives a algorithm on planar and fixed apex-minor-free underlays. On a 40-instance benchmark, the flow DP completes 22 instances, the labelled-path DP completes 20, and MILP completes all 40 under common limits. A separate provisioning study shows how shared resilient supports preserve the prescribed synchronous learning updates under an explicit arc-failure model.

Primary area:
optimization
Keywords:
combinatorial optimization, survivable network design, synchronous distributed learning, fault-tolerant communication, directed graphs, parameterized algorithms, treewidth, dynamic programming

Reviews

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

This paper studies a network design problem that is useful in distributed learning. In particular, we are given as input a directed graph D=(V,A)D = (V, A) together with a special root node rr and terminal set T⊆VT \subseteq V, a demand bt+b_t^+, a demand bt−b_t^- (both integers at least one) for each t∈Tt \in T, edge costs c:E→Rc : E \rightarrow \mathbb{R}, and a budget ℓ\ell. We need to find a subgraph with at most ℓ\ell edges such that for every t∈Tt \in T there are at least bt+b_t^+ edge-disjoint paths from rr to tt and at least bt−b_t^- edge-disjoint paths from tt to rr. The goal is to minimize the total cost of our subgraph. In other words, it is the directed survivable network design problems (Directed-SNDP) with a single source and an edge cardinality constraint. They design a dynamic programming algorithm that depends exponentially on the treewidth of the underlying undirected graph and the sum of the number of bits needed to represent the demands. Note that since each demand requires at least one bit, this means that they depend exponentially on ∣T∣|T|. They also provide a number of experiments.

Critical strengths
  • The problem might be interesting.
Critical weaknesses

I do not think that this paper should be accepted to ICLR. While I think that the problem is reasonable as a network design problem (i.e., it could be an interesting special case of directed SNDP), the writing is poor, the algorithm is not particularly interesting, and the results are somewhat weak.

  • The writing is a major issue. I read the abstract and intro and still did not understand what the problem was. It wasn't until they formally define it in Section 2 that I finally understood it. Their informal explanations earlier are written too poorly to be understandable. And then, in the actual formal definition in Section 2, their technical writing is also quite poor: they use notation and concepts without defining them, switch between formal and informal, etc. For example, in Theorem 2 on page 2 they use a tree decomposition. But this isn't defined until Section 4.1 on page 4, and even there they do not cite this definition (although they obviously did not invent it). Then in Section 4.1, they use a bunch of terms either without defining them or with crazy definitions. As a short set of examples, but from the 1/2 page of Section 4.1"

    • They use "root, introduce-vertex nodes, forget-vertex nodes, equal-bag two-child joins, and introduce-arc nodes" without defining any of them.
    • They say "For a partial binary flow...", but never define what a "partial binary flow" actually is. From the type of the object it seems to be a subgraph (each edge is assigned zero or one), in which case calling it a "flow" is crazy writing.
    • In Lemma 6 the statement of the lemma is about "binary witnesses", but a "binary witness" is never defined.
    • In equation (3), vv is never defined. It is presumably a vertex, but from what set? VxV_x? Or VV? Even ignoring this issue, equation (3) is, if I'm interpreting it correctly, just out-degree - in-degree for a particular subgraph. This is not a hard concept, but the current writing completely obscures it.
  • The algorithm and analysis are not particularly interesting. It seems to be a basically standard use of a tree decomposition to get a DP algorithm -- there are thousands of such algorithms, particularly in the FPT literature. If there is anything new and exciting, then the authors did not highlight it (another sign of poor writing). The correctness and complexity arguments take less than a page combined (although while they use earlier lemmas, the earlier lemmas are all essentially trivial). Moreover, the authors themselves say that there are already known ways to get algorithms for bounded treewidth (see the discussion just before Section 2). So there doesn't seem to be much that is of deep interest.

  • I was incredibly underwhelmed by the experimental results. All of their graphs are just small grids! What about realistic graphs? Or if you are going to use grids, they should at least be big! I think the largest grid they used was something like 30 nodes. If you're going to evaluate algorithms experimentally, you at least need to do it on graphs big enough to demonstrate why anyone should care. And even on these graphs, it seems like using a standard MILP approach is usually (almost always) better.

So in my opinion, this is a poorly written paper about an algorithm that isn't great in practice and isn't very interesting theoretically.

Questions for authors

None

2 comments
AuthorsOpenReview ↗

Definitions, proof details, and the quantitative contribution

Thank you for identifying where the presentation obstructed the argument. The reader should not have to reconstruct the model or states. We address each example, then novelty and evaluation.

  1. Problem statement and order of definitions. The problem is to choose a minimum-cost set of at most ℓ\ell directed arcs so that, for every worker tt, there are bt+b_t^+ arc-disjoint coordinator-to-worker paths and bt−b_t^- arc-disjoint return paths. Different requirements may share an arc, whose cost is paid once. We will put this before the application discussion and define tree decompositions before Theorem 2, citing Cygan et al. (2015, Chapter 7). Neither is claimed as new.

  2. The decomposition nodes and the missing domains. A tree decomposition has bags covering all vertices, both endpoints of each arc in some bag, and connected bags for every fixed vertex. Its width is the largest bag size minus one. In the rooted normalization, root and leaves have empty bags. Relative to its child, an introduce-vertex node adds one vertex and a forget-vertex node removes one. An introduce-arc node has the same bag and processes one uniquely assigned original arc whose endpoints lie in it. A join has two children with exactly the parent's bag. Unique arc assignment makes their processed arc sets disjoint.

For node xx, VxV_x is the union of bags in its subtree and AxA_x is its processed arc set. Equation (3) is defined for v∈Vxv\in V_x, but only values at v∈Bxv\in B_x are stored. It is outdegree minus indegree in the selected subgraph. We will say so explicitly.

  1. “Partial binary flow” and “binary witness.” A partial assignment is yg→0,1y_g\to{0,1}. It satisfies the final divergence equation at every forgotten vertex v∈Vx∖Bxv\in V_x\setminus B_x, while boundary vertices may still be unbalanced. It is therefore not yet a feasible flow on the full instance. Calling it a “partial binary arc assignment” before stating these conditions is clearer.

A complete witness for requirement g=(sg,tg,bg)g=(s_g,t_g,b_g) is the indicator of the union of bgb_g simple arc-disjoint sgs_g–tgt_g paths. At completion its divergence is bgb_g at sgs_g, −bg-b_g at tgt_g, and zero elsewhere. General binary flows may also contain removable circulations. Lemma 6 uses a path-union witness: each vertex has at most bgb_g incoming and outgoing selected arcs. After restriction to any AxA_x, both counts remain in [0,bg][0,b_g], so their difference lies in [−bg,bg][-b_g,b_g]. The bound holds at every node, but not for arbitrary assignments.

At the root, all conservation equations have been checked. Integral unit-capacity flow decomposition supplies the required disjoint paths. Removing a circulation from one requirement removes only that requirement's arc uses, not another requirement's certificate. Nonnegative union costs and an at-most budget make this harmless. This is why connectivity pairings can be omitted without a soundness gap.

  1. What is the algorithmic contribution? We agree that decomposition DP and flow decomposition are standard. The claim is the explicit dependence 2O((τ+1)κ)poly⁡(N,ℓ,L)2^{O((\tau+1)\kappa)}\operatorname{poly}(N,\ell,L) for the directed shared-cost, budgeted model, where κ=∑glog⁡2(2bg+1)\kappa=\sum_g\log_2(2b_g+1). The bounded-witness argument makes truncation complete, and the state invariant must enforce the bounds at all descendant bags, not merely the current one. Arc ownership gives exact one-time cost accounting at joins.

You are correct that the bound is exponential in workers. The distinction is polynomial dependence on multiplicity for fixed width and requirement count. Chalermsook et al. (2018) already provide rooted survivable-design algorithms with another parameter dependence. Feldmann et al. (2025) establish directed demand-two hardness and related undirected tractability. We claim neither novelty for qualitative FPT alone nor uniform improvement over those algorithms. The significance question is the quantitative guarantee, not the number of proof steps.

  1. Small grids and MILP. We agree on this limitation. The learning/provisioning grids have at most 30 vertices, with joint optima computed by MILP. The direct comparison has 40 cases plus 36 demand-profile stress cases. Flow-DP completes 22 in each suite, while MILP completes all cases. Small-instance agreement with exhaustive enumeration checks implementation correctness, not realistic scalability. We will not portray path-pairing speedups as MILP superiority, or the learning illustration as a DP deployment. The contribution is the quantitative theorem, with experiments delimiting its implementation.

References:

[1] Cygan et al. (2015), Parameterized Algorithms, Chapter 7, Springer.

[2] Chalermsook et al. (2018), “Survivable Network Design for Group Connectivity in Low-Treewidth Graphs,” APPROX/RANDOM.

[3] Feldmann et al. (2025), “The Parameterized Complexity of the Survivable Network Design Problem,” JCSS.

Thanks for the response. I will leave my rating where it is.

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

The paper studies minimum-cost directed communication supports under an arc-cardinality budget and prescribed survivability requirements between a coordinator and workers. It proposes a dynamic program on a supplied tree decomposition that stores bounded flow imbalances for each directional requirement, replacing explicit path identities and pairings. A bounded-witness argument establishes completeness, and rooted localization yields parameterized guarantees for planar and fixed apex-minor-free underlays. The experiments compare the flow DP with a labelled-path DP and MILP, followed by separate MILP-based provisioning and learning studies. The learning result establishes conditional preservation of a prescribed synchronous execution under bounded arc failures.

Critical strengths
  1. A clearly scoped algorithmic result with an explicit dependence on width and demand. The paper is honest that it is not a uniform improvement over prior bounded-width algorithms.
  2. Strong reproducibility: code, pinned dependencies, instances and raw results are provided, and the DP is validated against exhaustive enumeration and a MILP.
Critical weaknesses
  1. The demonstrated regime is far below realistic distributed-learning scale. The DP's state space is exponential in the number of requirements, which is twice the number of workers. It already fails on 6-requirement (3-worker) cases in Tables 1–2. Using the supplied code on a 4×5 grid with a larger state cap, the DP failed from 2 workers onward, while the MILP solved 8 workers in about 0.01 s. All learning and provisioning experiments use 3 workers and are solved by the MILP. Modern FL involves tens (cross-silo) to hundreds (cross-device) of clients. The paper does not identify any realistic setting where the DP is the right tool.
  2. The waiting and latency cost of the guarantee is not quantified. Corollary 8 assumes the coordinator waits indefinitely, failures stay fixed within a round, and surviving routes are found for free. The communication bound 2∣T∣ℓΔ2|T|\ell\Delta grows quadratically in ∣T∣|T|, since ℓ≥∣T∣(f+1)\ell ≥ |T|(f+1). Appendix H reports only hop counts and single-process simulator time, excluding failure detection, timeouts, contention and stragglers. Table 3 also shows that cheaper non-resilient supports lose only 0.05–0.5 points of accuracy, so the practical value of strict preservation is unclear.
Questions for authors
  1. What deployment size (number of workers, width, budget) motivates the DP, given that it fails at 3 workers while the MILP solves all cases quickly?
  2. Can you bound or measure actual round latency under failures, including detection and timeouts, and compare it with a synchronous protocol that skips unreachable workers?
1 comment
AuthorsOpenReview ↗

Tractability, waiting costs, and execution preservation

Thank you for the careful assessment and independent implementation test. We agree that a valid parameterized result does not establish a deployment-ready solver.

  1. What deployment regime actually motivates Flow-DP? The defensible regime is offline exact design with a small number of directional requirements and a narrow supplied decomposition, not general cross-device federated learning. With qq requirements, the table bound is S=(ℓ+1)∏g=1q(2bg+1)τ+1S=(\ell+1)\prod_{g=1}^q(2b_g+1)^{\tau+1}. Thus bidirectional demands for kk workers give q=2kq=2k, and the exponential dependence on workers is real. Narrow width does not establish suitability for many workers, or make our implementation preferable to MILP.

Your reported 4×54\times5 experiment reinforces this limitation. In the submitted 40-case suite, Flow-DP completes 22 cases and MILP all 40. In the separate 36-case stress suite, the corresponding counts are 22 and 36. Both suites include six-requirement cases on which Flow-DP fails. All larger provisioning and learning studies use MILP. We have not demonstrated a realistic deployment where Flow-DP should replace MILP.

The algorithmic value is an explicit worst-case guarantee exposing how multiplicity differs from requirement count: for fixed q,τq,\tau, increasing uniform demand bb incurs (2b+1)O(q(τ+1))(2b+1)^{O(q(\tau+1))}, rather than enumerating qbqb separate path identities. This is a quantitative guarantee, not universal speed superiority. Chalermsook et al. (2018) remain an important bounded-width predecessor with a different parameter tradeoff. The solver is a reference implementation, not a deployment recommendation.

  1. Waiting, failure discovery, and the latency bound. You are right that Corollary 8 supplies no unconditional wall-clock guarantee. It assumes failures remain fixed during a round, endpoints do not fail, surviving routes are discoverable, delivery is reliable, and the coordinator waits for every prescribed update. Without upper bounds on detection and delivery, a finite latency bound cannot follow from connectivity alone.

To make the distinction explicit, suppose detection including timeouts takes at most DD, route discovery takes at most RR, all sequential local computations and aggregation take at most CC, and a complete message crosses a surviving arc in at most Δ\Delta. For chosen simple outward/return paths Pt+,Pt−P_t^+,P_t^-, a serial schedule satisfies Tround≤D+R+C+Δ∑t(∣Pt+∣+∣Pt−∣)≤D+R+C+2kℓΔT_{\rm round}\le D+R+C+\Delta\sum_t(|P_t^+|+|P_t^-|)\le D+R+C+2k\ell\Delta. This sums the schedule's operations. It is conditional accounting, not measured latency. The 2kℓ2k\ell expression can be quadratic in workers under the required budget scaling. It is an upper bound for serialization, not a lower bound on every routing protocol. We make no subquadratic or throughput claim.

Appendix H reports 24.7 mean message hops and 0.352 ms of single-process simulated work per attempted round for the joint resilient support, versus 20.0 hops and 0.349 ms for healthy communication. Neither figure includes network delay or failure detection. They cannot answer the requested deployed-latency comparison. We will separate these measurements from the conditional schedule bound and identify the missing quantities explicitly.

  1. Why preserve all updates when the accuracy gap is small? We agree that Table 3 does not establish a favorable accuracy-versus-latency tradeoff. Its question is whether a prescribed computation is preserved. Joint resilient and pruned resilient supports retain every worker and reproduce healthy parameter trajectories. Nominal joint and nominal terminalwise supports retain all workers in 69.8% and 58.8% of attempted rounds. Their smaller final-accuracy losses show that execution preservation and predictive performance are different criteria, not that strict preservation is always preferable.

For a surviving set UU, renormalization uses ∑t∈Uwtgt/∑t∈Uwt\sum_{t\in U}w_tg_t/\sum_{t\in U}w_t, rather than ∑twtgt\sum_t w_tg_t. Equality need not hold. Recent methods address this problem by changing the learning algorithm: FedSWE compensates for heterogeneous, nonstationary availability (Xiang et al., 2026), while FedCompass changes scheduling to reduce straggler waiting (Li et al., 2024). Our narrower objective is to retain a fixed full-participation computation through link provisioning. We neither subsume those approaches nor show that waiting is preferable to them.

We will sharpen the paper accordingly: a scoped exact-design theorem, transparent implementation limits, and a conditional learning consequence. Your independent stress test helps delimit that contribution.

References:

[1] Chalermsook et al. (2018), “Survivable Network Design for Group Connectivity in Low-Treewidth Graphs,” APPROX/RANDOM.

[2] Xiang et al. (2026), “Resilience Beyond Stationary Client Unavailability: Unlocking Efficient and Unbiased Federated Learning,” JMLR 27(173).

[3] Li et al. (2024), “FedCompass,” ICLR.

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

The paper studies the selection of a minimum-cost directed support network that satisfies prescribed arc-disjoint path requirements between a coordinator and multiple workers, subject to a bound on the number of selected arcs. It formulates each connectivity requirement using flow-balance constraints and proposes a dynamic program over a tree decomposition, with states tracking boundary flow imbalances and the shared support cost and size. The paper evaluates the algorithms on small graph instances and presents a separate synchronous-learning simulation.

Critical strengths

On some of the smallest tested instances, Flow-DP appears to run faster than MILP. This suggests that the proposed approach may be useful in a restricted small-instance regime, though the results do not establish a broader advantage.

Critical weaknesses
  1. The connection to synchronous learning is not convincingly established. The paper essentially studies an abstract minimum-cost directed survivable-support problem. It does not clearly explain what deployment costs and connection failures represent in practice or how the formulation maps to actual communication and training decisions. Synchronous learning therefore appears more like motivation than an integral part of the technical contribution.
  2. The algorithmic novelty is insufficiently justified. Flow-DP combines flow-balance modeling with tree-decomposition DP, both established techniques. Although its bounded-imbalance state may be useful for this particular model, the paper does not sufficiently distinguish its contribution from prior low-treewidth survivable-network-design algorithms, such as Chalermsook et al. (2018), or establish a clear algorithmic advantage over them.
  3. The computational results do not demonstrate a practical advantage. Flow-DP solves only 22/40 instances, compared with 40/40 for MILP. The results provide limited evidence of an advantage over Pairing DP but do not establish that Flow-DP is more efficient or scalable than the stronger MILP baseline.
  4. The experimental coverage is too narrow. The graph experiments use small instances (up to (5\times4)), without sufficiently investigating different graph topologies, worker counts, or required redundancy levels. Thus, the practical robustness of the proposed method across different problem settings remains unclear.
  5. The learning simulation does not validate the proposed algorithm. Section 6.3 does not evaluate supports generated by Flow-DP. Instead, it compares support configurations constructed using other methods. The experiment illustrates that network survivability can affect worker participation and training outcomes, but does not demonstrate that Flow-DP provides any benefit in the motivating application.
  6. The comparisons in Section 6.3 are not controlled algorithmic comparisons. The evaluated configurations impose different connectivity and redundancy requirements, so their deployment costs and participation rates reflect different optimization objectives. The results therefore cannot establish the relative effectiveness of competing methods for the same problem.
  7. The simulation provides limited evidence of practical performance and reproducibility. Although the appendix describes parts of the simulation protocol, the evaluation relies on a small, single-process simulator rather than actual distributed execution. It does not account for network contention or failure-detection overhead, and the hardware/software environment and code availability are insufficiently documented.
  8. The theoretical and application-level contributions remain disconnected. Section 6.1 does not establish a computational advantage for Flow-DP, while Section 6.3 does not evaluate its outputs. Consequently, the paper neither convincingly demonstrates the practical value of its central algorithm nor establishes how that algorithm improves the motivating synchronous-learning scenario.
Questions for authors
  1. Clarification: What concrete system quantities do the arc costs and connection failures represent? How do the directed path and redundancy requirements map to communication and fault tolerance in synchronous learning? Is the algorithm intended to solve an operational planning problem, or is synchronous learning only a motivating example?
  2. Method: How does the demand-profile flow DP improve upon the rooted survivable network design algorithms of Chalermsook et al. (2018)? Specifically, for which parameter regimes does it provide guarantees that were previously unavailable or achieve a strictly better complexity bound?
  3. Clarification: Please specify the Section 6.3 setup, including the platform or simulator, configuration, network topology, and how connection failures are injected. Was Flow-DP run in this experiment? If so, what were its results? If not, how does this experiment validate the proposed method?
  4. Additional evidence relevant to the assessment: Can the authors provide results across more graph shapes, worker counts, and redundancy requirements, and report runtime and solved-instance comparisons against MILP? The current small, narrow test set does not establish the algorithm’s generality or practical regime of advantage.
  5. Presentation: Could the authors add a schematic overview of the problem and algorithm, and explicitly trace how the motivating synchronous-learning scenario induces the formal graph problem?
1 comment
AuthorsOpenReview ↗

Clarifying the contribution, learning connection, and evidence

Thank you for distinguishing small-instance gains from broader claims. We address each concern below.

  1. What is being designed, and why does it matter for learning? This is offline provisioning, not an online training scheduler. An arc represents a directed communication resource, cec_e its activation cost, and ℓ\ell the number of resources that may be provisioned. These are design weights, not measured latency or failure probabilities. A failure deletes a resource. Shared physical failure domains must be represented by all affected arc deletions, not counted as independent protection. Requiring bt+,bt−≥f+1b_t^+,b_t^-\ge f+1 preserves coordinator-to-worker and worker-to-coordinator reachability after any ff arc deletions.

The learning connection is precise but conditional. Given stable per-round failures, reliable delivery, unchanged worker randomness, and the same aggregation order, Corollary 8 preserves every reference iterate. Skipping unreachable workers generally changes the weighted update. Sun et al. (2025) study the bias induced by nonuniform participation, supporting the importance of this distinction, not the scalability of our solver. We establish a communication precondition, not a new learning rule or faster convergence.

  1. What is new relative to bounded-treewidth algorithms? We do not claim flow conservation or tree-decomposition DP as new. Theorem 2 gives an explicit bound for directed, nonuniform, independent survivability requirements with shared provisioning cost and a cardinality constraint. With qq requirements, κ=∑glog⁡2(2bg+1)\kappa=\sum_g\log_2(2b_g+1), and a width-τ\tau decomposition, the bound is 2O((τ+1)κ)poly⁡(N,ℓ,L)2^{O((\tau+1)\kappa)}\operatorname{poly}(N,\ell,L). For fixed q,τq,\tau, the dependence on uniform multiplicity bb is polynomial, rather than exponential in qbqb as in the path-labelled representation.

Chalermsook et al. (2018, Theorem 4 and Lemma 8) bound connection-profile cells by exp⁡(wO(wbmax⁡))\exp(w^{O(wb_{\max})}), for width ww and maximum demand bmax⁡b_{\max}, independently of requirement count. Our polynomial demand dependence for fixed q,τq,\tau is the contrast. The models and parameterizations differ, so we claim neither uniform dominance nor the first bounded-width algorithm. Feldmann et al. (2025) establish directed demand-two hardness and related undirected tractability. Our claim is the stated quantitative directed guarantee, not qualitative FPT alone. The completeness argument matters: an optimal path witness has bounded imbalance under every processed-arc restriction, whereas arbitrary partial assignments need not.

  1. Algorithm performance and experimental coverage. The 22/40 versus 40/40 result favors MILP overall. We agree. Section 6.1 also contains 36 prespecified stress cases crossing two widths, q∈1,2,6q\in{1,2,6}, b∈1,2,3b\in{1,2,3}, and two budget slacks. Flow-DP completes 22, pairing DP 19, and MILP all 36. Appendix G includes incomplete runs, stopping conditions, transition counts, and memory. These cases isolate parameter effects, but remain small grids. They do not establish realistic-topology or production-scale performance. We will state this explicitly.

  2. What does Section 6.3 actually test? Flow-DP did not produce those supports. The optimization-based designs use SciPy/HiGHS, and the pruning baseline is a separate heuristic. The study uses a fixed 3×43\times4 graph, three workers, linear softmax on digits, ten splits, balanced or Dirichlet(0.5) partitions, and 200 attempted rounds. Each round deletes one uniformly sampled underlay arc, using the same failure sequence for all supports. Unreachable workers are skipped and survivor weights renormalized.

Nominal versus resilient supports compare different survivability specifications, not competing solvers for one problem. The matched feasible comparison is joint resilient versus pruned resilient, which obey the same demands and budget. On the learning instance, their costs are 119 and 144, and both preserve healthy iterates. This supports the provisioning objective, not Flow-DP superiority. Appendix H measures routing and local computation in a single-process simulator. It excludes detection, contention, and real network delay. We will put hardware/software details and code/data instructions beside these timings and label them as simulator measurements.

  1. Presentation and scope. We will lead with a schematic: prescribed participants and failure tolerance → directional path demands → budgeted support optimization → surviving routes → the unchanged update rule. We will separate the theorem, solver comparison, and solver-independent learning illustration.

References:

[1] Chalermsook et al. (2018), “Survivable Network Design for Group Connectivity in Low-Treewidth Graphs,” APPROX/RANDOM.

[2] Feldmann et al. (2025), “The Parameterized Complexity of the Survivable Network Design Problem,” JCSS.

[3] Sun et al. (2025), “Debiasing Federated Learning with Correlated Client Participation,” ICLR.

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

Related papers

Discussion (0)

Sign in to comment.