Sparse Fourier Transform (lecture 4)

Size: px

Start display at page:

Download "Sparse Fourier Transform (lecture 4)"

Dwight Henry
5 years ago
Views:

1 1 / 5 Sparse Fourier Transform (lecture 4) Michael Kapralov 1 1 IBM Watson EPFL St. Petersburg CS Club November 215

2 2 / 5 Given x C n, compute the Discrete Fourier Transform of x: x i = 1 n x j ω ij, j [n] where ω = e 2πi/n is the n-th root of unity.

3 2 / 5 Given x C n, compute the Discrete Fourier Transform of x: x i = 1 n x j ω ij, j [n] where ω = e 2πi/n is the n-th root of unity. Goal: find the top k coefficients of x approximately In previous lectures: exactly k-sparse: O(k logn) runtime and samples

4 Given x C n, compute the Discrete Fourier Transform of x: x i = 1 n x j ω ij, j [n] where ω = e 2πi/n is the n-th root of unity. Goal: find the top k coefficients of x approximately In previous lectures: exactly k-sparse: O(k logn) runtime and samples approximately k-sparse: O(k log 2 n(loglogn)) runtime and samples This lecture, for approximately k-sparse case: k lognlog O(1) logn samples in k log 2 nlog O(1) logn time; O(k logn) samples (optimal). 2 / 5

5 3 / 5 Improvements? List For t = 1 to logk B t Ck/4 t γ t 1/(C2 t ) List List + PARTIALRECOVERY(B t,γ t,list) End

6 3 / 5 Improvements? List For t = 1 to logk B t Ck/4 t γ t 1/(C2 t ) List List + PARTIALRECOVERY(B t,γ t,list) End Summary: independent invocations of PARTIALRECOVERY: use fresh samples in every iteration

7 3 / 5 Improvements? List For t = 1 to logk B t Ck/4 t γ t 1/(C2 t ) List List + PARTIALRECOVERY(B t,γ t,list) End Summary: independent invocations of PARTIALRECOVERY: use fresh samples in every iteration reduce (approximate) sparsity at geometric rate

8 3 / 5 Improvements? List For t = 1 to logk B t Ck/4 t γ t 1/(C2 t ) List List + PARTIALRECOVERY(B t,γ t,list) End Summary: independent invocations of PARTIALRECOVERY: use fresh samples in every iteration reduce (approximate) sparsity at geometric rate need sharp filters to reduce sparsity

9 3 / 5 Improvements? List For t = 1 to logk B t Ck/4 t γ t 1/(C2 t ) List List + PARTIALRECOVERY(B t,γ t,list) End Summary: independent invocations of PARTIALRECOVERY: use fresh samples in every iteration reduce (approximate) sparsity at geometric rate need sharp filters to reduce sparsity lose Ω(logn) time and sparsity because of sharpness

4 / 5 Why not use simpler filters with smaller support? Let { 1/(B +1) if j [ B/2,B/2] G j := o.w. 1.2 1 1.

10 4 / 5 Why not use simpler filters with smaller support? Let { 1/(B +1) if j [ B/2,B/2] G j := o.w time frequency supp(g) = B k as opposed to B k logn, but buckets leak

11 5 / 5 Why not use simpler filters with smaller support? Let { 1/(B +1) if j [ B/2,B/2] G j := o.w time frequency supp(g) = B k as opposed to B k logn, but buckets leak Can only identify and approximate elements of value at least x 2 2 /k, and estimate up to x 2 /k additive error, so need to 2 repeat Ω(logn) times

12 6 / 5 Sample complexity Sample complexity=number of samples accessed in time domain. In some applications at least as important as runtime Shi-Andronesi-Hassanieh-Ghazi- Katabi-Adalsteinsson ISMRM 13

13 6 / 5 Sample complexity Sample complexity=number of samples accessed in time domain. In some applications at least as important as runtime Shi-Andronesi-Hassanieh-Ghazi- Katabi-Adalsteinsson ISMRM 13 Given access to x C n, find ŷ such that x ŷ 2 C min k sparse ẑ x ẑ 2 Use smallest possible number of samples?

14 7 / 5 Uniform bounds (for all): Candes-Tao 6 Rudelson-Vershynin 8 Cheraghchi-Guruswami-Velingker 12 Bourgain 14 Haviv-Regev 15 Non-uniform bounds (for each): Goldreich-Levin 89 Kushilevitz-Mansour 91, Mansour 92 Gilbert-Guha-Indyk-Muthukrishnan- Strauss 2 Gilbert-Muthukrishnan-Strauss 5 Hassanieh-Indyk-Katabi-Price 12a Hassanieh-Indyk-Katabi-Price 12b Deterministic, Ω(n) runtime O(k log 2 k logn) Randomized, O(k poly(logn)) runtime O(k log 2 n) Lower bound: Ω(k log(n/k)) for non-adaptive algorithms Do-Ba-Indyk-Price-Woodruff 1

15 7 / 5 Uniform bounds (for all): Candes-Tao 6 Rudelson-Vershynin 8 Cheraghchi-Guruswami-Velingker 12 Bourgain 14 Haviv-Regev 15 Non-uniform bounds (for each): Goldreich-Levin 89 Kushilevitz-Mansour 91, Mansour 92 Gilbert-Guha-Indyk-Muthukrishnan- Strauss 2 Gilbert-Muthukrishnan-Strauss 5 Hassanieh-Indyk-Katabi-Price 12a Hassanieh-Indyk-Katabi-Price 12b Deterministic, Ω(n) runtime O(k log 2 k logn) Randomized, O(k poly(logn)) runtime O(k log 2 n) Lower bound: Ω(k log(n/k)) for non-adaptive algorithms Do-Ba-Indyk-Price-Woodruff 1 Theorem There exists an algorithm for l 2 /l 2 sparse recovery from Fourier measurements using O(k logn log O(1) logn) samples and O(k log 2 n log O(1) logn) runtime. Optimal up to a poly(loglogn) factors for k n 1 δ.

16 8 / 5 l 2 /l 2 sparse recovery guarantees: x ŷ 2 C min k sparse ẑ x ẑ 2

17 9 / 5 l 2 /l 2 sparse recovery guarantees: x ŷ 2 C Err 2 k ( x) x 1... x k x k+1 x k+2... Err 2 k ( x) = n j=k+1 x j 2 Residual error bounded by noise energy Err 2 k ( x)

18 1 / 5 l 2 /l 2 sparse recovery guarantees: Signal to noise ratio R = x ŷ 2 /Err 2 k ( x) C x 1... x k x k+1 x k+2... Err 2 k ( x) = n j=k+1 x j 2 Residual error bounded by noise energy Err 2 k ( x)

19 1 / 5 l 2 /l 2 sparse recovery guarantees: Signal to noise ratio R = x ŷ 2 /Err 2 k ( x) C x 1... x k x k+1 x k+2... Err 2 k ( x) = n j=k+1 x j 2 Residual error bounded by noise energy Err 2 k ( x) Sufficient to ensure that most elements are below average noise level: x i ŷ i 2 c Err 2 k ( x)/k =: µ2

20 11 / 5 Iterative recovery Many algorithms use the iterative recovery scheme: Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x,ŷ t 1 ) Update ŷ t ŷ t 1 +ẑ Takes random samples of x y PARTIALRECOVERY(x, ŷ) return dominant Fourier coefficients ẑ of x y (approximately) dominant coefficients x i ŷ i 2 µ 2 (above average noise level)

21 12 / 5 PARTIALRECOVERY(x, ŷ) return dominant Fourier coefficients ẑ of x y (approximately) dominant coefficients x i ŷ i 2 µ 2 (above average noise level) Main questions: How many samples per SNR reduction step? How many iterations?

22 12 / 5 PARTIALRECOVERY(x, ŷ) return dominant Fourier coefficients ẑ of x y (approximately) dominant coefficients x i ŷ i 2 µ 2 (above average noise level) Main questions: How many samples per SNR reduction step? How many iterations? Summary of techniques from Gilbert-Guha-Indyk-Muthukrishnan-Strauss 2, Akavia-Goldwasser-Safra 3, Gilbert-Muthukrishnan-Strauss 5, Iwen 1, Akavia 1, Hassanieh-Indyk-Katabi-Price 12a, Hassanieh-Indyk-Katabi-Price 12b

23 13 / 5 1-sparse recovery from Fourier measurements magnitude.5 magnitude time frequency x a = ω a f +noise 2πf /n O(log SNR n) measurements for random a

24 14 / 5 Reducing k-sparse recovery to 1-sparse recovery Permute with a random linear transformation and phase shift magnitude.5.5 magnitude time frequency

25 15 / 5 Reducing k-sparse recovery to 1-sparse recovery Permute with a random linear transformation and phase shift magnitude.5.5 magnitude time frequency

26 16 / 5 Reducing k-sparse recovery to 1-sparse recovery Permute with a random linear transformation and phase shift magnitude.5.5 magnitude time frequency

27 17 / 5 Reducing k-sparse recovery to 1-sparse recovery Partition frequency space into B = k/α buckets for constant α (,1) magnitude.5.5 magnitude time frequency Choose a filter G,Ĝ such that Ĝ approximates the buckets G has small support Compute x Ĝ = (x G)

28 18 / 5 Reducing k-sparse recovery to 1-sparse recovery Partition frequency space into B = k/α buckets for constant α (,1) magnitude.5.5 magnitude time frequency Choose a filter G,Ĝ such that Ĝ approximates the buckets G has small support Compute x Ĝ = (x G)

29 19 / 5 Reducing k-sparse recovery to 1-sparse recovery Partition frequency space into B = k/α buckets for constant α (,1) magnitude.5.5 magnitude time frequency Choose a filter G,Ĝ such that Ĝ approximates the buckets G has small support Compute x Ĝ = (x G)

30 2 / 5 Reducing k-sparse recovery to 1-sparse recovery Partition frequency space into B = k/α buckets for constant α (,1) magnitude.5.5 magnitude time frequency Choose a filter G,Ĝ such that Ĝ approximates the buckets G has small support Compute x Ĝ = (x G) Sample complexity=supp G!

31 21 / 5 PARTIALRECOVERY step PARTIALRECOVERY(x, ŷ) Make measurements (independent permutation+filtering) Locate and estimate large frequencies (1-sparse recovery) return dominant Fourier coefficients ẑ of x y (approximately) Sample complexity = support of G

32 21 / 5 PARTIALRECOVERY step PARTIALRECOVERY(x, ŷ) Make measurements (independent permutation+filtering) Locate and estimate large frequencies (1-sparse recovery) return dominant Fourier coefficients ẑ of x y (approximately) Sample complexity = support of G How many measurements do we need? How effective is a refinement step? Both determined by signal to noise ratio in each bucket function of filter choice

33 Time domain: support O(k) [GMS 5] Frequency domain: 22 / magnitude frequency SNR = O(1) Reduce SNR by O(1) factor Ω(k log 2 n) samples

34 Time domain: support O(k) [GMS 5] Frequency domain: Time domain: support Θ(k logn) [HIKP12] Frequency domain: 23 / magnitude.6.4 magnitude frequency SNR = O(1) Reduce SNR by O(1) factor Ω(k log 2 n) samples frequency SNR = can by poly(n) Reduce sparsity by O(1) factor Ω(k log 2 n) samples This paper: interpolate between the two extremes, get all benefits

35 24 / 5 Main idea A new family of filters that adapt to current upper bound on SNR. Sharp filters initially, more blurred later magnitude.6.4 magnitude.6.4 magnitude frequency frequency frequency

36 / magnitude.6.4 magnitude.6.4 magnitude frequency frequency frequency When SNR is bounded by R: filter support O(k logr) ( convolve boxcar with itself logr times)

37 / magnitude.6.4 magnitude.6.4 magnitude frequency frequency frequency When SNR is bounded by R: filter support O(k logr) ( convolve boxcar with itself logr times) (most) 1-sparse recovery subproblems for dominant frequencies have high SNR (about R) so O (log R n) measurements! O (k logr log R n) = O (k logn) samples per step!

38 26 / 5 PARTIALRECOVERY(x, ŷ, R) R R 1/2 R 1/4... C 2 C }{{} O(loglogn) iterations R µ 2 R 1 2 µ 2 k µ 2 = tail noise/b

39 26 / 5 PARTIALRECOVERY(x, ŷ, R) R R 1/2 R 1/4... C 2 C }{{} O(loglogn) iterations R µ 2 R 1 2 µ 2 k µ 2 = tail noise/b

40 26 / 5 PARTIALRECOVERY(x,ŷ,R 1 2 ) R R 1/2 R 1/4... C 2 C }{{} O(loglogn) iterations R 1 2 µ 2 R 1 4 µ 2 k µ 2 = tail noise/b

41 26 / 5 PARTIALRECOVERY(x,ŷ,C 2 ) R R 1/2 R 1/4... C 2 C }{{} O(loglogn) iterations C 2 µ 2 C µ 2 k µ 2 = tail noise/b

42 27 / 5 Algorithm Input: x C n ŷ R poly(n) For t = 1 to O(loglogn) ẑ PARTIALRECOVERY(x,ŷ t 1,R t 1 ) Takes samples of x y Update ŷ t ŷ t 1 +ẑ R t R t 1 PARTIALRECOVERY step: Takes O (k logn) samples independent of R Is very effective: reduces R R 1 2, so O(loglogn) iterations suffice

43 28 / 5 Partial recovery analysis PARTIALRECOVERY(x, ŷ, R) R µ 2 R 1 2 µ 2 k µ 2 = tail noise/b Need to reduce most large frequencies, i.e. x i 2 Rµ 2

44 28 / 5 Partial recovery analysis PARTIALRECOVERY(x, ŷ, R) R µ 2 R 1 2 µ 2 k µ 2 = tail noise/b Need to reduce most large frequencies, i.e. x i 2 Rµ 2 Most=1 1/poly(R) fraction

45 28 / 5 Partial recovery analysis PARTIALRECOVERY(x, ŷ, R) R µ 2 R 1 2 µ 2 k µ 2 = tail noise/b Need to reduce most large frequencies, i.e. x i 2 Rµ 2 Most=1 1/poly(R) fraction Iterative process, O(loglogn) steps

46 29 / 5 R µ 2 R 1 2 µ 2 k µ 2 = tail noise/b partition elements into geometric weight classes write down recursion that governs the dynamics top half classes are reduced at double exponentialy rate if we use Ω(loglogR) levels

47 Sample optimal algorithm (reusing measurements) 3 / 5

48 31 / 5 Uniform bounds (for all): Candes-Tao 6 Rudelson-Vershynin 8 Cheraghchi-Guruswami-Velingker 12 Bourgain 14 Haviv-Regev 15 Non-uniform bounds (for each): Goldreich-Levin 89 Kushilevitz-Mansour 91, Mansour 92 Gilbert-Guha-Indyk-Muthukrishnan- Strauss 2 Gilbert-Muthukrishnan-Strauss 5 Hassanieh-Indyk-Katabi-Price 12a Hassanieh-Indyk-Katabi-Price 12b Indyk-K.-Price 14 Deterministic, Ω(n) runtime O(k log 2 k logn) Randomized, O(k poly(logn)) runtime O(k logn (loglogn) C ) Lower bound: Ω(k log(n/k)) for non-adaptive algorithms Do-Ba-Indyk-Price-Woodruff 1

49 31 / 5 Uniform bounds (for all): Candes-Tao 6 Rudelson-Vershynin 8 Cheraghchi-Guruswami-Velingker 12 Bourgain 14 Haviv-Regev 15 Non-uniform bounds (for each): Goldreich-Levin 89 Kushilevitz-Mansour 91, Mansour 92 Gilbert-Guha-Indyk-Muthukrishnan- Strauss 2 Gilbert-Muthukrishnan-Strauss 5 Hassanieh-Indyk-Katabi-Price 12a Hassanieh-Indyk-Katabi-Price 12b Indyk-K.-Price 14 Deterministic, Ω(n) runtime O(k log 2 k logn) Randomized, O(k poly(logn)) runtime O(k logn (loglogn) C ) Lower bound: Ω(k log(n/k)) for non-adaptive algorithms Do-Ba-Indyk-Price-Woodruff 1 Theorem There exists an algorithm for l 2 /l 2 sparse recovery from Fourier measurements using O(k logn) samples and O(nlog 3 n) runtime. Optimal up to constant factors for k n 1 δ.

50 32 / 5 Higher dimensional Fourier transform is needed in some applications Given x C [n]d, N = n d, compute x j = 1 ω it j x i and x j = 1 N i [n] d N i [n] d ω it j x i where ω is the n-th root of unity, and n is a power of 2.

51 33 / 5 Previous sample complexity bounds: O(k log d N) in sublinear time algorithms runtime k log O(d) N, for each O(k log 4 N) for any d Ω(N) time, for all This lecture: Theorem There exists an algorithm for l 2 /l 2 sparse recovery from Fourier measurements using O d (k logn) samples and O(N log 3 N) runtime. Sample-optimal up to constant factors for any constant d.

52 34 / 5 l 2 /l 2 sparse recovery guarantees: x ŷ 2 C min k sparse ẑ x ẑ 2 head tail µ tail noise/ k

53 35 / 5 l 2 /l 2 sparse recovery guarantees: x ŷ 2 C min k sparse ẑ x ẑ 2 x 1... x k x k+1 x k+2... Err 2 k ( x) = n j=k+1 x j 2 Residual error bounded by noise energy Err 2 k ( x) head tail µ tail noise/ k

54 l 2 /l 2 sparse recovery guarantees: 36 / 5 x ŷ 2 C Err 2 k ( x) x 1... x k x k+1 x k+2... Err 2 k ( x) = n j=k+1 x j 2 Residual error bounded by noise energy Err 2 k ( x) head tail µ tail noise/ k

55 l 2 /l 2 sparse recovery guarantees: 37 / 5 x ŷ 2 C Err 2 k ( x) x 1... x k x k+1 x k+2... Err 2 k ( x) = n j=k+1 x j 2 Residual error bounded by noise energy Err 2 k ( x) head tail µ tail noise/ k

56 l 2 /l 2 sparse recovery guarantees: 38 / 5 x ŷ 2 C Err 2 k ( x) µ tail noise/ k Sufficient to ensure that most elements are below average noise level: x i ŷ i 2 c Err 2 k ( x)/k =: µ2

57 39 / 5 l 2 /l 2 sparse recovery guarantees: x ŷ 2 C Err 2 k ( x) µ tail noise/ k Will ensure that all elements are below average noise level: x ŷ 2 c Err2 k ( x)/k =: µ2

58 4 / 5 l /l 2 sparse recovery guarantees: x ŷ 2 C Err2 k ( x)/k µ tail noise/ k Will ensure that all elements are below average noise level: x ŷ 2 c Err2 k ( x)/k =: µ2

59 41 / 5 l /l 2 sparse recovery guarantees: x ŷ 2 C Err2 k ( x)/k µ tail noise/ k Will ensure that all elements are below average noise level: x ŷ 2 µ2

60 42 / 5 Iterative recovery Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x y t 1 ) Takes random samples of x y Update ŷ t ŷ t 1 +ẑ

61 42 / 5 Iterative recovery Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x y t 1 ) Takes random samples of x y Update ŷ t ŷ t 1 +ẑ In most prior works sampling complexity is samples per PARTIALRECOVERY step number of iterations

62 42 / 5 Iterative recovery Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x y t 1 ) Takes random samples of x y Update ŷ t ŷ t 1 +ẑ In most prior works sampling complexity is samples per PARTIALRECOVERY step number of iterations Lots of work on carefully choosing filters, reducing number of iterations: Hassanieh-Indyk-Katabi-Price 12, Ghazi-Hassanieh-Indyk-Katabi-Price-Shi 13, Indyk-K.-Price 14 still lose Ω(loglogn) in sample complexity (number of iterations) lose Ω((logn) d 1 loglogn) in higher dimensions

63 43 / 5 Iterative recovery Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x y t 1 ) Takes random samples of x y Update ŷ t ŷ t 1 +ẑ Our sampling complexity is samples per PARTIALRECOVERY step number of iterations

64 43 / 5 Iterative recovery Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x y t 1 ) Takes random samples of x y Update ŷ t ŷ t 1 +ẑ Our sampling complexity is samples per PARTIALRECOVERY step number of iterations

65 43 / 5 Iterative recovery Input: x C n ŷ For t = 1 to L ẑ PARTIALRECOVERY(x y t 1 ) Takes random samples of x y Update ŷ t ŷ t 1 +ẑ Our sampling complexity is samples per PARTIALRECOVERY step number of iterations Can use very simple filters!

66 44 / 5 Our filter=boxcar convolved with itself O(1) times Filter support is O(k) (=samples per measurement) O(k logn) samples in PARTIALRECOVERY step magnitude.3.2 magnitude time frequency Can choose a rather weak filter, but do not need fresh randomness

67 44 / 5 Our filter=boxcar convolved with itself O(1) times Filter support is O(k) (=samples per measurement) O(k logn) samples in PARTIALRECOVERY step magnitude.3 magnitude time frequency Can choose a rather weak filter, but do not need fresh randomness

68 44 / 5 Our filter=boxcar convolved with itself O(1) times Filter support is O(k) (=samples per measurement) O(k logn) samples in PARTIALRECOVERY step magnitude.25.2 magnitude time frequency Can choose a rather weak filter, but do not need fresh randomness

69 45 / 5 G B B B Let y m (P m x) G m =,...,M = C logn ẑ For t = 1,...,T = O(logn): For f [n]: { ŵ f median ỹ 1 f,...,ỹm f If ŵ f < 2 T t µ/3 then ŵ f End ẑ t+1 = ẑ t +ŵ y m y m (P m w) G for m = 1,...,M End } Take samples of x Loop over thresholds Estimate, prune small elements Update samples

70 G B B B Let y m (P m x) G m =,...,M = C logn 45 / 5 ẑ For t = 1,...,T = O(logn): For f [n]: { ŵ f median ỹ 1 f,...,ỹm f If ŵ f < 2 T t µ/3 then ŵ f End ẑ t+1 = ẑ t +ŵ y m y m (P m w) G for m = 1,...,M End } µ

71 G B B B Let y m (P m x) G m =,...,M = C logn 45 / 5 ẑ For t = 1,...,T = O(logn): For f [n]: { ŵ f median ỹ 1 f,...,ỹm f If ŵ f < 2 T t µ/3 then ŵ f End ẑ t+1 = ẑ t +ŵ y m y m (P m w) G for m = 1,...,M End } µ

72 G B B B Let y m (P m x) G m =,...,M = C logn 45 / 5 ẑ For t = 1,...,T = O(logn): For f [n]: { ŵ f median ỹ 1 f,...,ỹm f If ŵ f < 2 T t µ/3 then ŵ f End ẑ t+1 = ẑ t +ŵ y m y m (P m w) G for m = 1,...,M End } µ

73 G B B B Let y m (P m x) G m =,...,M = C logn 45 / 5 ẑ For t = 1,...,T = O(logn): For f [n]: { ŵ f median ỹ 1 f,...,ỹm f If ŵ f < 2 T t µ/3 then ŵ f End ẑ t+1 = ẑ t +ŵ y m y m (P m w) G for m = 1,...,M End } µ

74 G B B B Let y m (P m x) G m =,...,M = C logn 45 / 5 ẑ For t = 1,...,T = O(logn): For f [n]: { ŵ f median ỹ 1 f,...,ỹm f If ŵ f < 2 T t µ/3 then ŵ f End ẑ t+1 = ẑ t +ŵ y m y m (P m w) G for m = 1,...,M End } µ

75 46 / 5 Lecture so far Optimal sample complexity by reusing randomness Very simple algorithm, can be implemented Extension to higher dimensions: algorithm is the same, permutations are different. Choose random invertible linear transformation over Z d n

76 47 / 5 Experimental evaluation Problem: recover support of a random k-sparse signal from Fourier measurements. Parameters: n = 2 15, k = 1,2,...,1 Filter: boxcar filter with support k + 1

77 Comparison to l 1 -minimization (SPGL1) O(k log 3 k logn) sample complexity, requires LP solve 25 n=32768, L1 minimization 1 25 n=32768, B=k, random phase, non monotone number of measurements number of measurements sparsity sparsity Within a factor of 2 of l 1 minimization 48 / 5

78 49 / 5 Open questions: O(k logn) in O(k log 2 n) time? O(k logn) runtime? remove dependence on dimension? Current approaches lose C d in sample complexity, (logn) d in runtime

79 49 / 5 Open questions: O(k logn) in O(k log 2 n) time? O(k logn) runtime? remove dependence on dimension? Current approaches lose C d in sample complexity, (logn) d in runtime More on sparse FFT:

Sample Optimal Fourier Sampling in Any Constant Dimension

1 / 26 Sample Optimal Fourier Sampling in Any Constant Dimension Piotr Indyk Michael Kapralov MIT IBM Watson October 21, 2014 Fourier Transform and Sparsity Discrete Fourier Transform Given x C n, compute