int check_invertible(Matrix4x4 *mat) {
    int status;
    Matrix4x4 working_copy;
    copy_matrix(mat, &working_copy);
    
    // Transform to lower triangular form
    for (int pivot = 0; pivot < 4; pivot++) {
        if ((working_copy.rows[pivot] & identity_mask[pivot]) != 0) {
            for (int row = pivot + 1; row < 4; row++) {
                if ((working_copy.rows[row] & identity_mask[pivot]) != 0) {
                    working_copy.rows[row] ^= working_copy.rows[pivot];
                }
            }
        } else {
            status = 1;
            for (int row = pivot + 1; row < 4; row++) {
                if ((working_copy.rows[row] & identity_mask[pivot]) != 0) {
                    swap_rows(row, pivot, &working_copy);
                    status = 0;
                    break;
                }
            }
            if (status) { 
                return 0; 
            }
            for (int row = pivot + 1; row < 4; row++) {
                if ((working_copy.rows[row] & identity_mask[pivot]) != 0) {
                    working_copy.rows[row] ^= working_copy.rows[pivot];
                }
            }
        }
    }
    
    // Verify diagonal elements
    for (int i = 0; i < 4; i++) {
        if ((working_copy.rows[i] & identity_mask[i]) == 0) {
            return 0;
        }
    }
    return 1;
}

Computing Matrix Inverses over GF(2)

When a matrix is confirmed to be invertible, we can compute its inverse over GF(2). The algorithm extends the matrix with an identity matrix [M|E] and performs row operations until it becomes [E|M⁻¹]. To optimize implementation, we maintain a separate identity matrix that undergoes identical transformations.

Implemantation Steps:

1. Transform the matrix to lower triangular form
2. Reduce to identity matrix through elimination

void compute_matrix_inverse(Matrix4x4 *mat) {
    Matrix4x4 inverse_mat;
    
    // Initialize as identity matrix
    for (int i = 0; i < 4; i++) {
        inverse_mat.rows[i] = identity_mask[i];
    }
    
    // Forward elimination phase
    for (int pivot = 0; pivot < 4; pivot++) {
        if ((mat->rows[pivot] & identity_mask[pivot]) != 0) {
            for (int row = pivot + 1; row < 4; row++) {
                if ((mat->rows[row] & identity_mask[pivot]) != 0) {
                    mat->rows[row] ^= mat->rows[pivot];
                    inverse_mat.rows[row] ^= inverse_mat.rows[pivot];
                }
            }
        } else {
            for (int row = pivot + 1; row < 4; row++) {
                if ((mat->rows[row] & identity_mask[pivot]) != 0) {
                    swap_rows(row, pivot, mat);
                    swap_rows(row, pivot, &inverse_mat);
                    break;
                }
            }
            for (int row = pivot + 1; row < 4; row++) {
                if ((mat->rows[row] & identity_mask[pivot]) != 0) {
                    mat->rows[row] ^= mat->rows[pivot];
                    inverse_mat.rows[row] ^= inverse_mat.rows[pivot];
                }
            }
        }
    }
    
    // Backward elimination phase
    for (int pivot = 3; pivot >= 0; pivot--) {
        for (int row = pivot - 1; row >= 0; row--) {
            if ((mat->rows[row] & identity_mask[pivot]) != 0) {
                mat->rows[row] ^= mat->rows[pivot];
                inverse_mat.rows[row] ^= inverse_mat.rows[pivot];
            }
        }
    }
    
    // Copy result back
    copy_matrix(&inverse_mat, mat);
}