Perfect steaming in the graph exists if and only if the determinant of the adjacency matrix of the graph is differ from zero. It is necessary to know whether the arrangement matrix is ​​degenerated. If you count the determinant using np.linalg.det (M), then due to rounding the answer may be incorrect. Question: How can I check the degeneracy of the matrix quickly using Python?

Answer 1, Authority 100%

np.linalg.det (m) Looks like everything comes down to the note of the matrix to the triangular form, with large matrices the accuracy is highly falling due to multiple divisions

But the calculation of the determinant is a redundant operation for your task

Matrix is ​​degenerate if

a = b * const

i.e. One column is equal to the second column, multiplied on some constant

so it can be repelled

for i in range (0, N-1):
  For j in Range (I + 1, N):
    IF Check ([Matrix [i], Matrix [J]):
      Return True.
Return False

How to check 2 columns among themselves – you can calculate the difference between columns dregated to the coefficient:

def check (col1, col2):
  # Calculate conversion coefficient
  CoeFF = COL [1] / COL [2]
  # Check columns
  For i in Range (Len (COL [1]):
    IF ABS (COL1 [I] - COL2 [I] * COEFF) & GT; 1E-10:
      Return False
  Return True.

Since it is necessary to work with floating semicolons, it is often possible that it cannot be obtained, so you can choose some limit near zero, for example 1E-10 or 1E-15 – here you need to see how much accuracy is needed

As a result, compared with the calculation of the determinant, the columns only are divided once to be multiplied by some number, so the accuracy floats weakly, in addition, already in the middle of the check, you can find the same columns and stop further analysis, because the matrix is ​​already degenerate

Here is the full code:

# check if you can submit one column as a product of another column on a constant
DEF Check (col1, col2):
  # Calculate conversion coefficient
  # In this case, you need to find nonzero values ​​otherwise
  FIRST1 = -1.
  FIRST2 = -1.
  For i in Range (Len (col1)):
    IF col1 [i]! = 0 and first1! = -1:
      FIRST1 = I.
    IF col2 [i]! = 0 and first2! = -1:
      FIRST2 = I.
  # If nonzero elements not found - go out
  If first1 == 0 and first2 == 0:
    Return True.
  # Find the coefficient
  First = Max (first1, first2)
  coeff = col1 [first] / col2 [first]
  # Check elements of columns - is it possible to imagine them in the form elem2 = elem1 * const
  For i in Range (Len (col1)):
    IF ABS (COL1 [I] - COL2 [I] * COEFF) & GT; 1E-10:
      Return False
  Return True.
# Check if the matrix is ​​degenerate
DEF is_invertible (Matrix):
  N = Len (Matrix)
  For i in Range (n - 1):
    For j in Range (I + 1, N):
      IF Check (Matrix [i], Matrix [J]):
        Return True.
  Return False
MATRIX1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Matrix2 = [[1, 2, 3], [4, 5, 6], [3, 6, 9]]
Print (Matrix1, IS_INvertible (Matrix1))
Print (Matrix2, IS_INvertible (Matrix2))