Log In Sign Up

Static Data Structure Lower Bounds Imply Rigidity

by   Zeev Dvir, et al.

We show that static data structure lower bounds in the group (linear) model imply semi-explicit lower bounds on matrix rigidity. In particular, we prove that an explicit lower bound of t ≥ω(^2 n) on the cell-probe complexity of linear data structures in the group model, even against arbitrarily small linear space (s= (1+ε)n), would already imply a semi-explicit ( P^NP) construction of rigid matrices with significantly better parameters than the current state of art (Alon, Panigrahy and Yekhanin, 2009). Our results further assert that polynomial (t≥ n^δ) data structure lower bounds against near-optimal space, would imply super-linear circuit lower bounds for log-depth linear circuits (a four-decade open question). In the succinct space regime (s=n+o(n)), we show that any improvement on current cell-probe lower bounds in the linear model would also imply new rigidity bounds. Our results rely on a new connection between the "inner" and "outer" dimensions of a matrix (Paturi and Pudlak, 2006), and on a new reduction from worst-case to average-case rigidity, which is of independent interest.


page 1

page 2

page 3

page 4


Equivalence of Systematic Linear Data Structures and Matrix Rigidity

Recently, Dvir, Golovnev, and Weinstein have shown that sufficiently str...

Data Structures Lower Bounds and Popular Conjectures

In this paper, we investigate the relative power of several conjectures ...

Lower Bounds for Matrix Factorization

We study the problem of constructing explicit families of matrices which...

Further Unifying the Landscape of Cell Probe Lower Bounds

In a landmark paper, Pǎtraşcu demonstrated how a single lower bound for ...

Localizability of the approximation method

We use the approximation method of Razborov to analyze the locality barr...

Tight Static Lower Bounds for Non-Adaptive Data Structures

In this paper, we study the static cell probe complexity of non-adaptive...

Constructive Separations and Their Consequences

For a complexity class C and language L, a constructive separation of L ...

1 Introduction

Proving lower bounds on the operational time of data structures has been a long and active research endeavor for several decades. In the static setting, the goal is to preprocess a database of elements into minimum space (), so that queries on the input database can be answered quickly, in query time (where the typical and realistic setting is ). The two naïve solutions to any such problem is to either precompute and store the answers to all queries in advance, which has optimal query time but prohibitive space (), or to store the raw database using optimal space () at the price of trivial query time (). The obvious question is whether the underlying problem admits a better time-space trade-off. Static data structure lower bounds aim to answer this question by proving unconditional lower bounds on this trade-off.

The most compelling model for proving such lower bounds is the “cell-probe” model [Yao81], in which a data structure is simply viewed as a table of memory cells (-bit words) and query time is measured only by the number of memory accesses (I/Os), whereas all computations on “probed” memory cells are free of charge. This nonuniform111Indeed, a nonadaptive cell-probe data structure is essentially equivalent to an -output depth-2 circuit with arbitrary gates, “width” , and a bounded top fan-in , see [JS11, BL15] and Section 2.5. model of computation renders time-space trade-offs as purely information-theoretic question and thereby extremely powerful. Unfortunately, the abstraction of this model also comes at a price: While a rather straight-forward counting argument [Mil93] shows that most static data structure problems with queries indeed require either time or space (i.e., the naïve solutions are essentially optimal), the highest explicit cell-probe lower bound known to date is


In the interesting and realistic regime of polynomially many queries (), this yields a lower bound on the query time of linear space () data structures for several natural problems, such as polynomial-evaluation, nearest-neighbor search and 2D range counting to mention a few [Sie04, Pǎt08, PTW10, Lar12]. Proving an cell-probe lower bound on any explicit static problem in the linear space regime, is a major open problem, and the trade-off in (1) remains the highest static cell-probe lower bound known to date, even for nonadaptive data structures (This is in sharp contrast to dynamic data structures, where the restriction to nonadaptivity enables polynomial cell-probe lower bounds [BL15]).

In an effort to circumvent the difficulty of proving lower bounds in the cell-probe model, several restricted models of data structures have been studied over the years, e.g., the pointer-machine and word-RAMs [vEB90] as well as (stronger) algebraic models, most notably, the group model [Fre81, Cha90, Pǎt07]. Since many important data structure problems involve linear queries

over the database (e.g., orthogonal range counting, partial sums, dictionaries, matrix-vector multiplication and polynomial evaluation to mention a few), it is natural to restrict the data structure to use only

linear operations as well. More formally, a static linear data structure problem over a field and input database , is defined by an matrix (i.e., a linear map) . The queries are the rows of , and the answer to the th query is . An -linear data structure for is allowed to store arbitrary field elements in memory , and must compute each query as a -sparse linear combination of its memory state (we assume the word-size satisfies , see Section 2.1 for the complete details). This model is a special case of the static group model, except here the group (field) is fixed in advance.222In the general (oblivious) group model, the input database consists of elements from a black-box (commutative) group, the data structure can only store and manipulate group elements through black-box group operations, and query-time () is measured by the number of algebraic operations (see e.g. [Aga04, Pǎt07] for further details).

While the restriction to the group model has been fruitful for proving strong lower bounds on dynamic data structures333In the dynamic setting, the data structure needs to maintain an online sequence of operations while minimizing the number of memory accesses for update and query operations. In the group (linear) model, these constraints are essentially equivalent to a decomposition of a matrix where both and are sparse. In contrast, static lower bounds only require to be sparse, hence intuitively such decomposition is much harder to rule out. ([Aga04, Pǎt07, Lar14]), the static group model resisted this restriction as well, and (1) remains the highest static lower bound even against nonadaptive linear data structures.

This paper shows that this barrier is no coincidence. We study linear data structures and show that proving super-logarithmic static lower bounds, even against nonadaptive linear data structures with arbitrarily small linear space , implies semi-explicit lower bounds on matrix rigidity

. Before stating our main results, we take a moment to introduce the notion of rigidity.

Matrix rigidity.

The notion of matrix rigidity was introduced by Valiant [Val77] as a possible approach for proving circuit lower bounds. We say that a matrix is -row rigid, if decreasing the rank of below , requires modifying at least entries in some row of . In other words, for any -dimensional subspace of , there exists a row in that is -far (in Hamming distance) from . We discuss a stronger notion of rigidity called ’global rigidity’ later in the paper (requiring many rows of to be far from ) and prove a general reduction from one to the other (see Theorem 3 below) which may be of independent interest.

The best known bound on matrix rigidity of square matrices (for any rank parameter ) is [Fri93, PR94, SSS97, Lok09]444Goldreich and Tal [GT16] also give a “semi-explicit” construction of rigid matrices which uses bits of randomness. This construction has (global) rigidity for any , which improves on the classical bound for . In particular, since the required number of random bits is only linear, this construction is in . Kumar and Volk [KV18] show how to construct an -globally rigid matrix in subexponential time . . Although matrix rigidity has attracted a lot of attention, this bound remains the best known for more than two decades.

Matrix rigidity is also studied for rectangular matrices (introduced in [APY09]), where we allow the number of rows to be larger than the number of columns. One can thus fix the parameters (typically ) and (the sparsity) and try to minimize the number of rows in . One can easily show that a random square matrix is highly rigid (say with and both close to ), but the best explicit constructions of an matrix which is )-row-rigid requires  [APY09, SY11]. This bound (and the related lower bound for square matrices which is even older) represent, to many experts in the field, a real barrier, and any improvement to it is likely to require substantially new ideas. Our results below show that this barrier can be surpassed if one can improve the currently known lower bounds on static data structures by a slightly super-logarithmic factor.

1.1 Our results

Our first main result is the following (see Theorem 7 for a formal statement):

Theorem 1 (Main Theorem, Informal).

A data structure lower bound of in the group (linear) model for computing a linear map , even against data structures with arbitrarily small linear space , yields an -row-rigid matrix with . Moreover, if is explicit, then .

The premise of Theorem 1 would imply a (semi-explicit) construction of an matrix which is -rigid (i.e., requires modifying at least entries in some row to decrease the rank below, say, ). In comparison, the aforementioned best known explicit constructions only yield an -rigid matrix [APY09, SY11], which is only when . In particular, Theorem 1 asserts that proving a data structure lower bound against arbitrarily small linear space, would already yield an asymptotic improvement on (rectangular) rigid matrix construction.555Although here we state Theorem 1 for the lowest probe complexity that is interesting, it actually gives a smooth trade-off: a lower bound on the linear data structure query time implies rigidity .

Theorem 1 indicates a “threshold” in data structure lower bounds, since for succinct data structures (which are constrained to use only space), polynomial lower bounds () are known on the query time (e.g., [GM07, BL13]), even in the general cell-probe model.

Our second main result concerns implications of data structure lower bounds on square matrix rigidity (see Theorem 7, item for a formal statement):

Theorem 2 (Implications to Square Rigidity, Informal).

For any , a data structure lower bound of in the group (linear) model, for computing a linear map , even against arbitrarily small linear space , yields a square matrix which is -rigid, for some . Moreover, if is explicit, then .

Since the highest rigidity bound known to date for square matrices (and any rank parameter ) is [Fri93], the premise of Theorem 2 would imply an asymptotic improvement over state-of-art lower bounds (the precise factor is given in the formal statement, see Theorem 7).

Our main result has further significant implications to other time-space regimes. In the succinct space regime, we show that any asymptotic improvement on the current best cell-probe lower bounds mentioned above, would yield improved rigidity bounds for near-square matrices, and vice versa. In particular, a corollary of this connection yields a logarithmic improvement on succinct lower bounds (in the group model): We exhibit an (explicit) data structure lower bound of for linear data structures using space , which is a logarithmic-factor improvement on the aforementioned bounds of [GM07, BL13] for a problem with linear number of queries .

Finally, we show that ‘holy-grail’ polynomial () data structure lower bounds against near-trivial space , would imply superlinear circuit lower bounds (see Theorem 8). We discuss all of these implications in Section 4.

Related work.

An independent concurrent work of Viola [Vio18] shows a different connection between circuit lower bounds and cell-probe lower bounds, yet only in extremely high space regimes (in fact, Theorem 4 in [Vio18] is very similar though formally incomparable to our Theorem 8; Theorem 3 in [Vio18] is of independent interest). In contrast, our main results (Theorems 1 and 2) focus on data structure lower bounds against arbitrarily small linear space (, whereas ), and prove a generic connection between (linear) data structures and rigidity.

Miltersen et al. [MNSW98, Theorem 4] prove that any data structure problem with inputs and outputs over a field of size which can be solved by a read branching program of polynomial size, can also be solved by a data structure with space and query time .

1.2 Technical Overview

It is not hard to see that a (nonadaptive) -linear data structure for a linear problem is nothing but a factorization of as a product of two matrices , where is a -sparse matrix (with non-zeros in each row), and is an arbitrary matrix with only rows (see Section 2.1). As such, proving a lower bound on linear data structures is equivalent to finding an (explicit) matrix which does not admit such factorization, or equivalently, showing that is “sumset-evasive”, in the sense that the rows of (viewed as points ) are not contained in the -span666I.e., the union of all -dimensional subspaces generated by any fixed set of size . We borrow the term “sumset evasive” by analogy from additive combinatorics, but caution that this definition allows arbitrary linear combinations and not just sums. of any fixed set of points in (see Section 2.3 below for the formal definition of -sumset evasive sets).

In contrast, matrix rigidity is the problem of finding an (explicit) matrix which cannot be factorized as the sum (rather than product) of a -row-sparse matrix plus a low rank matrix, say, . For brevity, unless otherwise stated, we say below that a matrix is -rigid to mean that is is -row-rigid, and that it is -sparse to mean -row-sparse.

We establish a new relationship between these two (seemingly disparate) factorizations. A key step in showing this relationship is to re-interpret the two factorization problems above as two (respective) “geometric” measures on the column space of , i.e., viewing the matrix as an -dimensional subspace spanned by its columns. Informally, the inner dimension of is the maximal dimension of the intersection of with any -sparse subspace777We say that a subspace is -sparse if it is the column-space of a -row-sparse matrix of the same dimension (in other words, has small inner dimension if it has low-dimensional intersection with any -dimensional -sparse subspace, see Definition 2 below). The outer dimension of is the minimal dimension of a -sparse subspace that contains (Definition 3). We first prove the following characterization (Lemmas 4 and 2):

  • is strongly888A matrix is strongly-rigid if it remains (row) rigid in any basis of its column-space , see Definition 6. -rigid if an only if has small inner dimension ().

  • is sumset-evasive if and only if has large outer dimension ().

(We note that the nontrivial direction of the first statement was already shown by [PP06] for a subtly different notion of inner/outer dimensions, we provide an alternative proof in Appendix C). In this terminology, proving that lower bounds on linear data structures imply lower bounds on (row) rigidity, is essentially equivalent to showing that large outer dimension implies small inner dimension (perhaps of a related explicit matrix). Indeed, our first main technical contribution is establishing the following relationship between these two measures on submatrices of , which is the heart of the proof of Theorem 1.

Lemma 1 (Large outer dimension implies small inner dimension, Theorem 5, Informal).

If , there exists an submatrix for which .

Indeed, by the characterization above, the last inequality implies that is -rigid. The high level idea of the proof is a simple recursive procedure that, given a matrix with high outer dimension , ‘finds’ a submatrix with low inner dimension. The heart of each iteration is as follows: If our current matrix (which is initially itself) is rigid (i.e., has low inner dimension, which can be checked with an NP oracle), then we are done. Otherwise, the NP oracle together with the characterization above, gives us a sparse subspace (of only dimensions) that has large intersection with the column space of . After a change of basis (of the column space) we can essentially, partition the columns of into the part covered by and the remaining columns. We then apply the same argument on the remaining columns. At each iteration we ‘accumulate’ an additional sparse (whose dimension is small – merely the dimension of the residual space) and so, at the end, we must show that these can be pasted together to give a low-dimensional ‘cover’ of the column-space of the original matrix (i.e., a small space data structure for ). Thus, the final sparsity grows by a factor proportional to the number of iterations, which is logarithmic. This implies that the process must end prematurely, resulting in a (semi-) explicit rigid submatrix.

Square Matrix Rigidity (Theorem 2).

One caveat of Theorem 1

is that it may produce a highly skewed (rectangular)

matrix, where (this is because we only recurse on the column-space of but never on the row-space). While this already yields a significant improvement over current-best rectangular rigidity results (e.g., when ), this argument does not seem to imply anything about rigidity for square matrices.

A trivial idea to turn the rectangular ()-row-rigid matrix produced by Lemma 1 into a square matrix while preserving rigidity (at the expense of decreasing the relative rank parameter), is to “stack” identical copies of side by side. Clearly, the rank of the resulting matrix remains unchanged (bounded by , so the relative rank parameter may decrease significantly relative to ) 999The ratio between and depends on the the postulated data structure lower bound on , determining ., but on the other hand, the hope is that remains -row-rigid. Indeed, Lemma 1 guarantees that is (say) -row-rigid, and therefore in order to decrease the rank of below , one would need to decrease the rank of each of the blocks below , which requires modifying row entries in total. The problem, of course, is that these rows may be different in each block, which completely dooms the argument. Note that this is a direct consequence of working with row-rigidity: If were globally rigid (i.e., at least of its rows need to be modified in at least entries in order to decrease the rank below ), this simple trick would have gone through flawlessly.

In order to bypass this obstacle, we prove the following black-box reduction from row-rigidity to global-rigidity. Our reduction uses Locally Decodable Codes (LDCs) in a way reminiscent of the way LDCs are used in worst-case to average-case hardness amplification results [IW01].

Theorem 3 (Row to Global Rigidity).

Let be a linear -query locally decodable code (LDC) against constant noise , and let be the application of to each column of . Then if is -row-rigid, then is -globally rigid.

To prove the theorem, we use the following crucial property of linear LDCs, originally observed by Goldreich et. al [GKST02]: If is a -query linear LDC (applied on the columns of ), then for any subset of at most rows of , and any row of , there exist rows of that lie outside and span . (See Section 3.2 for a formal argument). Now, suppose towards contradiction, that is not -globally rigid, for . This means that there is some -dimensional subspace which is at most -far (in Hamming distance) from an average row of , hence by a Markov argument, at most of the rows of are -far from . Let denote this set of rows. Since , the LDC property above asserts that every row of is a linear combination of at most rows in , each of which is -close to by definition of . But this means that every row of is at most far from , which is a contradiction since was assumed to be -row-rigid (hence there must be at least one row that is -far from ). The complete proof can be found in Theorem 6.

Since there are explicit linear -query LDCs with polynomial rate (), Theorem 3 now completes the proof of Theorem 2 using the aforementioned program (stacking copies of next to each other), at the price of an extra logarithmic loss in sparsity. To the best of our knowledge, Theorem 3 establishes the first nontrivial relationship between rectangular and square (row) rigidity, hence it may be of independent and general interest to rigidity theory (as the notion of row-rigidity is potentially much weaker than global rigidity). We also remark that Theorem 3 applies in the same way to reduce worst-case to average-case data-structure lower bounds for linear problems.

2 Setup and Preliminaries

2.1 Linear Data Structures (Static Group Model)

A linear data structure problem with queries over a field and an input database of elements is defined by an matrix (i.e., a linear map) . The queries are the rows of , and for any input database , the answer to the th query is given by .

An nonadaptive data structure for the problem in the cell-probe model is a pair , where is a preprocessing function that encodes the database into memory cells, and a query algorithm that correctly answers every query of by probing at most memory cells101010the indices of memory cells are only function of the query index, i.e., such that , for every and every query .

is a linear data structure for the (linear) problem if both and only compute linear functions over .We observe that it suffices to require to be linear: if a linear problem is solved by a data structure with a linear query function , then can be transformed into an equivalent data structure with the same parameters and where both and are linear.

Proposition 1 (Lemma 2.5 [Js11], Ex. 13.7 [Juk12]).

Given an -data structure

computing a linear transformation

for with linear query function , one can efficiently construct an equivalent -data structure where both the query function and the preprocessing function are linear.

2.2 Inner and Outer Dimensions

We state our main technical results in terms of Paturi-Pudlák dimensions [PP06, Lok09], and then show that they imply new connections between data structure lower bounds and matrix rigidity. While Paturi-Pudlák dimensions are defined w.r.t. column sparsity, for our applications we need to consider an analogous definition w.r.t. row sparsity (this difference is important in this context).

Definition 1 (Sparse subspaces).

A matrix is -globally sparse if it has non-zero elements, and is -row sparse if each of its rows has at most non-zero entries. A subspace is -sparse if it is the column space of a -row sparse matrix.

Definition 2 (Inner dimension [Pp06]).

Let be a subspace, and be a sparsity parameter. Then the inner dimension of is

Definition 3 (Outer dimension [Pp06]).

Let be a subspace, and be a sparsity parameter. Then the outer dimension of is

By abuse of notation, for a matrix we denote by and the inner and outer dimensions of the column space of .

2.3 Sumset Evasive Sets

For an integer and a set of points , denotes the -span of , i.e., the union of all -sparse linear combinations of :

Definition 4 (Sumset evasive sets).

For integers and we say that a set of size is -sumset evasive if for any set of size , it holds that121212We shall see that the definition of sumset evasive sets exactly captures the hardness of linear data structure problems. One can extend the definition of sumset evasive sets to capture the hardness of approximating a linear problem by a linear data structure. Since the main focus of this work is exact data structures, we omit this extended definition.

The next lemma asserts that linear data structure lower bounds, sumset evasive sets and subspaces of high outer dimension are all equivalent.

Lemma 2.

Let be a set of size , let be a matrix composed of the vectors of , and let be the column space of . The following are equivalent:

  1. [label=(0),ref=(0)]

  2. There is an linear data structure computing .

  3. .

  4. is not -sumset evasive.


: Since , there exists a -sparse subspace of such that . Then let be a -row sparse matrix whose columns generate . Since , each column of is a linear combination of columns from . Therefore, there exists a matrix such that . We show that there exists an linear data structure which computes . Indeed, let the preprocessing function of be the linear transformation defined by , and let the query algorithm be the linear function defined by . Since is -row sparse, and , is an linear data structure.

: Since is not -sumset evasive, there exists a set of size such that . Let be a matrix composed of the vectors of . Since , there exists a -row sparse matrix such that . Let be the column space of . We have that and .

: Let be an linear data structure which computes . Let be the linear transformation computed by its preprocessing function, and be the linear transformation computed by its query function. Let be the set of rows of . Since is -row sparse, the set contains the set which contradicts sumset evasiveness of .

2.4 Rigidity

Definition 5 (Rigidity).

A matrix is -row rigid if any matrix which differs from in at most elements in each row, has rank at least . is -globally rigid if any matrix which differs from in at most elements has rank at least .

In other words, is rigid if it cannot be written as a sum of a sparse matrix and a low rank matrix .

Now we define a stronger notion of rigidity which is invariant under basis changes.

Definition 6 (Strong rigidity).

A subspace of dimension is -strongly row rigid if cannot be written as a sum of a -sparse subspace of and a subspace of dimension . We abuse the notation by saying that a matrix is -strongly row rigid if its column space is -strongly row rigid. Similarly, we say that is -strongly globally rigid if cannot be written as a sum of a subspace generated by a -globally sparse matrix, and a subspace of dimension .131313We remark that while strong rigidity is interesting for rectangular matrices, and many of the known constructions of rigid matrices are actually strongly rigid (see, e.g., Proposition 4 in Appendix A), this definition is meaningless for square matrices. Indeed, any subspace of equals where is generated by the

-sparse identity matrix, and


Lemma 3 (Strong rigidity implies rigidity).

If is -strongly row rigid, then is -row rigid.


Assume that is not -row rigid. Then, by Definition 5, there exist matrices , where is -sparse, and , such that . Let , , and be the column spaces of , , and , respectfully. We have that . This implies thay for some and . Since is -sparse, so is , and , which contradicts the definition of strong rigidity of . ∎

Friedman [Fri93] defines strong rigidity in the same way as inner dimension. Now we show that this definition is equivalent to the definition above. The following simple lemma (which is a modified version of Proposition 3 from [PP06]) will play a key role in our proof of Theorem 1. It asserts that if a matrix is non-rigid, then there must be some sparse subspace with a significant intersection with the column space of .

Lemma 4 (Inner dimension is equivalent to strong rigidity).

Let be a subspace of . is -strongly row rigid if and only if .


Assume that is not -strongly row rigid. Then, by Definition 6, there exist subspaces , where is -sparse, and , such that . From we have that which gives us that


which implies that .

In the other direction: Assume that . Then, by Definition 2, there exists a -sparse subspace of , such that . Thus, there exists a subspace of such that

2.5 Circuit Lower Bounds

A long-standing open problem in circuit complexity is to prove a super-linear lower bound on the size of circuits of depth computing an explicit function [Val77, AB09, Frontier 3]. The same question remains open for linear circuits (i.e., circuits where each gate computes a linear combination of two of its inputs) computing an explicit linear map . Using a classical graph-theoretic result [EGS75], Valiant [Val77] reduced this problem to a problem about depth- circuits of a special kind: there are only gates in the middle layer which depend on the inputs, and each output gate depends on input and middle layer gates (for an arbitrary constant ). Note that a static data structure can be thought of as a depth- circuit with inputs, outputs, middle layer gates which depend on inputs, where each output depends on gates in the middle layer. Figures 1 (a) and (b) illustrate the depth- circuits corresponding to static data structures and Valiant’s reduction.


Figure 1: (a) A (nonadaptive) static data structure as a depth- circuit. The input nodes feed memory cells, and we do not pose any restrictions on linear functions computed in memory cells. Each query (or output gate) depends only on memory cells. In a typical scenario, is as low as or . (b) Depth- circuit resulting from Valiant’s reduction. The inputs feed only middle layer gates. Again, we do not pose any restrictions on the linear functions computed in the middle layer gates. Each of the output gates depends only on inputs and middle layer gates.

From Valiant’s reduction (see Figure 1 (b)) one can conclude that if a linear-size log-depth linear circuit computes a linear map , then can be written as , where , and encode the dependence of outputs on inputs, the dependence of outputs on the middle layer, and the dependence of the middle layer on inputs, respectfully. Note that since every output has fan-in , we can conclude that the matrices and are -sparse. Formally, Valiant gave the following decomposition:

Theorem 4 ([Val77]).

Let . For every , there exists such that any linear map computable by a circuit of size and depth , can be decomposed as

where , and are -sparse. There are two decompositions:

  • ;

  • .

In particular, from the dimensions of and , has rank at most . Thus, for a -sparse and .

Corollary 1.

An -row rigid matrix (for arbitrary constants ) does not have linear-size log-depth circuits.

The best known (row) rigidity lower bound for the regime of is only . If we relax the requirement of matrices to be (almost) square, then for we know examples of matrices with  [APY09, SY11].

The problem of finding non-trivial circuit lower bounds and rigid matrices is open not only in , but also in larger uniform classes like or even .

3 Main Building Blocks

This section contains our two main tools for converting data structure lower bounds into rigidity lower bounds. In Section 3.1, we show that a rectangular matrix which is hard for linear data structures contains a rectangular submatrix of high row-rigidity. In Section 3.2, we show that a rectangular matrix of high row-rigidity can be transformed in a rigid square matrix (with some loss in the relative rank parameter but almost no loss in the relative sparsity parameter).

3.1 Connection Between Outer and Inner Dimensions

In this section we shall prove that every matrix either has small outer dimension or contains a matrix of small inner dimension. From Lemmas 2 and 4, this implies that every matrix which cannot be computed by efficient data structures (has large outer dimension) contains a rigid submatrix (submatrix of low inner dimension). We start with the following auxiliary lemma.

Lemma 5.

Let be positive integers. If has , then can be decomposed as

where is a submatrix of , is -row sparse, , .

Moreover, if is a finite field of size , such a decomposition can be found in time with an oracle.


Let be the column space of . By Definition 2, there exists a -sparse subspace , s.t. . Let be a -row sparse matrix generating .

Let us now extend with at most column vectors from to generate the column space of , and let be a matrix formed by these columns. Since the columns of and together generate the column space of , there exist matrices such that

Let be the language of triples such that the matrix has inner dimension (with the sparsity parameter ) . Since there is a polynomial-size witness (a -row sparse matrix whose column space intersects with in at least dimensions) which can be verified in polynomial time, . Now we apply the standard search-to-decision reduction. Namely, we define languages so that we could use binary search to find each coordinate of a matrix witnessing high inner dimension of . For a field of size , this can be done with queries to the oracle. Now, we can just use Gaussian elimination (running in time )) to find a matrix , and then the matrices and . ∎

We are now ready to present the main result of this section.

Input: Parameters , and a matrix with .
      Output: A submatrix of with and .

1:Let for every
3:for  to  do
4:     if  has  then
5:          return      
6:     Let ,
7:      By Lemma 5, there exist -row sparse , , and , where is a submatrix of , such that:
Algorithm 1 Find a Submatrix with Low Inner Dimension in a Matrix with High Outer Dimension
Theorem 5.

Let and be positive integers, and let . If is a matrix of outer dimension

then for some , contains a submatrix of inner dimension

Moreover, if is a finite field of size , such a submatrix can be found in time with an oracle.


We prove that Algorithm 1 must return a submatrix of of the claimed size with low inner dimension. Assume towards a contradiction that the algorithm did not return a matrix in Step 5 in any of the iterations . Then, from Equation (2), we have


Now, recall that each is -sparse, and that where . Thus, we have that where has at most non-zero entries per row, and for . This implies that the columns of can be generated by the columns of a -row sparse matrix , which contradicts the assumption about the outer dimension of .

Now we show that one can implement Algorithm 1 in time polynomial in and with an oracle. Since the language (the language of triples such that ) is in , Step 4 can be done with an oracle. Step 7 can be performed in polynomial time (with an oracle) by Lemma 5. ∎

We conclude this section with an application of Theorem 5 to data structures.

Lemma 6.

Let be a constant. If the linear map given by a matrix cannot be solved by an linear data structure, then contains an -row rigid submatrix for some .


Since cannot be solved by the claimed data structure, by Lemma 2,

Let us set . Then, by Theorem 5, contains a submatrix with for

By Lemma 4, the column space of is -strongly row rigid. Now, by Lemma 3, is -row rigid. ∎

3.2 Row Rigidity to Global Rigidity

One drawback of Theorem 5 is that the recursive algorithm produces skewed matrices (as we only recurse on the column space). To remedy this limitation, in this subsection we exhibit a reduction from worst case to average case rigidity, which will allow us to translate our results to square matrix rigidity with some loss in the rank parameter (thereby proving Theorem 2). The main ingredient of our reduction is the use of locally decodable codes:

Definition 7 (Locally Decodable Codes).

A mapping is a locally decodable code (LDC) if there exists a probabilistic procedure such that

  • For every and , reads at most positions of ;

  • For every , and such that ,

An LDC is called linear if the corresponding map is linear. In this case we can identify the code with its generating matrix .

There are constructions of LDCs over all fields with for arbitrarily small , and constant and (based on Reed-Muller codes).

Lemma 7 ([Dvi11], Corollary 3.14).

Let be a finite field. For every there exists and an explicit family of -linear LDCs for .

We will use the following property of linear LDCs.

Lemma 8 (Implicit in [Gkst02, Ds07]).

Let be a linear LDC, and let be a set of at least rows of . For any , there exists a set of rows in which spans the th standard basis vector .

We are now ready to present the main result of this section.

Theorem 6.

Let be a matrix, be a -linear LDC, and let (i.e., the matrix obtained by applying to each column of ).