Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sympy/matrices/determinant.py

@@ -0,0 +1,898 @@
+from types import FunctionType
+
+from sympy.core.numbers import Float, Integer
+from sympy.core.singleton import S
+from sympy.core.symbol import uniquely_named_symbol
+from sympy.core.mul import Mul
+from sympy.polys import PurePoly, cancel
+from sympy.functions.combinatorial.numbers import nC
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+from .common import NonSquareMatrixError
+from .utilities import (
+    _get_intermediate_simp, _get_intermediate_simp_bool,
+    _iszero, _is_zero_after_expand_mul, _dotprodsimp, _simplify)
+
+
+def _find_reasonable_pivot(col, iszerofunc=_iszero, simpfunc=_simplify):
+    """ Find the lowest index of an item in ``col`` that is
+    suitable for a pivot.  If ``col`` consists only of
+    Floats, the pivot with the largest norm is returned.
+    Otherwise, the first element where ``iszerofunc`` returns
+    False is used.  If ``iszerofunc`` does not return false,
+    items are simplified and retested until a suitable
+    pivot is found.
+
+    Returns a 4-tuple
+        (pivot_offset, pivot_val, assumed_nonzero, newly_determined)
+    where pivot_offset is the index of the pivot, pivot_val is
+    the (possibly simplified) value of the pivot, assumed_nonzero
+    is True if an assumption that the pivot was non-zero
+    was made without being proved, and newly_determined are
+    elements that were simplified during the process of pivot
+    finding."""
+
+    newly_determined = []
+    col = list(col)
+    # a column that contains a mix of floats and integers
+    # but at least one float is considered a numerical
+    # column, and so we do partial pivoting
+    if all(isinstance(x, (Float, Integer)) for x in col) and any(
+            isinstance(x, Float) for x in col):
+        col_abs = [abs(x) for x in col]
+        max_value = max(col_abs)
+        if iszerofunc(max_value):
+            # just because iszerofunc returned True, doesn't
+            # mean the value is numerically zero.  Make sure
+            # to replace all entries with numerical zeros
+            if max_value != 0:
+                newly_determined = [(i, 0) for i, x in enumerate(col) if x != 0]
+            return (None, None, False, newly_determined)
+        index = col_abs.index(max_value)
+        return (index, col[index], False, newly_determined)
+
+    # PASS 1 (iszerofunc directly)
+    possible_zeros = []
+    for i, x in enumerate(col):
+        is_zero = iszerofunc(x)
+        # is someone wrote a custom iszerofunc, it may return
+        # BooleanFalse or BooleanTrue instead of True or False,
+        # so use == for comparison instead of `is`
+        if is_zero == False:
+            # we found something that is definitely not zero
+            return (i, x, False, newly_determined)
+        possible_zeros.append(is_zero)
+
+    # by this point, we've found no certain non-zeros
+    if all(possible_zeros):
+        # if everything is definitely zero, we have
+        # no pivot
+        return (None, None, False, newly_determined)
+
+    # PASS 2 (iszerofunc after simplify)
+    # we haven't found any for-sure non-zeros, so
+    # go through the elements iszerofunc couldn't
+    # make a determination about and opportunistically
+    # simplify to see if we find something
+    for i, x in enumerate(col):
+        if possible_zeros[i] is not None:
+            continue
+        simped = simpfunc(x)
+        is_zero = iszerofunc(simped)
+        if is_zero in (True, False):
+            newly_determined.append((i, simped))
+        if is_zero == False:
+            return (i, simped, False, newly_determined)
+        possible_zeros[i] = is_zero
+
+    # after simplifying, some things that were recognized
+    # as zeros might be zeros
+    if all(possible_zeros):
+        # if everything is definitely zero, we have
+        # no pivot
+        return (None, None, False, newly_determined)
+
+    # PASS 3 (.equals(0))
+    # some expressions fail to simplify to zero, but
+    # ``.equals(0)`` evaluates to True.  As a last-ditch
+    # attempt, apply ``.equals`` to these expressions
+    for i, x in enumerate(col):
+        if possible_zeros[i] is not None:
+            continue
+        if x.equals(S.Zero):
+            # ``.iszero`` may return False with
+            # an implicit assumption (e.g., ``x.equals(0)``
+            # when ``x`` is a symbol), so only treat it
+            # as proved when ``.equals(0)`` returns True
+            possible_zeros[i] = True
+            newly_determined.append((i, S.Zero))
+
+    if all(possible_zeros):
+        return (None, None, False, newly_determined)
+
+    # at this point there is nothing that could definitely
+    # be a pivot.  To maintain compatibility with existing
+    # behavior, we'll assume that an illdetermined thing is
+    # non-zero.  We should probably raise a warning in this case
+    i = possible_zeros.index(None)
+    return (i, col[i], True, newly_determined)
+
+
+def _find_reasonable_pivot_naive(col, iszerofunc=_iszero, simpfunc=None):
+    """
+    Helper that computes the pivot value and location from a
+    sequence of contiguous matrix column elements. As a side effect
+    of the pivot search, this function may simplify some of the elements
+    of the input column. A list of these simplified entries and their
+    indices are also returned.
+    This function mimics the behavior of _find_reasonable_pivot(),
+    but does less work trying to determine if an indeterminate candidate
+    pivot simplifies to zero. This more naive approach can be much faster,
+    with the trade-off that it may erroneously return a pivot that is zero.
+
+    ``col`` is a sequence of contiguous column entries to be searched for
+    a suitable pivot.
+    ``iszerofunc`` is a callable that returns a Boolean that indicates
+    if its input is zero, or None if no such determination can be made.
+    ``simpfunc`` is a callable that simplifies its input. It must return
+    its input if it does not simplify its input. Passing in
+    ``simpfunc=None`` indicates that the pivot search should not attempt
+    to simplify any candidate pivots.
+
+    Returns a 4-tuple:
+    (pivot_offset, pivot_val, assumed_nonzero, newly_determined)
+    ``pivot_offset`` is the sequence index of the pivot.
+    ``pivot_val`` is the value of the pivot.
+    pivot_val and col[pivot_index] are equivalent, but will be different
+    when col[pivot_index] was simplified during the pivot search.
+    ``assumed_nonzero`` is a boolean indicating if the pivot cannot be
+    guaranteed to be zero. If assumed_nonzero is true, then the pivot
+    may or may not be non-zero. If assumed_nonzero is false, then
+    the pivot is non-zero.
+    ``newly_determined`` is a list of index-value pairs of pivot candidates
+    that were simplified during the pivot search.
+    """
+
+    # indeterminates holds the index-value pairs of each pivot candidate
+    # that is neither zero or non-zero, as determined by iszerofunc().
+    # If iszerofunc() indicates that a candidate pivot is guaranteed
+    # non-zero, or that every candidate pivot is zero then the contents
+    # of indeterminates are unused.
+    # Otherwise, the only viable candidate pivots are symbolic.
+    # In this case, indeterminates will have at least one entry,
+    # and all but the first entry are ignored when simpfunc is None.
+    indeterminates = []
+    for i, col_val in enumerate(col):
+        col_val_is_zero = iszerofunc(col_val)
+        if col_val_is_zero == False:
+            # This pivot candidate is non-zero.
+            return i, col_val, False, []
+        elif col_val_is_zero is None:
+            # The candidate pivot's comparison with zero
+            # is indeterminate.
+            indeterminates.append((i, col_val))
+
+    if len(indeterminates) == 0:
+        # All candidate pivots are guaranteed to be zero, i.e. there is
+        # no pivot.
+        return None, None, False, []
+
+    if simpfunc is None:
+        # Caller did not pass in a simplification function that might
+        # determine if an indeterminate pivot candidate is guaranteed
+        # to be nonzero, so assume the first indeterminate candidate
+        # is non-zero.
+        return indeterminates[0][0], indeterminates[0][1], True, []
+
+    # newly_determined holds index-value pairs of candidate pivots
+    # that were simplified during the search for a non-zero pivot.
+    newly_determined = []
+    for i, col_val in indeterminates:
+        tmp_col_val = simpfunc(col_val)
+        if id(col_val) != id(tmp_col_val):
+            # simpfunc() simplified this candidate pivot.
+            newly_determined.append((i, tmp_col_val))
+            if iszerofunc(tmp_col_val) == False:
+                # Candidate pivot simplified to a guaranteed non-zero value.
+                return i, tmp_col_val, False, newly_determined
+
+    return indeterminates[0][0], indeterminates[0][1], True, newly_determined
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _berkowitz_toeplitz_matrix(M):
+    """Return (A,T) where T the Toeplitz matrix used in the Berkowitz algorithm
+    corresponding to ``M`` and A is the first principal submatrix.
+    """
+
+    # the 0 x 0 case is trivial
+    if M.rows == 0 and M.cols == 0:
+        return M._new(1,1, [M.one])
+
+    #
+    # Partition M = [ a_11  R ]
+    #                  [ C     A ]
+    #
+
+    a, R = M[0,0],   M[0, 1:]
+    C, A = M[1:, 0], M[1:,1:]
+
+    #
+    # The Toeplitz matrix looks like
+    #
+    #  [ 1                                     ]
+    #  [ -a         1                          ]
+    #  [ -RC       -a        1                 ]
+    #  [ -RAC     -RC       -a       1         ]
+    #  [ -RA**2C -RAC      -RC      -a       1 ]
+    #  etc.
+
+    # Compute the diagonal entries.
+    # Because multiplying matrix times vector is so much
+    # more efficient than matrix times matrix, recursively
+    # compute -R * A**n * C.
+    diags = [C]
+    for i in range(M.rows - 2):
+        diags.append(A.multiply(diags[i], dotprodsimp=None))
+    diags = [(-R).multiply(d, dotprodsimp=None)[0, 0] for d in diags]
+    diags = [M.one, -a] + diags
+
+    def entry(i,j):
+        if j > i:
+            return M.zero
+        return diags[i - j]
+
+    toeplitz = M._new(M.cols + 1, M.rows, entry)
+    return (A, toeplitz)
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _berkowitz_vector(M):
+    """ Run the Berkowitz algorithm and return a vector whose entries
+        are the coefficients of the characteristic polynomial of ``M``.
+
+        Given N x N matrix, efficiently compute
+        coefficients of characteristic polynomials of ``M``
+        without division in the ground domain.
+
+        This method is particularly useful for computing determinant,
+        principal minors and characteristic polynomial when ``M``
+        has complicated coefficients e.g. polynomials. Semi-direct
+        usage of this algorithm is also important in computing
+        efficiently sub-resultant PRS.
+
+        Assuming that M is a square matrix of dimension N x N and
+        I is N x N identity matrix, then the Berkowitz vector is
+        an N x 1 vector whose entries are coefficients of the
+        polynomial
+
+                        charpoly(M) = det(t*I - M)
+
+        As a consequence, all polynomials generated by Berkowitz
+        algorithm are monic.
+
+        For more information on the implemented algorithm refer to:
+
+        [1] S.J. Berkowitz, On computing the determinant in small
+            parallel time using a small number of processors, ACM,
+            Information Processing Letters 18, 1984, pp. 147-150
+
+        [2] M. Keber, Division-Free computation of sub-resultants
+            using Bezout matrices, Tech. Report MPI-I-2006-1-006,
+            Saarbrucken, 2006
+    """
+
+    # handle the trivial cases
+    if M.rows == 0 and M.cols == 0:
+        return M._new(1, 1, [M.one])
+    elif M.rows == 1 and M.cols == 1:
+        return M._new(2, 1, [M.one, -M[0,0]])
+
+    submat, toeplitz = _berkowitz_toeplitz_matrix(M)
+
+    return toeplitz.multiply(_berkowitz_vector(submat), dotprodsimp=None)
+
+
+def _adjugate(M, method="berkowitz"):
+    """Returns the adjugate, or classical adjoint, of
+    a matrix.  That is, the transpose of the matrix of cofactors.
+
+    https://en.wikipedia.org/wiki/Adjugate
+
+    Parameters
+    ==========
+
+    method : string, optional
+        Method to use to find the cofactors, can be "bareiss", "berkowitz" or
+        "lu".
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> M.adjugate()
+    Matrix([
+    [ 4, -2],
+    [-3,  1]])
+
+    See Also
+    ========
+
+    cofactor_matrix
+    sympy.matrices.common.MatrixCommon.transpose
+    """
+
+    return M.cofactor_matrix(method=method).transpose()
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _charpoly(M, x='lambda', simplify=_simplify):
+    """Computes characteristic polynomial det(x*I - M) where I is
+    the identity matrix.
+
+    A PurePoly is returned, so using different variables for ``x`` does
+    not affect the comparison or the polynomials:
+
+    Parameters
+    ==========
+
+    x : string, optional
+        Name for the "lambda" variable, defaults to "lambda".
+
+    simplify : function, optional
+        Simplification function to use on the characteristic polynomial
+        calculated. Defaults to ``simplify``.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.abc import x, y
+    >>> M = Matrix([[1, 3], [2, 0]])
+    >>> M.charpoly()
+    PurePoly(lambda**2 - lambda - 6, lambda, domain='ZZ')
+    >>> M.charpoly(x) == M.charpoly(y)
+    True
+    >>> M.charpoly(x) == M.charpoly(y)
+    True
+
+    Specifying ``x`` is optional; a symbol named ``lambda`` is used by
+    default (which looks good when pretty-printed in unicode):
+
+    >>> M.charpoly().as_expr()
+    lambda**2 - lambda - 6
+
+    And if ``x`` clashes with an existing symbol, underscores will
+    be prepended to the name to make it unique:
+
+    >>> M = Matrix([[1, 2], [x, 0]])
+    >>> M.charpoly(x).as_expr()
+    _x**2 - _x - 2*x
+
+    Whether you pass a symbol or not, the generator can be obtained
+    with the gen attribute since it may not be the same as the symbol
+    that was passed:
+
+    >>> M.charpoly(x).gen
+    _x
+    >>> M.charpoly(x).gen == x
+    False
+
+    Notes
+    =====
+
+    The Samuelson-Berkowitz algorithm is used to compute
+    the characteristic polynomial efficiently and without any
+    division operations.  Thus the characteristic polynomial over any
+    commutative ring without zero divisors can be computed.
+
+    If the determinant det(x*I - M) can be found out easily as
+    in the case of an upper or a lower triangular matrix, then
+    instead of Samuelson-Berkowitz algorithm, eigenvalues are computed
+    and the characteristic polynomial with their help.
+
+    See Also
+    ========
+
+    det
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError()
+    if M.is_lower or M.is_upper:
+        diagonal_elements = M.diagonal()
+        x = uniquely_named_symbol(x, diagonal_elements, modify=lambda s: '_' + s)
+        m = 1
+        for i in diagonal_elements:
+            m = m * (x - simplify(i))
+        return PurePoly(m, x)
+
+    berk_vector = _berkowitz_vector(M)
+    x = uniquely_named_symbol(x, berk_vector, modify=lambda s: '_' + s)
+
+    return PurePoly([simplify(a) for a in berk_vector], x)
+
+
+def _cofactor(M, i, j, method="berkowitz"):
+    """Calculate the cofactor of an element.
+
+    Parameters
+    ==========
+
+    method : string, optional
+        Method to use to find the cofactors, can be "bareiss", "berkowitz" or
+        "lu".
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> M.cofactor(0, 1)
+    -3
+
+    See Also
+    ========
+
+    cofactor_matrix
+    minor
+    minor_submatrix
+    """
+
+    if not M.is_square or M.rows < 1:
+        raise NonSquareMatrixError()
+
+    return S.NegativeOne**((i + j) % 2) * M.minor(i, j, method)
+
+
+def _cofactor_matrix(M, method="berkowitz"):
+    """Return a matrix containing the cofactor of each element.
+
+    Parameters
+    ==========
+
+    method : string, optional
+        Method to use to find the cofactors, can be "bareiss", "berkowitz" or
+        "lu".
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> M.cofactor_matrix()
+    Matrix([
+    [ 4, -3],
+    [-2,  1]])
+
+    See Also
+    ========
+
+    cofactor
+    minor
+    minor_submatrix
+    """
+
+    if not M.is_square or M.rows < 1:
+        raise NonSquareMatrixError()
+
+    return M._new(M.rows, M.cols,
+            lambda i, j: M.cofactor(i, j, method))
+
+def _per(M):
+    """Returns the permanent of a matrix. Unlike determinant,
+    permanent is defined for both square and non-square matrices.
+
+    For an m x n matrix, with m less than or equal to n,
+    it is given as the sum over the permutations s of size
+    less than or equal to m on [1, 2, . . . n] of the product
+    from i = 1 to m of M[i, s[i]]. Taking the transpose will
+    not affect the value of the permanent.
+
+    In the case of a square matrix, this is the same as the permutation
+    definition of the determinant, but it does not take the sign of the
+    permutation into account. Computing the permanent with this definition
+    is quite inefficient, so here the Ryser formula is used.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> M.per()
+    450
+    >>> M = Matrix([1, 5, 7])
+    >>> M.per()
+    13
+
+    References
+    ==========
+
+    .. [1] Prof. Frank Ben's notes: https://math.berkeley.edu/~bernd/ban275.pdf
+    .. [2] Wikipedia article on Permanent: https://en.wikipedia.org/wiki/Permanent_%28mathematics%29
+    .. [3] https://reference.wolfram.com/language/ref/Permanent.html
+    .. [4] Permanent of a rectangular matrix : https://arxiv.org/pdf/0904.3251.pdf
+    """
+    import itertools
+
+    m, n = M.shape
+    if m > n:
+        M = M.T
+        m, n = n, m
+    s = list(range(n))
+
+    subsets = []
+    for i in range(1, m + 1):
+        subsets += list(map(list, itertools.combinations(s, i)))
+
+    perm = 0
+    for subset in subsets:
+        prod = 1
+        sub_len = len(subset)
+        for i in range(m):
+             prod *= sum([M[i, j] for j in subset])
+        perm += prod * S.NegativeOne**sub_len * nC(n - sub_len, m - sub_len)
+    perm *= S.NegativeOne**m
+    return perm.simplify()
+
+def _det_DOM(M):
+    DOM = DomainMatrix.from_Matrix(M, field=True, extension=True)
+    K = DOM.domain
+    return K.to_sympy(DOM.det())
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _det(M, method="bareiss", iszerofunc=None):
+    """Computes the determinant of a matrix if ``M`` is a concrete matrix object
+    otherwise return an expressions ``Determinant(M)`` if ``M`` is a
+    ``MatrixSymbol`` or other expression.
+
+    Parameters
+    ==========
+
+    method : string, optional
+        Specifies the algorithm used for computing the matrix determinant.
+
+        If the matrix is at most 3x3, a hard-coded formula is used and the
+        specified method is ignored. Otherwise, it defaults to
+        ``'bareiss'``.
+
+        Also, if the matrix is an upper or a lower triangular matrix, determinant
+        is computed by simple multiplication of diagonal elements, and the
+        specified method is ignored.
+
+        If it is set to ``'domain-ge'``, then Gaussian elimination method will
+        be used via using DomainMatrix.
+
+        If it is set to ``'bareiss'``, Bareiss' fraction-free algorithm will
+        be used.
+
+        If it is set to ``'berkowitz'``, Berkowitz' algorithm will be used.
+
+        Otherwise, if it is set to ``'lu'``, LU decomposition will be used.
+
+        .. note::
+            For backward compatibility, legacy keys like "bareis" and
+            "det_lu" can still be used to indicate the corresponding
+            methods.
+            And the keys are also case-insensitive for now. However, it is
+            suggested to use the precise keys for specifying the method.
+
+    iszerofunc : FunctionType or None, optional
+        If it is set to ``None``, it will be defaulted to ``_iszero`` if the
+        method is set to ``'bareiss'``, and ``_is_zero_after_expand_mul`` if
+        the method is set to ``'lu'``.
+
+        It can also accept any user-specified zero testing function, if it
+        is formatted as a function which accepts a single symbolic argument
+        and returns ``True`` if it is tested as zero and ``False`` if it
+        tested as non-zero, and also ``None`` if it is undecidable.
+
+    Returns
+    =======
+
+    det : Basic
+        Result of determinant.
+
+    Raises
+    ======
+
+    ValueError
+        If unrecognized keys are given for ``method`` or ``iszerofunc``.
+
+    NonSquareMatrixError
+        If attempted to calculate determinant from a non-square matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, eye, det
+    >>> I3 = eye(3)
+    >>> det(I3)
+    1
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> det(M)
+    -2
+    >>> det(M) == M.det()
+    True
+    >>> M.det(method="domain-ge")
+    -2
+    """
+
+    # sanitize `method`
+    method = method.lower()
+
+    if method == "bareis":
+        method = "bareiss"
+    elif method == "det_lu":
+        method = "lu"
+
+    if method not in ("bareiss", "berkowitz", "lu", "domain-ge"):
+        raise ValueError("Determinant method '%s' unrecognized" % method)
+
+    if iszerofunc is None:
+        if method == "bareiss":
+            iszerofunc = _is_zero_after_expand_mul
+        elif method == "lu":
+            iszerofunc = _iszero
+
+    elif not isinstance(iszerofunc, FunctionType):
+        raise ValueError("Zero testing method '%s' unrecognized" % iszerofunc)
+
+    n = M.rows
+
+    if n == M.cols: # square check is done in individual method functions
+        if n == 0:
+            return M.one
+        elif n == 1:
+            return M[0, 0]
+        elif n == 2:
+            m = M[0, 0] * M[1, 1] - M[0, 1] * M[1, 0]
+            return _get_intermediate_simp(_dotprodsimp)(m)
+        elif n == 3:
+            m =  (M[0, 0] * M[1, 1] * M[2, 2]
+                + M[0, 1] * M[1, 2] * M[2, 0]
+                + M[0, 2] * M[1, 0] * M[2, 1]
+                - M[0, 2] * M[1, 1] * M[2, 0]
+                - M[0, 0] * M[1, 2] * M[2, 1]
+                - M[0, 1] * M[1, 0] * M[2, 2])
+            return _get_intermediate_simp(_dotprodsimp)(m)
+
+    dets = []
+    for b in M.strongly_connected_components():
+        if method == "domain-ge": # uses DomainMatrix to evaluate determinant
+            det = _det_DOM(M[b, b])
+        elif method == "bareiss":
+            det = M[b, b]._eval_det_bareiss(iszerofunc=iszerofunc)
+        elif method == "berkowitz":
+            det = M[b, b]._eval_det_berkowitz()
+        elif method == "lu":
+            det = M[b, b]._eval_det_lu(iszerofunc=iszerofunc)
+        dets.append(det)
+    return Mul(*dets)
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _det_bareiss(M, iszerofunc=_is_zero_after_expand_mul):
+    """Compute matrix determinant using Bareiss' fraction-free
+    algorithm which is an extension of the well known Gaussian
+    elimination method. This approach is best suited for dense
+    symbolic matrices and will result in a determinant with
+    minimal number of fractions. It means that less term
+    rewriting is needed on resulting formulae.
+
+    Parameters
+    ==========
+
+    iszerofunc : function, optional
+        The function to use to determine zeros when doing an LU decomposition.
+        Defaults to ``lambda x: x.is_zero``.
+
+    TODO: Implement algorithm for sparse matrices (SFF),
+    http://www.eecis.udel.edu/~saunders/papers/sffge/it5.ps.
+    """
+
+    # Recursively implemented Bareiss' algorithm as per Deanna Richelle Leggett's
+    # thesis http://www.math.usm.edu/perry/Research/Thesis_DRL.pdf
+    def bareiss(mat, cumm=1):
+        if mat.rows == 0:
+            return mat.one
+        elif mat.rows == 1:
+            return mat[0, 0]
+
+        # find a pivot and extract the remaining matrix
+        # With the default iszerofunc, _find_reasonable_pivot slows down
+        # the computation by the factor of 2.5 in one test.
+        # Relevant issues: #10279 and #13877.
+        pivot_pos, pivot_val, _, _ = _find_reasonable_pivot(mat[:, 0], iszerofunc=iszerofunc)
+        if pivot_pos is None:
+            return mat.zero
+
+        # if we have a valid pivot, we'll do a "row swap", so keep the
+        # sign of the det
+        sign = (-1) ** (pivot_pos % 2)
+
+        # we want every row but the pivot row and every column
+        rows = [i for i in range(mat.rows) if i != pivot_pos]
+        cols = list(range(mat.cols))
+        tmp_mat = mat.extract(rows, cols)
+
+        def entry(i, j):
+            ret = (pivot_val*tmp_mat[i, j + 1] - mat[pivot_pos, j + 1]*tmp_mat[i, 0]) / cumm
+            if _get_intermediate_simp_bool(True):
+                return _dotprodsimp(ret)
+            elif not ret.is_Atom:
+                return cancel(ret)
+            return ret
+
+        return sign*bareiss(M._new(mat.rows - 1, mat.cols - 1, entry), pivot_val)
+
+    if not M.is_square:
+        raise NonSquareMatrixError()
+
+    if M.rows == 0:
+        return M.one
+        # sympy/matrices/tests/test_matrices.py contains a test that
+        # suggests that the determinant of a 0 x 0 matrix is one, by
+        # convention.
+
+    return bareiss(M)
+
+
+def _det_berkowitz(M):
+    """ Use the Berkowitz algorithm to compute the determinant."""
+
+    if not M.is_square:
+        raise NonSquareMatrixError()
+
+    if M.rows == 0:
+        return M.one
+        # sympy/matrices/tests/test_matrices.py contains a test that
+        # suggests that the determinant of a 0 x 0 matrix is one, by
+        # convention.
+
+    berk_vector = _berkowitz_vector(M)
+    return (-1)**(len(berk_vector) - 1) * berk_vector[-1]
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _det_LU(M, iszerofunc=_iszero, simpfunc=None):
+    """ Computes the determinant of a matrix from its LU decomposition.
+    This function uses the LU decomposition computed by
+    LUDecomposition_Simple().
+
+    The keyword arguments iszerofunc and simpfunc are passed to
+    LUDecomposition_Simple().
+    iszerofunc is a callable that returns a boolean indicating if its
+    input is zero, or None if it cannot make the determination.
+    simpfunc is a callable that simplifies its input.
+    The default is simpfunc=None, which indicate that the pivot search
+    algorithm should not attempt to simplify any candidate pivots.
+    If simpfunc fails to simplify its input, then it must return its input
+    instead of a copy.
+
+    Parameters
+    ==========
+
+    iszerofunc : function, optional
+        The function to use to determine zeros when doing an LU decomposition.
+        Defaults to ``lambda x: x.is_zero``.
+
+    simpfunc : function, optional
+        The simplification function to use when looking for zeros for pivots.
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError()
+
+    if M.rows == 0:
+        return M.one
+        # sympy/matrices/tests/test_matrices.py contains a test that
+        # suggests that the determinant of a 0 x 0 matrix is one, by
+        # convention.
+
+    lu, row_swaps = M.LUdecomposition_Simple(iszerofunc=iszerofunc,
+            simpfunc=simpfunc)
+    # P*A = L*U => det(A) = det(L)*det(U)/det(P) = det(P)*det(U).
+    # Lower triangular factor L encoded in lu has unit diagonal => det(L) = 1.
+    # P is a permutation matrix => det(P) in {-1, 1} => 1/det(P) = det(P).
+    # LUdecomposition_Simple() returns a list of row exchange index pairs, rather
+    # than a permutation matrix, but det(P) = (-1)**len(row_swaps).
+
+    # Avoid forming the potentially time consuming  product of U's diagonal entries
+    # if the product is zero.
+    # Bottom right entry of U is 0 => det(A) = 0.
+    # It may be impossible to determine if this entry of U is zero when it is symbolic.
+    if iszerofunc(lu[lu.rows-1, lu.rows-1]):
+        return M.zero
+
+    # Compute det(P)
+    det = -M.one if len(row_swaps)%2 else M.one
+
+    # Compute det(U) by calculating the product of U's diagonal entries.
+    # The upper triangular portion of lu is the upper triangular portion of the
+    # U factor in the LU decomposition.
+    for k in range(lu.rows):
+        det *= lu[k, k]
+
+    # return det(P)*det(U)
+    return det
+
+
+def _minor(M, i, j, method="berkowitz"):
+    """Return the (i,j) minor of ``M``.  That is,
+    return the determinant of the matrix obtained by deleting
+    the `i`th row and `j`th column from ``M``.
+
+    Parameters
+    ==========
+
+    i, j : int
+        The row and column to exclude to obtain the submatrix.
+
+    method : string, optional
+        Method to use to find the determinant of the submatrix, can be
+        "bareiss", "berkowitz" or "lu".
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> M.minor(1, 1)
+    -12
+
+    See Also
+    ========
+
+    minor_submatrix
+    cofactor
+    det
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError()
+
+    return M.minor_submatrix(i, j).det(method=method)
+
+
+def _minor_submatrix(M, i, j):
+    """Return the submatrix obtained by removing the `i`th row
+    and `j`th column from ``M`` (works with Pythonic negative indices).
+
+    Parameters
+    ==========
+
+    i, j : int
+        The row and column to exclude to obtain the submatrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> M.minor_submatrix(1, 1)
+    Matrix([
+    [1, 3],
+    [7, 9]])
+
+    See Also
+    ========
+
+    minor
+    cofactor
+    """
+
+    if i < 0:
+        i += M.rows
+    if j < 0:
+        j += M.cols
+
+    if not 0 <= i < M.rows or not 0 <= j < M.cols:
+        raise ValueError("`i` and `j` must satisfy 0 <= i < ``M.rows`` "
+                            "(%d)" % M.rows + "and 0 <= j < ``M.cols`` (%d)." % M.cols)
+
+    rows = [a for a in range(M.rows) if a != i]
+    cols = [a for a in range(M.cols) if a != j]
+
+    return M.extract(rows, cols)

llmeval-env/lib/python3.10/site-packages/sympy/matrices/expressions/kronecker.py

@@ -0,0 +1,434 @@
+"""Implementation of the Kronecker product"""
+from functools import reduce
+from math import prod
+
+from sympy.core import Mul, sympify
+from sympy.functions import adjoint
+from sympy.matrices.common import ShapeError
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.transpose import transpose
+from sympy.matrices.expressions.special import Identity
+from sympy.matrices.matrices import MatrixBase
+from sympy.strategies import (
+    canon, condition, distribute, do_one, exhaust, flatten, typed, unpack)
+from sympy.strategies.traverse import bottom_up
+from sympy.utilities import sift
+
+from .matadd import MatAdd
+from .matmul import MatMul
+from .matpow import MatPow
+
+
+def kronecker_product(*matrices):
+    """
+    The Kronecker product of two or more arguments.
+
+    This computes the explicit Kronecker product for subclasses of
+    ``MatrixBase`` i.e. explicit matrices. Otherwise, a symbolic
+    ``KroneckerProduct`` object is returned.
+
+
+    Examples
+    ========
+
+    For ``MatrixSymbol`` arguments a ``KroneckerProduct`` object is returned.
+    Elements of this matrix can be obtained by indexing, or for MatrixSymbols
+    with known dimension the explicit matrix can be obtained with
+    ``.as_explicit()``
+
+    >>> from sympy import kronecker_product, MatrixSymbol
+    >>> A = MatrixSymbol('A', 2, 2)
+    >>> B = MatrixSymbol('B', 2, 2)
+    >>> kronecker_product(A)
+    A
+    >>> kronecker_product(A, B)
+    KroneckerProduct(A, B)
+    >>> kronecker_product(A, B)[0, 1]
+    A[0, 0]*B[0, 1]
+    >>> kronecker_product(A, B).as_explicit()
+    Matrix([
+        [A[0, 0]*B[0, 0], A[0, 0]*B[0, 1], A[0, 1]*B[0, 0], A[0, 1]*B[0, 1]],
+        [A[0, 0]*B[1, 0], A[0, 0]*B[1, 1], A[0, 1]*B[1, 0], A[0, 1]*B[1, 1]],
+        [A[1, 0]*B[0, 0], A[1, 0]*B[0, 1], A[1, 1]*B[0, 0], A[1, 1]*B[0, 1]],
+        [A[1, 0]*B[1, 0], A[1, 0]*B[1, 1], A[1, 1]*B[1, 0], A[1, 1]*B[1, 1]]])
+
+    For explicit matrices the Kronecker product is returned as a Matrix
+
+    >>> from sympy import Matrix, kronecker_product
+    >>> sigma_x = Matrix([
+    ... [0, 1],
+    ... [1, 0]])
+    ...
+    >>> Isigma_y = Matrix([
+    ... [0, 1],
+    ... [-1, 0]])
+    ...
+    >>> kronecker_product(sigma_x, Isigma_y)
+    Matrix([
+    [ 0, 0,  0, 1],
+    [ 0, 0, -1, 0],
+    [ 0, 1,  0, 0],
+    [-1, 0,  0, 0]])
+
+    See Also
+    ========
+        KroneckerProduct
+
+    """
+    if not matrices:
+        raise TypeError("Empty Kronecker product is undefined")
+    if len(matrices) == 1:
+        return matrices[0]
+    else:
+        return KroneckerProduct(*matrices).doit()
+
+
+class KroneckerProduct(MatrixExpr):
+    """
+    The Kronecker product of two or more arguments.
+
+    The Kronecker product is a non-commutative product of matrices.
+    Given two matrices of dimension (m, n) and (s, t) it produces a matrix
+    of dimension (m s, n t).
+
+    This is a symbolic object that simply stores its argument without
+    evaluating it. To actually compute the product, use the function
+    ``kronecker_product()`` or call the ``.doit()`` or  ``.as_explicit()``
+    methods.
+
+    >>> from sympy import KroneckerProduct, MatrixSymbol
+    >>> A = MatrixSymbol('A', 5, 5)
+    >>> B = MatrixSymbol('B', 5, 5)
+    >>> isinstance(KroneckerProduct(A, B), KroneckerProduct)
+    True
+    """
+    is_KroneckerProduct = True
+
+    def __new__(cls, *args, check=True):
+        args = list(map(sympify, args))
+        if all(a.is_Identity for a in args):
+            ret = Identity(prod(a.rows for a in args))
+            if all(isinstance(a, MatrixBase) for a in args):
+                return ret.as_explicit()
+            else:
+                return ret
+
+        if check:
+            validate(*args)
+        return super().__new__(cls, *args)
+
+    @property
+    def shape(self):
+        rows, cols = self.args[0].shape
+        for mat in self.args[1:]:
+            rows *= mat.rows
+            cols *= mat.cols
+        return (rows, cols)
+
+    def _entry(self, i, j, **kwargs):
+        result = 1
+        for mat in reversed(self.args):
+            i, m = divmod(i, mat.rows)
+            j, n = divmod(j, mat.cols)
+            result *= mat[m, n]
+        return result
+
+    def _eval_adjoint(self):
+        return KroneckerProduct(*list(map(adjoint, self.args))).doit()
+
+    def _eval_conjugate(self):
+        return KroneckerProduct(*[a.conjugate() for a in self.args]).doit()
+
+    def _eval_transpose(self):
+        return KroneckerProduct(*list(map(transpose, self.args))).doit()
+
+    def _eval_trace(self):
+        from .trace import trace
+        return Mul(*[trace(a) for a in self.args])
+
+    def _eval_determinant(self):
+        from .determinant import det, Determinant
+        if not all(a.is_square for a in self.args):
+            return Determinant(self)
+
+        m = self.rows
+        return Mul(*[det(a)**(m/a.rows) for a in self.args])
+
+    def _eval_inverse(self):
+        try:
+            return KroneckerProduct(*[a.inverse() for a in self.args])
+        except ShapeError:
+            from sympy.matrices.expressions.inverse import Inverse
+            return Inverse(self)
+
+    def structurally_equal(self, other):
+        '''Determine whether two matrices have the same Kronecker product structure
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerProduct, MatrixSymbol, symbols
+        >>> m, n = symbols(r'm, n', integer=True)
+        >>> A = MatrixSymbol('A', m, m)
+        >>> B = MatrixSymbol('B', n, n)
+        >>> C = MatrixSymbol('C', m, m)
+        >>> D = MatrixSymbol('D', n, n)
+        >>> KroneckerProduct(A, B).structurally_equal(KroneckerProduct(C, D))
+        True
+        >>> KroneckerProduct(A, B).structurally_equal(KroneckerProduct(D, C))
+        False
+        >>> KroneckerProduct(A, B).structurally_equal(C)
+        False
+        '''
+        # Inspired by BlockMatrix
+        return (isinstance(other, KroneckerProduct)
+                and self.shape == other.shape
+                and len(self.args) == len(other.args)
+                and all(a.shape == b.shape for (a, b) in zip(self.args, other.args)))
+
+    def has_matching_shape(self, other):
+        '''Determine whether two matrices have the appropriate structure to bring matrix
+        multiplication inside the KroneckerProdut
+
+        Examples
+        ========
+        >>> from sympy import KroneckerProduct, MatrixSymbol, symbols
+        >>> m, n = symbols(r'm, n', integer=True)
+        >>> A = MatrixSymbol('A', m, n)
+        >>> B = MatrixSymbol('B', n, m)
+        >>> KroneckerProduct(A, B).has_matching_shape(KroneckerProduct(B, A))
+        True
+        >>> KroneckerProduct(A, B).has_matching_shape(KroneckerProduct(A, B))
+        False
+        >>> KroneckerProduct(A, B).has_matching_shape(A)
+        False
+        '''
+        return (isinstance(other, KroneckerProduct)
+                and self.cols == other.rows
+                and len(self.args) == len(other.args)
+                and all(a.cols == b.rows for (a, b) in zip(self.args, other.args)))
+
+    def _eval_expand_kroneckerproduct(self, **hints):
+        return flatten(canon(typed({KroneckerProduct: distribute(KroneckerProduct, MatAdd)}))(self))
+
+    def _kronecker_add(self, other):
+        if self.structurally_equal(other):
+            return self.__class__(*[a + b for (a, b) in zip(self.args, other.args)])
+        else:
+            return self + other
+
+    def _kronecker_mul(self, other):
+        if self.has_matching_shape(other):
+            return self.__class__(*[a*b for (a, b) in zip(self.args, other.args)])
+        else:
+            return self * other
+
+    def doit(self, **hints):
+        deep = hints.get('deep', True)
+        if deep:
+            args = [arg.doit(**hints) for arg in self.args]
+        else:
+            args = self.args
+        return canonicalize(KroneckerProduct(*args))
+
+
+def validate(*args):
+    if not all(arg.is_Matrix for arg in args):
+        raise TypeError("Mix of Matrix and Scalar symbols")
+
+
+# rules
+
+def extract_commutative(kron):
+    c_part = []
+    nc_part = []
+    for arg in kron.args:
+        c, nc = arg.args_cnc()
+        c_part.extend(c)
+        nc_part.append(Mul._from_args(nc))
+
+    c_part = Mul(*c_part)
+    if c_part != 1:
+        return c_part*KroneckerProduct(*nc_part)
+    return kron
+
+
+def matrix_kronecker_product(*matrices):
+    """Compute the Kronecker product of a sequence of SymPy Matrices.
+
+    This is the standard Kronecker product of matrices [1].
+
+    Parameters
+    ==========
+
+    matrices : tuple of MatrixBase instances
+        The matrices to take the Kronecker product of.
+
+    Returns
+    =======
+
+    matrix : MatrixBase
+        The Kronecker product matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.matrices.expressions.kronecker import (
+    ... matrix_kronecker_product)
+
+    >>> m1 = Matrix([[1,2],[3,4]])
+    >>> m2 = Matrix([[1,0],[0,1]])
+    >>> matrix_kronecker_product(m1, m2)
+    Matrix([
+    [1, 0, 2, 0],
+    [0, 1, 0, 2],
+    [3, 0, 4, 0],
+    [0, 3, 0, 4]])
+    >>> matrix_kronecker_product(m2, m1)
+    Matrix([
+    [1, 2, 0, 0],
+    [3, 4, 0, 0],
+    [0, 0, 1, 2],
+    [0, 0, 3, 4]])
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Kronecker_product
+    """
+    # Make sure we have a sequence of Matrices
+    if not all(isinstance(m, MatrixBase) for m in matrices):
+        raise TypeError(
+            'Sequence of Matrices expected, got: %s' % repr(matrices)
+        )
+
+    # Pull out the first element in the product.
+    matrix_expansion = matrices[-1]
+    # Do the kronecker product working from right to left.
+    for mat in reversed(matrices[:-1]):
+        rows = mat.rows
+        cols = mat.cols
+        # Go through each row appending kronecker product to.
+        # running matrix_expansion.
+        for i in range(rows):
+            start = matrix_expansion*mat[i*cols]
+            # Go through each column joining each item
+            for j in range(cols - 1):
+                start = start.row_join(
+                    matrix_expansion*mat[i*cols + j + 1]
+                )
+            # If this is the first element, make it the start of the
+            # new row.
+            if i == 0:
+                next = start
+            else:
+                next = next.col_join(start)
+        matrix_expansion = next
+
+    MatrixClass = max(matrices, key=lambda M: M._class_priority).__class__
+    if isinstance(matrix_expansion, MatrixClass):
+        return matrix_expansion
+    else:
+        return MatrixClass(matrix_expansion)
+
+
+def explicit_kronecker_product(kron):
+    # Make sure we have a sequence of Matrices
+    if not all(isinstance(m, MatrixBase) for m in kron.args):
+        return kron
+
+    return matrix_kronecker_product(*kron.args)
+
+
+rules = (unpack,
+         explicit_kronecker_product,
+         flatten,
+         extract_commutative)
+
+canonicalize = exhaust(condition(lambda x: isinstance(x, KroneckerProduct),
+                                 do_one(*rules)))
+
+
+def _kronecker_dims_key(expr):
+    if isinstance(expr, KroneckerProduct):
+        return tuple(a.shape for a in expr.args)
+    else:
+        return (0,)
+
+
+def kronecker_mat_add(expr):
+    args = sift(expr.args, _kronecker_dims_key)
+    nonkrons = args.pop((0,), None)
+    if not args:
+        return expr
+
+    krons = [reduce(lambda x, y: x._kronecker_add(y), group)
+             for group in args.values()]
+
+    if not nonkrons:
+        return MatAdd(*krons)
+    else:
+        return MatAdd(*krons) + nonkrons
+
+
+def kronecker_mat_mul(expr):
+    # modified from block matrix code
+    factor, matrices = expr.as_coeff_matrices()
+
+    i = 0
+    while i < len(matrices) - 1:
+        A, B = matrices[i:i+2]
+        if isinstance(A, KroneckerProduct) and isinstance(B, KroneckerProduct):
+            matrices[i] = A._kronecker_mul(B)
+            matrices.pop(i+1)
+        else:
+            i += 1
+
+    return factor*MatMul(*matrices)
+
+
+def kronecker_mat_pow(expr):
+    if isinstance(expr.base, KroneckerProduct) and all(a.is_square for a in expr.base.args):
+        return KroneckerProduct(*[MatPow(a, expr.exp) for a in expr.base.args])
+    else:
+        return expr
+
+
+def combine_kronecker(expr):
+    """Combine KronekeckerProduct with expression.
+
+    If possible write operations on KroneckerProducts of compatible shapes
+    as a single KroneckerProduct.
+
+    Examples
+    ========
+
+    >>> from sympy.matrices.expressions import combine_kronecker
+    >>> from sympy import MatrixSymbol, KroneckerProduct, symbols
+    >>> m, n = symbols(r'm, n', integer=True)
+    >>> A = MatrixSymbol('A', m, n)
+    >>> B = MatrixSymbol('B', n, m)
+    >>> combine_kronecker(KroneckerProduct(A, B)*KroneckerProduct(B, A))
+    KroneckerProduct(A*B, B*A)
+    >>> combine_kronecker(KroneckerProduct(A, B)+KroneckerProduct(B.T, A.T))
+    KroneckerProduct(A + B.T, B + A.T)
+    >>> C = MatrixSymbol('C', n, n)
+    >>> D = MatrixSymbol('D', m, m)
+    >>> combine_kronecker(KroneckerProduct(C, D)**m)
+    KroneckerProduct(C**m, D**m)
+    """
+    def haskron(expr):
+        return isinstance(expr, MatrixExpr) and expr.has(KroneckerProduct)
+
+    rule = exhaust(
+        bottom_up(exhaust(condition(haskron, typed(
+            {MatAdd: kronecker_mat_add,
+             MatMul: kronecker_mat_mul,
+             MatPow: kronecker_mat_pow})))))
+    result = rule(expr)
+    doit = getattr(result, 'doit', None)
+    if doit is not None:
+        return doit()
+    else:
+        return result