Add files using upload-large-folder tool

.gitattributes

@@ -745,3 +745,4 @@ phi4/lib/libtinfow.so.6.4 filter=lfs diff=lfs merge=lfs -text
 openflamingo/lib/python3.10/site-packages/pycocoevalcap/spice/lib/guava-19.0.jar filter=lfs diff=lfs merge=lfs -text
 openflamingo/lib/python3.10/site-packages/torch/__pycache__/overrides.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 phi4/lib/python3.10/site-packages/transformers/models/seamless_m4t_v2/__pycache__/modeling_seamless_m4t_v2.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+phi4/lib/python3.10/site-packages/sympy/physics/quantum/tests/__pycache__/test_spin.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/_transformer_encoder_layer_fwd_cuda_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor _transformer_encoder_layer_fwd(const at::Tensor & src, int64_t embed_dim, int64_t num_heads, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, bool use_gelu, bool norm_first, double eps, const at::Tensor & norm_weight_1, const at::Tensor & norm_bias_1, const at::Tensor & norm_weight_2, const at::Tensor & norm_bias_2, const at::Tensor & ffn_weight_1, const at::Tensor & ffn_bias_1, const at::Tensor & ffn_weight_2, const at::Tensor & ffn_bias_2, const c10::optional<at::Tensor> & mask={}, c10::optional<int64_t> mask_type=c10::nullopt);
+
+} // namespace cuda
+} // namespace at

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/avg_pool3d_backward_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_avg_pool3d_backward : public at::impl::MetaBase {
+    
+    
+    void meta(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, c10::optional<int64_t> divisor_override);
+};
+
+} // namespace native
+} // namespace at

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/geqrf_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API geqrf_a {
+  using schema = ::std::tuple<at::Tensor &,at::Tensor &> (const at::Tensor &, at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::geqrf")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "a")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "geqrf.a(Tensor self, *, Tensor(a!) a, Tensor(b!) tau) -> (Tensor(a!) a, Tensor(b!) tau)")
+  static ::std::tuple<at::Tensor &,at::Tensor &> call(const at::Tensor & self, at::Tensor & a, at::Tensor & tau);
+  static ::std::tuple<at::Tensor &,at::Tensor &> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Tensor & a, at::Tensor & tau);
+};
+
+struct TORCH_API geqrf {
+  using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::geqrf")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "geqrf(Tensor self) -> (Tensor a, Tensor tau)")
+  static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & self);
+  static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+}} // namespace at::_ops

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/is_distributed_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API bool is_distributed(const at::Tensor & self);
+} // namespace native
+} // namespace at

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/polygamma_native.h

@@ -0,0 +1,24 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+#include <ATen/ops/polygamma_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_polygamma_out : public at::meta::structured_polygamma {
+void impl(int64_t n, const at::Tensor & self, const at::Tensor & out);
+};
+TORCH_API at::Tensor & polygamma_(at::Tensor & self, int64_t n);
+} // namespace native
+} // namespace at

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/replication_pad2d_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API replication_pad2d_out {
+  using schema = at::Tensor & (const at::Tensor &, c10::SymIntArrayRef, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::replication_pad2d")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "replication_pad2d.out(Tensor self, SymInt[4] padding, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out);
+};
+
+struct TORCH_API replication_pad2d {
+  using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::replication_pad2d")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "replication_pad2d(Tensor self, SymInt[4] padding) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, c10::SymIntArrayRef padding);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef padding);
+};
+
+}} // namespace at::_ops

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/rnn_relu_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API rnn_relu_input {
+  using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rnn_relu")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "input")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rnn_relu.input(Tensor input, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & input, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
+  static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
+};
+
+struct TORCH_API rnn_relu_data {
+  using schema = ::std::tuple<at::Tensor,at::Tensor> (const at::Tensor &, const at::Tensor &, const at::Tensor &, at::TensorList, bool, int64_t, double, bool, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rnn_relu")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "data")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rnn_relu.data(Tensor data, Tensor batch_sizes, Tensor hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor)")
+  static ::std::tuple<at::Tensor,at::Tensor> call(const at::Tensor & data, const at::Tensor & batch_sizes, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional);
+  static ::std::tuple<at::Tensor,at::Tensor> redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & data, const at::Tensor & batch_sizes, const at::Tensor & hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional);
+};
+
+}} // namespace at::_ops

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/special_i1_cuda_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor special_i1(const at::Tensor & self);
+TORCH_API at::Tensor & special_i1_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & special_i1_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace cuda
+} // namespace at

openflamingo/lib/python3.10/site-packages/torch/include/ATen/ops/triu_compositeexplicitautogradnonfunctional_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautogradnonfunctional {
+
+TORCH_API at::Tensor triu(const at::Tensor & self, int64_t diagonal=0);
+TORCH_API at::Tensor & triu_(at::Tensor & self, int64_t diagonal=0);
+
+} // namespace compositeexplicitautogradnonfunctional
+} // namespace at

phi4/lib/python3.10/site-packages/sympy/matrices/__init__.py

@@ -0,0 +1,72 @@
+"""A module that handles matrices.
+
+Includes functions for fast creating matrices like zero, one/eye, random
+matrix, etc.
+"""
+from .exceptions import ShapeError, NonSquareMatrixError
+from .kind import MatrixKind
+from .dense import (
+    GramSchmidt, casoratian, diag, eye, hessian, jordan_cell,
+    list2numpy, matrix2numpy, matrix_multiply_elementwise, ones,
+    randMatrix, rot_axis1, rot_axis2, rot_axis3, rot_ccw_axis1,
+    rot_ccw_axis2, rot_ccw_axis3, rot_givens,
+    symarray, wronskian, zeros)
+from .dense import MutableDenseMatrix
+from .matrixbase import DeferredVector, MatrixBase
+
+MutableMatrix = MutableDenseMatrix
+Matrix = MutableMatrix
+
+from .sparse import MutableSparseMatrix
+from .sparsetools import banded
+from .immutable import ImmutableDenseMatrix, ImmutableSparseMatrix
+
+ImmutableMatrix = ImmutableDenseMatrix
+SparseMatrix = MutableSparseMatrix
+
+from .expressions import (
+    MatrixSlice, BlockDiagMatrix, BlockMatrix, FunctionMatrix, Identity,
+    Inverse, MatAdd, MatMul, MatPow, MatrixExpr, MatrixSymbol, Trace,
+    Transpose, ZeroMatrix, OneMatrix, blockcut, block_collapse, matrix_symbols, Adjoint,
+    hadamard_product, HadamardProduct, HadamardPower, Determinant, det,
+    diagonalize_vector, DiagMatrix, DiagonalMatrix, DiagonalOf, trace,
+    DotProduct, kronecker_product, KroneckerProduct,
+    PermutationMatrix, MatrixPermute, MatrixSet, Permanent, per)
+
+from .utilities import dotprodsimp
+
+__all__ = [
+    'ShapeError', 'NonSquareMatrixError', 'MatrixKind',
+
+    'GramSchmidt', 'casoratian', 'diag', 'eye', 'hessian', 'jordan_cell',
+    'list2numpy', 'matrix2numpy', 'matrix_multiply_elementwise', 'ones',
+    'randMatrix', 'rot_axis1', 'rot_axis2', 'rot_axis3', 'symarray',
+    'wronskian', 'zeros', 'rot_ccw_axis1', 'rot_ccw_axis2', 'rot_ccw_axis3',
+    'rot_givens',
+
+    'MutableDenseMatrix',
+
+    'DeferredVector', 'MatrixBase',
+
+    'Matrix', 'MutableMatrix',
+
+    'MutableSparseMatrix',
+
+    'banded',
+
+    'ImmutableDenseMatrix', 'ImmutableSparseMatrix',
+
+    'ImmutableMatrix', 'SparseMatrix',
+
+    'MatrixSlice', 'BlockDiagMatrix', 'BlockMatrix', 'FunctionMatrix',
+    'Identity', 'Inverse', 'MatAdd', 'MatMul', 'MatPow', 'MatrixExpr',
+    'MatrixSymbol', 'Trace', 'Transpose', 'ZeroMatrix', 'OneMatrix',
+    'blockcut', 'block_collapse', 'matrix_symbols', 'Adjoint',
+    'hadamard_product', 'HadamardProduct', 'HadamardPower', 'Determinant',
+    'det', 'diagonalize_vector', 'DiagMatrix', 'DiagonalMatrix',
+    'DiagonalOf', 'trace', 'DotProduct', 'kronecker_product',
+    'KroneckerProduct', 'PermutationMatrix', 'MatrixPermute', 'MatrixSet',
+    'Permanent', 'per',
+
+    'dotprodsimp',
+]

phi4/lib/python3.10/site-packages/sympy/matrices/common.py

@@ -0,0 +1,3263 @@
+"""
+A module contining deprecated matrix mixin classes.
+
+The classes in this module are deprecated and will be removed in a future
+release. They are kept here for backwards compatibility in case downstream
+code was subclassing them.
+
+Importing anything else from this module is deprecated so anything here
+should either not be used or should be imported from somewhere else.
+"""
+
+from collections import defaultdict
+from collections.abc import Iterable
+from inspect import isfunction
+from functools import reduce
+
+from sympy.assumptions.refine import refine
+from sympy.core import SympifyError, Add
+from sympy.core.basic import Atom
+from sympy.core.decorators import call_highest_priority
+from sympy.core.logic import fuzzy_and, FuzzyBool
+from sympy.core.numbers import Integer
+from sympy.core.mod import Mod
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import Abs, re, im
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from .utilities import _dotprodsimp, _simplify
+from sympy.polys.polytools import Poly
+from sympy.utilities.iterables import flatten, is_sequence
+from sympy.utilities.misc import as_int, filldedent
+from sympy.tensor.array import NDimArray
+
+from .utilities import _get_intermediate_simp_bool
+
+
+# These exception types were previously defined in this module but were moved
+# to exceptions.py. We reimport them here for backwards compatibility in case
+# downstream code was importing them from here.
+from .exceptions import ( # noqa: F401
+    MatrixError, ShapeError, NonSquareMatrixError, NonInvertibleMatrixError,
+    NonPositiveDefiniteMatrixError
+)
+
+
+_DEPRECATED_MIXINS = (
+    'MatrixShaping',
+    'MatrixSpecial',
+    'MatrixProperties',
+    'MatrixOperations',
+    'MatrixArithmetic',
+    'MatrixCommon',
+    'MatrixDeterminant',
+    'MatrixReductions',
+    'MatrixSubspaces',
+    'MatrixEigen',
+    'MatrixCalculus',
+    'MatrixDeprecated',
+)
+
+
+class _MatrixDeprecatedMeta(type):
+
+    #
+    # Override the default __instancecheck__ implementation to ensure that
+    # e.g. isinstance(M, MatrixCommon) still works when M is one of the
+    # matrix classes. Matrix no longer inherits from MatrixCommon so
+    # isinstance(M, MatrixCommon) would now return False by default.
+    #
+    # There were lots of places in the codebase where this was being done
+    # so it seems likely that downstream code may be doing it too. All use
+    # of these mixins is deprecated though so we give a deprecation warning
+    # unconditionally if they are being used with isinstance.
+    #
+    # Any code seeing this deprecation warning should be changed to use
+    # isinstance(M, MatrixBase) instead which also works in previous versions
+    # of SymPy.
+    #
+
+    def __instancecheck__(cls, instance):
+
+        sympy_deprecation_warning(
+            f"""
+            Checking whether an object is an instance of {cls.__name__} is
+            deprecated.
+
+            Use `isinstance(obj, Matrix)` instead of `isinstance(obj, {cls.__name__})`.
+            """,
+            deprecated_since_version="1.13",
+            active_deprecations_target="deprecated-matrix-mixins",
+            stacklevel=3,
+        )
+
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.matrices.matrices import (
+            MatrixDeterminant,
+            MatrixReductions,
+            MatrixSubspaces,
+            MatrixEigen,
+            MatrixCalculus,
+            MatrixDeprecated
+        )
+
+        all_mixins = (
+            MatrixRequired,
+            MatrixShaping,
+            MatrixSpecial,
+            MatrixProperties,
+            MatrixOperations,
+            MatrixArithmetic,
+            MatrixCommon,
+            MatrixDeterminant,
+            MatrixReductions,
+            MatrixSubspaces,
+            MatrixEigen,
+            MatrixCalculus,
+            MatrixDeprecated
+        )
+
+        if cls in all_mixins and isinstance(instance, MatrixBase):
+            return True
+        else:
+            return super().__instancecheck__(instance)
+
+
+class MatrixRequired(metaclass=_MatrixDeprecatedMeta):
+    """Deprecated mixin class for making matrix classes."""
+
+    rows = None  # type: int
+    cols = None  # type: int
+    _simplify = None
+
+    def __init_subclass__(cls, **kwargs):
+
+        # Warn if any downstream code is subclassing this class or any of the
+        # deprecated mixin classes that are all ultimately subclasses of this
+        # class.
+        #
+        # We don't want to warn about the deprecated mixins themselves being
+        # created, but only about them being used as mixins by downstream code.
+        # Otherwise just importing this module would trigger a warning.
+        # Ultimately the whole module should be deprecated and removed but for
+        # SymPy 1.13 it is premature to do that given that this module was the
+        # main way to import matrix exception types in all previous versions.
+
+        if cls.__name__ not in _DEPRECATED_MIXINS:
+            sympy_deprecation_warning(
+                f"""
+                Inheriting from the Matrix mixin classes is deprecated.
+
+                The class {cls.__name__} is subclassing a deprecated mixin.
+                """,
+                deprecated_since_version="1.13",
+                active_deprecations_target="deprecated-matrix-mixins",
+                stacklevel=3,
+            )
+
+        super().__init_subclass__(**kwargs)
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        """`_new` must, at minimum, be callable as
+        `_new(rows, cols, mat) where mat is a flat list of the
+        elements of the matrix."""
+        raise NotImplementedError("Subclasses must implement this.")
+
+    def __eq__(self, other):
+        raise NotImplementedError("Subclasses must implement this.")
+
+    def __getitem__(self, key):
+        """Implementations of __getitem__ should accept ints, in which
+        case the matrix is indexed as a flat list, tuples (i,j) in which
+        case the (i,j) entry is returned, slices, or mixed tuples (a,b)
+        where a and b are any combination of slices and integers."""
+        raise NotImplementedError("Subclasses must implement this.")
+
+    def __len__(self):
+        """The total number of entries in the matrix."""
+        raise NotImplementedError("Subclasses must implement this.")
+
+    @property
+    def shape(self):
+        raise NotImplementedError("Subclasses must implement this.")
+
+
+class MatrixShaping(MatrixRequired):
+    """Provides basic matrix shaping and extracting of submatrices"""
+
+    def _eval_col_del(self, col):
+        def entry(i, j):
+            return self[i, j] if j < col else self[i, j + 1]
+        return self._new(self.rows, self.cols - 1, entry)
+
+    def _eval_col_insert(self, pos, other):
+
+        def entry(i, j):
+            if j < pos:
+                return self[i, j]
+            elif pos <= j < pos + other.cols:
+                return other[i, j - pos]
+            return self[i, j - other.cols]
+
+        return self._new(self.rows, self.cols + other.cols, entry)
+
+    def _eval_col_join(self, other):
+        rows = self.rows
+
+        def entry(i, j):
+            if i < rows:
+                return self[i, j]
+            return other[i - rows, j]
+
+        return classof(self, other)._new(self.rows + other.rows, self.cols,
+                                         entry)
+
+    def _eval_extract(self, rowsList, colsList):
+        mat = list(self)
+        cols = self.cols
+        indices = (i * cols + j for i in rowsList for j in colsList)
+        return self._new(len(rowsList), len(colsList),
+                         [mat[i] for i in indices])
+
+    def _eval_get_diag_blocks(self):
+        sub_blocks = []
+
+        def recurse_sub_blocks(M):
+            i = 1
+            while i <= M.shape[0]:
+                if i == 1:
+                    to_the_right = M[0, i:]
+                    to_the_bottom = M[i:, 0]
+                else:
+                    to_the_right = M[:i, i:]
+                    to_the_bottom = M[i:, :i]
+                if any(to_the_right) or any(to_the_bottom):
+                    i += 1
+                    continue
+                else:
+                    sub_blocks.append(M[:i, :i])
+                    if M.shape == M[:i, :i].shape:
+                        return
+                    else:
+                        recurse_sub_blocks(M[i:, i:])
+                        return
+
+        recurse_sub_blocks(self)
+        return sub_blocks
+
+    def _eval_row_del(self, row):
+        def entry(i, j):
+            return self[i, j] if i < row else self[i + 1, j]
+        return self._new(self.rows - 1, self.cols, entry)
+
+    def _eval_row_insert(self, pos, other):
+        entries = list(self)
+        insert_pos = pos * self.cols
+        entries[insert_pos:insert_pos] = list(other)
+        return self._new(self.rows + other.rows, self.cols, entries)
+
+    def _eval_row_join(self, other):
+        cols = self.cols
+
+        def entry(i, j):
+            if j < cols:
+                return self[i, j]
+            return other[i, j - cols]
+
+        return classof(self, other)._new(self.rows, self.cols + other.cols,
+                                         entry)
+
+    def _eval_tolist(self):
+        return [list(self[i,:]) for i in range(self.rows)]
+
+    def _eval_todok(self):
+        dok = {}
+        rows, cols = self.shape
+        for i in range(rows):
+            for j in range(cols):
+                val = self[i, j]
+                if val != self.zero:
+                    dok[i, j] = val
+        return dok
+
+    def _eval_vec(self):
+        rows = self.rows
+
+        def entry(n, _):
+            # we want to read off the columns first
+            j = n // rows
+            i = n - j * rows
+            return self[i, j]
+
+        return self._new(len(self), 1, entry)
+
+    def _eval_vech(self, diagonal):
+        c = self.cols
+        v = []
+        if diagonal:
+            for j in range(c):
+                for i in range(j, c):
+                    v.append(self[i, j])
+        else:
+            for j in range(c):
+                for i in range(j + 1, c):
+                    v.append(self[i, j])
+        return self._new(len(v), 1, v)
+
+    def col_del(self, col):
+        """Delete the specified column."""
+        if col < 0:
+            col += self.cols
+        if not 0 <= col < self.cols:
+            raise IndexError("Column {} is out of range.".format(col))
+        return self._eval_col_del(col)
+
+    def col_insert(self, pos, other):
+        """Insert one or more columns at the given column position.
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(3, 1)
+        >>> M.col_insert(1, V)
+        Matrix([
+        [0, 1, 0, 0],
+        [0, 1, 0, 0],
+        [0, 1, 0, 0]])
+
+        See Also
+        ========
+
+        col
+        row_insert
+        """
+        # Allows you to build a matrix even if it is null matrix
+        if not self:
+            return type(self)(other)
+
+        pos = as_int(pos)
+
+        if pos < 0:
+            pos = self.cols + pos
+        if pos < 0:
+            pos = 0
+        elif pos > self.cols:
+            pos = self.cols
+
+        if self.rows != other.rows:
+            raise ShapeError(
+                "The matrices have incompatible number of rows ({} and {})"
+                .format(self.rows, other.rows))
+
+        return self._eval_col_insert(pos, other)
+
+    def col_join(self, other):
+        """Concatenates two matrices along self's last and other's first row.
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(1, 3)
+        >>> M.col_join(V)
+        Matrix([
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+        [1, 1, 1]])
+
+        See Also
+        ========
+
+        col
+        row_join
+        """
+        # A null matrix can always be stacked (see  #10770)
+        if self.rows == 0 and self.cols != other.cols:
+            return self._new(0, other.cols, []).col_join(other)
+
+        if self.cols != other.cols:
+            raise ShapeError(
+                "The matrices have incompatible number of columns ({} and {})"
+                .format(self.cols, other.cols))
+        return self._eval_col_join(other)
+
+    def col(self, j):
+        """Elementary column selector.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> eye(2).col(0)
+        Matrix([
+        [1],
+        [0]])
+
+        See Also
+        ========
+
+        row
+        col_del
+        col_join
+        col_insert
+        """
+        return self[:, j]
+
+    def extract(self, rowsList, colsList):
+        r"""Return a submatrix by specifying a list of rows and columns.
+        Negative indices can be given. All indices must be in the range
+        $-n \le i < n$ where $n$ is the number of rows or columns.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(4, 3, range(12))
+        >>> m
+        Matrix([
+        [0,  1,  2],
+        [3,  4,  5],
+        [6,  7,  8],
+        [9, 10, 11]])
+        >>> m.extract([0, 1, 3], [0, 1])
+        Matrix([
+        [0,  1],
+        [3,  4],
+        [9, 10]])
+
+        Rows or columns can be repeated:
+
+        >>> m.extract([0, 0, 1], [-1])
+        Matrix([
+        [2],
+        [2],
+        [5]])
+
+        Every other row can be taken by using range to provide the indices:
+
+        >>> m.extract(range(0, m.rows, 2), [-1])
+        Matrix([
+        [2],
+        [8]])
+
+        RowsList or colsList can also be a list of booleans, in which case
+        the rows or columns corresponding to the True values will be selected:
+
+        >>> m.extract([0, 1, 2, 3], [True, False, True])
+        Matrix([
+        [0,  2],
+        [3,  5],
+        [6,  8],
+        [9, 11]])
+        """
+
+        if not is_sequence(rowsList) or not is_sequence(colsList):
+            raise TypeError("rowsList and colsList must be iterable")
+        # ensure rowsList and colsList are lists of integers
+        if rowsList and all(isinstance(i, bool) for i in rowsList):
+            rowsList = [index for index, item in enumerate(rowsList) if item]
+        if colsList and all(isinstance(i, bool) for i in colsList):
+            colsList = [index for index, item in enumerate(colsList) if item]
+
+        # ensure everything is in range
+        rowsList = [a2idx(k, self.rows) for k in rowsList]
+        colsList = [a2idx(k, self.cols) for k in colsList]
+
+        return self._eval_extract(rowsList, colsList)
+
+    def get_diag_blocks(self):
+        """Obtains the square sub-matrices on the main diagonal of a square matrix.
+
+        Useful for inverting symbolic matrices or solving systems of
+        linear equations which may be decoupled by having a block diagonal
+        structure.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y, z
+        >>> A = Matrix([[1, 3, 0, 0], [y, z*z, 0, 0], [0, 0, x, 0], [0, 0, 0, 0]])
+        >>> a1, a2, a3 = A.get_diag_blocks()
+        >>> a1
+        Matrix([
+        [1,    3],
+        [y, z**2]])
+        >>> a2
+        Matrix([[x]])
+        >>> a3
+        Matrix([[0]])
+
+        """
+        return self._eval_get_diag_blocks()
+
+    @classmethod
+    def hstack(cls, *args):
+        """Return a matrix formed by joining args horizontally (i.e.
+        by repeated application of row_join).
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, eye
+        >>> Matrix.hstack(eye(2), 2*eye(2))
+        Matrix([
+        [1, 0, 2, 0],
+        [0, 1, 0, 2]])
+        """
+        if len(args) == 0:
+            return cls._new()
+
+        kls = type(args[0])
+        return reduce(kls.row_join, args)
+
+    def reshape(self, rows, cols):
+        """Reshape the matrix. Total number of elements must remain the same.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 3, lambda i, j: 1)
+        >>> m
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1]])
+        >>> m.reshape(1, 6)
+        Matrix([[1, 1, 1, 1, 1, 1]])
+        >>> m.reshape(3, 2)
+        Matrix([
+        [1, 1],
+        [1, 1],
+        [1, 1]])
+
+        """
+        if self.rows * self.cols != rows * cols:
+            raise ValueError("Invalid reshape parameters %d %d" % (rows, cols))
+        return self._new(rows, cols, lambda i, j: self[i * cols + j])
+
+    def row_del(self, row):
+        """Delete the specified row."""
+        if row < 0:
+            row += self.rows
+        if not 0 <= row < self.rows:
+            raise IndexError("Row {} is out of range.".format(row))
+
+        return self._eval_row_del(row)
+
+    def row_insert(self, pos, other):
+        """Insert one or more rows at the given row position.
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(1, 3)
+        >>> M.row_insert(1, V)
+        Matrix([
+        [0, 0, 0],
+        [1, 1, 1],
+        [0, 0, 0],
+        [0, 0, 0]])
+
+        See Also
+        ========
+
+        row
+        col_insert
+        """
+        # Allows you to build a matrix even if it is null matrix
+        if not self:
+            return self._new(other)
+
+        pos = as_int(pos)
+
+        if pos < 0:
+            pos = self.rows + pos
+        if pos < 0:
+            pos = 0
+        elif pos > self.rows:
+            pos = self.rows
+
+        if self.cols != other.cols:
+            raise ShapeError(
+                "The matrices have incompatible number of columns ({} and {})"
+                .format(self.cols, other.cols))
+
+        return self._eval_row_insert(pos, other)
+
+    def row_join(self, other):
+        """Concatenates two matrices along self's last and rhs's first column
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(3, 1)
+        >>> M.row_join(V)
+        Matrix([
+        [0, 0, 0, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 1]])
+
+        See Also
+        ========
+
+        row
+        col_join
+        """
+        # A null matrix can always be stacked (see  #10770)
+        if self.cols == 0 and self.rows != other.rows:
+            return self._new(other.rows, 0, []).row_join(other)
+
+        if self.rows != other.rows:
+            raise ShapeError(
+                "The matrices have incompatible number of rows ({} and {})"
+                .format(self.rows, other.rows))
+        return self._eval_row_join(other)
+
+    def diagonal(self, k=0):
+        """Returns the kth diagonal of self. The main diagonal
+        corresponds to `k=0`; diagonals above and below correspond to
+        `k > 0` and `k < 0`, respectively. The values of `self[i, j]`
+        for which `j - i = k`, are returned in order of increasing
+        `i + j`, starting with `i + j = |k|`.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(3, 3, lambda i, j: j - i); m
+        Matrix([
+        [ 0,  1, 2],
+        [-1,  0, 1],
+        [-2, -1, 0]])
+        >>> _.diagonal()
+        Matrix([[0, 0, 0]])
+        >>> m.diagonal(1)
+        Matrix([[1, 1]])
+        >>> m.diagonal(-2)
+        Matrix([[-2]])
+
+        Even though the diagonal is returned as a Matrix, the element
+        retrieval can be done with a single index:
+
+        >>> Matrix.diag(1, 2, 3).diagonal()[1]  # instead of [0, 1]
+        2
+
+        See Also
+        ========
+
+        diag
+        """
+        rv = []
+        k = as_int(k)
+        r = 0 if k > 0 else -k
+        c = 0 if r else k
+        while True:
+            if r == self.rows or c == self.cols:
+                break
+            rv.append(self[r, c])
+            r += 1
+            c += 1
+        if not rv:
+            raise ValueError(filldedent('''
+            The %s diagonal is out of range [%s, %s]''' % (
+            k, 1 - self.rows, self.cols - 1)))
+        return self._new(1, len(rv), rv)
+
+    def row(self, i):
+        """Elementary row selector.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> eye(2).row(0)
+        Matrix([[1, 0]])
+
+        See Also
+        ========
+
+        col
+        row_del
+        row_join
+        row_insert
+        """
+        return self[i, :]
+
+    @property
+    def shape(self):
+        """The shape (dimensions) of the matrix as the 2-tuple (rows, cols).
+
+        Examples
+        ========
+
+        >>> from sympy import zeros
+        >>> M = zeros(2, 3)
+        >>> M.shape
+        (2, 3)
+        >>> M.rows
+        2
+        >>> M.cols
+        3
+        """
+        return (self.rows, self.cols)
+
+    def todok(self):
+        """Return the matrix as dictionary of keys.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix.eye(3)
+        >>> M.todok()
+        {(0, 0): 1, (1, 1): 1, (2, 2): 1}
+        """
+        return self._eval_todok()
+
+    def tolist(self):
+        """Return the Matrix as a nested Python list.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, ones
+        >>> m = Matrix(3, 3, range(9))
+        >>> m
+        Matrix([
+        [0, 1, 2],
+        [3, 4, 5],
+        [6, 7, 8]])
+        >>> m.tolist()
+        [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+        >>> ones(3, 0).tolist()
+        [[], [], []]
+
+        When there are no rows then it will not be possible to tell how
+        many columns were in the original matrix:
+
+        >>> ones(0, 3).tolist()
+        []
+
+        """
+        if not self.rows:
+            return []
+        if not self.cols:
+            return [[] for i in range(self.rows)]
+        return self._eval_tolist()
+
+    def todod(M):
+        """Returns matrix as dict of dicts containing non-zero elements of the Matrix
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[0, 1],[0, 3]])
+        >>> A
+        Matrix([
+        [0, 1],
+        [0, 3]])
+        >>> A.todod()
+        {0: {1: 1}, 1: {1: 3}}
+
+
+        """
+        rowsdict = {}
+        Mlol = M.tolist()
+        for i, Mi in enumerate(Mlol):
+            row = {j: Mij for j, Mij in enumerate(Mi) if Mij}
+            if row:
+                rowsdict[i] = row
+        return rowsdict
+
+    def vec(self):
+        """Return the Matrix converted into a one column matrix by stacking columns
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m=Matrix([[1, 3], [2, 4]])
+        >>> m
+        Matrix([
+        [1, 3],
+        [2, 4]])
+        >>> m.vec()
+        Matrix([
+        [1],
+        [2],
+        [3],
+        [4]])
+
+        See Also
+        ========
+
+        vech
+        """
+        return self._eval_vec()
+
+    def vech(self, diagonal=True, check_symmetry=True):
+        """Reshapes the matrix into a column vector by stacking the
+        elements in the lower triangle.
+
+        Parameters
+        ==========
+
+        diagonal : bool, optional
+            If ``True``, it includes the diagonal elements.
+
+        check_symmetry : bool, optional
+            If ``True``, it checks whether the matrix is symmetric.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m=Matrix([[1, 2], [2, 3]])
+        >>> m
+        Matrix([
+        [1, 2],
+        [2, 3]])
+        >>> m.vech()
+        Matrix([
+        [1],
+        [2],
+        [3]])
+        >>> m.vech(diagonal=False)
+        Matrix([[2]])
+
+        Notes
+        =====
+
+        This should work for symmetric matrices and ``vech`` can
+        represent symmetric matrices in vector form with less size than
+        ``vec``.
+
+        See Also
+        ========
+
+        vec
+        """
+        if not self.is_square:
+            raise NonSquareMatrixError
+
+        if check_symmetry and not self.is_symmetric():
+            raise ValueError("The matrix is not symmetric.")
+
+        return self._eval_vech(diagonal)
+
+    @classmethod
+    def vstack(cls, *args):
+        """Return a matrix formed by joining args vertically (i.e.
+        by repeated application of col_join).
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, eye
+        >>> Matrix.vstack(eye(2), 2*eye(2))
+        Matrix([
+        [1, 0],
+        [0, 1],
+        [2, 0],
+        [0, 2]])
+        """
+        if len(args) == 0:
+            return cls._new()
+
+        kls = type(args[0])
+        return reduce(kls.col_join, args)
+
+
+class MatrixSpecial(MatrixRequired):
+    """Construction of special matrices"""
+
+    @classmethod
+    def _eval_diag(cls, rows, cols, diag_dict):
+        """diag_dict is a defaultdict containing
+        all the entries of the diagonal matrix."""
+        def entry(i, j):
+            return diag_dict[(i, j)]
+        return cls._new(rows, cols, entry)
+
+    @classmethod
+    def _eval_eye(cls, rows, cols):
+        vals = [cls.zero]*(rows*cols)
+        vals[::cols+1] = [cls.one]*min(rows, cols)
+        return cls._new(rows, cols, vals, copy=False)
+
+    @classmethod
+    def _eval_jordan_block(cls, size: int, eigenvalue, band='upper'):
+        if band == 'lower':
+            def entry(i, j):
+                if i == j:
+                    return eigenvalue
+                elif j + 1 == i:
+                    return cls.one
+                return cls.zero
+        else:
+            def entry(i, j):
+                if i == j:
+                    return eigenvalue
+                elif i + 1 == j:
+                    return cls.one
+                return cls.zero
+        return cls._new(size, size, entry)
+
+    @classmethod
+    def _eval_ones(cls, rows, cols):
+        def entry(i, j):
+            return cls.one
+        return cls._new(rows, cols, entry)
+
+    @classmethod
+    def _eval_zeros(cls, rows, cols):
+        return cls._new(rows, cols, [cls.zero]*(rows*cols), copy=False)
+
+    @classmethod
+    def _eval_wilkinson(cls, n):
+        def entry(i, j):
+            return cls.one if i + 1 == j else cls.zero
+
+        D = cls._new(2*n + 1, 2*n + 1, entry)
+
+        wminus = cls.diag(list(range(-n, n + 1)), unpack=True) + D + D.T
+        wplus = abs(cls.diag(list(range(-n, n + 1)), unpack=True)) + D + D.T
+
+        return wminus, wplus
+
+    @classmethod
+    def diag(kls, *args, strict=False, unpack=True, rows=None, cols=None, **kwargs):
+        """Returns a matrix with the specified diagonal.
+        If matrices are passed, a block-diagonal matrix
+        is created (i.e. the "direct sum" of the matrices).
+
+        kwargs
+        ======
+
+        rows : rows of the resulting matrix; computed if
+               not given.
+
+        cols : columns of the resulting matrix; computed if
+               not given.
+
+        cls : class for the resulting matrix
+
+        unpack : bool which, when True (default), unpacks a single
+        sequence rather than interpreting it as a Matrix.
+
+        strict : bool which, when False (default), allows Matrices to
+        have variable-length rows.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> Matrix.diag(1, 2, 3)
+        Matrix([
+        [1, 0, 0],
+        [0, 2, 0],
+        [0, 0, 3]])
+
+        The current default is to unpack a single sequence. If this is
+        not desired, set `unpack=False` and it will be interpreted as
+        a matrix.
+
+        >>> Matrix.diag([1, 2, 3]) == Matrix.diag(1, 2, 3)
+        True
+
+        When more than one element is passed, each is interpreted as
+        something to put on the diagonal. Lists are converted to
+        matrices. Filling of the diagonal always continues from
+        the bottom right hand corner of the previous item: this
+        will create a block-diagonal matrix whether the matrices
+        are square or not.
+
+        >>> col = [1, 2, 3]
+        >>> row = [[4, 5]]
+        >>> Matrix.diag(col, row)
+        Matrix([
+        [1, 0, 0],
+        [2, 0, 0],
+        [3, 0, 0],
+        [0, 4, 5]])
+
+        When `unpack` is False, elements within a list need not all be
+        of the same length. Setting `strict` to True would raise a
+        ValueError for the following:
+
+        >>> Matrix.diag([[1, 2, 3], [4, 5], [6]], unpack=False)
+        Matrix([
+        [1, 2, 3],
+        [4, 5, 0],
+        [6, 0, 0]])
+
+        The type of the returned matrix can be set with the ``cls``
+        keyword.
+
+        >>> from sympy import ImmutableMatrix
+        >>> from sympy.utilities.misc import func_name
+        >>> func_name(Matrix.diag(1, cls=ImmutableMatrix))
+        'ImmutableDenseMatrix'
+
+        A zero dimension matrix can be used to position the start of
+        the filling at the start of an arbitrary row or column:
+
+        >>> from sympy import ones
+        >>> r2 = ones(0, 2)
+        >>> Matrix.diag(r2, 1, 2)
+        Matrix([
+        [0, 0, 1, 0],
+        [0, 0, 0, 2]])
+
+        See Also
+        ========
+        eye
+        diagonal
+        .dense.diag
+        .expressions.blockmatrix.BlockMatrix
+        .sparsetools.banded
+       """
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.matrices.dense import Matrix
+        from sympy.matrices import SparseMatrix
+        klass = kwargs.get('cls', kls)
+        if unpack and len(args) == 1 and is_sequence(args[0]) and \
+                not isinstance(args[0], MatrixBase):
+            args = args[0]
+
+        # fill a default dict with the diagonal entries
+        diag_entries = defaultdict(int)
+        rmax = cmax = 0  # keep track of the biggest index seen
+        for m in args:
+            if isinstance(m, list):
+                if strict:
+                    # if malformed, Matrix will raise an error
+                    _ = Matrix(m)
+                    r, c = _.shape
+                    m = _.tolist()
+                else:
+                    r, c, smat = SparseMatrix._handle_creation_inputs(m)
+                    for (i, j), _ in smat.items():
+                        diag_entries[(i + rmax, j + cmax)] = _
+                    m = []  # to skip process below
+            elif hasattr(m, 'shape'):  # a Matrix
+                # convert to list of lists
+                r, c = m.shape
+                m = m.tolist()
+            else:  # in this case, we're a single value
+                diag_entries[(rmax, cmax)] = m
+                rmax += 1
+                cmax += 1
+                continue
+            # process list of lists
+            for i, mi in enumerate(m):
+                for j, _ in enumerate(mi):
+                    diag_entries[(i + rmax, j + cmax)] = _
+            rmax += r
+            cmax += c
+        if rows is None:
+            rows, cols = cols, rows
+        if rows is None:
+            rows, cols = rmax, cmax
+        else:
+            cols = rows if cols is None else cols
+        if rows < rmax or cols < cmax:
+            raise ValueError(filldedent('''
+                The constructed matrix is {} x {} but a size of {} x {}
+                was specified.'''.format(rmax, cmax, rows, cols)))
+        return klass._eval_diag(rows, cols, diag_entries)
+
+    @classmethod
+    def eye(kls, rows, cols=None, **kwargs):
+        """Returns an identity matrix.
+
+        Parameters
+        ==========
+
+        rows : rows of the matrix
+        cols : cols of the matrix (if None, cols=rows)
+
+        kwargs
+        ======
+        cls : class of the returned matrix
+        """
+        if cols is None:
+            cols = rows
+        if rows < 0 or cols < 0:
+            raise ValueError("Cannot create a {} x {} matrix. "
+                             "Both dimensions must be positive".format(rows, cols))
+        klass = kwargs.get('cls', kls)
+        rows, cols = as_int(rows), as_int(cols)
+
+        return klass._eval_eye(rows, cols)
+
+    @classmethod
+    def jordan_block(kls, size=None, eigenvalue=None, *, band='upper', **kwargs):
+        """Returns a Jordan block
+
+        Parameters
+        ==========
+
+        size : Integer, optional
+            Specifies the shape of the Jordan block matrix.
+
+        eigenvalue : Number or Symbol
+            Specifies the value for the main diagonal of the matrix.
+
+            .. note::
+                The keyword ``eigenval`` is also specified as an alias
+                of this keyword, but it is not recommended to use.
+
+                We may deprecate the alias in later release.
+
+        band : 'upper' or 'lower', optional
+            Specifies the position of the off-diagonal to put `1` s on.
+
+        cls : Matrix, optional
+            Specifies the matrix class of the output form.
+
+            If it is not specified, the class type where the method is
+            being executed on will be returned.
+
+        Returns
+        =======
+
+        Matrix
+            A Jordan block matrix.
+
+        Raises
+        ======
+
+        ValueError
+            If insufficient arguments are given for matrix size
+            specification, or no eigenvalue is given.
+
+        Examples
+        ========
+
+        Creating a default Jordan block:
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x
+        >>> Matrix.jordan_block(4, x)
+        Matrix([
+        [x, 1, 0, 0],
+        [0, x, 1, 0],
+        [0, 0, x, 1],
+        [0, 0, 0, x]])
+
+        Creating an alternative Jordan block matrix where `1` is on
+        lower off-diagonal:
+
+        >>> Matrix.jordan_block(4, x, band='lower')
+        Matrix([
+        [x, 0, 0, 0],
+        [1, x, 0, 0],
+        [0, 1, x, 0],
+        [0, 0, 1, x]])
+
+        Creating a Jordan block with keyword arguments
+
+        >>> Matrix.jordan_block(size=4, eigenvalue=x)
+        Matrix([
+        [x, 1, 0, 0],
+        [0, x, 1, 0],
+        [0, 0, x, 1],
+        [0, 0, 0, x]])
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Jordan_matrix
+        """
+        klass = kwargs.pop('cls', kls)
+
+        eigenval = kwargs.get('eigenval', None)
+        if eigenvalue is None and eigenval is None:
+            raise ValueError("Must supply an eigenvalue")
+        elif eigenvalue != eigenval and None not in (eigenval, eigenvalue):
+            raise ValueError(
+                "Inconsistent values are given: 'eigenval'={}, "
+                "'eigenvalue'={}".format(eigenval, eigenvalue))
+        else:
+            if eigenval is not None:
+                eigenvalue = eigenval
+
+        if size is None:
+            raise ValueError("Must supply a matrix size")
+
+        size = as_int(size)
+        return klass._eval_jordan_block(size, eigenvalue, band)
+
+    @classmethod
+    def ones(kls, rows, cols=None, **kwargs):
+        """Returns a matrix of ones.
+
+        Parameters
+        ==========
+
+        rows : rows of the matrix
+        cols : cols of the matrix (if None, cols=rows)
+
+        kwargs
+        ======
+        cls : class of the returned matrix
+        """
+        if cols is None:
+            cols = rows
+        klass = kwargs.get('cls', kls)
+        rows, cols = as_int(rows), as_int(cols)
+
+        return klass._eval_ones(rows, cols)
+
+    @classmethod
+    def zeros(kls, rows, cols=None, **kwargs):
+        """Returns a matrix of zeros.
+
+        Parameters
+        ==========
+
+        rows : rows of the matrix
+        cols : cols of the matrix (if None, cols=rows)
+
+        kwargs
+        ======
+        cls : class of the returned matrix
+        """
+        if cols is None:
+            cols = rows
+        if rows < 0 or cols < 0:
+            raise ValueError("Cannot create a {} x {} matrix. "
+                             "Both dimensions must be positive".format(rows, cols))
+        klass = kwargs.get('cls', kls)
+        rows, cols = as_int(rows), as_int(cols)
+
+        return klass._eval_zeros(rows, cols)
+
+    @classmethod
+    def companion(kls, poly):
+        """Returns a companion matrix of a polynomial.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, Poly, Symbol, symbols
+        >>> x = Symbol('x')
+        >>> c0, c1, c2, c3, c4 = symbols('c0:5')
+        >>> p = Poly(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + x**5, x)
+        >>> Matrix.companion(p)
+        Matrix([
+        [0, 0, 0, 0, -c0],
+        [1, 0, 0, 0, -c1],
+        [0, 1, 0, 0, -c2],
+        [0, 0, 1, 0, -c3],
+        [0, 0, 0, 1, -c4]])
+        """
+        poly = kls._sympify(poly)
+        if not isinstance(poly, Poly):
+            raise ValueError("{} must be a Poly instance.".format(poly))
+        if not poly.is_monic:
+            raise ValueError("{} must be a monic polynomial.".format(poly))
+        if not poly.is_univariate:
+            raise ValueError(
+                "{} must be a univariate polynomial.".format(poly))
+
+        size = poly.degree()
+        if not size >= 1:
+            raise ValueError(
+                "{} must have degree not less than 1.".format(poly))
+
+        coeffs = poly.all_coeffs()
+        def entry(i, j):
+            if j == size - 1:
+                return -coeffs[-1 - i]
+            elif i == j + 1:
+                return kls.one
+            return kls.zero
+        return kls._new(size, size, entry)
+
+
+    @classmethod
+    def wilkinson(kls, n, **kwargs):
+        """Returns two square Wilkinson Matrix of size 2*n + 1
+        $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> wminus, wplus = Matrix.wilkinson(3)
+        >>> wminus
+        Matrix([
+        [-3,  1,  0, 0, 0, 0, 0],
+        [ 1, -2,  1, 0, 0, 0, 0],
+        [ 0,  1, -1, 1, 0, 0, 0],
+        [ 0,  0,  1, 0, 1, 0, 0],
+        [ 0,  0,  0, 1, 1, 1, 0],
+        [ 0,  0,  0, 0, 1, 2, 1],
+        [ 0,  0,  0, 0, 0, 1, 3]])
+        >>> wplus
+        Matrix([
+        [3, 1, 0, 0, 0, 0, 0],
+        [1, 2, 1, 0, 0, 0, 0],
+        [0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 0, 1, 0, 0],
+        [0, 0, 0, 1, 1, 1, 0],
+        [0, 0, 0, 0, 1, 2, 1],
+        [0, 0, 0, 0, 0, 1, 3]])
+
+        References
+        ==========
+
+        .. [1] https://blogs.mathworks.com/cleve/2013/04/15/wilkinsons-matrices-2/
+        .. [2] J. H. Wilkinson, The Algebraic Eigenvalue Problem, Claredon Press, Oxford, 1965, 662 pp.
+
+        """
+        klass = kwargs.get('cls', kls)
+        n = as_int(n)
+        return klass._eval_wilkinson(n)
+
+class MatrixProperties(MatrixRequired):
+    """Provides basic properties of a matrix."""
+
+    def _eval_atoms(self, *types):
+        result = set()
+        for i in self:
+            result.update(i.atoms(*types))
+        return result
+
+    def _eval_free_symbols(self):
+        return set().union(*(i.free_symbols for i in self if i))
+
+    def _eval_has(self, *patterns):
+        return any(a.has(*patterns) for a in self)
+
+    def _eval_is_anti_symmetric(self, simpfunc):
+        if not all(simpfunc(self[i, j] + self[j, i]).is_zero for i in range(self.rows) for j in range(self.cols)):
+            return False
+        return True
+
+    def _eval_is_diagonal(self):
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if i != j and self[i, j]:
+                    return False
+        return True
+
+    # _eval_is_hermitian is called by some general SymPy
+    # routines and has a different *args signature.  Make
+    # sure the names don't clash by adding `_matrix_` in name.
+    def _eval_is_matrix_hermitian(self, simpfunc):
+        mat = self._new(self.rows, self.cols, lambda i, j: simpfunc(self[i, j] - self[j, i].conjugate()))
+        return mat.is_zero_matrix
+
+    def _eval_is_Identity(self) -> FuzzyBool:
+        def dirac(i, j):
+            if i == j:
+                return 1
+            return 0
+
+        return all(self[i, j] == dirac(i, j)
+                for i in range(self.rows)
+                for j in range(self.cols))
+
+    def _eval_is_lower_hessenberg(self):
+        return all(self[i, j].is_zero
+                   for i in range(self.rows)
+                   for j in range(i + 2, self.cols))
+
+    def _eval_is_lower(self):
+        return all(self[i, j].is_zero
+                   for i in range(self.rows)
+                   for j in range(i + 1, self.cols))
+
+    def _eval_is_symbolic(self):
+        return self.has(Symbol)
+
+    def _eval_is_symmetric(self, simpfunc):
+        mat = self._new(self.rows, self.cols, lambda i, j: simpfunc(self[i, j] - self[j, i]))
+        return mat.is_zero_matrix
+
+    def _eval_is_zero_matrix(self):
+        if any(i.is_zero == False for i in self):
+            return False
+        if any(i.is_zero is None for i in self):
+            return None
+        return True
+
+    def _eval_is_upper_hessenberg(self):
+        return all(self[i, j].is_zero
+                   for i in range(2, self.rows)
+                   for j in range(min(self.cols, (i - 1))))
+
+    def _eval_values(self):
+        return [i for i in self if not i.is_zero]
+
+    def _has_positive_diagonals(self):
+        diagonal_entries = (self[i, i] for i in range(self.rows))
+        return fuzzy_and(x.is_positive for x in diagonal_entries)
+
+    def _has_nonnegative_diagonals(self):
+        diagonal_entries = (self[i, i] for i in range(self.rows))
+        return fuzzy_and(x.is_nonnegative for x in diagonal_entries)
+
+    def atoms(self, *types):
+        """Returns the atoms that form the current object.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import Matrix
+        >>> Matrix([[x]])
+        Matrix([[x]])
+        >>> _.atoms()
+        {x}
+        >>> Matrix([[x, y], [y, x]])
+        Matrix([
+        [x, y],
+        [y, x]])
+        >>> _.atoms()
+        {x, y}
+        """
+
+        types = tuple(t if isinstance(t, type) else type(t) for t in types)
+        if not types:
+            types = (Atom,)
+        return self._eval_atoms(*types)
+
+    @property
+    def free_symbols(self):
+        """Returns the free symbols within the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import Matrix
+        >>> Matrix([[x], [1]]).free_symbols
+        {x}
+        """
+        return self._eval_free_symbols()
+
+    def has(self, *patterns):
+        """Test whether any subexpression matches any of the patterns.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, SparseMatrix, Float
+        >>> from sympy.abc import x, y
+        >>> A = Matrix(((1, x), (0.2, 3)))
+        >>> B = SparseMatrix(((1, x), (0.2, 3)))
+        >>> A.has(x)
+        True
+        >>> A.has(y)
+        False
+        >>> A.has(Float)
+        True
+        >>> B.has(x)
+        True
+        >>> B.has(y)
+        False
+        >>> B.has(Float)
+        True
+        """
+        return self._eval_has(*patterns)
+
+    def is_anti_symmetric(self, simplify=True):
+        """Check if matrix M is an antisymmetric matrix,
+        that is, M is a square matrix with all M[i, j] == -M[j, i].
+
+        When ``simplify=True`` (default), the sum M[i, j] + M[j, i] is
+        simplified before testing to see if it is zero. By default,
+        the SymPy simplify function is used. To use a custom function
+        set simplify to a function that accepts a single argument which
+        returns a simplified expression. To skip simplification, set
+        simplify to False but note that although this will be faster,
+        it may induce false negatives.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, symbols
+        >>> m = Matrix(2, 2, [0, 1, -1, 0])
+        >>> m
+        Matrix([
+        [ 0, 1],
+        [-1, 0]])
+        >>> m.is_anti_symmetric()
+        True
+        >>> x, y = symbols('x y')
+        >>> m = Matrix(2, 3, [0, 0, x, -y, 0, 0])
+        >>> m
+        Matrix([
+        [ 0, 0, x],
+        [-y, 0, 0]])
+        >>> m.is_anti_symmetric()
+        False
+
+        >>> from sympy.abc import x, y
+        >>> m = Matrix(3, 3, [0, x**2 + 2*x + 1, y,
+        ...                   -(x + 1)**2, 0, x*y,
+        ...                   -y, -x*y, 0])
+
+        Simplification of matrix elements is done by default so even
+        though two elements which should be equal and opposite would not
+        pass an equality test, the matrix is still reported as
+        anti-symmetric:
+
+        >>> m[0, 1] == -m[1, 0]
+        False
+        >>> m.is_anti_symmetric()
+        True
+
+        If ``simplify=False`` is used for the case when a Matrix is already
+        simplified, this will speed things up. Here, we see that without
+        simplification the matrix does not appear anti-symmetric:
+
+        >>> print(m.is_anti_symmetric(simplify=False))
+        None
+
+        But if the matrix were already expanded, then it would appear
+        anti-symmetric and simplification in the is_anti_symmetric routine
+        is not needed:
+
+        >>> m = m.expand()
+        >>> m.is_anti_symmetric(simplify=False)
+        True
+        """
+        # accept custom simplification
+        simpfunc = simplify
+        if not isfunction(simplify):
+            simpfunc = _simplify if simplify else lambda x: x
+
+        if not self.is_square:
+            return False
+        return self._eval_is_anti_symmetric(simpfunc)
+
+    def is_diagonal(self):
+        """Check if matrix is diagonal,
+        that is matrix in which the entries outside the main diagonal are all zero.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, diag
+        >>> m = Matrix(2, 2, [1, 0, 0, 2])
+        >>> m
+        Matrix([
+        [1, 0],
+        [0, 2]])
+        >>> m.is_diagonal()
+        True
+
+        >>> m = Matrix(2, 2, [1, 1, 0, 2])
+        >>> m
+        Matrix([
+        [1, 1],
+        [0, 2]])
+        >>> m.is_diagonal()
+        False
+
+        >>> m = diag(1, 2, 3)
+        >>> m
+        Matrix([
+        [1, 0, 0],
+        [0, 2, 0],
+        [0, 0, 3]])
+        >>> m.is_diagonal()
+        True
+
+        See Also
+        ========
+
+        is_lower
+        is_upper
+        sympy.matrices.matrixbase.MatrixCommon.is_diagonalizable
+        diagonalize
+        """
+        return self._eval_is_diagonal()
+
+    @property
+    def is_weakly_diagonally_dominant(self):
+        r"""Tests if the matrix is row weakly diagonally dominant.
+
+        Explanation
+        ===========
+
+        A $n, n$ matrix $A$ is row weakly diagonally dominant if
+
+        .. math::
+            \left|A_{i, i}\right| \ge \sum_{j = 0, j \neq i}^{n-1}
+            \left|A_{i, j}\right| \quad {\text{for all }}
+            i \in \{ 0, ..., n-1 \}
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]])
+        >>> A.is_weakly_diagonally_dominant
+        True
+
+        >>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]])
+        >>> A.is_weakly_diagonally_dominant
+        False
+
+        >>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]])
+        >>> A.is_weakly_diagonally_dominant
+        True
+
+        Notes
+        =====
+
+        If you want to test whether a matrix is column diagonally
+        dominant, you can apply the test after transposing the matrix.
+        """
+        if not self.is_square:
+            return False
+
+        rows, cols = self.shape
+
+        def test_row(i):
+            summation = self.zero
+            for j in range(cols):
+                if i != j:
+                    summation += Abs(self[i, j])
+            return (Abs(self[i, i]) - summation).is_nonnegative
+
+        return fuzzy_and(test_row(i) for i in range(rows))
+
+    @property
+    def is_strongly_diagonally_dominant(self):
+        r"""Tests if the matrix is row strongly diagonally dominant.
+
+        Explanation
+        ===========
+
+        A $n, n$ matrix $A$ is row strongly diagonally dominant if
+
+        .. math::
+            \left|A_{i, i}\right| > \sum_{j = 0, j \neq i}^{n-1}
+            \left|A_{i, j}\right| \quad {\text{for all }}
+            i \in \{ 0, ..., n-1 \}
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]])
+        >>> A.is_strongly_diagonally_dominant
+        False
+
+        >>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]])
+        >>> A.is_strongly_diagonally_dominant
+        False
+
+        >>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]])
+        >>> A.is_strongly_diagonally_dominant
+        True
+
+        Notes
+        =====
+
+        If you want to test whether a matrix is column diagonally
+        dominant, you can apply the test after transposing the matrix.
+        """
+        if not self.is_square:
+            return False
+
+        rows, cols = self.shape
+
+        def test_row(i):
+            summation = self.zero
+            for j in range(cols):
+                if i != j:
+                    summation += Abs(self[i, j])
+            return (Abs(self[i, i]) - summation).is_positive
+
+        return fuzzy_and(test_row(i) for i in range(rows))
+
+    @property
+    def is_hermitian(self):
+        """Checks if the matrix is Hermitian.
+
+        In a Hermitian matrix element i,j is the complex conjugate of
+        element j,i.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy import I
+        >>> from sympy.abc import x
+        >>> a = Matrix([[1, I], [-I, 1]])
+        >>> a
+        Matrix([
+        [ 1, I],
+        [-I, 1]])
+        >>> a.is_hermitian
+        True
+        >>> a[0, 0] = 2*I
+        >>> a.is_hermitian
+        False
+        >>> a[0, 0] = x
+        >>> a.is_hermitian
+        >>> a[0, 1] = a[1, 0]*I
+        >>> a.is_hermitian
+        False
+        """
+        if not self.is_square:
+            return False
+
+        return self._eval_is_matrix_hermitian(_simplify)
+
+    @property
+    def is_Identity(self) -> FuzzyBool:
+        if not self.is_square:
+            return False
+        return self._eval_is_Identity()
+
+    @property
+    def is_lower_hessenberg(self):
+        r"""Checks if the matrix is in the lower-Hessenberg form.
+
+        The lower hessenberg matrix has zero entries
+        above the first superdiagonal.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> a = Matrix([[1, 2, 0, 0], [5, 2, 3, 0], [3, 4, 3, 7], [5, 6, 1, 1]])
+        >>> a
+        Matrix([
+        [1, 2, 0, 0],
+        [5, 2, 3, 0],
+        [3, 4, 3, 7],
+        [5, 6, 1, 1]])
+        >>> a.is_lower_hessenberg
+        True
+
+        See Also
+        ========
+
+        is_upper_hessenberg
+        is_lower
+        """
+        return self._eval_is_lower_hessenberg()
+
+    @property
+    def is_lower(self):
+        """Check if matrix is a lower triangular matrix. True can be returned
+        even if the matrix is not square.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, [1, 0, 0, 1])
+        >>> m
+        Matrix([
+        [1, 0],
+        [0, 1]])
+        >>> m.is_lower
+        True
+
+        >>> m = Matrix(4, 3, [0, 0, 0, 2, 0, 0, 1, 4, 0, 6, 6, 5])
+        >>> m
+        Matrix([
+        [0, 0, 0],
+        [2, 0, 0],
+        [1, 4, 0],
+        [6, 6, 5]])
+        >>> m.is_lower
+        True
+
+        >>> from sympy.abc import x, y
+        >>> m = Matrix(2, 2, [x**2 + y, y**2 + x, 0, x + y])
+        >>> m
+        Matrix([
+        [x**2 + y, x + y**2],
+        [       0,    x + y]])
+        >>> m.is_lower
+        False
+
+        See Also
+        ========
+
+        is_upper
+        is_diagonal
+        is_lower_hessenberg
+        """
+        return self._eval_is_lower()
+
+    @property
+    def is_square(self):
+        """Checks if a matrix is square.
+
+        A matrix is square if the number of rows equals the number of columns.
+        The empty matrix is square by definition, since the number of rows and
+        the number of columns are both zero.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> a = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> b = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        >>> c = Matrix([])
+        >>> a.is_square
+        False
+        >>> b.is_square
+        True
+        >>> c.is_square
+        True
+        """
+        return self.rows == self.cols
+
+    def is_symbolic(self):
+        """Checks if any elements contain Symbols.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y
+        >>> M = Matrix([[x, y], [1, 0]])
+        >>> M.is_symbolic()
+        True
+
+        """
+        return self._eval_is_symbolic()
+
+    def is_symmetric(self, simplify=True):
+        """Check if matrix is symmetric matrix,
+        that is square matrix and is equal to its transpose.
+
+        By default, simplifications occur before testing symmetry.
+        They can be skipped using 'simplify=False'; while speeding things a bit,
+        this may however induce false negatives.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, [0, 1, 1, 2])
+        >>> m
+        Matrix([
+        [0, 1],
+        [1, 2]])
+        >>> m.is_symmetric()
+        True
+
+        >>> m = Matrix(2, 2, [0, 1, 2, 0])
+        >>> m
+        Matrix([
+        [0, 1],
+        [2, 0]])
+        >>> m.is_symmetric()
+        False
+
+        >>> m = Matrix(2, 3, [0, 0, 0, 0, 0, 0])
+        >>> m
+        Matrix([
+        [0, 0, 0],
+        [0, 0, 0]])
+        >>> m.is_symmetric()
+        False
+
+        >>> from sympy.abc import x, y
+        >>> m = Matrix(3, 3, [1, x**2 + 2*x + 1, y, (x + 1)**2, 2, 0, y, 0, 3])
+        >>> m
+        Matrix([
+        [         1, x**2 + 2*x + 1, y],
+        [(x + 1)**2,              2, 0],
+        [         y,              0, 3]])
+        >>> m.is_symmetric()
+        True
+
+        If the matrix is already simplified, you may speed-up is_symmetric()
+        test by using 'simplify=False'.
+
+        >>> bool(m.is_symmetric(simplify=False))
+        False
+        >>> m1 = m.expand()
+        >>> m1.is_symmetric(simplify=False)
+        True
+        """
+        simpfunc = simplify
+        if not isfunction(simplify):
+            simpfunc = _simplify if simplify else lambda x: x
+
+        if not self.is_square:
+            return False
+
+        return self._eval_is_symmetric(simpfunc)
+
+    @property
+    def is_upper_hessenberg(self):
+        """Checks if the matrix is the upper-Hessenberg form.
+
+        The upper hessenberg matrix has zero entries
+        below the first subdiagonal.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> a = Matrix([[1, 4, 2, 3], [3, 4, 1, 7], [0, 2, 3, 4], [0, 0, 1, 3]])
+        >>> a
+        Matrix([
+        [1, 4, 2, 3],
+        [3, 4, 1, 7],
+        [0, 2, 3, 4],
+        [0, 0, 1, 3]])
+        >>> a.is_upper_hessenberg
+        True
+
+        See Also
+        ========
+
+        is_lower_hessenberg
+        is_upper
+        """
+        return self._eval_is_upper_hessenberg()
+
+    @property
+    def is_upper(self):
+        """Check if matrix is an upper triangular matrix. True can be returned
+        even if the matrix is not square.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, [1, 0, 0, 1])
+        >>> m
+        Matrix([
+        [1, 0],
+        [0, 1]])
+        >>> m.is_upper
+        True
+
+        >>> m = Matrix(4, 3, [5, 1, 9, 0, 4, 6, 0, 0, 5, 0, 0, 0])
+        >>> m
+        Matrix([
+        [5, 1, 9],
+        [0, 4, 6],
+        [0, 0, 5],
+        [0, 0, 0]])
+        >>> m.is_upper
+        True
+
+        >>> m = Matrix(2, 3, [4, 2, 5, 6, 1, 1])
+        >>> m
+        Matrix([
+        [4, 2, 5],
+        [6, 1, 1]])
+        >>> m.is_upper
+        False
+
+        See Also
+        ========
+
+        is_lower
+        is_diagonal
+        is_upper_hessenberg
+        """
+        return all(self[i, j].is_zero
+                   for i in range(1, self.rows)
+                   for j in range(min(i, self.cols)))
+
+    @property
+    def is_zero_matrix(self):
+        """Checks if a matrix is a zero matrix.
+
+        A matrix is zero if every element is zero.  A matrix need not be square
+        to be considered zero.  The empty matrix is zero by the principle of
+        vacuous truth.  For a matrix that may or may not be zero (e.g.
+        contains a symbol), this will be None
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, zeros
+        >>> from sympy.abc import x
+        >>> a = Matrix([[0, 0], [0, 0]])
+        >>> b = zeros(3, 4)
+        >>> c = Matrix([[0, 1], [0, 0]])
+        >>> d = Matrix([])
+        >>> e = Matrix([[x, 0], [0, 0]])
+        >>> a.is_zero_matrix
+        True
+        >>> b.is_zero_matrix
+        True
+        >>> c.is_zero_matrix
+        False
+        >>> d.is_zero_matrix
+        True
+        >>> e.is_zero_matrix
+        """
+        return self._eval_is_zero_matrix()
+
+    def values(self):
+        """Return non-zero values of self."""
+        return self._eval_values()
+
+
+class MatrixOperations(MatrixRequired):
+    """Provides basic matrix shape and elementwise
+    operations.  Should not be instantiated directly."""
+
+    def _eval_adjoint(self):
+        return self.transpose().conjugate()
+
+    def _eval_applyfunc(self, f):
+        out = self._new(self.rows, self.cols, [f(x) for x in self])
+        return out
+
+    def _eval_as_real_imag(self):  # type: ignore
+        return (self.applyfunc(re), self.applyfunc(im))
+
+    def _eval_conjugate(self):
+        return self.applyfunc(lambda x: x.conjugate())
+
+    def _eval_permute_cols(self, perm):
+        # apply the permutation to a list
+        mapping = list(perm)
+
+        def entry(i, j):
+            return self[i, mapping[j]]
+
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_permute_rows(self, perm):
+        # apply the permutation to a list
+        mapping = list(perm)
+
+        def entry(i, j):
+            return self[mapping[i], j]
+
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_trace(self):
+        return sum(self[i, i] for i in range(self.rows))
+
+    def _eval_transpose(self):
+        return self._new(self.cols, self.rows, lambda i, j: self[j, i])
+
+    def adjoint(self):
+        """Conjugate transpose or Hermitian conjugation."""
+        return self._eval_adjoint()
+
+    def applyfunc(self, f):
+        """Apply a function to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, lambda i, j: i*2+j)
+        >>> m
+        Matrix([
+        [0, 1],
+        [2, 3]])
+        >>> m.applyfunc(lambda i: 2*i)
+        Matrix([
+        [0, 2],
+        [4, 6]])
+
+        """
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        return self._eval_applyfunc(f)
+
+    def as_real_imag(self, deep=True, **hints):
+        """Returns a tuple containing the (real, imaginary) part of matrix."""
+        # XXX: Ignoring deep and hints...
+        return self._eval_as_real_imag()
+
+    def conjugate(self):
+        """Return the by-element conjugation.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix, I
+        >>> a = SparseMatrix(((1, 2 + I), (3, 4), (I, -I)))
+        >>> a
+        Matrix([
+        [1, 2 + I],
+        [3,     4],
+        [I,    -I]])
+        >>> a.C
+        Matrix([
+        [ 1, 2 - I],
+        [ 3,     4],
+        [-I,     I]])
+
+        See Also
+        ========
+
+        transpose: Matrix transposition
+        H: Hermite conjugation
+        sympy.matrices.matrixbase.MatrixBase.D: Dirac conjugation
+        """
+        return self._eval_conjugate()
+
+    def doit(self, **hints):
+        return self.applyfunc(lambda x: x.doit(**hints))
+
+    def evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False):
+        """Apply evalf() to each element of self."""
+        options = {'subs':subs, 'maxn':maxn, 'chop':chop, 'strict':strict,
+                'quad':quad, 'verbose':verbose}
+        return self.applyfunc(lambda i: i.evalf(n, **options))
+
+    def expand(self, deep=True, modulus=None, power_base=True, power_exp=True,
+               mul=True, log=True, multinomial=True, basic=True, **hints):
+        """Apply core.function.expand to each entry of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import Matrix
+        >>> Matrix(1, 1, [x*(x+1)])
+        Matrix([[x*(x + 1)]])
+        >>> _.expand()
+        Matrix([[x**2 + x]])
+
+        """
+        return self.applyfunc(lambda x: x.expand(
+            deep, modulus, power_base, power_exp, mul, log, multinomial, basic,
+            **hints))
+
+    @property
+    def H(self):
+        """Return Hermite conjugate.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, I
+        >>> m = Matrix((0, 1 + I, 2, 3))
+        >>> m
+        Matrix([
+        [    0],
+        [1 + I],
+        [    2],
+        [    3]])
+        >>> m.H
+        Matrix([[0, 1 - I, 2, 3]])
+
+        See Also
+        ========
+
+        conjugate: By-element conjugation
+        sympy.matrices.matrixbase.MatrixBase.D: Dirac conjugation
+        """
+        return self.T.C
+
+    def permute(self, perm, orientation='rows', direction='forward'):
+        r"""Permute the rows or columns of a matrix by the given list of
+        swaps.
+
+        Parameters
+        ==========
+
+        perm : Permutation, list, or list of lists
+            A representation for the permutation.
+
+            If it is ``Permutation``, it is used directly with some
+            resizing with respect to the matrix size.
+
+            If it is specified as list of lists,
+            (e.g., ``[[0, 1], [0, 2]]``), then the permutation is formed
+            from applying the product of cycles. The direction how the
+            cyclic product is applied is described in below.
+
+            If it is specified as a list, the list should represent
+            an array form of a permutation. (e.g., ``[1, 2, 0]``) which
+            would would form the swapping function
+            `0 \mapsto 1, 1 \mapsto 2, 2\mapsto 0`.
+
+        orientation : 'rows', 'cols'
+            A flag to control whether to permute the rows or the columns
+
+        direction : 'forward', 'backward'
+            A flag to control whether to apply the permutations from
+            the start of the list first, or from the back of the list
+            first.
+
+            For example, if the permutation specification is
+            ``[[0, 1], [0, 2]]``,
+
+            If the flag is set to ``'forward'``, the cycle would be
+            formed as `0 \mapsto 2, 2 \mapsto 1, 1 \mapsto 0`.
+
+            If the flag is set to ``'backward'``, the cycle would be
+            formed as `0 \mapsto 1, 1 \mapsto 2, 2 \mapsto 0`.
+
+            If the argument ``perm`` is not in a form of list of lists,
+            this flag takes no effect.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='forward')
+        Matrix([
+        [0, 0, 1],
+        [1, 0, 0],
+        [0, 1, 0]])
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='backward')
+        Matrix([
+        [0, 1, 0],
+        [0, 0, 1],
+        [1, 0, 0]])
+
+        Notes
+        =====
+
+        If a bijective function
+        `\sigma : \mathbb{N}_0 \rightarrow \mathbb{N}_0` denotes the
+        permutation.
+
+        If the matrix `A` is the matrix to permute, represented as
+        a horizontal or a vertical stack of vectors:
+
+        .. math::
+            A =
+            \begin{bmatrix}
+            a_0 \\ a_1 \\ \vdots \\ a_{n-1}
+            \end{bmatrix} =
+            \begin{bmatrix}
+            \alpha_0 & \alpha_1 & \cdots & \alpha_{n-1}
+            \end{bmatrix}
+
+        If the matrix `B` is the result, the permutation of matrix rows
+        is defined as:
+
+        .. math::
+            B := \begin{bmatrix}
+            a_{\sigma(0)} \\ a_{\sigma(1)} \\ \vdots \\ a_{\sigma(n-1)}
+            \end{bmatrix}
+
+        And the permutation of matrix columns is defined as:
+
+        .. math::
+            B := \begin{bmatrix}
+            \alpha_{\sigma(0)} & \alpha_{\sigma(1)} &
+            \cdots & \alpha_{\sigma(n-1)}
+            \end{bmatrix}
+        """
+        from sympy.combinatorics import Permutation
+
+        # allow british variants and `columns`
+        if direction == 'forwards':
+            direction = 'forward'
+        if direction == 'backwards':
+            direction = 'backward'
+        if orientation == 'columns':
+            orientation = 'cols'
+
+        if direction not in ('forward', 'backward'):
+            raise TypeError("direction='{}' is an invalid kwarg. "
+                            "Try 'forward' or 'backward'".format(direction))
+        if orientation not in ('rows', 'cols'):
+            raise TypeError("orientation='{}' is an invalid kwarg. "
+                            "Try 'rows' or 'cols'".format(orientation))
+
+        if not isinstance(perm, (Permutation, Iterable)):
+            raise ValueError(
+                "{} must be a list, a list of lists, "
+                "or a SymPy permutation object.".format(perm))
+
+        # ensure all swaps are in range
+        max_index = self.rows if orientation == 'rows' else self.cols
+        if not all(0 <= t <= max_index for t in flatten(list(perm))):
+            raise IndexError("`swap` indices out of range.")
+
+        if perm and not isinstance(perm, Permutation) and \
+            isinstance(perm[0], Iterable):
+            if direction == 'forward':
+                perm = list(reversed(perm))
+            perm = Permutation(perm, size=max_index+1)
+        else:
+            perm = Permutation(perm, size=max_index+1)
+
+        if orientation == 'rows':
+            return self._eval_permute_rows(perm)
+        if orientation == 'cols':
+            return self._eval_permute_cols(perm)
+
+    def permute_cols(self, swaps, direction='forward'):
+        """Alias for
+        ``self.permute(swaps, orientation='cols', direction=direction)``
+
+        See Also
+        ========
+
+        permute
+        """
+        return self.permute(swaps, orientation='cols', direction=direction)
+
+    def permute_rows(self, swaps, direction='forward'):
+        """Alias for
+        ``self.permute(swaps, orientation='rows', direction=direction)``
+
+        See Also
+        ========
+
+        permute
+        """
+        return self.permute(swaps, orientation='rows', direction=direction)
+
+    def refine(self, assumptions=True):
+        """Apply refine to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Matrix, Abs, sqrt, Q
+        >>> x = Symbol('x')
+        >>> Matrix([[Abs(x)**2, sqrt(x**2)],[sqrt(x**2), Abs(x)**2]])
+        Matrix([
+        [ Abs(x)**2, sqrt(x**2)],
+        [sqrt(x**2),  Abs(x)**2]])
+        >>> _.refine(Q.real(x))
+        Matrix([
+        [  x**2, Abs(x)],
+        [Abs(x),   x**2]])
+
+        """
+        return self.applyfunc(lambda x: refine(x, assumptions))
+
+    def replace(self, F, G, map=False, simultaneous=True, exact=None):
+        """Replaces Function F in Matrix entries with Function G.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Function, Matrix
+        >>> F, G = symbols('F, G', cls=Function)
+        >>> M = Matrix(2, 2, lambda i, j: F(i+j)) ; M
+        Matrix([
+        [F(0), F(1)],
+        [F(1), F(2)]])
+        >>> N = M.replace(F,G)
+        >>> N
+        Matrix([
+        [G(0), G(1)],
+        [G(1), G(2)]])
+        """
+        return self.applyfunc(
+            lambda x: x.replace(F, G, map=map, simultaneous=simultaneous, exact=exact))
+
+    def rot90(self, k=1):
+        """Rotates Matrix by 90 degrees
+
+        Parameters
+        ==========
+
+        k : int
+            Specifies how many times the matrix is rotated by 90 degrees
+            (clockwise when positive, counter-clockwise when negative).
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, symbols
+        >>> A = Matrix(2, 2, symbols('a:d'))
+        >>> A
+        Matrix([
+        [a, b],
+        [c, d]])
+
+        Rotating the matrix clockwise one time:
+
+        >>> A.rot90(1)
+        Matrix([
+        [c, a],
+        [d, b]])
+
+        Rotating the matrix anticlockwise two times:
+
+        >>> A.rot90(-2)
+        Matrix([
+        [d, c],
+        [b, a]])
+        """
+
+        mod = k%4
+        if mod == 0:
+            return self
+        if mod == 1:
+            return self[::-1, ::].T
+        if mod == 2:
+            return self[::-1, ::-1]
+        if mod == 3:
+            return self[::, ::-1].T
+
+    def simplify(self, **kwargs):
+        """Apply simplify to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import SparseMatrix, sin, cos
+        >>> SparseMatrix(1, 1, [x*sin(y)**2 + x*cos(y)**2])
+        Matrix([[x*sin(y)**2 + x*cos(y)**2]])
+        >>> _.simplify()
+        Matrix([[x]])
+        """
+        return self.applyfunc(lambda x: x.simplify(**kwargs))
+
+    def subs(self, *args, **kwargs):  # should mirror core.basic.subs
+        """Return a new matrix with subs applied to each entry.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import SparseMatrix, Matrix
+        >>> SparseMatrix(1, 1, [x])
+        Matrix([[x]])
+        >>> _.subs(x, y)
+        Matrix([[y]])
+        >>> Matrix(_).subs(y, x)
+        Matrix([[x]])
+        """
+
+        if len(args) == 1 and  not isinstance(args[0], (dict, set)) and iter(args[0]) and not is_sequence(args[0]):
+            args = (list(args[0]),)
+
+        return self.applyfunc(lambda x: x.subs(*args, **kwargs))
+
+    def trace(self):
+        """
+        Returns the trace of a square matrix i.e. the sum of the
+        diagonal elements.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix(2, 2, [1, 2, 3, 4])
+        >>> A.trace()
+        5
+
+        """
+        if self.rows != self.cols:
+            raise NonSquareMatrixError()
+        return self._eval_trace()
+
+    def transpose(self):
+        """
+        Returns the transpose of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix(2, 2, [1, 2, 3, 4])
+        >>> A.transpose()
+        Matrix([
+        [1, 3],
+        [2, 4]])
+
+        >>> from sympy import Matrix, I
+        >>> m=Matrix(((1, 2+I), (3, 4)))
+        >>> m
+        Matrix([
+        [1, 2 + I],
+        [3,     4]])
+        >>> m.transpose()
+        Matrix([
+        [    1, 3],
+        [2 + I, 4]])
+        >>> m.T == m.transpose()
+        True
+
+        See Also
+        ========
+
+        conjugate: By-element conjugation
+
+        """
+        return self._eval_transpose()
+
+    @property
+    def T(self):
+        '''Matrix transposition'''
+        return self.transpose()
+
+    @property
+    def C(self):
+        '''By-element conjugation'''
+        return self.conjugate()
+
+    def n(self, *args, **kwargs):
+        """Apply evalf() to each element of self."""
+        return self.evalf(*args, **kwargs)
+
+    def xreplace(self, rule):  # should mirror core.basic.xreplace
+        """Return a new matrix with xreplace applied to each entry.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import SparseMatrix, Matrix
+        >>> SparseMatrix(1, 1, [x])
+        Matrix([[x]])
+        >>> _.xreplace({x: y})
+        Matrix([[y]])
+        >>> Matrix(_).xreplace({y: x})
+        Matrix([[x]])
+        """
+        return self.applyfunc(lambda x: x.xreplace(rule))
+
+    def _eval_simplify(self, **kwargs):
+        # XXX: We can't use self.simplify here as mutable subclasses will
+        # override simplify and have it return None
+        return MatrixOperations.simplify(self, **kwargs)
+
+    def _eval_trigsimp(self, **opts):
+        from sympy.simplify.trigsimp import trigsimp
+        return self.applyfunc(lambda x: trigsimp(x, **opts))
+
+    def upper_triangular(self, k=0):
+        """Return the elements on and above the kth diagonal of a matrix.
+        If k is not specified then simply returns upper-triangular portion
+        of a matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ones
+        >>> A = ones(4)
+        >>> A.upper_triangular()
+        Matrix([
+        [1, 1, 1, 1],
+        [0, 1, 1, 1],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1]])
+
+        >>> A.upper_triangular(2)
+        Matrix([
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]])
+
+        >>> A.upper_triangular(-1)
+        Matrix([
+        [1, 1, 1, 1],
+        [1, 1, 1, 1],
+        [0, 1, 1, 1],
+        [0, 0, 1, 1]])
+
+        """
+
+        def entry(i, j):
+            return self[i, j] if i + k <= j else self.zero
+
+        return self._new(self.rows, self.cols, entry)
+
+
+    def lower_triangular(self, k=0):
+        """Return the elements on and below the kth diagonal of a matrix.
+        If k is not specified then simply returns lower-triangular portion
+        of a matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ones
+        >>> A = ones(4)
+        >>> A.lower_triangular()
+        Matrix([
+        [1, 0, 0, 0],
+        [1, 1, 0, 0],
+        [1, 1, 1, 0],
+        [1, 1, 1, 1]])
+
+        >>> A.lower_triangular(-2)
+        Matrix([
+        [0, 0, 0, 0],
+        [0, 0, 0, 0],
+        [1, 0, 0, 0],
+        [1, 1, 0, 0]])
+
+        >>> A.lower_triangular(1)
+        Matrix([
+        [1, 1, 0, 0],
+        [1, 1, 1, 0],
+        [1, 1, 1, 1],
+        [1, 1, 1, 1]])
+
+        """
+
+        def entry(i, j):
+            return self[i, j] if i + k >= j else self.zero
+
+        return self._new(self.rows, self.cols, entry)
+
+
+
+class MatrixArithmetic(MatrixRequired):
+    """Provides basic matrix arithmetic operations.
+    Should not be instantiated directly."""
+
+    _op_priority = 10.01
+
+    def _eval_Abs(self):
+        return self._new(self.rows, self.cols, lambda i, j: Abs(self[i, j]))
+
+    def _eval_add(self, other):
+        return self._new(self.rows, self.cols,
+                         lambda i, j: self[i, j] + other[i, j])
+
+    def _eval_matrix_mul(self, other):
+        def entry(i, j):
+            vec = [self[i,k]*other[k,j] for k in range(self.cols)]
+            try:
+                return Add(*vec)
+            except (TypeError, SympifyError):
+                # Some matrices don't work with `sum` or `Add`
+                # They don't work with `sum` because `sum` tries to add `0`
+                # Fall back to a safe way to multiply if the `Add` fails.
+                return reduce(lambda a, b: a + b, vec)
+
+        return self._new(self.rows, other.cols, entry)
+
+    def _eval_matrix_mul_elementwise(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: self[i,j]*other[i,j])
+
+    def _eval_matrix_rmul(self, other):
+        def entry(i, j):
+            return sum(other[i,k]*self[k,j] for k in range(other.cols))
+        return self._new(other.rows, self.cols, entry)
+
+    def _eval_pow_by_recursion(self, num):
+        if num == 1:
+            return self
+
+        if num % 2 == 1:
+            a, b = self, self._eval_pow_by_recursion(num - 1)
+        else:
+            a = b = self._eval_pow_by_recursion(num // 2)
+
+        return a.multiply(b)
+
+    def _eval_pow_by_cayley(self, exp):
+        from sympy.discrete.recurrences import linrec_coeffs
+        row = self.shape[0]
+        p = self.charpoly()
+
+        coeffs = (-p).all_coeffs()[1:]
+        coeffs = linrec_coeffs(coeffs, exp)
+        new_mat = self.eye(row)
+        ans = self.zeros(row)
+
+        for i in range(row):
+            ans += coeffs[i]*new_mat
+            new_mat *= self
+
+        return ans
+
+    def _eval_pow_by_recursion_dotprodsimp(self, num, prevsimp=None):
+        if prevsimp is None:
+            prevsimp = [True]*len(self)
+
+        if num == 1:
+            return self
+
+        if num % 2 == 1:
+            a, b = self, self._eval_pow_by_recursion_dotprodsimp(num - 1,
+                    prevsimp=prevsimp)
+        else:
+            a = b = self._eval_pow_by_recursion_dotprodsimp(num // 2,
+                    prevsimp=prevsimp)
+
+        m     = a.multiply(b, dotprodsimp=False)
+        lenm  = len(m)
+        elems = [None]*lenm
+
+        for i in range(lenm):
+            if prevsimp[i]:
+                elems[i], prevsimp[i] = _dotprodsimp(m[i], withsimp=True)
+            else:
+                elems[i] = m[i]
+
+        return m._new(m.rows, m.cols, elems)
+
+    def _eval_scalar_mul(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: self[i,j]*other)
+
+    def _eval_scalar_rmul(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: other*self[i,j])
+
+    def _eval_Mod(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: Mod(self[i, j], other))
+
+    # Python arithmetic functions
+    def __abs__(self):
+        """Returns a new matrix with entry-wise absolute values."""
+        return self._eval_Abs()
+
+    @call_highest_priority('__radd__')
+    def __add__(self, other):
+        """Return self + other, raising ShapeError if shapes do not match."""
+        if isinstance(other, NDimArray): # Matrix and array addition is currently not implemented
+            return NotImplemented
+        other = _matrixify(other)
+        # matrix-like objects can have shapes.  This is
+        # our first sanity check.
+        if hasattr(other, 'shape'):
+            if self.shape != other.shape:
+                raise ShapeError("Matrix size mismatch: %s + %s" % (
+                    self.shape, other.shape))
+
+        # honest SymPy matrices defer to their class's routine
+        if getattr(other, 'is_Matrix', False):
+            # call the highest-priority class's _eval_add
+            a, b = self, other
+            if a.__class__ != classof(a, b):
+                b, a = a, b
+            return a._eval_add(b)
+        # Matrix-like objects can be passed to CommonMatrix routines directly.
+        if getattr(other, 'is_MatrixLike', False):
+            return MatrixArithmetic._eval_add(self, other)
+
+        raise TypeError('cannot add %s and %s' % (type(self), type(other)))
+
+    @call_highest_priority('__rtruediv__')
+    def __truediv__(self, other):
+        return self * (self.one / other)
+
+    @call_highest_priority('__rmatmul__')
+    def __matmul__(self, other):
+        other = _matrixify(other)
+        if not getattr(other, 'is_Matrix', False) and not getattr(other, 'is_MatrixLike', False):
+            return NotImplemented
+
+        return self.__mul__(other)
+
+    def __mod__(self, other):
+        return self.applyfunc(lambda x: x % other)
+
+    @call_highest_priority('__rmul__')
+    def __mul__(self, other):
+        """Return self*other where other is either a scalar or a matrix
+        of compatible dimensions.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> 2*A == A*2 == Matrix([[2, 4, 6], [8, 10, 12]])
+        True
+        >>> B = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        >>> A*B
+        Matrix([
+        [30, 36, 42],
+        [66, 81, 96]])
+        >>> B*A
+        Traceback (most recent call last):
+        ...
+        ShapeError: Matrices size mismatch.
+        >>>
+
+        See Also
+        ========
+
+        matrix_multiply_elementwise
+        """
+
+        return self.multiply(other)
+
+    def multiply(self, other, dotprodsimp=None):
+        """Same as __mul__() but with optional simplification.
+
+        Parameters
+        ==========
+
+        dotprodsimp : bool, optional
+            Specifies whether intermediate term algebraic simplification is used
+            during matrix multiplications to control expression blowup and thus
+            speed up calculation. Default is off.
+        """
+
+        isimpbool = _get_intermediate_simp_bool(False, dotprodsimp)
+        other = _matrixify(other)
+        # matrix-like objects can have shapes.  This is
+        # our first sanity check. Double check other is not explicitly not a Matrix.
+        if (hasattr(other, 'shape') and len(other.shape) == 2 and
+            (getattr(other, 'is_Matrix', True) or
+             getattr(other, 'is_MatrixLike', True))):
+            if self.shape[1] != other.shape[0]:
+                raise ShapeError("Matrix size mismatch: %s * %s." % (
+                    self.shape, other.shape))
+
+        # honest SymPy matrices defer to their class's routine
+        if getattr(other, 'is_Matrix', False):
+            m = self._eval_matrix_mul(other)
+            if isimpbool:
+                return m._new(m.rows, m.cols, [_dotprodsimp(e) for e in m])
+            return m
+
+        # Matrix-like objects can be passed to CommonMatrix routines directly.
+        if getattr(other, 'is_MatrixLike', False):
+            return MatrixArithmetic._eval_matrix_mul(self, other)
+
+        # if 'other' is not iterable then scalar multiplication.
+        if not isinstance(other, Iterable):
+            try:
+                return self._eval_scalar_mul(other)
+            except TypeError:
+                pass
+
+        return NotImplemented
+
+    def multiply_elementwise(self, other):
+        """Return the Hadamard product (elementwise product) of A and B
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[0, 1, 2], [3, 4, 5]])
+        >>> B = Matrix([[1, 10, 100], [100, 10, 1]])
+        >>> A.multiply_elementwise(B)
+        Matrix([
+        [  0, 10, 200],
+        [300, 40,   5]])
+
+        See Also
+        ========
+
+        sympy.matrices.matrixbase.MatrixBase.cross
+        sympy.matrices.matrixbase.MatrixBase.dot
+        multiply
+        """
+        if self.shape != other.shape:
+            raise ShapeError("Matrix shapes must agree {} != {}".format(self.shape, other.shape))
+
+        return self._eval_matrix_mul_elementwise(other)
+
+    def __neg__(self):
+        return self._eval_scalar_mul(-1)
+
+    @call_highest_priority('__rpow__')
+    def __pow__(self, exp):
+        """Return self**exp a scalar or symbol."""
+
+        return self.pow(exp)
+
+
+    def pow(self, exp, method=None):
+        r"""Return self**exp a scalar or symbol.
+
+        Parameters
+        ==========
+
+        method : multiply, mulsimp, jordan, cayley
+            If multiply then it returns exponentiation using recursion.
+            If jordan then Jordan form exponentiation will be used.
+            If cayley then the exponentiation is done using Cayley-Hamilton
+            theorem.
+            If mulsimp then the exponentiation is done using recursion
+            with dotprodsimp. This specifies whether intermediate term
+            algebraic simplification is used during naive matrix power to
+            control expression blowup and thus speed up calculation.
+            If None, then it heuristically decides which method to use.
+
+        """
+
+        if method is not None and method not in ['multiply', 'mulsimp', 'jordan', 'cayley']:
+            raise TypeError('No such method')
+        if self.rows != self.cols:
+            raise NonSquareMatrixError()
+        a = self
+        jordan_pow = getattr(a, '_matrix_pow_by_jordan_blocks', None)
+        exp = sympify(exp)
+
+        if exp.is_zero:
+            return a._new(a.rows, a.cols, lambda i, j: int(i == j))
+        if exp == 1:
+            return a
+
+        diagonal = getattr(a, 'is_diagonal', None)
+        if diagonal is not None and diagonal():
+            return a._new(a.rows, a.cols, lambda i, j: a[i,j]**exp if i == j else 0)
+
+        if exp.is_Number and exp % 1 == 0:
+            if a.rows == 1:
+                return a._new([[a[0]**exp]])
+            if exp < 0:
+                exp = -exp
+                a = a.inv()
+        # When certain conditions are met,
+        # Jordan block algorithm is faster than
+        # computation by recursion.
+        if method == 'jordan':
+            try:
+                return jordan_pow(exp)
+            except MatrixError:
+                if method == 'jordan':
+                    raise
+
+        elif method == 'cayley':
+            if not exp.is_Number or exp % 1 != 0:
+                raise ValueError("cayley method is only valid for integer powers")
+            return a._eval_pow_by_cayley(exp)
+
+        elif method == "mulsimp":
+            if not exp.is_Number or exp % 1 != 0:
+                raise ValueError("mulsimp method is only valid for integer powers")
+            return a._eval_pow_by_recursion_dotprodsimp(exp)
+
+        elif method == "multiply":
+            if not exp.is_Number or exp % 1 != 0:
+                raise ValueError("multiply method is only valid for integer powers")
+            return a._eval_pow_by_recursion(exp)
+
+        elif method is None and exp.is_Number and exp % 1 == 0:
+            if exp.is_Float:
+                exp = Integer(exp)
+            # Decide heuristically which method to apply
+            if a.rows == 2 and exp > 100000:
+                return jordan_pow(exp)
+            elif _get_intermediate_simp_bool(True, None):
+                return a._eval_pow_by_recursion_dotprodsimp(exp)
+            elif exp > 10000:
+                return a._eval_pow_by_cayley(exp)
+            else:
+                return a._eval_pow_by_recursion(exp)
+
+        if jordan_pow:
+            try:
+                return jordan_pow(exp)
+            except NonInvertibleMatrixError:
+                # Raised by jordan_pow on zero determinant matrix unless exp is
+                # definitely known to be a non-negative integer.
+                # Here we raise if n is definitely not a non-negative integer
+                # but otherwise we can leave this as an unevaluated MatPow.
+                if exp.is_integer is False or exp.is_nonnegative is False:
+                    raise
+
+        from sympy.matrices.expressions import MatPow
+        return MatPow(a, exp)
+
+    @call_highest_priority('__add__')
+    def __radd__(self, other):
+        return self + other
+
+    @call_highest_priority('__matmul__')
+    def __rmatmul__(self, other):
+        other = _matrixify(other)
+        if not getattr(other, 'is_Matrix', False) and not getattr(other, 'is_MatrixLike', False):
+            return NotImplemented
+
+        return self.__rmul__(other)
+
+    @call_highest_priority('__mul__')
+    def __rmul__(self, other):
+        return self.rmultiply(other)
+
+    def rmultiply(self, other, dotprodsimp=None):
+        """Same as __rmul__() but with optional simplification.
+
+        Parameters
+        ==========
+
+        dotprodsimp : bool, optional
+            Specifies whether intermediate term algebraic simplification is used
+            during matrix multiplications to control expression blowup and thus
+            speed up calculation. Default is off.
+        """
+        isimpbool = _get_intermediate_simp_bool(False, dotprodsimp)
+        other = _matrixify(other)
+        # matrix-like objects can have shapes.  This is
+        # our first sanity check. Double check other is not explicitly not a Matrix.
+        if (hasattr(other, 'shape') and len(other.shape) == 2 and
+            (getattr(other, 'is_Matrix', True) or
+             getattr(other, 'is_MatrixLike', True))):
+            if self.shape[0] != other.shape[1]:
+                raise ShapeError("Matrix size mismatch.")
+
+        # honest SymPy matrices defer to their class's routine
+        if getattr(other, 'is_Matrix', False):
+            m = self._eval_matrix_rmul(other)
+            if isimpbool:
+                return m._new(m.rows, m.cols, [_dotprodsimp(e) for e in m])
+            return m
+        # Matrix-like objects can be passed to CommonMatrix routines directly.
+        if getattr(other, 'is_MatrixLike', False):
+            return MatrixArithmetic._eval_matrix_rmul(self, other)
+
+        # if 'other' is not iterable then scalar multiplication.
+        if not isinstance(other, Iterable):
+            try:
+                return self._eval_scalar_rmul(other)
+            except TypeError:
+                pass
+
+        return NotImplemented
+
+    @call_highest_priority('__sub__')
+    def __rsub__(self, a):
+        return (-self) + a
+
+    @call_highest_priority('__rsub__')
+    def __sub__(self, a):
+        return self + (-a)
+
+
+class MatrixCommon(MatrixArithmetic, MatrixOperations, MatrixProperties,
+                  MatrixSpecial, MatrixShaping):
+    """All common matrix operations including basic arithmetic, shaping,
+    and special matrices like `zeros`, and `eye`."""
+    _diff_wrt = True  # type: bool
+
+
+class _MinimalMatrix:
+    """Class providing the minimum functionality
+    for a matrix-like object and implementing every method
+    required for a `MatrixRequired`.  This class does not have everything
+    needed to become a full-fledged SymPy object, but it will satisfy the
+    requirements of anything inheriting from `MatrixRequired`.  If you wish
+    to make a specialized matrix type, make sure to implement these
+    methods and properties with the exception of `__init__` and `__repr__`
+    which are included for convenience."""
+
+    is_MatrixLike = True
+    _sympify = staticmethod(sympify)
+    _class_priority = 3
+    zero = S.Zero
+    one = S.One
+
+    is_Matrix = True
+    is_MatrixExpr = False
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def __init__(self, rows, cols=None, mat=None, copy=False):
+        if isfunction(mat):
+            # if we passed in a function, use that to populate the indices
+            mat = [mat(i, j) for i in range(rows) for j in range(cols)]
+        if cols is None and mat is None:
+            mat = rows
+        rows, cols = getattr(mat, 'shape', (rows, cols))
+        try:
+            # if we passed in a list of lists, flatten it and set the size
+            if cols is None and mat is None:
+                mat = rows
+            cols = len(mat[0])
+            rows = len(mat)
+            mat = [x for l in mat for x in l]
+        except (IndexError, TypeError):
+            pass
+        self.mat = tuple(self._sympify(x) for x in mat)
+        self.rows, self.cols = rows, cols
+        if self.rows is None or self.cols is None:
+            raise NotImplementedError("Cannot initialize matrix with given parameters")
+
+    def __getitem__(self, key):
+        def _normalize_slices(row_slice, col_slice):
+            """Ensure that row_slice and col_slice do not have
+            `None` in their arguments.  Any integers are converted
+            to slices of length 1"""
+            if not isinstance(row_slice, slice):
+                row_slice = slice(row_slice, row_slice + 1, None)
+            row_slice = slice(*row_slice.indices(self.rows))
+
+            if not isinstance(col_slice, slice):
+                col_slice = slice(col_slice, col_slice + 1, None)
+            col_slice = slice(*col_slice.indices(self.cols))
+
+            return (row_slice, col_slice)
+
+        def _coord_to_index(i, j):
+            """Return the index in _mat corresponding
+            to the (i,j) position in the matrix. """
+            return i * self.cols + j
+
+        if isinstance(key, tuple):
+            i, j = key
+            if isinstance(i, slice) or isinstance(j, slice):
+                # if the coordinates are not slices, make them so
+                # and expand the slices so they don't contain `None`
+                i, j = _normalize_slices(i, j)
+
+                rowsList, colsList = list(range(self.rows))[i], \
+                                     list(range(self.cols))[j]
+                indices = (i * self.cols + j for i in rowsList for j in
+                           colsList)
+                return self._new(len(rowsList), len(colsList),
+                                 [self.mat[i] for i in indices])
+
+            # if the key is a tuple of ints, change
+            # it to an array index
+            key = _coord_to_index(i, j)
+        return self.mat[key]
+
+    def __eq__(self, other):
+        try:
+            classof(self, other)
+        except TypeError:
+            return False
+        return (
+            self.shape == other.shape and list(self) == list(other))
+
+    def __len__(self):
+        return self.rows*self.cols
+
+    def __repr__(self):
+        return "_MinimalMatrix({}, {}, {})".format(self.rows, self.cols,
+                                                   self.mat)
+
+    @property
+    def shape(self):
+        return (self.rows, self.cols)
+
+
+class _CastableMatrix: # this is needed here ONLY FOR TESTS.
+    def as_mutable(self):
+        return self
+
+    def as_immutable(self):
+        return self
+
+
+class _MatrixWrapper:
+    """Wrapper class providing the minimum functionality for a matrix-like
+    object: .rows, .cols, .shape, indexability, and iterability. CommonMatrix
+    math operations should work on matrix-like objects. This one is intended for
+    matrix-like objects which use the same indexing format as SymPy with respect
+    to returning matrix elements instead of rows for non-tuple indexes.
+    """
+
+    is_Matrix     = False # needs to be here because of __getattr__
+    is_MatrixLike = True
+
+    def __init__(self, mat, shape):
+        self.mat = mat
+        self.shape = shape
+        self.rows, self.cols = shape
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            return sympify(self.mat.__getitem__(key))
+
+        return sympify(self.mat.__getitem__((key // self.rows, key % self.cols)))
+
+    def __iter__(self): # supports numpy.matrix and numpy.array
+        mat = self.mat
+        cols = self.cols
+
+        return iter(sympify(mat[r, c]) for r in range(self.rows) for c in range(cols))
+
+
+def _matrixify(mat):
+    """If `mat` is a Matrix or is matrix-like,
+    return a Matrix or MatrixWrapper object.  Otherwise
+    `mat` is passed through without modification."""
+
+    if getattr(mat, 'is_Matrix', False) or getattr(mat, 'is_MatrixLike', False):
+        return mat
+
+    if not(getattr(mat, 'is_Matrix', True) or getattr(mat, 'is_MatrixLike', True)):
+        return mat
+
+    shape = None
+
+    if hasattr(mat, 'shape'): # numpy, scipy.sparse
+        if len(mat.shape) == 2:
+            shape = mat.shape
+    elif hasattr(mat, 'rows') and hasattr(mat, 'cols'): # mpmath
+        shape = (mat.rows, mat.cols)
+
+    if shape:
+        return _MatrixWrapper(mat, shape)
+
+    return mat
+
+
+def a2idx(j, n=None):
+    """Return integer after making positive and validating against n."""
+    if not isinstance(j, int):
+        jindex = getattr(j, '__index__', None)
+        if jindex is not None:
+            j = jindex()
+        else:
+            raise IndexError("Invalid index a[%r]" % (j,))
+    if n is not None:
+        if j < 0:
+            j += n
+        if not (j >= 0 and j < n):
+            raise IndexError("Index out of range: a[%s]" % (j,))
+    return int(j)
+
+
+def classof(A, B):
+    """
+    Get the type of the result when combining matrices of different types.
+
+    Currently the strategy is that immutability is contagious.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, ImmutableMatrix
+    >>> from sympy.matrices.matrixbase import classof
+    >>> M = Matrix([[1, 2], [3, 4]]) # a Mutable Matrix
+    >>> IM = ImmutableMatrix([[1, 2], [3, 4]])
+    >>> classof(M, IM)
+    <class 'sympy.matrices.immutable.ImmutableDenseMatrix'>
+    """
+    priority_A = getattr(A, '_class_priority', None)
+    priority_B = getattr(B, '_class_priority', None)
+    if None not in (priority_A, priority_B):
+        if A._class_priority > B._class_priority:
+            return A.__class__
+        else:
+            return B.__class__
+
+    try:
+        import numpy
+    except ImportError:
+        pass
+    else:
+        if isinstance(A, numpy.ndarray):
+            return B.__class__
+        if isinstance(B, numpy.ndarray):
+            return A.__class__
+
+    raise TypeError("Incompatible classes %s, %s" % (A.__class__, B.__class__))

phi4/lib/python3.10/site-packages/sympy/matrices/dense.py

@@ -0,0 +1,1093 @@
+import random
+
+from sympy.core.basic import Basic
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+
+from .exceptions import ShapeError
+from .decompositions import _cholesky, _LDLdecomposition
+from .matrixbase import MatrixBase
+from .repmatrix import MutableRepMatrix, RepMatrix
+from .solvers import _lower_triangular_solve, _upper_triangular_solve
+
+
+__doctest_requires__ = {('symarray',): ['numpy']}
+
+
+def _iszero(x):
+    """Returns True if x is zero."""
+    return x.is_zero
+
+
+class DenseMatrix(RepMatrix):
+    """Matrix implementation based on DomainMatrix as the internal representation"""
+
+    #
+    # DenseMatrix is a superclass for both MutableDenseMatrix and
+    # ImmutableDenseMatrix. Methods shared by both classes but not for the
+    # Sparse classes should be implemented here.
+    #
+
+    is_MatrixExpr = False  # type: bool
+
+    _op_priority = 10.01
+    _class_priority = 4
+
+    @property
+    def _mat(self):
+        sympy_deprecation_warning(
+            """
+            The private _mat attribute of Matrix is deprecated. Use the
+            .flat() method instead.
+            """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-private-matrix-attributes"
+        )
+
+        return self.flat()
+
+    def _eval_inverse(self, **kwargs):
+        return self.inv(method=kwargs.get('method', 'GE'),
+                        iszerofunc=kwargs.get('iszerofunc', _iszero),
+                        try_block_diag=kwargs.get('try_block_diag', False))
+
+    def as_immutable(self):
+        """Returns an Immutable version of this Matrix
+        """
+        from .immutable import ImmutableDenseMatrix as cls
+        return cls._fromrep(self._rep.copy())
+
+    def as_mutable(self):
+        """Returns a mutable version of this matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ImmutableMatrix
+        >>> X = ImmutableMatrix([[1, 2], [3, 4]])
+        >>> Y = X.as_mutable()
+        >>> Y[1, 1] = 5 # Can set values in Y
+        >>> Y
+        Matrix([
+        [1, 2],
+        [3, 5]])
+        """
+        return Matrix(self)
+
+    def cholesky(self, hermitian=True):
+        return _cholesky(self, hermitian=hermitian)
+
+    def LDLdecomposition(self, hermitian=True):
+        return _LDLdecomposition(self, hermitian=hermitian)
+
+    def lower_triangular_solve(self, rhs):
+        return _lower_triangular_solve(self, rhs)
+
+    def upper_triangular_solve(self, rhs):
+        return _upper_triangular_solve(self, rhs)
+
+    cholesky.__doc__               = _cholesky.__doc__
+    LDLdecomposition.__doc__       = _LDLdecomposition.__doc__
+    lower_triangular_solve.__doc__ = _lower_triangular_solve.__doc__
+    upper_triangular_solve.__doc__ = _upper_triangular_solve.__doc__
+
+
+def _force_mutable(x):
+    """Return a matrix as a Matrix, otherwise return x."""
+    if getattr(x, 'is_Matrix', False):
+        return x.as_mutable()
+    elif isinstance(x, Basic):
+        return x
+    elif hasattr(x, '__array__'):
+        a = x.__array__()
+        if len(a.shape) == 0:
+            return sympify(a)
+        return Matrix(x)
+    return x
+
+
+class MutableDenseMatrix(DenseMatrix, MutableRepMatrix):
+
+    def simplify(self, **kwargs):
+        """Applies simplify to the elements of a matrix in place.
+
+        This is a shortcut for M.applyfunc(lambda x: simplify(x, ratio, measure))
+
+        See Also
+        ========
+
+        sympy.simplify.simplify.simplify
+        """
+        from sympy.simplify.simplify import simplify as _simplify
+        for (i, j), element in self.todok().items():
+            self[i, j] = _simplify(element, **kwargs)
+
+
+MutableMatrix = Matrix = MutableDenseMatrix
+
+###########
+# Numpy Utility Functions:
+# list2numpy, matrix2numpy, symmarray
+###########
+
+
+def list2numpy(l, dtype=object):  # pragma: no cover
+    """Converts Python list of SymPy expressions to a NumPy array.
+
+    See Also
+    ========
+
+    matrix2numpy
+    """
+    from numpy import empty
+    a = empty(len(l), dtype)
+    for i, s in enumerate(l):
+        a[i] = s
+    return a
+
+
+def matrix2numpy(m, dtype=object):  # pragma: no cover
+    """Converts SymPy's matrix to a NumPy array.
+
+    See Also
+    ========
+
+    list2numpy
+    """
+    from numpy import empty
+    a = empty(m.shape, dtype)
+    for i in range(m.rows):
+        for j in range(m.cols):
+            a[i, j] = m[i, j]
+    return a
+
+
+###########
+# Rotation matrices:
+# rot_givens, rot_axis[123], rot_ccw_axis[123]
+###########
+
+
+def rot_givens(i, j, theta, dim=3):
+    r"""Returns a a Givens rotation matrix, a a rotation in the
+    plane spanned by two coordinates axes.
+
+    Explanation
+    ===========
+
+    The Givens rotation corresponds to a generalization of rotation
+    matrices to any number of dimensions, given by:
+
+    .. math::
+        G(i, j, \theta) =
+            \begin{bmatrix}
+                1   & \cdots &    0   & \cdots &    0   & \cdots &    0   \\
+                \vdots & \ddots & \vdots &        & \vdots &        & \vdots \\
+                0   & \cdots &    c   & \cdots &   -s   & \cdots &    0   \\
+                \vdots &        & \vdots & \ddots & \vdots &        & \vdots \\
+                0   & \cdots &    s   & \cdots &    c   & \cdots &    0   \\
+                \vdots &        & \vdots &        & \vdots & \ddots & \vdots \\
+                0   & \cdots &    0   & \cdots &    0   & \cdots &    1
+            \end{bmatrix}
+
+    Where $c = \cos(\theta)$ and $s = \sin(\theta)$ appear at the intersections
+    ``i``\th and ``j``\th rows and columns.
+
+    For fixed ``i > j``\, the non-zero elements of a Givens matrix are
+    given by:
+
+    - $g_{kk} = 1$ for $k \ne i,\,j$
+    - $g_{kk} = c$ for $k = i,\,j$
+    - $g_{ji} = -g_{ij} = -s$
+
+    Parameters
+    ==========
+
+    i : int between ``0`` and ``dim - 1``
+        Represents first axis
+    j : int between ``0`` and ``dim - 1``
+        Represents second axis
+    dim : int bigger than 1
+        Number of dimentions. Defaults to 3.
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_givens
+
+    A counterclockwise rotation of pi/3 (60 degrees) around
+    the third axis (z-axis):
+
+    >>> rot_givens(1, 0, pi/3)
+    Matrix([
+    [      1/2, -sqrt(3)/2, 0],
+    [sqrt(3)/2,        1/2, 0],
+    [        0,          0, 1]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_givens(1, 0, pi/2)
+    Matrix([
+    [0, -1, 0],
+    [1,  0, 0],
+    [0,  0, 1]])
+
+    This can be generalized to any number
+    of dimensions:
+
+    >>> rot_givens(1, 0, pi/2, dim=4)
+    Matrix([
+    [0, -1, 0, 0],
+    [1,  0, 0, 0],
+    [0,  0, 1, 0],
+    [0,  0, 0, 1]])
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Givens_rotation
+
+    See Also
+    ========
+
+    rot_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (clockwise around the x axis)
+    rot_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (clockwise around the y axis)
+    rot_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (clockwise around the z axis)
+    rot_ccw_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (counterclockwise around the x axis)
+    rot_ccw_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (counterclockwise around the y axis)
+    rot_ccw_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (counterclockwise around the z axis)
+    """
+    if not isinstance(dim, int) or dim < 2:
+        raise ValueError('dim must be an integer biggen than one, '
+                         'got {}.'.format(dim))
+
+    if i == j:
+        raise ValueError('i and j must be different, '
+                         'got ({}, {})'.format(i, j))
+
+    for ij in [i, j]:
+        if not isinstance(ij, int) or ij < 0 or ij > dim - 1:
+            raise ValueError('i and j must be integers between 0 and '
+                             '{}, got i={} and j={}.'.format(dim-1, i, j))
+
+    theta = sympify(theta)
+    c = cos(theta)
+    s = sin(theta)
+    M = eye(dim)
+    M[i, i] = c
+    M[j, j] = c
+    M[i, j] = s
+    M[j, i] = -s
+    return M
+
+
+def rot_axis3(theta):
+    r"""Returns a rotation matrix for a rotation of theta (in radians)
+    about the 3-axis.
+
+    Explanation
+    ===========
+
+    For a right-handed coordinate system, this corresponds to a
+    clockwise rotation around the `z`-axis, given by:
+
+    .. math::
+
+        R  = \begin{bmatrix}
+                 \cos(\theta) & \sin(\theta) & 0 \\
+                -\sin(\theta) & \cos(\theta) & 0 \\
+                            0 &            0 & 1
+            \end{bmatrix}
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_axis3
+
+    A rotation of pi/3 (60 degrees):
+
+    >>> theta = pi/3
+    >>> rot_axis3(theta)
+    Matrix([
+    [       1/2, sqrt(3)/2, 0],
+    [-sqrt(3)/2,       1/2, 0],
+    [         0,         0, 1]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_axis3(pi/2)
+    Matrix([
+    [ 0, 1, 0],
+    [-1, 0, 0],
+    [ 0, 0, 1]])
+
+    See Also
+    ========
+
+    rot_givens: Returns a Givens rotation matrix (generalized rotation for
+        any number of dimensions)
+    rot_ccw_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (counterclockwise around the z axis)
+    rot_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (clockwise around the x axis)
+    rot_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (clockwise around the y axis)
+    """
+    return rot_givens(0, 1, theta, dim=3)
+
+
+def rot_axis2(theta):
+    r"""Returns a rotation matrix for a rotation of theta (in radians)
+    about the 2-axis.
+
+    Explanation
+    ===========
+
+    For a right-handed coordinate system, this corresponds to a
+    clockwise rotation around the `y`-axis, given by:
+
+    .. math::
+
+        R  = \begin{bmatrix}
+                \cos(\theta) & 0 & -\sin(\theta) \\
+                           0 & 1 &             0 \\
+                \sin(\theta) & 0 &  \cos(\theta)
+            \end{bmatrix}
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_axis2
+
+    A rotation of pi/3 (60 degrees):
+
+    >>> theta = pi/3
+    >>> rot_axis2(theta)
+    Matrix([
+    [      1/2, 0, -sqrt(3)/2],
+    [        0, 1,          0],
+    [sqrt(3)/2, 0,        1/2]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_axis2(pi/2)
+    Matrix([
+    [0, 0, -1],
+    [0, 1,  0],
+    [1, 0,  0]])
+
+    See Also
+    ========
+
+    rot_givens: Returns a Givens rotation matrix (generalized rotation for
+        any number of dimensions)
+    rot_ccw_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (clockwise around the y axis)
+    rot_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (counterclockwise around the x axis)
+    rot_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (counterclockwise around the z axis)
+    """
+    return rot_givens(2, 0, theta, dim=3)
+
+
+def rot_axis1(theta):
+    r"""Returns a rotation matrix for a rotation of theta (in radians)
+    about the 1-axis.
+
+    Explanation
+    ===========
+
+    For a right-handed coordinate system, this corresponds to a
+    clockwise rotation around the `x`-axis, given by:
+
+    .. math::
+
+        R  = \begin{bmatrix}
+                1 &             0 &            0 \\
+                0 &  \cos(\theta) & \sin(\theta) \\
+                0 & -\sin(\theta) & \cos(\theta)
+            \end{bmatrix}
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_axis1
+
+    A rotation of pi/3 (60 degrees):
+
+    >>> theta = pi/3
+    >>> rot_axis1(theta)
+    Matrix([
+    [1,          0,         0],
+    [0,        1/2, sqrt(3)/2],
+    [0, -sqrt(3)/2,       1/2]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_axis1(pi/2)
+    Matrix([
+    [1,  0, 0],
+    [0,  0, 1],
+    [0, -1, 0]])
+
+    See Also
+    ========
+
+    rot_givens: Returns a Givens rotation matrix (generalized rotation for
+        any number of dimensions)
+    rot_ccw_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (counterclockwise around the x axis)
+    rot_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (clockwise around the y axis)
+    rot_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (clockwise around the z axis)
+    """
+    return rot_givens(1, 2, theta, dim=3)
+
+
+def rot_ccw_axis3(theta):
+    r"""Returns a rotation matrix for a rotation of theta (in radians)
+    about the 3-axis.
+
+    Explanation
+    ===========
+
+    For a right-handed coordinate system, this corresponds to a
+    counterclockwise rotation around the `z`-axis, given by:
+
+    .. math::
+
+        R  = \begin{bmatrix}
+                \cos(\theta) & -\sin(\theta) & 0 \\
+                \sin(\theta) &  \cos(\theta) & 0 \\
+                           0 &             0 & 1
+            \end{bmatrix}
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_ccw_axis3
+
+    A rotation of pi/3 (60 degrees):
+
+    >>> theta = pi/3
+    >>> rot_ccw_axis3(theta)
+    Matrix([
+    [      1/2, -sqrt(3)/2, 0],
+    [sqrt(3)/2,        1/2, 0],
+    [        0,          0, 1]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_ccw_axis3(pi/2)
+    Matrix([
+    [0, -1, 0],
+    [1,  0, 0],
+    [0,  0, 1]])
+
+    See Also
+    ========
+
+    rot_givens: Returns a Givens rotation matrix (generalized rotation for
+        any number of dimensions)
+    rot_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (clockwise around the z axis)
+    rot_ccw_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (counterclockwise around the x axis)
+    rot_ccw_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (counterclockwise around the y axis)
+    """
+    return rot_givens(1, 0, theta, dim=3)
+
+
+def rot_ccw_axis2(theta):
+    r"""Returns a rotation matrix for a rotation of theta (in radians)
+    about the 2-axis.
+
+    Explanation
+    ===========
+
+    For a right-handed coordinate system, this corresponds to a
+    counterclockwise rotation around the `y`-axis, given by:
+
+    .. math::
+
+        R  = \begin{bmatrix}
+                 \cos(\theta) & 0 & \sin(\theta) \\
+                            0 & 1 &            0 \\
+                -\sin(\theta) & 0 & \cos(\theta)
+            \end{bmatrix}
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_ccw_axis2
+
+    A rotation of pi/3 (60 degrees):
+
+    >>> theta = pi/3
+    >>> rot_ccw_axis2(theta)
+    Matrix([
+    [       1/2, 0, sqrt(3)/2],
+    [         0, 1,         0],
+    [-sqrt(3)/2, 0,       1/2]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_ccw_axis2(pi/2)
+    Matrix([
+    [ 0,  0,  1],
+    [ 0,  1,  0],
+    [-1,  0,  0]])
+
+    See Also
+    ========
+
+    rot_givens: Returns a Givens rotation matrix (generalized rotation for
+        any number of dimensions)
+    rot_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (clockwise around the y axis)
+    rot_ccw_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (counterclockwise around the x axis)
+    rot_ccw_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (counterclockwise around the z axis)
+    """
+    return rot_givens(0, 2, theta, dim=3)
+
+
+def rot_ccw_axis1(theta):
+    r"""Returns a rotation matrix for a rotation of theta (in radians)
+    about the 1-axis.
+
+    Explanation
+    ===========
+
+    For a right-handed coordinate system, this corresponds to a
+    counterclockwise rotation around the `x`-axis, given by:
+
+    .. math::
+
+        R  = \begin{bmatrix}
+                1 &            0 &             0 \\
+                0 & \cos(\theta) & -\sin(\theta) \\
+                0 & \sin(\theta) &  \cos(\theta)
+            \end{bmatrix}
+
+    Examples
+    ========
+
+    >>> from sympy import pi, rot_ccw_axis1
+
+    A rotation of pi/3 (60 degrees):
+
+    >>> theta = pi/3
+    >>> rot_ccw_axis1(theta)
+    Matrix([
+    [1,         0,          0],
+    [0,       1/2, -sqrt(3)/2],
+    [0, sqrt(3)/2,        1/2]])
+
+    If we rotate by pi/2 (90 degrees):
+
+    >>> rot_ccw_axis1(pi/2)
+    Matrix([
+    [1, 0,  0],
+    [0, 0, -1],
+    [0, 1,  0]])
+
+    See Also
+    ========
+
+    rot_givens: Returns a Givens rotation matrix (generalized rotation for
+        any number of dimensions)
+    rot_axis1: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 1-axis (clockwise around the x axis)
+    rot_ccw_axis2: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 2-axis (counterclockwise around the y axis)
+    rot_ccw_axis3: Returns a rotation matrix for a rotation of theta (in radians)
+        about the 3-axis (counterclockwise around the z axis)
+    """
+    return rot_givens(2, 1, theta, dim=3)
+
+
+@doctest_depends_on(modules=('numpy',))
+def symarray(prefix, shape, **kwargs):  # pragma: no cover
+    r"""Create a numpy ndarray of symbols (as an object array).
+
+    The created symbols are named ``prefix_i1_i2_``...  You should thus provide a
+    non-empty prefix if you want your symbols to be unique for different output
+    arrays, as SymPy symbols with identical names are the same object.
+
+    Parameters
+    ----------
+
+    prefix : string
+      A prefix prepended to the name of every symbol.
+
+    shape : int or tuple
+      Shape of the created array.  If an int, the array is one-dimensional; for
+      more than one dimension the shape must be a tuple.
+
+    \*\*kwargs : dict
+      keyword arguments passed on to Symbol
+
+    Examples
+    ========
+    These doctests require numpy.
+
+    >>> from sympy import symarray
+    >>> symarray('', 3)
+    [_0 _1 _2]
+
+    If you want multiple symarrays to contain distinct symbols, you *must*
+    provide unique prefixes:
+
+    >>> a = symarray('', 3)
+    >>> b = symarray('', 3)
+    >>> a[0] == b[0]
+    True
+    >>> a = symarray('a', 3)
+    >>> b = symarray('b', 3)
+    >>> a[0] == b[0]
+    False
+
+    Creating symarrays with a prefix:
+
+    >>> symarray('a', 3)
+    [a_0 a_1 a_2]
+
+    For more than one dimension, the shape must be given as a tuple:
+
+    >>> symarray('a', (2, 3))
+    [[a_0_0 a_0_1 a_0_2]
+     [a_1_0 a_1_1 a_1_2]]
+    >>> symarray('a', (2, 3, 2))
+    [[[a_0_0_0 a_0_0_1]
+      [a_0_1_0 a_0_1_1]
+      [a_0_2_0 a_0_2_1]]
+    <BLANKLINE>
+     [[a_1_0_0 a_1_0_1]
+      [a_1_1_0 a_1_1_1]
+      [a_1_2_0 a_1_2_1]]]
+
+    For setting assumptions of the underlying Symbols:
+
+    >>> [s.is_real for s in symarray('a', 2, real=True)]
+    [True, True]
+    """
+    from numpy import empty, ndindex
+    arr = empty(shape, dtype=object)
+    for index in ndindex(shape):
+        arr[index] = Symbol('%s_%s' % (prefix, '_'.join(map(str, index))),
+                            **kwargs)
+    return arr
+
+
+###############
+# Functions
+###############
+
+def casoratian(seqs, n, zero=True):
+    """Given linear difference operator L of order 'k' and homogeneous
+       equation Ly = 0 we want to compute kernel of L, which is a set
+       of 'k' sequences: a(n), b(n), ... z(n).
+
+       Solutions of L are linearly independent iff their Casoratian,
+       denoted as C(a, b, ..., z), do not vanish for n = 0.
+
+       Casoratian is defined by k x k determinant::
+
+                  +  a(n)     b(n)     . . . z(n)     +
+                  |  a(n+1)   b(n+1)   . . . z(n+1)   |
+                  |    .         .     .        .     |
+                  |    .         .       .      .     |
+                  |    .         .         .    .     |
+                  +  a(n+k-1) b(n+k-1) . . . z(n+k-1) +
+
+       It proves very useful in rsolve_hyper() where it is applied
+       to a generating set of a recurrence to factor out linearly
+       dependent solutions and return a basis:
+
+       >>> from sympy import Symbol, casoratian, factorial
+       >>> n = Symbol('n', integer=True)
+
+       Exponential and factorial are linearly independent:
+
+       >>> casoratian([2**n, factorial(n)], n) != 0
+       True
+
+    """
+
+    seqs = list(map(sympify, seqs))
+
+    if not zero:
+        f = lambda i, j: seqs[j].subs(n, n + i)
+    else:
+        f = lambda i, j: seqs[j].subs(n, i)
+
+    k = len(seqs)
+
+    return Matrix(k, k, f).det()
+
+
+def eye(*args, **kwargs):
+    """Create square identity matrix n x n
+
+    See Also
+    ========
+
+    diag
+    zeros
+    ones
+    """
+
+    return Matrix.eye(*args, **kwargs)
+
+
+def diag(*values, strict=True, unpack=False, **kwargs):
+    """Returns a matrix with the provided values placed on the
+    diagonal. If non-square matrices are included, they will
+    produce a block-diagonal matrix.
+
+    Examples
+    ========
+
+    This version of diag is a thin wrapper to Matrix.diag that differs
+    in that it treats all lists like matrices -- even when a single list
+    is given. If this is not desired, either put a `*` before the list or
+    set `unpack=True`.
+
+    >>> from sympy import diag
+
+    >>> diag([1, 2, 3], unpack=True)  # = diag(1,2,3) or diag(*[1,2,3])
+    Matrix([
+    [1, 0, 0],
+    [0, 2, 0],
+    [0, 0, 3]])
+
+    >>> diag([1, 2, 3])  # a column vector
+    Matrix([
+    [1],
+    [2],
+    [3]])
+
+    See Also
+    ========
+    .matrixbase.MatrixBase.eye
+    .matrixbase.MatrixBase.diagonal
+    .matrixbase.MatrixBase.diag
+    .expressions.blockmatrix.BlockMatrix
+    """
+    return Matrix.diag(*values, strict=strict, unpack=unpack, **kwargs)
+
+
+def GramSchmidt(vlist, orthonormal=False):
+    """Apply the Gram-Schmidt process to a set of vectors.
+
+    Parameters
+    ==========
+
+    vlist : List of Matrix
+        Vectors to be orthogonalized for.
+
+    orthonormal : Bool, optional
+        If true, return an orthonormal basis.
+
+    Returns
+    =======
+
+    vlist : List of Matrix
+        Orthogonalized vectors
+
+    Notes
+    =====
+
+    This routine is mostly duplicate from ``Matrix.orthogonalize``,
+    except for some difference that this always raises error when
+    linearly dependent vectors are found, and the keyword ``normalize``
+    has been named as ``orthonormal`` in this function.
+
+    See Also
+    ========
+
+    .matrixbase.MatrixBase.orthogonalize
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process
+    """
+    return MutableDenseMatrix.orthogonalize(
+        *vlist, normalize=orthonormal, rankcheck=True
+    )
+
+
+def hessian(f, varlist, constraints=()):
+    """Compute Hessian matrix for a function f wrt parameters in varlist
+    which may be given as a sequence or a row/column vector. A list of
+    constraints may optionally be given.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, hessian, pprint
+    >>> from sympy.abc import x, y
+    >>> f = Function('f')(x, y)
+    >>> g1 = Function('g')(x, y)
+    >>> g2 = x**2 + 3*y
+    >>> pprint(hessian(f, (x, y), [g1, g2]))
+    [                   d               d            ]
+    [     0        0    --(g(x, y))     --(g(x, y))  ]
+    [                   dx              dy           ]
+    [                                                ]
+    [     0        0        2*x              3       ]
+    [                                                ]
+    [                     2               2          ]
+    [d                   d               d           ]
+    [--(g(x, y))  2*x   ---(f(x, y))   -----(f(x, y))]
+    [dx                   2            dy dx         ]
+    [                   dx                           ]
+    [                                                ]
+    [                     2               2          ]
+    [d                   d               d           ]
+    [--(g(x, y))   3   -----(f(x, y))   ---(f(x, y)) ]
+    [dy                dy dx              2          ]
+    [                                   dy           ]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hessian_matrix
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.jacobian
+    wronskian
+    """
+    # f is the expression representing a function f, return regular matrix
+    if isinstance(varlist, MatrixBase):
+        if 1 not in varlist.shape:
+            raise ShapeError("`varlist` must be a column or row vector.")
+        if varlist.cols == 1:
+            varlist = varlist.T
+        varlist = varlist.tolist()[0]
+    if is_sequence(varlist):
+        n = len(varlist)
+        if not n:
+            raise ShapeError("`len(varlist)` must not be zero.")
+    else:
+        raise ValueError("Improper variable list in hessian function")
+    if not getattr(f, 'diff'):
+        # check differentiability
+        raise ValueError("Function `f` (%s) is not differentiable" % f)
+    m = len(constraints)
+    N = m + n
+    out = zeros(N)
+    for k, g in enumerate(constraints):
+        if not getattr(g, 'diff'):
+            # check differentiability
+            raise ValueError("Function `f` (%s) is not differentiable" % f)
+        for i in range(n):
+            out[k, i + m] = g.diff(varlist[i])
+    for i in range(n):
+        for j in range(i, n):
+            out[i + m, j + m] = f.diff(varlist[i]).diff(varlist[j])
+    for i in range(N):
+        for j in range(i + 1, N):
+            out[j, i] = out[i, j]
+    return out
+
+
+def jordan_cell(eigenval, n):
+    """
+    Create a Jordan block:
+
+    Examples
+    ========
+
+    >>> from sympy import jordan_cell
+    >>> from sympy.abc import x
+    >>> jordan_cell(x, 4)
+    Matrix([
+    [x, 1, 0, 0],
+    [0, x, 1, 0],
+    [0, 0, x, 1],
+    [0, 0, 0, x]])
+    """
+
+    return Matrix.jordan_block(size=n, eigenvalue=eigenval)
+
+
+def matrix_multiply_elementwise(A, B):
+    """Return the Hadamard product (elementwise product) of A and B
+
+    >>> from sympy import Matrix, matrix_multiply_elementwise
+    >>> A = Matrix([[0, 1, 2], [3, 4, 5]])
+    >>> B = Matrix([[1, 10, 100], [100, 10, 1]])
+    >>> matrix_multiply_elementwise(A, B)
+    Matrix([
+    [  0, 10, 200],
+    [300, 40,   5]])
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.__mul__
+    """
+    return A.multiply_elementwise(B)
+
+
+def ones(*args, **kwargs):
+    """Returns a matrix of ones with ``rows`` rows and ``cols`` columns;
+    if ``cols`` is omitted a square matrix will be returned.
+
+    See Also
+    ========
+
+    zeros
+    eye
+    diag
+    """
+
+    if 'c' in kwargs:
+        kwargs['cols'] = kwargs.pop('c')
+
+    return Matrix.ones(*args, **kwargs)
+
+
+def randMatrix(r, c=None, min=0, max=99, seed=None, symmetric=False,
+               percent=100, prng=None):
+    """Create random matrix with dimensions ``r`` x ``c``. If ``c`` is omitted
+    the matrix will be square. If ``symmetric`` is True the matrix must be
+    square. If ``percent`` is less than 100 then only approximately the given
+    percentage of elements will be non-zero.
+
+    The pseudo-random number generator used to generate matrix is chosen in the
+    following way.
+
+    * If ``prng`` is supplied, it will be used as random number generator.
+      It should be an instance of ``random.Random``, or at least have
+      ``randint`` and ``shuffle`` methods with same signatures.
+    * if ``prng`` is not supplied but ``seed`` is supplied, then new
+      ``random.Random`` with given ``seed`` will be created;
+    * otherwise, a new ``random.Random`` with default seed will be used.
+
+    Examples
+    ========
+
+    >>> from sympy import randMatrix
+    >>> randMatrix(3) # doctest:+SKIP
+    [25, 45, 27]
+    [44, 54,  9]
+    [23, 96, 46]
+    >>> randMatrix(3, 2) # doctest:+SKIP
+    [87, 29]
+    [23, 37]
+    [90, 26]
+    >>> randMatrix(3, 3, 0, 2) # doctest:+SKIP
+    [0, 2, 0]
+    [2, 0, 1]
+    [0, 0, 1]
+    >>> randMatrix(3, symmetric=True) # doctest:+SKIP
+    [85, 26, 29]
+    [26, 71, 43]
+    [29, 43, 57]
+    >>> A = randMatrix(3, seed=1)
+    >>> B = randMatrix(3, seed=2)
+    >>> A == B
+    False
+    >>> A == randMatrix(3, seed=1)
+    True
+    >>> randMatrix(3, symmetric=True, percent=50) # doctest:+SKIP
+    [77, 70,  0],
+    [70,  0,  0],
+    [ 0,  0, 88]
+    """
+    # Note that ``Random()`` is equivalent to ``Random(None)``
+    prng = prng or random.Random(seed)
+
+    if c is None:
+        c = r
+
+    if symmetric and r != c:
+        raise ValueError('For symmetric matrices, r must equal c, but %i != %i' % (r, c))
+
+    ij = range(r * c)
+    if percent != 100:
+        ij = prng.sample(ij, int(len(ij)*percent // 100))
+
+    m = zeros(r, c)
+
+    if not symmetric:
+        for ijk in ij:
+            i, j = divmod(ijk, c)
+            m[i, j] = prng.randint(min, max)
+    else:
+        for ijk in ij:
+            i, j = divmod(ijk, c)
+            if i <= j:
+                m[i, j] = m[j, i] = prng.randint(min, max)
+
+    return m
+
+
+def wronskian(functions, var, method='bareiss'):
+    """
+    Compute Wronskian for [] of functions
+
+    ::
+
+                         | f1       f2        ...   fn      |
+                         | f1'      f2'       ...   fn'     |
+                         |  .        .        .      .      |
+        W(f1, ..., fn) = |  .        .         .     .      |
+                         |  .        .          .    .      |
+                         |  (n)      (n)            (n)     |
+                         | D   (f1) D   (f2)  ...  D   (fn) |
+
+    see: https://en.wikipedia.org/wiki/Wronskian
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.jacobian
+    hessian
+    """
+
+    functions = [sympify(f) for f in functions]
+    n = len(functions)
+    if n == 0:
+        return S.One
+    W = Matrix(n, n, lambda i, j: functions[i].diff(var, j))
+    return W.det(method)
+
+
+def zeros(*args, **kwargs):
+    """Returns a matrix of zeros with ``rows`` rows and ``cols`` columns;
+    if ``cols`` is omitted a square matrix will be returned.
+
+    See Also
+    ========
+
+    ones
+    eye
+    diag
+    """
+
+    if 'c' in kwargs:
+        kwargs['cols'] = kwargs.pop('c')
+
+    return Matrix.zeros(*args, **kwargs)

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

@@ -0,0 +1,1021 @@
+from types import FunctionType
+
+from sympy.core.cache import cacheit
+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 sympy.polys.matrices.ddm import DDM
+
+from .exceptions 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",
+        "bird", "laplace" 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.matrixbase.MatrixBase.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()
+
+    # Use DomainMatrix. We are already going to convert this to a Poly so there
+    # is no need to worry about expanding powers etc. Also since this algorithm
+    # does not require division or zero detection it is fine to use EX.
+    #
+    # M.to_DM() will fall back on EXRAW rather than EX. EXRAW is a lot faster
+    # for elementary arithmetic because it does not call cancel for each
+    # operation but it generates large unsimplified results that are slow in
+    # the subsequent call to simplify. Using EX instead is faster overall
+    # but at least in some cases EXRAW+simplify gives a simpler result so we
+    # preserve that existing behaviour of charpoly for now...
+    dM = M.to_DM()
+
+    K = dM.domain
+
+    cp = dM.charpoly()
+
+    x = uniquely_named_symbol(x, [M], modify=lambda s: '_' + s)
+
+    if K.is_EXRAW or simplify is not _simplify:
+        # XXX: Converting back to Expr is expensive. We only do it if the
+        # caller supplied a custom simplify function for backwards
+        # compatibility or otherwise if the domain was EX. For any other domain
+        # there should be no benefit in simplifying at this stage because Poly
+        # will put everything into canonical form anyway.
+        berk_vector = [K.to_sympy(c) for c in cp]
+        berk_vector = [simplify(a) for a in berk_vector]
+        p = PurePoly(berk_vector, x)
+
+    else:
+        # Convert from the list of domain elements directly to Poly.
+        p = PurePoly(cp, x, domain=K)
+
+    return p
+
+
+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",
+        "bird", "laplace" 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",
+        "bird", "laplace" 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:
+        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.
+
+        If it is set to ``'bird'``, Bird's algorithm will be used [1]_.
+
+        If it is set to ``'laplace'``, Laplace's 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
+
+    References
+    ==========
+
+    .. [1] Bird, R. S. (2011). A simple division-free algorithm for computing
+           determinants. Inf. Process. Lett., 111(21), 1072-1074. doi:
+           10.1016/j.ipl.2011.08.006
+    """
+
+    # 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", "bird",
+                      "laplace"):
+        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)
+        elif method == "bird":
+            det = M[b, b]._eval_det_bird()
+        elif method == "laplace":
+            det = M[b, b]._eval_det_laplace()
+        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
+
+
+@cacheit
+def __det_laplace(M):
+    """Compute the determinant of a matrix using Laplace expansion.
+
+    This is a recursive function, and it should not be called directly.
+    Use _det_laplace() instead. The reason for splitting this function
+    into two is to allow caching of determinants of submatrices. While
+    one could also define this function inside _det_laplace(), that
+    would remove the advantage of using caching in Cramer Solve.
+    """
+    n = M.shape[0]
+    if n == 1:
+        return M[0]
+    elif n == 2:
+        return M[0, 0] * M[1, 1] - M[0, 1] * M[1, 0]
+    else:
+        return sum((-1) ** i * M[0, i] *
+                   __det_laplace(M.minor_submatrix(0, i)) for i in range(n))
+
+
+def _det_laplace(M):
+    """Compute the determinant of a matrix using Laplace expansion.
+
+    While Laplace expansion is not the most efficient method of computing
+    a determinant, it is a simple one, and it has the advantage of
+    being division free. To improve efficiency, this function uses
+    caching to avoid recomputing determinants of submatrices.
+    """
+    if not M.is_square:
+        raise NonSquareMatrixError()
+    if M.shape[0] == 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 __det_laplace(M.as_immutable())
+
+
+def _det_bird(M):
+    r"""Compute the determinant of a matrix using Bird's algorithm.
+
+    Bird's algorithm is a simple division-free algorithm for computing, which
+    is of lower order than the Laplace's algorithm. It is described in [1]_.
+
+    References
+    ==========
+
+    .. [1] Bird, R. S. (2011). A simple division-free algorithm for computing
+           determinants. Inf. Process. Lett., 111(21), 1072-1074. doi:
+           10.1016/j.ipl.2011.08.006
+    """
+    def mu(X):
+        n = X.shape[0]
+        zero = X.domain.zero
+
+        total = zero
+        diag_sums = [zero]
+        for i in reversed(range(1, n)):
+            total -= X[i][i]
+            diag_sums.append(total)
+        diag_sums = diag_sums[::-1]
+
+        elems = [[zero] * i + [diag_sums[i]] + X_i[i + 1:] for i, X_i in
+                 enumerate(X)]
+        return DDM(elems, X.shape, X.domain)
+
+    Mddm = M._rep.to_ddm()
+    n = M.shape[0]
+    if n == 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.
+    Fn1 = Mddm
+    for _ in range(n - 1):
+        Fn1 = mu(Fn1).matmul(Mddm)
+    detA = Fn1[0][0]
+    if n % 2 == 0:
+        detA = -detA
+
+    return Mddm.domain.to_sympy(detA)
+
+
+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", "bird", "laplace" 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)

phi4/lib/python3.10/site-packages/sympy/matrices/exceptions.py

@@ -0,0 +1,26 @@
+"""
+Exceptions raised by the matrix module.
+"""
+
+
+class MatrixError(Exception):
+    pass
+
+
+class ShapeError(ValueError, MatrixError):
+    """Wrong matrix shape"""
+    pass
+
+
+class NonSquareMatrixError(ShapeError):
+    pass
+
+
+class NonInvertibleMatrixError(ValueError, MatrixError):
+    """The matrix in not invertible (division by multidimensional zero error)."""
+    pass
+
+
+class NonPositiveDefiniteMatrixError(ValueError, MatrixError):
+    """The matrix is not a positive-definite matrix."""
+    pass

phi4/lib/python3.10/site-packages/sympy/matrices/expressions/transpose.py

@@ -0,0 +1,103 @@
+from sympy.core.basic import Basic
+from sympy.matrices.expressions.matexpr import MatrixExpr
+
+
+class Transpose(MatrixExpr):
+    """
+    The transpose of a matrix expression.
+
+    This is a symbolic object that simply stores its argument without
+    evaluating it. To actually compute the transpose, use the ``transpose()``
+    function, or the ``.T`` attribute of matrices.
+
+    Examples
+    ========
+
+    >>> from sympy import MatrixSymbol, Transpose, transpose
+    >>> A = MatrixSymbol('A', 3, 5)
+    >>> B = MatrixSymbol('B', 5, 3)
+    >>> Transpose(A)
+    A.T
+    >>> A.T == transpose(A) == Transpose(A)
+    True
+    >>> Transpose(A*B)
+    (A*B).T
+    >>> transpose(A*B)
+    B.T*A.T
+
+    """
+    is_Transpose = True
+
+    def doit(self, **hints):
+        arg = self.arg
+        if hints.get('deep', True) and isinstance(arg, Basic):
+            arg = arg.doit(**hints)
+        _eval_transpose = getattr(arg, '_eval_transpose', None)
+        if _eval_transpose is not None:
+            result = _eval_transpose()
+            return result if result is not None else Transpose(arg)
+        else:
+            return Transpose(arg)
+
+    @property
+    def arg(self):
+        return self.args[0]
+
+    @property
+    def shape(self):
+        return self.arg.shape[::-1]
+
+    def _entry(self, i, j, expand=False, **kwargs):
+        return self.arg._entry(j, i, expand=expand, **kwargs)
+
+    def _eval_adjoint(self):
+        return self.arg.conjugate()
+
+    def _eval_conjugate(self):
+        return self.arg.adjoint()
+
+    def _eval_transpose(self):
+        return self.arg
+
+    def _eval_trace(self):
+        from .trace import Trace
+        return Trace(self.arg)  # Trace(X.T) => Trace(X)
+
+    def _eval_determinant(self):
+        from sympy.matrices.expressions.determinant import det
+        return det(self.arg)
+
+    def _eval_derivative(self, x):
+        # x is a scalar:
+        return self.arg._eval_derivative(x)
+
+    def _eval_derivative_matrix_lines(self, x):
+        lines = self.args[0]._eval_derivative_matrix_lines(x)
+        return [i.transpose() for i in lines]
+
+
+def transpose(expr):
+    """Matrix transpose"""
+    return Transpose(expr).doit(deep=False)
+
+
+from sympy.assumptions.ask import ask, Q
+from sympy.assumptions.refine import handlers_dict
+
+
+def refine_Transpose(expr, assumptions):
+    """
+    >>> from sympy import MatrixSymbol, Q, assuming, refine
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> X.T
+    X.T
+    >>> with assuming(Q.symmetric(X)):
+    ...     print(refine(X.T))
+    X
+    """
+    if ask(Q.symmetric(expr), assumptions):
+        return expr.arg
+
+    return expr
+
+handlers_dict['Transpose'] = refine_Transpose

phi4/lib/python3.10/site-packages/sympy/matrices/graph.py

@@ -0,0 +1,279 @@
+from sympy.utilities.iterables import \
+    flatten, connected_components, strongly_connected_components
+from .exceptions import NonSquareMatrixError
+
+
+def _connected_components(M):
+    """Returns the list of connected vertices of the graph when
+    a square matrix is viewed as a weighted graph.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([
+    ...     [66, 0, 0, 68, 0, 0, 0, 0, 67],
+    ...     [0, 55, 0, 0, 0, 0, 54, 53, 0],
+    ...     [0, 0, 0, 0, 1, 2, 0, 0, 0],
+    ...     [86, 0, 0, 88, 0, 0, 0, 0, 87],
+    ...     [0, 0, 10, 0, 11, 12, 0, 0, 0],
+    ...     [0, 0, 20, 0, 21, 22, 0, 0, 0],
+    ...     [0, 45, 0, 0, 0, 0, 44, 43, 0],
+    ...     [0, 35, 0, 0, 0, 0, 34, 33, 0],
+    ...     [76, 0, 0, 78, 0, 0, 0, 0, 77]])
+    >>> A.connected_components()
+    [[0, 3, 8], [1, 6, 7], [2, 4, 5]]
+
+    Notes
+    =====
+
+    Even if any symbolic elements of the matrix can be indeterminate
+    to be zero mathematically, this only takes the account of the
+    structural aspect of the matrix, so they will considered to be
+    nonzero.
+    """
+    if not M.is_square:
+        raise NonSquareMatrixError
+
+    V = range(M.rows)
+    E = sorted(M.todok().keys())
+    return connected_components((V, E))
+
+
+def _strongly_connected_components(M):
+    """Returns the list of strongly connected vertices of the graph when
+    a square matrix is viewed as a weighted graph.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([
+    ...     [44, 0, 0, 0, 43, 0, 45, 0, 0],
+    ...     [0, 66, 62, 61, 0, 68, 0, 60, 67],
+    ...     [0, 0, 22, 21, 0, 0, 0, 20, 0],
+    ...     [0, 0, 12, 11, 0, 0, 0, 10, 0],
+    ...     [34, 0, 0, 0, 33, 0, 35, 0, 0],
+    ...     [0, 86, 82, 81, 0, 88, 0, 80, 87],
+    ...     [54, 0, 0, 0, 53, 0, 55, 0, 0],
+    ...     [0, 0, 2, 1, 0, 0, 0, 0, 0],
+    ...     [0, 76, 72, 71, 0, 78, 0, 70, 77]])
+    >>> A.strongly_connected_components()
+    [[0, 4, 6], [2, 3, 7], [1, 5, 8]]
+    """
+    if not M.is_square:
+        raise NonSquareMatrixError
+
+    # RepMatrix uses the more efficient DomainMatrix.scc() method
+    rep = getattr(M, '_rep', None)
+    if rep is not None:
+        return rep.scc()
+
+    V = range(M.rows)
+    E = sorted(M.todok().keys())
+    return strongly_connected_components((V, E))
+
+
+def _connected_components_decomposition(M):
+    """Decomposes a square matrix into block diagonal form only
+    using the permutations.
+
+    Explanation
+    ===========
+
+    The decomposition is in a form of $A = P^{-1} B P$ where $P$ is a
+    permutation matrix and $B$ is a block diagonal matrix.
+
+    Returns
+    =======
+
+    P, B : PermutationMatrix, BlockDiagMatrix
+        *P* is a permutation matrix for the similarity transform
+        as in the explanation. And *B* is the block diagonal matrix of
+        the result of the permutation.
+
+        If you would like to get the diagonal blocks from the
+        BlockDiagMatrix, see
+        :meth:`~sympy.matrices.expressions.blockmatrix.BlockDiagMatrix.get_diag_blocks`.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, pprint
+    >>> A = Matrix([
+    ...     [66, 0, 0, 68, 0, 0, 0, 0, 67],
+    ...     [0, 55, 0, 0, 0, 0, 54, 53, 0],
+    ...     [0, 0, 0, 0, 1, 2, 0, 0, 0],
+    ...     [86, 0, 0, 88, 0, 0, 0, 0, 87],
+    ...     [0, 0, 10, 0, 11, 12, 0, 0, 0],
+    ...     [0, 0, 20, 0, 21, 22, 0, 0, 0],
+    ...     [0, 45, 0, 0, 0, 0, 44, 43, 0],
+    ...     [0, 35, 0, 0, 0, 0, 34, 33, 0],
+    ...     [76, 0, 0, 78, 0, 0, 0, 0, 77]])
+
+    >>> P, B = A.connected_components_decomposition()
+    >>> pprint(P)
+    PermutationMatrix((1 3)(2 8 5 7 4 6))
+    >>> pprint(B)
+    [[66  68  67]                            ]
+    [[          ]                            ]
+    [[86  88  87]       0             0      ]
+    [[          ]                            ]
+    [[76  78  77]                            ]
+    [                                        ]
+    [              [55  54  53]              ]
+    [              [          ]              ]
+    [     0        [45  44  43]       0      ]
+    [              [          ]              ]
+    [              [35  34  33]              ]
+    [                                        ]
+    [                            [0   1   2 ]]
+    [                            [          ]]
+    [     0             0        [10  11  12]]
+    [                            [          ]]
+    [                            [20  21  22]]
+
+    >>> P = P.as_explicit()
+    >>> B = B.as_explicit()
+    >>> P.T*B*P == A
+    True
+
+    Notes
+    =====
+
+    This problem corresponds to the finding of the connected components
+    of a graph, when a matrix is viewed as a weighted graph.
+    """
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.matrices.expressions.blockmatrix import BlockDiagMatrix
+    from sympy.matrices.expressions.permutation import PermutationMatrix
+
+    iblocks = M.connected_components()
+
+    p = Permutation(flatten(iblocks))
+    P = PermutationMatrix(p)
+
+    blocks = []
+    for b in iblocks:
+        blocks.append(M[b, b])
+    B = BlockDiagMatrix(*blocks)
+    return P, B
+
+
+def _strongly_connected_components_decomposition(M, lower=True):
+    """Decomposes a square matrix into block triangular form only
+    using the permutations.
+
+    Explanation
+    ===========
+
+    The decomposition is in a form of $A = P^{-1} B P$ where $P$ is a
+    permutation matrix and $B$ is a block diagonal matrix.
+
+    Parameters
+    ==========
+
+    lower : bool
+        Makes $B$ lower block triangular when ``True``.
+        Otherwise, makes $B$ upper block triangular.
+
+    Returns
+    =======
+
+    P, B : PermutationMatrix, BlockMatrix
+        *P* is a permutation matrix for the similarity transform
+        as in the explanation. And *B* is the block triangular matrix of
+        the result of the permutation.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, pprint
+    >>> A = Matrix([
+    ...     [44, 0, 0, 0, 43, 0, 45, 0, 0],
+    ...     [0, 66, 62, 61, 0, 68, 0, 60, 67],
+    ...     [0, 0, 22, 21, 0, 0, 0, 20, 0],
+    ...     [0, 0, 12, 11, 0, 0, 0, 10, 0],
+    ...     [34, 0, 0, 0, 33, 0, 35, 0, 0],
+    ...     [0, 86, 82, 81, 0, 88, 0, 80, 87],
+    ...     [54, 0, 0, 0, 53, 0, 55, 0, 0],
+    ...     [0, 0, 2, 1, 0, 0, 0, 0, 0],
+    ...     [0, 76, 72, 71, 0, 78, 0, 70, 77]])
+
+    A lower block triangular decomposition:
+
+    >>> P, B = A.strongly_connected_components_decomposition()
+    >>> pprint(P)
+    PermutationMatrix((8)(1 4 3 2 6)(5 7))
+    >>> pprint(B)
+    [[44  43  45]   [0  0  0]     [0  0  0]  ]
+    [[          ]   [       ]     [       ]  ]
+    [[34  33  35]   [0  0  0]     [0  0  0]  ]
+    [[          ]   [       ]     [       ]  ]
+    [[54  53  55]   [0  0  0]     [0  0  0]  ]
+    [                                        ]
+    [ [0  0  0]    [22  21  20]   [0  0  0]  ]
+    [ [       ]    [          ]   [       ]  ]
+    [ [0  0  0]    [12  11  10]   [0  0  0]  ]
+    [ [       ]    [          ]   [       ]  ]
+    [ [0  0  0]    [2   1   0 ]   [0  0  0]  ]
+    [                                        ]
+    [ [0  0  0]    [62  61  60]  [66  68  67]]
+    [ [       ]    [          ]  [          ]]
+    [ [0  0  0]    [82  81  80]  [86  88  87]]
+    [ [       ]    [          ]  [          ]]
+    [ [0  0  0]    [72  71  70]  [76  78  77]]
+
+    >>> P = P.as_explicit()
+    >>> B = B.as_explicit()
+    >>> P.T * B * P == A
+    True
+
+    An upper block triangular decomposition:
+
+    >>> P, B = A.strongly_connected_components_decomposition(lower=False)
+    >>> pprint(P)
+    PermutationMatrix((0 1 5 7 4 3 2 8 6))
+    >>> pprint(B)
+    [[66  68  67]  [62  61  60]   [0  0  0]  ]
+    [[          ]  [          ]   [       ]  ]
+    [[86  88  87]  [82  81  80]   [0  0  0]  ]
+    [[          ]  [          ]   [       ]  ]
+    [[76  78  77]  [72  71  70]   [0  0  0]  ]
+    [                                        ]
+    [ [0  0  0]    [22  21  20]   [0  0  0]  ]
+    [ [       ]    [          ]   [       ]  ]
+    [ [0  0  0]    [12  11  10]   [0  0  0]  ]
+    [ [       ]    [          ]   [       ]  ]
+    [ [0  0  0]    [2   1   0 ]   [0  0  0]  ]
+    [                                        ]
+    [ [0  0  0]     [0  0  0]    [44  43  45]]
+    [ [       ]     [       ]    [          ]]
+    [ [0  0  0]     [0  0  0]    [34  33  35]]
+    [ [       ]     [       ]    [          ]]
+    [ [0  0  0]     [0  0  0]    [54  53  55]]
+
+    >>> P = P.as_explicit()
+    >>> B = B.as_explicit()
+    >>> P.T * B * P == A
+    True
+    """
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.matrices.expressions.blockmatrix import BlockMatrix
+    from sympy.matrices.expressions.permutation import PermutationMatrix
+
+    iblocks = M.strongly_connected_components()
+    if not lower:
+        iblocks = list(reversed(iblocks))
+
+    p = Permutation(flatten(iblocks))
+    P = PermutationMatrix(p)
+
+    rows = []
+    for a in iblocks:
+        cols = []
+        for b in iblocks:
+            cols.append(M[a, b])
+        rows.append(cols)
+    B = BlockMatrix(rows)
+    return P, B

phi4/lib/python3.10/site-packages/sympy/matrices/immutable.py

@@ -0,0 +1,196 @@
+from mpmath.matrices.matrices import _matrix
+
+from sympy.core import Basic, Dict, Tuple
+from sympy.core.numbers import Integer
+from sympy.core.cache import cacheit
+from sympy.core.sympify import _sympy_converter as sympify_converter, _sympify
+from sympy.matrices.dense import DenseMatrix
+from sympy.matrices.expressions import MatrixExpr
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.matrices.repmatrix import RepMatrix
+from sympy.matrices.sparse import SparseRepMatrix
+from sympy.multipledispatch import dispatch
+
+
+def sympify_matrix(arg):
+    return arg.as_immutable()
+
+
+sympify_converter[MatrixBase] = sympify_matrix
+
+
+def sympify_mpmath_matrix(arg):
+    mat = [_sympify(x) for x in arg]
+    return ImmutableDenseMatrix(arg.rows, arg.cols, mat)
+
+
+sympify_converter[_matrix] = sympify_mpmath_matrix
+
+
+class ImmutableRepMatrix(RepMatrix, MatrixExpr): # type: ignore
+    """Immutable matrix based on RepMatrix
+
+    Uses DomainMAtrix as the internal representation.
+    """
+
+    #
+    # This is a subclass of RepMatrix that adds/overrides some methods to make
+    # the instances Basic and immutable. ImmutableRepMatrix is a superclass for
+    # both ImmutableDenseMatrix and ImmutableSparseMatrix.
+    #
+
+    def __new__(cls, *args, **kwargs):
+        return cls._new(*args, **kwargs)
+
+    __hash__ = MatrixExpr.__hash__
+
+    def copy(self):
+        return self
+
+    @property
+    def cols(self):
+        return self._cols
+
+    @property
+    def rows(self):
+        return self._rows
+
+    @property
+    def shape(self):
+        return self._rows, self._cols
+
+    def as_immutable(self):
+        return self
+
+    def _entry(self, i, j, **kwargs):
+        return self[i, j]
+
+    def __setitem__(self, *args):
+        raise TypeError("Cannot set values of {}".format(self.__class__))
+
+    def is_diagonalizable(self, reals_only=False, **kwargs):
+        return super().is_diagonalizable(
+            reals_only=reals_only, **kwargs)
+
+    is_diagonalizable.__doc__ = SparseRepMatrix.is_diagonalizable.__doc__
+    is_diagonalizable = cacheit(is_diagonalizable)
+
+    def analytic_func(self, f, x):
+        return self.as_mutable().analytic_func(f, x).as_immutable()
+
+
+class ImmutableDenseMatrix(DenseMatrix, ImmutableRepMatrix):  # type: ignore
+    """Create an immutable version of a matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import eye, ImmutableMatrix
+    >>> ImmutableMatrix(eye(3))
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> _[0, 0] = 42
+    Traceback (most recent call last):
+    ...
+    TypeError: Cannot set values of ImmutableDenseMatrix
+    """
+
+    # MatrixExpr is set as NotIterable, but we want explicit matrices to be
+    # iterable
+    _iterable = True
+    _class_priority = 8
+    _op_priority = 10.001
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        if len(args) == 1 and isinstance(args[0], ImmutableDenseMatrix):
+            return args[0]
+        if kwargs.get('copy', True) is False:
+            if len(args) != 3:
+                raise TypeError("'copy=False' requires a matrix be initialized as rows,cols,[list]")
+            rows, cols, flat_list = args
+        else:
+            rows, cols, flat_list = cls._handle_creation_inputs(*args, **kwargs)
+            flat_list = list(flat_list) # create a shallow copy
+
+        rep = cls._flat_list_to_DomainMatrix(rows, cols, flat_list)
+
+        return cls._fromrep(rep)
+
+    @classmethod
+    def _fromrep(cls, rep):
+        rows, cols = rep.shape
+        flat_list = rep.to_sympy().to_list_flat()
+        obj = Basic.__new__(cls,
+            Integer(rows),
+            Integer(cols),
+            Tuple(*flat_list, sympify=False))
+        obj._rows = rows
+        obj._cols = cols
+        obj._rep = rep
+        return obj
+
+
+# make sure ImmutableDenseMatrix is aliased as ImmutableMatrix
+ImmutableMatrix = ImmutableDenseMatrix
+
+
+class ImmutableSparseMatrix(SparseRepMatrix, ImmutableRepMatrix):  # type:ignore
+    """Create an immutable version of a sparse matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import eye, ImmutableSparseMatrix
+    >>> ImmutableSparseMatrix(1, 1, {})
+    Matrix([[0]])
+    >>> ImmutableSparseMatrix(eye(3))
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> _[0, 0] = 42
+    Traceback (most recent call last):
+    ...
+    TypeError: Cannot set values of ImmutableSparseMatrix
+    >>> _.shape
+    (3, 3)
+    """
+    is_Matrix = True
+    _class_priority = 9
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        rows, cols, smat = cls._handle_creation_inputs(*args, **kwargs)
+
+        rep = cls._smat_to_DomainMatrix(rows, cols, smat)
+
+        return cls._fromrep(rep)
+
+    @classmethod
+    def _fromrep(cls, rep):
+        rows, cols = rep.shape
+        smat = rep.to_sympy().to_dok()
+        obj = Basic.__new__(cls, Integer(rows), Integer(cols), Dict(smat))
+        obj._rows = rows
+        obj._cols = cols
+        obj._rep = rep
+        return obj
+
+
+@dispatch(ImmutableDenseMatrix, ImmutableDenseMatrix)
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    """Helper method for Equality with matrices.sympy.
+
+    Relational automatically converts matrices to ImmutableDenseMatrix
+    instances, so this method only applies here.  Returns True if the
+    matrices are definitively the same, False if they are definitively
+    different, and None if undetermined (e.g. if they contain Symbols).
+    Returning None triggers default handling of Equalities.
+
+    """
+    if lhs.shape != rhs.shape:
+        return False
+    return (lhs - rhs).is_zero_matrix

phi4/lib/python3.10/site-packages/sympy/matrices/inverse.py

@@ -0,0 +1,524 @@
+from sympy.polys.matrices.exceptions import DMNonInvertibleMatrixError
+from sympy.polys.domains import EX
+
+from .exceptions import MatrixError, NonSquareMatrixError, NonInvertibleMatrixError
+from .utilities import _iszero
+
+
+def _pinv_full_rank(M):
+    """Subroutine for full row or column rank matrices.
+
+    For full row rank matrices, inverse of ``A * A.H`` Exists.
+    For full column rank matrices, inverse of ``A.H * A`` Exists.
+
+    This routine can apply for both cases by checking the shape
+    and have small decision.
+    """
+
+    if M.is_zero_matrix:
+        return M.H
+
+    if M.rows >= M.cols:
+        return M.H.multiply(M).inv().multiply(M.H)
+    else:
+        return M.H.multiply(M.multiply(M.H).inv())
+
+def _pinv_rank_decomposition(M):
+    """Subroutine for rank decomposition
+
+    With rank decompositions, `A` can be decomposed into two full-
+    rank matrices, and each matrix can take pseudoinverse
+    individually.
+    """
+
+    if M.is_zero_matrix:
+        return M.H
+
+    B, C = M.rank_decomposition()
+
+    Bp = _pinv_full_rank(B)
+    Cp = _pinv_full_rank(C)
+
+    return Cp.multiply(Bp)
+
+def _pinv_diagonalization(M):
+    """Subroutine using diagonalization
+
+    This routine can sometimes fail if SymPy's eigenvalue
+    computation is not reliable.
+    """
+
+    if M.is_zero_matrix:
+        return M.H
+
+    A  = M
+    AH = M.H
+
+    try:
+        if M.rows >= M.cols:
+            P, D   = AH.multiply(A).diagonalize(normalize=True)
+            D_pinv = D.applyfunc(lambda x: 0 if _iszero(x) else 1 / x)
+
+            return P.multiply(D_pinv).multiply(P.H).multiply(AH)
+
+        else:
+            P, D   = A.multiply(AH).diagonalize(
+                        normalize=True)
+            D_pinv = D.applyfunc(lambda x: 0 if _iszero(x) else 1 / x)
+
+            return AH.multiply(P).multiply(D_pinv).multiply(P.H)
+
+    except MatrixError:
+        raise NotImplementedError(
+            'pinv for rank-deficient matrices where '
+            'diagonalization of A.H*A fails is not supported yet.')
+
+def _pinv(M, method='RD'):
+    """Calculate the Moore-Penrose pseudoinverse of the matrix.
+
+    The Moore-Penrose pseudoinverse exists and is unique for any matrix.
+    If the matrix is invertible, the pseudoinverse is the same as the
+    inverse.
+
+    Parameters
+    ==========
+
+    method : String, optional
+        Specifies the method for computing the pseudoinverse.
+
+        If ``'RD'``, Rank-Decomposition will be used.
+
+        If ``'ED'``, Diagonalization will be used.
+
+    Examples
+    ========
+
+    Computing pseudoinverse by rank decomposition :
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[1, 2, 3], [4, 5, 6]])
+    >>> A.pinv()
+    Matrix([
+    [-17/18,  4/9],
+    [  -1/9,  1/9],
+    [ 13/18, -2/9]])
+
+    Computing pseudoinverse by diagonalization :
+
+    >>> B = A.pinv(method='ED')
+    >>> B.simplify()
+    >>> B
+    Matrix([
+    [-17/18,  4/9],
+    [  -1/9,  1/9],
+    [ 13/18, -2/9]])
+
+    See Also
+    ========
+
+    inv
+    pinv_solve
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse
+
+    """
+
+    # Trivial case: pseudoinverse of all-zero matrix is its transpose.
+    if M.is_zero_matrix:
+        return M.H
+
+    if method == 'RD':
+        return _pinv_rank_decomposition(M)
+    elif method == 'ED':
+        return _pinv_diagonalization(M)
+    else:
+        raise ValueError('invalid pinv method %s' % repr(method))
+
+
+def _verify_invertible(M, iszerofunc=_iszero):
+    """Initial check to see if a matrix is invertible. Raises or returns
+    determinant for use in _inv_ADJ."""
+
+    if not M.is_square:
+        raise NonSquareMatrixError("A Matrix must be square to invert.")
+
+    d    = M.det(method='berkowitz')
+    zero = d.equals(0)
+
+    if zero is None: # if equals() can't decide, will rref be able to?
+        ok   = M.rref(simplify=True)[0]
+        zero = any(iszerofunc(ok[j, j]) for j in range(ok.rows))
+
+    if zero:
+        raise NonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+    return d
+
+def _inv_ADJ(M, iszerofunc=_iszero):
+    """Calculates the inverse using the adjugate matrix and a determinant.
+
+    See Also
+    ========
+
+    inv
+    inverse_GE
+    inverse_LU
+    inverse_CH
+    inverse_LDL
+    """
+
+    d = _verify_invertible(M, iszerofunc=iszerofunc)
+
+    return M.adjugate() / d
+
+def _inv_GE(M, iszerofunc=_iszero):
+    """Calculates the inverse using Gaussian elimination.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_LU
+    inverse_CH
+    inverse_LDL
+    """
+
+    from .dense import Matrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("A Matrix must be square to invert.")
+
+    big = Matrix.hstack(M.as_mutable(), Matrix.eye(M.rows))
+    red = big.rref(iszerofunc=iszerofunc, simplify=True)[0]
+
+    if any(iszerofunc(red[j, j]) for j in range(red.rows)):
+        raise NonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+    return M._new(red[:, big.rows:])
+
+def _inv_LU(M, iszerofunc=_iszero):
+    """Calculates the inverse using LU decomposition.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_GE
+    inverse_CH
+    inverse_LDL
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError("A Matrix must be square to invert.")
+    if M.free_symbols:
+        _verify_invertible(M, iszerofunc=iszerofunc)
+
+    return M.LUsolve(M.eye(M.rows), iszerofunc=_iszero)
+
+def _inv_CH(M, iszerofunc=_iszero):
+    """Calculates the inverse using cholesky decomposition.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_GE
+    inverse_LU
+    inverse_LDL
+    """
+
+    _verify_invertible(M, iszerofunc=iszerofunc)
+
+    return M.cholesky_solve(M.eye(M.rows))
+
+def _inv_LDL(M, iszerofunc=_iszero):
+    """Calculates the inverse using LDL decomposition.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_GE
+    inverse_LU
+    inverse_CH
+    """
+
+    _verify_invertible(M, iszerofunc=iszerofunc)
+
+    return M.LDLsolve(M.eye(M.rows))
+
+def _inv_QR(M, iszerofunc=_iszero):
+    """Calculates the inverse using QR decomposition.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_GE
+    inverse_CH
+    inverse_LDL
+    """
+
+    _verify_invertible(M, iszerofunc=iszerofunc)
+
+    return M.QRsolve(M.eye(M.rows))
+
+def _try_DM(M, use_EX=False):
+    """Try to convert a matrix to a ``DomainMatrix``."""
+    dM = M.to_DM()
+    K = dM.domain
+
+    # Return DomainMatrix if a domain is found. Only use EX if use_EX=True.
+    if not use_EX and K.is_EXRAW:
+        return None
+    elif K.is_EXRAW:
+        return dM.convert_to(EX)
+    else:
+        return dM
+
+
+def _use_exact_domain(dom):
+    """Check whether to convert to an exact domain."""
+    # DomainMatrix can handle RR and CC with partial pivoting. Other inexact
+    # domains like RR[a,b,...] can only be handled by converting to an exact
+    # domain like QQ[a,b,...]
+    if dom.is_RR or dom.is_CC:
+        return False
+    else:
+        return not dom.is_Exact
+
+
+def _inv_DM(dM, cancel=True):
+    """Calculates the inverse using ``DomainMatrix``.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_GE
+    inverse_CH
+    inverse_LDL
+    sympy.polys.matrices.domainmatrix.DomainMatrix.inv
+    """
+    m, n = dM.shape
+    dom = dM.domain
+
+    if m != n:
+        raise NonSquareMatrixError("A Matrix must be square to invert.")
+
+    # Convert RR[a,b,...] to QQ[a,b,...]
+    use_exact = _use_exact_domain(dom)
+
+    if use_exact:
+        dom_exact = dom.get_exact()
+        dM = dM.convert_to(dom_exact)
+
+    try:
+        dMi, den = dM.inv_den()
+    except DMNonInvertibleMatrixError:
+        raise NonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+    if use_exact:
+        dMi = dMi.convert_to(dom)
+        den = dom.convert_from(den, dom_exact)
+
+    if cancel:
+        # Convert to field and cancel with the denominator.
+        if not dMi.domain.is_Field:
+            dMi = dMi.to_field()
+        Mi = (dMi / den).to_Matrix()
+    else:
+        # Convert to Matrix and divide without cancelling
+        Mi = dMi.to_Matrix() / dMi.domain.to_sympy(den)
+
+    return Mi
+
+def _inv_block(M, iszerofunc=_iszero):
+    """Calculates the inverse using BLOCKWISE inversion.
+
+    See Also
+    ========
+
+    inv
+    inverse_ADJ
+    inverse_GE
+    inverse_CH
+    inverse_LDL
+    """
+    from sympy.matrices.expressions.blockmatrix import BlockMatrix
+    i = M.shape[0]
+    if i <= 20 :
+        return M.inv(method="LU", iszerofunc=_iszero)
+    A = M[:i // 2, :i //2]
+    B = M[:i // 2, i // 2:]
+    C = M[i // 2:, :i // 2]
+    D = M[i // 2:, i // 2:]
+    try:
+        D_inv = _inv_block(D)
+    except NonInvertibleMatrixError:
+        return M.inv(method="LU", iszerofunc=_iszero)
+    B_D_i = B*D_inv
+    BDC = B_D_i*C
+    A_n = A - BDC
+    try:
+        A_n = _inv_block(A_n)
+    except NonInvertibleMatrixError:
+        return M.inv(method="LU", iszerofunc=_iszero)
+    B_n = -A_n*B_D_i
+    dc = D_inv*C
+    C_n = -dc*A_n
+    D_n = D_inv + dc*-B_n
+    nn = BlockMatrix([[A_n, B_n], [C_n, D_n]]).as_explicit()
+    return nn
+
+def _inv(M, method=None, iszerofunc=_iszero, try_block_diag=False):
+    """
+    Return the inverse of a matrix using the method indicated. The default
+    is DM if a suitable domain is found or otherwise GE for dense matrices
+    LDL for sparse matrices.
+
+    Parameters
+    ==========
+
+    method : ('DM', 'DMNC', 'GE', 'LU', 'ADJ', 'CH', 'LDL', 'QR')
+
+    iszerofunc : function, optional
+        Zero-testing function to use.
+
+    try_block_diag : bool, optional
+        If True then will try to form block diagonal matrices using the
+        method get_diag_blocks(), invert these individually, and then
+        reconstruct the full inverse matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import SparseMatrix, Matrix
+    >>> A = SparseMatrix([
+    ... [ 2, -1,  0],
+    ... [-1,  2, -1],
+    ... [ 0,  0,  2]])
+    >>> A.inv('CH')
+    Matrix([
+    [2/3, 1/3, 1/6],
+    [1/3, 2/3, 1/3],
+    [  0,   0, 1/2]])
+    >>> A.inv(method='LDL') # use of 'method=' is optional
+    Matrix([
+    [2/3, 1/3, 1/6],
+    [1/3, 2/3, 1/3],
+    [  0,   0, 1/2]])
+    >>> A * _
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> A = Matrix(A)
+    >>> A.inv('CH')
+    Matrix([
+    [2/3, 1/3, 1/6],
+    [1/3, 2/3, 1/3],
+    [  0,   0, 1/2]])
+    >>> A.inv('ADJ') == A.inv('GE') == A.inv('LU') == A.inv('CH') == A.inv('LDL') == A.inv('QR')
+    True
+
+    Notes
+    =====
+
+    According to the ``method`` keyword, it calls the appropriate method:
+
+        DM .... Use DomainMatrix ``inv_den`` method
+        DMNC .... Use DomainMatrix ``inv_den`` method without cancellation
+        GE .... inverse_GE(); default for dense matrices
+        LU .... inverse_LU()
+        ADJ ... inverse_ADJ()
+        CH ... inverse_CH()
+        LDL ... inverse_LDL(); default for sparse matrices
+        QR ... inverse_QR()
+
+    Note, the GE and LU methods may require the matrix to be simplified
+    before it is inverted in order to properly detect zeros during
+    pivoting. In difficult cases a custom zero detection function can
+    be provided by setting the ``iszerofunc`` argument to a function that
+    should return True if its argument is zero. The ADJ routine computes
+    the determinant and uses that to detect singular matrices in addition
+    to testing for zeros on the diagonal.
+
+    See Also
+    ========
+
+    inverse_ADJ
+    inverse_GE
+    inverse_LU
+    inverse_CH
+    inverse_LDL
+
+    Raises
+    ======
+
+    ValueError
+        If the determinant of the matrix is zero.
+    """
+
+    from sympy.matrices import diag, SparseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("A Matrix must be square to invert.")
+
+    if try_block_diag:
+        blocks = M.get_diag_blocks()
+        r      = []
+
+        for block in blocks:
+            r.append(block.inv(method=method, iszerofunc=iszerofunc))
+
+        return diag(*r)
+
+    # Default: Use DomainMatrix if the domain is not EX.
+    # If DM is requested explicitly then use it even if the domain is EX.
+    if method is None and iszerofunc is _iszero:
+        dM = _try_DM(M, use_EX=False)
+        if dM is not None:
+            method = 'DM'
+    elif method in ("DM", "DMNC"):
+        dM = _try_DM(M, use_EX=True)
+
+    # A suitable domain was not found, fall back to GE for dense matrices
+    # and LDL for sparse matrices.
+    if method is None:
+        if isinstance(M, SparseMatrix):
+            method = 'LDL'
+        else:
+            method = 'GE'
+
+    if method == "DM":
+        rv = _inv_DM(dM)
+    elif method == "DMNC":
+        rv = _inv_DM(dM, cancel=False)
+    elif method == "GE":
+        rv = M.inverse_GE(iszerofunc=iszerofunc)
+    elif method == "LU":
+        rv = M.inverse_LU(iszerofunc=iszerofunc)
+    elif method == "ADJ":
+        rv = M.inverse_ADJ(iszerofunc=iszerofunc)
+    elif method == "CH":
+        rv = M.inverse_CH(iszerofunc=iszerofunc)
+    elif method == "LDL":
+        rv = M.inverse_LDL(iszerofunc=iszerofunc)
+    elif method == "QR":
+        rv = M.inverse_QR(iszerofunc=iszerofunc)
+    elif method == "BLOCK":
+        rv = M.inverse_BLOCK(iszerofunc=iszerofunc)
+    else:
+        raise ValueError("Inversion method unrecognized")
+
+    return M._new(rv)

phi4/lib/python3.10/site-packages/sympy/matrices/kind.py

@@ -0,0 +1,97 @@
+# sympy.matrices.kind
+
+from sympy.core.kind import Kind, _NumberKind, NumberKind
+from sympy.core.mul import Mul
+
+
+class MatrixKind(Kind):
+    """
+    Kind for all matrices in SymPy.
+
+    Basic class for this kind is ``MatrixBase`` and ``MatrixExpr``,
+    but any expression representing the matrix can have this.
+
+    Parameters
+    ==========
+
+    element_kind : Kind
+        Kind of the element. Default is
+        :class:`sympy.core.kind.NumberKind`,
+        which means that the matrix contains only numbers.
+
+    Examples
+    ========
+
+    Any instance of matrix class has kind ``MatrixKind``:
+
+    >>> from sympy import MatrixSymbol
+    >>> A = MatrixSymbol('A', 2, 2)
+    >>> A.kind
+    MatrixKind(NumberKind)
+
+    An expression representing a matrix may not be an instance of
+    the Matrix class, but it will have kind ``MatrixKind``:
+
+    >>> from sympy import MatrixExpr, Integral
+    >>> from sympy.abc import x
+    >>> intM = Integral(A, x)
+    >>> isinstance(intM, MatrixExpr)
+    False
+    >>> intM.kind
+    MatrixKind(NumberKind)
+
+    Use ``isinstance()`` to check for ``MatrixKind`` without specifying the
+    element kind. Use ``is`` to check the kind including the element kind:
+
+    >>> from sympy import Matrix
+    >>> from sympy.core import NumberKind
+    >>> from sympy.matrices import MatrixKind
+    >>> M = Matrix([1, 2])
+    >>> isinstance(M.kind, MatrixKind)
+    True
+    >>> M.kind is MatrixKind(NumberKind)
+    True
+
+    See Also
+    ========
+
+    sympy.core.kind.NumberKind
+    sympy.core.kind.UndefinedKind
+    sympy.core.containers.TupleKind
+    sympy.sets.sets.SetKind
+
+    """
+    def __new__(cls, element_kind=NumberKind):
+        obj = super().__new__(cls, element_kind)
+        obj.element_kind = element_kind
+        return obj
+
+    def __repr__(self):
+        return "MatrixKind(%s)" % self.element_kind
+
+
+@Mul._kind_dispatcher.register(_NumberKind, MatrixKind)
+def num_mat_mul(k1, k2):
+    """
+    Return MatrixKind. The element kind is selected by recursive dispatching.
+    Do not need to dispatch in reversed order because KindDispatcher
+    searches for this automatically.
+    """
+    # Deal with Mul._kind_dispatcher's commutativity
+    # XXX: this function is called with either k1 or k2 as MatrixKind because
+    # the Mul kind dispatcher is commutative. Maybe it shouldn't be. Need to
+    # swap the args here because NumberKind does not have an element_kind
+    # attribute.
+    if not isinstance(k2, MatrixKind):
+        k1, k2 = k2, k1
+    elemk = Mul._kind_dispatcher(k1, k2.element_kind)
+    return MatrixKind(elemk)
+
+
+@Mul._kind_dispatcher.register(MatrixKind, MatrixKind)
+def mat_mat_mul(k1, k2):
+    """
+    Return MatrixKind. The element kind is selected by recursive dispatching.
+    """
+    elemk = Mul._kind_dispatcher(k1.element_kind, k2.element_kind)
+    return MatrixKind(elemk)

phi4/lib/python3.10/site-packages/sympy/matrices/matrices.py

@@ -0,0 +1,687 @@
+#
+# A module consisting of deprecated matrix classes. New code should not be
+# added here.
+#
+from sympy.core.basic import Basic
+from sympy.core.symbol import Dummy
+
+from .common import MatrixCommon
+
+from .exceptions import NonSquareMatrixError
+
+from .utilities import _iszero, _is_zero_after_expand_mul, _simplify
+
+from .determinant import (
+    _find_reasonable_pivot, _find_reasonable_pivot_naive,
+    _adjugate, _charpoly, _cofactor, _cofactor_matrix, _per,
+    _det, _det_bareiss, _det_berkowitz, _det_bird, _det_laplace, _det_LU,
+    _minor, _minor_submatrix)
+
+from .reductions import _is_echelon, _echelon_form, _rank, _rref
+from .subspaces import _columnspace, _nullspace, _rowspace, _orthogonalize
+
+from .eigen import (
+    _eigenvals, _eigenvects,
+    _bidiagonalize, _bidiagonal_decomposition,
+    _is_diagonalizable, _diagonalize,
+    _is_positive_definite, _is_positive_semidefinite,
+    _is_negative_definite, _is_negative_semidefinite, _is_indefinite,
+    _jordan_form, _left_eigenvects, _singular_values)
+
+
+# This class was previously defined in this module, but was moved to
+# sympy.matrices.matrixbase. We import it here for backwards compatibility in
+# case someone was importing it from here.
+from .matrixbase import MatrixBase
+
+
+__doctest_requires__ = {
+    ('MatrixEigen.is_indefinite',
+     'MatrixEigen.is_negative_definite',
+     'MatrixEigen.is_negative_semidefinite',
+     'MatrixEigen.is_positive_definite',
+     'MatrixEigen.is_positive_semidefinite'): ['matplotlib'],
+}
+
+
+class MatrixDeterminant(MatrixCommon):
+    """Provides basic matrix determinant operations. Should not be instantiated
+    directly. See ``determinant.py`` for their implementations."""
+
+    def _eval_det_bareiss(self, iszerofunc=_is_zero_after_expand_mul):
+        return _det_bareiss(self, iszerofunc=iszerofunc)
+
+    def _eval_det_berkowitz(self):
+        return _det_berkowitz(self)
+
+    def _eval_det_lu(self, iszerofunc=_iszero, simpfunc=None):
+        return _det_LU(self, iszerofunc=iszerofunc, simpfunc=simpfunc)
+
+    def _eval_det_bird(self):
+        return _det_bird(self)
+
+    def _eval_det_laplace(self):
+        return _det_laplace(self)
+
+    def _eval_determinant(self): # for expressions.determinant.Determinant
+        return _det(self)
+
+    def adjugate(self, method="berkowitz"):
+        return _adjugate(self, method=method)
+
+    def charpoly(self, x='lambda', simplify=_simplify):
+        return _charpoly(self, x=x, simplify=simplify)
+
+    def cofactor(self, i, j, method="berkowitz"):
+        return _cofactor(self, i, j, method=method)
+
+    def cofactor_matrix(self, method="berkowitz"):
+        return _cofactor_matrix(self, method=method)
+
+    def det(self, method="bareiss", iszerofunc=None):
+        return _det(self, method=method, iszerofunc=iszerofunc)
+
+    def per(self):
+        return _per(self)
+
+    def minor(self, i, j, method="berkowitz"):
+        return _minor(self, i, j, method=method)
+
+    def minor_submatrix(self, i, j):
+        return _minor_submatrix(self, i, j)
+
+    _find_reasonable_pivot.__doc__       = _find_reasonable_pivot.__doc__
+    _find_reasonable_pivot_naive.__doc__ = _find_reasonable_pivot_naive.__doc__
+    _eval_det_bareiss.__doc__            = _det_bareiss.__doc__
+    _eval_det_berkowitz.__doc__          = _det_berkowitz.__doc__
+    _eval_det_bird.__doc__            = _det_bird.__doc__
+    _eval_det_laplace.__doc__            = _det_laplace.__doc__
+    _eval_det_lu.__doc__                 = _det_LU.__doc__
+    _eval_determinant.__doc__            = _det.__doc__
+    adjugate.__doc__                     = _adjugate.__doc__
+    charpoly.__doc__                     = _charpoly.__doc__
+    cofactor.__doc__                     = _cofactor.__doc__
+    cofactor_matrix.__doc__              = _cofactor_matrix.__doc__
+    det.__doc__                          = _det.__doc__
+    per.__doc__                          = _per.__doc__
+    minor.__doc__                        = _minor.__doc__
+    minor_submatrix.__doc__              = _minor_submatrix.__doc__
+
+
+class MatrixReductions(MatrixDeterminant):
+    """Provides basic matrix row/column operations. Should not be instantiated
+    directly. See ``reductions.py`` for some of their implementations."""
+
+    def echelon_form(self, iszerofunc=_iszero, simplify=False, with_pivots=False):
+        return _echelon_form(self, iszerofunc=iszerofunc, simplify=simplify,
+                with_pivots=with_pivots)
+
+    @property
+    def is_echelon(self):
+        return _is_echelon(self)
+
+    def rank(self, iszerofunc=_iszero, simplify=False):
+        return _rank(self, iszerofunc=iszerofunc, simplify=simplify)
+
+    def rref_rhs(self, rhs):
+        """Return reduced row-echelon form of matrix, matrix showing
+        rhs after reduction steps. ``rhs`` must have the same number
+        of rows as ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, symbols
+        >>> r1, r2 = symbols('r1 r2')
+        >>> Matrix([[1, 1], [2, 1]]).rref_rhs(Matrix([r1, r2]))
+        (Matrix([
+        [1, 0],
+        [0, 1]]), Matrix([
+        [ -r1 + r2],
+        [2*r1 - r2]]))
+        """
+        r, _ = _rref(self.hstack(self, self.eye(self.rows), rhs))
+        return r[:, :self.cols], r[:, -rhs.cols:]
+
+    def rref(self, iszerofunc=_iszero, simplify=False, pivots=True,
+            normalize_last=True):
+        return _rref(self, iszerofunc=iszerofunc, simplify=simplify,
+            pivots=pivots, normalize_last=normalize_last)
+
+    echelon_form.__doc__ = _echelon_form.__doc__
+    is_echelon.__doc__   = _is_echelon.__doc__
+    rank.__doc__         = _rank.__doc__
+    rref.__doc__         = _rref.__doc__
+
+    def _normalize_op_args(self, op, col, k, col1, col2, error_str="col"):
+        """Validate the arguments for a row/column operation.  ``error_str``
+        can be one of "row" or "col" depending on the arguments being parsed."""
+        if op not in ["n->kn", "n<->m", "n->n+km"]:
+            raise ValueError("Unknown {} operation '{}'. Valid col operations "
+                             "are 'n->kn', 'n<->m', 'n->n+km'".format(error_str, op))
+
+        # define self_col according to error_str
+        self_cols = self.cols if error_str == 'col' else self.rows
+
+        # normalize and validate the arguments
+        if op == "n->kn":
+            col = col if col is not None else col1
+            if col is None or k is None:
+                raise ValueError("For a {0} operation 'n->kn' you must provide the "
+                                 "kwargs `{0}` and `k`".format(error_str))
+            if not 0 <= col < self_cols:
+                raise ValueError("This matrix does not have a {} '{}'".format(error_str, col))
+
+        elif op == "n<->m":
+            # we need two cols to swap. It does not matter
+            # how they were specified, so gather them together and
+            # remove `None`
+            cols = {col, k, col1, col2}.difference([None])
+            if len(cols) > 2:
+                # maybe the user left `k` by mistake?
+                cols = {col, col1, col2}.difference([None])
+            if len(cols) != 2:
+                raise ValueError("For a {0} operation 'n<->m' you must provide the "
+                                 "kwargs `{0}1` and `{0}2`".format(error_str))
+            col1, col2 = cols
+            if not 0 <= col1 < self_cols:
+                raise ValueError("This matrix does not have a {} '{}'".format(error_str, col1))
+            if not 0 <= col2 < self_cols:
+                raise ValueError("This matrix does not have a {} '{}'".format(error_str, col2))
+
+        elif op == "n->n+km":
+            col = col1 if col is None else col
+            col2 = col1 if col2 is None else col2
+            if col is None or col2 is None or k is None:
+                raise ValueError("For a {0} operation 'n->n+km' you must provide the "
+                                 "kwargs `{0}`, `k`, and `{0}2`".format(error_str))
+            if col == col2:
+                raise ValueError("For a {0} operation 'n->n+km' `{0}` and `{0}2` must "
+                                 "be different.".format(error_str))
+            if not 0 <= col < self_cols:
+                raise ValueError("This matrix does not have a {} '{}'".format(error_str, col))
+            if not 0 <= col2 < self_cols:
+                raise ValueError("This matrix does not have a {} '{}'".format(error_str, col2))
+
+        else:
+            raise ValueError('invalid operation %s' % repr(op))
+
+        return op, col, k, col1, col2
+
+    def _eval_col_op_multiply_col_by_const(self, col, k):
+        def entry(i, j):
+            if j == col:
+                return k * self[i, j]
+            return self[i, j]
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_col_op_swap(self, col1, col2):
+        def entry(i, j):
+            if j == col1:
+                return self[i, col2]
+            elif j == col2:
+                return self[i, col1]
+            return self[i, j]
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_col_op_add_multiple_to_other_col(self, col, k, col2):
+        def entry(i, j):
+            if j == col:
+                return self[i, j] + k * self[i, col2]
+            return self[i, j]
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_row_op_swap(self, row1, row2):
+        def entry(i, j):
+            if i == row1:
+                return self[row2, j]
+            elif i == row2:
+                return self[row1, j]
+            return self[i, j]
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_row_op_multiply_row_by_const(self, row, k):
+        def entry(i, j):
+            if i == row:
+                return k * self[i, j]
+            return self[i, j]
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_row_op_add_multiple_to_other_row(self, row, k, row2):
+        def entry(i, j):
+            if i == row:
+                return self[i, j] + k * self[row2, j]
+            return self[i, j]
+        return self._new(self.rows, self.cols, entry)
+
+    def elementary_col_op(self, op="n->kn", col=None, k=None, col1=None, col2=None):
+        """Performs the elementary column operation `op`.
+
+        `op` may be one of
+
+            * ``"n->kn"`` (column n goes to k*n)
+            * ``"n<->m"`` (swap column n and column m)
+            * ``"n->n+km"`` (column n goes to column n + k*column m)
+
+        Parameters
+        ==========
+
+        op : string; the elementary row operation
+        col : the column to apply the column operation
+        k : the multiple to apply in the column operation
+        col1 : one column of a column swap
+        col2 : second column of a column swap or column "m" in the column operation
+               "n->n+km"
+        """
+
+        op, col, k, col1, col2 = self._normalize_op_args(op, col, k, col1, col2, "col")
+
+        # now that we've validated, we're all good to dispatch
+        if op == "n->kn":
+            return self._eval_col_op_multiply_col_by_const(col, k)
+        if op == "n<->m":
+            return self._eval_col_op_swap(col1, col2)
+        if op == "n->n+km":
+            return self._eval_col_op_add_multiple_to_other_col(col, k, col2)
+
+    def elementary_row_op(self, op="n->kn", row=None, k=None, row1=None, row2=None):
+        """Performs the elementary row operation `op`.
+
+        `op` may be one of
+
+            * ``"n->kn"`` (row n goes to k*n)
+            * ``"n<->m"`` (swap row n and row m)
+            * ``"n->n+km"`` (row n goes to row n + k*row m)
+
+        Parameters
+        ==========
+
+        op : string; the elementary row operation
+        row : the row to apply the row operation
+        k : the multiple to apply in the row operation
+        row1 : one row of a row swap
+        row2 : second row of a row swap or row "m" in the row operation
+               "n->n+km"
+        """
+
+        op, row, k, row1, row2 = self._normalize_op_args(op, row, k, row1, row2, "row")
+
+        # now that we've validated, we're all good to dispatch
+        if op == "n->kn":
+            return self._eval_row_op_multiply_row_by_const(row, k)
+        if op == "n<->m":
+            return self._eval_row_op_swap(row1, row2)
+        if op == "n->n+km":
+            return self._eval_row_op_add_multiple_to_other_row(row, k, row2)
+
+
+class MatrixSubspaces(MatrixReductions):
+    """Provides methods relating to the fundamental subspaces of a matrix.
+    Should not be instantiated directly. See ``subspaces.py`` for their
+    implementations."""
+
+    def columnspace(self, simplify=False):
+        return _columnspace(self, simplify=simplify)
+
+    def nullspace(self, simplify=False, iszerofunc=_iszero):
+        return _nullspace(self, simplify=simplify, iszerofunc=iszerofunc)
+
+    def rowspace(self, simplify=False):
+        return _rowspace(self, simplify=simplify)
+
+    # This is a classmethod but is converted to such later in order to allow
+    # assignment of __doc__ since that does not work for already wrapped
+    # classmethods in Python 3.6.
+    def orthogonalize(cls, *vecs, **kwargs):
+        return _orthogonalize(cls, *vecs, **kwargs)
+
+    columnspace.__doc__   = _columnspace.__doc__
+    nullspace.__doc__     = _nullspace.__doc__
+    rowspace.__doc__      = _rowspace.__doc__
+    orthogonalize.__doc__ = _orthogonalize.__doc__
+
+    orthogonalize         = classmethod(orthogonalize)  # type:ignore
+
+
+class MatrixEigen(MatrixSubspaces):
+    """Provides basic matrix eigenvalue/vector operations.
+    Should not be instantiated directly. See ``eigen.py`` for their
+    implementations."""
+
+    def eigenvals(self, error_when_incomplete=True, **flags):
+        return _eigenvals(self, error_when_incomplete=error_when_incomplete, **flags)
+
+    def eigenvects(self, error_when_incomplete=True, iszerofunc=_iszero, **flags):
+        return _eigenvects(self, error_when_incomplete=error_when_incomplete,
+                iszerofunc=iszerofunc, **flags)
+
+    def is_diagonalizable(self, reals_only=False, **kwargs):
+        return _is_diagonalizable(self, reals_only=reals_only, **kwargs)
+
+    def diagonalize(self, reals_only=False, sort=False, normalize=False):
+        return _diagonalize(self, reals_only=reals_only, sort=sort,
+                normalize=normalize)
+
+    def bidiagonalize(self, upper=True):
+        return _bidiagonalize(self, upper=upper)
+
+    def bidiagonal_decomposition(self, upper=True):
+        return _bidiagonal_decomposition(self, upper=upper)
+
+    @property
+    def is_positive_definite(self):
+        return _is_positive_definite(self)
+
+    @property
+    def is_positive_semidefinite(self):
+        return _is_positive_semidefinite(self)
+
+    @property
+    def is_negative_definite(self):
+        return _is_negative_definite(self)
+
+    @property
+    def is_negative_semidefinite(self):
+        return _is_negative_semidefinite(self)
+
+    @property
+    def is_indefinite(self):
+        return _is_indefinite(self)
+
+    def jordan_form(self, calc_transform=True, **kwargs):
+        return _jordan_form(self, calc_transform=calc_transform, **kwargs)
+
+    def left_eigenvects(self, **flags):
+        return _left_eigenvects(self, **flags)
+
+    def singular_values(self):
+        return _singular_values(self)
+
+    eigenvals.__doc__                  = _eigenvals.__doc__
+    eigenvects.__doc__                 = _eigenvects.__doc__
+    is_diagonalizable.__doc__          = _is_diagonalizable.__doc__
+    diagonalize.__doc__                = _diagonalize.__doc__
+    is_positive_definite.__doc__       = _is_positive_definite.__doc__
+    is_positive_semidefinite.__doc__   = _is_positive_semidefinite.__doc__
+    is_negative_definite.__doc__       = _is_negative_definite.__doc__
+    is_negative_semidefinite.__doc__   = _is_negative_semidefinite.__doc__
+    is_indefinite.__doc__              = _is_indefinite.__doc__
+    jordan_form.__doc__                = _jordan_form.__doc__
+    left_eigenvects.__doc__            = _left_eigenvects.__doc__
+    singular_values.__doc__            = _singular_values.__doc__
+    bidiagonalize.__doc__              = _bidiagonalize.__doc__
+    bidiagonal_decomposition.__doc__   = _bidiagonal_decomposition.__doc__
+
+
+class MatrixCalculus(MatrixCommon):
+    """Provides calculus-related matrix operations."""
+
+    def diff(self, *args, evaluate=True, **kwargs):
+        """Calculate the derivative of each element in the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y
+        >>> M = Matrix([[x, y], [1, 0]])
+        >>> M.diff(x)
+        Matrix([
+        [1, 0],
+        [0, 0]])
+
+        See Also
+        ========
+
+        integrate
+        limit
+        """
+        # XXX this should be handled here rather than in Derivative
+        from sympy.tensor.array.array_derivatives import ArrayDerivative
+        deriv = ArrayDerivative(self, *args, evaluate=evaluate)
+        # XXX This can rather changed to always return immutable matrix
+        if not isinstance(self, Basic) and evaluate:
+            return deriv.as_mutable()
+        return deriv
+
+    def _eval_derivative(self, arg):
+        return self.applyfunc(lambda x: x.diff(arg))
+
+    def integrate(self, *args, **kwargs):
+        """Integrate each element of the matrix.  ``args`` will
+        be passed to the ``integrate`` function.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y
+        >>> M = Matrix([[x, y], [1, 0]])
+        >>> M.integrate((x, ))
+        Matrix([
+        [x**2/2, x*y],
+        [     x,   0]])
+        >>> M.integrate((x, 0, 2))
+        Matrix([
+        [2, 2*y],
+        [2,   0]])
+
+        See Also
+        ========
+
+        limit
+        diff
+        """
+        return self.applyfunc(lambda x: x.integrate(*args, **kwargs))
+
+    def jacobian(self, X):
+        """Calculates the Jacobian matrix (derivative of a vector-valued function).
+
+        Parameters
+        ==========
+
+        ``self`` : vector of expressions representing functions f_i(x_1, ..., x_n).
+        X : set of x_i's in order, it can be a list or a Matrix
+
+        Both ``self`` and X can be a row or a column matrix in any order
+        (i.e., jacobian() should always work).
+
+        Examples
+        ========
+
+        >>> from sympy import sin, cos, Matrix
+        >>> from sympy.abc import rho, phi
+        >>> X = Matrix([rho*cos(phi), rho*sin(phi), rho**2])
+        >>> Y = Matrix([rho, phi])
+        >>> X.jacobian(Y)
+        Matrix([
+        [cos(phi), -rho*sin(phi)],
+        [sin(phi),  rho*cos(phi)],
+        [   2*rho,             0]])
+        >>> X = Matrix([rho*cos(phi), rho*sin(phi)])
+        >>> X.jacobian(Y)
+        Matrix([
+        [cos(phi), -rho*sin(phi)],
+        [sin(phi),  rho*cos(phi)]])
+
+        See Also
+        ========
+
+        hessian
+        wronskian
+        """
+        if not isinstance(X, MatrixBase):
+            X = self._new(X)
+        # Both X and ``self`` can be a row or a column matrix, so we need to make
+        # sure all valid combinations work, but everything else fails:
+        if self.shape[0] == 1:
+            m = self.shape[1]
+        elif self.shape[1] == 1:
+            m = self.shape[0]
+        else:
+            raise TypeError("``self`` must be a row or a column matrix")
+        if X.shape[0] == 1:
+            n = X.shape[1]
+        elif X.shape[1] == 1:
+            n = X.shape[0]
+        else:
+            raise TypeError("X must be a row or a column matrix")
+
+        # m is the number of functions and n is the number of variables
+        # computing the Jacobian is now easy:
+        return self._new(m, n, lambda j, i: self[j].diff(X[i]))
+
+    def limit(self, *args):
+        """Calculate the limit of each element in the matrix.
+        ``args`` will be passed to the ``limit`` function.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y
+        >>> M = Matrix([[x, y], [1, 0]])
+        >>> M.limit(x, 2)
+        Matrix([
+        [2, y],
+        [1, 0]])
+
+        See Also
+        ========
+
+        integrate
+        diff
+        """
+        return self.applyfunc(lambda x: x.limit(*args))
+
+
+# https://github.com/sympy/sympy/pull/12854
+class MatrixDeprecated(MatrixCommon):
+    """A class to house deprecated matrix methods."""
+    def berkowitz_charpoly(self, x=Dummy('lambda'), simplify=_simplify):
+        return self.charpoly(x=x)
+
+    def berkowitz_det(self):
+        """Computes determinant using Berkowitz method.
+
+        See Also
+        ========
+
+        det
+        berkowitz
+        """
+        return self.det(method='berkowitz')
+
+    def berkowitz_eigenvals(self, **flags):
+        """Computes eigenvalues of a Matrix using Berkowitz method.
+
+        See Also
+        ========
+
+        berkowitz
+        """
+        return self.eigenvals(**flags)
+
+    def berkowitz_minors(self):
+        """Computes principal minors using Berkowitz method.
+
+        See Also
+        ========
+
+        berkowitz
+        """
+        sign, minors = self.one, []
+
+        for poly in self.berkowitz():
+            minors.append(sign * poly[-1])
+            sign = -sign
+
+        return tuple(minors)
+
+    def berkowitz(self):
+        from sympy.matrices import zeros
+        berk = ((1,),)
+        if not self:
+            return berk
+
+        if not self.is_square:
+            raise NonSquareMatrixError()
+
+        A, N = self, self.rows
+        transforms = [0] * (N - 1)
+
+        for n in range(N, 1, -1):
+            T, k = zeros(n + 1, n), n - 1
+
+            R, C = -A[k, :k], A[:k, k]
+            A, a = A[:k, :k], -A[k, k]
+
+            items = [C]
+
+            for i in range(0, n - 2):
+                items.append(A * items[i])
+
+            for i, B in enumerate(items):
+                items[i] = (R * B)[0, 0]
+
+            items = [self.one, a] + items
+
+            for i in range(n):
+                T[i:, i] = items[:n - i + 1]
+
+            transforms[k - 1] = T
+
+        polys = [self._new([self.one, -A[0, 0]])]
+
+        for i, T in enumerate(transforms):
+            polys.append(T * polys[i])
+
+        return berk + tuple(map(tuple, polys))
+
+    def cofactorMatrix(self, method="berkowitz"):
+        return self.cofactor_matrix(method=method)
+
+    def det_bareis(self):
+        return _det_bareiss(self)
+
+    def det_LU_decomposition(self):
+        """Compute matrix determinant using LU decomposition.
+
+
+        Note that this method fails if the LU decomposition itself
+        fails. In particular, if the matrix has no inverse this method
+        will fail.
+
+        TODO: Implement algorithm for sparse matrices (SFF),
+        https://www.eecis.udel.edu/~saunders/papers/sffge/it5.ps
+
+        See Also
+        ========
+
+
+        det
+        det_bareiss
+        berkowitz_det
+        """
+        return self.det(method='lu')
+
+    def jordan_cell(self, eigenval, n):
+        return self.jordan_block(size=n, eigenvalue=eigenval)
+
+    def jordan_cells(self, calc_transformation=True):
+        P, J = self.jordan_form()
+        return P, J.get_diag_blocks()
+
+    def minorEntry(self, i, j, method="berkowitz"):
+        return self.minor(i, j, method=method)
+
+    def minorMatrix(self, i, j):
+        return self.minor_submatrix(i, j)
+
+    def permuteBkwd(self, perm):
+        """Permute the rows of the matrix with the given permutation in reverse."""
+        return self.permute_rows(perm, direction='backward')
+
+    def permuteFwd(self, perm):
+        """Permute the rows of the matrix with the given permutation."""
+        return self.permute_rows(perm, direction='forward')

phi4/lib/python3.10/site-packages/sympy/matrices/normalforms.py

@@ -0,0 +1,127 @@
+'''Functions returning normal forms of matrices'''
+
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.matrices import DomainMatrix
+from sympy.polys.matrices.normalforms import (
+        smith_normal_form as _snf,
+        invariant_factors as _invf,
+        hermite_normal_form as _hnf,
+    )
+
+
+def _to_domain(m, domain=None):
+    """Convert Matrix to DomainMatrix"""
+    # XXX: deprecated support for RawMatrix:
+    ring = getattr(m, "ring", None)
+    m = m.applyfunc(lambda e: e.as_expr() if isinstance(e, Poly) else e)
+
+    dM = DomainMatrix.from_Matrix(m)
+
+    domain = domain or ring
+    if domain is not None:
+        dM = dM.convert_to(domain)
+    return dM
+
+
+def smith_normal_form(m, domain=None):
+    '''
+    Return the Smith Normal Form of a matrix `m` over the ring `domain`.
+    This will only work if the ring is a principal ideal domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, ZZ
+    >>> from sympy.matrices.normalforms import smith_normal_form
+    >>> m = Matrix([[12, 6, 4], [3, 9, 6], [2, 16, 14]])
+    >>> print(smith_normal_form(m, domain=ZZ))
+    Matrix([[1, 0, 0], [0, 10, 0], [0, 0, -30]])
+
+    '''
+    dM = _to_domain(m, domain)
+    return _snf(dM).to_Matrix()
+
+
+def invariant_factors(m, domain=None):
+    '''
+    Return the tuple of abelian invariants for a matrix `m`
+    (as in the Smith-Normal form)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Smith_normal_form#Algorithm
+    .. [2] https://web.archive.org/web/20200331143852/https://sierra.nmsu.edu/morandi/notes/SmithNormalForm.pdf
+
+    '''
+    dM = _to_domain(m, domain)
+    factors = _invf(dM)
+    factors = tuple(dM.domain.to_sympy(f) for f in factors)
+    # XXX: deprecated.
+    if hasattr(m, "ring"):
+        if m.ring.is_PolynomialRing:
+            K = m.ring
+            to_poly = lambda f: Poly(f, K.symbols, domain=K.domain)
+            factors = tuple(to_poly(f) for f in factors)
+    return factors
+
+
+def hermite_normal_form(A, *, D=None, check_rank=False):
+    r"""
+    Compute the Hermite Normal Form of a Matrix *A* of integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.matrices.normalforms import hermite_normal_form
+    >>> m = Matrix([[12, 6, 4], [3, 9, 6], [2, 16, 14]])
+    >>> print(hermite_normal_form(m))
+    Matrix([[10, 0, 2], [0, 15, 3], [0, 0, 2]])
+
+    Parameters
+    ==========
+
+    A : $m \times n$ ``Matrix`` of integers.
+
+    D : int, optional
+        Let $W$ be the HNF of *A*. If known in advance, a positive integer *D*
+        being any multiple of $\det(W)$ may be provided. In this case, if *A*
+        also has rank $m$, then we may use an alternative algorithm that works
+        mod *D* in order to prevent coefficient explosion.
+
+    check_rank : boolean, optional (default=False)
+        The basic assumption is that, if you pass a value for *D*, then
+        you already believe that *A* has rank $m$, so we do not waste time
+        checking it for you. If you do want this to be checked (and the
+        ordinary, non-modulo *D* algorithm to be used if the check fails), then
+        set *check_rank* to ``True``.
+
+    Returns
+    =======
+
+    ``Matrix``
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`.
+
+    DMShapeError
+        If the mod *D* algorithm is used but the matrix has more rows than
+        columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithms 2.4.5 and 2.4.8.)
+
+    """
+    # Accept any of Python int, SymPy Integer, and ZZ itself:
+    if D is not None and not ZZ.of_type(D):
+        D = ZZ(int(D))
+    return _hnf(A._rep, D=D, check_rank=check_rank).to_Matrix()

phi4/lib/python3.10/site-packages/sympy/matrices/reductions.py

@@ -0,0 +1,387 @@
+from types import FunctionType
+
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.domains import ZZ, QQ
+
+from .utilities import _get_intermediate_simp, _iszero, _dotprodsimp, _simplify
+from .determinant import _find_reasonable_pivot
+
+
+def _row_reduce_list(mat, rows, cols, one, iszerofunc, simpfunc,
+                normalize_last=True, normalize=True, zero_above=True):
+    """Row reduce a flat list representation of a matrix and return a tuple
+    (rref_matrix, pivot_cols, swaps) where ``rref_matrix`` is a flat list,
+    ``pivot_cols`` are the pivot columns and ``swaps`` are any row swaps that
+    were used in the process of row reduction.
+
+    Parameters
+    ==========
+
+    mat : list
+        list of matrix elements, must be ``rows`` * ``cols`` in length
+
+    rows, cols : integer
+        number of rows and columns in flat list representation
+
+    one : SymPy object
+        represents the value one, from ``Matrix.one``
+
+    iszerofunc : determines if an entry can be used as a pivot
+
+    simpfunc : used to simplify elements and test if they are
+        zero if ``iszerofunc`` returns `None`
+
+    normalize_last : indicates where all row reduction should
+        happen in a fraction-free manner and then the rows are
+        normalized (so that the pivots are 1), or whether
+        rows should be normalized along the way (like the naive
+        row reduction algorithm)
+
+    normalize : whether pivot rows should be normalized so that
+        the pivot value is 1
+
+    zero_above : whether entries above the pivot should be zeroed.
+        If ``zero_above=False``, an echelon matrix will be returned.
+    """
+
+    def get_col(i):
+        return mat[i::cols]
+
+    def row_swap(i, j):
+        mat[i*cols:(i + 1)*cols], mat[j*cols:(j + 1)*cols] = \
+            mat[j*cols:(j + 1)*cols], mat[i*cols:(i + 1)*cols]
+
+    def cross_cancel(a, i, b, j):
+        """Does the row op row[i] = a*row[i] - b*row[j]"""
+        q = (j - i)*cols
+        for p in range(i*cols, (i + 1)*cols):
+            mat[p] = isimp(a*mat[p] - b*mat[p + q])
+
+    isimp = _get_intermediate_simp(_dotprodsimp)
+    piv_row, piv_col = 0, 0
+    pivot_cols = []
+    swaps = []
+
+    # use a fraction free method to zero above and below each pivot
+    while piv_col < cols and piv_row < rows:
+        pivot_offset, pivot_val, \
+        assumed_nonzero, newly_determined = _find_reasonable_pivot(
+                get_col(piv_col)[piv_row:], iszerofunc, simpfunc)
+
+        # _find_reasonable_pivot may have simplified some things
+        # in the process.  Let's not let them go to waste
+        for (offset, val) in newly_determined:
+            offset += piv_row
+            mat[offset*cols + piv_col] = val
+
+        if pivot_offset is None:
+            piv_col += 1
+            continue
+
+        pivot_cols.append(piv_col)
+        if pivot_offset != 0:
+            row_swap(piv_row, pivot_offset + piv_row)
+            swaps.append((piv_row, pivot_offset + piv_row))
+
+        # if we aren't normalizing last, we normalize
+        # before we zero the other rows
+        if normalize_last is False:
+            i, j = piv_row, piv_col
+            mat[i*cols + j] = one
+            for p in range(i*cols + j + 1, (i + 1)*cols):
+                mat[p] = isimp(mat[p] / pivot_val)
+            # after normalizing, the pivot value is 1
+            pivot_val = one
+
+        # zero above and below the pivot
+        for row in range(rows):
+            # don't zero our current row
+            if row == piv_row:
+                continue
+            # don't zero above the pivot unless we're told.
+            if zero_above is False and row < piv_row:
+                continue
+            # if we're already a zero, don't do anything
+            val = mat[row*cols + piv_col]
+            if iszerofunc(val):
+                continue
+
+            cross_cancel(pivot_val, row, val, piv_row)
+        piv_row += 1
+
+    # normalize each row
+    if normalize_last is True and normalize is True:
+        for piv_i, piv_j in enumerate(pivot_cols):
+            pivot_val = mat[piv_i*cols + piv_j]
+            mat[piv_i*cols + piv_j] = one
+            for p in range(piv_i*cols + piv_j + 1, (piv_i + 1)*cols):
+                mat[p] = isimp(mat[p] / pivot_val)
+
+    return mat, tuple(pivot_cols), tuple(swaps)
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _row_reduce(M, iszerofunc, simpfunc, normalize_last=True,
+                normalize=True, zero_above=True):
+
+    mat, pivot_cols, swaps = _row_reduce_list(list(M), M.rows, M.cols, M.one,
+            iszerofunc, simpfunc, normalize_last=normalize_last,
+            normalize=normalize, zero_above=zero_above)
+
+    return M._new(M.rows, M.cols, mat), pivot_cols, swaps
+
+
+def _is_echelon(M, iszerofunc=_iszero):
+    """Returns `True` if the matrix is in echelon form. That is, all rows of
+    zeros are at the bottom, and below each leading non-zero in a row are
+    exclusively zeros."""
+
+    if M.rows <= 0 or M.cols <= 0:
+        return True
+
+    zeros_below = all(iszerofunc(t) for t in M[1:, 0])
+
+    if iszerofunc(M[0, 0]):
+        return zeros_below and _is_echelon(M[:, 1:], iszerofunc)
+
+    return zeros_below and _is_echelon(M[1:, 1:], iszerofunc)
+
+
+def _echelon_form(M, iszerofunc=_iszero, simplify=False, with_pivots=False):
+    """Returns a matrix row-equivalent to ``M`` that is in echelon form. Note
+    that echelon form of a matrix is *not* unique, however, properties like the
+    row space and the null space are preserved.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> M.echelon_form()
+    Matrix([
+    [1,  2],
+    [0, -2]])
+    """
+
+    simpfunc = simplify if isinstance(simplify, FunctionType) else _simplify
+
+    mat, pivots, _ = _row_reduce(M, iszerofunc, simpfunc,
+            normalize_last=True, normalize=False, zero_above=False)
+
+    if with_pivots:
+        return mat, pivots
+
+    return mat
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _rank(M, iszerofunc=_iszero, simplify=False):
+    """Returns the rank of a matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.abc import x
+    >>> m = Matrix([[1, 2], [x, 1 - 1/x]])
+    >>> m.rank()
+    2
+    >>> n = Matrix(3, 3, range(1, 10))
+    >>> n.rank()
+    2
+    """
+
+    def _permute_complexity_right(M, iszerofunc):
+        """Permute columns with complicated elements as
+        far right as they can go.  Since the ``sympy`` row reduction
+        algorithms start on the left, having complexity right-shifted
+        speeds things up.
+
+        Returns a tuple (mat, perm) where perm is a permutation
+        of the columns to perform to shift the complex columns right, and mat
+        is the permuted matrix."""
+
+        def complexity(i):
+            # the complexity of a column will be judged by how many
+            # element's zero-ness cannot be determined
+            return sum(1 if iszerofunc(e) is None else 0 for e in M[:, i])
+
+        complex = [(complexity(i), i) for i in range(M.cols)]
+        perm    = [j for (i, j) in sorted(complex)]
+
+        return (M.permute(perm, orientation='cols'), perm)
+
+    simpfunc = simplify if isinstance(simplify, FunctionType) else _simplify
+
+    # for small matrices, we compute the rank explicitly
+    # if is_zero on elements doesn't answer the question
+    # for small matrices, we fall back to the full routine.
+    if M.rows <= 0 or M.cols <= 0:
+        return 0
+
+    if M.rows <= 1 or M.cols <= 1:
+        zeros = [iszerofunc(x) for x in M]
+
+        if False in zeros:
+            return 1
+
+    if M.rows == 2 and M.cols == 2:
+        zeros = [iszerofunc(x) for x in M]
+
+        if False not in zeros and None not in zeros:
+            return 0
+
+        d = M.det()
+
+        if iszerofunc(d) and False in zeros:
+            return 1
+        if iszerofunc(d) is False:
+            return 2
+
+    mat, _       = _permute_complexity_right(M, iszerofunc=iszerofunc)
+    _, pivots, _ = _row_reduce(mat, iszerofunc, simpfunc, normalize_last=True,
+            normalize=False, zero_above=False)
+
+    return len(pivots)
+
+
+def _to_DM_ZZ_QQ(M):
+    # We have to test for _rep here because there are tests that otherwise fail
+    # with e.g. "AttributeError: 'SubspaceOnlyMatrix' object has no attribute
+    # '_rep'." There is almost certainly no value in such tests. The
+    # presumption seems to be that someone could create a new class by
+    # inheriting some of the Matrix classes and not the full set that is used
+    # by the standard Matrix class but if anyone tried that it would fail in
+    # many ways.
+    if not hasattr(M, '_rep'):
+        return None
+
+    rep = M._rep
+    K = rep.domain
+
+    if K.is_ZZ:
+        return rep
+    elif K.is_QQ:
+        try:
+            return rep.convert_to(ZZ)
+        except CoercionFailed:
+            return rep
+    else:
+        if not all(e.is_Rational for e in M):
+            return None
+        try:
+            return rep.convert_to(ZZ)
+        except CoercionFailed:
+            return rep.convert_to(QQ)
+
+
+def _rref_dm(dM):
+    """Compute the reduced row echelon form of a DomainMatrix."""
+    K = dM.domain
+
+    if K.is_ZZ:
+        dM_rref, den, pivots = dM.rref_den(keep_domain=False)
+        dM_rref = dM_rref.to_field() / den
+    elif K.is_QQ:
+        dM_rref, pivots = dM.rref()
+    else:
+        assert False  # pragma: no cover
+
+    M_rref = dM_rref.to_Matrix()
+
+    return M_rref, pivots
+
+
+def _rref(M, iszerofunc=_iszero, simplify=False, pivots=True,
+        normalize_last=True):
+    """Return reduced row-echelon form of matrix and indices
+    of pivot vars.
+
+    Parameters
+    ==========
+
+    iszerofunc : Function
+        A function used for detecting whether an element can
+        act as a pivot.  ``lambda x: x.is_zero`` is used by default.
+
+    simplify : Function
+        A function used to simplify elements when looking for a pivot.
+        By default SymPy's ``simplify`` is used.
+
+    pivots : True or False
+        If ``True``, a tuple containing the row-reduced matrix and a tuple
+        of pivot columns is returned.  If ``False`` just the row-reduced
+        matrix is returned.
+
+    normalize_last : True or False
+        If ``True``, no pivots are normalized to `1` until after all
+        entries above and below each pivot are zeroed.  This means the row
+        reduction algorithm is fraction free until the very last step.
+        If ``False``, the naive row reduction procedure is used where
+        each pivot is normalized to be `1` before row operations are
+        used to zero above and below the pivot.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.abc import x
+    >>> m = Matrix([[1, 2], [x, 1 - 1/x]])
+    >>> m.rref()
+    (Matrix([
+    [1, 0],
+    [0, 1]]), (0, 1))
+    >>> rref_matrix, rref_pivots = m.rref()
+    >>> rref_matrix
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> rref_pivots
+    (0, 1)
+
+    ``iszerofunc`` can correct rounding errors in matrices with float
+    values. In the following example, calling ``rref()`` leads to
+    floating point errors, incorrectly row reducing the matrix.
+    ``iszerofunc= lambda x: abs(x) < 1e-9`` sets sufficiently small numbers
+    to zero, avoiding this error.
+
+    >>> m = Matrix([[0.9, -0.1, -0.2, 0], [-0.8, 0.9, -0.4, 0], [-0.1, -0.8, 0.6, 0]])
+    >>> m.rref()
+    (Matrix([
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0]]), (0, 1, 2))
+    >>> m.rref(iszerofunc=lambda x:abs(x)<1e-9)
+    (Matrix([
+    [1, 0, -0.301369863013699, 0],
+    [0, 1, -0.712328767123288, 0],
+    [0, 0,         0,          0]]), (0, 1))
+
+    Notes
+    =====
+
+    The default value of ``normalize_last=True`` can provide significant
+    speedup to row reduction, especially on matrices with symbols.  However,
+    if you depend on the form row reduction algorithm leaves entries
+    of the matrix, set ``normalize_last=False``
+    """
+    # Try to use DomainMatrix for ZZ or QQ
+    dM = _to_DM_ZZ_QQ(M)
+
+    if dM is not None:
+        # Use DomainMatrix for ZZ or QQ
+        mat, pivot_cols = _rref_dm(dM)
+    else:
+        # Use the generic Matrix routine.
+        if isinstance(simplify, FunctionType):
+            simpfunc = simplify
+        else:
+            simpfunc = _simplify
+
+        mat, pivot_cols, _ = _row_reduce(M, iszerofunc, simpfunc,
+                normalize_last, normalize=True, zero_above=True)
+
+    if pivots:
+        return mat, pivot_cols
+    else:
+        return mat

phi4/lib/python3.10/site-packages/sympy/matrices/repmatrix.py

@@ -0,0 +1,1025 @@
+from collections import defaultdict
+
+from operator import index as index_
+
+from sympy.core.expr import Expr
+from sympy.core.kind import Kind, NumberKind, UndefinedKind
+from sympy.core.numbers import Integer, Rational
+from sympy.core.sympify import _sympify, SympifyError
+from sympy.core.singleton import S
+from sympy.polys.domains import ZZ, QQ, GF, EXRAW
+from sympy.polys.matrices import DomainMatrix
+from sympy.polys.matrices.exceptions import DMNonInvertibleMatrixError
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import filldedent, as_int
+
+from .exceptions import ShapeError, NonSquareMatrixError, NonInvertibleMatrixError
+from .matrixbase import classof, MatrixBase
+from .kind import MatrixKind
+
+
+class RepMatrix(MatrixBase):
+    """Matrix implementation based on DomainMatrix as an internal representation.
+
+    The RepMatrix class is a superclass for Matrix, ImmutableMatrix,
+    SparseMatrix and ImmutableSparseMatrix which are the main usable matrix
+    classes in SymPy. Most methods on this class are simply forwarded to
+    DomainMatrix.
+    """
+
+    #
+    # MatrixBase is the common superclass for all of the usable explicit matrix
+    # classes in SymPy. The idea is that MatrixBase is an abstract class though
+    # and that subclasses will implement the lower-level methods.
+    #
+    # RepMatrix is a subclass of MatrixBase that uses DomainMatrix as an
+    # internal representation and delegates lower-level methods to
+    # DomainMatrix. All of SymPy's standard explicit matrix classes subclass
+    # RepMatrix and so use DomainMatrix internally.
+    #
+    # A RepMatrix uses an internal DomainMatrix with the domain set to ZZ, QQ
+    # or EXRAW. The EXRAW domain is equivalent to the previous implementation
+    # of Matrix that used Expr for the elements. The ZZ and QQ domains are used
+    # when applicable just because they are compatible with the previous
+    # implementation but are much more efficient. Other domains such as QQ[x]
+    # are not used because they differ from Expr in some way (e.g. automatic
+    # expansion of powers and products).
+    #
+
+    _rep: DomainMatrix
+
+    def __eq__(self, other):
+        # Skip sympify for mutable matrices...
+        if not isinstance(other, RepMatrix):
+            try:
+                other = _sympify(other)
+            except SympifyError:
+                return NotImplemented
+            if not isinstance(other, RepMatrix):
+                return NotImplemented
+
+        return self._rep.unify_eq(other._rep)
+
+    def to_DM(self, domain=None, **kwargs):
+        """Convert to a :class:`~.DomainMatrix`.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> M.to_DM()
+        DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
+
+        The :meth:`DomainMatrix.to_Matrix` method can be used to convert back:
+
+        >>> M.to_DM().to_Matrix() == M
+        True
+
+        The domain can be given explicitly or otherwise it will be chosen by
+        :func:`construct_domain`. Any keyword arguments (besides ``domain``)
+        are passed to :func:`construct_domain`:
+
+        >>> from sympy import QQ, symbols
+        >>> x = symbols('x')
+        >>> M = Matrix([[x, 1], [1, x]])
+        >>> M
+        Matrix([
+        [x, 1],
+        [1, x]])
+        >>> M.to_DM().domain
+        ZZ[x]
+        >>> M.to_DM(field=True).domain
+        ZZ(x)
+        >>> M.to_DM(domain=QQ[x]).domain
+        QQ[x]
+
+        See Also
+        ========
+
+        DomainMatrix
+        DomainMatrix.to_Matrix
+        DomainMatrix.convert_to
+        DomainMatrix.choose_domain
+        construct_domain
+        """
+        if domain is not None:
+            if kwargs:
+                raise TypeError("Options cannot be used with domain parameter")
+            return self._rep.convert_to(domain)
+
+        rep = self._rep
+        dom = rep.domain
+
+        # If the internal DomainMatrix is already ZZ or QQ then we can maybe
+        # bypass calling construct_domain or performing any conversions. Some
+        # kwargs might affect this though e.g. field=True (not sure if there
+        # are others).
+        if not kwargs:
+            if dom.is_ZZ:
+                return rep.copy()
+            elif dom.is_QQ:
+                # All elements might be integers
+                try:
+                    return rep.convert_to(ZZ)
+                except CoercionFailed:
+                    pass
+                return rep.copy()
+
+        # Let construct_domain choose a domain
+        rep_dom = rep.choose_domain(**kwargs)
+
+        # XXX: There should be an option to construct_domain to choose EXRAW
+        # instead of EX. At least converting to EX does not initially trigger
+        # EX.simplify which is what we want here but should probably be
+        # considered a bug in EX. Perhaps also this could be handled in
+        # DomainMatrix.choose_domain rather than here...
+        if rep_dom.domain.is_EX:
+            rep_dom = rep_dom.convert_to(EXRAW)
+
+        return rep_dom
+
+    @classmethod
+    def _unify_element_sympy(cls, rep, element):
+        domain = rep.domain
+        element = _sympify(element)
+
+        if domain != EXRAW:
+            # The domain can only be ZZ, QQ or EXRAW
+            if element.is_Integer:
+                new_domain = domain
+            elif element.is_Rational:
+                new_domain = QQ
+            else:
+                new_domain = EXRAW
+
+            # XXX: This converts the domain for all elements in the matrix
+            # which can be slow. This happens e.g. if __setitem__ changes one
+            # element to something that does not fit in the domain
+            if new_domain != domain:
+                rep = rep.convert_to(new_domain)
+                domain = new_domain
+
+            if domain != EXRAW:
+                element = new_domain.from_sympy(element)
+
+        if domain == EXRAW and not isinstance(element, Expr):
+            sympy_deprecation_warning(
+                """
+                non-Expr objects in a Matrix is deprecated. Matrix represents
+                a mathematical matrix. To represent a container of non-numeric
+                entities, Use a list of lists, TableForm, NumPy array, or some
+                other data structure instead.
+                """,
+                deprecated_since_version="1.9",
+                active_deprecations_target="deprecated-non-expr-in-matrix",
+                stacklevel=4,
+            )
+
+        return rep, element
+
+    @classmethod
+    def _dod_to_DomainMatrix(cls, rows, cols, dod, types):
+
+        if not all(issubclass(typ, Expr) for typ in types):
+            sympy_deprecation_warning(
+                """
+                non-Expr objects in a Matrix is deprecated. Matrix represents
+                a mathematical matrix. To represent a container of non-numeric
+                entities, Use a list of lists, TableForm, NumPy array, or some
+                other data structure instead.
+                """,
+                deprecated_since_version="1.9",
+                active_deprecations_target="deprecated-non-expr-in-matrix",
+                stacklevel=6,
+            )
+
+        rep = DomainMatrix(dod, (rows, cols), EXRAW)
+
+        if all(issubclass(typ, Rational) for typ in types):
+            if all(issubclass(typ, Integer) for typ in types):
+                rep = rep.convert_to(ZZ)
+            else:
+                rep = rep.convert_to(QQ)
+
+        return rep
+
+    @classmethod
+    def _flat_list_to_DomainMatrix(cls, rows, cols, flat_list):
+
+        elements_dod = defaultdict(dict)
+        for n, element in enumerate(flat_list):
+            if element != 0:
+                i, j = divmod(n, cols)
+                elements_dod[i][j] = element
+
+        types = set(map(type, flat_list))
+
+        rep = cls._dod_to_DomainMatrix(rows, cols, elements_dod, types)
+        return rep
+
+    @classmethod
+    def _smat_to_DomainMatrix(cls, rows, cols, smat):
+
+        elements_dod = defaultdict(dict)
+        for (i, j), element in smat.items():
+            if element != 0:
+                elements_dod[i][j] = element
+
+        types = set(map(type, smat.values()))
+
+        rep = cls._dod_to_DomainMatrix(rows, cols, elements_dod, types)
+        return rep
+
+    def flat(self):
+        return self._rep.to_sympy().to_list_flat()
+
+    def _eval_tolist(self):
+        return self._rep.to_sympy().to_list()
+
+    def _eval_todok(self):
+        return self._rep.to_sympy().to_dok()
+
+    @classmethod
+    def _eval_from_dok(cls, rows, cols, dok):
+        return cls._fromrep(cls._smat_to_DomainMatrix(rows, cols, dok))
+
+    def _eval_values(self):
+        return list(self._eval_iter_values())
+
+    def _eval_iter_values(self):
+        rep = self._rep
+        K = rep.domain
+        values = rep.iter_values()
+        if not K.is_EXRAW:
+            values = map(K.to_sympy, values)
+        return values
+
+    def _eval_iter_items(self):
+        rep = self._rep
+        K = rep.domain
+        to_sympy = K.to_sympy
+        items = rep.iter_items()
+        if not K.is_EXRAW:
+            items = ((i, to_sympy(v)) for i, v in items)
+        return items
+
+    def copy(self):
+        return self._fromrep(self._rep.copy())
+
+    @property
+    def kind(self) -> MatrixKind:
+        domain = self._rep.domain
+        element_kind: Kind
+        if domain in (ZZ, QQ):
+            element_kind = NumberKind
+        elif domain == EXRAW:
+            kinds = {e.kind for e in self.values()}
+            if len(kinds) == 1:
+                [element_kind] = kinds
+            else:
+                element_kind = UndefinedKind
+        else: # pragma: no cover
+            raise RuntimeError("Domain should only be ZZ, QQ or EXRAW")
+        return MatrixKind(element_kind)
+
+    def _eval_has(self, *patterns):
+        # if the matrix has any zeros, see if S.Zero
+        # has the pattern.  If _smat is full length,
+        # the matrix has no zeros.
+        zhas = False
+        dok = self.todok()
+        if len(dok) != self.rows*self.cols:
+            zhas = S.Zero.has(*patterns)
+        return zhas or any(value.has(*patterns) for value in dok.values())
+
+    def _eval_is_Identity(self):
+        if not all(self[i, i] == 1 for i in range(self.rows)):
+            return False
+        return len(self.todok()) == self.rows
+
+    def _eval_is_symmetric(self, simpfunc):
+        diff = (self - self.T).applyfunc(simpfunc)
+        return len(diff.values()) == 0
+
+    def _eval_transpose(self):
+        """Returns the transposed SparseMatrix of this SparseMatrix.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix
+        >>> a = SparseMatrix(((1, 2), (3, 4)))
+        >>> a
+        Matrix([
+        [1, 2],
+        [3, 4]])
+        >>> a.T
+        Matrix([
+        [1, 3],
+        [2, 4]])
+        """
+        return self._fromrep(self._rep.transpose())
+
+    def _eval_col_join(self, other):
+        return self._fromrep(self._rep.vstack(other._rep))
+
+    def _eval_row_join(self, other):
+        return self._fromrep(self._rep.hstack(other._rep))
+
+    def _eval_extract(self, rowsList, colsList):
+        return self._fromrep(self._rep.extract(rowsList, colsList))
+
+    def __getitem__(self, key):
+        return _getitem_RepMatrix(self, key)
+
+    @classmethod
+    def _eval_zeros(cls, rows, cols):
+        rep = DomainMatrix.zeros((rows, cols), ZZ)
+        return cls._fromrep(rep)
+
+    @classmethod
+    def _eval_eye(cls, rows, cols):
+        rep = DomainMatrix.eye((rows, cols), ZZ)
+        return cls._fromrep(rep)
+
+    def _eval_add(self, other):
+        return classof(self, other)._fromrep(self._rep + other._rep)
+
+    def _eval_matrix_mul(self, other):
+        return classof(self, other)._fromrep(self._rep * other._rep)
+
+    def _eval_matrix_mul_elementwise(self, other):
+        selfrep, otherrep = self._rep.unify(other._rep)
+        newrep = selfrep.mul_elementwise(otherrep)
+        return classof(self, other)._fromrep(newrep)
+
+    def _eval_scalar_mul(self, other):
+        rep, other = self._unify_element_sympy(self._rep, other)
+        return self._fromrep(rep.scalarmul(other))
+
+    def _eval_scalar_rmul(self, other):
+        rep, other = self._unify_element_sympy(self._rep, other)
+        return self._fromrep(rep.rscalarmul(other))
+
+    def _eval_Abs(self):
+        return self._fromrep(self._rep.applyfunc(abs))
+
+    def _eval_conjugate(self):
+        rep = self._rep
+        domain = rep.domain
+        if domain in (ZZ, QQ):
+            return self.copy()
+        else:
+            return self._fromrep(rep.applyfunc(lambda e: e.conjugate()))
+
+    def equals(self, other, failing_expression=False):
+        """Applies ``equals`` to corresponding elements of the matrices,
+        trying to prove that the elements are equivalent, returning True
+        if they are, False if any pair is not, and None (or the first
+        failing expression if failing_expression is True) if it cannot
+        be decided if the expressions are equivalent or not. This is, in
+        general, an expensive operation.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x
+        >>> A = Matrix([x*(x - 1), 0])
+        >>> B = Matrix([x**2 - x, 0])
+        >>> A == B
+        False
+        >>> A.simplify() == B.simplify()
+        True
+        >>> A.equals(B)
+        True
+        >>> A.equals(2)
+        False
+
+        See Also
+        ========
+        sympy.core.expr.Expr.equals
+        """
+        if self.shape != getattr(other, 'shape', None):
+            return False
+
+        rv = True
+        for i in range(self.rows):
+            for j in range(self.cols):
+                ans = self[i, j].equals(other[i, j], failing_expression)
+                if ans is False:
+                    return False
+                elif ans is not True and rv is True:
+                    rv = ans
+        return rv
+
+    def inv_mod(M, m):
+        r"""
+        Returns the inverse of the integer matrix ``M`` modulo ``m``.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix(2, 2, [1, 2, 3, 4])
+        >>> A.inv_mod(5)
+        Matrix([
+        [3, 1],
+        [4, 2]])
+        >>> A.inv_mod(3)
+        Matrix([
+        [1, 1],
+        [0, 1]])
+
+        """
+
+        if not M.is_square:
+            raise NonSquareMatrixError()
+
+        try:
+            m = as_int(m)
+        except ValueError:
+            raise TypeError("inv_mod: modulus m must be an integer")
+
+        K = GF(m, symmetric=False)
+
+        try:
+            dM = M.to_DM(K)
+        except CoercionFailed:
+            raise ValueError("inv_mod: matrix entries must be integers")
+
+        try:
+            dMi = dM.inv()
+        except DMNonInvertibleMatrixError as exc:
+            msg = f'Matrix is not invertible (mod {m})'
+            raise NonInvertibleMatrixError(msg) from exc
+
+        return dMi.to_Matrix()
+
+    def lll(self, delta=0.75):
+        """LLL-reduced basis for the rowspace of a matrix of integers.
+
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm.
+
+        The implementation is provided by :class:`~DomainMatrix`. See
+        :meth:`~DomainMatrix.lll` for more details.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 0, 0, 0, -20160],
+        ...             [0, 1, 0, 0, 33768],
+        ...             [0, 0, 1, 0, 39578],
+        ...             [0, 0, 0, 1, 47757]])
+        >>> M.lll()
+        Matrix([
+        [ 10, -3,  -2,  8,  -4],
+        [  3, -9,   8,  1, -11],
+        [ -3, 13,  -9, -3,  -9],
+        [-12, -7, -11,  9,  -1]])
+
+        See Also
+        ========
+
+        lll_transform
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+        """
+        delta = QQ.from_sympy(_sympify(delta))
+        dM = self._rep.convert_to(ZZ)
+        basis = dM.lll(delta=delta)
+        return self._fromrep(basis)
+
+    def lll_transform(self, delta=0.75):
+        """LLL-reduced basis and transformation matrix.
+
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm.
+
+        The implementation is provided by :class:`~DomainMatrix`. See
+        :meth:`~DomainMatrix.lll_transform` for more details.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 0, 0, 0, -20160],
+        ...             [0, 1, 0, 0, 33768],
+        ...             [0, 0, 1, 0, 39578],
+        ...             [0, 0, 0, 1, 47757]])
+        >>> B, T = M.lll_transform()
+        >>> B
+        Matrix([
+        [ 10, -3,  -2,  8,  -4],
+        [  3, -9,   8,  1, -11],
+        [ -3, 13,  -9, -3,  -9],
+        [-12, -7, -11,  9,  -1]])
+        >>> T
+        Matrix([
+        [ 10, -3,  -2,  8],
+        [  3, -9,   8,  1],
+        [ -3, 13,  -9, -3],
+        [-12, -7, -11,  9]])
+
+        The transformation matrix maps the original basis to the LLL-reduced
+        basis:
+
+        >>> T * M == B
+        True
+
+        See Also
+        ========
+
+        lll
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll_transform
+        """
+        delta = QQ.from_sympy(_sympify(delta))
+        dM = self._rep.convert_to(ZZ)
+        basis, transform = dM.lll_transform(delta=delta)
+        B = self._fromrep(basis)
+        T = self._fromrep(transform)
+        return B, T
+
+
+class MutableRepMatrix(RepMatrix):
+    """Mutable matrix based on DomainMatrix as the internal representation"""
+
+    #
+    # MutableRepMatrix is a subclass of RepMatrix that adds/overrides methods
+    # to make the instances mutable. MutableRepMatrix is a superclass for both
+    # MutableDenseMatrix and MutableSparseMatrix.
+    #
+
+    is_zero = False
+
+    def __new__(cls, *args, **kwargs):
+        return cls._new(*args, **kwargs)
+
+    @classmethod
+    def _new(cls, *args, copy=True, **kwargs):
+        if copy is False:
+            # The input was rows, cols, [list].
+            # It should be used directly without creating a copy.
+            if len(args) != 3:
+                raise TypeError("'copy=False' requires a matrix be initialized as rows,cols,[list]")
+            rows, cols, flat_list = args
+        else:
+            rows, cols, flat_list = cls._handle_creation_inputs(*args, **kwargs)
+            flat_list = list(flat_list) # create a shallow copy
+
+        rep = cls._flat_list_to_DomainMatrix(rows, cols, flat_list)
+
+        return cls._fromrep(rep)
+
+    @classmethod
+    def _fromrep(cls, rep):
+        obj = super().__new__(cls)
+        obj.rows, obj.cols = rep.shape
+        obj._rep = rep
+        return obj
+
+    def copy(self):
+        return self._fromrep(self._rep.copy())
+
+    def as_mutable(self):
+        return self.copy()
+
+    def __setitem__(self, key, value):
+        """
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, I, zeros, ones
+        >>> m = Matrix(((1, 2+I), (3, 4)))
+        >>> m
+        Matrix([
+        [1, 2 + I],
+        [3,     4]])
+        >>> m[1, 0] = 9
+        >>> m
+        Matrix([
+        [1, 2 + I],
+        [9,     4]])
+        >>> m[1, 0] = [[0, 1]]
+
+        To replace row r you assign to position r*m where m
+        is the number of columns:
+
+        >>> M = zeros(4)
+        >>> m = M.cols
+        >>> M[3*m] = ones(1, m)*2; M
+        Matrix([
+        [0, 0, 0, 0],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0],
+        [2, 2, 2, 2]])
+
+        And to replace column c you can assign to position c:
+
+        >>> M[2] = ones(m, 1)*4; M
+        Matrix([
+        [0, 0, 4, 0],
+        [0, 0, 4, 0],
+        [0, 0, 4, 0],
+        [2, 2, 4, 2]])
+        """
+        rv = self._setitem(key, value)
+        if rv is not None:
+            i, j, value = rv
+            self._rep, value = self._unify_element_sympy(self._rep, value)
+            self._rep.rep.setitem(i, j, value)
+
+    def _eval_col_del(self, col):
+        self._rep = DomainMatrix.hstack(self._rep[:,:col], self._rep[:,col+1:])
+        self.cols -= 1
+
+    def _eval_row_del(self, row):
+        self._rep = DomainMatrix.vstack(self._rep[:row,:], self._rep[row+1:, :])
+        self.rows -= 1
+
+    def _eval_col_insert(self, col, other):
+        other = self._new(other)
+        return self.hstack(self[:,:col], other, self[:,col:])
+
+    def _eval_row_insert(self, row, other):
+        other = self._new(other)
+        return self.vstack(self[:row,:], other, self[row:,:])
+
+    def col_op(self, j, f):
+        """In-place operation on col j using two-arg functor whose args are
+        interpreted as (self[i, j], i).
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.col_op(1, lambda v, i: v + 2*M[i, 0]); M
+        Matrix([
+        [1, 2, 0],
+        [0, 1, 0],
+        [0, 0, 1]])
+
+        See Also
+        ========
+        col
+        row_op
+        """
+        for i in range(self.rows):
+            self[i, j] = f(self[i, j], i)
+
+    def col_swap(self, i, j):
+        """Swap the two given columns of the matrix in-place.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 0], [1, 0]])
+        >>> M
+        Matrix([
+        [1, 0],
+        [1, 0]])
+        >>> M.col_swap(0, 1)
+        >>> M
+        Matrix([
+        [0, 1],
+        [0, 1]])
+
+        See Also
+        ========
+
+        col
+        row_swap
+        """
+        for k in range(0, self.rows):
+            self[k, i], self[k, j] = self[k, j], self[k, i]
+
+    def row_op(self, i, f):
+        """In-place operation on row ``i`` using two-arg functor whose args are
+        interpreted as ``(self[i, j], j)``.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.row_op(1, lambda v, j: v + 2*M[0, j]); M
+        Matrix([
+        [1, 0, 0],
+        [2, 1, 0],
+        [0, 0, 1]])
+
+        See Also
+        ========
+        row
+        zip_row_op
+        col_op
+
+        """
+        for j in range(self.cols):
+            self[i, j] = f(self[i, j], j)
+
+    #The next three methods give direct support for the most common row operations inplace.
+    def row_mult(self,i,factor):
+        """Multiply the given row by the given factor in-place.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.row_mult(1,7); M
+        Matrix([
+        [1, 0, 0],
+        [0, 7, 0],
+        [0, 0, 1]])
+
+        """
+        for j in range(self.cols):
+            self[i,j] *= factor
+
+    def row_add(self,s,t,k):
+        """Add k times row s (source) to row t (target) in place.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.row_add(0, 2,3); M
+        Matrix([
+        [1, 0, 0],
+        [0, 1, 0],
+        [3, 0, 1]])
+        """
+
+        for j in range(self.cols):
+            self[t,j] += k*self[s,j]
+
+    def row_swap(self, i, j):
+        """Swap the two given rows of the matrix in-place.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[0, 1], [1, 0]])
+        >>> M
+        Matrix([
+        [0, 1],
+        [1, 0]])
+        >>> M.row_swap(0, 1)
+        >>> M
+        Matrix([
+        [1, 0],
+        [0, 1]])
+
+        See Also
+        ========
+
+        row
+        col_swap
+        """
+        for k in range(0, self.cols):
+            self[i, k], self[j, k] = self[j, k], self[i, k]
+
+    def zip_row_op(self, i, k, f):
+        """In-place operation on row ``i`` using two-arg functor whose args are
+        interpreted as ``(self[i, j], self[k, j])``.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.zip_row_op(1, 0, lambda v, u: v + 2*u); M
+        Matrix([
+        [1, 0, 0],
+        [2, 1, 0],
+        [0, 0, 1]])
+
+        See Also
+        ========
+        row
+        row_op
+        col_op
+
+        """
+        for j in range(self.cols):
+            self[i, j] = f(self[i, j], self[k, j])
+
+    def copyin_list(self, key, value):
+        """Copy in elements from a list.
+
+        Parameters
+        ==========
+
+        key : slice
+            The section of this matrix to replace.
+        value : iterable
+            The iterable to copy values from.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> I = eye(3)
+        >>> I[:2, 0] = [1, 2] # col
+        >>> I
+        Matrix([
+        [1, 0, 0],
+        [2, 1, 0],
+        [0, 0, 1]])
+        >>> I[1, :2] = [[3, 4]]
+        >>> I
+        Matrix([
+        [1, 0, 0],
+        [3, 4, 0],
+        [0, 0, 1]])
+
+        See Also
+        ========
+
+        copyin_matrix
+        """
+        if not is_sequence(value):
+            raise TypeError("`value` must be an ordered iterable, not %s." % type(value))
+        return self.copyin_matrix(key, type(self)(value))
+
+    def copyin_matrix(self, key, value):
+        """Copy in values from a matrix into the given bounds.
+
+        Parameters
+        ==========
+
+        key : slice
+            The section of this matrix to replace.
+        value : Matrix
+            The matrix to copy values from.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, eye
+        >>> M = Matrix([[0, 1], [2, 3], [4, 5]])
+        >>> I = eye(3)
+        >>> I[:3, :2] = M
+        >>> I
+        Matrix([
+        [0, 1, 0],
+        [2, 3, 0],
+        [4, 5, 1]])
+        >>> I[0, 1] = M
+        >>> I
+        Matrix([
+        [0, 0, 1],
+        [2, 2, 3],
+        [4, 4, 5]])
+
+        See Also
+        ========
+
+        copyin_list
+        """
+        rlo, rhi, clo, chi = self.key2bounds(key)
+        shape = value.shape
+        dr, dc = rhi - rlo, chi - clo
+        if shape != (dr, dc):
+            raise ShapeError(filldedent("The Matrix `value` doesn't have the "
+                                        "same dimensions "
+                                        "as the in sub-Matrix given by `key`."))
+
+        for i in range(value.rows):
+            for j in range(value.cols):
+                self[i + rlo, j + clo] = value[i, j]
+
+    def fill(self, value):
+        """Fill self with the given value.
+
+        Notes
+        =====
+
+        Unless many values are going to be deleted (i.e. set to zero)
+        this will create a matrix that is slower than a dense matrix in
+        operations.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix
+        >>> M = SparseMatrix.zeros(3); M
+        Matrix([
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0]])
+        >>> M.fill(1); M
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1]])
+
+        See Also
+        ========
+
+        zeros
+        ones
+        """
+        value = _sympify(value)
+        if not value:
+            self._rep = DomainMatrix.zeros(self.shape, EXRAW)
+        else:
+            elements_dod = {i: dict.fromkeys(range(self.cols), value) for i in range(self.rows)}
+            self._rep = DomainMatrix(elements_dod, self.shape, EXRAW)
+
+
+def _getitem_RepMatrix(self, key):
+    """Return portion of self defined by key. If the key involves a slice
+    then a list will be returned (if key is a single slice) or a matrix
+    (if key was a tuple involving a slice).
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, I
+    >>> m = Matrix([
+    ... [1, 2 + I],
+    ... [3, 4    ]])
+
+    If the key is a tuple that does not involve a slice then that element
+    is returned:
+
+    >>> m[1, 0]
+    3
+
+    When a tuple key involves a slice, a matrix is returned. Here, the
+    first column is selected (all rows, column 0):
+
+    >>> m[:, 0]
+    Matrix([
+    [1],
+    [3]])
+
+    If the slice is not a tuple then it selects from the underlying
+    list of elements that are arranged in row order and a list is
+    returned if a slice is involved:
+
+    >>> m[0]
+    1
+    >>> m[::2]
+    [1, 3]
+    """
+    if isinstance(key, tuple):
+        i, j = key
+        try:
+            return self._rep.getitem_sympy(index_(i), index_(j))
+        except (TypeError, IndexError):
+            if (isinstance(i, Expr) and not i.is_number) or (isinstance(j, Expr) and not j.is_number):
+                if ((j < 0) is True) or ((j >= self.shape[1]) is True) or\
+                   ((i < 0) is True) or ((i >= self.shape[0]) is True):
+                    raise ValueError("index out of boundary")
+                from sympy.matrices.expressions.matexpr import MatrixElement
+                return MatrixElement(self, i, j)
+
+            if isinstance(i, slice):
+                i = range(self.rows)[i]
+            elif is_sequence(i):
+                pass
+            else:
+                i = [i]
+            if isinstance(j, slice):
+                j = range(self.cols)[j]
+            elif is_sequence(j):
+                pass
+            else:
+                j = [j]
+            return self.extract(i, j)
+
+    else:
+        # Index/slice like a flattened list
+        rows, cols = self.shape
+
+        # Raise the appropriate exception:
+        if not rows * cols:
+            return [][key]
+
+        rep = self._rep.rep
+        domain = rep.domain
+        is_slice = isinstance(key, slice)
+
+        if is_slice:
+            values = [rep.getitem(*divmod(n, cols)) for n in range(rows * cols)[key]]
+        else:
+            values = [rep.getitem(*divmod(index_(key), cols))]
+
+        if domain != EXRAW:
+            to_sympy = domain.to_sympy
+            values = [to_sympy(val) for val in values]
+
+        if is_slice:
+            return values
+        else:
+            return values[0]

phi4/lib/python3.10/site-packages/sympy/matrices/solvers.py

@@ -0,0 +1,942 @@
+from sympy.core.function import expand_mul
+from sympy.core.symbol import Dummy, uniquely_named_symbol, symbols
+from sympy.utilities.iterables import numbered_symbols
+
+from .exceptions import ShapeError, NonSquareMatrixError, NonInvertibleMatrixError
+from .eigen import _fuzzy_positive_definite
+from .utilities import _get_intermediate_simp, _iszero
+
+
+def _diagonal_solve(M, rhs):
+    """Solves ``Ax = B`` efficiently, where A is a diagonal Matrix,
+    with non-zero diagonal entries.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, eye
+    >>> A = eye(2)*2
+    >>> B = Matrix([[1, 2], [3, 4]])
+    >>> A.diagonal_solve(B) == B/2
+    True
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    if not M.is_diagonal():
+        raise TypeError("Matrix should be diagonal")
+    if rhs.rows != M.rows:
+        raise TypeError("Size mismatch")
+
+    return M._new(
+        rhs.rows, rhs.cols, lambda i, j: rhs[i, j] / M[i, i])
+
+
+def _lower_triangular_solve(M, rhs):
+    """Solves ``Ax = B``, where A is a lower triangular matrix.
+
+    See Also
+    ========
+
+    upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    from .dense import MutableDenseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if rhs.rows != M.rows:
+        raise ShapeError("Matrices size mismatch.")
+    if not M.is_lower:
+        raise ValueError("Matrix must be lower triangular.")
+
+    dps = _get_intermediate_simp()
+    X   = MutableDenseMatrix.zeros(M.rows, rhs.cols)
+
+    for j in range(rhs.cols):
+        for i in range(M.rows):
+            if M[i, i] == 0:
+                raise TypeError("Matrix must be non-singular.")
+
+            X[i, j] = dps((rhs[i, j] - sum(M[i, k]*X[k, j]
+                                        for k in range(i))) / M[i, i])
+
+    return M._new(X)
+
+def _lower_triangular_solve_sparse(M, rhs):
+    """Solves ``Ax = B``, where A is a lower triangular matrix.
+
+    See Also
+    ========
+
+    upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if rhs.rows != M.rows:
+        raise ShapeError("Matrices size mismatch.")
+    if not M.is_lower:
+        raise ValueError("Matrix must be lower triangular.")
+
+    dps  = _get_intermediate_simp()
+    rows = [[] for i in range(M.rows)]
+
+    for i, j, v in M.row_list():
+        if i > j:
+            rows[i].append((j, v))
+
+    X = rhs.as_mutable()
+
+    for j in range(rhs.cols):
+        for i in range(rhs.rows):
+            for u, v in rows[i]:
+                X[i, j] -= v*X[u, j]
+
+            X[i, j] = dps(X[i, j] / M[i, i])
+
+    return M._new(X)
+
+
+def _upper_triangular_solve(M, rhs):
+    """Solves ``Ax = B``, where A is an upper triangular matrix.
+
+    See Also
+    ========
+
+    lower_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    from .dense import MutableDenseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if rhs.rows != M.rows:
+        raise ShapeError("Matrix size mismatch.")
+    if not M.is_upper:
+        raise TypeError("Matrix is not upper triangular.")
+
+    dps = _get_intermediate_simp()
+    X   = MutableDenseMatrix.zeros(M.rows, rhs.cols)
+
+    for j in range(rhs.cols):
+        for i in reversed(range(M.rows)):
+            if M[i, i] == 0:
+                raise ValueError("Matrix must be non-singular.")
+
+            X[i, j] = dps((rhs[i, j] - sum(M[i, k]*X[k, j]
+                                        for k in range(i + 1, M.rows))) / M[i, i])
+
+    return M._new(X)
+
+def _upper_triangular_solve_sparse(M, rhs):
+    """Solves ``Ax = B``, where A is an upper triangular matrix.
+
+    See Also
+    ========
+
+    lower_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if rhs.rows != M.rows:
+        raise ShapeError("Matrix size mismatch.")
+    if not M.is_upper:
+        raise TypeError("Matrix is not upper triangular.")
+
+    dps  = _get_intermediate_simp()
+    rows = [[] for i in range(M.rows)]
+
+    for i, j, v in M.row_list():
+        if i < j:
+            rows[i].append((j, v))
+
+    X = rhs.as_mutable()
+
+    for j in range(rhs.cols):
+        for i in reversed(range(rhs.rows)):
+            for u, v in reversed(rows[i]):
+                X[i, j] -= v*X[u, j]
+
+            X[i, j] = dps(X[i, j] / M[i, i])
+
+    return M._new(X)
+
+
+def _cholesky_solve(M, rhs):
+    """Solves ``Ax = B`` using Cholesky decomposition,
+    for a general square non-singular matrix.
+    For a non-square matrix with rows > cols,
+    the least squares solution is returned.
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    gauss_jordan_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    if M.rows < M.cols:
+        raise NotImplementedError(
+            'Under-determined System. Try M.gauss_jordan_solve(rhs)')
+
+    hermitian = True
+    reform    = False
+
+    if M.is_symmetric():
+        hermitian = False
+    elif not M.is_hermitian:
+        reform = True
+
+    if reform or _fuzzy_positive_definite(M) is False:
+        H         = M.H
+        M         = H.multiply(M)
+        rhs       = H.multiply(rhs)
+        hermitian = not M.is_symmetric()
+
+    L = M.cholesky(hermitian=hermitian)
+    Y = L.lower_triangular_solve(rhs)
+
+    if hermitian:
+        return (L.H).upper_triangular_solve(Y)
+    else:
+        return (L.T).upper_triangular_solve(Y)
+
+
+def _LDLsolve(M, rhs):
+    """Solves ``Ax = B`` using LDL decomposition,
+    for a general square and non-singular matrix.
+
+    For a non-square matrix with rows > cols,
+    the least squares solution is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, eye
+    >>> A = eye(2)*2
+    >>> B = Matrix([[1, 2], [3, 4]])
+    >>> A.LDLsolve(B) == B/2
+    True
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.LDLdecomposition
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LUsolve
+    QRsolve
+    pinv_solve
+    cramer_solve
+    """
+
+    if M.rows < M.cols:
+        raise NotImplementedError(
+            'Under-determined System. Try M.gauss_jordan_solve(rhs)')
+
+    hermitian = True
+    reform    = False
+
+    if M.is_symmetric():
+        hermitian = False
+    elif not M.is_hermitian:
+        reform = True
+
+    if reform or _fuzzy_positive_definite(M) is False:
+        H         = M.H
+        M         = H.multiply(M)
+        rhs       = H.multiply(rhs)
+        hermitian = not M.is_symmetric()
+
+    L, D = M.LDLdecomposition(hermitian=hermitian)
+    Y    = L.lower_triangular_solve(rhs)
+    Z    = D.diagonal_solve(Y)
+
+    if hermitian:
+        return (L.H).upper_triangular_solve(Z)
+    else:
+        return (L.T).upper_triangular_solve(Z)
+
+
+def _LUsolve(M, rhs, iszerofunc=_iszero):
+    """Solve the linear system ``Ax = rhs`` for ``x`` where ``A = M``.
+
+    This is for symbolic matrices, for real or complex ones use
+    mpmath.lu_solve or mpmath.qr_solve.
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    QRsolve
+    pinv_solve
+    LUdecomposition
+    cramer_solve
+    """
+
+    if rhs.rows != M.rows:
+        raise ShapeError(
+            "``M`` and ``rhs`` must have the same number of rows.")
+
+    m = M.rows
+    n = M.cols
+
+    if m < n:
+        raise NotImplementedError("Underdetermined systems not supported.")
+
+    try:
+        A, perm = M.LUdecomposition_Simple(
+            iszerofunc=iszerofunc, rankcheck=True)
+    except ValueError:
+        raise NonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+    dps = _get_intermediate_simp()
+    b   = rhs.permute_rows(perm).as_mutable()
+
+    # forward substitution, all diag entries are scaled to 1
+    for i in range(m):
+        for j in range(min(i, n)):
+            scale = A[i, j]
+            b.zip_row_op(i, j, lambda x, y: dps(x - y * scale))
+
+    # consistency check for overdetermined systems
+    if m > n:
+        for i in range(n, m):
+            for j in range(b.cols):
+                if not iszerofunc(b[i, j]):
+                    raise ValueError("The system is inconsistent.")
+
+        b = b[0:n, :]   # truncate zero rows if consistent
+
+    # backward substitution
+    for i in range(n - 1, -1, -1):
+        for j in range(i + 1, n):
+            scale = A[i, j]
+            b.zip_row_op(i, j, lambda x, y: dps(x - y * scale))
+
+        scale = A[i, i]
+        b.row_op(i, lambda x, _: dps(x / scale))
+
+    return rhs.__class__(b)
+
+
+def _QRsolve(M, b):
+    """Solve the linear system ``Ax = b``.
+
+    ``M`` is the matrix ``A``, the method argument is the vector
+    ``b``.  The method returns the solution vector ``x``.  If ``b`` is a
+    matrix, the system is solved for each column of ``b`` and the
+    return value is a matrix of the same shape as ``b``.
+
+    This method is slower (approximately by a factor of 2) but
+    more stable for floating-point arithmetic than the LUsolve method.
+    However, LUsolve usually uses an exact arithmetic, so you do not need
+    to use QRsolve.
+
+    This is mainly for educational purposes and symbolic matrices, for real
+    (or complex) matrices use mpmath.qr_solve.
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    pinv_solve
+    QRdecomposition
+    cramer_solve
+    """
+
+    dps  = _get_intermediate_simp(expand_mul, expand_mul)
+    Q, R = M.QRdecomposition()
+    y    = Q.T * b
+
+    # back substitution to solve R*x = y:
+    # We build up the result "backwards" in the vector 'x' and reverse it
+    # only in the end.
+    x = []
+    n = R.rows
+
+    for j in range(n - 1, -1, -1):
+        tmp = y[j, :]
+
+        for k in range(j + 1, n):
+            tmp -= R[j, k] * x[n - 1 - k]
+
+        tmp = dps(tmp)
+
+        x.append(tmp / R[j, j])
+
+    return M.vstack(*x[::-1])
+
+
+def _gauss_jordan_solve(M, B, freevar=False):
+    """
+    Solves ``Ax = B`` using Gauss Jordan elimination.
+
+    There may be zero, one, or infinite solutions.  If one solution
+    exists, it will be returned. If infinite solutions exist, it will
+    be returned parametrically. If no solutions exist, It will throw
+    ValueError.
+
+    Parameters
+    ==========
+
+    B : Matrix
+        The right hand side of the equation to be solved for.  Must have
+        the same number of rows as matrix A.
+
+    freevar : boolean, optional
+        Flag, when set to `True` will return the indices of the free
+        variables in the solutions (column Matrix), for a system that is
+        undetermined (e.g. A has more columns than rows), for which
+        infinite solutions are possible, in terms of arbitrary
+        values of free variables. Default `False`.
+
+    Returns
+    =======
+
+    x : Matrix
+        The matrix that will satisfy ``Ax = B``.  Will have as many rows as
+        matrix A has columns, and as many columns as matrix B.
+
+    params : Matrix
+        If the system is underdetermined (e.g. A has more columns than
+        rows), infinite solutions are possible, in terms of arbitrary
+        parameters. These arbitrary parameters are returned as params
+        Matrix.
+
+    free_var_index : List, optional
+        If the system is underdetermined (e.g. A has more columns than
+        rows), infinite solutions are possible, in terms of arbitrary
+        values of free variables. Then the indices of the free variables
+        in the solutions (column Matrix) are returned by free_var_index,
+        if the flag `freevar` is set to `True`.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[1, 2, 1, 1], [1, 2, 2, -1], [2, 4, 0, 6]])
+    >>> B = Matrix([7, 12, 4])
+    >>> sol, params = A.gauss_jordan_solve(B)
+    >>> sol
+    Matrix([
+    [-2*tau0 - 3*tau1 + 2],
+    [                 tau0],
+    [           2*tau1 + 5],
+    [                 tau1]])
+    >>> params
+    Matrix([
+    [tau0],
+    [tau1]])
+    >>> taus_zeroes = { tau:0 for tau in params }
+    >>> sol_unique = sol.xreplace(taus_zeroes)
+    >>> sol_unique
+        Matrix([
+    [2],
+    [0],
+    [5],
+    [0]])
+
+
+    >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+    >>> B = Matrix([3, 6, 9])
+    >>> sol, params = A.gauss_jordan_solve(B)
+    >>> sol
+    Matrix([
+    [-1],
+    [ 2],
+    [ 0]])
+    >>> params
+    Matrix(0, 1, [])
+
+    >>> A = Matrix([[2, -7], [-1, 4]])
+    >>> B = Matrix([[-21, 3], [12, -2]])
+    >>> sol, params = A.gauss_jordan_solve(B)
+    >>> sol
+    Matrix([
+    [0, -2],
+    [3, -1]])
+    >>> params
+    Matrix(0, 2, [])
+
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[1, 2, 1, 1], [1, 2, 2, -1], [2, 4, 0, 6]])
+    >>> B = Matrix([7, 12, 4])
+    >>> sol, params, freevars = A.gauss_jordan_solve(B, freevar=True)
+    >>> sol
+    Matrix([
+    [-2*tau0 - 3*tau1 + 2],
+    [                 tau0],
+    [           2*tau1 + 5],
+    [                 tau1]])
+    >>> params
+    Matrix([
+    [tau0],
+    [tau1]])
+    >>> freevars
+    [1, 3]
+
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gaussian_elimination
+
+    """
+
+    from sympy.matrices import Matrix, zeros
+
+    cls      = M.__class__
+    aug      = M.hstack(M.copy(), B.copy())
+    B_cols   = B.cols
+    row, col = aug[:, :-B_cols].shape
+
+    # solve by reduced row echelon form
+    A, pivots = aug.rref(simplify=True)
+    A, v      = A[:, :-B_cols], A[:, -B_cols:]
+    pivots    = list(filter(lambda p: p < col, pivots))
+    rank      = len(pivots)
+
+    # Get index of free symbols (free parameters)
+    # non-pivots columns are free variables
+    free_var_index = [c for c in range(A.cols) if c not in pivots]
+
+    # Bring to block form
+    permutation = Matrix(pivots + free_var_index).T
+
+    # check for existence of solutions
+    # rank of aug Matrix should be equal to rank of coefficient matrix
+    if not v[rank:, :].is_zero_matrix:
+        raise ValueError("Linear system has no solution")
+
+    # Free parameters
+    # what are current unnumbered free symbol names?
+    name = uniquely_named_symbol('tau', [aug],
+            compare=lambda i: str(i).rstrip('1234567890'),
+            modify=lambda s: '_' + s).name
+    gen  = numbered_symbols(name)
+    tau  = Matrix([next(gen) for k in range((col - rank)*B_cols)]).reshape(
+            col - rank, B_cols)
+
+    # Full parametric solution
+    V        = A[:rank, free_var_index]
+    vt       = v[:rank, :]
+    free_sol = tau.vstack(vt - V * tau, tau)
+
+    # Undo permutation
+    sol = zeros(col, B_cols)
+
+    for k in range(col):
+        sol[permutation[k], :] = free_sol[k,:]
+
+    sol, tau = cls(sol), cls(tau)
+
+    if freevar:
+        return sol, tau, free_var_index
+    else:
+        return sol, tau
+
+
+def _pinv_solve(M, B, arbitrary_matrix=None):
+    """Solve ``Ax = B`` using the Moore-Penrose pseudoinverse.
+
+    There may be zero, one, or infinite solutions.  If one solution
+    exists, it will be returned.  If infinite solutions exist, one will
+    be returned based on the value of arbitrary_matrix.  If no solutions
+    exist, the least-squares solution is returned.
+
+    Parameters
+    ==========
+
+    B : Matrix
+        The right hand side of the equation to be solved for.  Must have
+        the same number of rows as matrix A.
+    arbitrary_matrix : Matrix
+        If the system is underdetermined (e.g. A has more columns than
+        rows), infinite solutions are possible, in terms of an arbitrary
+        matrix.  This parameter may be set to a specific matrix to use
+        for that purpose; if so, it must be the same shape as x, with as
+        many rows as matrix A has columns, and as many columns as matrix
+        B.  If left as None, an appropriate matrix containing dummy
+        symbols in the form of ``wn_m`` will be used, with n and m being
+        row and column position of each symbol.
+
+    Returns
+    =======
+
+    x : Matrix
+        The matrix that will satisfy ``Ax = B``.  Will have as many rows as
+        matrix A has columns, and as many columns as matrix B.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[1, 2, 3], [4, 5, 6]])
+    >>> B = Matrix([7, 8])
+    >>> A.pinv_solve(B)
+    Matrix([
+    [ _w0_0/6 - _w1_0/3 + _w2_0/6 - 55/18],
+    [-_w0_0/3 + 2*_w1_0/3 - _w2_0/3 + 1/9],
+    [ _w0_0/6 - _w1_0/3 + _w2_0/6 + 59/18]])
+    >>> A.pinv_solve(B, arbitrary_matrix=Matrix([0, 0, 0]))
+    Matrix([
+    [-55/18],
+    [   1/9],
+    [ 59/18]])
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.lower_triangular_solve
+    sympy.matrices.dense.DenseMatrix.upper_triangular_solve
+    gauss_jordan_solve
+    cholesky_solve
+    diagonal_solve
+    LDLsolve
+    LUsolve
+    QRsolve
+    pinv
+
+    Notes
+    =====
+
+    This may return either exact solutions or least squares solutions.
+    To determine which, check ``A * A.pinv() * B == B``.  It will be
+    True if exact solutions exist, and False if only a least-squares
+    solution exists.  Be aware that the left hand side of that equation
+    may need to be simplified to correctly compare to the right hand
+    side.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse#Obtaining_all_solutions_of_a_linear_system
+
+    """
+
+    from sympy.matrices import eye
+
+    A      = M
+    A_pinv = M.pinv()
+
+    if arbitrary_matrix is None:
+        rows, cols       = A.cols, B.cols
+        w                = symbols('w:{}_:{}'.format(rows, cols), cls=Dummy)
+        arbitrary_matrix = M.__class__(cols, rows, w).T
+
+    return A_pinv.multiply(B) + (eye(A.cols) -
+            A_pinv.multiply(A)).multiply(arbitrary_matrix)
+
+
+def _cramer_solve(M, rhs, det_method="laplace"):
+    """Solves system of linear equations using Cramer's rule.
+
+    This method is relatively inefficient compared to other methods.
+    However it only uses a single division, assuming a division-free determinant
+    method is provided. This is helpful to minimize the chance of divide-by-zero
+    cases in symbolic solutions to linear systems.
+
+    Parameters
+    ==========
+    M : Matrix
+        The matrix representing the left hand side of the equation.
+    rhs : Matrix
+        The matrix representing the right hand side of the equation.
+    det_method : str or callable
+        The method to use to calculate the determinant of the matrix.
+        The default is ``'laplace'``.  If a callable is passed, it should take a
+        single argument, the matrix, and return the determinant of the matrix.
+
+    Returns
+    =======
+    x : Matrix
+        The matrix that will satisfy ``Ax = B``.  Will have as many rows as
+        matrix A has columns, and as many columns as matrix B.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[0, -6, 1], [0, -6, -1], [-5, -2, 3]])
+    >>> B = Matrix([[-30, -9], [-18, -27], [-26, 46]])
+    >>> x = A.cramer_solve(B)
+    >>> x
+    Matrix([
+    [ 0, -5],
+    [ 4,  3],
+    [-6,  9]])
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cramer%27s_rule#Explicit_formulas_for_small_systems
+
+    """
+    from .dense import zeros
+
+    def entry(i, j):
+        return rhs[i, sol] if j == col else M[i, j]
+
+    if det_method == "bird":
+        from .determinant import _det_bird
+        det = _det_bird
+    elif det_method == "laplace":
+        from .determinant import _det_laplace
+        det = _det_laplace
+    elif isinstance(det_method, str):
+        det = lambda matrix: matrix.det(method=det_method)
+    else:
+        det = det_method
+    det_M = det(M)
+    x = zeros(*rhs.shape)
+    for sol in range(rhs.shape[1]):
+        for col in range(rhs.shape[0]):
+            x[col, sol] = det(M.__class__(*M.shape, entry)) / det_M
+    return M.__class__(x)
+
+
+def _solve(M, rhs, method='GJ'):
+    """Solves linear equation where the unique solution exists.
+
+    Parameters
+    ==========
+
+    rhs : Matrix
+        Vector representing the right hand side of the linear equation.
+
+    method : string, optional
+        If set to ``'GJ'`` or ``'GE'``, the Gauss-Jordan elimination will be
+        used, which is implemented in the routine ``gauss_jordan_solve``.
+
+        If set to ``'LU'``, ``LUsolve`` routine will be used.
+
+        If set to ``'QR'``, ``QRsolve`` routine will be used.
+
+        If set to ``'PINV'``, ``pinv_solve`` routine will be used.
+
+        If set to ``'CRAMER'``, ``cramer_solve`` routine will be used.
+
+        It also supports the methods available for special linear systems
+
+        For positive definite systems:
+
+        If set to ``'CH'``, ``cholesky_solve`` routine will be used.
+
+        If set to ``'LDL'``, ``LDLsolve`` routine will be used.
+
+        To use a different method and to compute the solution via the
+        inverse, use a method defined in the .inv() docstring.
+
+    Returns
+    =======
+
+    solutions : Matrix
+        Vector representing the solution.
+
+    Raises
+    ======
+
+    ValueError
+        If there is not a unique solution then a ``ValueError`` will be
+        raised.
+
+        If ``M`` is not square, a ``ValueError`` and a different routine
+        for solving the system will be suggested.
+    """
+
+    if method in ('GJ', 'GE'):
+        try:
+            soln, param = M.gauss_jordan_solve(rhs)
+
+            if param:
+                raise NonInvertibleMatrixError("Matrix det == 0; not invertible. "
+                "Try ``M.gauss_jordan_solve(rhs)`` to obtain a parametric solution.")
+
+        except ValueError:
+            raise NonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+        return soln
+
+    elif method == 'LU':
+        return M.LUsolve(rhs)
+    elif method == 'CH':
+        return M.cholesky_solve(rhs)
+    elif method == 'QR':
+        return M.QRsolve(rhs)
+    elif method == 'LDL':
+        return M.LDLsolve(rhs)
+    elif method == 'PINV':
+        return M.pinv_solve(rhs)
+    elif method == 'CRAMER':
+        return M.cramer_solve(rhs)
+    else:
+        return M.inv(method=method).multiply(rhs)
+
+
+def _solve_least_squares(M, rhs, method='CH'):
+    """Return the least-square fit to the data.
+
+    Parameters
+    ==========
+
+    rhs : Matrix
+        Vector representing the right hand side of the linear equation.
+
+    method : string or boolean, optional
+        If set to ``'CH'``, ``cholesky_solve`` routine will be used.
+
+        If set to ``'LDL'``, ``LDLsolve`` routine will be used.
+
+        If set to ``'QR'``, ``QRsolve`` routine will be used.
+
+        If set to ``'PINV'``, ``pinv_solve`` routine will be used.
+
+        Otherwise, the conjugate of ``M`` will be used to create a system
+        of equations that is passed to ``solve`` along with the hint
+        defined by ``method``.
+
+    Returns
+    =======
+
+    solutions : Matrix
+        Vector representing the solution.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, ones
+    >>> A = Matrix([1, 2, 3])
+    >>> B = Matrix([2, 3, 4])
+    >>> S = Matrix(A.row_join(B))
+    >>> S
+    Matrix([
+    [1, 2],
+    [2, 3],
+    [3, 4]])
+
+    If each line of S represent coefficients of Ax + By
+    and x and y are [2, 3] then S*xy is:
+
+    >>> r = S*Matrix([2, 3]); r
+    Matrix([
+    [ 8],
+    [13],
+    [18]])
+
+    But let's add 1 to the middle value and then solve for the
+    least-squares value of xy:
+
+    >>> xy = S.solve_least_squares(Matrix([8, 14, 18])); xy
+    Matrix([
+    [ 5/3],
+    [10/3]])
+
+    The error is given by S*xy - r:
+
+    >>> S*xy - r
+    Matrix([
+    [1/3],
+    [1/3],
+    [1/3]])
+    >>> _.norm().n(2)
+    0.58
+
+    If a different xy is used, the norm will be higher:
+
+    >>> xy += ones(2, 1)/10
+    >>> (S*xy - r).norm().n(2)
+    1.5
+
+    """
+
+    if method == 'CH':
+        return M.cholesky_solve(rhs)
+    elif method == 'QR':
+        return M.QRsolve(rhs)
+    elif method == 'LDL':
+        return M.LDLsolve(rhs)
+    elif method == 'PINV':
+        return M.pinv_solve(rhs)
+    else:
+        t = M.H
+        return (t * M).solve(t * rhs, method=method)

phi4/lib/python3.10/site-packages/sympy/matrices/sparse.py

@@ -0,0 +1,473 @@
+from collections.abc import Callable
+
+from sympy.core.containers import Dict
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import as_int
+
+from .matrixbase import MatrixBase
+from .repmatrix import MutableRepMatrix, RepMatrix
+
+from .utilities import _iszero
+
+from .decompositions import (
+    _liupc, _row_structure_symbolic_cholesky, _cholesky_sparse,
+    _LDLdecomposition_sparse)
+
+from .solvers import (
+    _lower_triangular_solve_sparse, _upper_triangular_solve_sparse)
+
+
+class SparseRepMatrix(RepMatrix):
+    """
+    A sparse matrix (a matrix with a large number of zero elements).
+
+    Examples
+    ========
+
+    >>> from sympy import SparseMatrix, ones
+    >>> SparseMatrix(2, 2, range(4))
+    Matrix([
+    [0, 1],
+    [2, 3]])
+    >>> SparseMatrix(2, 2, {(1, 1): 2})
+    Matrix([
+    [0, 0],
+    [0, 2]])
+
+    A SparseMatrix can be instantiated from a ragged list of lists:
+
+    >>> SparseMatrix([[1, 2, 3], [1, 2], [1]])
+    Matrix([
+    [1, 2, 3],
+    [1, 2, 0],
+    [1, 0, 0]])
+
+    For safety, one may include the expected size and then an error
+    will be raised if the indices of any element are out of range or
+    (for a flat list) if the total number of elements does not match
+    the expected shape:
+
+    >>> SparseMatrix(2, 2, [1, 2])
+    Traceback (most recent call last):
+    ...
+    ValueError: List length (2) != rows*columns (4)
+
+    Here, an error is not raised because the list is not flat and no
+    element is out of range:
+
+    >>> SparseMatrix(2, 2, [[1, 2]])
+    Matrix([
+    [1, 2],
+    [0, 0]])
+
+    But adding another element to the first (and only) row will cause
+    an error to be raised:
+
+    >>> SparseMatrix(2, 2, [[1, 2, 3]])
+    Traceback (most recent call last):
+    ...
+    ValueError: The location (0, 2) is out of designated range: (1, 1)
+
+    To autosize the matrix, pass None for rows:
+
+    >>> SparseMatrix(None, [[1, 2, 3]])
+    Matrix([[1, 2, 3]])
+    >>> SparseMatrix(None, {(1, 1): 1, (3, 3): 3})
+    Matrix([
+    [0, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 0, 0],
+    [0, 0, 0, 3]])
+
+    Values that are themselves a Matrix are automatically expanded:
+
+    >>> SparseMatrix(4, 4, {(1, 1): ones(2)})
+    Matrix([
+    [0, 0, 0, 0],
+    [0, 1, 1, 0],
+    [0, 1, 1, 0],
+    [0, 0, 0, 0]])
+
+    A ValueError is raised if the expanding matrix tries to overwrite
+    a different element already present:
+
+    >>> SparseMatrix(3, 3, {(0, 0): ones(2), (1, 1): 2})
+    Traceback (most recent call last):
+    ...
+    ValueError: collision at (1, 1)
+
+    See Also
+    ========
+    DenseMatrix
+    MutableSparseMatrix
+    ImmutableSparseMatrix
+    """
+
+    @classmethod
+    def _handle_creation_inputs(cls, *args, **kwargs):
+        if len(args) == 1 and isinstance(args[0], MatrixBase):
+            rows = args[0].rows
+            cols = args[0].cols
+            smat = args[0].todok()
+            return rows, cols, smat
+
+        smat = {}
+        # autosizing
+        if len(args) == 2 and args[0] is None:
+            args = [None, None, args[1]]
+
+        if len(args) == 3:
+            r, c = args[:2]
+            if r is c is None:
+                rows = cols = None
+            elif None in (r, c):
+                raise ValueError(
+                    'Pass rows=None and no cols for autosizing.')
+            else:
+                rows, cols = as_int(args[0]), as_int(args[1])
+
+            if isinstance(args[2], Callable):
+                op = args[2]
+
+                if None in (rows, cols):
+                    raise ValueError(
+                        "{} and {} must be integers for this "
+                        "specification.".format(rows, cols))
+
+                row_indices = [cls._sympify(i) for i in range(rows)]
+                col_indices = [cls._sympify(j) for j in range(cols)]
+
+                for i in row_indices:
+                    for j in col_indices:
+                        value = cls._sympify(op(i, j))
+                        if value != cls.zero:
+                            smat[i, j] = value
+
+                return rows, cols, smat
+
+            elif isinstance(args[2], (dict, Dict)):
+                def update(i, j, v):
+                    # update smat and make sure there are no collisions
+                    if v:
+                        if (i, j) in smat and v != smat[i, j]:
+                            raise ValueError(
+                                "There is a collision at {} for {} and {}."
+                                .format((i, j), v, smat[i, j])
+                            )
+                        smat[i, j] = v
+
+                # manual copy, copy.deepcopy() doesn't work
+                for (r, c), v in args[2].items():
+                    if isinstance(v, MatrixBase):
+                        for (i, j), vv in v.todok().items():
+                            update(r + i, c + j, vv)
+                    elif isinstance(v, (list, tuple)):
+                        _, _, smat = cls._handle_creation_inputs(v, **kwargs)
+                        for i, j in smat:
+                            update(r + i, c + j, smat[i, j])
+                    else:
+                        v = cls._sympify(v)
+                        update(r, c, cls._sympify(v))
+
+            elif is_sequence(args[2]):
+                flat = not any(is_sequence(i) for i in args[2])
+                if not flat:
+                    _, _, smat = \
+                        cls._handle_creation_inputs(args[2], **kwargs)
+                else:
+                    flat_list = args[2]
+                    if len(flat_list) != rows * cols:
+                        raise ValueError(
+                            "The length of the flat list ({}) does not "
+                            "match the specified size ({} * {})."
+                            .format(len(flat_list), rows, cols)
+                        )
+
+                    for i in range(rows):
+                        for j in range(cols):
+                            value = flat_list[i*cols + j]
+                            value = cls._sympify(value)
+                            if value != cls.zero:
+                                smat[i, j] = value
+
+            if rows is None:  # autosizing
+                keys = smat.keys()
+                rows = max(r for r, _ in keys) + 1 if keys else 0
+                cols = max(c for _, c in keys) + 1 if keys else 0
+
+            else:
+                for i, j in smat.keys():
+                    if i and i >= rows or j and j >= cols:
+                        raise ValueError(
+                            "The location {} is out of the designated range"
+                            "[{}, {}]x[{}, {}]"
+                            .format((i, j), 0, rows - 1, 0, cols - 1)
+                        )
+
+            return rows, cols, smat
+
+        elif len(args) == 1 and isinstance(args[0], (list, tuple)):
+            # list of values or lists
+            v = args[0]
+            c = 0
+            for i, row in enumerate(v):
+                if not isinstance(row, (list, tuple)):
+                    row = [row]
+                for j, vv in enumerate(row):
+                    if vv != cls.zero:
+                        smat[i, j] = cls._sympify(vv)
+                c = max(c, len(row))
+            rows = len(v) if c else 0
+            cols = c
+            return rows, cols, smat
+
+        else:
+            # handle full matrix forms with _handle_creation_inputs
+            rows, cols, mat = super()._handle_creation_inputs(*args)
+            for i in range(rows):
+                for j in range(cols):
+                    value = mat[cols*i + j]
+                    if value != cls.zero:
+                        smat[i, j] = value
+
+            return rows, cols, smat
+
+    @property
+    def _smat(self):
+
+        sympy_deprecation_warning(
+            """
+            The private _smat attribute of SparseMatrix is deprecated. Use the
+            .todok() method instead.
+            """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-private-matrix-attributes"
+        )
+
+        return self.todok()
+
+    def _eval_inverse(self, **kwargs):
+        return self.inv(method=kwargs.get('method', 'LDL'),
+                        iszerofunc=kwargs.get('iszerofunc', _iszero),
+                        try_block_diag=kwargs.get('try_block_diag', False))
+
+    def applyfunc(self, f):
+        """Apply a function to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix
+        >>> m = SparseMatrix(2, 2, lambda i, j: i*2+j)
+        >>> m
+        Matrix([
+        [0, 1],
+        [2, 3]])
+        >>> m.applyfunc(lambda i: 2*i)
+        Matrix([
+        [0, 2],
+        [4, 6]])
+
+        """
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        # XXX: This only applies the function to the nonzero elements of the
+        # matrix so is inconsistent with DenseMatrix.applyfunc e.g.
+        #   zeros(2, 2).applyfunc(lambda x: x + 1)
+        dok = {}
+        for k, v in self.todok().items():
+            fv = f(v)
+            if fv != 0:
+                dok[k] = fv
+
+        return self._new(self.rows, self.cols, dok)
+
+    def as_immutable(self):
+        """Returns an Immutable version of this Matrix."""
+        from .immutable import ImmutableSparseMatrix
+        return ImmutableSparseMatrix(self)
+
+    def as_mutable(self):
+        """Returns a mutable version of this matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ImmutableMatrix
+        >>> X = ImmutableMatrix([[1, 2], [3, 4]])
+        >>> Y = X.as_mutable()
+        >>> Y[1, 1] = 5 # Can set values in Y
+        >>> Y
+        Matrix([
+        [1, 2],
+        [3, 5]])
+        """
+        return MutableSparseMatrix(self)
+
+    def col_list(self):
+        """Returns a column-sorted list of non-zero elements of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix
+        >>> a=SparseMatrix(((1, 2), (3, 4)))
+        >>> a
+        Matrix([
+        [1, 2],
+        [3, 4]])
+        >>> a.CL
+        [(0, 0, 1), (1, 0, 3), (0, 1, 2), (1, 1, 4)]
+
+        See Also
+        ========
+
+        sympy.matrices.sparse.SparseMatrix.row_list
+        """
+        return [tuple(k + (self[k],)) for k in sorted(self.todok().keys(), key=lambda k: list(reversed(k)))]
+
+    def nnz(self):
+        """Returns the number of non-zero elements in Matrix."""
+        return len(self.todok())
+
+    def row_list(self):
+        """Returns a row-sorted list of non-zero elements of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix
+        >>> a = SparseMatrix(((1, 2), (3, 4)))
+        >>> a
+        Matrix([
+        [1, 2],
+        [3, 4]])
+        >>> a.RL
+        [(0, 0, 1), (0, 1, 2), (1, 0, 3), (1, 1, 4)]
+
+        See Also
+        ========
+
+        sympy.matrices.sparse.SparseMatrix.col_list
+        """
+        return [tuple(k + (self[k],)) for k in
+            sorted(self.todok().keys(), key=list)]
+
+    def scalar_multiply(self, scalar):
+        "Scalar element-wise multiplication"
+        return scalar * self
+
+    def solve_least_squares(self, rhs, method='LDL'):
+        """Return the least-square fit to the data.
+
+        By default the cholesky_solve routine is used (method='CH'); other
+        methods of matrix inversion can be used. To find out which are
+        available, see the docstring of the .inv() method.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix, Matrix, ones
+        >>> A = Matrix([1, 2, 3])
+        >>> B = Matrix([2, 3, 4])
+        >>> S = SparseMatrix(A.row_join(B))
+        >>> S
+        Matrix([
+        [1, 2],
+        [2, 3],
+        [3, 4]])
+
+        If each line of S represent coefficients of Ax + By
+        and x and y are [2, 3] then S*xy is:
+
+        >>> r = S*Matrix([2, 3]); r
+        Matrix([
+        [ 8],
+        [13],
+        [18]])
+
+        But let's add 1 to the middle value and then solve for the
+        least-squares value of xy:
+
+        >>> xy = S.solve_least_squares(Matrix([8, 14, 18])); xy
+        Matrix([
+        [ 5/3],
+        [10/3]])
+
+        The error is given by S*xy - r:
+
+        >>> S*xy - r
+        Matrix([
+        [1/3],
+        [1/3],
+        [1/3]])
+        >>> _.norm().n(2)
+        0.58
+
+        If a different xy is used, the norm will be higher:
+
+        >>> xy += ones(2, 1)/10
+        >>> (S*xy - r).norm().n(2)
+        1.5
+
+        """
+        t = self.T
+        return (t*self).inv(method=method)*t*rhs
+
+    def solve(self, rhs, method='LDL'):
+        """Return solution to self*soln = rhs using given inversion method.
+
+        For a list of possible inversion methods, see the .inv() docstring.
+        """
+        if not self.is_square:
+            if self.rows < self.cols:
+                raise ValueError('Under-determined system.')
+            elif self.rows > self.cols:
+                raise ValueError('For over-determined system, M, having '
+                    'more rows than columns, try M.solve_least_squares(rhs).')
+        else:
+            return self.inv(method=method).multiply(rhs)
+
+    RL = property(row_list, None, None, "Alternate faster representation")
+    CL = property(col_list, None, None, "Alternate faster representation")
+
+    def liupc(self):
+        return _liupc(self)
+
+    def row_structure_symbolic_cholesky(self):
+        return _row_structure_symbolic_cholesky(self)
+
+    def cholesky(self, hermitian=True):
+        return _cholesky_sparse(self, hermitian=hermitian)
+
+    def LDLdecomposition(self, hermitian=True):
+        return _LDLdecomposition_sparse(self, hermitian=hermitian)
+
+    def lower_triangular_solve(self, rhs):
+        return _lower_triangular_solve_sparse(self, rhs)
+
+    def upper_triangular_solve(self, rhs):
+        return _upper_triangular_solve_sparse(self, rhs)
+
+    liupc.__doc__                           = _liupc.__doc__
+    row_structure_symbolic_cholesky.__doc__ = _row_structure_symbolic_cholesky.__doc__
+    cholesky.__doc__                        = _cholesky_sparse.__doc__
+    LDLdecomposition.__doc__                = _LDLdecomposition_sparse.__doc__
+    lower_triangular_solve.__doc__          = lower_triangular_solve.__doc__
+    upper_triangular_solve.__doc__          = upper_triangular_solve.__doc__
+
+
+class MutableSparseMatrix(SparseRepMatrix, MutableRepMatrix):
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        rows, cols, smat = cls._handle_creation_inputs(*args, **kwargs)
+
+        rep = cls._smat_to_DomainMatrix(rows, cols, smat)
+
+        return cls._fromrep(rep)
+
+
+SparseMatrix = MutableSparseMatrix

phi4/lib/python3.10/site-packages/sympy/matrices/subspaces.py

@@ -0,0 +1,174 @@
+from .utilities import _iszero
+
+
+def _columnspace(M, simplify=False):
+    """Returns a list of vectors (Matrix objects) that span columnspace of ``M``
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6])
+    >>> M
+    Matrix([
+    [ 1,  3, 0],
+    [-2, -6, 0],
+    [ 3,  9, 6]])
+    >>> M.columnspace()
+    [Matrix([
+    [ 1],
+    [-2],
+    [ 3]]), Matrix([
+    [0],
+    [0],
+    [6]])]
+
+    See Also
+    ========
+
+    nullspace
+    rowspace
+    """
+
+    reduced, pivots = M.echelon_form(simplify=simplify, with_pivots=True)
+
+    return [M.col(i) for i in pivots]
+
+
+def _nullspace(M, simplify=False, iszerofunc=_iszero):
+    """Returns list of vectors (Matrix objects) that span nullspace of ``M``
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6])
+    >>> M
+    Matrix([
+    [ 1,  3, 0],
+    [-2, -6, 0],
+    [ 3,  9, 6]])
+    >>> M.nullspace()
+    [Matrix([
+    [-3],
+    [ 1],
+    [ 0]])]
+
+    See Also
+    ========
+
+    columnspace
+    rowspace
+    """
+
+    reduced, pivots = M.rref(iszerofunc=iszerofunc, simplify=simplify)
+
+    free_vars = [i for i in range(M.cols) if i not in pivots]
+    basis     = []
+
+    for free_var in free_vars:
+        # for each free variable, we will set it to 1 and all others
+        # to 0.  Then, we will use back substitution to solve the system
+        vec           = [M.zero] * M.cols
+        vec[free_var] = M.one
+
+        for piv_row, piv_col in enumerate(pivots):
+            vec[piv_col] -= reduced[piv_row, free_var]
+
+        basis.append(vec)
+
+    return [M._new(M.cols, 1, b) for b in basis]
+
+
+def _rowspace(M, simplify=False):
+    """Returns a list of vectors that span the row space of ``M``.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6])
+    >>> M
+    Matrix([
+    [ 1,  3, 0],
+    [-2, -6, 0],
+    [ 3,  9, 6]])
+    >>> M.rowspace()
+    [Matrix([[1, 3, 0]]), Matrix([[0, 0, 6]])]
+    """
+
+    reduced, pivots = M.echelon_form(simplify=simplify, with_pivots=True)
+
+    return [reduced.row(i) for i in range(len(pivots))]
+
+
+def _orthogonalize(cls, *vecs, normalize=False, rankcheck=False):
+    """Apply the Gram-Schmidt orthogonalization procedure
+    to vectors supplied in ``vecs``.
+
+    Parameters
+    ==========
+
+    vecs
+        vectors to be made orthogonal
+
+    normalize : bool
+        If ``True``, return an orthonormal basis.
+
+    rankcheck : bool
+        If ``True``, the computation does not stop when encountering
+        linearly dependent vectors.
+
+        If ``False``, it will raise ``ValueError`` when any zero
+        or linearly dependent vectors are found.
+
+    Returns
+    =======
+
+    list
+        List of orthogonal (or orthonormal) basis vectors.
+
+    Examples
+    ========
+
+    >>> from sympy import I, Matrix
+    >>> v = [Matrix([1, I]), Matrix([1, -I])]
+    >>> Matrix.orthogonalize(*v)
+    [Matrix([
+    [1],
+    [I]]), Matrix([
+    [ 1],
+    [-I]])]
+
+    See Also
+    ========
+
+    MatrixBase.QRdecomposition
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process
+    """
+    from .decompositions import _QRdecomposition_optional
+
+    if not vecs:
+        return []
+
+    all_row_vecs = (vecs[0].rows == 1)
+
+    vecs = [x.vec() for x in vecs]
+    M = cls.hstack(*vecs)
+    Q, R = _QRdecomposition_optional(M, normalize=normalize)
+
+    if rankcheck and Q.cols < len(vecs):
+        raise ValueError("GramSchmidt: vector set not linearly independent")
+
+    ret = []
+    for i in range(Q.cols):
+        if all_row_vecs:
+            col = cls(Q[:, i].T)
+        else:
+            col = cls(Q[:, i])
+        ret.append(col)
+    return ret