Add LinBox algorithm for right kernel of sparse matrix over the rationals

[rburing]

This uses less memory than the only alternative which is a dense option, so it can handle some bigger matrices.

The code is based on analogous existing/surrounding Sage code and LinBox's example nullspacebasis_rat.C.

I'm not yet fluent in Cythonese so comments are welcome.

📝 Checklist

• The title is concise and informative.
• The description explains in detail what this PR is about.
• I have linked a relevant issue or discussion.
• I have created tests covering the changes.
• I have updated the documentation and checked the documentation preview.

[github-actions]

Documentation preview for this PR (built with commit b67fb38; changes) is ready! 🎉
This preview will update shortly after each push to this PR.

[user202729]

otherwise looks good to me, but do add some doctest for the top-level method .right_kernel_matrix().

is the new algorithm asymptotically faster (for very sparse matrix)? If so it may be beneficial to add a test that can be handled quickly with the change, but cannot be handled in reasonable time without it.

[whoami730]

@rburing please avoid rebases / force pushes if possible. That messes with review history and makes reviews more cumbersome.

[rburing]

please avoid rebases / force pushes if possible.

I'll keep it in mind for next time.

I didn't change the base commit, so you can just press the Compare link to see the changes since the previous push.

[user202729]

bug:

matrix([
	[ZZ.random_element(-5, 5)/ZZ.random_element(1, 5) if random() < 1/20 else 0 for j in range(400)]
	for i in range(200)
	]).right_kernel_matrix(algorithm="linbox")

run it, then ctrl-C, you'll see it's spending time in flint or iml. When the original matrix is dense, the algorithm= parameter is silently thrown away.

even when it's sparse, sometimes it spend time in echelonize_multimodular.

alarm(0.3)
matrix([
	[ZZ.random_element(-5, 5)/ZZ.random_element(1, 5) if random() < 1/20 else 0 for j in range(200)]
	for i in range(100)
	], sparse=True).right_kernel_matrix(algorithm="linbox")
cancel_alarm()

I'm also struggling to find a combination of parameters that makes linbox faster than the other algorithms. (although if the goal is to provide an interface, this is not mandatory.)

[rburing]

I improved the error handling.

The reason you see it spending time on echelonization with other algorithms is because of the basis argument of right_kernel_matrix defaulting to 'echelon' in this case, which does echelonization after computing the basis with the specified algorithm. To avoid that, you can pass e.g. basis = 'computed'.

The example I used is a 38875 x 13867 matrix ec9.txt (in SMS format) that you can load:

def read_sms_matrix(filename):
    f = open(filename)
    firstline = f.readline()
    dimensions = firstline.split(" ")
    rows = int(dimensions[0])
    columns = int(dimensions[1])
    A = zero_matrix(QQ, rows, columns, sparse=True)
    for line in f:
        parts = [int(z) for z in line.split(" ")]
        row = parts[0] - 1
        column = parts[1] - 1
        entry = parts[2]
        if row == 0 and column == 0 and entry == 0:
            break
        A[row, column] = entry
    f.close()
    return A

Trying the right_kernel_matrix method on this matrix runs out of memory with the dense algorithm.

[user202729]

looks hard to make this into a doctest (unless someone can figure out how to concisely construct a matrix with similar property), but otherwise should be fine.