{'fraction_non_alphanumeric': 0.04237685691946833, 'fraction_numerical': 0.007753453218660411, 'mean_word_length': 4.034507642852457, 'pattern_counts': {'":': 1, '<': 15, '<?xml version=': 0, '>': 13, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 10, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Optimal Oblivious Reconfigurable Networks

Oblivious routing has a long history in both the theory and practice of networking. In this work we initiate the formal study of oblivious routing in the context of reconfigurable networks, a new architecture that has recently come to the fore in datacenter networking. These networks allow a rapidly changing bounded-degree pattern of interconnections between nodes, but the network topology and the selection of routing paths must both be oblivious to the traffic demand matrix. Our focus is on the trade-off between maximizing throughput and minimizing latency in these networks. For every constant throughput rate, we characterize (up to a constant factor) the minimum latency achievable by an oblivious reconfigurable network design that satisfies the given throughput guarantee. The trade-off between these two objectives turns out to be surprisingly subtle: the curve depicting it has an unexpected scalloped shape reflecting the fact that load-balancing becomes more difficult when the average length of routing paths is not an integer because equalizing all the path lengths is not possible. The proof of our lower bound uses LP duality to verify that Valiant load balancing is the most efficient oblivious routing scheme when used in combination with an optimally-designed reconfigurable network topology. The proof of our upper bound uses an algebraic construction in which the network nodes are identified with vectors over a finite field, the network topology is described by either the elementary basis or a sequence of Vandermonde matrices, and routing paths are constructed by selecting columns of these matrices to yield the appropriate mixture of path lengths within the shortest possible time interval.


Introduction
Oblivious routing has a long history in both the theory and practice of networking. By design, an oblivious routing scheme forwards data along a fixed path (or distribution over paths) designed to provide good performance across a wide range of possible traffic demand matrices. Past theoretical work on oblivious routing schemes focused on their ability to approximate the congestion of the optimal multicommodity flow, culminating in Räcke's discovery [R08] of oblivious routing schemes for general networks that are guaranteed to approximate the optimum congestion within a logarithmic factor in the worst case. However, thus far, oblivious routing has only been studied in the context of static networks, where the edges in the network are fixed at the beginning and do not change over time. Recent advances in datacenter network architecture [WAK + 10, FPR + 10, PSF + 13, LLF + 14, GMP + 16, MMR + 17, MDG + 20, SVB + 19] have brought reconfigurable networks to the fore. A reconfigurable network is defined as a d-regular network with N nodes (or hosts) where the edges (or links) between the nodes can be reconfigured (or rearranged) very rapidly over time. Early designs of reconfigurable networks for datacenters [WAK + 10, FPR + 10, LLF + 14] relied on predictable traffic demand matrices to choose optimal edge configurations and routes for sending data between nodes. However, more recent works [MMR + 17, MDG + 20, SVB + 19] in this space have made a case that traffic demand matrices in datacenters are highly unpredictable and change at very fine time granularities, making it challenging, if not impossible, to accurately track the demand matrix at any given time. To overcome this fundamental challenge, recent works have advocated for edge configuration and route selection mechanisms that are oblivious to traffic demand matrices. In this paper, we make the first attempt to formally study the problem of oblivious routing in the novel context of reconfigurable networks.
There are two key objectives that oblivious reconfigurable networks must aim to optimize. First, since it is costly to overprovision networks (especially for modern high-bandwidth links), datacenter network operators aim for extremely high throughput, utilizing a large constant factor of the available network capacity at all times if possible. At the same time, it is desirable to minimize latency, the worst-case delay between when a packet arrives to the network and when it reaches its destination. Thus, there is a vital need to understand oblivious network designs for reconfigurable networks that guarantee high throughput and low maximum latency.
The objectives of maximizing throughput and minimizing latency in reconfigurable networks are in conflict: due to degree constraints most nodes cannot be connected by a direct link at all times, so one has to either use indirect paths, which comes at the expense of throughput, or settle for higher latency while waiting for reconfigurations to yield a more direct path. Since different deployments (and applications) may necessitate different tradeoffs between these two conflicting objectives, the main question that our work investigates is the following: For every throughput rate r, what is the minimum latency achievable by an oblivious reconfigurable network design that guarantees throughput r?
We fully resolve this question to within a constant factor 1 for d-regular reconfigurable networks, except when d is very large -bounded below by a constant power of N (the number of nodes in 1 One could, of course, ask the transposed question: for every latency bound L, what is the maximum guaranteed throughput rate achievable by an oblivious routing scheme with maximum latency L? Our work also resolves this question, not only to within a constant factor, but up to an additive error that tends to zero as N → ∞. As noted below in Section 1.2, optimizing throughput to within a factor of two, subject to a latency bound, is much easier than optimizing latency to within a constant factor subject to a throughput bound. The importance of the latter optimization problem, i.e. our main question, is justified by the high cost of overprovisioning networks: due to the cost of overprovisioning, datacenter network operators tend to be much less tolerant of suboptimal throughput than of suboptimal latency. the network). That is, for every constant rate r, we identify a lower bound 1 d L * (r, N ) such that any N -node d-regular reconfigurable network guaranteeing throughput r must have maximum latency bounded below by 1 d L * (r, N ). Complementing this lower bound, we design oblivious networking schemes that guarantee throughput r and have maximum latency bounded by O( 1 d L * (r, N )), for every constant r ∈ (0, 1 2 ], d ∈ N, and infinitely many N . (For r > 1 2 + o(1), we show in Appendix A that it is impossible for oblivious network designs to guarantee throughput r.) The shape of the optimal tradeoff curve between throughput and latency is quite surprising. Figure 1 depicts the curve for N = 10 9 and d = 1; the x-axis measures the inverse throughput, 1/r, while the y-axis (in log scale) measures maximum latency. The curve is scallop-shaped, with particularly favorable tradeoffs occurring when 1/r is an even integer. Between even-integer values of 1/r, the maximum latency improves slowly at first, then precipitously as 1/r approaches the next even integer. The proof of our main result explains these key features of the tradeoff curve: its non-convexity, the special role played by even integer values of 1/r, and the steep but continuous improvement in L * (r, N, d) as 1/r approaches the next even integer. In Section 1.2 below we sketch the intuitions that account for these features. Before doing so, we pause to explain more fully our model and notation. Figure 1: A plot of the upper and lower bounds for the latency of an ORN containing 10 9 nodes that can guarantee a given throughput.

Our Model and Results
Our model of oblivious reconfigurable networking is inspired by the circuit-switched network designs popularized by works such as [MMR + 17, MDG + 20, SVB + 19]. These are networks composed of a fixed set of N nodes, with a switching fabric that allows a time-varying pattern of links providing connectivity between node pairs. A network design in our model is specified by two ingredients: a connection schedule and an oblivious routing scheme. The connection schedule designates which node pairs are connected in each timeslot. This can be visualized in the form of a virtual topology: a layered directed graph (with layers corresponding to timeslots) that encodes the paths that network traffic can take over time. The oblivious routing scheme designates, for each source-destination pair (a, b) and timeslot t, a probability distribution over routing paths used to forward traffic with destination b that originates at a in timeslot t. A routing path is specified by the sequence of edges in the virtual topology that compose the path. We call the combination of a connection schedule and an oblivious routing scheme an oblivious reconfigurable network (ORN) design.
We evaluate ORN designs according to two quantities: maximum latency (L) and guaranteed throughput (r). Latency of a path measures the difference between the timeslots when it starts and ends, and an ORN design with maximum latency L uses no routing paths of latency greater than L. The definition of guaranteed throughput is more subtle. First, we model demand using a function that specifies, for each source-destination pair and each timeslot, the amount of flow with that source and destination originating at that time. We say an ORN design guarantees throughput r if the routing scheme is guaranteed not to exceed the capacity of any link, whenever the demand satisfies the property that the total amount of demand originating at any source, or bound for any destination, never exceeds r at any timeslot. Our main result can now be stated in the following form.
Theorem 1. Consider any constant r ∈ (0, 1 2 ]. Let (h, ε) to be the unique solution in N × (0, 1] to the equation 1 2r = h + 1 − ε, and let L * (r, N ) be the function For every N > 1 and every ORN design on N nodes that guarantees throughput r, the maximum latency is at least Ω(L * (r, N )). Furthermore for infinitely many N there exists an ORN design on N nodes that guarantees throughput r and whose maximum latency is O(L * (r, N )).

Techniques
To begin reasoning about the latency-throughput tradeoff in ORNs, note that for any node in the virtual topology, the number of distinct routing paths originating at that node whose latency is at most L and which contain p physical edges is L p . Hence, in order for a node to be able to reach a majority of other nodes within L timeslots using at most h physical links, we must have the inequality h p=0 L p ≥ N/2. A simple calculation verifies that this inequality implies L = Ω hN 1/h . A routing scheme in which the routing path between a random source and a random destination contains h physical links, on average, cannot guarantee throughput greater than 1/h. This suggests a latency-throughput relationship of the form L = Ω 1 r N r . This lower bound can be made rigorous with a little bit of work, but it differs from the tight bound asserted in Theorem 1 in two significant ways.
1. Whereas 1 r N r is a smooth convex function of r > 0, the function L * (r, N ) is non-smooth and non-convex; when plotted as a function of 1/r it exhibits a scalloped shape with cusps at even integer values of 1/r.
2. The exponent of N in the function L * (r, N ) is approximately 2r rather than r. In other words, the naïve bound L ≥ 1 r N r is tight up to a factor of 2 in terms of throughput, but off by a factor of about N r in terms of latency. (As remarked in Footnote 1, sacrificing a factor of 2 in throughput is typically regarded by network operators as much more costly than sacrificing a constant factor in latency.) The first of these differences is explained by a refinement of the counting argument at the start of this section. In order to guarantee throughput r, the average number of physical hops on the routing paths used (under any traffic demands with at most r units of flow based at any source or destination) must be at most 1/r. However, the number of physical hops in any path must be an integer. Thus, if 1/r is not an integer, at least a constant fraction of routing paths must have 1/r physical hops or fewer. Subject to any upper bound on latency, paths with a limited number of physical hops are much less numerous than those with a larger number of physical hops, so the requirement to use a large number of distinct paths with 1/r or fewer physical hops places a significantly stricter lower bound on maximum latency, leading to the non-convex shape with regularly spaced cusps depicted in Figure 1.
To give intuition for the factor-two difference in throughput between the naïve lower bound and the true function L * (r, N ), it is useful to recall Valiant load balancing (VLB), an ingredient in many of the earliest and most practical oblivious routing schemes. VLB constructs a random path from source s to destination t by choosing a random intermediate node, r, and concatenating minimumcost paths from s to r and from r to t. This inflates the number of physical hops used in routing paths by a factor of two, but is beneficial because it prevents congestion under worst-case demands. The fact that the exponent of N in L * (r, N ) is approximately 2r rather than r can be interpreted as confirming that the factor-two inflation due to VLB is unavoidable, for oblivious routing schemes that guarantee throughput r. To prove this fact, we formulate optimal oblivious routing for a given virtual topology as a linear program and interpret the dual variables as endpoint-specific edge costs that can be summed to ascribe a cost to every path connecting a given pair of endpoints. We prove that, regardless of the virtual topology, one can always design a carefully-constructed dual solution that penalizes paths containing a large number of physical hops, and doubly penalizes physical hops that are too close to both endpoints. Paths that avoid the double penalty must use twice as many physical hops as minimum-cost paths, exactly as in VLB routing. The most delicate part of the proof is the verification that the dual solution is feasible, which requires carefully bounding the number of nodes reachable from any source within a given cost budget.
To prove that the lower bound L * (r, N ) is tight, we need to construct an ORN design that matches the bound up to a constant factor. Our design is easiest to describe when r = 1 2h and N = n h for positive integer h and prime number n. In that case, we use a design that we call the Elementary Basis Scheme (EBS) which identifies the set of N nodes with elements of the group (Z/(n)) h . Let e be the elementary basis consisting of the columns of the h×h identity matrix. EBS uses a connection schedule whose timeslots cycle through the nonzero scalar multiples of elements of Y . In a timeslot devoted to s · e i , the network is configured to allow each node x to send to x + s · e i . Over the course of one complete cycle, any two nodes can be connected by a "direct path" consisting of h physical hops (or fewer) that modify the coordinates of the source node one by one until they match the coordinates of the destination. The EBS routing scheme constructs a random path connecting a given source and destination using VLB: it chooses a random intermediate node and concatenates two "semi-paths": the direct paths from the source to the intermediate node and from the intermediate node to the destination.
To generalize this design to all non-integer values of 1 2r , we need to enhance EBS so that a constant fraction of semi-paths use h physical hops and a constant fraction use h + 1 physical hops. This necessitates a modified ORN design that we call the Vandermonde Basis Scheme (VBS). Assume r = h + 1 − ε for h ∈ N, 0 < ε < 1, and that N = n h+1 for prime n, so that the nodes can be identified with the vector space F h+1 n . Instead of one basis corresponding to the identity matrix, we now use a sequence of distinct bases each corresponding to a different Vandermonde matrix. In addition to the single-basis semi-paths (which now constitute h + 1 physical hops), this enables the creation of "hop-efficient" semi-paths composed of h physical hops belonging to two or more of the Vandermonde matrices in the sequence. Hop-efficient semi-paths have higher latency than direct paths, but we opportunistically use only the ones with lowest latency to connect a subset of terminal pairs, joining the remaining pairs with direct semi-paths. A full routing path is then defined to be the concatenation of two random semi-paths, as before. Proving that the routing scheme guarantees throughput r boils down to quantifying, for each physical edge e, the net effect of shifting load from direct paths that use e to hop-efficient paths that avoid e and vice-versa. The relevant sets of paths in this calculation can be parameterized by unions of affine subspaces of F h+1 n , and the use of Vandermonde matrices in the connection schedule gives us control over the dimensions of intersections of these subspaces, and thus over the size of their union.

Related work
Oblivious routing in general networks: Räcke's seminal 2002 paper [R02] proved the existence of polylog(n)-competitive oblivious routing schemes in general networks. Subsequent work improved the competitive ratio [HHR03] and devised polynomial-time algorithms for computing an oblivious routing scheme that meets this bound [BKR03, HHR03, ACF + 03]. Räcke's 2008 paper [R08] yielded an O(log n)-competitive oblivious routing scheme, computed by a fast, simple algorithm based on multiplicative weights and FRT's randomized approximation of general metric spaces by tree metrics [FRT04]. The effectiveness of Räcke's 2008 routing scheme for wide-area traffic engineering in practice was demonstrated in [AC03,KYY + 18]. Additionally, Gupta, Hajiaghayi, and Räcke [GHR06] show a polylog(n) competitive ratio for routing schemes oblivious to both traffic and the cost functions associated with each edge. While these works achieve excellent congestion minimization over general networks, they do not specifically consider throughput or latency, and do not attempt to co-design the network with their routing scheme.
With respect to bounding the throughput of oblivious routing schemes, Hajiaghayi, Kleinberg, Leighton, and Räcke [HKLR06] prove a lower bound of Ω( log n log log n ) on the competitive ratio in general networks. However, their definition of throughput differs from ours; they simply mean the combined flow rate delivered to all sender-receiver pairs. With respect to latency, the competitive ratio of average latency of oblivious routing over general networks is analyzed by [HHN + 08]. Their model of latency differs from ours; they assign resistance values to each edge, and they only provide an oblivious routing scheme achieving the O(log(N ))-competitive ratio when routing to a single target.
Valiant load balancing in hypercubes and other architectures: Leslie Valiant introduced oblivious routing in [Val82]. The VLB scheme for randomized routing in the hypercube was introduced, and shown to be optimal, by Valiant and Brebner [VB81a,Val82]. While these works evaluate latency under queueing, they do not evaluate throughput. Additionally, they use a directconnect torus topology. Our work can be interpreted as proving that VLB is the optimal oblivious routing scheme to use in conjunction with an optimally-designed reconfigurable network topology, thus providing further theoretical justification for the widespread usage of VLB in practice when oblivious routing is applied on handcrafted network topologies.
A lower bound for deterministic oblivious routing in d-regular networks with N nodes was proven in [KKT91]; the same paper shows this bound is tight for hypercube networks, in which d = log(N ).
Load-Balanced Switches: The load-balanced switch architecture proposed by Chang [lb-02] uses static schedules and sends traffic obliviously via intermediate nodes. While there are significant similarities between this architecture and ORNs, it differs in its use of specialized intermediate nodes (rather than sending traffic via multiple end-hosts), as well as its focus on monolithic switches.
Circuit-Switched Datacenter Network Architectures: c-Through [WAK + 10] and Traffic Matrix Scheduling [PSF + 13], as well as many other designs, propose a hybrid network in which a packet-switched backbone exists alongside a circuit-switched fabric. However, with advances in circuit switches that have reduced reconfiguration times to nanosecond-scale, it is worth reconsidering whether a separate packet-switched backbone is truly necessary.
Oblivious Circuit-Switched Networks: Rotornet and Sirius [MMR + 17, BCB + 20] are two ORN concepts proposed for datacenter-wide networks that use optical circuit switches to build a reconfigurable network fabric. Shoal [SVB + 19] is a similar ORN concept that uses electric circuit switches in a disaggregated rack environment. Together, these works demonstrate that the ORN paradigm is feasible in practice. These designs use similar schedules that prioritize achieving high throughput at the expense of poor latency for large N . Our first ORN design, EBS, generalizes these existing designs to achieve many potential tradeoffs, ranging from the existing tradeoff to that achieved by an ORN version of hypercube routing.
Opera [MDG + 20] evolves on the ORN concept by greatly lengthening each timeslot and creating an expander graph topology between nodes during each timeslot. Opera uses a non-oblivious routing scheme in which latency-sensitive traffic is sent via multiple hops within a single expander graph topology, while throughput-sensitive traffic is held until the schedule advances to a topology in which it can be sent directly to the destination in one hop. This design makes strong assumptions about the workload, including that bandwidth-sensitive traffic demand is near all-to-all, limiting its flexibility.

Definitions
This section presents definitions that formalize the notion of an oblivious reconfigurable network (ORN). We assume a network of N nodes communicating in discrete, synchronous timeslots. The nodes are joined by a communication medium that allows an arbitrary pattern of unidirectional communication links to be established in each timeslot, subject to a degree constraint that each node participates as the sender in at most d connections, and as the receiver in at most d connections. Throughout most of this paper we specialize to the case d = 1; see Section 2.1 below for a discussion of why the general case reduces to this special case.
In systems that instantiate reconfigurable networking, data is encapsulated in fixed-size units called frames or packets. In this work we instead treat data as a continuously-divisible commodity, and we allow sending fractional quantities of flow along multiple paths from the source to the destination. This abstraction is standard in theoretical works on oblivious routing, and it can be justified by interpreting a fractional flow as a probability distribution over routing paths, with each discrete frame being sent along one path sampled at random from the distribution. Under this interpretation flow values represent the expected number of frames traversing a link.
Definition 1. A connection schedule π with size N and period length T is a sequence of permutations π 0 , π 1 , . . . , π T −1 , each mapping [N ] to [N ]. The interpretation of the relation π k (i) = j is that node i is allowed to send one frame to node j during any timeslot t such that t ≡ k (mod T ).
The virtual topology of the connection schedule π is a directed graph G π with vertex set [N ]×Z. The edge set of G π consists of the union of E virt and E phys . E virt is the set of virtual edges, which are of the form (i, t) → (i, t + 1) and represent the frame waiting at node i during the timeslot t. E phys is the set of physical edges, which are of the form (i, t) → (π t (i), t + 1) and represent the frame being transmitted from i to π t (i) at timeslot t.
We interpret a path in G π from (a, t) to (b, t ) as a potential way to transmit a frame from node a to node b, beginning at timeslot t and ending at some timeslot t . For a node a ∈ [N ] let a denote the set {a} × Z, consisting of all copies of a in G π . Let P(a, b, t) denote the set of paths in G π from the vertex (a, t) to b . Finally, let P = a,b,t P(a, b, t) denote the set of all paths in G π .
Figure 2: A connection schedule among four nodes, as well as part of its corresponding virtual topology. The full virtual topology represents a countably infinite number of timeslots.
For a given flow f , the amount of flow traversing an edge e is defined as: We say that f is feasible if for every physical edge e ∈ E phys , F (f, e) ≤ 1.
Definition 3. The latency L(P ) of a path P in G π is equal to the number of edges it contains (both virtual and physical). Note that traversing any edge in the virtual topology (either virtual or physical) is equivalent to advancing in time by the duration of one timeslot, so the number of edges in a path is proportional to the elapsed time. For a nonzero flow f , the maximum latency is the maximum over all paths in the flow We remark that our definitions of latency and of the virtual topology G π incorporate the idealized assumption of zero propagation delay. In other words, we assume that a frame sent in one timeslot is received by the beginning of the following timeslot, and that the number of edges of a path in the virtual topology accurately reflects the length of the time interval between when the frame originates and when it reaches its destination.
Definition 4. An oblivious routing scheme R is a function that associates to every (a, b, t) ∈ [N ] × [N ] × Z a flow R a,b,t such that: 1. R a,b,t is supported on paths from (a, t) to b , meaning ∀P ∈ P(a, b, t) R a,b,t (P ) = 0.
2. R a,b,t defines one unit of flow. In other words, P R a,b,t (P ) = 1.
3. R has period T . In other words, R a,b,t+T is equivalent to R a,b,t (except with all paths transposed by T timeslots, as required to satisfy point 1).

Definition 5.
A demand matrix is an N × N matrix which associates to each ordered pair (a, b) an amount of flow to be sent from a to b. A demand function D is a function that associates to every t ∈ Z a demand matrix D(t) representing the amount of flow D(t, a, b) to originate between each source-destination pair (a, b) at timeslot t. The throughput requested by demand function D is the maximum, over all t, of the maximum row or column sum of D(t).
Definition 6. For a given oblivious routing scheme R and demand function D, the induced flow Definition 7. An oblivious routing scheme is said to guarantee throughput r if the induced flow f (R, D) is feasible whenever the demand function D requests throughput at most r.
Definition 7 can be interpreted as meaning that the network is able to simulate a "big switch" with N input and output ports having line rate r: as long as the amount of data originating at any node a or destined for any node b does not exceed rate r per timeslot, the network is able to route all data to its destination without violating capacity constraints.
In this work, we examine the tradeoffs between guaranteed throughput and maximum latency. Specifically, among ORNs of size N that guarantee throughput r, what is the lowest possible maximum latency?

Allowing degree d > 1 in a timeslot
Although our formalization of ORNs only describes networks in which nodes have a degree of 1 in every timeslot, it can be generalized to networks that support a d-regular connectivity pattern in each timeslot. When d > 1, we interpret a demand matrix D which requests throughput r as one in which the row and column sums of D are bounded above by dr.
The connectivity of N × {t, t + 1} is d-regular bipartite. By Kőnig's Theorem, this edge set can be decomposed into d edge-disjoint perfect matchings, which we use to "unroll" into d consecutive timeslots of a 1-regular ORN. Therefore, a d-regular ORN design which guarantees throughput r with maximum latency L unrolls into a 1-regular ORN design which guarantees throughput r with maximum latency dL.
Under this framework, a lower bound L * (r, N ) for 1-regular ORN designs trivially implies the lower bound 1 d L * (r, N ) for d-regular designs. However, an upper bound for 1-regular designs does not necessarily imply a similar upper bound for d-regular designs, because the routing scheme could route paths containing two or more physical edges in timeslots belonging to the same "unrolled" segment of the 1-regular virtual topology. This would correspond to traversing two or more edges at once in the d-regular topology. We show in Section 4 that such a problem will never occur due to our construction. Specifically, we show that our construction can be modified to never allow flow to be routed along two edges within any block of d consecutive time slots, provided d ≤ N 1/(h+1) . This modification will add a factor of at most 2 to the maximum latency. Then, by inverting the unrolling process, we will obtain a d-regular ORN design with maximum latency L = O( 1 d L * (r, N )). This confirms that the tight bound on maximum latency for d-regular ORN designs is Θ( 1 d L * (r, N )) whenever d ≤ N 1/(h+1) and justifies our focus on the case d = 1 throughout the remainder this paper.

Lower Bound
In this section we prove the lower-bound half of Theorem 1, which says that when 1 2r = h + 1 − ε with h ∈ N and 0 < ε ≤ 1, any d-regular, N -node ORN design that guarantees throughput r must have maximum latency Ω( h d [N 1/(h+1) + (εN ) 1/h ]). As noted in Section 2.1, the general case of this lower bound reduces to the case d = 1, and we will assume d = 1 throughout the remainder of this section.
Because the full proof is somewhat long, we begin by sketching some of the main ideas in the proof, beginning with a much simpler argument leading to a lower bound of the form Ω( 1 r N r ) when 1/r is an integer. This simple lower bound applies not only to oblivious routing schemes, but to any feasible flow f that solves the uniform multicommodity flow problem given by the demand function D(t, a, b) = r N −1 for all t ∈ [T ] and b = a. The lower bound follows by combining a few key observations. 1. Define the cost of a path to be the number of physical edges it contains. Since every source sends out r units of flow at all times, the flow f sends out rN T units of flow per T -step period, in a network whose physical edges have only N T units of capacity per T -step period.
Consequently the average cost of flow paths in f must be at most 1 r . 2. For any source node (a, t) in the virtual topology, the number of distinct destinations b that can be reached via a path with maximum latency L and cost p is bounded above by L p .
3. If L ≤ 1 2er N r , we have L 1/r ≤ N/4 and 1/r p=1 L p ≤ N/2, so the majority of source-destination pairs cannot be joined by a path with latency L and cost less than 1 r + 1. In fact, even if we connect every source and destination with a minimum-cost path (subject to latency bound L), one can show that the average cost of paths will exceed 1 r . 4. Since a feasible flow must have average path cost at most 1 r , we can conclude that a feasible flow does not exist when L ≤ 1 2er N r .
When 1/r is an integer, this lower bound of L max ≥ 1 2er N r for feasible uniform multicommodity flows turns out to be tight up to a constant factor. However for oblivious routing schemes, Theorem 1 shows that maximum latency is bounded below by a function in which the exponent of N is roughly twice as large. Stated differently, for a given maximum latency bound, the optimal throughput guarantee for oblivious routing is only half as large as the throughput of an optimal uniform multicommodity flow.
The factor-two difference in throughput between oblivious routing and optimal uniformly multicommodity flow solutions aligns with the intuition that oblivious routing schemes must use indirect paths (as in Valiant load balancing) if they are to guarantee throughput r, whereas uniform multicommodity flow solutions (in a well-designed virtual topology) can afford to satisfy all demands using shortest-path routing. The proof of the lower bound for oblivious routing needs to substantiate this intuition.
To do so, we formulate oblivious routing as a linear program and interpret the dual variables as specifying a more refined way to measure the cost of paths. Rather than defining the cost of a path to be its number of physical edges, the duality-based proof amounts to an accounting system in which the cost of using an edge depends on the endpoints of the path in which the edge is being used. For a parameter θ which we will set to h + 1 (unless ε is very small, in which case we'll set θ = h + 2), the dual accounting system assesses the cost of an edge to be 1 if its distance from the source is less than θ, plus 1 if its distance from the destination is less than θ. Thus, the cost of an edge is doubled when it is close to both the source and the destination. The doubling has the effect of equalizing the costs of direct and indirect paths: when the distance between a source and destination is at least θ, there is no difference in cost between a shortest path and one that combines two semi-paths each composed of θ physical edges.
Viewed in this way, it is intuitive that the proof manages to show that VLB routing schemes, which construct routing paths by concatenating random semi-paths with the appropriate number of physical edges, correspond to optimal solutions of the oblivious routing LP. The difficulty in the proof lies in showing that the constructed dual solution is feasible; for this, we make use of a version of the same counting argument sketched above, that bounds the number of distinct destinations reachable from a given source under constraints on the maximum latency and the maximum number of physical edges used.

Lower Bound Theorem Proof
Before presenting the proof of Theorem 2, we formalize the counting argument we reasoned about in our proof sketch.
Lemma 1. (Counting Lemma) If in an ORN topology, some node a can reach k other nodes in at most L timeslots using at most h physical hops per path for some integer h, then k ≤ 2 L h , assuming h ≤ 1 3 L. Proof. If node a can reach k other nodes in ≤ L timeslots using exactly h physical hops per path, then k ≤ L h . Additionally, the function L h grows at least exponentially in base 2 -that is, Given an ORN design R which guarantees throughput r, the maximum latency suffered by any routing path P with R a,b,t (P ) > 0 over all a, b, t is bounded by the following equation Consider the linear program below which maximizes throughput given a maximum latency constraint, L, where we let P L (a, b, t) be the set of paths from (a, t) → b with latency at most L.
The second set of constraints, in which the parameter σ ranges over the set S N of all permutations of [N ], can be reformulated as the following set of nonlinear constraints in which the maximum is again taken over all permutations σ: Note that given an edge e, this maximization over permutations σ corresponds to maximizing over perfect bipartite matchings with edge weights defined by w a,b,e = T −1 t=0 P ∈P L (a,b,t):e∈P R a,b,t (P ). This prompts the following matching LP and its dual. We then substitute finding a feasible matching dual solution into the original LP, replace the expression w a,b,e with its definition T −1 t=0 P ∈P L (a,b,t):e∈P R a,b,t (P ), and take the dual again.

Matching
The variables y a,b,e can be interpreted as either edge costs we assign dependent on sourcedestination pairs (a, b), or demand functions designed to overload a particular edge e. We will use both interpretations, depending on if we are comparing y a,b,e variables to either x a,b,t or z e variables respectively. According to the fourth dual constraint, the variables x a,b,t can be interpreted as encoding the minimum cost of a path from (a, t) to b subject to latency bound L. According to the second and third dual constraints, the variables z e can be interpreted as bounding the throughput requested by the demand function D(t, a, b) = y a,b,e . We will next define the cost inflation scheme we use to set our dual variables.
Cost inflation scheme For a given node a ∈ [N ] and cutoff θ ∈ Z >0 , we will classify edges e according to whether they are reachable within θ physical hops of a, counting edge e as one of the hops. (In other words, one could start at node a and cross edge e using θ or fewer physical hops.) We define this value m + θ (e, a) as follows. To understand how these values are set, consider some path P from (a, t) → b . If we consider the m + θ , m − θ weights on the edges of P , then the first θ physical hop edges of P have weight m + θ (e, a) = 1 and the last θ physical hop edges of P have weight m − θ (e, b) = 1. It may be the case that some edges have both m + θ (e, a) = m − θ (e, b) = 1, if P uses fewer than 2θ physical hops. And if P uses θ or fewer physical hops, then every physical hop edge along P has weight m + θ (e, a) = m − θ (e, b) = 1. All other weights may be 0 or 1 depending on whether those edges are otherwise reachable from a or can otherwise reach b.
We start by settingŷ a,b,e = m + θ (e, a) + m − θ (e, b). Also setx a,b,t = min P ∈P L (a,b,t) { e∈Pŷ a,b,e }. Note that by definition,x andŷ variables satisfy the last dual constraint. We will next find a lower bound w ≤ a,b,tx a,b,t and use that to normalize thex,ŷ variables to satisfy the first dual constraint.
Note that e∈Pŷ a,b,e ≥ min{2θ, 2|P ∩ E phys |}. Then we can bound the sum ofx variables by Note thatx a,b,t < 2θ only when there exists some path from (a, t) to b which uses less than θ physical edges. We can then use the Counting Lemma to produce an upper bound on the number of b = a which have such paths: this is at most 2 L θ−1 . So, assuming that 2 L θ−1 ≤ N and that θ − 1 ≤ L/3, we have and then set y a,b,e = 1 wŷ a,b,e and x a,b,t = 1 wx a,b,t . Next, we set z e = max a,b { a y a,b,e , b y a,b,e }. By construction, the values of x a,b,t , y a,b,e , z e that we have defined satisfy the dual constraints. Then to bound throughput from above, we upper bound the sums a y a,b,e and b y a,b,e , thus upper bounding the sum of z e 's.
where the last step is an application of the Counting Lemma. Similarly, Recalling that z e = max a,b { a y a,b,e , b y a,b,e }, we deduce that Using this upper bound on z e , we find that the optimal value of the dual objective -hence also the optimal value of the primal, i.e. the maximum throughput of oblivious routing schemes -is bounded by At this point, we can rearrange the inequality to isolate L.
Now that we have a closed form, we simplify. We use Stirling's approximation, in the form (k!) To set the parameter θ, first note that the above bound is positive when r > 1 2θ . Additionally, we would like to set θ as large as possible, and θ must be an integer value (otherwise the Counting Lemma doesn't make sense). Taking this into account, we set θ = 1 2r + 1, the nearest integer for which (r − 1 2θ ) produces a positive value. To simplify our lower bound further, let h = 1 2r and ε = h + 1 − 1 2r . These can be interpreted in the following way: h represents the largest number of physical hops we take per path (approximately), and ε is directly related to how many pairs take paths using h physical hops instead of paths using fewer than h physical hops. Note that ε ∈ (0, 1]. This gives the restated bound below. As ε → 0, this bound goes toward 0, making it meaningless for extremely small values of ε. However, for such values of ε, we simply set θ = h + 2 instead, which gives the following L max ≥ Ω (h + 1)N 1/(h+1) To combine the two ways in which we set θ, we take the average of the two bounds. This gives the bound from our theorem statement, r, N )) .

Upper Bound
To prove an upper bound on the latency achievable while guaranteeing a given throughput, we define an infinite family of ORN designs which we refer to as the Elementary Basis Scheme (EBS). The upper bound given by EBS is within a constant factor of the previously described lower bound for most values of r. To tightly bound the remaining values of r, we describe a second infinite family of ORN designs which we refer to as the Vandermonde Bases Scheme (VBS). Combined, EBS and VBS give a tight upper bound on maximum latency for all constant r. We address the upper bound for d-regular networks with d > 1 by modifying EBS and VBS in Section 4.7.

Elementary Basis Scheme
Connection Schedule: In EBS's connection schedule, each node participates in a series of subschedules called round robins. Consider a cyclic group H = Z/(n) acting freely on a set S of n nodes, where we denote the action of t ∈ H on i ∈ S by i + t. A round robin for S is a schedule of n − 1 timeslots in which each element of S has a chance to send directly to each other element exactly once; during timeslot t ∈ [n − 1] node i may send to i + t. The number of round-robins in which each EBS node participates is controlled by a tuning parameter h which we refer to as the order. Similar to the previous section, h will be half of the the maximum number of physical hops in an EBS path.
Let n = N 1/h , so that the node set [N ] is in one-to-one correspondence with the elements of the group H h . Each node a ∈ [N ] is assigned a unique set of h coordinates (a 0 , a 1 , ..., a h−1 ) ∈ H h and participates in h round robins, each containing the n nodes that match in all but one of the h coordinates. We refer to these round robins as phases of the EBS schedule. One full iteration of the EBS schedule, or epoch, contains h phases. Because each phase is a round robin among n nodes, each phase takes n − 1 timeslots, resulting in an overall epoch length of T = h(n − 1) = h(N 1/h − 1).
We now describe the EBS schedule formally. We express each node i as the h-tuple (i 0 , i 1 , . . . , i h−1 ) ∈ (Z/n) h . Similarly, we identify each permutation π k of the connection schedule using a scale factor s, 1 ≤ s < n, and a phase number p, 0 ≤ p < h, such that k = (n − 1)p + s − 1. Let e p denote the standard basis vector whose p th coordinate is 1 and all other coordinates are 0. The connection schedule is then π (n−1)p+s−1 (i) = i + se p = j. Since e is the standard basis, j x = i x for x = p, and j p = i p + s (mod n).
The EBS schedule can be seen as simulating a flattened butterfly graph between nodes [KNP + 07]. This schedule generalizes existing ORN designs which have thus far all been based on the same schedule: a single round robin among all nodes, simulating an all-to-all graph. When h = 1, the EBS schedule reduces to this existing schedule. On the other hand, when h = log 2 (N ), the EBS schedule simulates a direct-connect hypercube topology. By varying h, in addition to achieving these two known points, the EBS family includes schedules which achieve intermediate throughput and latency tradeoff points.

Oblivious Routing Scheme
The EBS oblivious routing scheme is based around Valiant load balancing (VLB) [VB81b]. VLB operates in two stages: first, traffic is routed from the source to a random intermediate node in the network. Then, traffic is routed from the intermediate node to its final destination. This two-stage design ensures that traffic is uniformly distributed throughout the network regardless of demand. We refer to the path taken during an individual stage as a semi-path, and we use the same algorithm to generate semi-paths in either stage.
To create a semi-path between a node (a, t) and b , the following greedy algorithm is used starting at (a, t): for the current node in the virtual topology, if the outgoing physical edge leads to a node with a decreased Hamming distance to b (i.e. it matches b in the modified coordinate), traverse the physical edge. Otherwise, traverse the virtual edge. This algorithm terminates when it reaches a node in b . Note that because there are h coordinates, the largest Hamming distance possible is h, and the longest semi-paths use h physical links.
In order to construct a full path from (a, t) to b , first select an intermediate node c in the system uniformly at random. Then, traverse the semi-path from (a, t) to c . Let t be the timeslot at which we reach c . If t < t + T , traverse virtual edges until node (c, t + T ) is reached. Finally, traverse the semi-path from (c, t + T ) to b .
The EBS oblivious routing scheme is formed as follows: for R a,b,t , for all intermediate nodes c, construct the path from (a, t) to b via c as described above, and assign it the value 1 N . Assign all other paths the value 0. Because there are N possible intermediate nodes, each of which is used to define one path from (a, t) to b , this routing scheme defines one unit of flow.

Latency-Throughput Tradeoff of EBS
Proposition 1. For each r ≤ 1 2 such that h = 1 2r is an integer, and each N > 1 such that N 1/h is an integer, the EBS design of order h on N nodes guarantees throughput r and has maximum latency 1 r N 2r − 1 .
The proof of Proposition 1 is contained in the following two subsections, which address the latency and throughput guarantees respectively.

Latency
Recall that h = 1 2r and that n = N 1/h = N 2r , so the latency bound in Proposition 1 can be written as 2h(n − 1). Since the epoch length is T = h(n − 1), the latency bound asserts that every EBS routing path completes within a time interval no greater than the length of two epochs. An EBS path is composed of two semi-paths, so we only need to show that each semi-path completes within the length of a single epoch.
Let (a, t) denote the first node of the semi-path. If t occurs at the start of a phase, then after p phases have completed the Hamming distance to the semi-path's destination address must be less than or equal to t − p; consequently the semi-path completes after at most h phases, as claimed. If t occurs in the middle of a phase using basis vector e p , let s denote the number of timeslots that have already elapsed in that phase. Either the semi-path is able to match the p th destination coordinate before the phase ends, or the coordinate can be matched during the first s timeslots of the next phase that uses basis vector e p . In either case, the p th destination coordinate will be matched no later than timeslot t + T , and all other destination coordinates will be matched during the intervening phases.

Throughput
Lemma 2. Let R be the EBS routing scheme for a given N and h. For all demand functions D requesting throughput at most 1 2h , the flow f (R, D) is feasible.
Proof. Consider an arbitrary demand function D requesting throughput r = 1 2h , and consider an arbitrary physical edge e ∈ E phys from (i, t e ) to (j, t e + 1), where t e is the timeslot during which the edge begins. Let t e ≡ (p e , s e ) such that p e is the phase in the schedule corresponding to t e , and s e is the scale factor used during t e . We wish to show that F (f (R, D), e) ≤ 1.
We first use a greedy algorithm described in Appendix B to generate D , a demand function such that for all t, D (t) has row and column sums exactly equal to r, and D (t) bounds D(t) above. Due to the latter condition, it follows that f (R, D ) bounds f (R, D) above; thus F (f (R, D ), e) ≥ F (f (R, D), e). Henceforward, we focus on proving F (f (R, D ), e) ≤ 1.
Valid paths in EBS include two components: the semi-path from the source node to an intermediate node, and the semi-path from the intermediate node to the destination node. We can therefore decompose the paths in F (f (R, D ), e) into two components as follows: first, we define R , a routing protocol defined such that R a,b,t (P ) equals 1 if P is the semi-path from (a, t) to b , and 0 otherwise. Because EBS uses the same routing strategy for both source-intermediate semi-paths and intermediate-destination semi-paths, R is used for both components. Then, we introduce two demand functions: D a→b represents demand on semi-paths from origin nodes to intermediate nodes, while D b→c represents demand on semi-paths from intermediate nodes to destination nodes. Note that for all physical edges e, To characterize D a→b , note that regardless of source and destination, R samples intermediate nodes Similarly, because semi-paths from an intermediate node to the destination always commence exactly T timeslots after the starting vertex, we can characterize D b→c (t, b, c) as follows: Proof of claim. Denote the endpoints of edge e by (i, t e ) and (i + s · e p , t e + 1). The semi-path of a triple (t, a, b) traverses e if and only if the semi-path first routes from (a, t) to (i, t e ), and (b − a) p = s. Because semi-paths complete in T timeslots, only semi-paths beginning in timeslots in the range [t e − T + 1 . . . t e ] could possibly reach node (i, t e ) and traverse e. For every t ∈ [t e − T + 1..t e ], where t ≡ (p t , s t ), we can construct n h−1 such triples as follows: First, we select d, a vector representing the difference between a and b in the triple we will construct. To satisfy the second condition on (t, a, b), we must set d p = s. However, the remaining h − 1 indices of d can take on any of the n possible values. Thus, there are n h−1 possibilities for d.
For any semi-path (t, a, b) such that b−a = d, the timeslots in which a physical edge is traversed can be determined from d. For any given timeslot t ≡ (p , s ) such that t ≤ t < t + T , a physical edge is traversed if and only if d p = s . These are the edges that decrease the Hamming distance to b by correctly setting coordinate p. We thus construct a as follows: For every index p, if (d p , p) is between k t and k e − 1 inclusive, we set a p = i p − d p . Otherwise, we set a p = i p . Once we have constructed a, b is simply a + d. This choice of a and b ensures that by timeslot t e , the semi-path from (a, t) to b reaches i .
For each of the T timeslots for which semi-paths originating in the given timeslot may traverse e, there are n h−1 such semi-paths. This gives a total of T n h−1 semi-paths that traverse e over all timeslots. Note that because each such semi-path has a unique (t, d), none of the constructed semi-paths are double counted. In addition, because the (t, d) pair determines the timeslots in which physical links are followed, and because there is only one physical link entering and leaving each node during each timeslot, there cannot be more than one choice of a for a given (t, d) pair such that the semi-path includes (i, t e ). Because the T n h−1 count includes all possible choices of d for every timeslot, all semi-paths that traverse e are accounted for. Now we continue with the proof of Lemma 2. Since exactly T n h−1 triples (t, a, b) correspond to semi-paths that traverse e, and D ALL assigns r N flow to each semi-path, F (f (R , D ALL ), e) = r N T n h−1 = r N h(n − 1)n h−1 . Thus: When r ≤ 1 2h , for all physical edges e, F (f (R, D, e)) ≤ 1. Thus, f (R, D) is feasible.

Tightness of EBS Upper Bound
Lemma 3. For 0 < r ≤ 1 2 let h = 1 2r and ε = h + 1 − 1 2r . The EBS design of order h attains maximum latency at most CL * (r, N ), except when Proof. Theorem 2 and Proposition 1 together show the following about the maximum latency of EBS compared to the maximum latency lower bound: Note that this interpretation of the maximum latency lower bound is taken from equation (2) in the proof of Theorem 2. Suppose we wish to assert L EBS /L * (r, N ) ≤ C. Given C and h, we will derive the possible values of ε for which this assertion holds.
When ε falls outside this range, the maximum latency of the EBS design is far from optimal. In the following sections we present and analyze an ORN design which gives a tighter upper bound when ε falls outside this range, in other words when ε < 2 2h π 2e C h .

Vandermonde Bases Scheme
In order to provide a tight bound when ε is very small, we define a new family of ORN designs which we term the Vandermonde Bases Scheme (VBS). VBS is defined for values of N which are perfect powers of prime numbers. We begin by providing some intuition behind the design of VBS.
For h = 1 2r and ε = h + 1 − 1 2r , a small value of ε indicates that r is slightly above 1 2(h+1) . This indicates that the average number of physical hops in a path can be at most slightly below the even integer 2(h + 1). EBS is only able to achieve an average number of physical hops equal to an even integer as N becomes sufficiently large. In small ε regions, the difference between the highest average number of physical hops theoretically capable of guaranteeing r throughput and the average number of physical hops used by EBS approaches 2. This suggests that EBS achieves a throughputlatency tradeoff that favors throughput more than is necessary in these regions, penalizing latency too much to form a tight bound. A more effective ORN design for these regions would use paths with 2(h + 1) physical hops, but mix in sufficiently many paths with fewer physical hops to ensure that the average number of physical hops per path is at most 2(h + 1 − ε).
VBS achieves this by employing two routing strategies for semi-paths alongside each other. The first strategy, single-basis (SB) paths, resembles the semi-path routing used by EBS for h = h + 1. The second strategy, hop-efficient (HE) paths, will rely on the fact that VBS's schedule regularly modifies the basis used to determine which nodes are connected to one another. HE paths will consider edges beyond the current basis, enabling them to form semi-paths between nodes using only h hops, even when this is not possible within a single basis. The more future phases are considered, the more nodes can be connected by HE paths. This tuning provides a high granularity in the achieved tradeoff between throughput and latency, and enables a tight bound in regions where ε is small. It is interesting that the quantitative reasoning underlying this scheme is reminiscent of the proof of the Counting Lemma (Lemma 1), which similarly classifies paths into short paths and long paths and counts the number of destinations reachable by short paths.
We define VBS for N = n h+1 such that n is a prime number. The connection schedule and routing algorithm of VBS depend on a parameter δ, which represents a target for the fraction of semi-paths that traverse HE paths. We later describe how to set Q, the number of future phases considered for HE path formation, such that the number of destinations reachable by HE paths is approximately δN .

Connection Schedule
Before describing the connection schedule of VBS, it is instructive to revisit the schedule of EBS. EBS's schedule consists of h phases. Each of these phases is defined based on an elementary basis vector e p , connecting each node i to nodes i + se p for all possible nonzero scale factors s. VBS is defined similarly, except instead of elementary basis vectors, Vandermonde vectors (to be defined in the next paragraph of this section) are used to form the phases. In addition, rather than using a single basis, the VBS connection schedule is formed from a longer sequence of phases, with any set of h + 1 adjacent phases corresponding to a basis.
For VBS, we assume the total number of nodes in the system is N = n h+1 for some prime number n. As in EBS, each node a is assigned a unique set of h + 1 coordinates (a 0 , a 1 , ..., a h ), each ranging from 0 to n − 1. This maps each node to a unique element of F h+1 n . We identify each permutation π k of the connection schedule using a scale factor s, 1 ≤ s < n and a phase number 2 p, 0 ≤ p < n, such that k = (n − 1)p + s − 1. Each phase p is formed using the Vandermonde vector v(p) = (1, p, p 2 , ..., p h ). This produces the connection schedule π (n−1)p+s−1 (i) = i + sv(p).

Routing Algorithm
As with EBS, VBS's oblivious routing scheme is based around VLB. First, traffic is routed along a semi-path from the source to a random intermediate node in the network, and then traffic is routed along a second semi-path from the intermediate node to its final destination. As in EBS, the same algorithm is used to generate semi-paths in both stages of VLB. However, unlike in EBS, semi-paths are only defined starting at phase boundaries. Thus, the first step of a VBS path is to traverse up to n − 2 virtual edges until a phase boundary is reached. Paths are then defined for a given (q, a, b) triple, where q = t/(n − 1) for some timeslot t at the beginning of a phase (hence t is divisible by n − 1). Following the initial virtual edges to reach a phase boundary, we concatenate the semi-path from the source to the intermediate node, followed by the semi-path from the intermediate node to the destination.
Depending on the current phase and the source-destination pair, we either route via a singlebasis path or a hop-efficient path. The routing scheme always selects a hop-efficient semi-path when one is available, and otherwise it selects a single-basis path. We describe both path types below.
Single-basis paths The single-basis path, or SB path, for a given (q, a, b) is formed as follows: First, we define the distance vector d = b − a, as well as the basis Y = (v(q), v(q + 1), ..., v(q + h)). Note that the vectors in the basis Y are those used to form the h + 1 phases beginning with phase q. Then, we find s = Y −1 d. Over the next h + 1 phases, for every timeslot t ≡ (p , s ), if s = s p , the physical edge is traversed. Otherwise, the virtual edge is traversed. This strategy corresponds to traversing d through its decomposition in basis Y , beginning at node a and ending at node b.
Although this algorithm for SB paths completes within h + 1 phases, following this virtual edges are traversed for a further Q phases. This ensures that both SB and HE paths take h + 1 + Q phases to complete. Note that it is possible for an SB path to have fewer than h + 1 hops, although this becomes increasingly rare as N grows without bound.
Hop-efficient paths A hop-efficient path, or HE path, is formed as follows: First, for h + 1 phases, only virtual edges are traversed. This ensures that the physical hops of HE and SB paths beginning during the same phase q use disjoint sets of vectors (assuming n > h + 1 + Q), which simplifies later analysis. Following this initial buffer period, h phases are selected out of the next Q phases, and one physical hop is taken in each selected phase. During all other timeslots within the Q phases, virtual hops are taken.
For a given starting phase q and starting node a, there are Q h (n − 1) h possible HE paths. Because there are a total of N destinations reachable from a, we would like δN destinations to be reachable by HE paths. Ignoring for now the possibility of destinations reachable by multiple HE paths, we set Q to the lowest integer value such that: Note that for this value of Q, Q−1 h < δn. For some (q, a, b), more than one HE path may exist. In this case, an arbitrary selection can be made between these multiple paths; the specific path chosen does not affect our analysis of VBS.

Latency
A VBS path begins with at most n − 2 virtual edges traversed until a phase boundary is reached. Following this, the first semi-path immediately begins, followed by the second semi-path. Because both SB and HE paths are defined to take h + 1 + Q phases, the latency of a single semi-path is (n − 1)(h + 1 + Q). This gives a total maximum latency of (n − 2) + 2(n − 1)(h + 1 + Q) = (n − 1)(3 + 2h + 2Q) − 1 for VBS paths.
Proof. Consider an arbitrary demand function D requesting throughput at most r, and consider an arbitrary physical edge e ∈ W phys from (i, t e ) to (j, t e + 1), where t e is the timeslot during which the edge begins. Let t e ≡ (p e , s e ) such that p e is the phase in the schedule corresponding to t e , and s e is the scale factor used during t e . We wish to show that F (f (R, D), e) ≤ 1.
As in our proof of the throughput of EBS (Lemma 2), we begin by inflating D into D . Similarly, we define R , the routing protocol for semi-paths, and we decompose f (R, D ) into f (R , D a→b ) and f (R , D b→c ). Note that because semi-paths begin only on phase boundaries, R in this case does not strictly follow our definition for an oblivious routing scheme. Instead, we define R a,b,q using phases q, rather than timeslots t, for the domain. The path used for R a,b,q begins during the first timeslot of phase q. This is reflective of the definitions for semi-paths in VBS.
To generate D a→b , note that R first batches (a, b, t) triples over the n − 1 timeslots preceding an epoch boundary, before sampling intermediate nodes uniformly. Therefore, for all (q, a, b) D (q(n − 1) − t, a, c) = (n − 1)r N Similarly, because semi-paths from an intermediate node to the destination always commence exactly h + 1 + Q phases after the beginning of the first semi-path, we can define D b→c (t, b, c) as follows: To calculate F (f (R , D ALL ), e), we compute the number of (q, a, b) triples that traverse edge e. We calculate this number as follows: First, we calculate # SB , which represents the number of (q, a, b) triples that have an SB path that traverses edge e. Then, we calculate # missing , the number of such triples that have an HE path available (and thus do not traverse e). Finally, we determine # HE , the number of triples that traverse e using an HE path. The total flow traversing edge e is then F (f (R , D ALL ), e) = (n−1)r N (# SB − # missing + # HE ). To find # SB , we use reasoning similar to that used in Lemma 2. In order for a given (q, a, b) to have an SB path that traverses edge e, the SB path for (q, a, b) must reach node (i, t), then traverse edge e. The only values of q for which this is possible are those in the range q e − h ≤ q ≤ q e . For each of these q, we can generate n h distinct (q, a, b) triples that have SB paths that traverse edge e as follows. First, select an arbitrary s such that s qe−q = s e . Then, set a = i − Σ qe−1 q =q s q −q v(q ), and b = a + Σ q+h q =q s q −q v(q ). In this case, s corresponds to a distance vector between a and b, expressed in terms of the basis used for SB paths starting in phase q. Because of how a is set, it is clear that the SB path for (q, a, b) must traverse (i, t). In addition, because s qe−q = s e , the SB path will traverse edge e instead of another edge during the same phase.
For a given q, there are n h possible values for s, because all but one of its h + 1 elements can be set to any value in [n]. There are (h + 1) possible values for q, giving a total of # SB = (h + 1)n h To find # missing , we compare the distance vectors of (q, a, b) triples that have SB paths which traverse e with those of (q, a, b) triples that have valid HE paths. Each vector found in the overlap between these two sets corresponds to one (q, a, b) triple that contributes to # missing . To reason about the former set of vectors, we return to the construction of s used to find # SB . For a given starting phase q, each s such that s qe−q = s e represents a distance vector that can traverse e, expressed in terms of the basis used for SB paths starting in phase q. We can construct this basis as Y = (v(q), v(q + 1), ..., v(q + h). For each s, d = Y s is the same distance vector expressed using the elementary basis. The range of possible distance vectors d reachable while traversing e forms D e , an h-dimensional affine subspace of F h+1 n that is parallel to W e , the linear subspace spanned by the set Y \ {v(q e )}.
Next, we consider which triples have valid HE paths. For a given starting phase q, there are Q phases which are considered for forming HE paths. Let I be a set of h phase numbers chosen from these Q phases, and let V (I) be the linear subspace spanned by the vectors corresponding to the phase numbers in I. There are Q h ways of choosing such a set I. For each possible choice, V (I) forms an h-dimensional linear subspace in F h+1 n , corresponding to the distance vectors reachable via HE paths using the chosen phases. (Note that V (I) must be h-dimensional because every h distinct Vandermonde vectors are linearly independent.) Because V (I) and W e are spanned by distinct sets of h Vandermonde vectors, these linear subspaces are not equivalent, implying that V (I) and D e are not parallel. Thus, V (I) ∩ D e is an affine subspace with dimension h − 1 and contains n h−1 distance vectors.
Some distance vectors lie in more than one such intersection. In order to avoid overcounting # missing , we must remove at least this many vectors from our count. Given two sets of h chosen phase numbers I and J, V (I) and V (J) form two different linear subspaces of F h+1 n . As linear subspaces, both I and J contain the zero vector, as does the (h − 1)-dimensional I ∩ J. D e does not contain the zero vector, so D e ∩ I ∩ J can only be (h − 2)-dimensional, containing n h−2 distance vectors. There are fewer than Q h 2 ways of choosing two distinct sets I and J.
Thus, for a given starting q, there are fewer than Q h n h−1 − Q h 2 n h−2 distance vectors in the overlap between D e and the union of all possible V (I). Because there are h + 1 possibilities for the starting q, this gives the following lower bound for # missing : To find # HE , note that a given (q, a, b) can only traverse edge e if q e − h − Q ≤ q < q e − h, since q e must be in the set of Q phases considered for HE paths for (q, a, b). For a given q, we can construct an HE path by selecting h − 1 additional phases from the Q − 1 remaining phases, and then selecting one of the n − 1 edges within that phase to traverse. Some of these paths may lead to the same destination, causing an overcount, but it is fine to overcount # HE slightly.
Now that we have found # SB , # missing , and # HE , we can finally bound F (f (R, D), e): h . This gives: Note that because of how we set ε and restrict δ, ε ≤ 1 2 δ − (h + 1)δ 2 (1 + 1 2h ) 2 . Because the amount of flow traversing any physical edge e is less than 1, the flow f (R, D) is feasible.

Tightness of Upper Bound
Theorem 3. For all r ∈ (0, 1/2], there is a VBS design or an EBS design which guarantees throughput r and uses maximum latency L max ≤ O(L * (r, N )). (3) Proof. The VBS design of order h with parameter δ gives maximum latency L ≤ (h + 1)(n − 1) + Q(n − 1) for h = 1 2r , Q h ≥ δn, as long as δ ≤ . We upper bound the max latency of VBS in the following way.
≤ 2(h + 1)n + 2h 2 n + hn(4εn) 1/h 2h + 1 2 For sufficiently large N (determined by ε and h, both functions of r), the second term will dominate. Thus, for large N: By Lemma 4, VBS only gives a tight latency bound when 4ε = δ ≤ 1 4(h+1)(1+ 1 2h ) 2 . When ε is greater than this value, we use EBS instead. By Lemma 3, EBS gives a factor C tight bound when ε > 2 2h π 2e C h . We check to make sure that there exists a constant C which works for all Since there exists such a factor C, the following holds for EBS in the regions of interest.

Showing the Upper Bound for d > 1
Recall from Section 2.1 that an upper bound for 1-regular designs will only imply a similar upper bound for d-regular designs if we can ensure that the routing scheme does not route flow paths on multiple edges in the same "unrolled" segment of the 1-degree virtual topology. EBS and VBS always route flow on paths which use at most 1 edge from each phase, where a phase constitutes (n − 1) timeslots. Trivially, if d divides (n − 1), then these constructions already have the property we need. However, even if d does not divide (n − 1), as long as d < n − 1, we can modify EBS and VBS as follows.
We change the connection schedule to iterate through each phase twice before moving on to the next. So for VBS, π (n−1)p+s−1 (i) = i + sv( p/2 ). We also change the definition of single-basis and hop-efficient paths to use exclusively even-numbered phases or exclusively odd-numbered phases, depending on whether the next phase starts after the request originates. With this modification, single-basis and hop-efficient paths always use physical edges that occur at least (n − 1) timeslots apart from each other. Therefore, in the "rolled up" virtual topology, our flow paths will always use at most one physical edge per timeslot. This at most doubles the maximum latency, and does not affect throughput.

Conclusion and Open Questions
In this paper we introduced a mathematical model of oblivious reconfigurable network design and investigated the optimal latency attainable for designs satisfying any given throughput guarantee, r. We proved that the best maximum latency achievable is Ω(L * (r, N )), for L * (r, N ) = h N 1/(h+1) + (εN ) 1/h . We also present two ORN designs, EBS and VBS. For every constant r, we show there exist infinitely many N for which either EBS or VBS achieves a maximum latency of O(L * (r, N )).
Our investigation of the throughput-latency tradeoff for ORN designs affords numerous opportunities for follow-up work. In this section we sketch some of the most appealing future directions.

Universal connection schedules
EBS and VBS both use connection schedules tuned to the specific throughput rate, r, that they aim to guarantee. Is there a single connection schedule that permits achieving the Pareto-optimal latency for a large range of of r, or perhaps even for every value of r, merely by varying the routing scheme?
We conjecture that the following connection schedule, inspired by [TBKJ19], supports ORN designs that are Pareto-optimal with respect to the tradeoff between worst-case throughput and average latency, for every value of r, when N is a prime power. Let F denote the finite field with N elements, and let x denote a primitive root in F. Define the sequence of permutations π 0 , π 1 , . . . by specifying that π k (i) = i + x k for all i ∈ F, k ∈ N. We have experimented with this family of connection schedules when F is a prime field and 2 is a primitive root, for values of N ranging from 11 up to around 300. We numerically verified that in all cases we tested, for each value of r ranging from 1 2 down to roughly 1 log n , there is an oblivious routing scheme guaranteeing throughput r, whose average latency is within a constant factor of matching our lower bound. In fact, the average latency in most cases that we tested was moderately less than EBS's. However, thus far we have not succeeded in proving that this pattern persists for infinitely many N .

Bridging the gap between theory and practice
Our model of ORNs incorporates idealized assumptions that gloss over important details that affect the performance of ORNs in practice. A more realistic model would not equate expected congestion with actual congestion. This would necessitate grappling with the issues of queueing and congestion control. It also opens the Pandora's box of non-oblivious routing, since a frame that was intended to be transmitted on link (u, v) but finds that link blocked due to congestion must either be transmitted in a different timeslot, or on a different link in the same timeslot, and in either case the frame's path in the virtual topology differs from the intended one. An appealing middle ground between fully centralized control (as in classical models of circuit-switched networks) and a fully oblivious model (as in our paper) could be a network design with a fully oblivious connection schedule coupled with a partially-adaptive routing scheme based on local information such as queue lengths at the transmitting and receiving nodes.
Our model also fails to account for (possibly heterogeneous) propagation delays, due to our assumption that each link of the virtual topology corresponds to exactly one timeslot regardless of where its endpoints are situated. The model could be enhanced to take propagation delay into account by adjusting the virtual topology. Rather than connecting physical edges from (i, s) to (j, s + 1), they could instead connect to (j, s + d ij ), where d ij is a whole number representing the propagation delay from i to j in units of timeslots. As in our basic model, nodes of the virtual topology in this enhanced model would be constrained to belong to at most one incoming and at most one outgoing physical edge, though if d ij varies with i and j then the set of physical edges would no longer be described by a sequence of permutations.

Supporting multiple traffic classes
In this paper we sought to optimize the worst-case latency guarantee for network designs that guarantee a specified rate of throughput. In practice, flows co-existing on a network can differ markedly in their latency sensitivity. Can EBS, VBS, or other ORN designs be adapted to offer users a menu of options targeting different points on the latency-throughput tradeoff curve? What guarantees can such network designs simultaneously provide to the different classes of traffic they serve?

A A general upper bound on achievable throughput in ORNs
The use of Valiant load balancing inflates path lengths by a factor of 2, which reduces throughput by a factor of 2. It turns out that this factor-2 loss is unavoidable for ORN designs. It is instructive to present a proof that no ORN design can sustain throughput greater than 1 2 +o(1), even if latency is allowed to be unbounded.
Consider the following: let σ denote a random permutation of the nodes, and consider a workload D in which every node a sends flow to destination σ(a) at rate r. We will say a "direct link" is one whose endpoints are a and σ(a) for some node a, and a "spraying link" is any other physical link. Define the inflated cost of a link to be 2 if it is a direct link and 1 if it is a spraying link.
This ensures that the inflated cost of every routing path from a to σ(a) is at least 2, regardless of whether it is a direct or indirect path. Therefore, when an ORN design is used to route workload D over a span of T timeslots, the total inflated cost of the links used, weighted by their flow rates, is at least 2rN T . (In each of T timeslots, each of N nodes sends flow at rate r on a routing path of inflated cost at least 2.) On the other hand, the expected total inflated cost of all physical edges in the virtual topology is 1 + 1 N −1 N T . This is because the virtual topology contains N T physical edges, and the expected inflated cost of each e is 1 + 1 N −1 , accounting for the 1 N −1 probability that the random permutation σ leads us to label e as a direct link and inflate its cost from 1 to 2.
If an ORN design sustains throughput r, then the flow rate on any physical edge in the virtual topology when routing workload D is at most 1, and consequently the total inflated cost of all the physical edges used, weighted by their flow rates, is bounded above by the combined inflated cost of all the physical edges in the virtual topology. Hence 2rN T ≤ 1 + 1 N −1 N T and r ≤ 1 2 + 1 2(N −1) . This upper bound on throughput converges to 1/2 as N → ∞.

B Demand function inflation
Suppose we have a periodic demand function D such that for all t ∈ Z, D(t) has row and column sums bounded above by r. Here, we present a greedy algorithm for inflating D to produce D , a demand function such that for all t ∈ Z, D (t) has row and column sums exactly equal to r, and D (t) bounds D(t) above: For all t ∈ Z, because cells in D (t) are only ever increased, it should be clear that D (t) bounds D(t) above.
To show that the row and column sums of D (t) all exactly equal r, first note that no cell has its value increased in a way that would cause a row or column sum to exceed r. Next, note that if the algorithm terminates successfully, all row sums of D (t) are equal to r. This implies that the sum of all cells in D (t) is N r. Assume there exists a column sum less than r. Even if all column sums equal r, this leads to a contradiction, as the total sum of all cells must be less than N r. Therefore, all column sums must equal r as well.
The only step in the algorithm that does not trivially succeed is finding the lowest column y whose column sum is less than r. We show that this step must succeed through contradiction: Assume that this step fails because there is no column sum less than r. Because no column sum is increased to be greater than r, it follows that all column sums must equal r. Due to a similar argument as the previous paragraph, all row sums must equal r. However, if all row sums equal r, the algorithm should have already moved on to the next t, which is a contradiction. Therefore, the algorithm terminates successfully.