DeepAI

# Hardness of Sparse Sets and Minimal Circuit Size Problem

We develop a polynomial method on finite fields to amplify the hardness of spare sets in nondeterministic time complexity classes on a randomized streaming model. One of our results shows that if there exists a 2^n^o(1)-sparse set in NTIME(2^n^o(1)) that does not have any randomized streaming algorithm with n^o(1) updating time, and n^o(1) space, then NEXP≠BPP, where a f(n)-sparse set is a language that has at most f(n) strings of length n. We also show that if MCSP is ZPP-hard under polynomial time truth-table reductions, then EXP≠ZPP.

07/23/2020

### Lower Bounds and Hardness Magnification for Sublinear-Time Shrinking Cellular Automata

The minimum circuit size problem (MCSP) is a string compression problem ...
02/21/2022

### Time complexity of the Analyst's Traveling Salesman algorithm

The Analyst's Traveling Salesman Problem asks for conditions under which...
08/30/2022

### On Sparse Hitting Sets: from Fair Vertex Cover to Highway Dimension

We consider the Sparse Hitting Set (Sparse-HS) problem, where we are giv...
06/02/2021

### The Hardest Explicit Construction

We investigate the complexity of explicit construction problems, where t...
10/26/2017

### Minimum Circuit Size, Graph Isomorphism, and Related Problems

We study the computational power of deciding whether a given truth-table...
01/17/2018

### Nonuniform Reductions and NP-Completeness

Nonuniformity is a central concept in computational complexity with powe...
07/25/2021

### Logspace Reducibility From Secret Leakage Planted Clique

The planted clique problem is well-studied in the context of observing, ...

## 1 Introduction

Hardness amplification has been intensively studied in the recent years [12, 3, 9, 11]. A small lower bound such as for one problem may bring a large lower bound such as super-polynomial lower for another problem. This research is closely related to Minimum Circuit Size Problem (MCSP) that is to determine if a given string of length with integer can be generated by a circuit of size . For a function , is that given a string of length , determine if there is a circuit of size at most to generate . This problem has received much attention in the recent years [2, 1, 12, 7, 6, 5, 4, 3, 11, 10, 9].

Hardness magnification results are shown in a series of recent papers about MCSP [12, 3, 9, 11]. Oliveira and Santhanam [12] show that -size lower bounds for approximating with error implies . Oliveira, Pich and Santhanam [11] show that for all small , -size lower bounds for approximating with factor error implies . McKay, Murray, and Williams [9] show that an lower bound on space deterministic streaming model for implies separation of P from NP.

The hardness amplification of non-uniform complexity for sparse sets is recently developed by Chen, Jin and Williams [3]. Since are of sub-exponential density for , the hardness amplification for sub-exponential density sets is more general than the hardness amplification for . They show that if there is an and a family of languages (indexed over ) such that each is a -sparse language in , and , then for all , where is the class of languages with nonuniform circuits of size bounded by function . Their result also holds for all complexity classes with .

On the other hand, it is unknown if MCSP is NP-hard. Murray and Williams [10] show that NP-completeness of MCSP implies the separation of EXP  from ZPP, a long standing unsolved problem in computational complexity theory. Hitchcock and Pavan [7, 10] if MCSP is -hard under polynomial time truth-table reductions, then EXP.

Separating NEXP from BPP, and EXP from ZPP  are two of major open problems in the computational complexity theory. We are motivated by further relationship about sparse sets and MCSP, and the two separations and . We develop a polynomial method on finite fields to amplify the hardness of spare sets in nondeterministic time complexity classes over a randomized streaming model. One of our results show that if there exists a -sparse set in that does not a randomized streaming algorithm with updating time, and space, then , where a -sparse set is a language that has at most strings of length . Our magnification result has a flexible trade off between the spareness and time complexity.

We use two functions and to control the sparseness of a tally set . Function gives an upper bound for the number of elements of in and is the gap lower bound between a string and the next string in , which satisfy . The class defines the class of all those tally sets. By choosing , and , we prove that MCSP is -hard under polynomial time truth-table reductions implies .

### 1.1 Comparison with the existing results

Comparing with some existing results about sparse sets hardness magnification in this line [3], there are some new advancements in this paper.

1. Our amplification of sparse set is based on a uniform streaming model. A class of results in [3] are based on nonuniform models. In [9], they show that if there is , and a function , search- does not have updating time in deterministic streaming model for all positive, then . is a -sparse set.

2. Our method is conceptually simple, and easy to understand. It is a polynomial algebraic approach on finite fields.

3. A flexible trade off between sparseness and time complexity is given in our paper.

Proving NP-hardness for MCSP implies  [7, 10]. We consider the implication of ZPP-hardness for , and show that if MCSP is -hard for a function pair such as and , then . It seems that proving MCSP is -hard is much easier than proving MCSP is NP-hard since . According to the hierarch theory developed by Schöning [13], the class is the low class . Although may not be in the class , it is possible to be -hard.

## 2 Notations

Minimum Circuit Size Problem (MCSP) is that given an integer , and string of length , determine if can be generated by a circuit of size . Let be the set of all natural numbers.

Let

be the class of languages accepted by deterministic Turing machines in time

. Let be the class of languages accepted by nondeterministic Turing machines in time . Define and .

We use a polynomial method on a finite field . It is classical theory that each finite field is of size for some prime number and integer (see [8]). For a finite field , we denote to represent , where is a irreducible polynomial over field for the prime number and its degree is . The polynomial is equal to the unit if is of size , which is a prime number. Each element of with is a polynomial with degree less than the degree of . For two elements and in , their addition is defined by , and their multiplication is defined by (see [8]).

We use field in our randomized streaming algorithm for hardness amplification. Let be field, a field of size and has its . Let be a binary string of length with , and be a variable. Define be the element in . Let be a string in and be an integer at least . Let such that each is a substring of of length for , and the substring has its length . Each is called a -segment of for . Define the polynomial , which converts a binary string into a polynomial in .

We develop a streaming algorithm that converts an input string into an element in a finite field. We give the definition to characterize the properties of the streaming algorithm developed in this paper. Our streaming algorithm is to convert an input stream into an element by selecting a random element from .

###### Definition 1

Let be nondecreasing functions from to . Define to be the class of languages that have streaming algorithms that has input with ( is a string and read by streaming), it satisfies

1. It takes time to generate a field , where is represented by a irreducible polynomial over of degree .

2. It takes random steps before reading the first bit from the input stream .

3. It takes field conversion to elements in and field operations in after reading each bit.

4. It uses space that includes the space to hold the field representation generated by the algorithm. The space for a field representation is and for the irreducible polynomial over .

5. It runs randomized steps after reading the entire input.

## 3 Overview of Our Methods

In this section, we give a brief description about our methods used in this paper. Our first result is based on a polynomial method method on a finite field whose size affects the hardness of amplification. The second result is a translational method for zero-error probabilistic complexity classes.

### 3.1 Amplify the hardness of sparse sets

We have a polynomial method over finite fields. Let be -sparse language in . In order to handle an input string of size , a finite field with for some prime number and integer is selected, and is represented by , where is a irreducible polynomial over . An input is partitioned into -segments such that each is converted into an element in , and is transformed into an polynomial . A random element is chosen in the beginning of streaming algorithm before processing the input stream. The value is evaluated with the procession of input stream. The finite is large enough such that for different and of the same length, their polynomials and are different. Let be the set of all with and . Set is the union of all with . The set of is . A small lower bound for the language is amplified to large lower bound for .

The size of field depends on the density of set and is . By the construction of , if , there are tuples in that are generated by via all in . For two different and of length , the intersection is bounded by the degree of . If , the number of items generated by is at most in . If , the number of items generated by is in . This enables us to convert a string of in into some strings in of length much smaller than , make the hardness amplification possible.

### 3.2 Separation by ZPP-hardness of MCSP

Our another result shows that ZPP-hardness for MCSP implies

. We identify a class of functions that are padding stable, which has the property if

, then . The function pair and has this property. We construct a very sparse tally set that separates from , where is the zero error exponential time probabilistic class. It is based on a diagonal method that is combined with a padding design. A tally language has a zero-error -time probabilistic algorithm implies has a zero-error -time probabilistic algorithm. Adapting to the method of [10], we prove that if MCSP is -hard under polynomial time truth-table reductions, then .

## 4 Hardness Magnification via Streaming

In this section, we show a hardness magnification of sparse sets via streaming algorithm. A classical algorithm to find irreducible polynomial [14] is used to construct a field that is large enough for our algorithm.

###### Theorem 2

[14] There is a deterministic algorithm that constructs a irreducible polynomial of degree in operations in , where is a finite field with prime number .

###### Definition 3

Let be a function from to . For a language , we say is -sparse if for all large integer , where and .

### 4.1 Streaming Algorithm

The algorithm Streaming(.) is based on a language that is -sparse. It generates a field and evaluates with a random element in . A polynomial can be evaluated by according to the classical algorithm.

Algorithm

Streaming()

Input: an integer , and string of the length ;

Steps:

1. Select a field size such that .

2. Generate an irreducible polynomial of degree over to represent finite (by Theorem 2 with );

3. Let be a random element in ;

4. Let ; (Note that is the number of -segments of . See Section 2)

5. Let ;

6. Let ;

7. Repeat

8. {

9. Receive the next -segment from the input stream ;

10. Convert into an element in ;

11. Let ;

12. Let ;

}

13. Until (the end of the stream);

14. Output ;

End of Algorithm

Now we have our amplification algorithm. Let be a randomized Turing machine to accept a language that contains all with and . We have the following randomized streaming algorithm to accept via the randomized algorithm for .

Algorithm

Amplification()

Input integer and as a stream;

Steps:

1. Let Streaming();

2. Accept if accepts;

End of Algorithm

### 4.2 Hardness Amplification

In this section, we derive some results about hardness amplification via sparse set. Our results show a trade off between the hardness amplification and sparseness via the streaming model.

###### Definition 4
• For a nondecreasing function , define the class of languages that have bounded two-side error probabilistic algorithms with time complexity .

• .

###### Theorem 5

Assume that be nondecreasing function for the time to generate an irreducible polynomial of degree in , and be the nondecreasing function of a time upper bound for the operations of polynomials of degree at most in . Let be nondecreasing functions with , and for all large . If there is a -sparse set with and , then there is a language such that and .

Proof:  Select a finite field with for an integer that satisfies as in the algorithm streaming(.). For each and integer , let be partitioned into -segments: . Let convert into an element of (See Section 2). Define polynomial . For each , let be the set , where . Define set for , and language .

Claim 1. For any with , we have .

Proof:  Assume that for some with , . It is easy to see that and for all large by the algorithm Streaming(.) and the condition of in the theorem. Assume that for every . Since is the union with and , there are at most elements in by line 1 of the algorithm Streaming(.). Thus, . This brings a contradiction. Therefore, there is a to have . Since the polynomials and are of degrees at most , we have . Thus, . This brings a contradiction because and .

Claim 2. If , then Streaming

. Otherwise, with probability at most

, Streaming.

Proof:  For each , it generates for a random . Each determines a random path. We have that if , then , and if , then with probability at most by Claim 1.

Claim 3. .

Proof:  Let . For each , we need to guess a string such that . It is easy to see that if . Let . It takes at most steps to generate a irreducible polynomial for the field by our assumption.

Since , checking if takes nondeterministic steps to guess a string and additional deterministic steps (note is already provided) to evaluate in by following algorithm Streaming(.) and check . The polynomial generated in the has degree at most during the algorithm. Each polynomial operation ( or ) in takes at most steps . Since time, we have .

Claim 4. . Furthermore, the streaming algorithm takes time randomized time in total.

Proof:  The field generated at line 2 in algorithm Streaming(.) takes time by Theorem 2.

Let be the input string. The string partitioned into -segments . Transform each into an element in in the streaming algorithm. We generate a polynomial . Given a random element , we evaluate according to the classical algorithm. Therefore, is evaluated in Streaming(.) with input .

If , then has a randomized streaming algorithm that has at most random bits after reading the input, and at most space. After reading one substring from , it takes one conversion from substring of the input to the field, and at most two field operations by line 11 in the algorithm Streaming(.).

Claim 4 brings a contradiction to our assumption about the complexity of in the theorem. This proves the theorem.

###### Proposition 6

Let be a nondecreasing function. If for each fixed , for all large , then there is a nondecreasing unbounded function with .

Proof: Let . For each , let be the least integer such that for all . Clearly, we have the infinite list such that . Define function such that for all . For each , we have .

Our Definition 7 is based Proposition 6. It can simplify the proof when we handle a function that is .

###### Definition 7
• A function is if there is a nondecreasing function such that and for all large .

• A function is if there is a nondecreasing function such that and for all large .

###### Corollary 8

If there exists a -sparse language in such that does not have any randomized streaming algorithm with updating time, and space, then .

Proof:  Let be an arbitrary unbounded nondecreasing function that satisfies and . Let and Let , and .

It is easy to see that , and both and are . For any fixed , we have for all large . Clearly, the two functions and satisfy the inequality of the precondition in Theorem  5. For all large , we have

 t3(8(logn+logf(n)) ≤ t3(16logf(n))=t3(16n1g(n)) (1) ≤ (16n1g(n))√g(16n1g(n)) (2) ≤ (n2g(n))√g(n)=no(1). (3)

Assume . With space, we have a field representation with . Thus, each field operation takes time by the brute force method for polynomial addition and multiplication. We have by inequality (3). Thus, the streaming algorithm updating time is . Therefore, we have that has a randomized streaming algorithm with updating time, and space. This gives a contradiction. So, . By Theorem 5, there is such that . Therefore, . Thus, .

## 5 Implication of ZPP-Hardness of MCSP

In this section, we show that if MCSP is -hard, then . The conclusion still holds if  is replaced by a very sparse subclass of languages.

###### Definition 9
• For a nondecreasing function , define the class of languages that have zero-error probabilistic algorithms with time complexity .

• .

• .

###### Definition 10
• For a function , define be the class of tally set such that for each , there is an integer with .

• For a tally language , define .

###### Definition 11

For two languages and , a polynomial time truth-table reduction from to is a polynomial time computable function such that for each instance for , to satisfy if and only if , where is circuit of input bits and

is the characteristic function of

.

Let be a type of polynomial time reductions ( represents polynomial time truth-table reductions), and be a class of languages. A language is -hard under reductions if for each , .

###### Definition 12

Let be an integer. Define two functions

1. , and .

2. , and .

###### Definition 13

For two nondecreasing functions , the pair is time constructible if can be computed in time steps.

###### Definition 14

Define to be the class of tally sets such that and for any two strings with , they satisfy . We call to be the density function and to be the gap function. A gap function is padding stable if for all .

###### Lemma 15
1. Assume the gap function is padding stable. If , then .

2. For each integer , is padding stable.

Proof:  Let be a string in . The next shortest string with satisfies . We have and are two consecutive neighbor strings in such that there is no other string with . We have . Since the strings in are one-one mapped from the strings in with length less than , , we have . This proves Part (i).

We have inequality . Therefore, gap function is padding stable. This proves Part (ii).

###### Lemma 16

Let and be nondecreasing unbounded functions from to , and is time constructible. Then there exists a time constructible increasing unbounded function such that .

Proof: Compute the least integer with . Let be the number of steps for the computation. Define . Assume that has been defined. We determine the function value below.

For an integer , compute and the least numbers such that . Assume the computation above takes steps. Define to be the . For each language , there are at most strings in with length at most . On the other hand, by the increasing list . Therefore, we have . Furthermore, we also have . Since is the number of steps to determine the values and . We have . Thus, can be computed in steps by spending some idle steps. Therefore, the function is time constructible.

We will use the notion to characterize extremely sparse tally sets with fast growing function such as