# Space-efficient null space of sparse array

I have a roughly 100,000 × 3,000 matrix (as a SparseArray) that I'd like to find the kernel (null space) of. It has about 500,000 nonzero entries, all -1 or 1.

When I tried with NullSpace, it ate up 8 GB of RAM, complained about insufficient memory and shut down:

No more memory available.
Mathematica kernel has shut down.
Try quitting other applications and then retry.


Is there a better way to do this? Something a bit more efficient with memory (either a different Mathematica technique or a different language altogether)?

I don't think there's any structure in the matrix to exploit, beyond what I've mentioned.

-
Maybe break off the first 3000 or so rows and find the null space for that. Now take the next 3000. Eventual null vectors must be in the row space of the first set and nulled by the new submatrix. Continue in this manner. (Putting this as a comment because I've not worked out the code details.) – Daniel Lichtblau Jun 13 '12 at 20:50
If numerical precision is OK you could try to convert the matrix to machine precision first before doing a NullSpace. – Sjoerd C. de Vries Jun 13 '12 at 21:05
Can you check if it is a packed array, if not make it one (to be honest, I'm not sure if you can have an unpacked sparse array). – s0rce Jun 13 '12 at 21:39

Here is the method I outlined. I'll illustrate on a small example where we split matrix into top and bottom halves.

In[794]:= SeedRandom[1111];
halfsize = 3;
mat = RandomInteger[{-4, 4}, {2*halfsize, 10}]

Out[796]= {{-3, -1, 3, -3, 3, 3, 3, 3, 4, 2}, {3, 3, -3, 0, 0,
1, -2, -4, 0, -1}, {-3, 4, 3, 0, -2, 4, 3, -2, -2, -2}, {2, 2, 4,
0, -4, 4, -1, -4, 1, -1}, {-2, 4, 3, 4, 1, -1, 4, 1, 4, 0}, {-3,
4, -1, -3, 0, 1, 1, 0, 4, 4}}

{top, bottom} = Partition[mat, halfsize];


First find a set of null vectors for the top half.

In[800]:= n1 = NullSpace[top]

Out[800]= {{-2, 9, 0, 13, 0, 0, 0, 0, 0, 21}, {-6, 6, 0, 32, 0, 0, 0,
0, 21, 0}, {10, 18, 0, 5, 0, 0, 0, 21, 0, 0}, {17, -3, 0, 5, 0, 0,
21, 0, 0, 0}, {8, -15, 0, 18, 0, 21, 0, 0, 0, 0}, {-6, 6, 0, 25, 21,
0, 0, 0, 0, 0}, {1, 0, 1, 0, 0, 0, 0, 0, 0, 0}}


Nulls for the entire matrix must be in the null space of the bottom half and comprised of linear combinations of these. If you work out the linear algebra it goes like this: we get the linear combination multipliers as null vectors of the bottom times the first nulls.

In[808]:= multipliers = NullSpace[bottom.Transpose[n1]]

Out[808]= {{149, -479, 1057, 0, 0, 0, 6783}, {5732, 372, -13751, 0, 0,
4199, 0}, {4982, -3820, 6387, 0, 4199, 0, 0}, {201, -100, -70, 221,
0, 0, 0}}

In[813]:= nulls = multipliers.n1

Out[813]= {{19929, 17493, 6783, -8106, 0, 0, 0, 22197, -10059,
3129}, {-176400, -168504, 0, 122640, 88179, 0, 0, -288771, 7812,
120372}, {110418, 73899, 0, 50043, 0, 88179, 0, 134127, -80220,
104622}, {3255, -714, 0, 168, 0, 0, 4641, -1470, -2100, 4221}}


let's check that these are in fact null vectors for the full matrix.

In[814]:= Map[mat.# &, nulls]

Out[814]= {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0,
0}, {0, 0, 0, 0, 0, 0}}


This shows they are moreover linearly independent.

In[817]:= MatrixRank[nulls]

Out[817]= 4


For the size indicated in this post I'd advocate working at most a few thousand rows at a time, iterating this construction to get nulls for the sequence of partial matrices formed by top, top + second set of rows, top + second set + third set,...

-