Lucy McManamon

I arrived at Rutgers, attended orientation and two seminars. On Thursday I met with Dr. Yu and we discussed the sharp transition between 2 and 3-regular graphs. At k = 2 makespan is either infinity or O(n). However, at k = 3 the graph is with high probability k-connected, an expander, and has O(log n) diameter. The current goal is to utilize these and other properties of random 3-regular graphs to create a plan proving O(log n) makespan for MAPF. We are also interested in analyzing what lies between the transition from k=2 to k=3, and in classifying special cases of graphs like the Petersen graph, grid on a torus graph, etc.

Additionally, I visited NYC with Sofia T :)

I gave a short presentation on my project and continued to work on an algorithm to prove O(log n) makespan on 3-regular graphs. I started by reviewing primitive rotation sequences that are used to prove makespan on different types of graphs: cactus, 2-connected, and grids [1]. The problem with extending these approaches is they are hard to cleanly parallelize on random 3-regular graphs, which are locally tree like expanders with overlapping cycles. There are not enough disjoint "modules" to perform many swap primitives in parallel to acheive O(log n) makespan. On the other hand, grids contain many small, local, orderly cycles which allow for swap operations to be parallelized quite nicely.

An interesting property I have discovered is that random 3-regular graphs are with high probability 3-edge-colorable and have no bridges. I believe the 1 and 2 factors of the graphs could be an useful routing tool, or at least some sort of structure I can use in my algorithm. Dr. Yu also suggested a divide and conquer approach, but we are not sure if it is possible for these graphs to retain their properties if they are cut. I will be looking into this approach more next week.

I was also able to attend a few talks for computational geometry week.

I spent this week researching 2 approaches to the problem, which both fail for similar reasons.

The divide and conquer approach is frequently used in grid instances of Multi-Robot Path Planning, but does not scale to random cubic graphs. Cutting the graph can destroy cycles, which are essential for movement when we have m = n robots. Because G is an expander, a balanced cut requires O(n) edges. Depending on which edges are cut, at any iteration we may be left with deadlocked degree 0 or 1 vertices. This approach may be more successful on planar 3-regular graphs, which are not good expanders.

I also looked into an interesting result in theorem 7 of [2]. The authors show O(log² n) makespan for routing permutations on d-regular graphs with good expansion. However, their routing mechanism is different: it relies on selecting a disjoint set of edges and interchanging the pebbles at their endpoints. On fully occupied graphs, a θ-structure is needed to swap 2 adjacent agents. Thus, to acheive the same makespan we would need to execute many disjoint swaps in parallel, when the probability of having constant sized θ-structures on our graphs is near 0. They are much more likely to be logarithmic in size.

I am now exploring the possibility of acheiving polylogarithmic makespan by executing swaps through disjoint O(log n) sized θ-subgraphs. As a first step, I have been focused on proving how many are expected to exist. I also intend to research this problem with m=n/2 agents occupying the graph to see if it is more fruitful.

I spent this week looking into multi-agent path finding on random 3-regular graphs with half-density (m = n/2) agents. I first tried a divide and conquer approach using O(n) disjoint trees spanning cut edges. The trees would allow agents on each side to swap and would need to be carefully formed so each individual instance would be feasible. I soon realized that as the graph is decomposed, O(n) cut edges are no longer guaranteed. In addition, it would be quite dfficult to partition the trees evenly and maintain feasibility.

I shifted my focus and carefully studied the proof of theorem 7 in [2]. Though our problem differs mechanically, we believe that it is possible to acheive polylogarithmic makespan using similar methods. However, it is essential to ensure an even distribution of the n/2 agents and holes in the graph. I proved that with high probability two adjacent agents can be swapped using a constant number of vertices in a constant number of steps. Theoretically this would allow multiple agents to be routed to their destinations in parallel.

An interesting development is that Esmé and Sofia A and I are book clubbing War and Peace.

This week I expanded on my proof from last week, and found a significant oversight.

The proof relies on incrementally "adding" levels of vertices from the graph G=(V,E) to an edge (u,v), forming full binary trees rooted at u and v and stopping at round R when a swap is feasible. I proved that R is constant with high probability (follows Pascal distribution) and thus the number of vertices needed for a swap is constant, however this approach will not work if the subgraph contains any cycle at round R. Random 3-regular graphs are locally tree like so small cycles are not common, but we cannot disregard them. Ultimately they have Poisson behavior as n->infinity and the total number is at most log n. My approach will work for "R-good" edges of G, edges for which the vertices at a distance R from (u,v) form a tree. Swaps on the other "R-bad" edges will need to be completed separately.

I realized that routing is greatly simplified by treating the Alon, Chung, Graham routing algorithm [2] as a black box. Their algorithm routes any permutation in O(log² n) rounds. During each round a matching of disjoint edges simultaneously have their endpoints swapped. We focus on swapping any matching in O(log n) steps, giving O(log³ n) makespan. This is much cleaner than trying to modify [2]'s random walk decomposition framework and handle multiple swaps tangled together. The construction requires G to be 3-vertex-connected, have O(logn) constant sized cycles, and to have vertex expansion bounded below by a constant. Random cubic graphs satisfy all of these with high probability.

In order to simulate a full permutation of the vertices of G, we assign dummy labels to the holes. A matching M of [2] can contain three kinds of edges: robot-robot, robot-hole, and hole-hole. The hole-hole edges can be ignored, their dummy labels are swapped. The robot-hole edges can be completed simultaneously in 1 legal step.

The real work lies in the robot-robot edges. We are able to swap them using a T shape, but this T must contain 2 holes to be able to "park" the robots. The difficulty lies in routing holes to each T. We create a vertex-colored conflict graph to route the R-good edges of G, and proved that in O(log n) steps, all swaps on R-good edges for a matching in [2] can be completed. R-bad edges are handled sequentially, each taking a constant number of steps. Because a random cubic graph has O(log n) R-bad edges with high probability, this adds another O(log n) steps total.

Additionally I gave a short presentation on my project during the NYC Math REU visit.

This week I extended our result on cubic graphs to random d-regular graphs with constant d>2. The result is O(log_d³ n) makespan - the only change is that the log base now depends on d. The only difference in the proof lies in the R-good-edge routing: there are (d-1)m ports instead of 2m, but we still only need 2 holes in a set of ports to be able to swap on an edge. I also worked on extending to robot density between 0 and 1 for cubic graphs. Above 1/2 density a key inequality in the proof breaks because we cannot guarantee that the set of occupied ports in a matching on the conflict graph is ≤ n/2 in size. Thus vertex expansion cannot be applied to the set. Trying to find a different way to go about this.

We were able to visit Nokia Bell Labs this week and experienced their anechoic chamber.