Algebraic Structures and Algorithms for Matching and Matroid Problems Nick Harvey

Perfect Matching Given graph G=(V,E) Perfect matching is M ⊆ E such that each vertex incident with exactly one edge in M

Edmonds ’65 Blossom Alg. O(n 2 m) Micali-Vazirani ’80-’90 Blossoms + “Blocking Flow” O( √ n m) Mucha-Sankowski ’04 Fast Matrix Multiplication O(n  ) Matching History All are non-trivial Mucha-Sankowski uses sophisticated dynamic connectivity data structures (Holm et al. ’01) to maintain “canonical partition” (Cheriyan ’97) O(n 4 ) O(n 2.5 ) (n = # vertices, m = # edges) All are non-trivial! Mucha ’05: “[Our] algorithm is quite complicated and heavily relies on graph theoretic results and techniques. It would be nice to have a strictly algebraic, and possibly simpler, matching algorithm”. O(n 2.38 ) (  <2.38 is exponent for matrix multiplication) Dense Graphs m=n 2

Edmonds ’65 Blossom Alg. O(n 4 ) Micali-Vazirani ’80-’90 Blossoms + “Blocking Flow” O(n 2.5 ) Mucha-Sankowski ’04 Fast Matrix Multiplication O(n 2.38 ) This Work Purely Algebraic, Clean Divide-and-Conquer, Fast Matrix Multiplication O(n 2.38 ) Matching Algorithms Conceptually simple Implemented in ~200 lines of MATLAB * * Randomized, but Las Vegas via [Cheriyan ’97] * Dense Graphs m=n 2

(Linear) Matroid Intersection Find largest set of columns S such that A S and B S are both linearly independent A = B = ASAS BSBS

Matroid Intersection Find largest set of columns S such that A S and B S are both linearly independent Why? Many problems are a special case: –Bipartite matching –Arboresence (directed spanning tree), … Powerful tool: –Bounded-Degree Sp. Tree [Goemans ’06]

Edmonds ’65-’70, Lawler ’75 Augmenting Paths O(mn 2 ) oracle Cunningham ’86 “Blocking Flows” O(mn 2 log n) Gabow-Xu ’89-’96 “Blocking Flows” & Fast Matrix Mult. O(mn 1.62 ) Matroid Intersection History (for matrices of size n x m)

Essentially optimal: –Best known alg to compute rank takes O(mn  -1 ) –Computing rank reduces to matroid intersection Edmonds ’65-’70, Lawler ’75 Augmenting Paths O(mn 2 ) oracle Cunningham ’86 “Blocking Flows” O(mn 2 log n) Gabow-Xu ’89-’96 “Blocking Flows” & Fast Matrix Mult. O(mn 1.62 ) This paper Purely Algebraic, Fast Matrix Mult. O(mn  -1 ) Matroid Intersection History * * * * Assumes matroids are linear † † Randomized, and assumes matroids can be represented over same field O(mn 1.38 )

Generic Matching Algorithm For each e  E If e is contained in a perfect matching Add e to solution Delete endpoints of e Else Delete edge e

Generic Matching Algorithm How can we test this? Randomization and linear algebra play key role For each e  E If e is contained in a perfect matching Add e to solution Delete endpoints of e Else Delete edge e

Matching Outline Implementing Generic Algorithm –Tutte Matrix & Properties –Rabin-Vazirani Algorithm –Rank-1 Updates –Rabin-Vazirani with Rank-1 Updates –Our Recursive Algorithm (overview) –Our Recursive Algorithm (fast updates)

Matching & Tutte Matrix Let G=(V,E) be a graph Define variable x {u,v}  {u,v} ∈ E Define a skew-symmetric matrix T s.t. T u,v = ± x {u,v} 0 cb a 0-x {a,b} -x {a,c} x {a,b} 0-x {b,c} x {a,c} x {b,c} 0 if {u,v} ∈ E otherwise

Properties of Tutte Matrix Lemma [Tutte’47]: G has a perfect matching iff T is non-singular. Lemma [RV’89]: G[ V\{u,v} ] has a perfect matching iff (T -1 ) u,v  0.

Properties of Tutte Matrix Lemma [Tutte’47]: G has a perfect matching iff T is non-singular. Lemma [RV’89]: G[ V\{u,v} ] has a perfect matching iff (T -1 ) u,v  0. v u (T -1 ) u,v  0

Properties of Tutte Matrix Lemma [Tutte’47]: G has a perfect matching iff T is non-singular. Lemma [RV’89]: G[ V\{u,v} ] has a perfect matching iff (T -1 ) u,v  0. (T -1 ) u,v  0 G[ V\{u,v} ] has perfect matching

Properties of Tutte Matrix Lemma [Tutte’47]: G has a perfect matching iff T is non-singular. Lemma [RV’89]: G[ V\{u,v} ] has a perfect matching iff (T -1 ) u,v  0. (T -1 ) u,v  0 G[ V\{u,v} ] has perfect matching

Properties of Tutte Matrix Lemma [Tutte’47]: G has a perfect matching iff T is non-singular. Lemma [RV’89]: G[ V\{u,v} ] has a perfect matching iff (T -1 ) u,v  0. (T -1 ) u,v  0 G[ V\{u,v} ] has perfect matching v u

Properties of Tutte Matrix Lemma [Tutte’47]: G has a perfect matching iff T is non-singular. Lemma [RV’89]: G[ V\{u,v} ] has a perfect matching iff (T -1 ) u,v  0. Computing T -1 very slow: Contains variables! Lemma [Lovász’79]: These results hold w.h.p. if we randomly choose values for x {u,v} ’s.

Matching Algorithm Compute T -1 For each {u,v}  E If T -1 u,v  0 Add {u,v} to matching Recurse on G[ V\{u,v} ] (Takes O(n  ) time) Total time: O(n  +1 ) time Natural question: Can we recompute T -1 quickly in each iteration? Rabin-Vazirani ’89

Matching Outline –Tutte Matrix & Properties –Rabin-Vazirani Algorithm –Rank-1 Updates –Rabin-Vazirani with Rank-1 Updates –Our Recursive Algorithm (overview) –Our Recursive Algorithm (fast updates)

Rank-1 Updates Let T be a n x n matrix T + uv T is called a rank-1 update of T n n ∙ + TuvTvT

123n 2462n 3693n n2n3nn2n2 Let T be a n x n matrix T + uv T is called a rank-1 update of T Computing rank-1 update takes O(n 2 ) time Rank-1 Updates Tuv T

Rank-1 Updates Let T be a n x n matrix T + uv T is called a rank-1 update of T Claim: If you modify one entry of T, then T -1 is modified by a rank-1 update. T =T -1 =

Rank-1 Updates Let T be a n x n matrix T + uv T is called a rank-1 update of T Claim: If you modify one entry of T, then T -1 is modified by a rank-1 update. Claim: If you delete O(1) rows and columns of T then T -1 is affected by O(1) rank-1 updates.  T -1 can be updated in O(n 2 ) time

Matching Outline –Tutte Matrix & Properties –Rabin-Vazirani Algorithm –Rank-1 Updates –Rabin-Vazirani with Rank-1 Updates –Our Recursive Algorithm (overview) –Our Recursive Algorithm (fast updates)

RV Algorithm + Rank-1 Updates Compute T -1 For each {u,v}  E If T -1 u,v  0 Add {u,v} to matching Update T -1 (via rank-1 updates) Recurse on G[ V\{u,v} ] Total runtime: O(n 3 ) time Can updates use Fast Matrix Multiplication? –Bipartite graphs: Yes –Non-bip. graphs: Yes, but non-trivial Mucha-Sankowski ’04 [MS’04]

RV Algorithm + Rank-1 Updates Compute T -1 For each {u,v}  E If T -1 u,v  0 Add {u,v} to matching Update T -1 (via rank-1 updates) Recurse on G[ V\{u,v} ] Total runtime: O(n 3 ) time Can updates use Fast Matrix Multiplication? Mucha-Sankowski ’04 New approach: An unusual recursion!

Matching Outline –Tutte Matrix & Properties –Rabin-Vazirani Algorithm –Rank-1 Updates –Rabin-Vazirani with Rank-1 Updates –Our Recursive Algorithm (overview) –Our Recursive Algorithm (fast updates)

New Recursive Approach (Here c=4 parts) Partition into c parts {V 1,…,V c } (arbitrarily) For each pair of parts {V a,V b } (arbitrary order) –Recurse on G[V a ⋃ V b ]

New Recursive Approach Partition into c parts {V 1,…,V c } (arbitrarily) For each pair of parts {V a,V b } (arbitrary order) –Recurse on G[V a ⋃ V b ]

New Recursive Approach Partition into c parts {V 1,…,V c } (arbitrarily) For each pair of parts {V a,V b } (arbitrary order) –Recurse on G[V a ⋃ V b ]

New Recursive Approach Partition into c parts {V 1,…,V c } (arbitrarily) For each pair of parts {V a,V b } (arbitrary order) –Recurse on G[V a ⋃ V b ] Base case: 2 vertices

New Recursive Approach Partition into c parts {V 1,…,V c } (arbitrarily) For each pair of parts {V a,V b } (arbitrary order) –Recurse on G[V a ⋃ V b ] Base case: 2 vertices {u,v} –If T -1 u,v  0, add {u,v} to matching, update T -1

Recursion F.A.Q. Why not just recurse on G[ V a ]? –Edges between parts would be missed –Claim: Our recursion examines every pair of vertices  examines every edge Why does algorithm work? –It implements Rabin-Vazirani Algorithm! Isn’t this horribly slow? –No: we’ll see recurrence next Partition into c parts {V 1,…,V c } (arbitrarily) For each pair of parts {V a,V b } (arbitrary order) –Recurse on G[V a ⋃ V b ] Base case: 2 vertices {u,v} –If T -1 u,v  0, add {u,v} to matching, update T -1

Final Matching Algorithm If base case with 2 vertices {u,v} If T -1 u,v  0, add {u,v} to matching Else Partition into c parts {V 1,…,V c } For each pair {V a,V b } Recurse on G[V a ⋃ V b ] Apply updates to current subproblem s = size of subproblem

Final Matching Algorithm If base case with 2 vertices {u,v} If T -1 u,v  0, add {u,v} to matching Else Partition into c parts {V 1,…,V c } For each pair {V a,V b } Recurse on G[V a ⋃ V b ] Apply updates to current subproblem s = size of subproblem

Final Matching Algorithm If base case with 2 vertices {u,v} If T -1 u,v  0, add {u,v} to matching Else Partition into c parts {V 1,…,V c } For each pair {V a,V b } Recurse on G[V a ⋃ V b ] Apply updates to current subproblem Assume: O(s  ) time s = size of subproblem

Basic Divide-and-Conquer –If then Since, just choose c large enough! Time Analysis c = 13 is large enough if  = 2.38

Handling Updates T =

Handling Updates T =T -1 = Delete vertices u and v u v u v u v u v

Handling Updates (Naively) T =T -1 = Delete vertices u and v  clear rows / columns Causes rank-1 updates to T -1 Algorithm still takes  (n 3 ) time u v u v u v u v

Matching Outline –Tutte Matrix & Properties –Rabin-Vazirani Algorithm –Rank-1 Updates –Rabin-Vazirani with Rank-1 Updates –Our Recursive Algorithm (overview) –Our Recursive Algorithm (fast updates)

Just-in-time Updates T -1 = Don’t update entire matrix! Just update parent in recursion tree Updates outside of parent are postponed u v u v

Postponed Updates T -1 = Accumulate batches of updates Claim: New updates can be applied with matrix multiplication and inversion u v u v

Final Matching Algorithm If base case with 2 vertices {u,v} If T -1 u,v  0, add {u,v} to matching Else Partition into c parts {V 1,…,V c } For each pair {V a,V b } Recurse on G[V a ⋃ V b ] Apply updates to current subproblem Invariant: Before / after child subproblem, parent’s submatrix is completely updated  in every base case, T -1 u,v is up-to-date!

Graph G children All edges chosen in base cases Only take edges that can be extended to a perfect matching in the whole graph. This decision is possible because invariant ensures that T -1 u,v is up-to-date. Just apply postponed updates

Matching Summary Can compute a perfect matching in O(n  ) = O(n 2.38 ) time Algorithm uses only simple randomization, linear algebra and divide-and-conquer Easy to implement Extensions for: (by existing techniques) –maximum matchings –Las Vegas

More Extensions Same philosophy applies to many matching-like problems –Design matrix capturing problem –Design algorithm to test if element in OPT –Design method to efficiently do updates x3x3 x4x4 x5x5 x6x6 x7x7 x8x8 A BTBT J J Matroid Intersection O(mn  -1 ) algorithm – Design “algebraic structure” capturing problem

More Extensions Same philosophy applies to many matching-like problems –Design matrix capturing problem Bipartite Matroid Matching & Basic Path-Matching O(n  ) algorithm – Design “algebraic structure” capturing problem

Open Problems Fast, deterministic methods to choose values for indeterminates? –Implications for Matching in NC Scaling algorithms for weighted problems? O(n 2 ) algorithms for matching by completely different techniques? –e.g., via Karger-Levine randomized max flow