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 timespace tradeoff. Static data structure lower bounds aim to answer this question by proving unconditional lower bounds on this tradeoff.
The most compelling model for proving such lower bounds is the “cellprobe” 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 nonuniform^{1}^{1}1Indeed, a nonadaptive cellprobe data structure is essentially equivalent to an output depth2 circuit with arbitrary gates, “width” , and a bounded top fanin , see [JS11, BL15] and Section 2.5. model of computation renders timespace tradeoffs as purely informationtheoretic question and thereby extremely powerful. Unfortunately, the abstraction of this model also comes at a price: While a rather straightforward 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 cellprobe lower bound known to date is
(1) 
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 polynomialevaluation, nearestneighbor search and 2D range counting to mention a few [Sie04, Pǎt08, PTW10, Lar12]. Proving an cellprobe lower bound on any explicit static problem in the linear space regime, is a major open problem, and the tradeoff in (1) remains the highest static cellprobe 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 cellprobe lower bounds [BL15]).
In an effort to circumvent the difficulty of proving lower bounds in the cellprobe model, several restricted models of data structures have been studied over the years, e.g., the pointermachine and wordRAMs [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, matrixvector 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 wordsize 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.^{2}^{2}2In the general (oblivious) group model, the input database consists of elements from a blackbox (commutative) group, the data structure can only store and manipulate group elements through blackbox group operations, and querytime () 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 structures^{3}^{3}3In 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 superlogarithmic static lower bounds, even against nonadaptive linear data structures with arbitrarily small linear space , implies semiexplicit 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]^{4}^{4}4Goldreich and Tal [GT16] also give a “semiexplicit” 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 )rowrigid 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 superlogarithmic 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 rowrigid matrix with . Moreover, if is explicit, then .
The premise of Theorem 1 would imply a (semiexplicit) 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.^{5}^{5}5Although here we state Theorem 1 for the lowest probe complexity that is interesting, it actually gives a smooth tradeoff: 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 cellprobe 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 stateofart lower bounds (the precise factor is given in the formal statement, see Theorem 7).
Our main result has further significant implications to other timespace regimes. In the succinct space regime, we show that any asymptotic improvement on the current best cellprobe lower bounds mentioned above, would yield improved rigidity bounds for nearsquare 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 logarithmicfactor improvement on the aforementioned bounds of [GM07, BL13] for a problem with linear number of queries .
Finally, we show that ‘holygrail’ polynomial () data structure lower bounds against neartrivial 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 cellprobe 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 nonzeros 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 “sumsetevasive”, in the sense that the rows of (viewed as points ) are not contained in the span^{6}^{6}6I.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 rowsparse 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 rowrigid, and that it is sparse to mean rowsparse.
We establish a new relationship between these two (seemingly disparate) factorizations. A key step in showing this relationship is to reinterpret 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 subspace^{7}^{7}7We say that a subspace is sparse if it is the columnspace of a rowsparse matrix of the same dimension (in other words, has small inner dimension if it has lowdimensional 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 strongly^{8}^{8}8A matrix is stronglyrigid if it remains (row) rigid in any basis of its columnspace , see Definition 6. rigid if an only if has small inner dimension ().

is sumsetevasive 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 lowdimensional ‘cover’ of the columnspace 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 columnspace of but never on the rowspace). While this already yields a significant improvement over currentbest 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 ()rowrigid 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 ) ^{9}^{9}9The ratio between and depends on the the postulated data structure lower bound on , determining ., but on the other hand, the hope is that remains rowrigid. Indeed, Lemma 1 guarantees that is (say) rowrigid, 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 rowrigidity: 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 blackbox reduction from rowrigidity to globalrigidity. Our reduction uses Locally Decodable Codes (LDCs) in a way reminiscent of the way LDCs are used in worstcase to averagecase 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 rowrigid, 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 rowrigid (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 rowrigidity is potentially much weaker than global rigidity). We also remark that Theorem 3 applies in the same way to reduce worstcase to averagecase datastructure 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 cellprobe 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 cells^{10}^{10}10the 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 PaturiPudlák dimensions [PP06, Lok09], and then show that they imply new connections between data structure lower bounds and matrix rigidity. While PaturiPudlá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 nonzero elements, and is row sparse if each of its rows has at most nonzero 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 that^{12}^{12}12We 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:

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

There is an linear data structure computing .

.

is not sumset evasive.
Proof.
: 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 .^{13}^{13}13We 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.
Proof.
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 nonrigid, 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 .
Proof.
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
and
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 longstanding open problem in circuit complexity is to prove a superlinear 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 graphtheoretic 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.
From Valiant’s reduction (see Figure 1 (b)) one can conclude that if a linearsize logdepth 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 fanin , 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 linearsize logdepth 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 nontrivial 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 rowrigidity. In Section 3.2, we show that a rectangular matrix of high rowrigidity 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.
Proof.
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 polynomialsize 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 searchtodecision 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 .
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.
Proof.
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
where
Now, recall that each is sparse, and that where . Thus, we have that where has at most nonzero 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 .
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 .
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 ReedMuller 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 ).