1. On Approximating the Number of Relevant Variables in a Function
Dana Ron Gilad Tsur
Tel-Aviv University

2. What We'd Like to Do We're given oracle access to a function f.
Consider f:{0,1}n→{0,1}, although any discrete domain and range will be OK.
We'd like to know how many variables influence f.
We'd like to perform o(2n) queries, and would prefer as few as possible .
∣{ 𝑥 𝑖 𝑠.𝑡.∃ 𝑥 1, ..., 𝑥 𝑛 :𝑓 𝑥 1,. .. 𝑥 𝑖 ,..., 𝑥 𝑛 ≠𝑓 𝑥 1,. ..¬ 𝑥 𝑖 ,..., 𝑥 𝑛 }∣

3. But That Can't Be Done
Consider a constant 0 function contrasted with a function g such that for single, unknown x, g(x) = 1 and g(y) = 0 otherwise.
This shows we can't even give a good approximation of the number of variables in general.
So we consider relaxations:
Multiplicative approximation in the Property- Testing setting.
Multiplicative approximation for particular families of functions.

4. What Others Have Done - Testing Juntas
Testing Juntas: accept functions with at most k relevant variables ("k-Juntas"), and reject those ε-far from every k-junta.
Fischer, Kindler, Ron, Safra and Samorodnitsky give an Õ(k2/ε) queries algorithm, improved by Blais to O(k/ε + k log(k)) queries.
Chockler and Gutfreund give an Ω(k) Lower bound, improved by Blais to min(Ω(k/ε), 2k/k)(up to polylog factors).

5. What We Do: Upper Bounds
Distinguish between linear functions with k relevant variables, and those with more than (1+γ)k, using O(log(1/γ)/γ2) queries.
Do same for degree d polynomials, using O(2dlog(1/γ)/γ2) queries.
Distinguish between k-Juntas and functions ε-far from every (1+γ)k-junta using O(klog(1/γ)/εγ2) queries.
Techniques: We use tools developed in previous junta- testing papers, and some properties of variable influence.

6. What We Do: Lower Bounds
k-Juntas vs.
ε-far from (1+γ)k-junta
(ε,γ- constant).
Ω(k/log(k))
Degree-d polynomial k-Juntas vs.
ε-far from degree-d polynomial (1+γ)k-Juntas.
Ω(2d/d)
A weaker lower bound for Monotone functions.
Techniques: We use a reduction from the Distinct Elements problem.
Recently, Blais, Brody and Matulef showed that distinguishing between k-juntas and (k+t)-juntas requires Ω(min(k2/t2,k)-log(k)).

7. Linear Functions
Imagine we want to know if a linear function f has fewer than k or more than 2k variables.
We can select a subset of variables S, adding each variable to S with probability 1/2k.
Testing whether S contains a relevant variable is easy as f is linear.
This takes a constant number of queries.
Distinguishing between a linear functions with k variables and those with k+t requires Ω(min(k2/t2,k)-log(k)) [Blais, Brody and Matulef].
f( )
f( )
f( )
f( )

8. Linear Functions and More
Extends to deciding whether a linear function has k relevant variables, or more than (1+γ)k, using O(log(1/γ)/γ2) queries.
Can also extend to polynomials with degree d using O(2dlog(1/γ)/γ2) queries.
[Recall the 2d factor is required]
We basically use the fact that each relevant variable has significant influence.

9. General Functions Given a function f:
accept if f is influenced by at most k variables.
reject if f is ε-far from every function influenced by at most (1+γ)k variables.
We do this using O(klog(1/γ)/εγ2) queries.
This is, again, done by taking a subset of the variables and checking if they influence the function. This is more likely to happen if we're far from (1+γ)k juntas.
The difference from linear functions is that when influence is divided among many variables we must still capture sufficient influence in the selected subset.

10. Lower Bound: The Distinct Elements Problem
We use a reduction from the Distinct Elements problem:
Given random access to a string, approximate the number of different elements in it (think of each element as a color).
Similar to approximating the support of a distribution (under certain conditions).
Approximating the support of a distribution - Valiant and Valiant, improving on Raskhodnikova, Ron, Shpilka and Smith: t/log(t) queries are required to distinguish :
length t string with t/2 distinct elements
from
length t string with t/16 distinct elements

11. Lower Bound: Reduction example

12. Lower Bound: The Reduction I
We'll describe the reduction for k = Θ(n). (recall that we'll give a k/log(k) lower bound)
We'll reduce strings with m distinct elements to functions in a family Fnm.
Each function in Fnm depends on log(n) + m of the variables.
The first log(n) varibles index one of the m variables, and that determines the value of f.
For Ψ: {0,1}log(n) → [0,n-log(n)] We have
f(x1,...,xn) = xlog(n) + Ψ(x1...xlog(n)).

13. Lower Bound: The Reduction II
For a string s of length n, we have colors s[i][1,..., n-log(n)] .
The string s maps to a function f. The first log(n) bits of f's input map to locations in the string. The rest, sequentially to colors.
In our reduction we map colors sequentially to input bits (e.g., the color 1 to xlog(n)+1, 2 to xlog(n)+2...).
Consider the string s= Length is 8, and the number of colors is, say, in the range
The variables of the function will be: x1x2x3x4x5x6x7x8
Example: f( )=0: 001 location 2, color 2, Bit 5 is 0.
Example: f( )=0: 010 location 3, color 2, Bit 5 is 0.
Example: f( )=1: 110 location 7, color 1, Bit 4 is 1.

14. Lower Bound: The Reduction III
Strings with n/16 colors will be mapped to functions with fewer than n/8 relevant variables.
Strings with n/2 colors will be mapped to functions that are far from n/4-juntas. [Can be shown that f in Fnt/2 is ε-far from all t/4-juntas for a constant ε. ].
As it takes us Ω(k/log(k)) queries to distinguish the strings, the same holds for the functions.

15. Summary
k-Juntas vs. functions ε-far from every (1+γ)k-junta: O(klog(1/γ)/εγ2) queries.
Degree d polynomials with k relevant variables vs. those with more than (1+γ)k: O(2dlog(1/γ)/γ2) queries.
Lower bound of Ω(k/log(k)) queries for k-Juntas vs. functions ε-far from every (1+γ)k-junta (for constant ε and γ).
Lower bound of Ω(2d/d) queries for degree-d polynomials with k relevant variables where
d < log(k) vs. functions ε-far from every such polynomial with more than (1+γ)k relevant variables.