SlideShare a Scribd company logo

Solving connectivity problems via basic Linear Algebra

C
cseiitgn

The document discusses various problems related to connectivity in directed and undirected graphs, focusing on pathfinding and reachability. It highlights the definitions, complexities, and computational challenges of problems such as disjoint paths and the min-sum disjoint path problem, as well as specific algorithmic approaches and their relevance. Additionally, the document explores solutions involving linear algebra and determinants to address these connectivity issues.

Education
1 of 147
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
Solving connectivity problems via basic Linear Algebra Samir Datta Chennai Mathematical Institute Includes joint work with Raghav Kulkarni Anish Mukherjee Thomas Schwentick Thomas Zeume NMI Workshop on Complexity IIT Gandhinagar November 6, 2016
Outline 1 Part I: Disjoint Paths 2 Part II: Dynamic Reachability 3 Conclusion
Two fundamental problems
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t?
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t?
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL • (Reingold) SL = L
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL • (Reingold) SL = L • Optimization version: shortest path in NL
Disjoint Path Problem
Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths?
Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability)
Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2
Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2 • NP-complete for undirected graphs when k part of input.
Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2 • NP-complete for undirected graphs when k part of input. • (Robertson-Seymour) Cubic time (fixed k) in undirected graphs.
Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2 • NP-complete for undirected graphs when k part of input. • (Robertson-Seymour) Cubic time (fixed k) in undirected graphs. • Special cases: Planar graphs/DAGs well studied.
One-face Min-sum Disjoint Path Problem • A very special case: 1 2 4 2k 2k − 1 3
One-face Min-sum Disjoint Path Problem • A very special case: • k-DPP instance with undirected planar graph, and 1 2 4 2k 2k − 1 3
One-face Min-sum Disjoint Path Problem • A very special case: • k-DPP instance with undirected planar graph, and • All terminals on single face, and 1 2 4 2k 2k − 1 3
One-face Min-sum Disjoint Path Problem • A very special case: • k-DPP instance with undirected planar graph, and • All terminals on single face, and • Want solution with minimum total length of paths. 1 2 4 2k 2k − 1 3
One-face Min-sum Disjoint Path Problem: Motivation • Directed general case remains NP-hard in the plane though fixed parameter tractable in k.
One-face Min-sum Disjoint Path Problem: Motivation • Directed general case remains NP-hard in the plane though fixed parameter tractable in k. • NP-hardness in undirected case: open for k > 2.
One-face Min-sum Disjoint Path Problem: Motivation • Directed general case remains NP-hard in the plane though fixed parameter tractable in k. • NP-hardness in undirected case: open for k > 2. • (Bj¨orklund-Husfeldt’14) Randomized polynomial time algorithm in undirected case for 2-DPP.
One-face Min-sum Disjoint Path Problem: Motivation • (de Verdi`ere-Schrijver’08) Two-face case with sources and sinks on two different faces in time O(kn log n).
One-face Min-sum Disjoint Path Problem: Motivation • (de Verdi`ere-Schrijver’08) Two-face case with sources and sinks on two different faces in time O(kn log n). • (Kobayashi-Sommer’10) One-face min-sum 3-DPP in polynomial time
One-face Min-sum Disjoint Path Problem: Motivation • (de Verdi`ere-Schrijver’08) Two-face case with sources and sinks on two different faces in time O(kn log n). • (Kobayashi-Sommer’10) One-face min-sum 3-DPP in polynomial time • (Borradaile-Nayyeri-Zafarani’15) One-face min-sum k-DPP in “serial” configuration in polynomial time (in n as well as k).
One-face min-sum Disjoint Path Problem: Our Results Theorem • The count of One-face min-sum k-DPP solutions can be reduced to O(4k) determinant computations.
One-face min-sum Disjoint Path Problem: Our Results Theorem • The count of One-face min-sum k-DPP solutions can be reduced to O(4k) determinant computations. • Finding a witness to the problem can be randomly reduced to O(4k) determinant computations.
One-face min-sum Disjoint Path Problem: Our Results Theorem • The count of One-face min-sum k-DPP solutions can be reduced to O(4k) determinant computations. • Finding a witness to the problem can be randomly reduced to O(4k) determinant computations. • Can also do the above sequentially in deterministic O(4knω) time (ω matrix multiplication constant).
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n}
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π)
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i).
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π)
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π) • = signed sum of weights of cycle covers in G
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π) • = signed sum of weights of cycle covers in G • cycle cover is a covering of vertices of G by disjoint cycles
Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π) • = signed sum of weights of cycle covers in G • cycle cover is a covering of vertices of G by disjoint cycles • (cycles include self loops)
Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face
Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face • Subdivide edge at ri
Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face • Subdivide edge at ri • Put self loops on all vertices in graph except ri ’s
Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face • Subdivide edge at ri • Put self loops on all vertices in graph except ri ’s • Put weight x on each original edge and 1 on self-loops
Solving a special case • Bijection between k-DPP’s and cycle covers
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP)
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are:
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP)
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k • Lighter than any other cycle cover
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k • Lighter than any other cycle cover • coefficient of smallest degree term counts #-min-sum k-DPPs
Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k • Lighter than any other cycle cover • coefficient of smallest degree term counts #-min-sum k-DPPs • As easy as determinant
Solving a special case • Search reduces to counting in polynomial time
Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges
Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0
Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC
Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC • Use Isolation Lemma [MVV] to isolate a min-sum k-DPP
Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC • Use Isolation Lemma [MVV] to isolate a min-sum k-DPP • Use isolating weights w(e) as exponent of x on e
Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC • Use Isolation Lemma [MVV] to isolate a min-sum k-DPP • Use isolating weights w(e) as exponent of x on e • Discard any edge removing which doesn’t affect min weight exponent
Issues with general case 1 2 3 4 5 67 8 • Spurious cycle covers in addition to good ones
Issues with general case 1 2 3 4 5 67 8 • Spurious cycle covers in addition to good ones • No bijection between required k-DPP paths and cycle covers
Issues with general case 1 2 3 4 5 67 8 • Spurious cycle covers in addition to good ones • No bijection between required k-DPP paths and cycle covers • Spurious cycle covers for different terminal pairing/demands
Fixing issues with general case 1 2 3 4 5 67 8 1 2 3 4 5 67 8 1 2 3 4 5 67 8 • Spurious cycle covers canceled by cycle covers with new demands
Fixing issues with general case 1 2 3 4 5 67 8 1 2 3 4 5 67 8 1 2 3 4 5 67 8 • Spurious cycle covers canceled by cycle covers with new demands • Further spurious cycles - canceled by another demand set - etc.
Fixing issues with general case 1 2 3 4 5 67 8 1 2 3 4 5 67 8 1 2 3 4 5 67 8 • Spurious cycle covers canceled by cycle covers with new demands • Further spurious cycles - canceled by another demand set - etc. • Need to prove that process converges
Fixing issues with general case • Define a function len mapping demands to N
Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater
Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater • Prove: len of parallel demands maximum
Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater • Prove: len of parallel demands maximum • Recursively express k-DPP for demand as
Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater • Prove: len of parallel demands maximum • Recursively express k-DPP for demand as • Sum of determinant and k-DPP for demands of greater len.
Outline 1 Part I: Disjoint Paths 2 Part II: Dynamic Reachability 3 Conclusion
Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL • (Reingold) SL = L • Optimization version: shortest path in NL
Dynamic Complexity • Static complexity:
Dynamic Complexity • Static complexity: • Input graph G presented in one shot
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property.
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity:
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph?
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query • Complexity: in terms of circuit or descriptive complexity
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query • Complexity: in terms of circuit or descriptive complexity • DynAC0 : update circuit is AC0
Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query • Complexity: in terms of circuit or descriptive complexity • DynAC0 : update circuit is AC0 • DynFO: updates are First Order computable
Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix?
Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix? • Step 1 Reduce Reach to Rank
Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix? • Step 1 Reduce Reach to Rank • Step 2 Rank ∈ uniform DynAC0
Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix? • Step 1 Reduce Reach to Rank • Step 2 Rank ∈ uniform DynAC0 • Step 3 DynFO ≈ uniform DynAC0
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B.
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0 • iff Bx = et has unique solution x with xs = 0
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0 • iff Bx = et has unique solution x with xs = 0 • This equation system can be phrased as rank-problem ...and one change in A leads to one change in B
Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0 • iff Bx = et has unique solution x with xs = 0 • This equation system can be phrased as rank-problem ...and one change in A leads to one change in B • Technical detail: Use B def = nI − A instead of B def = I − 1 n A
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A)
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒ • rkp(A) ≥ k
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒ • rkp(A) ≥ k • But, rkp(A) ≤ rk(A), since
Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒ • rkp(A) ≥ k • But, rkp(A) ≤ rk(A), since • Linear relation over integers =⇒ linear relation over Zp
Maintaining row-echelon form • Definition         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1,         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible • Maintain E in row echelon form         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible • Maintain E in row echelon form • such that E = BA         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible • Maintain E in row echelon form • such that E = BA • Rank(A) is #non-zero rows of E         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
Maintaining row-echelon form • Change A[i, j] to yield A .
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA :
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations:
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1,
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j ,
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations:
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1 • set all other entries of column to 0,
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1 • set all other entries of column to 0, • If needed:
Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1 • set all other entries of column to 0, • If needed: • move the (at most two) rows above with changed leading entries to correct positions
Outline 1 Part I: Disjoint Paths 2 Part II: Dynamic Reachability 3 Conclusion
Conclusion • Considered two connectivity problems:
Conclusion • Considered two connectivity problems: • One-face k-DPP
Conclusion • Considered two connectivity problems: • One-face k-DPP • Dynamic Reachability
Conclusion • Considered two connectivity problems: • One-face k-DPP • Dynamic Reachability • Writing and solving linear equations, key to solution
Conclusion • Considered two connectivity problems: • One-face k-DPP • Dynamic Reachability • Writing and solving linear equations, key to solution • Scratched the surface of Linear Algebra
Open Questions • Derandomize construction of One-face k-DPP solution?
Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above?
Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ?
Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ? • Serial/parallel cases can be deparameterized [Borradaile et al.]
Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ? • Serial/parallel cases can be deparameterized [Borradaile et al.] • Contrariwise, does there exist a crossover gadget?
Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ? • Serial/parallel cases can be deparameterized [Borradaile et al.] • Contrariwise, does there exist a crossover gadget? • Is directed distance in DynAC0? What about path construction?
Thanks!

More Related Content

PDF
Lossy Kernelization
msramanujan
 
PDF
Polylogarithmic approximation algorithm for weighted F-deletion problems
AkankshaAgrawal55
 
PDF
Biconnectivity
msramanujan
 
PDF
Fine Grained Complexity of Rainbow Coloring and its Variants
AkankshaAgrawal55
 
PDF
Kernel for Chordal Vertex Deletion
AkankshaAgrawal55
 
PDF
Split Contraction: The Untold Story
AkankshaAgrawal55
 
PDF
Polynomial Kernel for Interval Vertex Deletion
AkankshaAgrawal55
 
PDF
Guarding Terrains though the Lens of Parameterized Complexity
AkankshaAgrawal55
 
Lossy Kernelization
msramanujan
 
Polylogarithmic approximation algorithm for weighted F-deletion problems
AkankshaAgrawal55
 
Biconnectivity
msramanujan
 
Fine Grained Complexity of Rainbow Coloring and its Variants
AkankshaAgrawal55
 
Kernel for Chordal Vertex Deletion
AkankshaAgrawal55
 
Split Contraction: The Untold Story
AkankshaAgrawal55
 
Polynomial Kernel for Interval Vertex Deletion
AkankshaAgrawal55
 
Guarding Terrains though the Lens of Parameterized Complexity
AkankshaAgrawal55
 

What's hot (20)

PDF
Node Unique Label Cover
msramanujan
 
PDF
Graph Modification: Beyond the known Boundaries
AkankshaAgrawal55
 
PDF
Chapter06
Tianlu Wang
 
PDF
Chapter06
Tianlu Wang
 
PDF
Guarding Polygons via CSP
AkankshaAgrawal55
 
PDF
Chapter04
Tianlu Wang
 
PDF
Archipelagos
msramanujan
 
PDF
SPECTRAL SYNTHESIS PROBLEM FOR FOURIER ALGEBRAS
Kunda Chowdaiah
 
PDF
COnflict Free Feedback Vertex Set: A Parameterized Dichotomy
AkankshaAgrawal55
 
PDF
On Convolution of Graph Signals and Deep Learning on Graph Domains
Jean-Charles Vialatte
 
PDF
Ilya Shkredov – Subsets of Z/pZ with small Wiener norm and arithmetic progres...
Yandex
 
PDF
Chapter02b
Tianlu Wang
 
PDF
On the Parameterized Complexity of Simultaneous Deletion Problems
AkankshaAgrawal55
 
PDF
A multi-objective optimization framework for a second order traffic flow mode...
Guillaume Costeseque
 
PDF
Crystallographic groups
Mathieu Dutour Sikiric
 
PDF
qlp
Rei Mizuta
 
PDF
Parabolic Restricted Three Body Problem
Esther Barrabés Vera
 
PPT
Pushdown automata
eugenesri
 
PPT
Pushdown automata
parmeet834
 
PDF
Approximation Algorithms for the Directed k-Tour and k-Stroll Problems
Sunny Kr
 
Node Unique Label Cover
msramanujan
 
Graph Modification: Beyond the known Boundaries
AkankshaAgrawal55
 
Chapter06
Tianlu Wang
 
Chapter06
Tianlu Wang
 
Guarding Polygons via CSP
AkankshaAgrawal55
 
Chapter04
Tianlu Wang
 
Archipelagos
msramanujan
 
SPECTRAL SYNTHESIS PROBLEM FOR FOURIER ALGEBRAS
Kunda Chowdaiah
 
COnflict Free Feedback Vertex Set: A Parameterized Dichotomy
AkankshaAgrawal55
 
On Convolution of Graph Signals and Deep Learning on Graph Domains
Jean-Charles Vialatte
 
Ilya Shkredov – Subsets of Z/pZ with small Wiener norm and arithmetic progres...
Yandex
 
Chapter02b
Tianlu Wang
 
On the Parameterized Complexity of Simultaneous Deletion Problems
AkankshaAgrawal55
 
A multi-objective optimization framework for a second order traffic flow mode...
Guillaume Costeseque
 
Crystallographic groups
Mathieu Dutour Sikiric
 
qlp
Rei Mizuta
 
Parabolic Restricted Three Body Problem
Esther Barrabés Vera
 
Pushdown automata
eugenesri
 
Pushdown automata
parmeet834
 
Approximation Algorithms for the Directed k-Tour and k-Stroll Problems
Sunny Kr
 
Ad

Viewers also liked (19)

PPTX
Power point
Mitzilin Nieto
 
PDF
Práctica 18. 2 do trimestre hidróxido de sodio
stefanny ochoa
 
PPTX
Transtornos del lenguaje
7304560
 
PDF
Lecture1 pc
Adrian Runceanu
 
DOCX
SAKTHEESWARAN CHANDRASEGARAM (1)
Sakthees Chandrasegaram
 
PPT
Dr prasanna karhade
Prasannakarhade
 
PDF
Dissertation Organisational Performance in Alliance boots UK Sample
DissertationFirst
 
PPTX
Fluig Webinar #4 - Webinar mostra como a FTD Educação levou mobilidade à sua ...
Fluig
 
PPS
05 hindi parents expecation from child
nprasannamhindi
 
PPTX
LISP: Data types in lisp
DataminingTools Inc
 
PPT
Introduction of iso9001
Arvind sahu
 
PDF
2016 Media Kit for BLR's Environmental, Health & Safety
Ryan Vincent
 
PDF
Avi Network SDN meetup
Philippe Bogaerts
 
DOCX
Energy Meters
Rao Saim Zafar
 
PDF
FSc Marksheet
ASAD SHAUKAT
 
PPTX
Design Thinking & Innovation Games : Presented by Cedric Mainguy
oGuild .
 
PDF
Competence Book Talent Management
Competence Books
 
PPTX
LISP: Introduction to lisp
DataminingTools Inc
 
DOCX
38857 juknis uic hasil tm
Dody Ismadiyono
 
Power point
Mitzilin Nieto
 
Práctica 18. 2 do trimestre hidróxido de sodio
stefanny ochoa
 
Transtornos del lenguaje
7304560
 
Lecture1 pc
Adrian Runceanu
 
SAKTHEESWARAN CHANDRASEGARAM (1)
Sakthees Chandrasegaram
 
Dr prasanna karhade
Prasannakarhade
 
Dissertation Organisational Performance in Alliance boots UK Sample
DissertationFirst
 
Fluig Webinar #4 - Webinar mostra como a FTD Educação levou mobilidade à sua ...
Fluig
 
05 hindi parents expecation from child
nprasannamhindi
 
LISP: Data types in lisp
DataminingTools Inc
 
Introduction of iso9001
Arvind sahu
 
2016 Media Kit for BLR's Environmental, Health & Safety
Ryan Vincent
 
Avi Network SDN meetup
Philippe Bogaerts
 
Energy Meters
Rao Saim Zafar
 
FSc Marksheet
ASAD SHAUKAT
 
Design Thinking & Innovation Games : Presented by Cedric Mainguy
oGuild .
 
Competence Book Talent Management
Competence Books
 
LISP: Introduction to lisp
DataminingTools Inc
 
38857 juknis uic hasil tm
Dody Ismadiyono
 
Ad

Similar to Solving connectivity problems via basic Linear Algebra (20)

PPT
Graph
Lovepreet Kaur
 
PPTX
Graph ds
university of Gujrat, pakistan
 
PPTX
NP Complete Problems -- Internship
Seshagiri Rao Kornepati
 
PDF
Lecture26
Dr Sandeep Kumar Poonia
 
PDF
Daa chapter11
B.Kirron Reddi
 
PDF
Problem Solving with Algorithms and Data Structure - Graphs
Yi-Lung Tsai
 
PPTX
Randomized algorithms all pairs shortest path
Mohammad Akbarizadeh
 
PDF
Class01_Computer_Contest_Level_3_Notes_Sep_07 - Copy.pdf
ChristianKapsales1
 
PDF
P versus NP
Rituraj Joshi
 
PDF
Graph representation
Amit Kumar Rathi
 
PDF
Graph in Data Structure
Prof Ansari
 
PPTX
ICPC 2015, Tsukuba : Unofficial Commentary
irrrrr
 
PPT
graph.ppt
RakeshPandey951330
 
PPT
Approx
guest0264d3b
 
PPT
Appendix b 2
Loc Tran
 
PPT
graph.ppt
AqeelAbbas94
 
PPT
graph.ppt
yogeshbairagi126
 
PPT
Graphs in Discrete mathematics for computing
shardaharyani
 
PDF
NP Problems in design and analysis of alogorithm
keshavrohilla987
 
PPTX
Matrix representation of graph
Rounak Biswas
 
Graph
Lovepreet Kaur
 
Graph ds
university of Gujrat, pakistan
 
NP Complete Problems -- Internship
Seshagiri Rao Kornepati
 
Lecture26
Dr Sandeep Kumar Poonia
 
Daa chapter11
B.Kirron Reddi
 
Problem Solving with Algorithms and Data Structure - Graphs
Yi-Lung Tsai
 
Randomized algorithms all pairs shortest path
Mohammad Akbarizadeh
 
Class01_Computer_Contest_Level_3_Notes_Sep_07 - Copy.pdf
ChristianKapsales1
 
P versus NP
Rituraj Joshi
 
Graph representation
Amit Kumar Rathi
 
Graph in Data Structure
Prof Ansari
 
ICPC 2015, Tsukuba : Unofficial Commentary
irrrrr
 
graph.ppt
RakeshPandey951330
 
Approx
guest0264d3b
 
Appendix b 2
Loc Tran
 
graph.ppt
AqeelAbbas94
 
graph.ppt
yogeshbairagi126
 
Graphs in Discrete mathematics for computing
shardaharyani
 
NP Problems in design and analysis of alogorithm
keshavrohilla987
 
Matrix representation of graph
Rounak Biswas
 

More from cseiitgn (13)

PDF
A Quest for Subexponential Time Parameterized Algorithms for Planar-k-Path: F...
cseiitgn
 
PDF
Alternate Parameterizations
cseiitgn
 
PDF
Dynamic Parameterized Problems - Algorithms and Complexity
cseiitgn
 
PDF
Space-efficient Approximation Scheme for Maximum Matching in Sparse Graphs
cseiitgn
 
PDF
Hardness of multiple choice problems
cseiitgn
 
PDF
The Chasm at Depth Four, and Tensor Rank : Old results, new insights
cseiitgn
 
PDF
Isolation Lemma for Directed Reachability and NL vs. L
cseiitgn
 
PDF
Unbounded Error Communication Complexity of XOR Functions
cseiitgn
 
PDF
Color Coding-Related Techniques
cseiitgn
 
PPTX
Topology Matters in Communication
cseiitgn
 
PDF
Space-efficient Approximation Scheme for Maximum Matching in Sparse Graphs
cseiitgn
 
PDF
Efficiently decoding Reed-Muller codes from random errors
cseiitgn
 
PDF
Complexity Classes and the Graph Isomorphism Problem
cseiitgn
 
A Quest for Subexponential Time Parameterized Algorithms for Planar-k-Path: F...
cseiitgn
 
Alternate Parameterizations
cseiitgn
 
Dynamic Parameterized Problems - Algorithms and Complexity
cseiitgn
 
Space-efficient Approximation Scheme for Maximum Matching in Sparse Graphs
cseiitgn
 
Hardness of multiple choice problems
cseiitgn
 
The Chasm at Depth Four, and Tensor Rank : Old results, new insights
cseiitgn
 
Isolation Lemma for Directed Reachability and NL vs. L
cseiitgn
 
Unbounded Error Communication Complexity of XOR Functions
cseiitgn
 
Color Coding-Related Techniques
cseiitgn
 
Topology Matters in Communication
cseiitgn
 
Space-efficient Approximation Scheme for Maximum Matching in Sparse Graphs
cseiitgn
 
Efficiently decoding Reed-Muller codes from random errors
cseiitgn
 
Complexity Classes and the Graph Isomorphism Problem
cseiitgn
 

Recently uploaded (20)

PDF
O5-L3 Freight Transport Ops (International) V1.pdf
labyankof
 
PDF
01-Introduction-to-Information-Management.pdf
PrinceIbarra
 
PPTX
Introduction-to-Literarature-and-Literary-Studies-week-Prelim-coverage.pptx
EricaRamos80
 
PDF
STATICS OF THE RIGID BODIES Hibbelers.pdf
pascualasturiaskaye4
 
PDF
3rd Neelam Sanjeevareddy Memorial Lecture.pdf
Academy of Grassroots Studies and Research of India (AGRASRI)
 
PPTX
Pharma ospi slides which help in ospi learning
rameetkumar304
 
PPTX
Presentation on HIE in infants and its manifestations
joghikamal786
 
PDF
Chapter 2 Heredity, Prenatal Development, and Birth.pdf
MarjorieLopezTiu
 
PPTX
IMMUNITY IMMUNITY refers to protection against infection, and the immune syst...
shilpa939953
 
PDF
Chinmaya Tiranga quiz Grand Finale.pdf
Nitin Suresh
 
PDF
Complications of Minimal Access Surgery at WLH
mohitsuren827
 
PDF
Computing-Curriculum for Schools in Ghana
abigailanane203
 
PPTX
Cell Types and Its function , kingdom of life
ClaireMangundayao1
 
PDF
Microbial disease of the cardiovascular and lymphatic systems
KeyaSharma
 
PDF
Black Hat USA 2025 - Micro ICS Summit - ICS/OT Threat Landscape
Chris Sistrunk
 
PPTX
1st Inaugural Professorial Lecture held on 19th February 2020 (Governance and...
kawisojames10
 
PDF
Classroom Observation Tools for Teachers
Nicaramirez
 
PDF
VCE English Exam - Section C Student Revision Booklet
jpinnuck
 
PDF
2.FourierTransform-ShortQuestionswithAnswers.pdf
Raji Murugan
 
PDF
RMMM.pdf make it easy to upload and study
sajedul2
 
O5-L3 Freight Transport Ops (International) V1.pdf
labyankof
 
01-Introduction-to-Information-Management.pdf
PrinceIbarra
 
Introduction-to-Literarature-and-Literary-Studies-week-Prelim-coverage.pptx
EricaRamos80
 
STATICS OF THE RIGID BODIES Hibbelers.pdf
pascualasturiaskaye4
 
3rd Neelam Sanjeevareddy Memorial Lecture.pdf
Academy of Grassroots Studies and Research of India (AGRASRI)
 
Pharma ospi slides which help in ospi learning
rameetkumar304
 
Presentation on HIE in infants and its manifestations
joghikamal786
 
Chapter 2 Heredity, Prenatal Development, and Birth.pdf
MarjorieLopezTiu
 
IMMUNITY IMMUNITY refers to protection against infection, and the immune syst...
shilpa939953
 
Chinmaya Tiranga quiz Grand Finale.pdf
Nitin Suresh
 
Complications of Minimal Access Surgery at WLH
mohitsuren827
 
Computing-Curriculum for Schools in Ghana
abigailanane203
 
Cell Types and Its function , kingdom of life
ClaireMangundayao1
 
Microbial disease of the cardiovascular and lymphatic systems
KeyaSharma
 
Black Hat USA 2025 - Micro ICS Summit - ICS/OT Threat Landscape
Chris Sistrunk
 
1st Inaugural Professorial Lecture held on 19th February 2020 (Governance and...
kawisojames10
 
Classroom Observation Tools for Teachers
Nicaramirez
 
VCE English Exam - Section C Student Revision Booklet
jpinnuck
 
2.FourierTransform-ShortQuestionswithAnswers.pdf
Raji Murugan
 
RMMM.pdf make it easy to upload and study
sajedul2
 

Solving connectivity problems via basic Linear Algebra

  • 1. Solving connectivity problems via basic Linear Algebra Samir Datta Chennai Mathematical Institute Includes joint work with Raghav Kulkarni Anish Mukherjee Thomas Schwentick Thomas Zeume NMI Workshop on Complexity IIT Gandhinagar November 6, 2016
  • 2. Outline 1 Part I: Disjoint Paths 2 Part II: Dynamic Reachability 3 Conclusion
  • 4. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t?
  • 5. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL
  • 6. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL
  • 7. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL
  • 8. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t?
  • 9. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL
  • 10. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL • (Reingold) SL = L
  • 11. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL • (Reingold) SL = L • Optimization version: shortest path in NL
  • 13. Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths?
  • 14. Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability)
  • 15. Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2
  • 16. Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2 • NP-complete for undirected graphs when k part of input.
  • 17. Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2 • NP-complete for undirected graphs when k part of input. • (Robertson-Seymour) Cubic time (fixed k) in undirected graphs.
  • 18. Disjoint Path Problem • Definition (k-DPP) G graph/digraph. (si , ti ) for i ∈ [k], si , ti ∈ V (G). Do there exist vertex-disjoint (si , ti )-paths? • Distinct from k-connectivity (k-reachability) • NP-complete for directed graphs for k = 2 • NP-complete for undirected graphs when k part of input. • (Robertson-Seymour) Cubic time (fixed k) in undirected graphs. • Special cases: Planar graphs/DAGs well studied.
  • 19. One-face Min-sum Disjoint Path Problem • A very special case: 1 2 4 2k 2k − 1 3
  • 20. One-face Min-sum Disjoint Path Problem • A very special case: • k-DPP instance with undirected planar graph, and 1 2 4 2k 2k − 1 3
  • 21. One-face Min-sum Disjoint Path Problem • A very special case: • k-DPP instance with undirected planar graph, and • All terminals on single face, and 1 2 4 2k 2k − 1 3
  • 22. One-face Min-sum Disjoint Path Problem • A very special case: • k-DPP instance with undirected planar graph, and • All terminals on single face, and • Want solution with minimum total length of paths. 1 2 4 2k 2k − 1 3
  • 23. One-face Min-sum Disjoint Path Problem: Motivation • Directed general case remains NP-hard in the plane though fixed parameter tractable in k.
  • 24. One-face Min-sum Disjoint Path Problem: Motivation • Directed general case remains NP-hard in the plane though fixed parameter tractable in k. • NP-hardness in undirected case: open for k > 2.
  • 25. One-face Min-sum Disjoint Path Problem: Motivation • Directed general case remains NP-hard in the plane though fixed parameter tractable in k. • NP-hardness in undirected case: open for k > 2. • (Bj¨orklund-Husfeldt’14) Randomized polynomial time algorithm in undirected case for 2-DPP.
  • 26. One-face Min-sum Disjoint Path Problem: Motivation • (de Verdi`ere-Schrijver’08) Two-face case with sources and sinks on two different faces in time O(kn log n).
  • 27. One-face Min-sum Disjoint Path Problem: Motivation • (de Verdi`ere-Schrijver’08) Two-face case with sources and sinks on two different faces in time O(kn log n). • (Kobayashi-Sommer’10) One-face min-sum 3-DPP in polynomial time
  • 28. One-face Min-sum Disjoint Path Problem: Motivation • (de Verdi`ere-Schrijver’08) Two-face case with sources and sinks on two different faces in time O(kn log n). • (Kobayashi-Sommer’10) One-face min-sum 3-DPP in polynomial time • (Borradaile-Nayyeri-Zafarani’15) One-face min-sum k-DPP in “serial” configuration in polynomial time (in n as well as k).
  • 29. One-face min-sum Disjoint Path Problem: Our Results Theorem • The count of One-face min-sum k-DPP solutions can be reduced to O(4k) determinant computations.
  • 30. One-face min-sum Disjoint Path Problem: Our Results Theorem • The count of One-face min-sum k-DPP solutions can be reduced to O(4k) determinant computations. • Finding a witness to the problem can be randomly reduced to O(4k) determinant computations.
  • 31. One-face min-sum Disjoint Path Problem: Our Results Theorem • The count of One-face min-sum k-DPP solutions can be reduced to O(4k) determinant computations. • Finding a witness to the problem can be randomly reduced to O(4k) determinant computations. • Can also do the above sequentially in deterministic O(4knω) time (ω matrix multiplication constant).
  • 32. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n}
  • 33. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G
  • 34. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles
  • 35. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π)
  • 36. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π
  • 37. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i).
  • 38. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π)
  • 39. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π) • = signed sum of weights of cycle covers in G
  • 40. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π) • = signed sum of weights of cycle covers in G • cycle cover is a covering of vertices of G by disjoint cycles
  • 41. Determinant • Let G be a weighted graph with V (G) = {1, . . . , n} • Let A be the weighted adjacency matrix of G • Permutation π ∈ Sn can be written as a product of cycles • sgn(π) = (−1)#transpositions in π = (−1)n+c(π) • where, c(π) is the number of cycles in π • w(π) := 1≤i≤n Ai,π(i). • det(A) = π∈Sn sgn(π)w(π) • = signed sum of weights of cycle covers in G • cycle cover is a covering of vertices of G by disjoint cycles • (cycles include self loops)
  • 42. Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face
  • 43. Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face • Subdivide edge at ri
  • 44. Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face • Subdivide edge at ri • Put self loops on all vertices in graph except ri ’s
  • 45. Solving a special case 1 2 3 k-1 k k+1 k+22k-2 2k-1 2k • Add edge from sink ti to si inside the face • Subdivide edge at ri • Put self loops on all vertices in graph except ri ’s • Put weight x on each original edge and 1 on self-loops
  • 46. Solving a special case • Bijection between k-DPP’s and cycle covers
  • 47. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0
  • 48. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP)
  • 49. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are:
  • 50. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP)
  • 51. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k
  • 52. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k • Lighter than any other cycle cover
  • 53. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k • Lighter than any other cycle cover • coefficient of smallest degree term counts #-min-sum k-DPPs
  • 54. Solving a special case • Bijection between k-DPP’s and cycle covers • No k-DPP implies determinant = 0 • Preserves weight (= x#edges in k-DPP) • All min-sum k-DPPs are: • Same weight = x ( = length of min-sum k-DPP) • Same sign = (−1)n+(n− )+k • Lighter than any other cycle cover • coefficient of smallest degree term counts #-min-sum k-DPPs • As easy as determinant
  • 55. Solving a special case • Search reduces to counting in polynomial time
  • 56. Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges
  • 57. Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0
  • 58. Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC
  • 59. Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC • Use Isolation Lemma [MVV] to isolate a min-sum k-DPP
  • 60. Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC • Use Isolation Lemma [MVV] to isolate a min-sum k-DPP • Use isolating weights w(e) as exponent of x on e
  • 61. Solving a special case • Search reduces to counting in polynomial time • Sequentially consider edges • Discard any edge after removing which count remains > 0 • Search in RNC • Use Isolation Lemma [MVV] to isolate a min-sum k-DPP • Use isolating weights w(e) as exponent of x on e • Discard any edge removing which doesn’t affect min weight exponent
  • 62. Issues with general case 1 2 3 4 5 67 8 • Spurious cycle covers in addition to good ones
  • 63. Issues with general case 1 2 3 4 5 67 8 • Spurious cycle covers in addition to good ones • No bijection between required k-DPP paths and cycle covers
  • 64. Issues with general case 1 2 3 4 5 67 8 • Spurious cycle covers in addition to good ones • No bijection between required k-DPP paths and cycle covers • Spurious cycle covers for different terminal pairing/demands
  • 65. Fixing issues with general case 1 2 3 4 5 67 8 1 2 3 4 5 67 8 1 2 3 4 5 67 8 • Spurious cycle covers canceled by cycle covers with new demands
  • 66. Fixing issues with general case 1 2 3 4 5 67 8 1 2 3 4 5 67 8 1 2 3 4 5 67 8 • Spurious cycle covers canceled by cycle covers with new demands • Further spurious cycles - canceled by another demand set - etc.
  • 67. Fixing issues with general case 1 2 3 4 5 67 8 1 2 3 4 5 67 8 1 2 3 4 5 67 8 • Spurious cycle covers canceled by cycle covers with new demands • Further spurious cycles - canceled by another demand set - etc. • Need to prove that process converges
  • 68. Fixing issues with general case • Define a function len mapping demands to N
  • 69. Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater
  • 70. Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater • Prove: len of parallel demands maximum
  • 71. Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater • Prove: len of parallel demands maximum • Recursively express k-DPP for demand as
  • 72. Fixing issues with general case • Define a function len mapping demands to N • Prove: len of spurious demands strictly greater • Prove: len of parallel demands maximum • Recursively express k-DPP for demand as • Sum of determinant and k-DPP for demands of greater len.
  • 73. Outline 1 Part I: Disjoint Paths 2 Part II: Dynamic Reachability 3 Conclusion
  • 74. Two fundamental problems • Definition (Reachability) G directed graph and s, t ∈ V (G). Is there a path from s to t? • Complete for NL • Optimization version: shortest path also in NL • Definition (Connectivity) G undirected graph, s, t ∈ V (G). Is there a path joining s, t? • Complete for SL • (Reingold) SL = L • Optimization version: shortest path in NL
  • 76. Dynamic Complexity • Static complexity: • Input graph G presented in one shot
  • 77. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property.
  • 78. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm
  • 79. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity:
  • 80. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices
  • 81. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added
  • 82. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted
  • 83. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph?
  • 84. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs
  • 85. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step
  • 86. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string
  • 87. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query
  • 88. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query • Complexity: in terms of circuit or descriptive complexity
  • 89. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query • Complexity: in terms of circuit or descriptive complexity • DynAC0 : update circuit is AC0
  • 90. Dynamic Complexity • Static complexity: • Input graph G presented in one shot • Algorithm outputs whether G satisfies a property. • Complexity: Time/space/circuit depth/... of algorithm • Dynamic Complexity: • Start out with empty graph G on fixed number n of vertices • Edge Insertion: Edge e = (u, v) is added • Edge Deletion: Edge e = (u, v) is deleted • Query: Is property satisfied by current graph? • At every time step either insertion/deletion/query occurs • Algorithm input: string output at last step • Algorithm output: new string • One (specific) bit must be answer to query • Complexity: in terms of circuit or descriptive complexity • DynAC0 : update circuit is AC0 • DynFO: updates are First Order computable
  • 91. Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix?
  • 92. Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix? • Step 1 Reduce Reach to Rank
  • 93. Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix? • Step 1 Reduce Reach to Rank • Step 2 Rank ∈ uniform DynAC0
  • 94. Dynamic Reachability Theorem Reach is in DynFO. Proof Outline: • Rank: What is the rank of a given n × n-matrix? • Step 1 Reduce Reach to Rank • Step 2 Rank ∈ uniform DynAC0 • Step 3 DynFO ≈ uniform DynAC0
  • 95. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B.
  • 96. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t
  • 97. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i
  • 98. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A
  • 99. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0
  • 100. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0 • iff Bx = et has unique solution x with xs = 0
  • 101. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0 • iff Bx = et has unique solution x with xs = 0 • This equation system can be phrased as rank-problem ...and one change in A leads to one change in B
  • 102. Reducing Reach to Rank • Approach: Map a graph G to a matrix B such that • s-t-Reachability in G corresponds to full rank of B. • A change of G can be simulated by a constant number of changes of B. • Denote the adjacency matrix of G by A. • Recall: (s, t)-entry of Ai is the number of paths from s to t • Observe: I − 1 n A is invertible and (I − 1 n A)−1 = ∞ i=0 ( 1 n A)i • Crux: t is not reachable from s • iff (s, t)-entry of B−1 is zero where B def = I − 1 n A • iff x = B−1 et with xs = 0 • iff Bx = et has unique solution x with xs = 0 • This equation system can be phrased as rank-problem ...and one change in A leads to one change in B • Technical detail: Use B def = nI − A instead of B def = I − 1 n A
  • 103. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A)
  • 104. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff
  • 105. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff
  • 106. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff
  • 107. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff
  • 108. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒
  • 109. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒ • rkp(A) ≥ k
  • 110. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒ • rkp(A) ≥ k • But, rkp(A) ≤ rk(A), since
  • 111. Reducing Rank to mod-p-Rank • rk(A) = maxp∈[n2] rkp(A) • rk(A) ≥ k iff • ∃A , k × k submatrix of A such that rk(A ) = k iff • det(A ) = 0 iff • ∃p, small prime not dividing det(A ) iff • rkp(A ) = k =⇒ • rkp(A) ≥ k • But, rkp(A) ≤ rk(A), since • Linear relation over integers =⇒ linear relation over Zp
  • 112. Maintaining row-echelon form • Definition         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 113. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1,         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 114. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 115. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 116. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 117. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 118. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible • Maintain E in row echelon form         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 119. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible • Maintain E in row echelon form • such that E = BA         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 120. Maintaining row-echelon form • Definition • Leading (left-most non-zero) entry in every row is 1, • in column of leading entry: other entries zero • Rows are sorted in “diagonal” fashion • Given matrix A • Maintain B invertible • Maintain E in row echelon form • such that E = BA • Rank(A) is #non-zero rows of E         1 4 0 2 0 2 0 0 1 3 0 4 0 0 0 0 1 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0        
  • 121. Maintaining row-echelon form • Change A[i, j] to yield A .
  • 122. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column
  • 123. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA :
  • 124. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j
  • 125. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations:
  • 126. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1,
  • 127. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0
  • 128. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j ,
  • 129. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j
  • 130. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations:
  • 131. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1
  • 132. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1 • set all other entries of column to 0,
  • 133. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1 • set all other entries of column to 0, • If needed:
  • 134. Maintaining row-echelon form • Change A[i, j] to yield A . • BA is E + i-th column of B as j-th column • If column j has more than one leading entry of BA : • new leading entry with max # of consecutive 0’s in row after column j • by row operations: • set new leading entry to 1, • set all other entries of column j to 0 • If leading entry of row k is lost in column j , • new leading entry next non-zero in row k and column > j • by row operations: • set leading entry to 1 • set all other entries of column to 0, • If needed: • move the (at most two) rows above with changed leading entries to correct positions
  • 135. Outline 1 Part I: Disjoint Paths 2 Part II: Dynamic Reachability 3 Conclusion
  • 136. Conclusion • Considered two connectivity problems:
  • 137. Conclusion • Considered two connectivity problems: • One-face k-DPP
  • 138. Conclusion • Considered two connectivity problems: • One-face k-DPP • Dynamic Reachability
  • 139. Conclusion • Considered two connectivity problems: • One-face k-DPP • Dynamic Reachability • Writing and solving linear equations, key to solution
  • 140. Conclusion • Considered two connectivity problems: • One-face k-DPP • Dynamic Reachability • Writing and solving linear equations, key to solution • Scratched the surface of Linear Algebra
  • 141. Open Questions • Derandomize construction of One-face k-DPP solution?
  • 142. Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above?
  • 143. Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ?
  • 144. Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ? • Serial/parallel cases can be deparameterized [Borradaile et al.]
  • 145. Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ? • Serial/parallel cases can be deparameterized [Borradaile et al.] • Contrariwise, does there exist a crossover gadget?
  • 146. Open Questions • Derandomize construction of One-face k-DPP solution? • “Deparameterize” counting or even decision of above? • From 4k nO(1) to kO(1) nO(1) ? • Serial/parallel cases can be deparameterized [Borradaile et al.] • Contrariwise, does there exist a crossover gadget? • Is directed distance in DynAC0? What about path construction?