Subexponential Algorithms for
Subgraph Isomorphism
(and related problems)
on Minor-Free Graphs
Hans Bodlaender (U Utrecht, TU Eindhoven)
Jesper Nederlof (TU Eindhoven)
Tom van der Zanden (U Utrecht)
1
Subgraph Isomorphism
• Given: a pattern graph 𝑃 and host graph 𝐺
• Question: does 𝐺 have a subgraph isomorphic to 𝑃
• Upper bound and (assuming ETH) matching lower
bound
2
Complexity of Subgraph Isomorphism
• Let 𝑛 = 𝑉 𝐺
and 𝑘 = 𝑉 𝑃 and 𝑡𝑤 = 𝑡𝑤 𝐺
• General graphs:
– O(𝑛!) time
– 2Ω 𝑛 log 𝑛 lower bound [Fomin et al. ’15]
• Planar:
– 2𝑂 𝑘 𝑛 time [Dorn ‘09]
– Connected and bounded degree: see previous talk
𝜖
– This talk: 2𝑂(𝑘 𝑛 + 𝑘 / log 𝑘) time
– This talk: 2Ω(𝑛/ log 𝑛) lower bound under ETH
3
Our Results
• Theorem
For any 𝐻, and 𝜖 > 0: If 𝑃 is 𝐻-Minor Free, and 𝐺 has
treewidth 𝑡𝑤, Subgraph Isomorphism can be solved in
𝑂(𝑘 𝜖 𝑡𝑤 + 𝑘 / log 𝑘)
2
time.
• Interesting special cases: 𝐺 and 𝑃 of bounded treewidth, 𝐺
and 𝑃 planar.
• Theorem
Assume the ETH. There is no 2𝑜(𝑛/ log 𝑛) algorithm for
Subgraph Isomorphism, even when
– 𝐺 and 𝑃 are forests, with each component a caterpillar, or
– 𝐺 is connected, has pathwidth 2 with one vertex of degree
larger than 3 and 𝑃 is a tree
4
Similar results
• Upper and lower bound result hold for:
– Induced Subgraph Isomorphism
– Minor
– Induced Minor
– Topological Minor
– Shallow Minor (bounded radius)
• With small modifications to proofs and
arguments
5
Lower bound proof
• Simple proof (=> incomplete talk…) using
• Theorem. (By Sparsification Lemma)
Assume the ETH. There is no 2𝑜(𝑛/ log 𝑛)
algorithm for 3-SAT with 𝑂(𝑛) clauses.
6
Numbers and strings
• Number variables 1 … 𝑛, and clauses 𝑛 + 1, … ,
𝑟 = 𝑂(𝑛)
• Change each number to bitstring with 4log 𝑟
bits:
– Take the number in binary
– Add the number in binary with 0 and 1 switched
– Add the string reversed:
• I.e.: 6 -> 110 001 100 011
• Note: strings are `incomparable’
7
G and P (partly on board)
• G:
– For each variable 𝑥𝑖 a caterpillar for 𝑥𝑖 = 𝑡𝑟𝑢𝑒 and a
caterpillar for 𝑥𝑖 = 𝑓𝑎𝑙𝑠𝑒
• P
– For each variable 𝑥𝑖 a caterpillar (“to eat the false
literal”)
– For each clause a caterpillar (“to make sure it is
satisfied”)
– 3(𝑟 – 𝑛) – 𝑛 paths (“to eat unused clauses in true
literals” )
8
End of proof
• Instance of 3-Sat is satisfiable, if and only if P
is isomorphic to a subgraph of G
• G and P has 𝑂(𝑛 log 𝑛) vertices, so 2𝑜(𝑛/ log 𝑛)
algorithm would break ETH
9
Modifications
• Connected G and P:
– Add one vertex with edges (see board)
• Minor, topological minor: same construction
• Induced subgraph, induced minor: trivial
modification to proof
10
Outline of algorithm
• Dynamic programming on a tree
decomposition of 𝐺
• Partial solution: map of bag into 𝑃 + set of
connected components 𝑃
• Use isomorphism to reduce the number of
partial solutions
11
Partial Solution
𝑋𝑡
𝑓(𝑋𝑡 )
𝐺[𝑡]
• Partial solution: 𝑓: 𝐺[𝑡] → 𝑉 𝑃 ∪ □
12
Partial Solution
𝑋𝑡
𝑓(𝑋𝑡 )
𝐺[𝑡]
• Partial solution: 𝑓: 𝐺[𝑡] → 𝑉 𝑃 ∪ □
• Consider connected components 𝑃 − 𝑓 𝑋𝑡
13
Partial Solution
𝑋𝑡
𝑓(𝑋𝑡 )
𝐺[𝑡]
• Partial solution: 𝑓: 𝐺[𝑡] → 𝑉 𝑃 ∪ □
• Consider connected components 𝑃 − 𝑓 𝑋𝑡
• Either completely IN or completely OUT
14
Partial Solution
• A partial solution can be characterized by
– Image of Xt : 2𝑂 𝑡𝑤 log 𝑘 options
– List for each connected component of 𝑃 − 𝑓 𝑋𝑡 if it is
in or out: can be 2𝑘 options: still too many
𝑓(𝑋𝑡 )
15
Partial Solution
• A partial solution can be characterized by
– Image of Xt : 2𝑂 𝑡𝑤 log 𝑘 options
– List for each connected component of 𝑃 − 𝑓 𝑋𝑡 if it is
in or out: can be 2𝑘 options: still too many
• Idea: it does not matter which of the
isomorphic components we have, only
how many
𝑓(𝑋𝑡 )
𝑓(𝑋𝑡 )
16
Cases
• For well chosen c:
• A component is large if it has at least c log n
vertices
• Small components are isomorphic if
– There is an isomorphism that also takes care of
the adjacencies to 𝑓 𝑋𝑡
𝑓(𝑋𝑡 )
17
Info In DP
• For each large component: store if it is in or out
– 𝑛/𝑐 log 𝑛 large components: 2𝑂(𝑛/ log 𝑛)
• For each equivalence class of small components:
– Store how many in the class are in
– Equivalence test is sufficiently fast (only done on
subgraphs with 𝑂(log 𝑛) vertices)
– Counting argument shows that the number of cases is
bounded by 2𝑂(𝑛/ log 𝑛)
18
Number of isomorphisms (1)
• Theorem [Amini et al. ‘12]: for any graph 𝐻, there is
a constant 𝐶𝐻 so that there are at most 𝐶𝐻 𝑛 nonisomorphic 𝑛-vertex 𝐻-Minor Free graphs
• For small enough 𝑐, at most 𝐶𝐻
𝑐 log 𝑘
= 𝑘𝜖
This bounds the number of
isomorphism classes except for how
components are attached to 𝑓(𝑋𝑡 )
19
Small Components
• Component 𝐶 itself: 𝐶𝐻 𝑐 log 𝑘 options
• What about incidence to 𝑓(𝑋𝑡 )?
• Each conn. comp. 𝐶 is incident to
subset 𝑆 ⊆ 𝑓 𝑋𝑡
• Each vertex 𝑣 ∈ 𝐶 is incident to
subset of 𝑆
𝑓(𝑋𝑡 )
20
Small Components – Case 1
• Small Component with Big Neighborhood
• 𝑆≥ 𝐻
• Lemma [Gajarský et al.]: there are
O(tw) small components with Big
Neighborhood
• 2O(tw) cases
𝑓(𝑋𝑡 )
21
Small Components – Case 2
• Small Component with Small Neighborhood
• 𝑆< 𝐻
𝑓(𝑋𝑡 )
• Lemma [Gajarský et al.]: there are
O(tw) different possible small
neighborhoods
22
Counting Small Components
• 𝐶𝐻 𝑐 log 𝑘 distinct isomorphism classes:
• 𝑂 𝑋𝑡 distinct small neighborhoods
• Each vertex: 2 𝐻 cases for adjacency to
neighborhood
𝑓(𝑋𝑡 )
𝑐 log 𝑘
𝐻
𝑐 log 𝑘
• Total: 𝐶𝐻
𝑋𝑡 2
• Small enough 𝑐: = 𝑂(𝑘 𝜖 𝑡𝑤)
23
Wrapping Up
𝑂(𝑘 𝜖 𝑡𝑤)
𝑂(𝑘 𝜖′ 𝑡𝑤)
• 𝑘+1
=2
cases for small
components (0 … 𝑛 of each)
• 2𝑂(𝑘/ log 𝑘+𝑡𝑤) for large comps., large nbh.’s
• 𝑘+1
𝑡𝑤
= 2𝑂
𝑡𝑤 log 𝑘
cases for 𝑓
𝑂 𝑘 𝜖 𝑡𝑤+𝑘 / log 𝑘
• 2
𝑝(𝑛) algorithm for
Subgraph Isomorphism on Minor-Free graphs
24
Consequences
𝑂 𝑘 𝜖 𝑡𝑤+𝑘 / log 𝑘
• 2
𝑝(𝑛) algorithm for Subgraph
Isomorphism on Minor-Free graphs
• + result Fomin et al. (previous talk)
•  2𝑂 𝑘 / log 𝑘 𝑝(𝑛) algorithm for Subgraph
Isomorphism on Apex-Minor-Free graphs for
connected patterns
25
Conclusions
• 2Θ 𝑛/ log 𝑛 algorithm and lower bound for
Subgraph Isomorphism and other problems on Hminor free graphs (resolves some open problems)
• Can we do 2𝑂 𝑘/ log 𝑘 𝑝𝑜𝑙𝑦(𝑛) in the
disconnected case? Lower bound?
• For which `embeddings’ does this work?
• Algorithm has nice, simple, useful technique:
speed up DP by isomorphism test
– Isomorphic subproblems have the same answer
– Counting shows there are sufficiently few
26