Complexity Theory of Polynomial-Time Problems Lecture 6: 3SUM Part - - PowerPoint PPT Presentation

Complexity Theory of Polynomial-Time Problems

Karl Bringmann

Lecture 6: 3SUM Part I

3SUM

given sets 𝐵,𝐶,𝐷 of 𝑜 integers are there 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶,𝑑 ∈ 𝐷 such that 𝑏 + 𝑐 + 𝑑 = 0? (we assume that we can add/subtract/compare input integers in constant time) trivial algorithm: 𝑃(𝑜/) well-known: 𝑃(𝑜1) Conjecture: no 𝑃 𝑜123 algorithm → 3SUM-Hardness

[Gajentaan,Overmars’95]

More Known Algorithms

trivial: 𝑃(𝑜/) well-known: 𝑃(𝑜1) using Word RAM bit-tricks: 𝑃(𝑜1 ⋅

789:; ; ), 𝑃(𝑜1 ⋅ (789 789 <): 789:<

) no bit-tricks: 𝑃(𝑜1 ⋅

(789 789 <): 789 <

)

[Baran,Demaine,Patrascu’05] [Gronlund,Pettie’14]

we prove a simplified version: Thm: Without bit-tricks, 3SUM is in time 𝑃(𝑜1 ⋅

=87> 789 789 < 789 <

) using FFT: 𝑃(𝑜 + 𝑉 polylog𝑉) for numbers in {−𝑉, …, 𝑉} (cell size 𝑥 = Ω(log𝑜), each number fits in a cell)

Equivalent Variants

given sets 𝐵,𝐶,𝐷 of 𝑜 integers are there 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶,𝑑 ∈ 𝐷 such that 𝑏 + 𝑐 + 𝑑 = 0? 1) given a set 𝑌 of 𝑜 integers are there 𝑦, 𝑧, 𝑨 ∈ 𝑌 such that 𝑦 + 𝑧 + 𝑨 = 0? 4) given sets 𝐵,𝐶,𝐷 of 𝑜 integers and target 𝑢 are there 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶,𝑑 ∈ 𝐷 such that 𝑏 + 𝑐 + 𝑑 = 𝑢? 3) given sets 𝐵,𝐶,𝐷 of 𝑜 integers are there 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶,𝑑 ∈ 𝐷 such that 𝑏 + 𝑐 = 𝑑? 2) replace 𝐷 by 𝑑 − 𝑢 𝑑 ∈ 𝐷} ⇔ 𝑏 + 𝑐 − 𝑑 = 0 ⇔ 𝑏 + 𝑐 + (𝑑 − 𝑢) = 0 replace 𝐷 by −𝑑 𝑑 ∈ 𝐷} ↑: set 𝐵, 𝐶, 𝐷 ≔ 𝑌 ↓: set 𝑌 ≔ 𝑏 + 4𝑉 | 𝑏 ∈ 𝐵 ∪ 𝐶 ∪ {𝑑 − 4𝑉 | 𝑑 ∈ 𝐷} where 𝐵,𝐶,𝐷 ⊆ {−𝑉,. . , 𝑉}

Outline

1) algorithm for small universe 2) quadratic algorithm 3) small decision tree 4) logfactor improvement 5) some 3SUM-hardness results

Algorithm for Small Numbers

add 𝑉 to each number, then numbers are in {0,. . , 2𝑉} and 𝑃(𝑜 + 𝑉 polylog𝑉) for numbers in {−𝑉, …, 𝑉} we want 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶,𝑑 ∈ 𝐷 such that 𝑏 + 𝑐 + 𝑑 = 3𝑉 define polynomials 𝑞\ 𝑦 ≔ ∑ 𝑦^

^∈\

and similarly 𝑞_ 𝑦 , 𝑞` 𝑦 have degree at most 2𝑉 compute 𝑟 𝑦 ≔ 𝑞\ 𝑦 ⋅ 𝑞_ 𝑦 ⋅ 𝑞` 𝑦 = (∑ 𝑦^

^∈\

)(∑ 𝑦b

b∈_

)(∑ 𝑦c

c∈`

) what is the coefficient of 𝑦/d in 𝑟(𝑦)? use efficient polynomial multiplication (via Fast Fourier Transform): polynomials of degree 𝑒 can be multiplied in time 𝑃(𝑒 polylog𝑒) (𝑦^ ⋅ 𝑦b ⋅ 𝑦c = 𝑦^fbfc) it is the number of (𝑏, 𝑐, 𝑑) summing to 3𝑉

Outline

1) algorithm for small universe 2) quadratic algorithm 3) small decision tree 4) logfactor improvement 5) some 3SUM-hardness results

Quadratic Algorithm

given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 𝑏g 𝑏1 𝑏/ 𝑏< … 𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

return “no solution”

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

if 𝑏m + 𝑏

n < −𝑑: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Quadratic Algorithm

𝑏g 𝑏1 𝑏/ 𝑏< … initialize 𝑗 = 𝑜,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜: return “no solution” time 𝑃(𝑜) per 𝑑 ∈ 𝐵 time 𝑃(𝑜1) overall given a set 𝐵 of 𝑜 integers are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? sort 𝐵 in increasing order: 𝐵 = {𝑏g,… , 𝑏<} for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 if 𝑏m + 𝑏

n = −𝑑: return (𝑏m, 𝑏 n,𝑑)

if 𝑏m + 𝑏

n > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

𝑏g 𝑏1 𝑏/ 𝑏< …

Outline

1) algorithm for small universe 2) quadratic algorithm 3) small decision tree 4) logfactor improvement 5) some 3SUM-hardness results

Decision Tree Complexity

Thm: 3SUM has a decision tree of depth 𝑃(𝑜//1 log𝑜)

Decision Tree Complexity

where you have seen this: Thm: Any decision tree for Sorting 𝑜 numbers has depth Ω(𝑜 log𝑜) Thm: Any comparison-based Sorting algorithm takes time Ω(𝑜log 𝑜) problem 𝑄 on input 𝑦g,…, 𝑦< decision tree complexity of 𝑄 = minimal depth of any decision tree for 𝑄 Decision Tree: each inner node is a comparison: 𝑦m ≤ 𝑦n more generally any linear combination: ∑ 𝛽m

m

𝑦m ≥ 0 all instances reaching the same leaf have the same result 𝑄(𝑦g,… ,𝑦<) 𝑦g ≤ 𝑦1 𝑦1 ≤ 𝑦/ 𝑦g ≤ 𝑦/

• utgoing edges are labeled 1/0 = true/false

1 1 … … … 1 yields a lower bound for running time of any algorithm (that uses only comparisons, no bit-tricks)

Decision Tree Complexity

alternative interpretation: think of 𝑦g,… ,𝑦< as physical entities we may specify factors 𝛽m we can perform experiments: the outcome of the experiment tells us whether ∑ 𝛽m

m

𝑦m ≥ 0 experiments are very costly, computation is cheap what is the minimal number of experiments to decide 𝑄(𝑦g,… ,𝑦<)?

„experiment“ or „costly comparison“

= decision tree complexity

Decision Tree Complexity

alternative interpretation II: RAM with two types of cells: special and standard input numbers 𝑦g,… ,𝑦< are stored in special cells special standard Stores: e.g. real number 𝑃(log 𝑜) bit number Operations: add, subtract, compare (result of comparison can be stored in standard cell) all standard arithmetic and logical operations and comparisons usual RAM cost model: each operations takes constant time decision tree cost model: comparisons of special numbers cost 1 all other operations are for free

Decision Tree Complexity

Thm: 3SUM has a decision tree of depth 𝑃(𝑜//1 log𝑜) why study decision tree upper bounds? rules out quadratic lower bound in decision tree model

• ften small decision trees yield lower order improvements

Thm: Without bit-tricks, 3SUM is in time 𝑃(𝑜1 ⋅

=87> 789 789 < 789 <

)

Small Decision Tree

sort 𝐵 in increasing order partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? write 𝐵m = {𝑏m,g,…, 𝑏m,u} i.e., build a list 𝑀| containing all (𝑗, 𝑘, 𝑙) with 𝑗 ∈ 1,… , 𝑜/𝑕 , 𝑘, 𝑙 ∈ {1, … ,𝑕} sorted by 𝑏m,n − 𝑏m,~ ascendingly this preprocessing allows to compare any 𝑏m,n − 𝑏m,~ and 𝑏m•,n• − 𝑏m•,~• without any costly comparisons Fredman’s trick: 𝑏m,n + 𝑏m•,n• ≤ 𝑏m,~ + 𝑏m•,~• ⟺ 𝑏m•,n• − 𝑏m•,~• ≤ 𝑏m,~ − 𝑏m,n so this preprocessing allows to compare any 𝑏m,n + 𝑏m•,n• and 𝑏m,~ + 𝑏m•,~• without any costly comparisons: 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons 𝑃(𝑜 log𝑜) comparisons 𝑏m,n + 𝑏m•,n• ≤ 𝑏m,~ + 𝑏m•,~• ⟺ (𝑗•,𝑘•,𝑙•) appears before (𝑗, 𝑙, 𝑘) in 𝑀| any numbers in 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•}

Small Decision Tree

sort 𝐵 in increasing order for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 𝐵g 𝐵1 𝐵</u … 𝐵g 𝐵1 𝐵</u … initialize 𝑗 = 𝑜/𝑕,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜/𝑕: if −𝑑 ∈ 𝐵m,n: return “solution found” if min 𝐵m + max (𝐵

n) > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

return “no solution” partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? for all 𝑗, 𝑗•: sort 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•} 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons 𝑃(𝑜 log𝑜) comparisons no comparisons!

Small Decision Tree

sort 𝐵 in increasing order for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 𝐵g 𝐵1 𝐵</u … 𝐵g 𝐵1 𝐵</u … initialize 𝑗 = 𝑜/𝑕,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜/𝑕: if −𝑑 ∈ 𝐵m,n: return “solution found” if min 𝐵m + max (𝐵

n) > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

return “no solution” partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? for all 𝑗, 𝑗•: sort 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•} 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons 𝑃(𝑜 log𝑜) comparisons no comparisons!

Small Decision Tree

sort 𝐵 in increasing order for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 𝐵g 𝐵1 𝐵</u … 𝐵g 𝐵1 𝐵</u … initialize 𝑗 = 𝑜/𝑕,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜/𝑕: if −𝑑 ∈ 𝐵m,n: return “solution found” if min 𝐵m + max (𝐵

n) > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

return “no solution” partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? for all 𝑗, 𝑗•: sort 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•} 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons 𝑃(𝑜 log𝑜) comparisons no comparisons!

Small Decision Tree

sort 𝐵 in increasing order for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 initialize 𝑗 = 𝑜/𝑕,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜/𝑕: if −𝑑 ∈ 𝐵m,n: return “solution found” if min 𝐵m + max (𝐵

n) > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

return “no solution” partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? for all 𝑗, 𝑗•: sort 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•} 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons 𝑃(𝑜 log𝑜) comparisons no comparisons! 𝑃 𝑜/𝑕 iterations 𝑃 log(𝑕1) = 𝑃(log𝑜) comparisons using binary search 𝑜 iterations in total: 𝑃((𝑜𝑕 + 𝑜1/𝑕)log 𝑜) comparisons = 𝑃(𝑜//1 log𝑜) for 𝑕 ≔ 𝑜

Decision Tree Complexity

Thm: 3SUM has a decision tree of depth 𝑃(𝑜//1 log𝑜) Thm: Without bit-tricks, 3SUM is in time 𝑃(𝑜1 ⋅

=87> 789 789 < 789 <

)

Outline

1) algorithm for small universe 2) quadratic algorithm 3) small decision tree 4) logfactor improvement 5) some 3SUM-hardness results

Converting Decision Tree to Algorithm

sort 𝐵 in increasing order for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 initialize 𝑗 = 𝑜/𝑕,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜/𝑕: if −𝑑 ∈ 𝐵m,n: return “solution found” if min 𝐵m + max (𝐵

n) > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

return “no solution” partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? for all 𝑗, 𝑗•: sort 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•} 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons and time 𝑃(𝑜 log𝑜) comparisons and time no comparisons! 𝑃( 𝑜/𝑕 1 ⋅ 𝑕1 log(𝑕1)) time 𝑃 𝑜/𝑕 iterations 𝑃 log(𝑕1) = 𝑃(log𝑜) comparisons and time using binary search 𝑜 iterations in total: 𝑃(𝑜1 log(𝑕1)) time ☹

Converting Decision Tree to Algorithm

for all 𝒋,𝒋•: sort 𝑩𝒋,𝒋• ≔ 𝑩𝒋 + 𝑩𝒋• = 𝒃 + 𝒄 𝒃 ∈ 𝑩𝒋,𝒄 ∈ 𝑩𝒋•} write 𝐵m = {𝑏m,g,…, 𝑏m,u} make 𝐵m,m• totally ordered: replace 𝐵m by 𝑏m,n ⋅ 2𝑕 1 + 𝑘 1 ≤ 𝑘 ≤ 𝑕} replace 𝐵m• by 𝑏m•,n ⋅ 2𝑕 1 + 𝑘 ⋅ 2𝑕 1 ≤ 𝑘 ≤ 𝑕} then no 𝒃 ∈ 𝑩𝒋, 𝒄 ∈ 𝑩𝒋• and 𝒃′ ∈ 𝑩𝒋, 𝒄′ ∈ 𝑩𝒋• sum up to the same value simplification: and from the new 𝐵m + 𝐵m• we can recover the old 𝐵m + 𝐵m• implement this step faster!

Converting Decision Tree to Algorithm

for all 𝒋,𝒋•: sort 𝑩𝒋,𝒋• ≔ 𝑩𝒋 + 𝑩𝒋• = 𝒃 + 𝒄 𝒃 ∈ 𝑩𝒋,𝒄 ∈ 𝑩𝒋•} write 𝐵m = {𝑏m,g,…, 𝑏m,u} consider any permutation 𝑄 = 𝜌g,𝜏g , 𝜌1,𝜏1 ,… , 𝜌u:,𝜏u:

• f 1, . ., 𝑕 ×{1, …, 𝑕}

this is the correct sorted ordering of 𝐵m,m• if and only if: 𝑄 corresponds to this ordering of 𝐵m,m•: (𝑏m,•• + 𝑏m•,‘• 𝑏m,•: + 𝑏m•,‘: … 𝑏m,•’ + 𝑏m•,‘’) 𝑏m,•“ + 𝑏m•,‘“ < 𝑏m,•“”• + 𝑏m•,‘“”• for all 1 ≤ 𝑙 < 𝑕1 by Fredman‘s trick, this is equivalent to: 𝑏m•,‘“ − 𝑏m•,‘“”• < 𝑏m,•“”• − 𝑏m,•“ for all 1 ≤ 𝑙 < 𝑕1 construct vectors: (𝑏m•,‘“ − 𝑏m•,‘“”•)g•~–u: (𝑏m,•“”• − 𝑏m,•“)g•~–u: we say that vector 𝑦 dominates vector 𝑧 if 𝑦m > 𝑧m for all 𝑗

Dominance Reporting

Dominance Reporting problem: given sets 𝐵,𝐶 of (integer-valued) vectors in ℝ˜, 𝐵 + 𝐶 = 𝑛 report all pairs 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶 where 𝑐 dominates 𝑏 Thm: Dominance Reporting is in time 𝑃 𝑛 log𝑛 ˜ + outputsize

Converting Decision Tree to Algorithm

for all 𝒋,𝒋•: sort 𝑩𝒋,𝒋• ≔ 𝑩𝒋 + 𝑩𝒋• = 𝒃 + 𝒄 𝒃 ∈ 𝑩𝒋,𝒄 ∈ 𝑩𝒋•} write 𝐵m = {𝑏m,g,…, 𝑏m,u} for each permutation 𝑄 = 𝜌g,𝜏g , 𝜌1,𝜏1 ,… , 𝜌u:,𝜏u:

• f 1, . ., 𝑕 ×{1, …, 𝑕}:

construct sets: (𝑏m•,‘“ − 𝑏m•,‘“”•)g•~–u: (𝑏m,•“”• − 𝑏m,•“)g•~–u: 𝐵 = { 𝐶 = { | 1 ≤ 𝑗• ≤ 𝑜/𝑕 } | 1 ≤ 𝑗 ≤ 𝑜/𝑕 } solve Dominance Reporting on 𝐵,𝐶 for each reported pair (𝑗, 𝑗•): the sorted ordering of 𝐵m,m• is given by 𝑄: (𝑏m,•• + 𝑏m•,‘• 𝑏m,•: + 𝑏m•,‘: … 𝑏m,•’ + 𝑏m•,‘’) time for sorting all 𝐵m,m•: 𝑃 𝑕1 ! ⋅ (𝑜/𝑕)(log𝑜/𝑕)u: + 𝑜/𝑕 1

• ne vector

for each of 𝑜/𝑕 groups 𝑕1 ! iterations vectors have dimension 𝑕1 total

• utputsize

𝑜/𝑕 1 time 𝑃(𝑛 log𝑛 ˜ + outputsize)

Converting Decision Tree to Algorithm

for all 𝒋,𝒋•: sort 𝑩𝒋,𝒋• ≔ 𝑩𝒋 + 𝑩𝒋• = 𝒃 + 𝒄 𝒃 ∈ 𝑩𝒋,𝒄 ∈ 𝑩𝒋•} write 𝐵m = {𝑏m,g,…, 𝑏m,u} for each permutation 𝑄 = 𝜌g,𝜏g , 𝜌1,𝜏1 ,… , 𝜌u:,𝜏u:

• f 1, . ., 𝑕 ×{1, …, 𝑕}:

construct sets: (𝑏m•,‘“ − 𝑏m•,‘“”•)g•~–u: (𝑏m,•“”• − 𝑏m,•“)g•~–u: 𝐵 = { 𝐶 = { | 1 ≤ 𝑗• ≤ 𝑜/𝑕 } | 1 ≤ 𝑗 ≤ 𝑜/𝑕 } solve Dominance Reporting on 𝐵,𝐶 for each reported pair (𝑗, 𝑗•): the sorted ordering of 𝐵m,m• is given by 𝑄: (𝑏m,•• + 𝑏m•,‘• 𝑏m,•: + 𝑏m•,‘: … 𝑏m,•’ + 𝑏m•,‘’) time for sorting all 𝐵m,m•: 𝑃 𝑕1 ! ⋅ (𝑜/𝑕)(log𝑜/𝑕)u: + 𝑜/𝑕 1 time 𝑃(𝑛 log𝑛 ˜ + outputsize) setting 𝑕 ≔ 0.1 ⋅ log 𝑜/ loglog 𝑜 𝑕1 ! ≤ 𝑕1

u: ≤ (log𝑜)u:≤ log𝑜 ( . g 789 <)/789 789 < = 𝑜 . g

(log𝑜/𝑕)u:≤ log𝑜 u: ≤ 𝑜 . g = 𝑃 𝑜/𝑕 1

Converting Decision Tree to Algorithm

sort 𝐵 in increasing order for each 𝑑 ∈ 𝐵: check whether there are 𝑏, 𝑐 ∈ 𝐵 s.t. 𝑏 + 𝑐 + 𝑑 = 0 initialize 𝑗 = 𝑜/𝑕,𝑘 = 1 while 𝑗 > 0 and 𝑘 ≤ 𝑜/𝑕: if −𝑑 ∈ 𝐵m,n: return “solution found” if min 𝐵m + max (𝐵

n) > −𝑑: 𝑗 ≔ 𝑗 − 1

• therwise: 𝑘 ≔ 𝑘 + 1

return “no solution” partition 𝐵 into 𝑜/𝑕 groups: 𝐵g, …, 𝐵</u (all elements of 𝐵m are smaller than all elements of 𝐵mfg) sort 𝐸 ≔ ⋃ 𝐵m − 𝐵m

</u mxg

= 𝑏 − 𝑐 ∃𝑗: 𝑏, 𝑐 ∈ 𝐵m} given a set 𝐵 of 𝑜 integers, are there 𝑏, 𝑐, 𝑑 ∈ 𝐵 such that 𝑏 + 𝑐 + 𝑑 = 0? for all 𝑗, 𝑗•: sort 𝐵m,m• ≔ 𝐵m + 𝐵m• = 𝑏 + 𝑐 𝑏 ∈ 𝐵m, 𝑐 ∈ 𝐵m•} 𝑃 𝐸 log 𝐸 = 𝑃(𝑜𝑕 log(𝑜𝑕)) comparisons and time 𝑃(𝑜 log𝑜) comparisons and time no comparisons! 𝑃( 𝑜/𝑕 1 ⋅ 𝑕1 log(𝑕1)) time 𝑃 𝑜/𝑕 iterations 𝑃 log(𝑕1) = 𝑃(log𝑜) comparisons and time using binary search 𝑜 iterations in total: 𝑃(𝑜1 log(𝑕)/𝑕) time for 𝑕 ≔ 0.1 ⋅ log 𝑜/ loglog 𝑜: 𝑃(𝑜1 =87> 789 789 <

789 <

) time

Decision Tree Complexity

Thm: 3SUM has a decision tree of depth 𝑃(𝑜//1 log𝑜) Thm: Without bit-tricks, 3SUM is in time 𝑃(𝑜1 ⋅

=87> 789 789 < 789 <

)

Dominance Reporting

Dominance Reporting problem: given sets 𝐵,𝐶 of (integer-valued) vectors in ℝ˜, 𝐵 + 𝐶 = 𝑛 report all pairs 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶 where 𝑐 dominates 𝑏 Thm: deciding whether there is a dominating pair (𝑏, 𝑐) is OV-hard so we do not expect an 𝑃(poly 𝑒 𝑛123) algorithm OV is in time 𝑃(2˜𝑛) the theorem „generalizes“ this OV-algorithm to Dominance Reporting Dominance Reporting is in time 𝑃 𝑛 log𝑛 ˜ + outputsize

Dominance Reporting

Dominance Reporting problem: given sets 𝐵,𝐶 of (integer-valued) vectors in ℝ˜, 𝐵 + 𝐶 = 𝑛 report all pairs 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶 where 𝑐 dominates 𝑏 if 𝑒 = 0: report all pairs 𝐵×𝐶

• therwise:

find median 𝑦 of 𝑒-th coordinates of all points in 𝐵 ∪ 𝐶 - time 𝑃(𝑛) assume all coordinates to be different 𝐵¡ ≔ 𝑏 ∈ 𝐵 𝑏˜ < 𝑦} and 𝐵¢ ≔ 𝐵\𝐵¡ 𝐶¡ ≔ 𝑐 ∈ 𝐶 𝑐˜ < 𝑦} and 𝐶¢ ≔ 𝐶\𝐶

¡

recursively solve 𝐵¢, 𝐶¢ ,(𝐵¡, 𝐶

¡ ), and (𝐵¡,𝐶¢ )

remove 𝑒-th coordinates! 𝑈˜ 𝑛 ≤ 2𝑈˜ 𝑛/2 + 𝑈˜2g 𝑛 + 𝑛 Thm: Dominance Reporting is in time 𝑃 𝑛 log𝑛 ˜ + outputsize

Dominance Reporting

𝑈˜ 𝑛 ≤ 2𝑈˜ 𝑛/2 + 𝑈˜2g 𝑛 + 𝑛 𝑈 𝑛 = 𝑈˜ 1 = 0 Excluding cost of output: 𝑈˜ 𝑛 ≤ 𝑛 log2𝑛 ˜ − 𝑛 Inductively prove that: 𝑈˜ 𝑛 ≤ 2 𝑛 2 log𝑛 ˜ − 𝑛 2 + 𝑛 log2𝑛 ˜2g − 𝑛 + 𝑛 = 𝑛 (log2𝑛) − 1 ˜ + 𝑛 (log2𝑛)˜2g−𝑛 = 𝑛 (log 2𝑛)˜ 1 − 1/ log2𝑛 ˜ + 𝑛 (log2𝑛)˜2g−𝑛 ≤ 𝑛 (log 2𝑛)˜ 1 − 1/ log2𝑛 + 𝑛 (log2𝑛)˜2g−𝑛 = 𝑛 (log 2𝑛)˜ − 𝑛

Dominance Reporting

Dominance Reporting problem: given sets 𝐵,𝐶 of (integer-valued) vectors in ℝ˜, 𝐵 + 𝐶 = 𝑛 report all pairs 𝑏 ∈ 𝐵, 𝑐 ∈ 𝐶 where 𝑐 dominates 𝑏 Thm: Dominance Reporting is in time 𝑃 𝑛 log𝑛 ˜ + outputsize Thm: Without bit-tricks, 3SUM is in time 𝑃(𝑜1 ⋅

=87> 789 789 < 789 <

) this finishes the proof of:

Outline

1) algorithm for small universe 2) quadratic algorithm 3) small decision tree 4) logfactor improvement 5) some 3SUM-hardness results

GeomBase

given a set of 𝑜 points on three horinzontal lines 𝑧 = 0,𝑧 = 1, 𝑧 = 2, determine whether there exists a non-horizontal line containing three of the points GeomBase is even equivalent to 3SUM Thm: GeomBase is 3SUM-hard. Given an instance (𝐵, 𝐶, 𝐷) of 3SUM 𝑧 = 0 𝑧 = 1 𝑧 = 2 construct points: (𝑏, 0) for any 𝑏 ∈ 𝐵 (𝑐,2) for any 𝑐 ∈ 𝐶 (𝑑/2,1) for any 𝑑 ∈ 𝐷 they lie on a line if 𝑑/2 − 𝑏 = 𝑐 − 𝑑/2 ⇔ 𝑏 + 𝑐 = 𝑑

3-Points-on-line / Collinear

given a set of 𝑜 points in the plane, is there a line containing at least 3 of the points? Thm: 3-Points-on-line is 3SUM-hard. Given an instance 𝐵 of 3SUM construct points: (𝑏, 𝑏/) for any 𝑏 ∈ 𝐵 then 𝑏, 𝑏/ , 𝑑, 𝑑/ , 𝑑,𝑑/ are collinear if and only if 𝑏 + 𝑐 + 𝑑 = 0 (without proof)

3-Points-on-line / Collinear

given a set of 𝑜 possibly half-infinite, closed horizontal line segments, is there a non-horizontal separator? Thm: Separator is 3SUM-hard.

Planar Motion Planning

given a set of line segment obstacles in the plane and a line segment robot, decide whether the robot can be moved (allowing translation and rotation) from a given source to a given goal configuration without colliding with the obstacles. Thm: PlanarMotionPlanning is 3SUM-hard.