How to test linear independence of boolean array in a pythonic way?

Question

The rows of this matrix are not linearly independent, as the first two rows can be added (or XORed) to produce the third:

matrix = [
    [ 1, 0, 0, 1 ],
    [ 0, 0, 1, 0 ],
    [ 1, 0, 1, 1 ],
    [ 1, 1, 0, 1 ]
]

One could do brute-force reduction of the rows, with deeply nested for loops and if conditions and testing for an all zero row, but the resulting code doesn't feel like python.

Without using numpy or other library, what is a pythonic way of testing for independent rows (on much larger matrices)?

The [definition](https://mathworld.wolfram.com/LinearlyIndependent.html) uses multiplication and addition, nor XOR... — Kelly Bundy, Mar 03 '23 at 14:06
@KellyBundy, Aren't XOR and ADD the same for booleans? 0+0=0=0^0, 0+1=1=0^1, 1+0=1=1^0, 1+1=0=1^1. — Ray Butterworth, Mar 03 '23 at 14:31
The question says nothing about booleans. It does say "binary array", but that just refers to the input. If you add the rows, you get [3,1,2,3], not [1,1,0,1]. — Kelly Bundy, Mar 03 '23 at 14:45
@KellyBundy, I've now changed "binary" to "boolean" to avoid any confusion. — Ray Butterworth, Mar 03 '23 at 14:51
Ok. I btw tried a bit to find a counter-example, i.e., where xor and addition disagree, and didn't find one. Maybe they are even equivalent, although I doubt it. — Kelly Bundy, Mar 03 '23 at 15:59
@KellyBundy, there are only the four cases to test for agreement, as in my comment. — Ray Butterworth, Mar 03 '23 at 16:24
But that's just for adding/xoring *two* rows, and only considering factors 0 and 1. — Kelly Bundy, Mar 03 '23 at 20:22

btilly · Accepted Answer · 2023-03-02T19:11:54.263

My guess is that you want something like this:

import itertools

def linearly_independent (rows):
    for r in range(2, len(rows) + 1):
        for c in itertools.combinations(rows, r):
            x = [0 for x in c[0]]
            for row in c:
                for i in range(len(x)):
                    x[i] ^= row[i]
            if not 1 in x:
                return False
    return True

If so, then calling algorithmically terrible code like this "Pythonic" and row reduction "brute force" suggests that your aesthetic principles are a problem. Because row reduction is absolutely the right approach.

For comparison here is the row reduction solution.

def linearly_independent (rows):
    # Clone everything to not mess up the original.
    rows = [[x for x in r] for r in rows]

    # We will be accessing rows[i][j].
    # Start at the top corner.
    i = j = 0
    while j < len(rows[0]):
        if 1 != rows[i][j]:
            found = False
            for i_swap in range(i+1, len(rows)):
                if 1 == rows[i_swap][j]:
                    (rows[i], rows[i_swap]) = (rows[i_swap], rows[i])
                    found = True
                    break
            if not found:
                j += 1
                continue
        # Now we have a row with a leading 1.
        for i_other in range(i+1, len(rows)):
            if rows[i_other][j] == 1:
                for k in range(j, len(rows[0])):
                    rows[i_other][k] ^= rows[i][k]
        i += 1
        if len(rows) < i:
            return True

    return False

Algorithmically the combinations code for an n x m matrix scales like O(m * n * 2^n). Row reduction scales like O(m * n^2). Which is much better.

Thanks, but I was looking for a self-contained solution, "Without using numpy or other library". — Ray Butterworth, Mar 02 '23 at 17:46
@RayButterworth Usually when people say "Pythonic", the Python standard library is fair game. Anyways I added a pure Python solution for row reduction with no libraries at all. — btilly, Mar 02 '23 at 19:06

score 1 · Answer 2 · answered Mar 02 '23 at 17:40

1

This is also brute force, but using some Python tools:

from itertools import combinations

matrix = [
    [ 1, 0, 0, 1 ],
    [ 0, 0, 1, 0 ],
    [ 1, 0, 1, 1 ],
    [ 1, 1, 0, 1 ]
]

row_combinations = combinations(matrix, 2)


linear_dependant = True

for combination in row_combinations:
    
    result = [i1 ^ i2 for i1, i2 in zip(combination[0], combination[1])]
    not_all_zeros = not all([elem == 0 for elem in result])

    if not_all_zeros:
        linear_dependant = False
        break

answered Mar 02 '23 at 17:40

Raydel Miranda

13,825
3
38
60

Thanks, but I was looking for a self-contained solution, "Without using numpy or other library". – Ray Butterworth Mar 02 '23 at 17:46
Itertools is a built-in python module, you won't need to install any third-party library. You can use both solutions out-of-the-box. – Raydel Miranda Mar 02 '23 at 17:51

How to test linear independence of boolean array in a pythonic way?

2 Answers2