Add files using upload-large-folder tool

.venv/lib/python3.13/site-packages/sympy/assumptions/predicates/matrices.py

@@ -0,0 +1,511 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+class SquarePredicate(Predicate):
+    """
+    Square matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.square(x)`` is true iff ``x`` is a square matrix. A square matrix
+    is a matrix with the same number of rows and columns.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('X', 2, 3)
+    >>> ask(Q.square(X))
+    True
+    >>> ask(Q.square(Y))
+    False
+    >>> ask(Q.square(ZeroMatrix(3, 3)))
+    True
+    >>> ask(Q.square(Identity(3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_matrix
+
+    """
+    name = 'square'
+    handler = Dispatcher("SquareHandler", doc="Handler for Q.square.")
+
+
+class SymmetricPredicate(Predicate):
+    """
+    Symmetric matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.symmetric(x)`` is true iff ``x`` is a square matrix and is equal to
+    its transpose. Every square diagonal matrix is a symmetric matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z))
+    True
+    >>> ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z))
+    True
+    >>> ask(Q.symmetric(Y))
+    False
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Symmetric_matrix
+
+    """
+    # TODO: Add handlers to make these keys work with
+    # actual matrices and add more examples in the docstring.
+    name = 'symmetric'
+    handler = Dispatcher("SymmetricHandler", doc="Handler for Q.symmetric.")
+
+
+class InvertiblePredicate(Predicate):
+    """
+    Invertible matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.invertible(x)`` is true iff ``x`` is an invertible matrix.
+    A square matrix is called invertible only if its determinant is 0.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.invertible(X*Y), Q.invertible(X))
+    False
+    >>> ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z))
+    True
+    >>> ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Invertible_matrix
+
+    """
+    name = 'invertible'
+    handler = Dispatcher("InvertibleHandler", doc="Handler for Q.invertible.")
+
+
+class OrthogonalPredicate(Predicate):
+    """
+    Orthogonal matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.orthogonal(x)`` is true iff ``x`` is an orthogonal matrix.
+    A square matrix ``M`` is an orthogonal matrix if it satisfies
+    ``M^TM = MM^T = I`` where ``M^T`` is the transpose matrix of
+    ``M`` and ``I`` is an identity matrix. Note that an orthogonal
+    matrix is necessarily invertible.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.orthogonal(Y))
+    False
+    >>> ask(Q.orthogonal(X*Z*X), Q.orthogonal(X) & Q.orthogonal(Z))
+    True
+    >>> ask(Q.orthogonal(Identity(3)))
+    True
+    >>> ask(Q.invertible(X), Q.orthogonal(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Orthogonal_matrix
+
+    """
+    name = 'orthogonal'
+    handler = Dispatcher("OrthogonalHandler", doc="Handler for key 'orthogonal'.")
+
+
+class UnitaryPredicate(Predicate):
+    """
+    Unitary matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.unitary(x)`` is true iff ``x`` is a unitary matrix.
+    Unitary matrix is an analogue to orthogonal matrix. A square
+    matrix ``M`` with complex elements is unitary if :math:``M^TM = MM^T= I``
+    where :math:``M^T`` is the conjugate transpose matrix of ``M``.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.unitary(Y))
+    False
+    >>> ask(Q.unitary(X*Z*X), Q.unitary(X) & Q.unitary(Z))
+    True
+    >>> ask(Q.unitary(Identity(3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Unitary_matrix
+
+    """
+    name = 'unitary'
+    handler = Dispatcher("UnitaryHandler", doc="Handler for key 'unitary'.")
+
+
+class FullRankPredicate(Predicate):
+    """
+    Fullrank matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.fullrank(x)`` is true iff ``x`` is a full rank matrix.
+    A matrix is full rank if all rows and columns of the matrix
+    are linearly independent. A square matrix is full rank iff
+    its determinant is nonzero.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> ask(Q.fullrank(X.T), Q.fullrank(X))
+    True
+    >>> ask(Q.fullrank(ZeroMatrix(3, 3)))
+    False
+    >>> ask(Q.fullrank(Identity(3)))
+    True
+
+    """
+    name = 'fullrank'
+    handler = Dispatcher("FullRankHandler", doc="Handler for key 'fullrank'.")
+
+
+class PositiveDefinitePredicate(Predicate):
+    r"""
+    Positive definite matrix predicate.
+
+    Explanation
+    ===========
+
+    If $M$ is a :math:`n \times n` symmetric real matrix, it is said
+    to be positive definite if :math:`Z^TMZ` is positive for
+    every non-zero column vector $Z$ of $n$ real numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.positive_definite(Y))
+    False
+    >>> ask(Q.positive_definite(Identity(3)))
+    True
+    >>> ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
+    ...     Q.positive_definite(Z))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Positive-definite_matrix
+
+    """
+    name = "positive_definite"
+    handler = Dispatcher("PositiveDefiniteHandler", doc="Handler for key 'positive_definite'.")
+
+
+class UpperTriangularPredicate(Predicate):
+    """
+    Upper triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A matrix $M$ is called upper triangular matrix if :math:`M_{ij}=0`
+    for :math:`i<j`.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, ZeroMatrix, Identity
+    >>> ask(Q.upper_triangular(Identity(3)))
+    True
+    >>> ask(Q.upper_triangular(ZeroMatrix(3, 3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/UpperTriangularMatrix.html
+
+    """
+    name = "upper_triangular"
+    handler = Dispatcher("UpperTriangularHandler", doc="Handler for key 'upper_triangular'.")
+
+
+class LowerTriangularPredicate(Predicate):
+    """
+    Lower triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A matrix $M$ is called lower triangular matrix if :math:`M_{ij}=0`
+    for :math:`i>j`.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, ZeroMatrix, Identity
+    >>> ask(Q.lower_triangular(Identity(3)))
+    True
+    >>> ask(Q.lower_triangular(ZeroMatrix(3, 3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/LowerTriangularMatrix.html
+
+    """
+    name = "lower_triangular"
+    handler = Dispatcher("LowerTriangularHandler", doc="Handler for key 'lower_triangular'.")
+
+
+class DiagonalPredicate(Predicate):
+    """
+    Diagonal matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.diagonal(x)`` is true iff ``x`` is a diagonal matrix. A diagonal
+    matrix is a matrix in which the entries outside the main diagonal
+    are all zero.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> ask(Q.diagonal(ZeroMatrix(3, 3)))
+    True
+    >>> ask(Q.diagonal(X), Q.lower_triangular(X) &
+    ...     Q.upper_triangular(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Diagonal_matrix
+
+    """
+    name = "diagonal"
+    handler = Dispatcher("DiagonalHandler", doc="Handler for key 'diagonal'.")
+
+
+class IntegerElementsPredicate(Predicate):
+    """
+    Integer elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.integer_elements(x)`` is true iff all the elements of ``x``
+    are integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.integer(X[1, 2]), Q.integer_elements(X))
+    True
+
+    """
+    name = "integer_elements"
+    handler = Dispatcher("IntegerElementsHandler", doc="Handler for key 'integer_elements'.")
+
+
+class RealElementsPredicate(Predicate):
+    """
+    Real elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.real_elements(x)`` is true iff all the elements of ``x``
+    are real numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.real(X[1, 2]), Q.real_elements(X))
+    True
+
+    """
+    name = "real_elements"
+    handler = Dispatcher("RealElementsHandler", doc="Handler for key 'real_elements'.")
+
+
+class ComplexElementsPredicate(Predicate):
+    """
+    Complex elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.complex_elements(x)`` is true iff all the elements of ``x``
+    are complex numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.complex(X[1, 2]), Q.complex_elements(X))
+    True
+    >>> ask(Q.complex_elements(X), Q.integer_elements(X))
+    True
+
+    """
+    name = "complex_elements"
+    handler = Dispatcher("ComplexElementsHandler", doc="Handler for key 'complex_elements'.")
+
+
+class SingularPredicate(Predicate):
+    """
+    Singular matrix predicate.
+
+    A matrix is singular iff the value of its determinant is 0.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.singular(X), Q.invertible(X))
+    False
+    >>> ask(Q.singular(X), ~Q.invertible(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/SingularMatrix.html
+
+    """
+    name = "singular"
+    handler = Dispatcher("SingularHandler", doc="Predicate fore key 'singular'.")
+
+
+class NormalPredicate(Predicate):
+    """
+    Normal matrix predicate.
+
+    A matrix is normal if it commutes with its conjugate transpose.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.normal(X), Q.unitary(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Normal_matrix
+
+    """
+    name = "normal"
+    handler = Dispatcher("NormalHandler", doc="Predicate fore key 'normal'.")
+
+
+class TriangularPredicate(Predicate):
+    """
+    Triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.triangular(X)`` is true if ``X`` is one that is either lower
+    triangular or upper triangular.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.triangular(X), Q.upper_triangular(X))
+    True
+    >>> ask(Q.triangular(X), Q.lower_triangular(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Triangular_matrix
+
+    """
+    name = "triangular"
+    handler = Dispatcher("TriangularHandler", doc="Predicate fore key 'triangular'.")
+
+
+class UnitTriangularPredicate(Predicate):
+    """
+    Unit triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A unit triangular matrix is a triangular matrix with 1s
+    on the diagonal.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.triangular(X), Q.unit_triangular(X))
+    True
+
+    """
+    name = "unit_triangular"
+    handler = Dispatcher("UnitTriangularHandler", doc="Predicate fore key 'unit_triangular'.")

.venv/lib/python3.13/site-packages/sympy/assumptions/predicates/order.py

@@ -0,0 +1,390 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class NegativePredicate(Predicate):
+    r"""
+    Negative number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.negative(x)`` is true iff ``x`` is a real number and :math:`x < 0`, that is,
+    it is in the interval :math:`(-\infty, 0)`.  Note in particular that negative
+    infinity is not negative.
+
+    A few important facts about negative numbers:
+
+    - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same
+        thing. ``~Q.negative(x)`` simply means that ``x`` is not negative,
+        whereas ``Q.nonnegative(x)`` means that ``x`` is real and not
+        negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to
+        ``Q.zero(x) | Q.positive(x)``.  So for example, ``~Q.negative(I)`` is
+        true, whereas ``Q.nonnegative(I)`` is false.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I
+    >>> x = symbols('x')
+    >>> ask(Q.negative(x), Q.real(x) & ~Q.positive(x) & ~Q.zero(x))
+    True
+    >>> ask(Q.negative(-1))
+    True
+    >>> ask(Q.nonnegative(I))
+    False
+    >>> ask(~Q.negative(I))
+    True
+
+    """
+    name = 'negative'
+    handler = Dispatcher(
+        "NegativeHandler",
+        doc=("Handler for Q.negative. Test that an expression is strictly less"
+        " than zero.")
+    )
+
+
+class NonNegativePredicate(Predicate):
+    """
+    Nonnegative real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonnegative(x))`` is true iff ``x`` belongs to the set of
+    positive numbers including zero.
+
+    - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same
+        thing. ``~Q.negative(x)`` simply means that ``x`` is not negative,
+        whereas ``Q.nonnegative(x)`` means that ``x`` is real and not
+        negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to
+        ``Q.zero(x) | Q.positive(x)``.  So for example, ``~Q.negative(I)`` is
+        true, whereas ``Q.nonnegative(I)`` is false.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+    >>> ask(Q.nonnegative(1))
+    True
+    >>> ask(Q.nonnegative(0))
+    True
+    >>> ask(Q.nonnegative(-1))
+    False
+    >>> ask(Q.nonnegative(I))
+    False
+    >>> ask(Q.nonnegative(-I))
+    False
+
+    """
+    name = 'nonnegative'
+    handler = Dispatcher(
+        "NonNegativeHandler",
+        doc=("Handler for Q.nonnegative.")
+    )
+
+
+class NonZeroPredicate(Predicate):
+    """
+    Nonzero real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonzero(x))`` is true iff ``x`` is real and ``x`` is not zero.  Note in
+    particular that ``Q.nonzero(x)`` is false if ``x`` is not real.  Use
+    ``~Q.zero(x)`` if you want the negation of being zero without any real
+    assumptions.
+
+    A few important facts about nonzero numbers:
+
+    - ``Q.nonzero`` is logically equivalent to ``Q.positive | Q.negative``.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I, oo
+    >>> x = symbols('x')
+    >>> print(ask(Q.nonzero(x), ~Q.zero(x)))
+    None
+    >>> ask(Q.nonzero(x), Q.positive(x))
+    True
+    >>> ask(Q.nonzero(x), Q.zero(x))
+    False
+    >>> ask(Q.nonzero(0))
+    False
+    >>> ask(Q.nonzero(I))
+    False
+    >>> ask(~Q.zero(I))
+    True
+    >>> ask(Q.nonzero(oo))
+    False
+
+    """
+    name = 'nonzero'
+    handler = Dispatcher(
+        "NonZeroHandler",
+        doc=("Handler for key 'nonzero'. Test that an expression is not identically"
+        " zero.")
+    )
+
+
+class ZeroPredicate(Predicate):
+    """
+    Zero number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.zero(x))`` is true iff the value of ``x`` is zero.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, oo, symbols
+    >>> x, y = symbols('x, y')
+    >>> ask(Q.zero(0))
+    True
+    >>> ask(Q.zero(1/oo))
+    True
+    >>> print(ask(Q.zero(0*oo)))
+    None
+    >>> ask(Q.zero(1))
+    False
+    >>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y))
+    True
+
+    """
+    name = 'zero'
+    handler = Dispatcher(
+        "ZeroHandler",
+        doc="Handler for key 'zero'."
+    )
+
+
+class NonPositivePredicate(Predicate):
+    """
+    Nonpositive real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonpositive(x))`` is true iff ``x`` belongs to the set of
+    negative numbers including zero.
+
+    - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same
+        thing. ``~Q.positive(x)`` simply means that ``x`` is not positive,
+        whereas ``Q.nonpositive(x)`` means that ``x`` is real and not
+        positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to
+        `Q.negative(x) | Q.zero(x)``.  So for example, ``~Q.positive(I)`` is
+        true, whereas ``Q.nonpositive(I)`` is false.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+
+    >>> ask(Q.nonpositive(-1))
+    True
+    >>> ask(Q.nonpositive(0))
+    True
+    >>> ask(Q.nonpositive(1))
+    False
+    >>> ask(Q.nonpositive(I))
+    False
+    >>> ask(Q.nonpositive(-I))
+    False
+
+    """
+    name = 'nonpositive'
+    handler = Dispatcher(
+        "NonPositiveHandler",
+        doc="Handler for key 'nonpositive'."
+    )
+
+
+class PositivePredicate(Predicate):
+    r"""
+    Positive real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.positive(x)`` is true iff ``x`` is real and `x > 0`, that is if ``x``
+    is in the interval `(0, \infty)`.  In particular, infinity is not
+    positive.
+
+    A few important facts about positive numbers:
+
+    - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same
+        thing. ``~Q.positive(x)`` simply means that ``x`` is not positive,
+        whereas ``Q.nonpositive(x)`` means that ``x`` is real and not
+        positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to
+        `Q.negative(x) | Q.zero(x)``.  So for example, ``~Q.positive(I)`` is
+        true, whereas ``Q.nonpositive(I)`` is false.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I
+    >>> x = symbols('x')
+    >>> ask(Q.positive(x), Q.real(x) & ~Q.negative(x) & ~Q.zero(x))
+    True
+    >>> ask(Q.positive(1))
+    True
+    >>> ask(Q.nonpositive(I))
+    False
+    >>> ask(~Q.positive(I))
+    True
+
+    """
+    name = 'positive'
+    handler = Dispatcher(
+        "PositiveHandler",
+        doc=("Handler for key 'positive'. Test that an expression is strictly"
+        " greater than zero.")
+    )
+
+
+class ExtendedPositivePredicate(Predicate):
+    r"""
+    Positive extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_positive(x)`` is true iff ``x`` is extended real and
+    `x > 0`, that is if ``x`` is in the interval `(0, \infty]`.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_positive(1))
+    True
+    >>> ask(Q.extended_positive(oo))
+    True
+    >>> ask(Q.extended_positive(I))
+    False
+
+    """
+    name = 'extended_positive'
+    handler = Dispatcher("ExtendedPositiveHandler")
+
+
+class ExtendedNegativePredicate(Predicate):
+    r"""
+    Negative extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_negative(x)`` is true iff ``x`` is extended real and
+    `x < 0`, that is if ``x`` is in the interval `[-\infty, 0)`.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_negative(-1))
+    True
+    >>> ask(Q.extended_negative(-oo))
+    True
+    >>> ask(Q.extended_negative(-I))
+    False
+
+    """
+    name = 'extended_negative'
+    handler = Dispatcher("ExtendedNegativeHandler")
+
+
+class ExtendedNonZeroPredicate(Predicate):
+    """
+    Nonzero extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonzero(x))`` is true iff ``x`` is extended real and
+    ``x`` is not zero.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonzero(-1))
+    True
+    >>> ask(Q.extended_nonzero(oo))
+    True
+    >>> ask(Q.extended_nonzero(I))
+    False
+
+    """
+    name = 'extended_nonzero'
+    handler = Dispatcher("ExtendedNonZeroHandler")
+
+
+class ExtendedNonPositivePredicate(Predicate):
+    """
+    Nonpositive extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonpositive(x))`` is true iff ``x`` is extended real and
+    ``x`` is not positive.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonpositive(-1))
+    True
+    >>> ask(Q.extended_nonpositive(oo))
+    False
+    >>> ask(Q.extended_nonpositive(0))
+    True
+    >>> ask(Q.extended_nonpositive(I))
+    False
+
+    """
+    name = 'extended_nonpositive'
+    handler = Dispatcher("ExtendedNonPositiveHandler")
+
+
+class ExtendedNonNegativePredicate(Predicate):
+    """
+    Nonnegative extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonnegative(x))`` is true iff ``x`` is extended real and
+    ``x`` is not negative.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonnegative(-1))
+    False
+    >>> ask(Q.extended_nonnegative(oo))
+    True
+    >>> ask(Q.extended_nonnegative(0))
+    True
+    >>> ask(Q.extended_nonnegative(I))
+    False
+
+    """
+    name = 'extended_nonnegative'
+    handler = Dispatcher("ExtendedNonNegativeHandler")

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_abstract_nodes.py

@@ -0,0 +1,14 @@
+from sympy.core.symbol import symbols
+from sympy.codegen.abstract_nodes import List
+
+
+def test_List():
+    l = List(2, 3, 4)
+    assert l == List(2, 3, 4)
+    assert str(l) == "[2, 3, 4]"
+    x, y, z = symbols('x y z')
+    l = List(x**2,y**3,z**4)
+    # contrary to python's built-in list, we can call e.g. "replace" on List.
+    m = l.replace(lambda arg: arg.is_Pow and arg.exp>2, lambda p: p.base-p.exp)
+    assert m == [x**2, y-3, z-4]
+    hash(m)

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_algorithms.py

@@ -0,0 +1,180 @@
+import tempfile
+from sympy import log, Min, Max, sqrt
+from sympy.core.numbers import Float
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.elementary.trigonometric import cos
+from sympy.codegen.ast import Assignment, Raise, RuntimeError_, QuotedString
+from sympy.codegen.algorithms import newtons_method, newtons_method_function
+from sympy.codegen.cfunctions import expm1
+from sympy.codegen.fnodes import bind_C
+from sympy.codegen.futils import render_as_module as f_module
+from sympy.codegen.pyutils import render_as_module as py_module
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.utilities._compilation import compile_link_import_strings, has_c, has_fortran
+from sympy.utilities._compilation.util import may_xfail
+from sympy.testing.pytest import skip, raises, skip_under_pyodide
+
+cython = import_module('cython')
+wurlitzer = import_module('wurlitzer')
+
+def test_newtons_method():
+    x, dx, atol = symbols('x dx atol')
+    expr = cos(x) - x**3
+    algo = newtons_method(expr, x, atol, dx)
+    assert algo.has(Assignment(dx, -expr/expr.diff(x)))
+
+
+@may_xfail
+def test_newtons_method_function__ccode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x)
+
+    if not cython:
+        skip("cython not installed.")
+    if not has_c():
+        skip("No C compiler found.")
+
+    compile_kw = {"std": 'c99'}
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton.c', ('#include <math.h>\n'
+                          '#include <stdio.h>\n') + ccode(func)),
+            ('_newton.pyx', ("#cython: language_level={}\n".format("3") +
+                             "cdef extern double newton(double)\n"
+                             "def py_newton(x):\n"
+                             "    return newton(x)\n"))
+        ], build_dir=folder, compile_kwargs=compile_kw)
+        assert abs(mod.py_newton(0.5) - 0.865474033102) < 1e-12
+
+
+@may_xfail
+def test_newtons_method_function__fcode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x, attrs=[bind_C(name='newton')])
+
+    if not cython:
+        skip("cython not installed.")
+    if not has_fortran():
+        skip("No Fortran compiler found.")
+
+    f_mod = f_module([func], 'mod_newton')
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton.f90', f_mod),
+            ('_newton.pyx', ("#cython: language_level={}\n".format("3") +
+                             "cdef extern double newton(double*)\n"
+                             "def py_newton(double x):\n"
+                             "    return newton(&x)\n"))
+        ], build_dir=folder)
+        assert abs(mod.py_newton(0.5) - 0.865474033102) < 1e-12
+
+
+def test_newtons_method_function__pycode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x)
+    py_mod = py_module(func)
+    namespace = {}
+    exec(py_mod, namespace, namespace)
+    res = eval('newton(0.5)', namespace)
+    assert abs(res - 0.865474033102) < 1e-12
+
+
+@may_xfail
+@skip_under_pyodide("Emscripten does not support process spawning")
+def test_newtons_method_function__ccode_parameters():
+    args = x, A, k, p = symbols('x A k p')
+    expr = A*cos(k*x) - p*x**3
+    raises(ValueError, lambda: newtons_method_function(expr, x))
+    use_wurlitzer = wurlitzer
+
+    func = newtons_method_function(expr, x, args, debug=use_wurlitzer)
+
+    if not has_c():
+        skip("No C compiler found.")
+    if not cython:
+        skip("cython not installed.")
+
+    compile_kw = {"std": 'c99'}
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton_par.c', ('#include <math.h>\n'
+                          '#include <stdio.h>\n') + ccode(func)),
+            ('_newton_par.pyx', ("#cython: language_level={}\n".format("3") +
+                                 "cdef extern double newton(double, double, double, double)\n"
+                             "def py_newton(x, A=1, k=1, p=1):\n"
+                             "    return newton(x, A, k, p)\n"))
+        ], compile_kwargs=compile_kw, build_dir=folder)
+
+        if use_wurlitzer:
+            with wurlitzer.pipes() as (out, err):
+                result = mod.py_newton(0.5)
+        else:
+            result = mod.py_newton(0.5)
+
+        assert abs(result - 0.865474033102) < 1e-12
+
+        if not use_wurlitzer:
+            skip("C-level output only tested when package 'wurlitzer' is available.")
+
+        out, err = out.read(), err.read()
+        assert err == ''
+        assert out == """\
+x=         0.5
+x=      1.1121 d_x=     0.61214
+x=     0.90967 d_x=    -0.20247
+x=     0.86726 d_x=   -0.042409
+x=     0.86548 d_x=  -0.0017867
+x=     0.86547 d_x= -3.1022e-06
+x=     0.86547 d_x= -9.3421e-12
+x=     0.86547 d_x=  3.6902e-17
+"""  # try to run tests with LC_ALL=C if this assertion fails
+
+
+def test_newtons_method_function__rtol_cse_nan():
+    a, b, c, N_geo, N_tot = symbols('a b c N_geo N_tot', real=True, nonnegative=True)
+    i = Symbol('i', integer=True, nonnegative=True)
+    N_ari = N_tot - N_geo - 1
+    delta_ari = (c-b)/N_ari
+    ln_delta_geo = log(b) + log(-expm1((log(a)-log(b))/N_geo))
+    eqb_log = ln_delta_geo - log(delta_ari)
+
+    def _clamp(low, expr, high):
+        return Min(Max(low, expr), high)
+
+    meth_kw = {
+        'clamped_newton': {'delta_fn': lambda e, x: _clamp(
+            (sqrt(a*x)-x)*0.99,
+            -e/e.diff(x),
+            (sqrt(c*x)-x)*0.99
+        )},
+        'halley': {'delta_fn': lambda e, x: (-2*(e*e.diff(x))/(2*e.diff(x)**2 - e*e.diff(x, 2)))},
+        'halley_alt': {'delta_fn': lambda e, x: (-e/e.diff(x)/(1-e/e.diff(x)*e.diff(x,2)/2/e.diff(x)))},
+    }
+    args = eqb_log, b
+    for use_cse in [False, True]:
+        kwargs = {
+            'params': (b, a, c, N_geo, N_tot), 'itermax': 60, 'debug': True, 'cse': use_cse,
+            'counter': i, 'atol': 1e-100, 'rtol': 2e-16, 'bounds': (a,c),
+            'handle_nan': Raise(RuntimeError_(QuotedString("encountered NaN.")))
+        }
+        func = {k: newtons_method_function(*args, func_name=f"{k}_b", **dict(kwargs, **kw)) for k, kw in meth_kw.items()}
+        py_mod = {k: py_module(v) for k, v in func.items()}
+        namespace = {}
+        root_find_b = {}
+        for k, v in py_mod.items():
+            ns = namespace[k] = {}
+            exec(v, ns, ns)
+            root_find_b[k] = ns[f'{k}_b']
+        ref = Float('13.2261515064168768938151923226496')
+        reftol = {'clamped_newton': 2e-16, 'halley': 2e-16, 'halley_alt': 3e-16}
+        guess = 4.0
+        for meth, func in root_find_b.items():
+            result = func(guess, 1e-2, 1e2, 50, 100)
+            req = ref*reftol[meth]
+            if use_cse:
+                req *= 2
+            assert abs(result - ref) < req

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_applications.py

@@ -0,0 +1,58 @@
+# This file contains tests that exercise multiple AST nodes
+
+import tempfile
+
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.utilities._compilation import compile_link_import_strings, has_c
+from sympy.utilities._compilation.util import may_xfail
+from sympy.testing.pytest import skip, skip_under_pyodide
+from sympy.codegen.ast import (
+    FunctionDefinition, FunctionPrototype, Variable, Pointer, real, Assignment,
+    integer, CodeBlock, While
+)
+from sympy.codegen.cnodes import void, PreIncrement
+from sympy.codegen.cutils import render_as_source_file
+
+cython = import_module('cython')
+np = import_module('numpy')
+
+def _mk_func1():
+    declars = n, inp, out = Variable('n', integer), Pointer('inp', real), Pointer('out', real)
+    i = Variable('i', integer)
+    whl = While(i<n, [Assignment(out[i], inp[i]), PreIncrement(i)])
+    body = CodeBlock(i.as_Declaration(value=0), whl)
+    return FunctionDefinition(void, 'our_test_function', declars, body)
+
+
+def _render_compile_import(funcdef, build_dir):
+    code_str = render_as_source_file(funcdef, settings={"contract": False})
+    declar = ccode(FunctionPrototype.from_FunctionDefinition(funcdef))
+    return compile_link_import_strings([
+        ('our_test_func.c', code_str),
+        ('_our_test_func.pyx', ("#cython: language_level={}\n".format("3") +
+                                "cdef extern {declar}\n"
+                                "def _{fname}({typ}[:] inp, {typ}[:] out):\n"
+                                "    {fname}(inp.size, &inp[0], &out[0])").format(
+                                    declar=declar, fname=funcdef.name, typ='double'
+                                ))
+    ], build_dir=build_dir)
+
+
+@may_xfail
+@skip_under_pyodide("Emscripten does not support process spawning")
+def test_copying_function():
+    if not np:
+        skip("numpy not installed.")
+    if not has_c():
+        skip("No C compiler found.")
+    if not cython:
+        skip("Cython not found.")
+
+    info = None
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = _render_compile_import(_mk_func1(), build_dir=folder)
+        inp = np.arange(10.0)
+        out = np.empty_like(inp)
+        mod._our_test_function(inp, out)
+        assert np.allclose(inp, out)

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_approximations.py

@@ -0,0 +1,53 @@
+import math
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.codegen.rewriting import optimize
+from sympy.codegen.approximations import SumApprox, SeriesApprox
+
+
+def test_SumApprox_trivial():
+    x = symbols('x')
+    expr1 = 1 + x
+    sum_approx = SumApprox(bounds={x: (-1e-20, 1e-20)}, reltol=1e-16)
+    apx1 = optimize(expr1, [sum_approx])
+    assert apx1 - 1 == 0
+
+
+def test_SumApprox_monotone_terms():
+    x, y, z = symbols('x y z')
+    expr1 = exp(z)*(x**2 + y**2 + 1)
+    bnds1 = {x: (0, 1e-3), y: (100, 1000)}
+    sum_approx_m2 = SumApprox(bounds=bnds1, reltol=1e-2)
+    sum_approx_m5 = SumApprox(bounds=bnds1, reltol=1e-5)
+    sum_approx_m11 = SumApprox(bounds=bnds1, reltol=1e-11)
+    assert (optimize(expr1, [sum_approx_m2])/exp(z) - (y**2)).simplify() == 0
+    assert (optimize(expr1, [sum_approx_m5])/exp(z) - (y**2 + 1)).simplify() == 0
+    assert (optimize(expr1, [sum_approx_m11])/exp(z) - (y**2 + 1 + x**2)).simplify() == 0
+
+
+def test_SeriesApprox_trivial():
+    x, z = symbols('x z')
+    for factor in [1, exp(z)]:
+        x = symbols('x')
+        expr1 = exp(x)*factor
+        bnds1 = {x: (-1, 1)}
+        series_approx_50 = SeriesApprox(bounds=bnds1, reltol=0.50)
+        series_approx_10 = SeriesApprox(bounds=bnds1, reltol=0.10)
+        series_approx_05 = SeriesApprox(bounds=bnds1, reltol=0.05)
+        c = (bnds1[x][1] + bnds1[x][0])/2  # 0.0
+        f0 = math.exp(c)  # 1.0
+
+        ref_50 = f0 + x + x**2/2
+        ref_10 = f0 + x + x**2/2 + x**3/6
+        ref_05 = f0 + x + x**2/2 + x**3/6 + x**4/24
+
+        res_50 = optimize(expr1, [series_approx_50])
+        res_10 = optimize(expr1, [series_approx_10])
+        res_05 = optimize(expr1, [series_approx_05])
+
+        assert (res_50/factor - ref_50).simplify() == 0
+        assert (res_10/factor - ref_10).simplify() == 0
+        assert (res_05/factor - ref_05).simplify() == 0
+
+        max_ord3 = SeriesApprox(bounds=bnds1, reltol=0.05, max_order=3)
+        assert optimize(expr1, [max_ord3]) == expr1

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_ast.py

@@ -0,0 +1,661 @@
+import math
+from sympy.core.containers import Tuple
+from sympy.core.numbers import nan, oo, Float, Integer
+from sympy.core.relational import Lt
+from sympy.core.symbol import symbols, Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.sets.fancysets import Range
+from sympy.tensor.indexed import Idx, IndexedBase
+from sympy.testing.pytest import raises
+
+
+from sympy.codegen.ast import (
+    Assignment, Attribute, aug_assign, CodeBlock, For, Type, Variable, Pointer, Declaration,
+    AddAugmentedAssignment, SubAugmentedAssignment, MulAugmentedAssignment,
+    DivAugmentedAssignment, ModAugmentedAssignment, value_const, pointer_const,
+    integer, real, complex_, int8, uint8, float16 as f16, float32 as f32,
+    float64 as f64, float80 as f80, float128 as f128, complex64 as c64, complex128 as c128,
+    While, Scope, String, Print, QuotedString, FunctionPrototype, FunctionDefinition, Return,
+    FunctionCall, untyped, IntBaseType, intc, Node, none, NoneToken, Token, Comment
+)
+
+x, y, z, t, x0, x1, x2, a, b = symbols("x, y, z, t, x0, x1, x2, a, b")
+n = symbols("n", integer=True)
+A = MatrixSymbol('A', 3, 1)
+mat = Matrix([1, 2, 3])
+B = IndexedBase('B')
+i = Idx("i", n)
+A22 = MatrixSymbol('A22',2,2)
+B22 = MatrixSymbol('B22',2,2)
+
+
+def test_Assignment():
+    # Here we just do things to show they don't error
+    Assignment(x, y)
+    Assignment(x, 0)
+    Assignment(A, mat)
+    Assignment(A[1,0], 0)
+    Assignment(A[1,0], x)
+    Assignment(B[i], x)
+    Assignment(B[i], 0)
+    a = Assignment(x, y)
+    assert a.func(*a.args) == a
+    assert a.op == ':='
+    # Here we test things to show that they error
+    # Matrix to scalar
+    raises(ValueError, lambda: Assignment(B[i], A))
+    raises(ValueError, lambda: Assignment(B[i], mat))
+    raises(ValueError, lambda: Assignment(x, mat))
+    raises(ValueError, lambda: Assignment(x, A))
+    raises(ValueError, lambda: Assignment(A[1,0], mat))
+    # Scalar to matrix
+    raises(ValueError, lambda: Assignment(A, x))
+    raises(ValueError, lambda: Assignment(A, 0))
+    # Non-atomic lhs
+    raises(TypeError, lambda: Assignment(mat, A))
+    raises(TypeError, lambda: Assignment(0, x))
+    raises(TypeError, lambda: Assignment(x*x, 1))
+    raises(TypeError, lambda: Assignment(A + A, mat))
+    raises(TypeError, lambda: Assignment(B, 0))
+
+
+def test_AugAssign():
+    # Here we just do things to show they don't error
+    aug_assign(x, '+', y)
+    aug_assign(x, '+', 0)
+    aug_assign(A, '+', mat)
+    aug_assign(A[1, 0], '+', 0)
+    aug_assign(A[1, 0], '+', x)
+    aug_assign(B[i], '+', x)
+    aug_assign(B[i], '+', 0)
+
+    # Check creation via aug_assign vs constructor
+    for binop, cls in [
+            ('+', AddAugmentedAssignment),
+            ('-', SubAugmentedAssignment),
+            ('*', MulAugmentedAssignment),
+            ('/', DivAugmentedAssignment),
+            ('%', ModAugmentedAssignment),
+        ]:
+        a = aug_assign(x, binop, y)
+        b = cls(x, y)
+        assert a.func(*a.args) == a == b
+        assert a.binop == binop
+        assert a.op == binop + '='
+
+    # Here we test things to show that they error
+    # Matrix to scalar
+    raises(ValueError, lambda: aug_assign(B[i], '+', A))
+    raises(ValueError, lambda: aug_assign(B[i], '+', mat))
+    raises(ValueError, lambda: aug_assign(x, '+', mat))
+    raises(ValueError, lambda: aug_assign(x, '+', A))
+    raises(ValueError, lambda: aug_assign(A[1, 0], '+', mat))
+    # Scalar to matrix
+    raises(ValueError, lambda: aug_assign(A, '+', x))
+    raises(ValueError, lambda: aug_assign(A, '+', 0))
+    # Non-atomic lhs
+    raises(TypeError, lambda: aug_assign(mat, '+', A))
+    raises(TypeError, lambda: aug_assign(0, '+', x))
+    raises(TypeError, lambda: aug_assign(x * x, '+', 1))
+    raises(TypeError, lambda: aug_assign(A + A, '+', mat))
+    raises(TypeError, lambda: aug_assign(B, '+', 0))
+
+
+def test_Assignment_printing():
+    assignment_classes = [
+        Assignment,
+        AddAugmentedAssignment,
+        SubAugmentedAssignment,
+        MulAugmentedAssignment,
+        DivAugmentedAssignment,
+        ModAugmentedAssignment,
+    ]
+    pairs = [
+        (x, 2 * y + 2),
+        (B[i], x),
+        (A22, B22),
+        (A[0, 0], x),
+    ]
+
+    for cls in assignment_classes:
+        for lhs, rhs in pairs:
+            a = cls(lhs, rhs)
+            assert repr(a) == '%s(%s, %s)' % (cls.__name__, repr(lhs), repr(rhs))
+
+
+def test_CodeBlock():
+    c = CodeBlock(Assignment(x, 1), Assignment(y, x + 1))
+    assert c.func(*c.args) == c
+
+    assert c.left_hand_sides == Tuple(x, y)
+    assert c.right_hand_sides == Tuple(1, x + 1)
+
+def test_CodeBlock_topological_sort():
+    assignments = [
+        Assignment(x, y + z),
+        Assignment(z, 1),
+        Assignment(t, x),
+        Assignment(y, 2),
+        ]
+
+    ordered_assignments = [
+        # Note that the unrelated z=1 and y=2 are kept in that order
+        Assignment(z, 1),
+        Assignment(y, 2),
+        Assignment(x, y + z),
+        Assignment(t, x),
+        ]
+    c1 = CodeBlock.topological_sort(assignments)
+    assert c1 == CodeBlock(*ordered_assignments)
+
+    # Cycle
+    invalid_assignments = [
+        Assignment(x, y + z),
+        Assignment(z, 1),
+        Assignment(y, x),
+        Assignment(y, 2),
+        ]
+
+    raises(ValueError, lambda: CodeBlock.topological_sort(invalid_assignments))
+
+    # Free symbols
+    free_assignments = [
+        Assignment(x, y + z),
+        Assignment(z, a * b),
+        Assignment(t, x),
+        Assignment(y, b + 3),
+        ]
+
+    free_assignments_ordered = [
+        Assignment(z, a * b),
+        Assignment(y, b + 3),
+        Assignment(x, y + z),
+        Assignment(t, x),
+        ]
+
+    c2 = CodeBlock.topological_sort(free_assignments)
+    assert c2 == CodeBlock(*free_assignments_ordered)
+
+def test_CodeBlock_free_symbols():
+    c1 = CodeBlock(
+        Assignment(x, y + z),
+        Assignment(z, 1),
+        Assignment(t, x),
+        Assignment(y, 2),
+        )
+    assert c1.free_symbols == set()
+
+    c2 = CodeBlock(
+        Assignment(x, y + z),
+        Assignment(z, a * b),
+        Assignment(t, x),
+        Assignment(y, b + 3),
+    )
+    assert c2.free_symbols == {a, b}
+
+def test_CodeBlock_cse():
+    c1 = CodeBlock(
+        Assignment(y, 1),
+        Assignment(x, sin(y)),
+        Assignment(z, sin(y)),
+        Assignment(t, x*z),
+        )
+    assert c1.cse() == CodeBlock(
+        Assignment(y, 1),
+        Assignment(x0, sin(y)),
+        Assignment(x, x0),
+        Assignment(z, x0),
+        Assignment(t, x*z),
+    )
+
+    # Multiple assignments to same symbol not supported
+    raises(NotImplementedError, lambda: CodeBlock(
+        Assignment(x, 1),
+        Assignment(y, 1), Assignment(y, 2)
+    ).cse())
+
+    # Check auto-generated symbols do not collide with existing ones
+    c2 = CodeBlock(
+        Assignment(x0, sin(y) + 1),
+        Assignment(x1, 2 * sin(y)),
+        Assignment(z, x * y),
+        )
+    assert c2.cse() == CodeBlock(
+        Assignment(x2, sin(y)),
+        Assignment(x0, x2 + 1),
+        Assignment(x1, 2 * x2),
+        Assignment(z, x * y),
+        )
+
+
+def test_CodeBlock_cse__issue_14118():
+    # see https://github.com/sympy/sympy/issues/14118
+    c = CodeBlock(
+        Assignment(A22, Matrix([[x, sin(y)],[3, 4]])),
+        Assignment(B22, Matrix([[sin(y), 2*sin(y)], [sin(y)**2, 7]]))
+    )
+    assert c.cse() == CodeBlock(
+        Assignment(x0, sin(y)),
+        Assignment(A22, Matrix([[x, x0],[3, 4]])),
+        Assignment(B22, Matrix([[x0, 2*x0], [x0**2, 7]]))
+    )
+
+def test_For():
+    f = For(n, Range(0, 3), (Assignment(A[n, 0], x + n), aug_assign(x, '+', y)))
+    f = For(n, (1, 2, 3, 4, 5), (Assignment(A[n, 0], x + n),))
+    assert f.func(*f.args) == f
+    raises(TypeError, lambda: For(n, x, (x + y,)))
+
+
+def test_none():
+    assert none.is_Atom
+    assert none == none
+    class Foo(Token):
+        pass
+    foo = Foo()
+    assert foo != none
+    assert none == None
+    assert none == NoneToken()
+    assert none.func(*none.args) == none
+
+
+def test_String():
+    st = String('foobar')
+    assert st.is_Atom
+    assert st == String('foobar')
+    assert st.text == 'foobar'
+    assert st.func(**st.kwargs()) == st
+    assert st.func(*st.args) == st
+
+
+    class Signifier(String):
+        pass
+
+    si = Signifier('foobar')
+    assert si != st
+    assert si.text == st.text
+    s = String('foo')
+    assert str(s) == 'foo'
+    assert repr(s) == "String('foo')"
+
+def test_Comment():
+    c = Comment('foobar')
+    assert c.text == 'foobar'
+    assert str(c) == 'foobar'
+
+def test_Node():
+    n = Node()
+    assert n == Node()
+    assert n.func(*n.args) == n
+
+
+def test_Type():
+    t = Type('MyType')
+    assert len(t.args) == 1
+    assert t.name == String('MyType')
+    assert str(t) == 'MyType'
+    assert repr(t) == "Type(String('MyType'))"
+    assert Type(t) == t
+    assert t.func(*t.args) == t
+    t1 = Type('t1')
+    t2 = Type('t2')
+    assert t1 != t2
+    assert t1 == t1 and t2 == t2
+    t1b = Type('t1')
+    assert t1 == t1b
+    assert t2 != t1b
+
+
+def test_Type__from_expr():
+    assert Type.from_expr(i) == integer
+    u = symbols('u', real=True)
+    assert Type.from_expr(u) == real
+    assert Type.from_expr(n) == integer
+    assert Type.from_expr(3) == integer
+    assert Type.from_expr(3.0) == real
+    assert Type.from_expr(3+1j) == complex_
+    raises(ValueError, lambda: Type.from_expr(sum))
+
+
+def test_Type__cast_check__integers():
+    # Rounding
+    raises(ValueError, lambda: integer.cast_check(3.5))
+    assert integer.cast_check('3') == 3
+    assert integer.cast_check(Float('3.0000000000000000000')) == 3
+    assert integer.cast_check(Float('3.0000000000000000001')) == 3  # unintuitive maybe?
+
+    # Range
+    assert int8.cast_check(127.0) == 127
+    raises(ValueError, lambda: int8.cast_check(128))
+    assert int8.cast_check(-128) == -128
+    raises(ValueError, lambda: int8.cast_check(-129))
+
+    assert uint8.cast_check(0) == 0
+    assert uint8.cast_check(128) == 128
+    raises(ValueError, lambda: uint8.cast_check(256.0))
+    raises(ValueError, lambda: uint8.cast_check(-1))
+
+def test_Attribute():
+    noexcept = Attribute('noexcept')
+    assert noexcept == Attribute('noexcept')
+    alignas16 = Attribute('alignas', [16])
+    alignas32 = Attribute('alignas', [32])
+    assert alignas16 != alignas32
+    assert alignas16.func(*alignas16.args) == alignas16
+
+
+def test_Variable():
+    v = Variable(x, type=real)
+    assert v == Variable(v)
+    assert v == Variable('x', type=real)
+    assert v.symbol == x
+    assert v.type == real
+    assert value_const not in v.attrs
+    assert v.func(*v.args) == v
+    assert str(v) == 'Variable(x, type=real)'
+
+    w = Variable(y, f32, attrs={value_const})
+    assert w.symbol == y
+    assert w.type == f32
+    assert value_const in w.attrs
+    assert w.func(*w.args) == w
+
+    v_n = Variable(n, type=Type.from_expr(n))
+    assert v_n.type == integer
+    assert v_n.func(*v_n.args) == v_n
+    v_i = Variable(i, type=Type.from_expr(n))
+    assert v_i.type == integer
+    assert v_i != v_n
+
+    a_i = Variable.deduced(i)
+    assert a_i.type == integer
+    assert Variable.deduced(Symbol('x', real=True)).type == real
+    assert a_i.func(*a_i.args) == a_i
+
+    v_n2 = Variable.deduced(n, value=3.5, cast_check=False)
+    assert v_n2.func(*v_n2.args) == v_n2
+    assert abs(v_n2.value - 3.5) < 1e-15
+    raises(ValueError, lambda: Variable.deduced(n, value=3.5, cast_check=True))
+
+    v_n3 = Variable.deduced(n)
+    assert v_n3.type == integer
+    assert str(v_n3) == 'Variable(n, type=integer)'
+    assert Variable.deduced(z, value=3).type == integer
+    assert Variable.deduced(z, value=3.0).type == real
+    assert Variable.deduced(z, value=3.0+1j).type == complex_
+
+
+def test_Pointer():
+    p = Pointer(x)
+    assert p.symbol == x
+    assert p.type == untyped
+    assert value_const not in p.attrs
+    assert pointer_const not in p.attrs
+    assert p.func(*p.args) == p
+
+    u = symbols('u', real=True)
+    pu = Pointer(u, type=Type.from_expr(u), attrs={value_const, pointer_const})
+    assert pu.symbol is u
+    assert pu.type == real
+    assert value_const in pu.attrs
+    assert pointer_const in pu.attrs
+    assert pu.func(*pu.args) == pu
+
+    i = symbols('i', integer=True)
+    deref = pu[i]
+    assert deref.indices == (i,)
+
+
+def test_Declaration():
+    u = symbols('u', real=True)
+    vu = Variable(u, type=Type.from_expr(u))
+    assert Declaration(vu).variable.type == real
+    vn = Variable(n, type=Type.from_expr(n))
+    assert Declaration(vn).variable.type == integer
+
+    # PR 19107, does not allow comparison between expressions and Basic
+    # lt = StrictLessThan(vu, vn)
+    # assert isinstance(lt, StrictLessThan)
+
+    vuc = Variable(u, Type.from_expr(u), value=3.0, attrs={value_const})
+    assert value_const in vuc.attrs
+    assert pointer_const not in vuc.attrs
+    decl = Declaration(vuc)
+    assert decl.variable == vuc
+    assert isinstance(decl.variable.value, Float)
+    assert decl.variable.value == 3.0
+    assert decl.func(*decl.args) == decl
+    assert vuc.as_Declaration() == decl
+    assert vuc.as_Declaration(value=None, attrs=None) == Declaration(vu)
+
+    vy = Variable(y, type=integer, value=3)
+    decl2 = Declaration(vy)
+    assert decl2.variable == vy
+    assert decl2.variable.value == Integer(3)
+
+    vi = Variable(i, type=Type.from_expr(i), value=3.0)
+    decl3 = Declaration(vi)
+    assert decl3.variable.type == integer
+    assert decl3.variable.value == 3.0
+
+    raises(ValueError, lambda: Declaration(vi, 42))
+
+
+def test_IntBaseType():
+    assert intc.name == String('intc')
+    assert intc.args == (intc.name,)
+    assert str(IntBaseType('a').name) == 'a'
+
+
+def test_FloatType():
+    assert f16.dig == 3
+    assert f32.dig == 6
+    assert f64.dig == 15
+    assert f80.dig == 18
+    assert f128.dig == 33
+
+    assert f16.decimal_dig == 5
+    assert f32.decimal_dig == 9
+    assert f64.decimal_dig == 17
+    assert f80.decimal_dig == 21
+    assert f128.decimal_dig == 36
+
+    assert f16.max_exponent == 16
+    assert f32.max_exponent == 128
+    assert f64.max_exponent == 1024
+    assert f80.max_exponent == 16384
+    assert f128.max_exponent == 16384
+
+    assert f16.min_exponent == -13
+    assert f32.min_exponent == -125
+    assert f64.min_exponent == -1021
+    assert f80.min_exponent == -16381
+    assert f128.min_exponent == -16381
+
+    assert abs(f16.eps / Float('0.00097656', precision=16) - 1) < 0.1*10**-f16.dig
+    assert abs(f32.eps / Float('1.1920929e-07', precision=32) - 1) < 0.1*10**-f32.dig
+    assert abs(f64.eps / Float('2.2204460492503131e-16', precision=64) - 1) < 0.1*10**-f64.dig
+    assert abs(f80.eps / Float('1.08420217248550443401e-19', precision=80) - 1) < 0.1*10**-f80.dig
+    assert abs(f128.eps / Float(' 1.92592994438723585305597794258492732e-34', precision=128) - 1) < 0.1*10**-f128.dig
+
+    assert abs(f16.max / Float('65504', precision=16) - 1) < .1*10**-f16.dig
+    assert abs(f32.max / Float('3.40282347e+38', precision=32) - 1) < 0.1*10**-f32.dig
+    assert abs(f64.max / Float('1.79769313486231571e+308', precision=64) - 1) < 0.1*10**-f64.dig  # cf. np.finfo(np.float64).max
+    assert abs(f80.max / Float('1.18973149535723176502e+4932', precision=80) - 1) < 0.1*10**-f80.dig
+    assert abs(f128.max / Float('1.18973149535723176508575932662800702e+4932', precision=128) - 1) < 0.1*10**-f128.dig
+
+    # cf. np.finfo(np.float32).tiny
+    assert abs(f16.tiny / Float('6.1035e-05', precision=16) - 1) < 0.1*10**-f16.dig
+    assert abs(f32.tiny / Float('1.17549435e-38', precision=32) - 1) < 0.1*10**-f32.dig
+    assert abs(f64.tiny / Float('2.22507385850720138e-308', precision=64) - 1) < 0.1*10**-f64.dig
+    assert abs(f80.tiny / Float('3.36210314311209350626e-4932', precision=80) - 1) < 0.1*10**-f80.dig
+    assert abs(f128.tiny / Float('3.3621031431120935062626778173217526e-4932', precision=128) - 1) < 0.1*10**-f128.dig
+
+    assert f64.cast_check(0.5) == Float(0.5, 17)
+    assert abs(f64.cast_check(3.7) - 3.7) < 3e-17
+    assert isinstance(f64.cast_check(3), (Float, float))
+
+    assert f64.cast_nocheck(oo) == float('inf')
+    assert f64.cast_nocheck(-oo) == float('-inf')
+    assert f64.cast_nocheck(float(oo)) == float('inf')
+    assert f64.cast_nocheck(float(-oo)) == float('-inf')
+    assert math.isnan(f64.cast_nocheck(nan))
+
+    assert f32 != f64
+    assert f64 == f64.func(*f64.args)
+
+
+def test_Type__cast_check__floating_point():
+    raises(ValueError, lambda: f32.cast_check(123.45678949))
+    raises(ValueError, lambda: f32.cast_check(12.345678949))
+    raises(ValueError, lambda: f32.cast_check(1.2345678949))
+    raises(ValueError, lambda: f32.cast_check(.12345678949))
+    assert abs(123.456789049 - f32.cast_check(123.456789049) - 4.9e-8) < 1e-8
+    assert abs(0.12345678904 - f32.cast_check(0.12345678904) - 4e-11) < 1e-11
+
+    dcm21 = Float('0.123456789012345670499')  # 21 decimals
+    assert abs(dcm21 - f64.cast_check(dcm21) - 4.99e-19) < 1e-19
+
+    f80.cast_check(Float('0.12345678901234567890103', precision=88))
+    raises(ValueError, lambda: f80.cast_check(Float('0.12345678901234567890149', precision=88)))
+
+    v10 = 12345.67894
+    raises(ValueError, lambda: f32.cast_check(v10))
+    assert abs(Float(str(v10), precision=64+8) - f64.cast_check(v10)) < v10*1e-16
+
+    assert abs(f32.cast_check(2147483647) - 2147483650) < 1
+
+
+def test_Type__cast_check__complex_floating_point():
+    val9_11 = 123.456789049 + 0.123456789049j
+    raises(ValueError, lambda: c64.cast_check(.12345678949 + .12345678949j))
+    assert abs(val9_11 - c64.cast_check(val9_11) - 4.9e-8) < 1e-8
+
+    dcm21 = Float('0.123456789012345670499') + 1e-20j  # 21 decimals
+    assert abs(dcm21 - c128.cast_check(dcm21) - 4.99e-19) < 1e-19
+    v19 = Float('0.1234567890123456749') + 1j*Float('0.1234567890123456749')
+    raises(ValueError, lambda: c128.cast_check(v19))
+
+
+def test_While():
+    xpp = AddAugmentedAssignment(x, 1)
+    whl1 = While(x < 2, [xpp])
+    assert whl1.condition.args[0] == x
+    assert whl1.condition.args[1] == 2
+    assert whl1.condition == Lt(x, 2, evaluate=False)
+    assert whl1.body.args == (xpp,)
+    assert whl1.func(*whl1.args) == whl1
+
+    cblk = CodeBlock(AddAugmentedAssignment(x, 1))
+    whl2 = While(x < 2, cblk)
+    assert whl1 == whl2
+    assert whl1 != While(x < 3, [xpp])
+
+
+def test_Scope():
+    assign = Assignment(x, y)
+    incr = AddAugmentedAssignment(x, 1)
+    scp = Scope([assign, incr])
+    cblk = CodeBlock(assign, incr)
+    assert scp.body == cblk
+    assert scp == Scope(cblk)
+    assert scp != Scope([incr, assign])
+    assert scp.func(*scp.args) == scp
+
+
+def test_Print():
+    fmt = "%d %.3f"
+    ps = Print([n, x], fmt)
+    assert str(ps.format_string) == fmt
+    assert ps.print_args == Tuple(n, x)
+    assert ps.args == (Tuple(n, x), QuotedString(fmt), none)
+    assert ps == Print((n, x), fmt)
+    assert ps != Print([x, n], fmt)
+    assert ps.func(*ps.args) == ps
+
+    ps2 = Print([n, x])
+    assert ps2 == Print([n, x])
+    assert ps2 != ps
+    assert ps2.format_string == None
+
+
+def test_FunctionPrototype_and_FunctionDefinition():
+    vx = Variable(x, type=real)
+    vn = Variable(n, type=integer)
+    fp1 = FunctionPrototype(real, 'power', [vx, vn])
+    assert fp1.return_type == real
+    assert fp1.name == String('power')
+    assert fp1.parameters == Tuple(vx, vn)
+    assert fp1 == FunctionPrototype(real, 'power', [vx, vn])
+    assert fp1 != FunctionPrototype(real, 'power', [vn, vx])
+    assert fp1.func(*fp1.args) == fp1
+
+
+    body = [Assignment(x, x**n), Return(x)]
+    fd1 = FunctionDefinition(real, 'power', [vx, vn], body)
+    assert fd1.return_type == real
+    assert str(fd1.name) == 'power'
+    assert fd1.parameters == Tuple(vx, vn)
+    assert fd1.body == CodeBlock(*body)
+    assert fd1 == FunctionDefinition(real, 'power', [vx, vn], body)
+    assert fd1 != FunctionDefinition(real, 'power', [vx, vn], body[::-1])
+    assert fd1.func(*fd1.args) == fd1
+
+    fp2 = FunctionPrototype.from_FunctionDefinition(fd1)
+    assert fp2 == fp1
+
+    fd2 = FunctionDefinition.from_FunctionPrototype(fp1, body)
+    assert fd2 == fd1
+
+
+def test_Return():
+    rs = Return(x)
+    assert rs.args == (x,)
+    assert rs == Return(x)
+    assert rs != Return(y)
+    assert rs.func(*rs.args) == rs
+
+
+def test_FunctionCall():
+    fc = FunctionCall('power', (x, 3))
+    assert fc.function_args[0] == x
+    assert fc.function_args[1] == 3
+    assert len(fc.function_args) == 2
+    assert isinstance(fc.function_args[1], Integer)
+    assert fc == FunctionCall('power', (x, 3))
+    assert fc != FunctionCall('power', (3, x))
+    assert fc != FunctionCall('Power', (x, 3))
+    assert fc.func(*fc.args) == fc
+
+    fc2 = FunctionCall('fma', [2, 3, 4])
+    assert len(fc2.function_args) == 3
+    assert fc2.function_args[0] == 2
+    assert fc2.function_args[1] == 3
+    assert fc2.function_args[2] == 4
+    assert str(fc2) in ( # not sure if QuotedString is a better default...
+        'FunctionCall(fma, function_args=(2, 3, 4))',
+        'FunctionCall("fma", function_args=(2, 3, 4))',
+    )
+
+def test_ast_replace():
+    x = Variable('x', real)
+    y = Variable('y', real)
+    n = Variable('n', integer)
+
+    pwer = FunctionDefinition(real, 'pwer', [x, n], [pow(x.symbol, n.symbol)])
+    pname = pwer.name
+    pcall = FunctionCall('pwer', [y, 3])
+
+    tree1 = CodeBlock(pwer, pcall)
+    assert str(tree1.args[0].name) == 'pwer'
+    assert str(tree1.args[1].name) == 'pwer'
+    for a, b in zip(tree1, [pwer, pcall]):
+        assert a == b
+
+    tree2 = tree1.replace(pname, String('power'))
+    assert str(tree1.args[0].name) == 'pwer'
+    assert str(tree1.args[1].name) == 'pwer'
+    assert str(tree2.args[0].name) == 'power'
+    assert str(tree2.args[1].name) == 'power'

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_cfunctions.py

@@ -0,0 +1,186 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.codegen.cfunctions import (
+    expm1, log1p, exp2, log2, fma, log10, Sqrt, Cbrt, hypot, isnan, isinf
+)
+from sympy.core.function import expand_log
+
+
+def test_expm1():
+    # Eval
+    assert expm1(0) == 0
+
+    x = Symbol('x', real=True)
+
+    # Expand and rewrite
+    assert expm1(x).expand(func=True) - exp(x) == -1
+    assert expm1(x).rewrite('tractable') - exp(x) == -1
+    assert expm1(x).rewrite('exp') - exp(x) == -1
+
+    # Precision
+    assert not ((exp(1e-10).evalf() - 1) - 1e-10 - 5e-21) < 1e-22  # for comparison
+    assert abs(expm1(1e-10).evalf() - 1e-10 - 5e-21) < 1e-22
+
+    # Properties
+    assert expm1(x).is_real
+    assert expm1(x).is_finite
+
+    # Diff
+    assert expm1(42*x).diff(x) - 42*exp(42*x) == 0
+    assert expm1(42*x).diff(x) - expm1(42*x).expand(func=True).diff(x) == 0
+
+
+def test_log1p():
+    # Eval
+    assert log1p(0) == 0
+    d = S(10)
+    assert expand_log(log1p(d**-1000) - log(d**1000 + 1) + log(d**1000)) == 0
+
+    x = Symbol('x', real=True)
+
+    # Expand and rewrite
+    assert log1p(x).expand(func=True) - log(x + 1) == 0
+    assert log1p(x).rewrite('tractable') - log(x + 1) == 0
+    assert log1p(x).rewrite('log') - log(x + 1) == 0
+
+    # Precision
+    assert not abs(log(1e-99 + 1).evalf() - 1e-99) < 1e-100  # for comparison
+    assert abs(expand_log(log1p(1e-99)).evalf() - 1e-99) < 1e-100
+
+    # Properties
+    assert log1p(-2**Rational(-1, 2)).is_real
+
+    assert not log1p(-1).is_finite
+    assert log1p(pi).is_finite
+
+    assert not log1p(x).is_positive
+    assert log1p(Symbol('y', positive=True)).is_positive
+
+    assert not log1p(x).is_zero
+    assert log1p(Symbol('z', zero=True)).is_zero
+
+    assert not log1p(x).is_nonnegative
+    assert log1p(Symbol('o', nonnegative=True)).is_nonnegative
+
+    # Diff
+    assert log1p(42*x).diff(x) - 42/(42*x + 1) == 0
+    assert log1p(42*x).diff(x) - log1p(42*x).expand(func=True).diff(x) == 0
+
+
+def test_exp2():
+    # Eval
+    assert exp2(2) == 4
+
+    x = Symbol('x', real=True)
+
+    # Expand
+    assert exp2(x).expand(func=True) - 2**x == 0
+
+    # Diff
+    assert exp2(42*x).diff(x) - 42*exp2(42*x)*log(2) == 0
+    assert exp2(42*x).diff(x) - exp2(42*x).diff(x) == 0
+
+
+def test_log2():
+    # Eval
+    assert log2(8) == 3
+    assert log2(pi) != log(pi)/log(2)  # log2 should *save* (CPU) instructions
+
+    x = Symbol('x', real=True)
+    assert log2(x) != log(x)/log(2)
+    assert log2(2**x) == x
+
+    # Expand
+    assert log2(x).expand(func=True) - log(x)/log(2) == 0
+
+    # Diff
+    assert log2(42*x).diff() - 1/(log(2)*x) == 0
+    assert log2(42*x).diff() - log2(42*x).expand(func=True).diff(x) == 0
+
+
+def test_fma():
+    x, y, z = symbols('x y z')
+
+    # Expand
+    assert fma(x, y, z).expand(func=True) - x*y - z == 0
+
+    expr = fma(17*x, 42*y, 101*z)
+
+    # Diff
+    assert expr.diff(x) - expr.expand(func=True).diff(x) == 0
+    assert expr.diff(y) - expr.expand(func=True).diff(y) == 0
+    assert expr.diff(z) - expr.expand(func=True).diff(z) == 0
+
+    assert expr.diff(x) - 17*42*y == 0
+    assert expr.diff(y) - 17*42*x == 0
+    assert expr.diff(z) - 101 == 0
+
+
+def test_log10():
+    x = Symbol('x')
+
+    # Expand
+    assert log10(x).expand(func=True) - log(x)/log(10) == 0
+
+    # Diff
+    assert log10(42*x).diff(x) - 1/(log(10)*x) == 0
+    assert log10(42*x).diff(x) - log10(42*x).expand(func=True).diff(x) == 0
+
+
+def test_Cbrt():
+    x = Symbol('x')
+
+    # Expand
+    assert Cbrt(x).expand(func=True) - x**Rational(1, 3) == 0
+
+    # Diff
+    assert Cbrt(42*x).diff(x) - 42*(42*x)**(Rational(1, 3) - 1)/3 == 0
+    assert Cbrt(42*x).diff(x) - Cbrt(42*x).expand(func=True).diff(x) == 0
+
+
+def test_Sqrt():
+    x = Symbol('x')
+
+    # Expand
+    assert Sqrt(x).expand(func=True) - x**S.Half == 0
+
+    # Diff
+    assert Sqrt(42*x).diff(x) - 42*(42*x)**(S.Half - 1)/2 == 0
+    assert Sqrt(42*x).diff(x) - Sqrt(42*x).expand(func=True).diff(x) == 0
+
+
+def test_hypot():
+    x, y = symbols('x y')
+
+    # Expand
+    assert hypot(x, y).expand(func=True) - (x**2 + y**2)**S.Half == 0
+
+    # Diff
+    assert hypot(17*x, 42*y).diff(x).expand(func=True) - hypot(17*x, 42*y).expand(func=True).diff(x) == 0
+    assert hypot(17*x, 42*y).diff(y).expand(func=True) - hypot(17*x, 42*y).expand(func=True).diff(y) == 0
+
+    assert hypot(17*x, 42*y).diff(x).expand(func=True) - 2*17*17*x*((17*x)**2 + (42*y)**2)**Rational(-1, 2)/2 == 0
+    assert hypot(17*x, 42*y).diff(y).expand(func=True) - 2*42*42*y*((17*x)**2 + (42*y)**2)**Rational(-1, 2)/2 == 0
+
+
+def test_isnan_isinf():
+    x = Symbol('x')
+
+    # isinf
+    assert isinf(+S.Infinity) == True
+    assert isinf(-S.Infinity) == True
+    assert isinf(S.Pi) == False
+    isinfx = isinf(x)
+    assert isinfx not in (False, True)
+    assert isinfx.func is isinf
+    assert isinfx.args == (x,)
+
+    # isnan
+    assert isnan(S.NaN) == True
+    assert isnan(S.Pi) == False
+    isnanx = isnan(x)
+    assert isnanx not in (False, True)
+    assert isnanx.func is isnan
+    assert isnanx.args == (x,)

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_cnodes.py

@@ -0,0 +1,112 @@
+from sympy.core.symbol import symbols
+from sympy.printing.codeprinter import ccode
+from sympy.codegen.ast import Declaration, Variable, float64, int64, String, CodeBlock
+from sympy.codegen.cnodes import (
+    alignof, CommaOperator, goto, Label, PreDecrement, PostDecrement, PreIncrement, PostIncrement,
+    sizeof, union, struct
+)
+
+x, y = symbols('x y')
+
+
+def test_alignof():
+    ax = alignof(x)
+    assert ccode(ax) == 'alignof(x)'
+    assert ax.func(*ax.args) == ax
+
+
+def test_CommaOperator():
+    expr = CommaOperator(PreIncrement(x), 2*x)
+    assert ccode(expr) == '(++(x), 2*x)'
+    assert expr.func(*expr.args) == expr
+
+
+def test_goto_Label():
+    s = 'early_exit'
+    g = goto(s)
+    assert g.func(*g.args) == g
+    assert g != goto('foobar')
+    assert ccode(g) == 'goto early_exit'
+
+    l1 = Label(s)
+    assert ccode(l1) == 'early_exit:'
+    assert l1 == Label('early_exit')
+    assert l1 != Label('foobar')
+
+    body = [PreIncrement(x)]
+    l2 = Label(s, body)
+    assert l2.name == String("early_exit")
+    assert l2.body == CodeBlock(PreIncrement(x))
+    assert ccode(l2) == ("early_exit:\n"
+        "++(x);")
+
+    body = [PreIncrement(x), PreDecrement(y)]
+    l2 = Label(s, body)
+    assert l2.name == String("early_exit")
+    assert l2.body == CodeBlock(PreIncrement(x), PreDecrement(y))
+    assert ccode(l2) == ("early_exit:\n"
+        "{\n   ++(x);\n   --(y);\n}")
+
+
+def test_PreDecrement():
+    p = PreDecrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '--(x)'
+
+
+def test_PostDecrement():
+    p = PostDecrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '(x)--'
+
+
+def test_PreIncrement():
+    p = PreIncrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '++(x)'
+
+
+def test_PostIncrement():
+    p = PostIncrement(x)
+    assert p.func(*p.args) == p
+    assert ccode(p) == '(x)++'
+
+
+def test_sizeof():
+    typename = 'unsigned int'
+    sz = sizeof(typename)
+    assert ccode(sz) == 'sizeof(%s)' % typename
+    assert sz.func(*sz.args) == sz
+    assert not sz.is_Atom
+    assert sz.atoms() == {String('unsigned int'), String('sizeof')}
+
+
+def test_struct():
+    vx, vy = Variable(x, type=float64), Variable(y, type=float64)
+    s = struct('vec2', [vx, vy])
+    assert s.func(*s.args) == s
+    assert s == struct('vec2', (vx, vy))
+    assert s != struct('vec2', (vy, vx))
+    assert str(s.name) == 'vec2'
+    assert len(s.declarations) == 2
+    assert all(isinstance(arg, Declaration) for arg in s.declarations)
+    assert ccode(s) == (
+        "struct vec2 {\n"
+        "   double x;\n"
+        "   double y;\n"
+        "}")
+
+
+def test_union():
+    vx, vy = Variable(x, type=float64), Variable(y, type=int64)
+    u = union('dualuse', [vx, vy])
+    assert u.func(*u.args) == u
+    assert u == union('dualuse', (vx, vy))
+    assert str(u.name) == 'dualuse'
+    assert len(u.declarations) == 2
+    assert all(isinstance(arg, Declaration) for arg in u.declarations)
+    assert ccode(u) == (
+        "union dualuse {\n"
+        "   double x;\n"
+        "   int64_t y;\n"
+        "}")

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_cxxnodes.py

@@ -0,0 +1,14 @@
+from sympy.core.symbol import Symbol
+from sympy.codegen.ast import Type
+from sympy.codegen.cxxnodes import using
+from sympy.printing.codeprinter import cxxcode
+
+x = Symbol('x')
+
+def test_using():
+    v = Type('std::vector')
+    u1 = using(v)
+    assert cxxcode(u1) == 'using std::vector'
+
+    u2 = using(v, 'vec')
+    assert cxxcode(u2) == 'using vec = std::vector'

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_fnodes.py

@@ -0,0 +1,213 @@
+import os
+import tempfile
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.codegen.ast import (
+    Assignment, Print, Declaration, FunctionDefinition, Return, real,
+    FunctionCall, Variable, Element, integer
+)
+from sympy.codegen.fnodes import (
+    allocatable, ArrayConstructor, isign, dsign, cmplx, kind, literal_dp,
+    Program, Module, use, Subroutine, dimension, assumed_extent, ImpliedDoLoop,
+    intent_out, size, Do, SubroutineCall, sum_, array, bind_C
+)
+from sympy.codegen.futils import render_as_module
+from sympy.core.expr import unchanged
+from sympy.external import import_module
+from sympy.printing.codeprinter import fcode
+from sympy.utilities._compilation import has_fortran, compile_run_strings, compile_link_import_strings
+from sympy.utilities._compilation.util import may_xfail
+from sympy.testing.pytest import skip, XFAIL
+
+cython = import_module('cython')
+np = import_module('numpy')
+
+
+def test_size():
+    x = Symbol('x', real=True)
+    sx = size(x)
+    assert fcode(sx, source_format='free') == 'size(x)'
+
+
+@may_xfail
+def test_size_assumed_shape():
+    if not has_fortran():
+        skip("No fortran compiler found.")
+    a = Symbol('a', real=True)
+    body = [Return((sum_(a**2)/size(a))**.5)]
+    arr = array(a, dim=[':'], intent='in')
+    fd = FunctionDefinition(real, 'rms', [arr], body)
+    render_as_module([fd], 'mod_rms')
+
+    (stdout, stderr), info = compile_run_strings([
+        ('rms.f90', render_as_module([fd], 'mod_rms')),
+        ('main.f90', (
+            'program myprog\n'
+            'use mod_rms, only: rms\n'
+            'real*8, dimension(4), parameter :: x = [4, 2, 2, 2]\n'
+            'print "(f7.5)", dsqrt(7d0) - rms(x)\n'
+            'end program\n'
+        ))
+    ], clean=True)
+    assert '0.00000' in stdout
+    assert stderr == ''
+    assert info['exit_status'] == os.EX_OK
+
+
+@XFAIL  # https://github.com/sympy/sympy/issues/20265
+@may_xfail
+def test_ImpliedDoLoop():
+    if not has_fortran():
+        skip("No fortran compiler found.")
+
+    a, i = symbols('a i', integer=True)
+    idl = ImpliedDoLoop(i**3, i, -3, 3, 2)
+    ac = ArrayConstructor([-28, idl, 28])
+    a = array(a, dim=[':'], attrs=[allocatable])
+    prog = Program('idlprog', [
+        a.as_Declaration(),
+        Assignment(a, ac),
+        Print([a])
+    ])
+    fsrc = fcode(prog, standard=2003, source_format='free')
+    (stdout, stderr), info = compile_run_strings([('main.f90', fsrc)], clean=True)
+    for numstr in '-28 -27 -1 1 27 28'.split():
+        assert numstr in stdout
+    assert stderr == ''
+    assert info['exit_status'] == os.EX_OK
+
+
+@may_xfail
+def test_Program():
+    x = Symbol('x', real=True)
+    vx = Variable.deduced(x, 42)
+    decl = Declaration(vx)
+    prnt = Print([x, x+1])
+    prog = Program('foo', [decl, prnt])
+    if not has_fortran():
+        skip("No fortran compiler found.")
+
+    (stdout, stderr), info = compile_run_strings([('main.f90', fcode(prog, standard=90))], clean=True)
+    assert '42' in stdout
+    assert '43' in stdout
+    assert stderr == ''
+    assert info['exit_status'] == os.EX_OK
+
+
+@may_xfail
+def test_Module():
+    x = Symbol('x', real=True)
+    v_x = Variable.deduced(x)
+    sq = FunctionDefinition(real, 'sqr', [v_x], [Return(x**2)])
+    mod_sq = Module('mod_sq', [], [sq])
+    sq_call = FunctionCall('sqr', [42.])
+    prg_sq = Program('foobar', [
+        use('mod_sq', only=['sqr']),
+        Print(['"Square of 42 = "', sq_call])
+    ])
+    if not has_fortran():
+        skip("No fortran compiler found.")
+    (stdout, stderr), info = compile_run_strings([
+        ('mod_sq.f90', fcode(mod_sq, standard=90)),
+        ('main.f90', fcode(prg_sq, standard=90))
+    ], clean=True)
+    assert '42' in stdout
+    assert str(42**2) in stdout
+    assert stderr == ''
+
+
+@XFAIL  # https://github.com/sympy/sympy/issues/20265
+@may_xfail
+def test_Subroutine():
+    # Code to generate the subroutine in the example from
+    # http://www.fortran90.org/src/best-practices.html#arrays
+    r = Symbol('r', real=True)
+    i = Symbol('i', integer=True)
+    v_r = Variable.deduced(r, attrs=(dimension(assumed_extent), intent_out))
+    v_i = Variable.deduced(i)
+    v_n = Variable('n', integer)
+    do_loop = Do([
+        Assignment(Element(r, [i]), literal_dp(1)/i**2)
+    ], i, 1, v_n)
+    sub = Subroutine("f", [v_r], [
+        Declaration(v_n),
+        Declaration(v_i),
+        Assignment(v_n, size(r)),
+        do_loop
+    ])
+    x = Symbol('x', real=True)
+    v_x3 = Variable.deduced(x, attrs=[dimension(3)])
+    mod = Module('mymod', definitions=[sub])
+    prog = Program('foo', [
+        use(mod, only=[sub]),
+        Declaration(v_x3),
+        SubroutineCall(sub, [v_x3]),
+        Print([sum_(v_x3), v_x3])
+    ])
+
+    if not has_fortran():
+        skip("No fortran compiler found.")
+
+    (stdout, stderr), info = compile_run_strings([
+        ('a.f90', fcode(mod, standard=90)),
+        ('b.f90', fcode(prog, standard=90))
+    ], clean=True)
+    ref = [1.0/i**2 for i in range(1, 4)]
+    assert str(sum(ref))[:-3] in stdout
+    for _ in ref:
+        assert str(_)[:-3] in stdout
+    assert stderr == ''
+
+
+def test_isign():
+    x = Symbol('x', integer=True)
+    assert unchanged(isign, 1, x)
+    assert fcode(isign(1, x), standard=95, source_format='free') == 'isign(1, x)'
+
+
+def test_dsign():
+    x = Symbol('x')
+    assert unchanged(dsign, 1, x)
+    assert fcode(dsign(literal_dp(1), x), standard=95, source_format='free') == 'dsign(1d0, x)'
+
+
+def test_cmplx():
+    x = Symbol('x')
+    assert unchanged(cmplx, 1, x)
+
+
+def test_kind():
+    x = Symbol('x')
+    assert unchanged(kind, x)
+
+
+def test_literal_dp():
+    assert fcode(literal_dp(0), source_format='free') == '0d0'
+
+
+@may_xfail
+def test_bind_C():
+    if not has_fortran():
+        skip("No fortran compiler found.")
+    if not cython:
+        skip("Cython not found.")
+    if not np:
+        skip("NumPy not found.")
+
+    a = Symbol('a', real=True)
+    s = Symbol('s', integer=True)
+    body = [Return((sum_(a**2)/s)**.5)]
+    arr = array(a, dim=[s], intent='in')
+    fd = FunctionDefinition(real, 'rms', [arr, s], body, attrs=[bind_C('rms')])
+    f_mod = render_as_module([fd], 'mod_rms')
+
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('rms.f90', f_mod),
+            ('_rms.pyx', (
+                "#cython: language_level={}\n".format("3") +
+                "cdef extern double rms(double*, int*)\n"
+                "def py_rms(double[::1] x):\n"
+                "    cdef int s = x.size\n"
+                "    return rms(&x[0], &s)\n"))
+        ], build_dir=folder)
+        assert abs(mod.py_rms(np.array([2., 4., 2., 2.])) - 7**0.5) < 1e-14

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_matrix_nodes.py

@@ -0,0 +1,50 @@
+from sympy.core.symbol import symbols
+from sympy.core.function import Function
+from sympy.matrices.dense import Matrix
+from sympy.matrices.dense import zeros
+from sympy.simplify.simplify import simplify
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.utilities.lambdify import lambdify
+from sympy.printing.numpy import NumPyPrinter
+from sympy.testing.pytest import skip
+from sympy.external import import_module
+
+
+def test_matrix_solve_issue_24862():
+    A = Matrix(3, 3, symbols('a:9'))
+    b = Matrix(3, 1, symbols('b:3'))
+    hash(MatrixSolve(A, b))
+
+
+def test_matrix_solve_derivative_exact():
+    q = symbols('q')
+    a11, a12, a21, a22, b1, b2 = (
+        f(q) for f in symbols('a11 a12 a21 a22 b1 b2', cls=Function))
+    A = Matrix([[a11, a12], [a21, a22]])
+    b = Matrix([b1, b2])
+    x_lu = A.LUsolve(b)
+    dxdq_lu = A.LUsolve(b.diff(q) - A.diff(q) * A.LUsolve(b))
+    assert simplify(x_lu.diff(q) - dxdq_lu) == zeros(2, 1)
+    # dxdq_ms is the MatrixSolve equivalent of dxdq_lu
+    dxdq_ms = MatrixSolve(A, b.diff(q) - A.diff(q) * MatrixSolve(A, b))
+    assert MatrixSolve(A, b).diff(q) == dxdq_ms
+
+
+def test_matrix_solve_derivative_numpy():
+    np = import_module('numpy')
+    if not np:
+        skip("numpy not installed.")
+    q = symbols('q')
+    a11, a12, a21, a22, b1, b2 = (
+        f(q) for f in symbols('a11 a12 a21 a22 b1 b2', cls=Function))
+    A = Matrix([[a11, a12], [a21, a22]])
+    b = Matrix([b1, b2])
+    dx_lu = A.LUsolve(b).diff(q)
+    subs = {a11.diff(q): 0.2, a12.diff(q): 0.3, a21.diff(q): 0.1,
+            a22.diff(q): 0.5, b1.diff(q): 0.4, b2.diff(q): 0.9,
+            a11: 1.3, a12: 0.5, a21: 1.2, a22: 4, b1: 6.2, b2: 3.5}
+    p, p_vals = zip(*subs.items())
+    dx_sm = MatrixSolve(A, b).diff(q)
+    np.testing.assert_allclose(
+        lambdify(p, dx_sm, printer=NumPyPrinter)(*p_vals),
+        lambdify(p, dx_lu, printer=NumPyPrinter)(*p_vals))

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_numpy_nodes.py

@@ -0,0 +1,69 @@
+from itertools import product
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import Max, Min
+from sympy.printing.repr import srepr
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2, minimum, maximum, amax, amin
+from sympy.testing.pytest import raises
+
+x, y, z = symbols('x y z')
+
+def test_logaddexp():
+    lae_xy = logaddexp(x, y)
+    ref_xy = log(exp(x) + exp(y))
+    for wrt, deriv_order in product([x, y, z], range(3)):
+        assert (
+            lae_xy.diff(wrt, deriv_order) -
+            ref_xy.diff(wrt, deriv_order)
+        ).rewrite(log).simplify() == 0
+
+    one_third_e = 1*exp(1)/3
+    two_thirds_e = 2*exp(1)/3
+    logThirdE = log(one_third_e)
+    logTwoThirdsE = log(two_thirds_e)
+    lae_sum_to_e = logaddexp(logThirdE, logTwoThirdsE)
+    assert lae_sum_to_e.rewrite(log) == 1
+    assert lae_sum_to_e.simplify() == 1
+    was = logaddexp(2, 3)
+    assert srepr(was) == srepr(was.simplify())  # cannot simplify with 2, 3
+
+
+def test_logaddexp2():
+    lae2_xy = logaddexp2(x, y)
+    ref2_xy = log(2**x + 2**y)/log(2)
+    for wrt, deriv_order in product([x, y, z], range(3)):
+        assert (
+            lae2_xy.diff(wrt, deriv_order) -
+            ref2_xy.diff(wrt, deriv_order)
+        ).rewrite(log).cancel() == 0
+
+    def lb(x):
+        return log(x)/log(2)
+
+    two_thirds = S.One*2/3
+    four_thirds = 2*two_thirds
+    lbTwoThirds = lb(two_thirds)
+    lbFourThirds = lb(four_thirds)
+    lae2_sum_to_2 = logaddexp2(lbTwoThirds, lbFourThirds)
+    assert lae2_sum_to_2.rewrite(log) == 1
+    assert lae2_sum_to_2.simplify() == 1
+    was = logaddexp2(x, y)
+    assert srepr(was) == srepr(was.simplify())  # cannot simplify with x, y
+
+
+def test_minimum_maximum():
+    for MM, mm in zip([Min, Max], [minimum, maximum]):
+        ref = MM(x, y, z)
+        m = mm(x, y, z)
+        assert m != ref
+        assert m.rewrite(MM) == ref
+
+
+def test_amin_amax():
+    for am in [amin, amax]:
+        assert am(x).array == x
+        assert am(x).axis == None
+        assert am(x, axis=3).axis == 3
+        with raises(ValueError):
+            am(x, y, z)

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_pynodes.py

@@ -0,0 +1,13 @@
+from sympy.core.symbol import symbols
+from sympy.codegen.pynodes import List
+
+
+def test_List():
+    l = List(2, 3, 4)
+    assert l == List(2, 3, 4)
+    assert str(l) == "[2, 3, 4]"
+    x, y, z = symbols('x y z')
+    l = List(x**2,y**3,z**4)
+    # contrary to python's built-in list, we can call e.g. "replace" on List.
+    m = l.replace(lambda arg: arg.is_Pow and arg.exp>2, lambda p: p.base-p.exp)
+    assert m == [x**2, y-3, z-4]

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_pyutils.py

@@ -0,0 +1,7 @@
+from sympy.codegen.ast import Print
+from sympy.codegen.pyutils import render_as_module
+
+def test_standard():
+    ast = Print('x y'.split(), r"coordinate: %12.5g %12.5g\n")
+    assert render_as_module(ast, standard='python3') == \
+        '\n\nprint("coordinate: %12.5g %12.5g\\n" % (x, y), end="")'

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_rewriting.py

@@ -0,0 +1,479 @@
+import tempfile
+from sympy.core.numbers import pi, Rational
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.assumptions import assuming, Q
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.codegen.cfunctions import log2, exp2, expm1, log1p
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2
+from sympy.codegen.scipy_nodes import cosm1, powm1
+from sympy.codegen.rewriting import (
+    optimize, cosm1_opt, log2_opt, exp2_opt, expm1_opt, log1p_opt, powm1_opt, optims_c99,
+    create_expand_pow_optimization, matinv_opt, logaddexp_opt, logaddexp2_opt,
+    optims_numpy, optims_scipy, sinc_opts, FuncMinusOneOptim
+)
+from sympy.testing.pytest import XFAIL, skip
+from sympy.utilities import lambdify
+from sympy.utilities._compilation import compile_link_import_strings, has_c
+from sympy.utilities._compilation.util import may_xfail
+
+cython = import_module('cython')
+numpy = import_module('numpy')
+scipy = import_module('scipy')
+
+
+def test_log2_opt():
+    x = Symbol('x')
+    expr1 = 7*log(3*x + 5)/(log(2))
+    opt1 = optimize(expr1, [log2_opt])
+    assert opt1 == 7*log2(3*x + 5)
+    assert opt1.rewrite(log) == expr1
+
+    expr2 = 3*log(5*x + 7)/(13*log(2))
+    opt2 = optimize(expr2, [log2_opt])
+    assert opt2 == 3*log2(5*x + 7)/13
+    assert opt2.rewrite(log) == expr2
+
+    expr3 = log(x)/log(2)
+    opt3 = optimize(expr3, [log2_opt])
+    assert opt3 == log2(x)
+    assert opt3.rewrite(log) == expr3
+
+    expr4 = log(x)/log(2) + log(x+1)
+    opt4 = optimize(expr4, [log2_opt])
+    assert opt4 == log2(x) + log(2)*log2(x+1)
+    assert opt4.rewrite(log) == expr4
+
+    expr5 = log(17)
+    opt5 = optimize(expr5, [log2_opt])
+    assert opt5 == expr5
+
+    expr6 = log(x + 3)/log(2)
+    opt6 = optimize(expr6, [log2_opt])
+    assert str(opt6) == 'log2(x + 3)'
+    assert opt6.rewrite(log) == expr6
+
+
+def test_exp2_opt():
+    x = Symbol('x')
+    expr1 = 1 + 2**x
+    opt1 = optimize(expr1, [exp2_opt])
+    assert opt1 == 1 + exp2(x)
+    assert opt1.rewrite(Pow) == expr1
+
+    expr2 = 1 + 3**x
+    assert expr2 == optimize(expr2, [exp2_opt])
+
+
+def test_expm1_opt():
+    x = Symbol('x')
+
+    expr1 = exp(x) - 1
+    opt1 = optimize(expr1, [expm1_opt])
+    assert expm1(x) - opt1 == 0
+    assert opt1.rewrite(exp) == expr1
+
+    expr2 = 3*exp(x) - 3
+    opt2 = optimize(expr2, [expm1_opt])
+    assert 3*expm1(x) == opt2
+    assert opt2.rewrite(exp) == expr2
+
+    expr3 = 3*exp(x) - 5
+    opt3 = optimize(expr3, [expm1_opt])
+    assert 3*expm1(x) - 2 == opt3
+    assert opt3.rewrite(exp) == expr3
+    expm1_opt_non_opportunistic = FuncMinusOneOptim(exp, expm1, opportunistic=False)
+    assert expr3 == optimize(expr3, [expm1_opt_non_opportunistic])
+    assert opt1 == optimize(expr1, [expm1_opt_non_opportunistic])
+    assert opt2 == optimize(expr2, [expm1_opt_non_opportunistic])
+
+    expr4 = 3*exp(x) + log(x) - 3
+    opt4 = optimize(expr4, [expm1_opt])
+    assert 3*expm1(x) + log(x) == opt4
+    assert opt4.rewrite(exp) == expr4
+
+    expr5 = 3*exp(2*x) - 3
+    opt5 = optimize(expr5, [expm1_opt])
+    assert 3*expm1(2*x) == opt5
+    assert opt5.rewrite(exp) == expr5
+
+    expr6 = (2*exp(x) + 1)/(exp(x) + 1) + 1
+    opt6 = optimize(expr6, [expm1_opt])
+    assert opt6.count_ops() <= expr6.count_ops()
+
+    def ev(e):
+        return e.subs(x, 3).evalf()
+    assert abs(ev(expr6) - ev(opt6)) < 1e-15
+
+    y = Symbol('y')
+    expr7 = (2*exp(x) - 1)/(1 - exp(y)) - 1/(1-exp(y))
+    opt7 = optimize(expr7, [expm1_opt])
+    assert -2*expm1(x)/expm1(y) == opt7
+    assert (opt7.rewrite(exp) - expr7).factor() == 0
+
+    expr8 = (1+exp(x))**2 - 4
+    opt8 = optimize(expr8, [expm1_opt])
+    tgt8a = (exp(x) + 3)*expm1(x)
+    tgt8b = 2*expm1(x) + expm1(2*x)
+    # Both tgt8a & tgt8b seem to give full precision (~16 digits for double)
+    # for x=1e-7 (compare with expr8 which only achieves ~8 significant digits).
+    # If we can show that either tgt8a or tgt8b is preferable, we can
+    # change this test to ensure the preferable version is returned.
+    assert (tgt8a - tgt8b).rewrite(exp).factor() == 0
+    assert opt8 in (tgt8a, tgt8b)
+    assert (opt8.rewrite(exp) - expr8).factor() == 0
+
+    expr9 = sin(expr8)
+    opt9 = optimize(expr9, [expm1_opt])
+    tgt9a = sin(tgt8a)
+    tgt9b = sin(tgt8b)
+    assert opt9 in (tgt9a, tgt9b)
+    assert (opt9.rewrite(exp) - expr9.rewrite(exp)).factor().is_zero
+
+
+def test_expm1_two_exp_terms():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = exp(x) + exp(y) - 2
+    opt1 = optimize(expr1, [expm1_opt])
+    assert opt1 == expm1(x) + expm1(y)
+
+
+def test_cosm1_opt():
+    x = Symbol('x')
+
+    expr1 = cos(x) - 1
+    opt1 = optimize(expr1, [cosm1_opt])
+    assert cosm1(x) - opt1 == 0
+    assert opt1.rewrite(cos) == expr1
+
+    expr2 = 3*cos(x) - 3
+    opt2 = optimize(expr2, [cosm1_opt])
+    assert 3*cosm1(x) == opt2
+    assert opt2.rewrite(cos) == expr2
+
+    expr3 = 3*cos(x) - 5
+    opt3 = optimize(expr3, [cosm1_opt])
+    assert 3*cosm1(x) - 2 == opt3
+    assert opt3.rewrite(cos) == expr3
+    cosm1_opt_non_opportunistic = FuncMinusOneOptim(cos, cosm1, opportunistic=False)
+    assert expr3 == optimize(expr3, [cosm1_opt_non_opportunistic])
+    assert opt1 == optimize(expr1, [cosm1_opt_non_opportunistic])
+    assert opt2 == optimize(expr2, [cosm1_opt_non_opportunistic])
+
+    expr4 = 3*cos(x) + log(x) - 3
+    opt4 = optimize(expr4, [cosm1_opt])
+    assert 3*cosm1(x) + log(x) == opt4
+    assert opt4.rewrite(cos) == expr4
+
+    expr5 = 3*cos(2*x) - 3
+    opt5 = optimize(expr5, [cosm1_opt])
+    assert 3*cosm1(2*x) == opt5
+    assert opt5.rewrite(cos) == expr5
+
+    expr6 = 2 - 2*cos(x)
+    opt6 = optimize(expr6, [cosm1_opt])
+    assert -2*cosm1(x) == opt6
+    assert opt6.rewrite(cos) == expr6
+
+
+def test_cosm1_two_cos_terms():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = cos(x) + cos(y) - 2
+    opt1 = optimize(expr1, [cosm1_opt])
+    assert opt1 == cosm1(x) + cosm1(y)
+
+
+def test_expm1_cosm1_mixed():
+    x = Symbol('x')
+    expr1 = exp(x) + cos(x) - 2
+    opt1 = optimize(expr1, [expm1_opt, cosm1_opt])
+    assert opt1 == cosm1(x) + expm1(x)
+
+
+def _check_num_lambdify(expr, opt, val_subs, approx_ref, lambdify_kw=None, poorness=1e10):
+    """ poorness=1e10 signifies that `expr` loses precision of at least ten decimal digits. """
+    num_ref = expr.subs(val_subs).evalf()
+    eps = numpy.finfo(numpy.float64).eps
+    assert abs(num_ref - approx_ref) < approx_ref*eps
+    f1 = lambdify(list(val_subs.keys()), opt, **(lambdify_kw or {}))
+    args_float = tuple(map(float, val_subs.values()))
+    num_err1 = abs(f1(*args_float) - approx_ref)
+    assert num_err1 < abs(num_ref*eps)
+    f2 = lambdify(list(val_subs.keys()), expr, **(lambdify_kw or {}))
+    num_err2 = abs(f2(*args_float) - approx_ref)
+    assert num_err2 > abs(num_ref*eps*poorness)   # this only ensures that the *test* works as intended
+
+
+def test_cosm1_apart():
+    x = Symbol('x')
+
+    expr1 = 1/cos(x) - 1
+    opt1 = optimize(expr1, [cosm1_opt])
+    assert opt1 == -cosm1(x)/cos(x)
+    if scipy:
+        _check_num_lambdify(expr1, opt1, {x: S(10)**-30}, 5e-61, lambdify_kw={"modules": 'scipy'})
+
+    expr2 = 2/cos(x) - 2
+    opt2 = optimize(expr2, optims_scipy)
+    assert opt2 == -2*cosm1(x)/cos(x)
+    if scipy:
+        _check_num_lambdify(expr2, opt2, {x: S(10)**-30}, 1e-60, lambdify_kw={"modules": 'scipy'})
+
+    expr3 = pi/cos(3*x) - pi
+    opt3 = optimize(expr3, [cosm1_opt])
+    assert opt3 == -pi*cosm1(3*x)/cos(3*x)
+    if scipy:
+        _check_num_lambdify(expr3, opt3, {x: S(10)**-30/3}, float(5e-61*pi), lambdify_kw={"modules": 'scipy'})
+
+
+def test_powm1():
+    args = x, y = map(Symbol, "xy")
+
+    expr1 = x**y - 1
+    opt1 = optimize(expr1, [powm1_opt])
+    assert opt1 == powm1(x, y)
+    for arg in args:
+        assert expr1.diff(arg) == opt1.diff(arg)
+    if scipy and tuple(map(int, scipy.version.version.split('.')[:3])) >= (1, 10, 0):
+        subs1_a = {x: Rational(*(1.0+1e-13).as_integer_ratio()), y: pi}
+        ref1_f64_a = 3.139081648208105e-13
+        _check_num_lambdify(expr1, opt1, subs1_a, ref1_f64_a, lambdify_kw={"modules": 'scipy'}, poorness=10**11)
+
+        subs1_b = {x: pi, y: Rational(*(1e-10).as_integer_ratio())}
+        ref1_f64_b = 1.1447298859149205e-10
+        _check_num_lambdify(expr1, opt1, subs1_b, ref1_f64_b, lambdify_kw={"modules": 'scipy'}, poorness=10**9)
+
+
+def test_log1p_opt():
+    x = Symbol('x')
+    expr1 = log(x + 1)
+    opt1 = optimize(expr1, [log1p_opt])
+    assert log1p(x) - opt1 == 0
+    assert opt1.rewrite(log) == expr1
+
+    expr2 = log(3*x + 3)
+    opt2 = optimize(expr2, [log1p_opt])
+    assert log1p(x) + log(3) == opt2
+    assert (opt2.rewrite(log) - expr2).simplify() == 0
+
+    expr3 = log(2*x + 1)
+    opt3 = optimize(expr3, [log1p_opt])
+    assert log1p(2*x) - opt3 == 0
+    assert opt3.rewrite(log) == expr3
+
+    expr4 = log(x+3)
+    opt4 = optimize(expr4, [log1p_opt])
+    assert str(opt4) == 'log(x + 3)'
+
+
+def test_optims_c99():
+    x = Symbol('x')
+
+    expr1 = 2**x + log(x)/log(2) + log(x + 1) + exp(x) - 1
+    opt1 = optimize(expr1, optims_c99).simplify()
+    assert opt1 == exp2(x) + log2(x) + log1p(x) + expm1(x)
+    assert opt1.rewrite(exp).rewrite(log).rewrite(Pow) == expr1
+
+    expr2 = log(x)/log(2) + log(x + 1)
+    opt2 = optimize(expr2, optims_c99)
+    assert opt2 == log2(x) + log1p(x)
+    assert opt2.rewrite(log) == expr2
+
+    expr3 = log(x)/log(2) + log(17*x + 17)
+    opt3 = optimize(expr3, optims_c99)
+    delta3 = opt3 - (log2(x) + log(17) + log1p(x))
+    assert delta3 == 0
+    assert (opt3.rewrite(log) - expr3).simplify() == 0
+
+    expr4 = 2**x + 3*log(5*x + 7)/(13*log(2)) + 11*exp(x) - 11 + log(17*x + 17)
+    opt4 = optimize(expr4, optims_c99).simplify()
+    delta4 = opt4 - (exp2(x) + 3*log2(5*x + 7)/13 + 11*expm1(x) + log(17) + log1p(x))
+    assert delta4 == 0
+    assert (opt4.rewrite(exp).rewrite(log).rewrite(Pow) - expr4).simplify() == 0
+
+    expr5 = 3*exp(2*x) - 3
+    opt5 = optimize(expr5, optims_c99)
+    delta5 = opt5 - 3*expm1(2*x)
+    assert delta5 == 0
+    assert opt5.rewrite(exp) == expr5
+
+    expr6 = exp(2*x) - 3
+    opt6 = optimize(expr6, optims_c99)
+    assert opt6 in (expm1(2*x) - 2, expr6)  # expm1(2*x) - 2 is not better or worse
+
+    expr7 = log(3*x + 3)
+    opt7 = optimize(expr7, optims_c99)
+    delta7 = opt7 - (log(3) + log1p(x))
+    assert delta7 == 0
+    assert (opt7.rewrite(log) - expr7).simplify() == 0
+
+    expr8 = log(2*x + 3)
+    opt8 = optimize(expr8, optims_c99)
+    assert opt8 == expr8
+
+
+def test_create_expand_pow_optimization():
+    cc = lambda x: ccode(
+        optimize(x, [create_expand_pow_optimization(4)]))
+    x = Symbol('x')
+    assert cc(x**4) == 'x*x*x*x'
+    assert cc(x**4 + x**2) == 'x*x + x*x*x*x'
+    assert cc(x**5 + x**4) == 'pow(x, 5) + x*x*x*x'
+    assert cc(sin(x)**4) == 'pow(sin(x), 4)'
+    # gh issue 15335
+    assert cc(x**(-4)) == '1.0/(x*x*x*x)'
+    assert cc(x**(-5)) == 'pow(x, -5)'
+    assert cc(-x**4) == '-(x*x*x*x)'
+    assert cc(x**4 - x**2) == '-(x*x) + x*x*x*x'
+    i = Symbol('i', integer=True)
+    assert cc(x**i - x**2) == 'pow(x, i) - (x*x)'
+    y = Symbol('y', real=True)
+    assert cc(Abs(exp(y**4))) == "exp(y*y*y*y)"
+
+    # gh issue 20753
+    cc2 = lambda x: ccode(optimize(x, [create_expand_pow_optimization(
+        4, base_req=lambda b: b.is_Function)]))
+    assert cc2(x**3 + sin(x)**3) == "pow(x, 3) + sin(x)*sin(x)*sin(x)"
+
+
+def test_matsolve():
+    n = Symbol('n', integer=True)
+    A = MatrixSymbol('A', n, n)
+    x = MatrixSymbol('x', n, 1)
+
+    with assuming(Q.fullrank(A)):
+        assert optimize(A**(-1) * x, [matinv_opt]) == MatrixSolve(A, x)
+        assert optimize(A**(-1) * x + x, [matinv_opt]) == MatrixSolve(A, x) + x
+
+
+def test_logaddexp_opt():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = log(exp(x) + exp(y))
+    opt1 = optimize(expr1, [logaddexp_opt])
+    assert logaddexp(x, y) - opt1 == 0
+    assert logaddexp(y, x) - opt1 == 0
+    assert opt1.rewrite(log) == expr1
+
+
+def test_logaddexp2_opt():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = log(2**x + 2**y)/log(2)
+    opt1 = optimize(expr1, [logaddexp2_opt])
+    assert logaddexp2(x, y) - opt1 == 0
+    assert logaddexp2(y, x) - opt1 == 0
+    assert opt1.rewrite(log) == expr1
+
+
+def test_sinc_opts():
+    def check(d):
+        for k, v in d.items():
+            assert optimize(k, sinc_opts) == v
+
+    x = Symbol('x')
+    check({
+        sin(x)/x       : sinc(x),
+        sin(2*x)/(2*x) : sinc(2*x),
+        sin(3*x)/x     : 3*sinc(3*x),
+        x*sin(x)       : x*sin(x)
+    })
+
+    y = Symbol('y')
+    check({
+        sin(x*y)/(x*y)       : sinc(x*y),
+        y*sin(x/y)/x         : sinc(x/y),
+        sin(sin(x))/sin(x)   : sinc(sin(x)),
+        sin(3*sin(x))/sin(x) : 3*sinc(3*sin(x)),
+        sin(x)/y             : sin(x)/y
+    })
+
+
+def test_optims_numpy():
+    def check(d):
+        for k, v in d.items():
+            assert optimize(k, optims_numpy) == v
+
+    x = Symbol('x')
+    check({
+        sin(2*x)/(2*x) + exp(2*x) - 1: sinc(2*x) + expm1(2*x),
+        log(x+3)/log(2) + log(x**2 + 1): log1p(x**2) + log2(x+3)
+    })
+
+
+@XFAIL  # room for improvement, ideally this test case should pass.
+def test_optims_numpy_TODO():
+    def check(d):
+        for k, v in d.items():
+            assert optimize(k, optims_numpy) == v
+
+    x, y = map(Symbol, 'x y'.split())
+    check({
+        log(x*y)*sin(x*y)*log(x*y+1)/(log(2)*x*y): log2(x*y)*sinc(x*y)*log1p(x*y),
+        exp(x*sin(y)/y) - 1: expm1(x*sinc(y))
+    })
+
+
+@may_xfail
+def test_compiled_ccode_with_rewriting():
+    if not cython:
+        skip("cython not installed.")
+    if not has_c():
+        skip("No C compiler found.")
+
+    x = Symbol('x')
+    about_two = 2**(58/S(117))*3**(97/S(117))*5**(4/S(39))*7**(92/S(117))/S(30)*pi
+    # about_two: 1.999999999999581826
+    unchanged = 2*exp(x) - about_two
+    xval = S(10)**-11
+    ref = unchanged.subs(x, xval).n(19) # 2.0418173913673213e-11
+
+    rewritten = optimize(2*exp(x) - about_two, [expm1_opt])
+
+    # Unfortunately, we need to call ``.n()`` on our expressions before we hand them
+    # to ``ccode``, and we need to request a large number of significant digits.
+    # In this test, results converged for double precision when the following number
+    # of significant digits were chosen:
+    NUMBER_OF_DIGITS = 25   # TODO: this should ideally be automatically handled.
+
+    func_c = '''
+#include <math.h>
+
+double func_unchanged(double x) {
+    return %(unchanged)s;
+}
+double func_rewritten(double x) {
+    return %(rewritten)s;
+}
+''' % {"unchanged": ccode(unchanged.n(NUMBER_OF_DIGITS)),
+           "rewritten": ccode(rewritten.n(NUMBER_OF_DIGITS))}
+
+    func_pyx = '''
+#cython: language_level=3
+cdef extern double func_unchanged(double)
+cdef extern double func_rewritten(double)
+def py_unchanged(x):
+    return func_unchanged(x)
+def py_rewritten(x):
+    return func_rewritten(x)
+'''
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings(
+            [('func.c', func_c), ('_func.pyx', func_pyx)],
+            build_dir=folder, compile_kwargs={"std": 'c99'}
+        )
+        err_rewritten = abs(mod.py_rewritten(1e-11) - ref)
+        err_unchanged = abs(mod.py_unchanged(1e-11) - ref)
+        assert 1e-27 < err_rewritten < 1e-25  # highly accurate.
+        assert 1e-19 < err_unchanged < 1e-16  # quite poor.
+
+    # Tolerances used above were determined as follows:
+    # >>> no_opt = unchanged.subs(x, xval.evalf()).evalf()
+    # >>> with_opt = rewritten.n(25).subs(x, 1e-11).evalf()
+    # >>> with_opt - ref, no_opt - ref
+    # (1.1536301877952077e-26, 1.6547074214222335e-18)

.venv/lib/python3.13/site-packages/sympy/codegen/tests/test_scipy_nodes.py

@@ -0,0 +1,44 @@
+from itertools import product
+from sympy.core.power import Pow
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.trigonometric import cos
+from sympy.core.numbers import pi
+from sympy.codegen.scipy_nodes import cosm1, powm1
+
+x, y, z = symbols('x y z')
+
+
+def test_cosm1():
+    cm1_xy = cosm1(x*y)
+    ref_xy = cos(x*y) - 1
+    for wrt, deriv_order in product([x, y, z], range(3)):
+        assert (
+            cm1_xy.diff(wrt, deriv_order) -
+            ref_xy.diff(wrt, deriv_order)
+        ).rewrite(cos).simplify() == 0
+
+    expr_minus2 = cosm1(pi)
+    assert expr_minus2.rewrite(cos) == -2
+    assert cosm1(3.14).simplify() == cosm1(3.14)  # cannot simplify with 3.14
+    assert cosm1(pi/2).simplify() == -1
+    assert (1/cos(x) - 1 + cosm1(x)/cos(x)).simplify() == 0
+
+
+def test_powm1():
+    cases = {
+            powm1(x, y): x**y - 1,
+            powm1(x*y, z): (x*y)**z - 1,
+            powm1(x, y*z): x**(y*z)-1,
+            powm1(x*y*z, x*y*z): (x*y*z)**(x*y*z)-1
+    }
+    for pm1_e, ref_e in cases.items():
+        for wrt, deriv_order in product([x, y, z], range(3)):
+            der = pm1_e.diff(wrt, deriv_order)
+            ref = ref_e.diff(wrt, deriv_order)
+            delta = (der - ref).rewrite(Pow)
+            assert delta.simplify() == 0
+
+    eulers_constant_m1 = powm1(x, 1/log(x))
+    assert eulers_constant_m1.rewrite(Pow) == exp(1) - 1
+    assert eulers_constant_m1.simplify() == exp(1) - 1

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_coset_table.py

@@ -0,0 +1,825 @@
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.coset_table import (CosetTable,
+                    coset_enumeration_r, coset_enumeration_c)
+from sympy.combinatorics.coset_table import modified_coset_enumeration_r
+from sympy.combinatorics.free_groups import free_group
+
+from sympy.testing.pytest import slow
+
+"""
+References
+==========
+
+[1] Holt, D., Eick, B., O'Brien, E.
+"Handbook of Computational Group Theory"
+
+[2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+"Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+"""
+
+def test_scan_1():
+    # Example 5.1 from [1]
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    c = CosetTable(f, [x])
+
+    c.scan_and_fill(0, x)
+    assert c.table == [[0, 0, None, None]]
+    assert c.p == [0]
+    assert c.n == 1
+    assert c.omega == [0]
+
+    c.scan_and_fill(0, x**3)
+    assert c.table == [[0, 0, None, None]]
+    assert c.p == [0]
+    assert c.n == 1
+    assert c.omega == [0]
+
+    c.scan_and_fill(0, y**3)
+    assert c.table == [[0, 0, 1, 2], [None, None, 2, 0], [None, None, 0, 1]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(0, x**-1*y**-1*x*y)
+    assert c.table == [[0, 0, 1, 2], [None, None, 2, 0], [2, 2, 0, 1]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, x**3)
+    assert c.table == [[0, 0, 1, 2], [3, 4, 2, 0], [2, 2, 0, 1], \
+            [4, 1, None, None], [1, 3, None, None]]
+    assert c.p == [0, 1, 2, 3, 4]
+    assert c.n == 5
+    assert c.omega == [0, 1, 2, 3, 4]
+
+    c.scan_and_fill(1, y**3)
+    assert c.table == [[0, 0, 1, 2], [3, 4, 2, 0], [2, 2, 0, 1], \
+            [4, 1, None, None], [1, 3, None, None]]
+    assert c.p == [0, 1, 2, 3, 4]
+    assert c.n == 5
+    assert c.omega == [0, 1, 2, 3, 4]
+
+    c.scan_and_fill(1, x**-1*y**-1*x*y)
+    assert c.table == [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1], \
+            [None, 1, None, None], [1, 3, None, None]]
+    assert c.p == [0, 1, 2, 1, 1]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    # Example 5.2 from [1]
+    f = FpGroup(F, [x**2, y**3, (x*y)**3])
+    c = CosetTable(f, [x*y])
+
+    c.scan_and_fill(0, x*y)
+    assert c.table == [[1, None, None, 1], [None, 0, 0, None]]
+    assert c.p == [0, 1]
+    assert c.n == 2
+    assert c.omega == [0, 1]
+
+    c.scan_and_fill(0, x**2)
+    assert c.table == [[1, 1, None, 1], [0, 0, 0, None]]
+    assert c.p == [0, 1]
+    assert c.n == 2
+    assert c.omega == [0, 1]
+
+    c.scan_and_fill(0, y**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(0, (x*y)**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, x**2)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, y**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, (x*y)**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [3, 4, 1, 0], [None, 2, 4, None], [2, None, None, 3]]
+    assert c.p == [0, 1, 2, 3, 4]
+    assert c.n == 5
+    assert c.omega == [0, 1, 2, 3, 4]
+
+    c.scan_and_fill(2, x**2)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [3, 3, 1, 0], [2, 2, 3, 3], [2, None, None, 3]]
+    assert c.p == [0, 1, 2, 3, 3]
+    assert c.n == 4
+    assert c.omega == [0, 1, 2, 3]
+
+
+@slow
+def test_coset_enumeration():
+    # this test function contains the combined tests for the two strategies
+    # i.e. HLT and Felsch strategies.
+
+    # Example 5.1 from [1]
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    C_r = coset_enumeration_r(f, [x])
+    C_r.compress(); C_r.standardize()
+    C_c = coset_enumeration_c(f, [x])
+    C_c.compress(); C_c.standardize()
+    table1 = [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]]
+    assert C_r.table == table1
+    assert C_c.table == table1
+
+    # E1 from [2] Pg. 474
+    F, r, s, t = free_group("r, s, t")
+    E1 = FpGroup(F, [t**-1*r*t*r**-2, r**-1*s*r*s**-2, s**-1*t*s*t**-2])
+    C_r = coset_enumeration_r(E1, [])
+    C_r.compress()
+    C_c = coset_enumeration_c(E1, [])
+    C_c.compress()
+    table2 = [[0, 0, 0, 0, 0, 0]]
+    assert C_r.table == table2
+    # test for issue #11449
+    assert C_c.table == table2
+
+    # Cox group from [2] Pg. 474
+    F, a, b = free_group("a, b")
+    Cox = FpGroup(F, [a**6, b**6, (a*b)**2, (a**2*b**2)**2, (a**3*b**3)**5])
+    C_r = coset_enumeration_r(Cox, [a])
+    C_r.compress(); C_r.standardize()
+    C_c = coset_enumeration_c(Cox, [a])
+    C_c.compress(); C_c.standardize()
+    table3 = [[0, 0, 1, 2],
+             [2, 3, 4, 0],
+             [5, 1, 0, 6],
+             [1, 7, 8, 9],
+             [9, 10, 11, 1],
+             [12, 2, 9, 13],
+             [14, 9, 2, 11],
+             [3, 12, 15, 16],
+             [16, 17, 18, 3],
+             [6, 4, 3, 5],
+             [4, 19, 20, 21],
+             [21, 22, 6, 4],
+             [7, 5, 23, 24],
+             [25, 23, 5, 18],
+             [19, 6, 22, 26],
+             [24, 27, 28, 7],
+             [29, 8, 7, 30],
+             [8, 31, 32, 33],
+             [33, 34, 13, 8],
+             [10, 14, 35, 35],
+             [35, 36, 37, 10],
+             [30, 11, 10, 29],
+             [11, 38, 39, 14],
+             [13, 39, 38, 12],
+             [40, 15, 12, 41],
+             [42, 13, 34, 43],
+             [44, 35, 14, 45],
+             [15, 46, 47, 34],
+             [34, 48, 49, 15],
+             [50, 16, 21, 51],
+             [52, 21, 16, 49],
+             [17, 50, 53, 54],
+             [54, 55, 56, 17],
+             [41, 18, 17, 40],
+             [18, 28, 27, 25],
+             [26, 20, 19, 19],
+             [20, 57, 58, 59],
+             [59, 60, 51, 20],
+             [22, 52, 61, 23],
+             [23, 62, 63, 22],
+             [64, 24, 33, 65],
+             [48, 33, 24, 61],
+             [62, 25, 54, 66],
+             [67, 54, 25, 68],
+             [57, 26, 59, 69],
+             [70, 59, 26, 63],
+             [27, 64, 71, 72],
+             [72, 73, 68, 27],
+             [28, 41, 74, 75],
+             [75, 76, 30, 28],
+             [31, 29, 77, 78],
+             [79, 77, 29, 37],
+             [38, 30, 76, 80],
+             [78, 81, 82, 31],
+             [43, 32, 31, 42],
+             [32, 83, 84, 85],
+             [85, 86, 65, 32],
+             [36, 44, 87, 88],
+             [88, 89, 90, 36],
+             [45, 37, 36, 44],
+             [37, 82, 81, 79],
+             [80, 74, 41, 38],
+             [39, 42, 91, 92],
+             [92, 93, 45, 39],
+             [46, 40, 94, 95],
+             [96, 94, 40, 56],
+             [97, 91, 42, 82],
+             [83, 43, 98, 99],
+             [100, 98, 43, 47],
+             [101, 87, 44, 90],
+             [82, 45, 93, 97],
+             [95, 102, 103, 46],
+             [104, 47, 46, 105],
+             [47, 106, 107, 100],
+             [61, 108, 109, 48],
+             [105, 49, 48, 104],
+             [49, 110, 111, 52],
+             [51, 111, 110, 50],
+             [112, 53, 50, 113],
+             [114, 51, 60, 115],
+             [116, 61, 52, 117],
+             [53, 118, 119, 60],
+             [60, 70, 66, 53],
+             [55, 67, 120, 121],
+             [121, 122, 123, 55],
+             [113, 56, 55, 112],
+             [56, 103, 102, 96],
+             [69, 124, 125, 57],
+             [115, 58, 57, 114],
+             [58, 126, 127, 128],
+             [128, 128, 69, 58],
+             [66, 129, 130, 62],
+             [117, 63, 62, 116],
+             [63, 125, 124, 70],
+             [65, 109, 108, 64],
+             [131, 71, 64, 132],
+             [133, 65, 86, 134],
+             [135, 66, 70, 136],
+             [68, 130, 129, 67],
+             [137, 120, 67, 138],
+             [132, 68, 73, 131],
+             [139, 69, 128, 140],
+             [71, 141, 142, 86],
+             [86, 143, 144, 71],
+             [145, 72, 75, 146],
+             [147, 75, 72, 144],
+             [73, 145, 148, 120],
+             [120, 149, 150, 73],
+             [74, 151, 152, 94],
+             [94, 153, 146, 74],
+             [76, 147, 154, 77],
+             [77, 155, 156, 76],
+             [157, 78, 85, 158],
+             [143, 85, 78, 154],
+             [155, 79, 88, 159],
+             [160, 88, 79, 161],
+             [151, 80, 92, 162],
+             [163, 92, 80, 156],
+             [81, 157, 164, 165],
+             [165, 166, 161, 81],
+             [99, 107, 106, 83],
+             [134, 84, 83, 133],
+             [84, 167, 168, 169],
+             [169, 170, 158, 84],
+             [87, 171, 172, 93],
+             [93, 163, 159, 87],
+             [89, 160, 173, 174],
+             [174, 175, 176, 89],
+             [90, 90, 89, 101],
+             [91, 177, 178, 98],
+             [98, 179, 162, 91],
+             [180, 95, 100, 181],
+             [179, 100, 95, 152],
+             [153, 96, 121, 148],
+             [182, 121, 96, 183],
+             [177, 97, 165, 184],
+             [185, 165, 97, 172],
+             [186, 99, 169, 187],
+             [188, 169, 99, 178],
+             [171, 101, 174, 189],
+             [190, 174, 101, 176],
+             [102, 180, 191, 192],
+             [192, 193, 183, 102],
+             [103, 113, 194, 195],
+             [195, 196, 105, 103],
+             [106, 104, 197, 198],
+             [199, 197, 104, 109],
+             [110, 105, 196, 200],
+             [198, 201, 133, 106],
+             [107, 186, 202, 203],
+             [203, 204, 181, 107],
+             [108, 116, 205, 206],
+             [206, 207, 132, 108],
+             [109, 133, 201, 199],
+             [200, 194, 113, 110],
+             [111, 114, 208, 209],
+             [209, 210, 117, 111],
+             [118, 112, 211, 212],
+             [213, 211, 112, 123],
+             [214, 208, 114, 125],
+             [126, 115, 215, 216],
+             [217, 215, 115, 119],
+             [218, 205, 116, 130],
+             [125, 117, 210, 214],
+             [212, 219, 220, 118],
+             [136, 119, 118, 135],
+             [119, 221, 222, 217],
+             [122, 182, 223, 224],
+             [224, 225, 226, 122],
+             [138, 123, 122, 137],
+             [123, 220, 219, 213],
+             [124, 139, 227, 228],
+             [228, 229, 136, 124],
+             [216, 222, 221, 126],
+             [140, 127, 126, 139],
+             [127, 230, 231, 232],
+             [232, 233, 140, 127],
+             [129, 135, 234, 235],
+             [235, 236, 138, 129],
+             [130, 132, 207, 218],
+             [141, 131, 237, 238],
+             [239, 237, 131, 150],
+             [167, 134, 240, 241],
+             [242, 240, 134, 142],
+             [243, 234, 135, 220],
+             [221, 136, 229, 244],
+             [149, 137, 245, 246],
+             [247, 245, 137, 226],
+             [220, 138, 236, 243],
+             [244, 227, 139, 221],
+             [230, 140, 233, 248],
+             [238, 249, 250, 141],
+             [251, 142, 141, 252],
+             [142, 253, 254, 242],
+             [154, 255, 256, 143],
+             [252, 144, 143, 251],
+             [144, 257, 258, 147],
+             [146, 258, 257, 145],
+             [259, 148, 145, 260],
+             [261, 146, 153, 262],
+             [263, 154, 147, 264],
+             [148, 265, 266, 153],
+             [246, 267, 268, 149],
+             [260, 150, 149, 259],
+             [150, 250, 249, 239],
+             [162, 269, 270, 151],
+             [262, 152, 151, 261],
+             [152, 271, 272, 179],
+             [159, 273, 274, 155],
+             [264, 156, 155, 263],
+             [156, 270, 269, 163],
+             [158, 256, 255, 157],
+             [275, 164, 157, 276],
+             [277, 158, 170, 278],
+             [279, 159, 163, 280],
+             [161, 274, 273, 160],
+             [281, 173, 160, 282],
+             [276, 161, 166, 275],
+             [283, 162, 179, 284],
+             [164, 285, 286, 170],
+             [170, 188, 184, 164],
+             [166, 185, 189, 173],
+             [173, 287, 288, 166],
+             [241, 254, 253, 167],
+             [278, 168, 167, 277],
+             [168, 289, 290, 291],
+             [291, 292, 187, 168],
+             [189, 293, 294, 171],
+             [280, 172, 171, 279],
+             [172, 295, 296, 185],
+             [175, 190, 297, 297],
+             [297, 298, 299, 175],
+             [282, 176, 175, 281],
+             [176, 294, 293, 190],
+             [184, 296, 295, 177],
+             [284, 178, 177, 283],
+             [178, 300, 301, 188],
+             [181, 272, 271, 180],
+             [302, 191, 180, 303],
+             [304, 181, 204, 305],
+             [183, 266, 265, 182],
+             [306, 223, 182, 307],
+             [303, 183, 193, 302],
+             [308, 184, 188, 309],
+             [310, 189, 185, 311],
+             [187, 301, 300, 186],
+             [305, 202, 186, 304],
+             [312, 187, 292, 313],
+             [314, 297, 190, 315],
+             [191, 316, 317, 204],
+             [204, 318, 319, 191],
+             [320, 192, 195, 321],
+             [322, 195, 192, 319],
+             [193, 320, 323, 223],
+             [223, 324, 325, 193],
+             [194, 326, 327, 211],
+             [211, 328, 321, 194],
+             [196, 322, 329, 197],
+             [197, 330, 331, 196],
+             [332, 198, 203, 333],
+             [318, 203, 198, 329],
+             [330, 199, 206, 334],
+             [335, 206, 199, 336],
+             [326, 200, 209, 337],
+             [338, 209, 200, 331],
+             [201, 332, 339, 240],
+             [240, 340, 336, 201],
+             [202, 341, 342, 292],
+             [292, 343, 333, 202],
+             [205, 344, 345, 210],
+             [210, 338, 334, 205],
+             [207, 335, 346, 237],
+             [237, 347, 348, 207],
+             [208, 349, 350, 215],
+             [215, 351, 337, 208],
+             [352, 212, 217, 353],
+             [351, 217, 212, 327],
+             [328, 213, 224, 323],
+             [354, 224, 213, 355],
+             [349, 214, 228, 356],
+             [357, 228, 214, 345],
+             [358, 216, 232, 359],
+             [360, 232, 216, 350],
+             [344, 218, 235, 361],
+             [362, 235, 218, 348],
+             [219, 352, 363, 364],
+             [364, 365, 355, 219],
+             [222, 358, 366, 367],
+             [367, 368, 353, 222],
+             [225, 354, 369, 370],
+             [370, 371, 372, 225],
+             [307, 226, 225, 306],
+             [226, 268, 267, 247],
+             [227, 373, 374, 233],
+             [233, 360, 356, 227],
+             [229, 357, 361, 234],
+             [234, 375, 376, 229],
+             [248, 231, 230, 230],
+             [231, 377, 378, 379],
+             [379, 380, 359, 231],
+             [236, 362, 381, 245],
+             [245, 382, 383, 236],
+             [384, 238, 242, 385],
+             [340, 242, 238, 346],
+             [347, 239, 246, 381],
+             [386, 246, 239, 387],
+             [388, 241, 291, 389],
+             [343, 291, 241, 339],
+             [375, 243, 364, 390],
+             [391, 364, 243, 383],
+             [373, 244, 367, 392],
+             [393, 367, 244, 376],
+             [382, 247, 370, 394],
+             [395, 370, 247, 396],
+             [377, 248, 379, 397],
+             [398, 379, 248, 374],
+             [249, 384, 399, 400],
+             [400, 401, 387, 249],
+             [250, 260, 402, 403],
+             [403, 404, 252, 250],
+             [253, 251, 405, 406],
+             [407, 405, 251, 256],
+             [257, 252, 404, 408],
+             [406, 409, 277, 253],
+             [254, 388, 410, 411],
+             [411, 412, 385, 254],
+             [255, 263, 413, 414],
+             [414, 415, 276, 255],
+             [256, 277, 409, 407],
+             [408, 402, 260, 257],
+             [258, 261, 416, 417],
+             [417, 418, 264, 258],
+             [265, 259, 419, 420],
+             [421, 419, 259, 268],
+             [422, 416, 261, 270],
+             [271, 262, 423, 424],
+             [425, 423, 262, 266],
+             [426, 413, 263, 274],
+             [270, 264, 418, 422],
+             [420, 427, 307, 265],
+             [266, 303, 428, 425],
+             [267, 386, 429, 430],
+             [430, 431, 396, 267],
+             [268, 307, 427, 421],
+             [269, 283, 432, 433],
+             [433, 434, 280, 269],
+             [424, 428, 303, 271],
+             [272, 304, 435, 436],
+             [436, 437, 284, 272],
+             [273, 279, 438, 439],
+             [439, 440, 282, 273],
+             [274, 276, 415, 426],
+             [285, 275, 441, 442],
+             [443, 441, 275, 288],
+             [289, 278, 444, 445],
+             [446, 444, 278, 286],
+             [447, 438, 279, 294],
+             [295, 280, 434, 448],
+             [287, 281, 449, 450],
+             [451, 449, 281, 299],
+             [294, 282, 440, 447],
+             [448, 432, 283, 295],
+             [300, 284, 437, 452],
+             [442, 453, 454, 285],
+             [309, 286, 285, 308],
+             [286, 455, 456, 446],
+             [450, 457, 458, 287],
+             [311, 288, 287, 310],
+             [288, 454, 453, 443],
+             [445, 456, 455, 289],
+             [313, 290, 289, 312],
+             [290, 459, 460, 461],
+             [461, 462, 389, 290],
+             [293, 310, 463, 464],
+             [464, 465, 315, 293],
+             [296, 308, 466, 467],
+             [467, 468, 311, 296],
+             [298, 314, 469, 470],
+             [470, 471, 472, 298],
+             [315, 299, 298, 314],
+             [299, 458, 457, 451],
+             [452, 435, 304, 300],
+             [301, 312, 473, 474],
+             [474, 475, 309, 301],
+             [316, 302, 476, 477],
+             [478, 476, 302, 325],
+             [341, 305, 479, 480],
+             [481, 479, 305, 317],
+             [324, 306, 482, 483],
+             [484, 482, 306, 372],
+             [485, 466, 308, 454],
+             [455, 309, 475, 486],
+             [487, 463, 310, 458],
+             [454, 311, 468, 485],
+             [486, 473, 312, 455],
+             [459, 313, 488, 489],
+             [490, 488, 313, 342],
+             [491, 469, 314, 472],
+             [458, 315, 465, 487],
+             [477, 492, 485, 316],
+             [463, 317, 316, 468],
+             [317, 487, 493, 481],
+             [329, 447, 464, 318],
+             [468, 319, 318, 463],
+             [319, 467, 448, 322],
+             [321, 448, 467, 320],
+             [475, 323, 320, 466],
+             [432, 321, 328, 437],
+             [438, 329, 322, 434],
+             [323, 474, 452, 328],
+             [483, 494, 486, 324],
+             [466, 325, 324, 475],
+             [325, 485, 492, 478],
+             [337, 422, 433, 326],
+             [437, 327, 326, 432],
+             [327, 436, 424, 351],
+             [334, 426, 439, 330],
+             [434, 331, 330, 438],
+             [331, 433, 422, 338],
+             [333, 464, 447, 332],
+             [449, 339, 332, 440],
+             [465, 333, 343, 469],
+             [413, 334, 338, 418],
+             [336, 439, 426, 335],
+             [441, 346, 335, 415],
+             [440, 336, 340, 449],
+             [416, 337, 351, 423],
+             [339, 451, 470, 343],
+             [346, 443, 450, 340],
+             [480, 493, 487, 341],
+             [469, 342, 341, 465],
+             [342, 491, 495, 490],
+             [361, 407, 414, 344],
+             [418, 345, 344, 413],
+             [345, 417, 408, 357],
+             [381, 446, 442, 347],
+             [415, 348, 347, 441],
+             [348, 414, 407, 362],
+             [356, 408, 417, 349],
+             [423, 350, 349, 416],
+             [350, 425, 420, 360],
+             [353, 424, 436, 352],
+             [479, 363, 352, 435],
+             [428, 353, 368, 476],
+             [355, 452, 474, 354],
+             [488, 369, 354, 473],
+             [435, 355, 365, 479],
+             [402, 356, 360, 419],
+             [405, 361, 357, 404],
+             [359, 420, 425, 358],
+             [476, 366, 358, 428],
+             [427, 359, 380, 482],
+             [444, 381, 362, 409],
+             [363, 481, 477, 368],
+             [368, 393, 390, 363],
+             [365, 391, 394, 369],
+             [369, 490, 480, 365],
+             [366, 478, 483, 380],
+             [380, 398, 392, 366],
+             [371, 395, 496, 497],
+             [497, 498, 489, 371],
+             [473, 372, 371, 488],
+             [372, 486, 494, 484],
+             [392, 400, 403, 373],
+             [419, 374, 373, 402],
+             [374, 421, 430, 398],
+             [390, 411, 406, 375],
+             [404, 376, 375, 405],
+             [376, 403, 400, 393],
+             [397, 430, 421, 377],
+             [482, 378, 377, 427],
+             [378, 484, 497, 499],
+             [499, 499, 397, 378],
+             [394, 461, 445, 382],
+             [409, 383, 382, 444],
+             [383, 406, 411, 391],
+             [385, 450, 443, 384],
+             [492, 399, 384, 453],
+             [457, 385, 412, 493],
+             [387, 442, 446, 386],
+             [494, 429, 386, 456],
+             [453, 387, 401, 492],
+             [389, 470, 451, 388],
+             [493, 410, 388, 457],
+             [471, 389, 462, 495],
+             [412, 390, 393, 399],
+             [462, 394, 391, 410],
+             [401, 392, 398, 429],
+             [396, 445, 461, 395],
+             [498, 496, 395, 460],
+             [456, 396, 431, 494],
+             [431, 397, 499, 496],
+             [399, 477, 481, 412],
+             [429, 483, 478, 401],
+             [410, 480, 490, 462],
+             [496, 497, 484, 431],
+             [489, 495, 491, 459],
+             [495, 460, 459, 471],
+             [460, 489, 498, 498],
+             [472, 472, 471, 491]]
+
+    assert C_r.table == table3
+    assert C_c.table == table3
+
+    # Group denoted by B2,4 from [2] Pg. 474
+    F, a, b = free_group("a, b")
+    B_2_4 = FpGroup(F, [a**4, b**4, (a*b)**4, (a**-1*b)**4, (a**2*b)**4, \
+            (a*b**2)**4, (a**2*b**2)**4, (a**-1*b*a*b)**4, (a*b**-1*a*b)**4])
+    C_r = coset_enumeration_r(B_2_4, [a])
+    C_c = coset_enumeration_c(B_2_4, [a])
+    index_r = 0
+    for i in range(len(C_r.p)):
+        if C_r.p[i] == i:
+            index_r += 1
+    assert index_r == 1024
+
+    index_c = 0
+    for i in range(len(C_c.p)):
+        if C_c.p[i] == i:
+            index_c += 1
+    assert index_c == 1024
+
+    # trivial Macdonald group G(2,2) from [2] Pg. 480
+    M = FpGroup(F, [b**-1*a**-1*b*a*b**-1*a*b*a**-2, a**-1*b**-1*a*b*a**-1*b*a*b**-2])
+    C_r = coset_enumeration_r(M, [a])
+    C_r.compress(); C_r.standardize()
+    C_c = coset_enumeration_c(M, [a])
+    C_c.compress(); C_c.standardize()
+    table4 = [[0, 0, 0, 0]]
+    assert C_r.table == table4
+    assert C_c.table == table4
+
+
+def test_look_ahead():
+    # Section 3.2 [Test Example] Example (d) from [2]
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**11, b**5, c**4, (a*c)**3, b**2*c**-1*b**-1*c, a**4*b**-1*a**-1*b])
+    H = [c, b, c**2]
+    table0 = [[1, 2, 0, 0, 0, 0],
+              [3, 0, 4, 5, 6, 7],
+              [0, 8, 9, 10, 11, 12],
+              [5, 1, 10, 13, 14, 15],
+              [16, 5, 16, 1, 17, 18],
+              [4, 3, 1, 8, 19, 20],
+              [12, 21, 22, 23, 24, 1],
+              [25, 26, 27, 28, 1, 24],
+              [2, 10, 5, 16, 22, 28],
+              [10, 13, 13, 2, 29, 30]]
+    CosetTable.max_stack_size = 10
+    C_c = coset_enumeration_c(f, H)
+    C_c.compress(); C_c.standardize()
+    assert C_c.table[: 10] == table0
+
+def test_modified_methods():
+    '''
+    Tests for modified coset table methods.
+    Example 5.7 from [1] Holt, D., Eick, B., O'Brien
+    "Handbook of Computational Group Theory".
+
+    '''
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    C = CosetTable(f, H)
+    C.modified_define(0, x)
+    identity = C._grp.identity
+    a_0 = C._grp.generators[0]
+    a_1 = C._grp.generators[1]
+
+    assert C.P == [[identity, None, None, None],
+                    [None, identity, None, None]]
+    assert C.table == [[1, None, None, None],
+                        [None, 0, None, None]]
+
+    C.modified_define(1, x)
+    assert C.table == [[1, None, None, None],
+                        [2, 0, None, None],
+                        [None, 1, None, None]]
+    assert C.P == [[identity, None, None, None],
+                    [identity, identity, None, None],
+                    [None, identity, None, None]]
+
+    C.modified_scan(0, x**3, C._grp.identity, fill=False)
+    assert C.P == [[identity, identity, None, None],
+                     [identity, identity, None, None],
+                     [identity, identity, None, None]]
+    assert C.table == [[1, 2, None, None],
+                        [2, 0, None, None],
+                        [0, 1, None, None]]
+
+    C.modified_scan(0, x*y, C._grp.generators[0], fill=False)
+    assert C.P == [[identity, identity, None, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, None]]
+    assert C.table == [[1, 2, None, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, None]]
+
+    C.modified_define(2, y**-1)
+    assert C.table == [[1, 2, None, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, 3],
+                        [None, None, 2, None]]
+    assert C.P == [[identity, identity, None, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, identity],
+                    [None, None, identity, None]]
+
+    C.modified_scan(0, x**-1*y**-1*x*y*x, C._grp.generators[1])
+    assert C.table == [[1, 2, None, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, 3],
+                        [3, 3, 2, None]]
+    assert C.P == [[identity, identity, None, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, identity],
+                    [a_1, a_1**-1, identity, None]]
+
+    C.modified_scan(2, (x*y)**2, C._grp.identity)
+    assert C.table == [[1, 2, 3, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, 3],
+                        [3, 3, 2, 0]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, identity],
+                    [a_1, a_1**-1, identity, a_1]]
+
+    C.modified_define(2, y)
+    assert C.table == [[1, 2, 3, 1],
+                        [2, 0, 0, None],
+                        [0, 1, 4, 3],
+                        [3, 3, 2, 0],
+                        [None, None, None, 2]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, identity, identity],
+                    [a_1, a_1**-1, identity, a_1],
+                    [None, None, None, identity]]
+
+    C.modified_scan(0, y**5, C._grp.identity)
+    assert C.table == [[1, 2, 3, 1], [2, 0, 0, 4], [0, 1, 4, 3], [3, 3, 2, 0], [None, None, 1, 2]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, a_0*a_1**-1],
+                    [identity, identity, identity, identity],
+                    [a_1, a_1**-1, identity, a_1],
+                    [None, None, a_1*a_0**-1, identity]]
+
+    C.modified_scan(1, (x*y)**2, C._grp.identity)
+    assert C.table == [[1, 2, 3, 1],
+                        [2, 0, 0, 4],
+                        [0, 1, 4, 3],
+                        [3, 3, 2, 0],
+                        [4, 4, 1, 2]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, a_0*a_1**-1],
+                    [identity, identity, identity, identity],
+                    [a_1, a_1**-1, identity, a_1],
+                    [a_0*a_1**-1, a_1*a_0**-1, a_1*a_0**-1, identity]]
+
+    # Modified coset enumeration test
+    f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    C = coset_enumeration_r(f, [x])
+    C_m = modified_coset_enumeration_r(f, [x])
+    assert C_m.table == C.table

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_fp_groups.py

@@ -0,0 +1,257 @@
+from sympy.core.singleton import S
+from sympy.combinatorics.fp_groups import (FpGroup, low_index_subgroups,
+                                   reidemeister_presentation, FpSubgroup,
+                                           simplify_presentation)
+from sympy.combinatorics.free_groups import (free_group, FreeGroup)
+
+from sympy.testing.pytest import slow
+
+"""
+References
+==========
+
+[1] Holt, D., Eick, B., O'Brien, E.
+"Handbook of Computational Group Theory"
+
+[2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+"Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+[3] PROC. SECOND  INTERNAT. CONF. THEORY OF GROUPS, CANBERRA 1973,
+pp. 347-356. "A Reidemeister-Schreier program" by George Havas.
+http://staff.itee.uq.edu.au/havas/1973cdhw.pdf
+
+"""
+
+def test_low_index_subgroups():
+    F, x, y = free_group("x, y")
+
+    # Example 5.10 from [1] Pg. 194
+    f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    L = low_index_subgroups(f, 4)
+    t1 = [[[0, 0, 0, 0]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 3, 3]],
+          [[0, 0, 1, 2], [2, 2, 2, 0], [1, 1, 0, 1]],
+          [[1, 1, 0, 0], [0, 0, 1, 1]]]
+    for i in range(len(t1)):
+        assert L[i].table == t1[i]
+
+    f = FpGroup(F, [x**2, y**3, (x*y)**7])
+    L = low_index_subgroups(f, 15)
+    t2 = [[[0, 0, 0, 0]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [4, 4, 5, 3], [6, 6, 3, 4], [5, 5, 6, 6]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [5, 5, 3, 4], [4, 4, 6, 6]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [9, 9, 6, 8], [12, 12, 11, 7], [8, 8, 7, 10],
+            [10, 10, 13, 14], [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [12, 12, 6, 8], [10, 10, 11, 7], [8, 8, 7, 10],
+            [9, 9, 13, 14], [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [12, 12, 6, 8], [13, 13, 11, 7], [8, 8, 7, 10],
+            [9, 9, 12, 12], [10, 10, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 3, 3], [2, 2, 5, 6]
+            , [7, 7, 6, 4], [8, 8, 4, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [11, 11, 12, 10], [13, 13, 10, 11],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 3, 3], [2, 2, 5, 6]
+            , [7, 7, 6, 4], [8, 8, 4, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [13, 13, 12, 10], [12, 12, 10, 11],
+            [11, 11, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 4, 4]
+            , [7, 7, 6, 3], [8, 8, 3, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [13, 13, 12, 10], [12, 12, 10, 11],
+            [11, 11, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [5, 5, 6, 3], [9, 9, 3, 5], [10, 10, 8, 4], [8, 8, 4, 7],
+            [6, 6, 10, 11], [7, 7, 11, 9], [12, 12, 9, 10], [11, 11, 13, 14],
+            [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [6, 6, 6, 3], [5, 5, 3, 5], [8, 8, 8, 4], [7, 7, 4, 7]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [6, 6, 3, 5], [10, 10, 8, 4], [11, 11, 4, 7],
+            [5, 5, 10, 12], [7, 7, 12, 9], [8, 8, 11, 11], [13, 13, 9, 10],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [6, 6, 3, 5], [10, 10, 8, 4], [11, 11, 4, 7],
+            [5, 5, 12, 11], [7, 7, 10, 10], [8, 8, 9, 12], [13, 13, 11, 9],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [7, 7, 8, 4], [11, 11, 4, 7],
+            [5, 5, 9, 9], [6, 6, 11, 12], [8, 8, 12, 10], [13, 13, 10, 11],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [7, 7, 8, 4], [11, 11, 4, 7],
+            [5, 5, 12, 11], [6, 6, 10, 10], [8, 8, 9, 12], [13, 13, 11, 9],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [11, 11, 8, 4], [12, 12, 4, 7],
+            [5, 5, 9, 9], [6, 6, 12, 13], [7, 7, 11, 11], [8, 8, 13, 10],
+            [13, 13, 10, 12]],
+           [[1, 1, 0, 0], [0, 0, 2, 3], [4, 4, 3, 1], [5, 5, 1, 2], [2, 2, 4, 4]
+            , [3, 3, 6, 7], [7, 7, 7, 5], [6, 6, 5, 6]]]
+    for i  in range(len(t2)):
+        assert L[i].table == t2[i]
+
+    f = FpGroup(F, [x**2, y**3, (x*y)**7])
+    L = low_index_subgroups(f, 10, [x])
+    t3 = [[[0, 0, 0, 0]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5], [4, 4, 5, 3],
+           [6, 6, 3, 4], [5, 5, 6, 6]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5], [6, 6, 5, 3],
+           [5, 5, 3, 4], [4, 4, 6, 6]],
+          [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8],
+           [6, 6, 6, 3], [5, 5, 3, 5], [8, 8, 8, 4], [7, 7, 4, 7]]]
+    for i in range(len(t3)):
+        assert L[i].table == t3[i]
+
+
+def test_subgroup_presentations():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    p1 = reidemeister_presentation(f, H)
+    assert str(p1) == "((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1))"
+
+    H = f.subgroup(H)
+    assert (H.generators, H.relators) == p1
+
+    f = FpGroup(F, [x**3, y**3, (x*y)**3])
+    H = [x*y, x*y**-1]
+    p2 = reidemeister_presentation(f, H)
+    assert str(p2) == "((x_0, y_0), (x_0**3, y_0**3, x_0*y_0*x_0*y_0*x_0*y_0))"
+
+    f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    H = [x]
+    p3 = reidemeister_presentation(f, H)
+    assert str(p3) == "((x_0,), (x_0**4,))"
+
+    f = FpGroup(F, [x**3*y**-3, (x*y)**3, (x*y**-1)**2])
+    H = [x]
+    p4 = reidemeister_presentation(f, H)
+    assert str(p4) == "((x_0,), (x_0**6,))"
+
+    # this presentation can be improved, the most simplified form
+    # of presentation is <a, b | a^11, b^2, (a*b)^3, (a^4*b*a^-5*b)^2>
+    # See [2] Pg 474 group PSL_2(11)
+    # This is the group PSL_2(11)
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**11, b**5, c**4, (b*c**2)**2, (a*b*c)**3, (a**4*c**2)**3, b**2*c**-1*b**-1*c, a**4*b**-1*a**-1*b])
+    H = [a, b, c**2]
+    gens, rels = reidemeister_presentation(f, H)
+    assert str(gens) == "(b_1, c_3)"
+    assert len(rels) == 18
+
+
+@slow
+def test_order():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert f.order() == 8
+
+    f = FpGroup(F, [x*y*x**-1*y**-1, y**2])
+    assert f.order() is S.Infinity
+
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**250, b**2, c*b*c**-1*b, c**4, c**-1*a**-1*c*a, a**-1*b**-1*a*b])
+    assert f.order() == 2000
+
+    F, x = free_group("x")
+    f = FpGroup(F, [])
+    assert f.order() is S.Infinity
+
+    f = FpGroup(free_group('')[0], [])
+    assert f.order() == 1
+
+def test_fp_subgroup():
+    def _test_subgroup(K, T, S):
+        _gens = T(K.generators)
+        assert all(elem in S for elem in _gens)
+        assert T.is_injective()
+        assert T.image().order() == S.order()
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    S = FpSubgroup(f, [x*y])
+    assert (x*y)**-3 in S
+    K, T = f.subgroup([x*y], homomorphism=True)
+    assert T(K.generators) == [y*x**-1]
+    _test_subgroup(K, T, S)
+
+    S = FpSubgroup(f, [x**-1*y*x])
+    assert x**-1*y**4*x in S
+    assert x**-1*y**4*x**2 not in S
+    K, T = f.subgroup([x**-1*y*x], homomorphism=True)
+    assert T(K.generators[0]**3) == y**3
+    _test_subgroup(K, T, S)
+
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    K, T = f.subgroup(H, homomorphism=True)
+    S = FpSubgroup(f, H)
+    _test_subgroup(K, T, S)
+
+def test_permutation_methods():
+    F, x, y = free_group("x, y")
+    # DihedralGroup(8)
+    G = FpGroup(F, [x**2, y**8, x*y*x**-1*y])
+    T = G._to_perm_group()[1]
+    assert T.is_isomorphism()
+    assert G.center() == [y**4]
+
+    # DiheadralGroup(4)
+    G = FpGroup(F, [x**2, y**4, x*y*x**-1*y])
+    S = FpSubgroup(G, G.normal_closure([x]))
+    assert x in S
+    assert y**-1*x*y in S
+
+    # Z_5xZ_4
+    G = FpGroup(F, [x*y*x**-1*y**-1, y**5, x**4])
+    assert G.is_abelian
+    assert G.is_solvable
+
+    # AlternatingGroup(5)
+    G = FpGroup(F, [x**3, y**2, (x*y)**5])
+    assert not G.is_solvable
+
+    # AlternatingGroup(4)
+    G = FpGroup(F, [x**3, y**2, (x*y)**3])
+    assert len(G.derived_series()) == 3
+    S = FpSubgroup(G, G.derived_subgroup())
+    assert S.order() == 4
+
+
+def test_simplify_presentation():
+    # ref #16083
+    G = simplify_presentation(FpGroup(FreeGroup([]), []))
+    assert not G.generators
+    assert not G.relators
+
+    # CyclicGroup(3)
+    # The second generator in <x, y | x^2, x^5, y^3> is trivial due to relators {x^2, x^5}
+    F, x, y = free_group("x, y")
+    G = simplify_presentation(FpGroup(F, [x**2, x**5, y**3]))
+    assert x in G.relators
+
+def test_cyclic():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x])
+    assert f.is_cyclic
+    f = FpGroup(F, [x*y, x*y**-1])
+    assert f.is_cyclic
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert not f.is_cyclic
+
+
+def test_abelian_invariants():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x])
+    assert f.abelian_invariants() == []
+    f = FpGroup(F, [x*y, x*y**-1])
+    assert f.abelian_invariants() == [2]
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert f.abelian_invariants() == [2, 4]

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_free_groups.py

@@ -0,0 +1,226 @@
+from sympy.combinatorics.free_groups import free_group, FreeGroup
+from sympy.core import Symbol
+from sympy.testing.pytest import raises
+from sympy.core.numbers import oo
+
+F, x, y, z = free_group("x, y, z")
+
+
+def test_FreeGroup__init__():
+    x, y, z = map(Symbol, "xyz")
+
+    assert len(FreeGroup("x, y, z").generators) == 3
+    assert len(FreeGroup(x).generators) == 1
+    assert len(FreeGroup(("x", "y", "z"))) == 3
+    assert len(FreeGroup((x, y, z)).generators) == 3
+
+
+def test_FreeGroup__getnewargs__():
+    x, y, z = map(Symbol, "xyz")
+    assert FreeGroup("x, y, z").__getnewargs__() == ((x, y, z),)
+
+
+def test_free_group():
+    G, a, b, c = free_group("a, b, c")
+    assert F.generators == (x, y, z)
+    assert x*z**2 in F
+    assert x in F
+    assert y*z**-1 in F
+    assert (y*z)**0 in F
+    assert a not in F
+    assert a**0 not in F
+    assert len(F) == 3
+    assert str(F) == '<free group on the generators (x, y, z)>'
+    assert not F == G
+    assert F.order() is oo
+    assert F.is_abelian == False
+    assert F.center() == {F.identity}
+
+    (e,) = free_group("")
+    assert e.order() == 1
+    assert e.generators == ()
+    assert e.elements == {e.identity}
+    assert e.is_abelian == True
+
+
+def test_FreeGroup__hash__():
+    assert hash(F)
+
+
+def test_FreeGroup__eq__():
+    assert free_group("x, y, z")[0] == free_group("x, y, z")[0]
+    assert free_group("x, y, z")[0] is free_group("x, y, z")[0]
+
+    assert free_group("x, y, z")[0] != free_group("a, x, y")[0]
+    assert free_group("x, y, z")[0] is not free_group("a, x, y")[0]
+
+    assert free_group("x, y")[0] != free_group("x, y, z")[0]
+    assert free_group("x, y")[0] is not free_group("x, y, z")[0]
+
+    assert free_group("x, y, z")[0] != free_group("x, y")[0]
+    assert free_group("x, y, z")[0] is not free_group("x, y")[0]
+
+
+def test_FreeGroup__getitem__():
+    assert F[0:] == FreeGroup("x, y, z")
+    assert F[1:] == FreeGroup("y, z")
+    assert F[2:] == FreeGroup("z")
+
+
+def test_FreeGroupElm__hash__():
+    assert hash(x*y*z)
+
+
+def test_FreeGroupElm_copy():
+    f = x*y*z**3
+    g = f.copy()
+    h = x*y*z**7
+
+    assert f == g
+    assert f != h
+
+
+def test_FreeGroupElm_inverse():
+    assert x.inverse() == x**-1
+    assert (x*y).inverse() == y**-1*x**-1
+    assert (y*x*y**-1).inverse() == y*x**-1*y**-1
+    assert (y**2*x**-1).inverse() == x*y**-2
+
+
+def test_FreeGroupElm_type_error():
+    raises(TypeError, lambda: 2/x)
+    raises(TypeError, lambda: x**2 + y**2)
+    raises(TypeError, lambda: x/2)
+
+
+def test_FreeGroupElm_methods():
+    assert (x**0).order() == 1
+    assert (y**2).order() is oo
+    assert (x**-1*y).commutator(x) == y**-1*x**-1*y*x
+    assert len(x**2*y**-1) == 3
+    assert len(x**-1*y**3*z) == 5
+
+
+def test_FreeGroupElm_eliminate_word():
+    w = x**5*y*x**2*y**-4*x
+    assert w.eliminate_word( x, x**2 ) == x**10*y*x**4*y**-4*x**2
+    w3 = x**2*y**3*x**-1*y
+    assert w3.eliminate_word(x, x**2) == x**4*y**3*x**-2*y
+    assert w3.eliminate_word(x, y) == y**5
+    assert w3.eliminate_word(x, y**4) == y**8
+    assert w3.eliminate_word(y, x**-1) == x**-3
+    assert w3.eliminate_word(x, y*z) == y*z*y*z*y**3*z**-1
+    assert (y**-3).eliminate_word(y, x**-1*z**-1) == z*x*z*x*z*x
+    #assert w3.eliminate_word(x, y*x) == y*x*y*x**2*y*x*y*x*y*x*z**3
+    #assert w3.eliminate_word(x, x*y) == x*y*x**2*y*x*y*x*y*x*y*z**3
+
+
+def test_FreeGroupElm_array_form():
+    assert (x*z).array_form == ((Symbol('x'), 1), (Symbol('z'), 1))
+    assert (x**2*z*y*x**-2).array_form == \
+        ((Symbol('x'), 2), (Symbol('z'), 1), (Symbol('y'), 1), (Symbol('x'), -2))
+    assert (x**-2*y**-1).array_form == ((Symbol('x'), -2), (Symbol('y'), -1))
+
+
+def test_FreeGroupElm_letter_form():
+    assert (x**3).letter_form == (Symbol('x'), Symbol('x'), Symbol('x'))
+    assert (x**2*z**-2*x).letter_form == \
+        (Symbol('x'), Symbol('x'), -Symbol('z'), -Symbol('z'), Symbol('x'))
+
+
+def test_FreeGroupElm_ext_rep():
+    assert (x**2*z**-2*x).ext_rep == \
+        (Symbol('x'), 2, Symbol('z'), -2, Symbol('x'), 1)
+    assert (x**-2*y**-1).ext_rep == (Symbol('x'), -2, Symbol('y'), -1)
+    assert (x*z).ext_rep == (Symbol('x'), 1, Symbol('z'), 1)
+
+
+def test_FreeGroupElm__mul__pow__():
+    x1 = x.group.dtype(((Symbol('x'), 1),))
+    assert x**2 == x1*x
+
+    assert (x**2*y*x**-2)**4 == x**2*y**4*x**-2
+    assert (x**2)**2 == x**4
+    assert (x**-1)**-1 == x
+    assert (x**-1)**0 == F.identity
+    assert (y**2)**-2 == y**-4
+
+    assert x**2*x**-1 == x
+    assert x**2*y**2*y**-1 == x**2*y
+    assert x*x**-1 == F.identity
+
+    assert x/x == F.identity
+    assert x/x**2 == x**-1
+    assert (x**2*y)/(x**2*y**-1) == x**2*y**2*x**-2
+    assert (x**2*y)/(y**-1*x**2) == x**2*y*x**-2*y
+
+    assert x*(x**-1*y*z*y**-1) == y*z*y**-1
+    assert x**2*(x**-2*y**-1*z**2*y) == y**-1*z**2*y
+
+    a = F.identity
+    for n in range(10):
+        assert a == x**n
+        assert a**-1 == x**-n
+        a *= x
+
+
+def test_FreeGroupElm__len__():
+    assert len(x**5*y*x**2*y**-4*x) == 13
+    assert len(x**17) == 17
+    assert len(y**0) == 0
+
+
+def test_FreeGroupElm_comparison():
+    assert not (x*y == y*x)
+    assert x**0 == y**0
+
+    assert x**2 < y**3
+    assert not x**3 < y**2
+    assert x*y < x**2*y
+    assert x**2*y**2 < y**4
+    assert not y**4 < y**-4
+    assert not y**4 < x**-4
+    assert y**-2 < y**2
+
+    assert x**2 <= y**2
+    assert x**2 <= x**2
+
+    assert not y*z > z*y
+    assert x > x**-1
+
+    assert not x**2 >= y**2
+
+
+def test_FreeGroupElm_syllables():
+    w = x**5*y*x**2*y**-4*x
+    assert w.number_syllables() == 5
+    assert w.exponent_syllable(2) == 2
+    assert w.generator_syllable(3) == Symbol('y')
+    assert w.sub_syllables(1, 2) == y
+    assert w.sub_syllables(3, 3) == F.identity
+
+
+def test_FreeGroup_exponents():
+    w1 = x**2*y**3
+    assert w1.exponent_sum(x) == 2
+    assert w1.exponent_sum(x**-1) == -2
+    assert w1.generator_count(x) == 2
+
+    w2 = x**2*y**4*x**-3
+    assert w2.exponent_sum(x) == -1
+    assert w2.generator_count(x) == 5
+
+
+def test_FreeGroup_generators():
+    assert (x**2*y**4*z**-1).contains_generators() == {x, y, z}
+    assert (x**-1*y**3).contains_generators() == {x, y}
+
+
+def test_FreeGroupElm_words():
+    w = x**5*y*x**2*y**-4*x
+    assert w.subword(2, 6) == x**3*y
+    assert w.subword(3, 2) == F.identity
+    assert w.subword(6, 10) == x**2*y**-2
+
+    assert w.substituted_word(0, 7, y**-1) == y**-1*x*y**-4*x
+    assert w.substituted_word(0, 7, y**2*x) == y**2*x**2*y**-4*x

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_galois.py

@@ -0,0 +1,82 @@
+"""Test groups defined by the galois module. """
+
+from sympy.combinatorics.galois import (
+    S4TransitiveSubgroups, S5TransitiveSubgroups, S6TransitiveSubgroups,
+    find_transitive_subgroups_of_S6,
+)
+from sympy.combinatorics.homomorphisms import is_isomorphic
+from sympy.combinatorics.named_groups import (
+    SymmetricGroup, AlternatingGroup, CyclicGroup,
+)
+
+
+def test_four_group():
+    G = S4TransitiveSubgroups.V.get_perm_group()
+    A4 = AlternatingGroup(4)
+    assert G.is_subgroup(A4)
+    assert G.degree == 4
+    assert G.is_transitive()
+    assert G.order() == 4
+    assert not G.is_cyclic
+
+
+def test_M20():
+    G = S5TransitiveSubgroups.M20.get_perm_group()
+    S5 = SymmetricGroup(5)
+    A5 = AlternatingGroup(5)
+    assert G.is_subgroup(S5)
+    assert not G.is_subgroup(A5)
+    assert G.degree == 5
+    assert G.is_transitive()
+    assert G.order() == 20
+
+
+# Setting this True means that for each of the transitive subgroups of S6,
+# we run a test not only on the fixed representation, but also on one freshly
+# generated by the search procedure.
+INCLUDE_SEARCH_REPS = False
+S6_randomized = {}
+if INCLUDE_SEARCH_REPS:
+    S6_randomized = find_transitive_subgroups_of_S6(*list(S6TransitiveSubgroups))
+
+
+def get_versions_of_S6_subgroup(name):
+    vers = [name.get_perm_group()]
+    if INCLUDE_SEARCH_REPS:
+        vers.append(S6_randomized[name])
+    return vers
+
+
+def test_S6_transitive_subgroups():
+    """
+    Test enough characteristics to distinguish all 16 transitive subgroups.
+    """
+    ts = S6TransitiveSubgroups
+    A6 = AlternatingGroup(6)
+    for name, alt, order, is_isom, not_isom in [
+        (ts.C6,     False,    6, CyclicGroup(6), None),
+        (ts.S3,     False,    6, SymmetricGroup(3), None),
+        (ts.D6,     False,   12, None, None),
+        (ts.A4,     True,    12, None, None),
+        (ts.G18,    False,   18, None, None),
+        (ts.A4xC2,  False,   24, None, SymmetricGroup(4)),
+        (ts.S4m,    False,   24, SymmetricGroup(4), None),
+        (ts.S4p,    True,    24, None, None),
+        (ts.G36m,   False,   36, None, None),
+        (ts.G36p,   True,    36, None, None),
+        (ts.S4xC2,  False,   48, None, None),
+        (ts.PSL2F5, True,    60, None, None),
+        (ts.G72,    False,   72, None, None),
+        (ts.PGL2F5, False,  120, None, None),
+        (ts.A6,     True,   360, None, None),
+        (ts.S6,     False,  720, None, None),
+    ]:
+        for G in get_versions_of_S6_subgroup(name):
+            assert G.is_transitive()
+            assert G.degree == 6
+            assert G.is_subgroup(A6) is alt
+            assert G.order() == order
+            if is_isom:
+                assert is_isomorphic(G, is_isom)
+            if not_isom:
+                assert not is_isomorphic(G, not_isom)

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_generators.py

@@ -0,0 +1,105 @@
+from sympy.combinatorics.generators import symmetric, cyclic, alternating, \
+    dihedral, rubik
+from sympy.combinatorics.permutations import Permutation
+from sympy.testing.pytest import raises
+
+def test_generators():
+
+    assert list(cyclic(6)) == [
+        Permutation([0, 1, 2, 3, 4, 5]),
+        Permutation([1, 2, 3, 4, 5, 0]),
+        Permutation([2, 3, 4, 5, 0, 1]),
+        Permutation([3, 4, 5, 0, 1, 2]),
+        Permutation([4, 5, 0, 1, 2, 3]),
+        Permutation([5, 0, 1, 2, 3, 4])]
+
+    assert list(cyclic(10)) == [
+        Permutation([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        Permutation([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]),
+        Permutation([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]),
+        Permutation([3, 4, 5, 6, 7, 8, 9, 0, 1, 2]),
+        Permutation([4, 5, 6, 7, 8, 9, 0, 1, 2, 3]),
+        Permutation([5, 6, 7, 8, 9, 0, 1, 2, 3, 4]),
+        Permutation([6, 7, 8, 9, 0, 1, 2, 3, 4, 5]),
+        Permutation([7, 8, 9, 0, 1, 2, 3, 4, 5, 6]),
+        Permutation([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]),
+        Permutation([9, 0, 1, 2, 3, 4, 5, 6, 7, 8])]
+
+    assert list(alternating(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(symmetric(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([0, 2, 1]),
+        Permutation([1, 0, 2]),
+        Permutation([1, 2, 0]),
+        Permutation([2, 0, 1]),
+        Permutation([2, 1, 0])]
+
+    assert list(symmetric(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 1, 3, 2]),
+        Permutation([0, 2, 1, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([0, 3, 2, 1]),
+        Permutation([1, 0, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 2, 3, 0]),
+        Permutation([1, 3, 0, 2]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 0, 3, 1]),
+        Permutation([2, 1, 0, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([2, 3, 1, 0]),
+        Permutation([3, 0, 1, 2]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 1, 2, 0]),
+        Permutation([3, 2, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(1)) == [
+        Permutation([0, 1]), Permutation([1, 0])]
+
+    assert list(dihedral(2)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([2, 1, 0]),
+        Permutation([1, 2, 0]),
+        Permutation([0, 2, 1]),
+        Permutation([2, 0, 1]),
+        Permutation([1, 0, 2])]
+
+    assert list(dihedral(5)) == [
+        Permutation([0, 1, 2, 3, 4]),
+        Permutation([4, 3, 2, 1, 0]),
+        Permutation([1, 2, 3, 4, 0]),
+        Permutation([0, 4, 3, 2, 1]),
+        Permutation([2, 3, 4, 0, 1]),
+        Permutation([1, 0, 4, 3, 2]),
+        Permutation([3, 4, 0, 1, 2]),
+        Permutation([2, 1, 0, 4, 3]),
+        Permutation([4, 0, 1, 2, 3]),
+        Permutation([3, 2, 1, 0, 4])]
+
+    raises(ValueError, lambda: rubik(1))

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_graycode.py

@@ -0,0 +1,72 @@
+from sympy.combinatorics.graycode import (GrayCode, bin_to_gray,
+    random_bitstring, get_subset_from_bitstring, graycode_subsets,
+    gray_to_bin)
+from sympy.testing.pytest import raises
+
+def test_graycode():
+    g = GrayCode(2)
+    got = []
+    for i in g.generate_gray():
+        if i.startswith('0'):
+            g.skip()
+        got.append(i)
+    assert got == '00 11 10'.split()
+    a = GrayCode(6)
+    assert a.current == '0'*6
+    assert a.rank == 0
+    assert len(list(a.generate_gray())) == 64
+    codes = ['011001', '011011', '011010',
+    '011110', '011111', '011101', '011100', '010100', '010101', '010111',
+    '010110', '010010', '010011', '010001', '010000', '110000', '110001',
+    '110011', '110010', '110110', '110111', '110101', '110100', '111100',
+    '111101', '111111', '111110', '111010', '111011', '111001', '111000',
+    '101000', '101001', '101011', '101010', '101110', '101111', '101101',
+    '101100', '100100', '100101', '100111', '100110', '100010', '100011',
+    '100001', '100000']
+    assert list(a.generate_gray(start='011001')) == codes
+    assert list(
+        a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
+    assert a.next().current == '000001'
+    assert a.next(2).current == '000011'
+    assert a.next(-1).current == '100000'
+
+    a = GrayCode(5, start='10010')
+    assert a.rank == 28
+    a = GrayCode(6, start='101000')
+    assert a.rank == 48
+
+    assert GrayCode(6, rank=4).current == '000110'
+    assert GrayCode(6, rank=4).rank == 4
+    assert [GrayCode(4, start=s).rank for s in
+            GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8,
+                                             9, 10, 11, 12, 13, 14, 15]
+    a = GrayCode(15, rank=15)
+    assert a.current == '000000000001000'
+
+    assert bin_to_gray('111') == '100'
+
+    a = random_bitstring(5)
+    assert type(a) is str
+    assert len(a) == 5
+    assert all(i in ['0', '1'] for i in a)
+
+    assert get_subset_from_bitstring(
+        ['a', 'b', 'c', 'd'], '0011') == ['c', 'd']
+    assert get_subset_from_bitstring('abcd', '1001') == ['a', 'd']
+    assert list(graycode_subsets(['a', 'b', 'c'])) == \
+        [[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'],
+         ['a', 'c'], ['a']]
+
+    raises(ValueError, lambda: GrayCode(0))
+    raises(ValueError, lambda: GrayCode(2.2))
+    raises(ValueError, lambda: GrayCode(2, start=[1, 1, 0]))
+    raises(ValueError, lambda: GrayCode(2, rank=2.5))
+    raises(ValueError, lambda: get_subset_from_bitstring(['c', 'a', 'c'], '1100'))
+    raises(ValueError, lambda: list(GrayCode(3).generate_gray(start="1111")))
+
+
+def test_live_issue_117():
+    assert bin_to_gray('0100') == '0110'
+    assert bin_to_gray('0101') == '0111'
+    for bits in ('0100', '0101'):
+        assert gray_to_bin(bin_to_gray(bits)) == bits

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_group_constructs.py

@@ -0,0 +1,15 @@
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.named_groups import CyclicGroup, DihedralGroup
+
+
+def test_direct_product_n():
+    C = CyclicGroup(4)
+    D = DihedralGroup(4)
+    G = DirectProduct(C, C, C)
+    assert G.order() == 64
+    assert G.degree == 12
+    assert len(G.orbits()) == 3
+    assert G.is_abelian is True
+    H = DirectProduct(D, C)
+    assert H.order() == 32
+    assert H.is_abelian is False

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_group_numbers.py

@@ -0,0 +1,110 @@
+from sympy.combinatorics.group_numbers import (is_nilpotent_number,
+    is_abelian_number, is_cyclic_number, _holder_formula, groups_count)
+from sympy.ntheory.factor_ import factorint
+from sympy.ntheory.generate import prime
+from sympy.testing.pytest import raises
+from sympy import randprime
+
+
+def test_is_nilpotent_number():
+    assert is_nilpotent_number(21) == False
+    assert is_nilpotent_number(randprime(1, 30)**12) == True
+    raises(ValueError, lambda: is_nilpotent_number(-5))
+
+    A056867	= [1, 2, 3, 4, 5, 7, 8, 9, 11, 13, 15, 16, 17, 19,
+               23, 25, 27, 29, 31, 32, 33, 35, 37, 41, 43, 45,
+               47, 49, 51, 53, 59, 61, 64, 65, 67, 69, 71, 73,
+               77, 79, 81, 83, 85, 87, 89, 91, 95, 97, 99]
+    for n in range(1, 100):
+        assert is_nilpotent_number(n) == (n in A056867)
+
+
+def test_is_abelian_number():
+    assert is_abelian_number(4) == True
+    assert is_abelian_number(randprime(1, 2000)**2) == True
+    assert is_abelian_number(randprime(1000, 100000)) == True
+    assert is_abelian_number(60) == False
+    assert is_abelian_number(24) == False
+    raises(ValueError, lambda: is_abelian_number(-5))
+
+    A051532 = [1, 2, 3, 4, 5, 7, 9, 11, 13, 15, 17, 19, 23, 25,
+               29, 31, 33, 35, 37, 41, 43, 45, 47, 49, 51, 53,
+               59, 61, 65, 67, 69, 71, 73, 77, 79, 83, 85, 87,
+               89, 91, 95, 97, 99]
+    for n in range(1, 100):
+        assert is_abelian_number(n) == (n in A051532)
+
+
+A003277 = [1, 2, 3, 5, 7, 11, 13, 15, 17, 19, 23, 29,
+           31, 33, 35, 37, 41, 43, 47, 51, 53, 59, 61,
+           65, 67, 69, 71, 73, 77, 79, 83, 85, 87, 89,
+           91, 95, 97]
+
+
+def test_is_cyclic_number():
+    assert is_cyclic_number(15) == True
+    assert is_cyclic_number(randprime(1, 2000)**2) == False
+    assert is_cyclic_number(randprime(1000, 100000)) == True
+    assert is_cyclic_number(4) == False
+    raises(ValueError, lambda: is_cyclic_number(-5))
+
+    for n in range(1, 100):
+        assert is_cyclic_number(n) == (n in A003277)
+
+
+def test_holder_formula():
+    # semiprime
+    assert _holder_formula({3, 5}) == 1
+    assert _holder_formula({5, 11}) == 2
+    # n in A003277 is always 1
+    for n in A003277:
+        assert _holder_formula(set(factorint(n).keys())) == 1
+    # otherwise
+    assert _holder_formula({2, 3, 5, 7}) == 12
+
+
+def test_groups_count():
+    A000001 = [0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1,
+               2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2,
+               5, 4, 1, 4, 1, 51, 1, 2, 1, 14, 1, 2, 2,
+               14, 1, 6, 1, 4, 2, 2, 1, 52, 2, 5, 1, 5,
+               1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4, 267,
+               1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1,
+               6, 1, 52, 15, 2, 1, 15, 1, 2, 1, 12, 1,
+               10, 1, 4, 2]
+    for n in range(1, len(A000001)):
+        try:
+            assert groups_count(n) == A000001[n]
+        except ValueError:
+            pass
+
+    A000679 = [1, 1, 2, 5, 14, 51, 267, 2328, 56092, 10494213, 49487367289]
+    for e in range(1, len(A000679)):
+        assert groups_count(2**e) == A000679[e]
+
+    A090091 = [1, 1, 2, 5, 15, 67, 504, 9310, 1396077, 5937876645]
+    for e in range(1, len(A090091)):
+        assert groups_count(3**e) == A090091[e]
+
+    A090130 = [1, 1, 2, 5, 15, 77, 684, 34297]
+    for e in range(1, len(A090130)):
+        assert groups_count(5**e) == A090130[e]
+
+    A090140 = [1, 1, 2, 5, 15, 83, 860, 113147]
+    for e in range(1, len(A090140)):
+        assert groups_count(7**e) == A090140[e]
+
+    A232105 = [51, 67, 77, 83, 87, 97, 101, 107, 111, 125, 131,
+               145, 149, 155, 159, 173, 183, 193, 203, 207, 217]
+    for i in range(len(A232105)):
+        assert groups_count(prime(i+1)**5) == A232105[i]
+
+    A232106 = [267, 504, 684, 860, 1192, 1476, 1944, 2264, 2876,
+               4068, 4540, 6012, 7064, 7664, 8852, 10908, 13136]
+    for i in range(len(A232106)):
+        assert groups_count(prime(i+1)**6) == A232106[i]
+
+    A232107 = [2328, 9310, 34297, 113147, 750735, 1600573,
+               5546909, 9380741, 23316851, 71271069, 98488755]
+    for i in range(len(A232107)):
+        assert groups_count(prime(i+1)**7) == A232107[i]

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_homomorphisms.py

@@ -0,0 +1,114 @@
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.homomorphisms import homomorphism, group_isomorphism, is_isomorphic
+from sympy.combinatorics.free_groups import free_group
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.named_groups import AlternatingGroup, DihedralGroup, CyclicGroup
+from sympy.testing.pytest import raises
+
+def test_homomorphism():
+    # FpGroup -> PermutationGroup
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+
+    c = Permutation(3)(0, 1, 2)
+    d = Permutation(3)(1, 2, 3)
+    A = AlternatingGroup(4)
+    T = homomorphism(G, A, [a, b], [c, d])
+    assert T(a*b**2*a**-1) == c*d**2*c**-1
+    assert T.is_isomorphism()
+    assert T(T.invert(Permutation(3)(0, 2, 3))) == Permutation(3)(0, 2, 3)
+
+    T = homomorphism(G, AlternatingGroup(4), G.generators)
+    assert T.is_trivial()
+    assert T.kernel().order() == G.order()
+
+    E, e = free_group("e")
+    G = FpGroup(E, [e**8])
+    P = PermutationGroup([Permutation(0, 1, 2, 3), Permutation(0, 2)])
+    T = homomorphism(G, P, [e], [Permutation(0, 1, 2, 3)])
+    assert T.image().order() == 4
+    assert T(T.invert(Permutation(0, 2)(1, 3))) == Permutation(0, 2)(1, 3)
+
+    T = homomorphism(E, AlternatingGroup(4), E.generators, [c])
+    assert T.invert(c**2) == e**-1 #order(c) == 3 so c**2 == c**-1
+
+    # FreeGroup -> FreeGroup
+    T = homomorphism(F, E, [a], [e])
+    assert T(a**-2*b**4*a**2).is_identity
+
+    # FreeGroup -> FpGroup
+    G = FpGroup(F, [a*b*a**-1*b**-1])
+    T = homomorphism(F, G, F.generators, G.generators)
+    assert T.invert(a**-1*b**-1*a**2) == a*b**-1
+
+    # PermutationGroup -> PermutationGroup
+    D = DihedralGroup(8)
+    p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    P = PermutationGroup(p)
+    T = homomorphism(P, D, [p], [p])
+    assert T.is_injective()
+    assert not T.is_isomorphism()
+    assert T.invert(p**3) == p**3
+
+    T2 = homomorphism(F, P, [F.generators[0]], P.generators)
+    T = T.compose(T2)
+    assert T.domain == F
+    assert T.codomain == D
+    assert T(a*b) == p
+
+    D3 = DihedralGroup(3)
+    T = homomorphism(D3, D3, D3.generators, D3.generators)
+    assert T.is_isomorphism()
+
+
+def test_isomorphisms():
+
+    F, a, b = free_group("a, b")
+    E, c, d = free_group("c, d")
+    # Infinite groups with differently ordered relators.
+    G = FpGroup(F, [a**2, b**3])
+    H = FpGroup(F, [b**3, a**2])
+    assert is_isomorphic(G, H)
+
+    # Trivial Case
+    # FpGroup -> FpGroup
+    H = FpGroup(F, [a**3, b**3, (a*b)**2])
+    F, c, d = free_group("c, d")
+    G = FpGroup(F, [c**3, d**3, (c*d)**2])
+    check, T =  group_isomorphism(G, H)
+    assert check
+    assert T(c**3*d**2) == a**3*b**2
+
+    # FpGroup -> PermutationGroup
+    # FpGroup is converted to the equivalent isomorphic group.
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    H = AlternatingGroup(4)
+    check, T = group_isomorphism(G, H)
+    assert check
+    assert T(b*a*b**-1*a**-1*b**-1) == Permutation(0, 2, 3)
+    assert T(b*a*b*a**-1*b**-1) == Permutation(0, 3, 2)
+
+    # PermutationGroup -> PermutationGroup
+    D = DihedralGroup(8)
+    p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    P = PermutationGroup(p)
+    assert not is_isomorphic(D, P)
+
+    A = CyclicGroup(5)
+    B = CyclicGroup(7)
+    assert not is_isomorphic(A, B)
+
+    # Two groups of the same prime order are isomorphic to each other.
+    G = FpGroup(F, [a, b**5])
+    H = CyclicGroup(5)
+    assert G.order() == H.order()
+    assert is_isomorphic(G, H)
+
+
+def test_check_homomorphism():
+    a = Permutation(1,2,3,4)
+    b = Permutation(1,3)
+    G = PermutationGroup([a, b])
+    raises(ValueError, lambda: homomorphism(G, G, [a], [a]))

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_named_groups.py

@@ -0,0 +1,70 @@
+from sympy.combinatorics.named_groups import (SymmetricGroup, CyclicGroup,
+                                              DihedralGroup, AlternatingGroup,
+                                              AbelianGroup, RubikGroup)
+from sympy.testing.pytest import raises
+
+
+def test_SymmetricGroup():
+    G = SymmetricGroup(5)
+    elements = list(G.generate())
+    assert (G.generators[0]).size == 5
+    assert len(elements) == 120
+    assert G.is_solvable is False
+    assert G.is_abelian is False
+    assert G.is_nilpotent is False
+    assert G.is_transitive() is True
+    H = SymmetricGroup(1)
+    assert H.order() == 1
+    L = SymmetricGroup(2)
+    assert L.order() == 2
+
+
+def test_CyclicGroup():
+    G = CyclicGroup(10)
+    elements = list(G.generate())
+    assert len(elements) == 10
+    assert (G.derived_subgroup()).order() == 1
+    assert G.is_abelian is True
+    assert G.is_solvable is True
+    assert G.is_nilpotent is True
+    H = CyclicGroup(1)
+    assert H.order() == 1
+    L = CyclicGroup(2)
+    assert L.order() == 2
+
+
+def test_DihedralGroup():
+    G = DihedralGroup(6)
+    elements = list(G.generate())
+    assert len(elements) == 12
+    assert G.is_transitive() is True
+    assert G.is_abelian is False
+    assert G.is_solvable is True
+    assert G.is_nilpotent is False
+    H = DihedralGroup(1)
+    assert H.order() == 2
+    L = DihedralGroup(2)
+    assert L.order() == 4
+    assert L.is_abelian is True
+    assert L.is_nilpotent is True
+
+
+def test_AlternatingGroup():
+    G = AlternatingGroup(5)
+    elements = list(G.generate())
+    assert len(elements) == 60
+    assert [perm.is_even for perm in elements] == [True]*60
+    H = AlternatingGroup(1)
+    assert H.order() == 1
+    L = AlternatingGroup(2)
+    assert L.order() == 1
+
+
+def test_AbelianGroup():
+    A = AbelianGroup(3, 3, 3)
+    assert A.order() == 27
+    assert A.is_abelian is True
+
+
+def test_RubikGroup():
+    raises(ValueError, lambda: RubikGroup(1))

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_partitions.py

@@ -0,0 +1,118 @@
+from sympy.core.sorting import ordered, default_sort_key
+from sympy.combinatorics.partitions import (Partition, IntegerPartition,
+                                            RGS_enum, RGS_unrank, RGS_rank,
+                                            random_integer_partition)
+from sympy.testing.pytest import raises
+from sympy.utilities.iterables import partitions
+from sympy.sets.sets import Set, FiniteSet
+
+
+def test_partition_constructor():
+    raises(ValueError, lambda: Partition([1, 1, 2]))
+    raises(ValueError, lambda: Partition([1, 2, 3], [2, 3, 4]))
+    raises(ValueError, lambda: Partition(1, 2, 3))
+    raises(ValueError, lambda: Partition(*list(range(3))))
+
+    assert Partition([1, 2, 3], [4, 5]) == Partition([4, 5], [1, 2, 3])
+    assert Partition({1, 2, 3}, {4, 5}) == Partition([1, 2, 3], [4, 5])
+
+    a = FiniteSet(1, 2, 3)
+    b = FiniteSet(4, 5)
+    assert Partition(a, b) == Partition([1, 2, 3], [4, 5])
+    assert Partition({a, b}) == Partition(FiniteSet(a, b))
+    assert Partition({a, b}) != Partition(a, b)
+
+def test_partition():
+    from sympy.abc import x
+
+    a = Partition([1, 2, 3], [4])
+    b = Partition([1, 2], [3, 4])
+    c = Partition([x])
+    l = [a, b, c]
+    l.sort(key=default_sort_key)
+    assert l == [c, a, b]
+    l.sort(key=lambda w: default_sort_key(w, order='rev-lex'))
+    assert l == [c, a, b]
+
+    assert (a == b) is False
+    assert a <= b
+    assert (a > b) is False
+    assert a != b
+    assert a < b
+
+    assert (a + 2).partition == [[1, 2], [3, 4]]
+    assert (b - 1).partition == [[1, 2, 4], [3]]
+
+    assert (a - 1).partition == [[1, 2, 3, 4]]
+    assert (a + 1).partition == [[1, 2, 4], [3]]
+    assert (b + 1).partition == [[1, 2], [3], [4]]
+
+    assert a.rank == 1
+    assert b.rank == 3
+
+    assert a.RGS == (0, 0, 0, 1)
+    assert b.RGS == (0, 0, 1, 1)
+
+
+def test_integer_partition():
+    # no zeros in partition
+    raises(ValueError, lambda: IntegerPartition(list(range(3))))
+    # check fails since 1 + 2 != 100
+    raises(ValueError, lambda: IntegerPartition(100, list(range(1, 3))))
+    a = IntegerPartition(8, [1, 3, 4])
+    b = a.next_lex()
+    c = IntegerPartition([1, 3, 4])
+    d = IntegerPartition(8, {1: 3, 3: 1, 2: 1})
+    assert a == c
+    assert a.integer == d.integer
+    assert a.conjugate == [3, 2, 2, 1]
+    assert (a == b) is False
+    assert a <= b
+    assert (a > b) is False
+    assert a != b
+
+    for i in range(1, 11):
+        next = set()
+        prev = set()
+        a = IntegerPartition([i])
+        ans = {IntegerPartition(p) for p in partitions(i)}
+        n = len(ans)
+        for j in range(n):
+            next.add(a)
+            a = a.next_lex()
+            IntegerPartition(i, a.partition)  # check it by giving i
+        for j in range(n):
+            prev.add(a)
+            a = a.prev_lex()
+            IntegerPartition(i, a.partition)  # check it by giving i
+        assert next == ans
+        assert prev == ans
+
+    assert IntegerPartition([1, 2, 3]).as_ferrers() == '###\n##\n#'
+    assert IntegerPartition([1, 1, 3]).as_ferrers('o') == 'ooo\no\no'
+    assert str(IntegerPartition([1, 1, 3])) == '[3, 1, 1]'
+    assert IntegerPartition([1, 1, 3]).partition == [3, 1, 1]
+
+    raises(ValueError, lambda: random_integer_partition(-1))
+    assert random_integer_partition(1) == [1]
+    assert random_integer_partition(10, seed=[1, 3, 2, 1, 5, 1]
+            ) == [5, 2, 1, 1, 1]
+
+
+def test_rgs():
+    raises(ValueError, lambda: RGS_unrank(-1, 3))
+    raises(ValueError, lambda: RGS_unrank(3, 0))
+    raises(ValueError, lambda: RGS_unrank(10, 1))
+
+    raises(ValueError, lambda: Partition.from_rgs(list(range(3)), list(range(2))))
+    raises(ValueError, lambda: Partition.from_rgs(list(range(1, 3)), list(range(2))))
+    assert RGS_enum(-1) == 0
+    assert RGS_enum(1) == 1
+    assert RGS_unrank(7, 5) == [0, 0, 1, 0, 2]
+    assert RGS_unrank(23, 14) == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2]
+    assert RGS_rank(RGS_unrank(40, 100)) == 40
+
+def test_ordered_partition_9608():
+    a = Partition([1, 2, 3], [4])
+    b = Partition([1, 2], [3, 4])
+    assert list(ordered([a,b], Set._infimum_key))

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_pc_groups.py

@@ -0,0 +1,87 @@
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.named_groups import SymmetricGroup, AlternatingGroup, DihedralGroup
+from sympy.matrices import Matrix
+
+def test_pc_presentation():
+    Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3),
+         SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2), DihedralGroup(10)]
+
+    S = SymmetricGroup(125).sylow_subgroup(5)
+    G = S.derived_series()[2]
+    Groups.append(G)
+
+    G = SymmetricGroup(25).sylow_subgroup(5)
+    Groups.append(G)
+
+    S = SymmetricGroup(11**2).sylow_subgroup(11)
+    G = S.derived_series()[2]
+    Groups.append(G)
+
+    for G in Groups:
+        PcGroup = G.polycyclic_group()
+        collector = PcGroup.collector
+        pc_presentation = collector.pc_presentation
+
+        pcgs = PcGroup.pcgs
+        free_group = collector.free_group
+        free_to_perm = {}
+        for s, g in zip(free_group.symbols, pcgs):
+            free_to_perm[s] = g
+
+        for k, v in pc_presentation.items():
+            k_array = k.array_form
+            if v != ():
+                v_array = v.array_form
+
+            lhs = Permutation()
+            for gen in k_array:
+                s = gen[0]
+                e = gen[1]
+                lhs = lhs*free_to_perm[s]**e
+
+            if v == ():
+                assert lhs.is_identity
+                continue
+
+            rhs = Permutation()
+            for gen in v_array:
+                s = gen[0]
+                e = gen[1]
+                rhs = rhs*free_to_perm[s]**e
+
+            assert lhs == rhs
+
+
+def test_exponent_vector():
+
+    Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3),
+         SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)]
+
+    for G in Groups:
+        PcGroup = G.polycyclic_group()
+        collector = PcGroup.collector
+
+        pcgs = PcGroup.pcgs
+        # free_group = collector.free_group
+
+        for gen in G.generators:
+            exp = collector.exponent_vector(gen)
+            g = Permutation()
+            for i in range(len(exp)):
+                g = g*pcgs[i]**exp[i] if exp[i] else g
+            assert g == gen
+
+
+def test_induced_pcgs():
+    G = [SymmetricGroup(9).sylow_subgroup(3), SymmetricGroup(20).sylow_subgroup(2), AlternatingGroup(4),
+    DihedralGroup(4), DihedralGroup(10), DihedralGroup(9), SymmetricGroup(3), SymmetricGroup(4)]
+
+    for g in G:
+        PcGroup = g.polycyclic_group()
+        collector = PcGroup.collector
+        gens = list(g.generators)
+        ipcgs = collector.induced_pcgs(gens)
+        m = []
+        for i in ipcgs:
+            m.append(collector.exponent_vector(i))
+        assert Matrix(m).is_upper

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_perm_groups.py

@@ -0,0 +1,1243 @@
+from sympy.core.containers import Tuple
+from sympy.combinatorics.generators import rubik_cube_generators
+from sympy.combinatorics.homomorphisms import is_isomorphic
+from sympy.combinatorics.named_groups import SymmetricGroup, CyclicGroup,\
+    DihedralGroup, AlternatingGroup, AbelianGroup, RubikGroup
+from sympy.combinatorics.perm_groups import (PermutationGroup,
+    _orbit_transversal, Coset, SymmetricPermutationGroup)
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.polyhedron import tetrahedron as Tetra, cube
+from sympy.combinatorics.testutil import _verify_bsgs, _verify_centralizer,\
+    _verify_normal_closure
+from sympy.testing.pytest import skip, XFAIL, slow
+
+rmul = Permutation.rmul
+
+
+def test_has():
+    a = Permutation([1, 0])
+    G = PermutationGroup([a])
+    assert G.is_abelian
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    assert not G.is_abelian
+
+    G = PermutationGroup([a])
+    assert G.has(a)
+    assert not G.has(b)
+
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([0, 2, 1, 3, 4])
+    assert PermutationGroup(a, b).degree == \
+        PermutationGroup(a, b).degree == 6
+
+    g = PermutationGroup(Permutation(0, 2, 1))
+    assert Tuple(1, g).has(g)
+
+
+def test_generate():
+    a = Permutation([1, 0])
+    g = list(PermutationGroup([a]).generate())
+    assert g == [Permutation([0, 1]), Permutation([1, 0])]
+    assert len(list(PermutationGroup(Permutation((0, 1))).generate())) == 1
+    g = PermutationGroup([a]).generate(method='dimino')
+    assert list(g) == [Permutation([0, 1]), Permutation([1, 0])]
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    g = G.generate()
+    v1 = [p.array_form for p in list(g)]
+    v1.sort()
+    assert v1 == [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0,
+        1], [2, 1, 0]]
+    v2 = list(G.generate(method='dimino', af=True))
+    assert v1 == sorted(v2)
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    g = PermutationGroup([a, b]).generate(af=True)
+    assert len(list(g)) == 360
+
+
+def test_order():
+    a = Permutation([2, 0, 1, 3, 4, 5, 6, 7, 8, 9])
+    b = Permutation([2, 1, 3, 4, 5, 6, 7, 8, 9, 0])
+    g = PermutationGroup([a, b])
+    assert g.order() == 1814400
+    assert PermutationGroup().order() == 1
+
+
+def test_equality():
+    p_1 = Permutation(0, 1, 3)
+    p_2 = Permutation(0, 2, 3)
+    p_3 = Permutation(0, 1, 2)
+    p_4 = Permutation(0, 1, 3)
+    g_1 = PermutationGroup(p_1, p_2)
+    g_2 = PermutationGroup(p_3, p_4)
+    g_3 = PermutationGroup(p_2, p_1)
+    g_4 = PermutationGroup(p_1, p_2)
+
+    assert g_1 != g_2
+    assert g_1.generators != g_2.generators
+    assert g_1.equals(g_2)
+    assert g_1 != g_3
+    assert g_1.equals(g_3)
+    assert g_1 == g_4
+
+
+def test_stabilizer():
+    S = SymmetricGroup(2)
+    H = S.stabilizer(0)
+    assert H.generators == [Permutation(1)]
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    G = PermutationGroup([a, b])
+    G0 = G.stabilizer(0)
+    assert G0.order() == 60
+
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    G2 = G.stabilizer(2)
+    assert G2.order() == 6
+    G2_1 = G2.stabilizer(1)
+    v = list(G2_1.generate(af=True))
+    assert v == [[0, 1, 2, 3, 4, 5, 6, 7], [3, 1, 2, 0, 7, 5, 6, 4]]
+
+    gens = (
+        (1, 2, 0, 4, 5, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
+        (0, 1, 2, 3, 4, 5, 19, 6, 8, 9, 10, 11, 12, 13, 14,
+         15, 16, 7, 17, 18),
+        (0, 1, 2, 3, 4, 5, 6, 7, 9, 18, 16, 11, 12, 13, 14, 15, 8, 17, 10, 19))
+    gens = [Permutation(p) for p in gens]
+    G = PermutationGroup(gens)
+    G2 = G.stabilizer(2)
+    assert G2.order() == 181440
+    S = SymmetricGroup(3)
+    assert [G.order() for G in S.basic_stabilizers] == [6, 2]
+
+
+def test_center():
+    # the center of the dihedral group D_n is of order 2 for even n
+    for i in (4, 6, 10):
+        D = DihedralGroup(i)
+        assert (D.center()).order() == 2
+    # the center of the dihedral group D_n is of order 1 for odd n>2
+    for i in (3, 5, 7):
+        D = DihedralGroup(i)
+        assert (D.center()).order() == 1
+    # the center of an abelian group is the group itself
+    for i in (2, 3, 5):
+        for j in (1, 5, 7):
+            for k in (1, 1, 11):
+                G = AbelianGroup(i, j, k)
+                assert G.center().is_subgroup(G)
+    # the center of a nonabelian simple group is trivial
+    for i in(1, 5, 9):
+        A = AlternatingGroup(i)
+        assert (A.center()).order() == 1
+    # brute-force verifications
+    D = DihedralGroup(5)
+    A = AlternatingGroup(3)
+    C = CyclicGroup(4)
+    G.is_subgroup(D*A*C)
+    assert _verify_centralizer(G, G)
+
+
+def test_centralizer():
+    # the centralizer of the trivial group is the entire group
+    S = SymmetricGroup(2)
+    assert S.centralizer(Permutation(list(range(2)))).is_subgroup(S)
+    A = AlternatingGroup(5)
+    assert A.centralizer(Permutation(list(range(5)))).is_subgroup(A)
+    # a centralizer in the trivial group is the trivial group itself
+    triv = PermutationGroup([Permutation([0, 1, 2, 3])])
+    D = DihedralGroup(4)
+    assert triv.centralizer(D).is_subgroup(triv)
+    # brute-force verifications for centralizers of groups
+    for i in (4, 5, 6):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        C = CyclicGroup(i)
+        D = DihedralGroup(i)
+        for gp in (S, A, C, D):
+            for gp2 in (S, A, C, D):
+                if not gp2.is_subgroup(gp):
+                    assert _verify_centralizer(gp, gp2)
+    # verify the centralizer for all elements of several groups
+    S = SymmetricGroup(5)
+    elements = list(S.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(S, element)
+    A = AlternatingGroup(5)
+    elements = list(A.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(A, element)
+    D = DihedralGroup(7)
+    elements = list(D.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(D, element)
+    # verify centralizers of small groups within small groups
+    small = []
+    for i in (1, 2, 3):
+        small.append(SymmetricGroup(i))
+        small.append(AlternatingGroup(i))
+        small.append(DihedralGroup(i))
+        small.append(CyclicGroup(i))
+    for gp in small:
+        for gp2 in small:
+            if gp.degree == gp2.degree:
+                assert _verify_centralizer(gp, gp2)
+
+
+def test_coset_rank():
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    i = 0
+    for h in G.generate(af=True):
+        rk = G.coset_rank(h)
+        assert rk == i
+        h1 = G.coset_unrank(rk, af=True)
+        assert h == h1
+        i += 1
+    assert G.coset_unrank(48) is None
+    assert G.coset_unrank(G.coset_rank(gens[0])) == gens[0]
+
+
+def test_coset_factor():
+    a = Permutation([0, 2, 1])
+    G = PermutationGroup([a])
+    c = Permutation([2, 1, 0])
+    assert not G.coset_factor(c)
+    assert G.coset_rank(c) is None
+
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    g = PermutationGroup([a, b])
+    assert g.order() == 360
+    d = Permutation([1, 0, 2, 3, 4, 5])
+    assert not g.coset_factor(d.array_form)
+    assert not g.contains(d)
+    assert Permutation(2) in G
+    c = Permutation([1, 0, 2, 3, 5, 4])
+    v = g.coset_factor(c, True)
+    tr = g.basic_transversals
+    p = Permutation.rmul(*[tr[i][v[i]] for i in range(len(g.base))])
+    assert p == c
+    v = g.coset_factor(c)
+    p = Permutation.rmul(*v)
+    assert p == c
+    assert g.contains(c)
+    G = PermutationGroup([Permutation([2, 1, 0])])
+    p = Permutation([1, 0, 2])
+    assert G.coset_factor(p) == []
+
+
+def test_orbits():
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    g = PermutationGroup([a, b])
+    assert g.orbit(0) == {0, 1, 2}
+    assert g.orbits() == [{0, 1, 2}]
+    assert g.is_transitive() and g.is_transitive(strict=False)
+    assert g.orbit_transversal(0) == \
+        [Permutation(
+            [0, 1, 2]), Permutation([2, 0, 1]), Permutation([1, 2, 0])]
+    assert g.orbit_transversal(0, True) == \
+        [(0, Permutation([0, 1, 2])), (2, Permutation([2, 0, 1])),
+        (1, Permutation([1, 2, 0]))]
+
+    G = DihedralGroup(6)
+    transversal, slps = _orbit_transversal(G.degree, G.generators, 0, True, slp=True)
+    for i, t in transversal:
+        slp = slps[i]
+        w = G.identity
+        for s in slp:
+            w = G.generators[s]*w
+        assert w == t
+
+    a = Permutation(list(range(1, 100)) + [0])
+    G = PermutationGroup([a])
+    assert [min(o) for o in G.orbits()] == [0]
+    G = PermutationGroup(rubik_cube_generators())
+    assert [min(o) for o in G.orbits()] == [0, 1]
+    assert not G.is_transitive() and not G.is_transitive(strict=False)
+    G = PermutationGroup([Permutation(0, 1, 3), Permutation(3)(0, 1)])
+    assert not G.is_transitive() and G.is_transitive(strict=False)
+    assert PermutationGroup(
+        Permutation(3)).is_transitive(strict=False) is False
+
+
+def test_is_normal():
+    gens_s5 = [Permutation(p) for p in [[1, 2, 3, 4, 0], [2, 1, 4, 0, 3]]]
+    G1 = PermutationGroup(gens_s5)
+    assert G1.order() == 120
+    gens_a5 = [Permutation(p) for p in [[1, 0, 3, 2, 4], [2, 1, 4, 3, 0]]]
+    G2 = PermutationGroup(gens_a5)
+    assert G2.order() == 60
+    assert G2.is_normal(G1)
+    gens3 = [Permutation(p) for p in [[2, 1, 3, 0, 4], [1, 2, 0, 3, 4]]]
+    G3 = PermutationGroup(gens3)
+    assert not G3.is_normal(G1)
+    assert G3.order() == 12
+    G4 = G1.normal_closure(G3.generators)
+    assert G4.order() == 60
+    gens5 = [Permutation(p) for p in [[1, 2, 3, 0, 4], [1, 2, 0, 3, 4]]]
+    G5 = PermutationGroup(gens5)
+    assert G5.order() == 24
+    G6 = G1.normal_closure(G5.generators)
+    assert G6.order() == 120
+    assert G1.is_subgroup(G6)
+    assert not G1.is_subgroup(G4)
+    assert G2.is_subgroup(G4)
+    I5 = PermutationGroup(Permutation(4))
+    assert I5.is_normal(G5)
+    assert I5.is_normal(G6, strict=False)
+    p1 = Permutation([1, 0, 2, 3, 4])
+    p2 = Permutation([0, 1, 2, 4, 3])
+    p3 = Permutation([3, 4, 2, 1, 0])
+    id_ = Permutation([0, 1, 2, 3, 4])
+    H = PermutationGroup([p1, p3])
+    H_n1 = PermutationGroup([p1, p2])
+    H_n2_1 = PermutationGroup(p1)
+    H_n2_2 = PermutationGroup(p2)
+    H_id = PermutationGroup(id_)
+    assert H_n1.is_normal(H)
+    assert H_n2_1.is_normal(H_n1)
+    assert H_n2_2.is_normal(H_n1)
+    assert H_id.is_normal(H_n2_1)
+    assert H_id.is_normal(H_n1)
+    assert H_id.is_normal(H)
+    assert not H_n2_1.is_normal(H)
+    assert not H_n2_2.is_normal(H)
+
+
+def test_eq():
+    a = [[1, 2, 0, 3, 4, 5], [1, 0, 2, 3, 4, 5], [2, 1, 0, 3, 4, 5], [
+        1, 2, 0, 3, 4, 5]]
+    a = [Permutation(p) for p in a + [[1, 2, 3, 4, 5, 0]]]
+    g = Permutation([1, 2, 3, 4, 5, 0])
+    G1, G2, G3 = [PermutationGroup(x) for x in [a[:2], a[2:4], [g, g**2]]]
+    assert G1.order() == G2.order() == G3.order() == 6
+    assert G1.is_subgroup(G2)
+    assert not G1.is_subgroup(G3)
+    G4 = PermutationGroup([Permutation([0, 1])])
+    assert not G1.is_subgroup(G4)
+    assert G4.is_subgroup(G1, 0)
+    assert PermutationGroup(g, g).is_subgroup(PermutationGroup(g))
+    assert SymmetricGroup(3).is_subgroup(SymmetricGroup(4), 0)
+    assert SymmetricGroup(3).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+    assert not CyclicGroup(5).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+    assert CyclicGroup(3).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+
+
+def test_derived_subgroup():
+    a = Permutation([1, 0, 2, 4, 3])
+    b = Permutation([0, 1, 3, 2, 4])
+    G = PermutationGroup([a, b])
+    C = G.derived_subgroup()
+    assert C.order() == 3
+    assert C.is_normal(G)
+    assert C.is_subgroup(G, 0)
+    assert not G.is_subgroup(C, 0)
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    C = G.derived_subgroup()
+    assert C.order() == 12
+
+
+def test_is_solvable():
+    a = Permutation([1, 2, 0])
+    b = Permutation([1, 0, 2])
+    G = PermutationGroup([a, b])
+    assert G.is_solvable
+    G = PermutationGroup([a])
+    assert G.is_solvable
+    a = Permutation([1, 2, 3, 4, 0])
+    b = Permutation([1, 0, 2, 3, 4])
+    G = PermutationGroup([a, b])
+    assert not G.is_solvable
+    P = SymmetricGroup(10)
+    S = P.sylow_subgroup(3)
+    assert S.is_solvable
+
+def test_rubik1():
+    gens = rubik_cube_generators()
+    gens1 = [gens[-1]] + [p**2 for p in gens[1:]]
+    G1 = PermutationGroup(gens1)
+    assert G1.order() == 19508428800
+    gens2 = [p**2 for p in gens]
+    G2 = PermutationGroup(gens2)
+    assert G2.order() == 663552
+    assert G2.is_subgroup(G1, 0)
+    C1 = G1.derived_subgroup()
+    assert C1.order() == 4877107200
+    assert C1.is_subgroup(G1, 0)
+    assert not G2.is_subgroup(C1, 0)
+
+    G = RubikGroup(2)
+    assert G.order() == 3674160
+
+
+@XFAIL
+def test_rubik():
+    skip('takes too much time')
+    G = PermutationGroup(rubik_cube_generators())
+    assert G.order() == 43252003274489856000
+    G1 = PermutationGroup(G[:3])
+    assert G1.order() == 170659735142400
+    assert not G1.is_normal(G)
+    G2 = G.normal_closure(G1.generators)
+    assert G2.is_subgroup(G)
+
+
+def test_direct_product():
+    C = CyclicGroup(4)
+    D = DihedralGroup(4)
+    G = C*C*C
+    assert G.order() == 64
+    assert G.degree == 12
+    assert len(G.orbits()) == 3
+    assert G.is_abelian is True
+    H = D*C
+    assert H.order() == 32
+    assert H.is_abelian is False
+
+
+def test_orbit_rep():
+    G = DihedralGroup(6)
+    assert G.orbit_rep(1, 3) in [Permutation([2, 3, 4, 5, 0, 1]),
+    Permutation([4, 3, 2, 1, 0, 5])]
+    H = CyclicGroup(4)*G
+    assert H.orbit_rep(1, 5) is False
+
+
+def test_schreier_vector():
+    G = CyclicGroup(50)
+    v = [0]*50
+    v[23] = -1
+    assert G.schreier_vector(23) == v
+    H = DihedralGroup(8)
+    assert H.schreier_vector(2) == [0, 1, -1, 0, 0, 1, 0, 0]
+    L = SymmetricGroup(4)
+    assert L.schreier_vector(1) == [1, -1, 0, 0]
+
+
+def test_random_pr():
+    D = DihedralGroup(6)
+    r = 11
+    n = 3
+    _random_prec_n = {}
+    _random_prec_n[0] = {'s': 7, 't': 3, 'x': 2, 'e': -1}
+    _random_prec_n[1] = {'s': 5, 't': 5, 'x': 1, 'e': -1}
+    _random_prec_n[2] = {'s': 3, 't': 4, 'x': 2, 'e': 1}
+    D._random_pr_init(r, n, _random_prec_n=_random_prec_n)
+    assert D._random_gens[11] == [0, 1, 2, 3, 4, 5]
+    _random_prec = {'s': 2, 't': 9, 'x': 1, 'e': -1}
+    assert D.random_pr(_random_prec=_random_prec) == \
+        Permutation([0, 5, 4, 3, 2, 1])
+
+
+def test_is_alt_sym():
+    G = DihedralGroup(10)
+    assert G.is_alt_sym() is False
+    assert G._eval_is_alt_sym_naive() is False
+    assert G._eval_is_alt_sym_naive(only_alt=True) is False
+    assert G._eval_is_alt_sym_naive(only_sym=True) is False
+
+    S = SymmetricGroup(10)
+    assert S._eval_is_alt_sym_naive() is True
+    assert S._eval_is_alt_sym_naive(only_alt=True) is False
+    assert S._eval_is_alt_sym_naive(only_sym=True) is True
+
+    N_eps = 10
+    _random_prec = {'N_eps': N_eps,
+        0: Permutation([[2], [1, 4], [0, 6, 7, 8, 9, 3, 5]]),
+        1: Permutation([[1, 8, 7, 6, 3, 5, 2, 9], [0, 4]]),
+        2: Permutation([[5, 8], [4, 7], [0, 1, 2, 3, 6, 9]]),
+        3: Permutation([[3], [0, 8, 2, 7, 4, 1, 6, 9, 5]]),
+        4: Permutation([[8], [4, 7, 9], [3, 6], [0, 5, 1, 2]]),
+        5: Permutation([[6], [0, 2, 4, 5, 1, 8, 3, 9, 7]]),
+        6: Permutation([[6, 9, 8], [4, 5], [1, 3, 7], [0, 2]]),
+        7: Permutation([[4], [0, 2, 9, 1, 3, 8, 6, 5, 7]]),
+        8: Permutation([[1, 5, 6, 3], [0, 2, 7, 8, 4, 9]]),
+        9: Permutation([[8], [6, 7], [2, 3, 4, 5], [0, 1, 9]])}
+    assert S.is_alt_sym(_random_prec=_random_prec) is True
+
+    A = AlternatingGroup(10)
+    assert A._eval_is_alt_sym_naive() is True
+    assert A._eval_is_alt_sym_naive(only_alt=True) is True
+    assert A._eval_is_alt_sym_naive(only_sym=True) is False
+
+    _random_prec = {'N_eps': N_eps,
+        0: Permutation([[1, 6, 4, 2, 7, 8, 5, 9, 3], [0]]),
+        1: Permutation([[1], [0, 5, 8, 4, 9, 2, 3, 6, 7]]),
+        2: Permutation([[1, 9, 8, 3, 2, 5], [0, 6, 7, 4]]),
+        3: Permutation([[6, 8, 9], [4, 5], [1, 3, 7, 2], [0]]),
+        4: Permutation([[8], [5], [4], [2, 6, 9, 3], [1], [0, 7]]),
+        5: Permutation([[3, 6], [0, 8, 1, 7, 5, 9, 4, 2]]),
+        6: Permutation([[5], [2, 9], [1, 8, 3], [0, 4, 7, 6]]),
+        7: Permutation([[1, 8, 4, 7, 2, 3], [0, 6, 9, 5]]),
+        8: Permutation([[5, 8, 7], [3], [1, 4, 2, 6], [0, 9]]),
+        9: Permutation([[4, 9, 6], [3, 8], [1, 2], [0, 5, 7]])}
+    assert A.is_alt_sym(_random_prec=_random_prec) is False
+
+    G = PermutationGroup(
+        Permutation(1, 3, size=8)(0, 2, 4, 6),
+        Permutation(5, 7, size=8)(0, 2, 4, 6))
+    assert G.is_alt_sym() is False
+
+    # Tests for monte-carlo c_n parameter setting, and which guarantees
+    # to give False.
+    G = DihedralGroup(10)
+    assert G._eval_is_alt_sym_monte_carlo() is False
+    G = DihedralGroup(20)
+    assert G._eval_is_alt_sym_monte_carlo() is False
+
+    # A dry-running test to check if it looks up for the updated cache.
+    G = DihedralGroup(6)
+    G.is_alt_sym()
+    assert G.is_alt_sym() is False
+
+
+def test_minimal_block():
+    D = DihedralGroup(6)
+    block_system = D.minimal_block([0, 3])
+    for i in range(3):
+        assert block_system[i] == block_system[i + 3]
+    S = SymmetricGroup(6)
+    assert S.minimal_block([0, 1]) == [0, 0, 0, 0, 0, 0]
+
+    assert Tetra.pgroup.minimal_block([0, 1]) == [0, 0, 0, 0]
+
+    P1 = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    P2 = PermutationGroup(Permutation(0, 1, 2, 3, 4, 5), Permutation(1, 5)(2, 4))
+    assert P1.minimal_block([0, 2]) == [0, 1, 0, 1, 0, 1]
+    assert P2.minimal_block([0, 2]) == [0, 1, 0, 1, 0, 1]
+
+
+def test_minimal_blocks():
+    P = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    assert P.minimal_blocks() == [[0, 1, 0, 1, 0, 1], [0, 1, 2, 0, 1, 2]]
+
+    P = SymmetricGroup(5)
+    assert P.minimal_blocks() == [[0]*5]
+
+    P = PermutationGroup(Permutation(0, 3))
+    assert P.minimal_blocks() is False
+
+
+def test_max_div():
+    S = SymmetricGroup(10)
+    assert S.max_div == 5
+
+
+def test_is_primitive():
+    S = SymmetricGroup(5)
+    assert S.is_primitive() is True
+    C = CyclicGroup(7)
+    assert C.is_primitive() is True
+
+    a = Permutation(0, 1, 2, size=6)
+    b = Permutation(3, 4, 5, size=6)
+    G = PermutationGroup(a, b)
+    assert G.is_primitive() is False
+
+
+def test_random_stab():
+    S = SymmetricGroup(5)
+    _random_el = Permutation([1, 3, 2, 0, 4])
+    _random_prec = {'rand': _random_el}
+    g = S.random_stab(2, _random_prec=_random_prec)
+    assert g == Permutation([1, 3, 2, 0, 4])
+    h = S.random_stab(1)
+    assert h(1) == 1
+
+
+def test_transitivity_degree():
+    perm = Permutation([1, 2, 0])
+    C = PermutationGroup([perm])
+    assert C.transitivity_degree == 1
+    gen1 = Permutation([1, 2, 0, 3, 4])
+    gen2 = Permutation([1, 2, 3, 4, 0])
+    # alternating group of degree 5
+    Alt = PermutationGroup([gen1, gen2])
+    assert Alt.transitivity_degree == 3
+
+
+def test_schreier_sims_random():
+    assert sorted(Tetra.pgroup.base) == [0, 1]
+
+    S = SymmetricGroup(3)
+    base = [0, 1]
+    strong_gens = [Permutation([1, 2, 0]), Permutation([1, 0, 2]),
+                  Permutation([0, 2, 1])]
+    assert S.schreier_sims_random(base, strong_gens, 5) == (base, strong_gens)
+    D = DihedralGroup(3)
+    _random_prec = {'g': [Permutation([2, 0, 1]), Permutation([1, 2, 0]),
+                         Permutation([1, 0, 2])]}
+    base = [0, 1]
+    strong_gens = [Permutation([1, 2, 0]), Permutation([2, 1, 0]),
+                  Permutation([0, 2, 1])]
+    assert D.schreier_sims_random([], D.generators, 2,
+           _random_prec=_random_prec) == (base, strong_gens)
+
+
+def test_baseswap():
+    S = SymmetricGroup(4)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    assert base == [0, 1, 2]
+    deterministic = S.baseswap(base, strong_gens, 1, randomized=False)
+    randomized = S.baseswap(base, strong_gens, 1)
+    assert deterministic[0] == [0, 2, 1]
+    assert _verify_bsgs(S, deterministic[0], deterministic[1]) is True
+    assert randomized[0] == [0, 2, 1]
+    assert _verify_bsgs(S, randomized[0], randomized[1]) is True
+
+
+def test_schreier_sims_incremental():
+    identity = Permutation([0, 1, 2, 3, 4])
+    TrivialGroup = PermutationGroup([identity])
+    base, strong_gens = TrivialGroup.schreier_sims_incremental(base=[0, 1, 2])
+    assert _verify_bsgs(TrivialGroup, base, strong_gens) is True
+    S = SymmetricGroup(5)
+    base, strong_gens = S.schreier_sims_incremental(base=[0, 1, 2])
+    assert _verify_bsgs(S, base, strong_gens) is True
+    D = DihedralGroup(2)
+    base, strong_gens = D.schreier_sims_incremental(base=[1])
+    assert _verify_bsgs(D, base, strong_gens) is True
+    A = AlternatingGroup(7)
+    gens = A.generators[:]
+    gen0 = gens[0]
+    gen1 = gens[1]
+    gen1 = rmul(gen1, ~gen0)
+    gen0 = rmul(gen0, gen1)
+    gen1 = rmul(gen0, gen1)
+    base, strong_gens = A.schreier_sims_incremental(base=[0, 1], gens=gens)
+    assert _verify_bsgs(A, base, strong_gens) is True
+    C = CyclicGroup(11)
+    gen = C.generators[0]
+    base, strong_gens = C.schreier_sims_incremental(gens=[gen**3])
+    assert _verify_bsgs(C, base, strong_gens) is True
+
+
+def _subgroup_search(i, j, k):
+    prop_true = lambda x: True
+    prop_fix_points = lambda x: [x(point) for point in points] == points
+    prop_comm_g = lambda x: rmul(x, g) == rmul(g, x)
+    prop_even = lambda x: x.is_even
+    for i in range(i, j, k):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        C = CyclicGroup(i)
+        Sym = S.subgroup_search(prop_true)
+        assert Sym.is_subgroup(S)
+        Alt = S.subgroup_search(prop_even)
+        assert Alt.is_subgroup(A)
+        Sym = S.subgroup_search(prop_true, init_subgroup=C)
+        assert Sym.is_subgroup(S)
+        points = [7]
+        assert S.stabilizer(7).is_subgroup(S.subgroup_search(prop_fix_points))
+        points = [3, 4]
+        assert S.stabilizer(3).stabilizer(4).is_subgroup(
+            S.subgroup_search(prop_fix_points))
+        points = [3, 5]
+        fix35 = A.subgroup_search(prop_fix_points)
+        points = [5]
+        fix5 = A.subgroup_search(prop_fix_points)
+        assert A.subgroup_search(prop_fix_points, init_subgroup=fix35
+            ).is_subgroup(fix5)
+        base, strong_gens = A.schreier_sims_incremental()
+        g = A.generators[0]
+        comm_g = \
+            A.subgroup_search(prop_comm_g, base=base, strong_gens=strong_gens)
+        assert _verify_bsgs(comm_g, base, comm_g.generators) is True
+        assert [prop_comm_g(gen) is True for gen in comm_g.generators]
+
+
+def test_subgroup_search():
+    _subgroup_search(10, 15, 2)
+
+
+@XFAIL
+def test_subgroup_search2():
+    skip('takes too much time')
+    _subgroup_search(16, 17, 1)
+
+
+def test_normal_closure():
+    # the normal closure of the trivial group is trivial
+    S = SymmetricGroup(3)
+    identity = Permutation([0, 1, 2])
+    closure = S.normal_closure(identity)
+    assert closure.is_trivial
+    # the normal closure of the entire group is the entire group
+    A = AlternatingGroup(4)
+    assert A.normal_closure(A).is_subgroup(A)
+    # brute-force verifications for subgroups
+    for i in (3, 4, 5):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        D = DihedralGroup(i)
+        C = CyclicGroup(i)
+        for gp in (A, D, C):
+            assert _verify_normal_closure(S, gp)
+    # brute-force verifications for all elements of a group
+    S = SymmetricGroup(5)
+    elements = list(S.generate_dimino())
+    for element in elements:
+        assert _verify_normal_closure(S, element)
+    # small groups
+    small = []
+    for i in (1, 2, 3):
+        small.append(SymmetricGroup(i))
+        small.append(AlternatingGroup(i))
+        small.append(DihedralGroup(i))
+        small.append(CyclicGroup(i))
+    for gp in small:
+        for gp2 in small:
+            if gp2.is_subgroup(gp, 0) and gp2.degree == gp.degree:
+                assert _verify_normal_closure(gp, gp2)
+
+
+def test_derived_series():
+    # the derived series of the trivial group consists only of the trivial group
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert triv.derived_series()[0].is_subgroup(triv)
+    # the derived series for a simple group consists only of the group itself
+    for i in (5, 6, 7):
+        A = AlternatingGroup(i)
+        assert A.derived_series()[0].is_subgroup(A)
+    # the derived series for S_4 is S_4 > A_4 > K_4 > triv
+    S = SymmetricGroup(4)
+    series = S.derived_series()
+    assert series[1].is_subgroup(AlternatingGroup(4))
+    assert series[2].is_subgroup(DihedralGroup(2))
+    assert series[3].is_trivial
+
+
+def test_lower_central_series():
+    # the lower central series of the trivial group consists of the trivial
+    # group
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert triv.lower_central_series()[0].is_subgroup(triv)
+    # the lower central series of a simple group consists of the group itself
+    for i in (5, 6, 7):
+        A = AlternatingGroup(i)
+        assert A.lower_central_series()[0].is_subgroup(A)
+    # GAP-verified example
+    S = SymmetricGroup(6)
+    series = S.lower_central_series()
+    assert len(series) == 2
+    assert series[1].is_subgroup(AlternatingGroup(6))
+
+
+def test_commutator():
+    # the commutator of the trivial group and the trivial group is trivial
+    S = SymmetricGroup(3)
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert S.commutator(triv, triv).is_subgroup(triv)
+    # the commutator of the trivial group and any other group is again trivial
+    A = AlternatingGroup(3)
+    assert S.commutator(triv, A).is_subgroup(triv)
+    # the commutator is commutative
+    for i in (3, 4, 5):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        D = DihedralGroup(i)
+        assert S.commutator(A, D).is_subgroup(S.commutator(D, A))
+    # the commutator of an abelian group is trivial
+    S = SymmetricGroup(7)
+    A1 = AbelianGroup(2, 5)
+    A2 = AbelianGroup(3, 4)
+    triv = PermutationGroup([Permutation([0, 1, 2, 3, 4, 5, 6])])
+    assert S.commutator(A1, A1).is_subgroup(triv)
+    assert S.commutator(A2, A2).is_subgroup(triv)
+    # examples calculated by hand
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert S.commutator(A, S).is_subgroup(A)
+
+
+def test_is_nilpotent():
+    # every abelian group is nilpotent
+    for i in (1, 2, 3):
+        C = CyclicGroup(i)
+        Ab = AbelianGroup(i, i + 2)
+        assert C.is_nilpotent
+        assert Ab.is_nilpotent
+    Ab = AbelianGroup(5, 7, 10)
+    assert Ab.is_nilpotent
+    # A_5 is not solvable and thus not nilpotent
+    assert AlternatingGroup(5).is_nilpotent is False
+
+
+def test_is_trivial():
+    for i in range(5):
+        triv = PermutationGroup([Permutation(list(range(i)))])
+        assert triv.is_trivial
+
+
+def test_pointwise_stabilizer():
+    S = SymmetricGroup(2)
+    stab = S.pointwise_stabilizer([0])
+    assert stab.generators == [Permutation(1)]
+    S = SymmetricGroup(5)
+    points = []
+    stab = S
+    for point in (2, 0, 3, 4, 1):
+        stab = stab.stabilizer(point)
+        points.append(point)
+        assert S.pointwise_stabilizer(points).is_subgroup(stab)
+
+
+def test_make_perm():
+    assert cube.pgroup.make_perm(5, seed=list(range(5))) == \
+        Permutation([4, 7, 6, 5, 0, 3, 2, 1])
+    assert cube.pgroup.make_perm(7, seed=list(range(7))) == \
+        Permutation([6, 7, 3, 2, 5, 4, 0, 1])
+
+
+def test_elements():
+    from sympy.sets.sets import FiniteSet
+
+    p = Permutation(2, 3)
+    assert set(PermutationGroup(p).elements) == {Permutation(3), Permutation(2, 3)}
+    assert FiniteSet(*PermutationGroup(p).elements) \
+        == FiniteSet(Permutation(2, 3), Permutation(3))
+
+
+def test_is_group():
+    assert PermutationGroup(Permutation(1,2), Permutation(2,4)).is_group is True
+    assert SymmetricGroup(4).is_group is True
+
+
+def test_PermutationGroup():
+    assert PermutationGroup() == PermutationGroup(Permutation())
+    assert (PermutationGroup() == 0) is False
+
+
+def test_coset_transvesal():
+    G = AlternatingGroup(5)
+    H = PermutationGroup(Permutation(0,1,2),Permutation(1,2)(3,4))
+    assert G.coset_transversal(H) == \
+        [Permutation(4), Permutation(2, 3, 4), Permutation(2, 4, 3),
+         Permutation(1, 2, 4), Permutation(4)(1, 2, 3), Permutation(1, 3)(2, 4),
+         Permutation(0, 1, 2, 3, 4), Permutation(0, 1, 2, 4, 3),
+         Permutation(0, 1, 3, 2, 4), Permutation(0, 2, 4, 1, 3)]
+
+
+def test_coset_table():
+    G = PermutationGroup(Permutation(0,1,2,3), Permutation(0,1,2),
+         Permutation(0,4,2,7), Permutation(5,6), Permutation(0,7))
+    H = PermutationGroup(Permutation(0,1,2,3), Permutation(0,7))
+    assert G.coset_table(H) == \
+        [[0, 0, 0, 0, 1, 2, 3, 3, 0, 0], [4, 5, 2, 5, 6, 0, 7, 7, 1, 1],
+         [5, 4, 5, 1, 0, 6, 8, 8, 6, 6], [3, 3, 3, 3, 7, 8, 0, 0, 3, 3],
+         [2, 1, 4, 4, 4, 4, 9, 9, 4, 4], [1, 2, 1, 2, 5, 5, 10, 10, 5, 5],
+         [6, 6, 6, 6, 2, 1, 11, 11, 2, 2], [9, 10, 8, 10, 11, 3, 1, 1, 7, 7],
+         [10, 9, 10, 7, 3, 11, 2, 2, 11, 11], [8, 7, 9, 9, 9, 9, 4, 4, 9, 9],
+         [7, 8, 7, 8, 10, 10, 5, 5, 10, 10], [11, 11, 11, 11, 8, 7, 6, 6, 8, 8]]
+
+
+def test_subgroup():
+    G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3))
+    H = G.subgroup([Permutation(0,1,3)])
+    assert H.is_subgroup(G)
+
+
+def test_generator_product():
+    G = SymmetricGroup(5)
+    p = Permutation(0, 2, 3)(1, 4)
+    gens = G.generator_product(p)
+    assert all(g in G.strong_gens for g in gens)
+    w = G.identity
+    for g in gens:
+        w = g*w
+    assert w == p
+
+
+def test_sylow_subgroup():
+    P = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    S = P.sylow_subgroup(2)
+    assert S.order() == 4
+
+    P = DihedralGroup(12)
+    S = P.sylow_subgroup(3)
+    assert S.order() == 3
+
+    P = PermutationGroup(
+        Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5), Permutation(0, 2))
+    S = P.sylow_subgroup(3)
+    assert S.order() == 9
+    S = P.sylow_subgroup(2)
+    assert S.order() == 8
+
+    P = SymmetricGroup(10)
+    S = P.sylow_subgroup(2)
+    assert S.order() == 256
+    S = P.sylow_subgroup(3)
+    assert S.order() == 81
+    S = P.sylow_subgroup(5)
+    assert S.order() == 25
+
+    # the length of the lower central series
+    # of a p-Sylow subgroup of Sym(n) grows with
+    # the highest exponent exp of p such
+    # that n >= p**exp
+    exp = 1
+    length = 0
+    for i in range(2, 9):
+        P = SymmetricGroup(i)
+        S = P.sylow_subgroup(2)
+        ls = S.lower_central_series()
+        if i // 2**exp > 0:
+            # length increases with exponent
+            assert len(ls) > length
+            length = len(ls)
+            exp += 1
+        else:
+            assert len(ls) == length
+
+    G = SymmetricGroup(100)
+    S = G.sylow_subgroup(3)
+    assert G.order() % S.order() == 0
+    assert G.order()/S.order() % 3 > 0
+
+    G = AlternatingGroup(100)
+    S = G.sylow_subgroup(2)
+    assert G.order() % S.order() == 0
+    assert G.order()/S.order() % 2 > 0
+
+    G = DihedralGroup(18)
+    S = G.sylow_subgroup(p=2)
+    assert S.order() == 4
+
+    G = DihedralGroup(50)
+    S = G.sylow_subgroup(p=2)
+    assert S.order() == 4
+
+
+@slow
+def test_presentation():
+    def _test(P):
+        G = P.presentation()
+        return G.order() == P.order()
+
+    def _strong_test(P):
+        G = P.strong_presentation()
+        chk = len(G.generators) == len(P.strong_gens)
+        return chk and G.order() == P.order()
+
+    P = PermutationGroup(Permutation(0,1,5,2)(3,7,4,6), Permutation(0,3,5,4)(1,6,2,7))
+    assert _test(P)
+
+    P = AlternatingGroup(5)
+    assert _test(P)
+
+    P = SymmetricGroup(5)
+    assert _test(P)
+
+    P = PermutationGroup(
+        [Permutation(0,3,1,2), Permutation(3)(0,1), Permutation(0,1)(2,3)])
+    assert _strong_test(P)
+
+    P = DihedralGroup(6)
+    assert _strong_test(P)
+
+    a = Permutation(0,1)(2,3)
+    b = Permutation(0,2)(3,1)
+    c = Permutation(4,5)
+    P = PermutationGroup(c, a, b)
+    assert _strong_test(P)
+
+
+def test_polycyclic():
+    a = Permutation([0, 1, 2])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    assert G.is_polycyclic is True
+
+    a = Permutation([1, 2, 3, 4, 0])
+    b = Permutation([1, 0, 2, 3, 4])
+    G = PermutationGroup([a, b])
+    assert G.is_polycyclic is False
+
+
+def test_elementary():
+    a = Permutation([1, 5, 2, 0, 3, 6, 4])
+    G = PermutationGroup([a])
+    assert G.is_elementary(7) is False
+
+    a = Permutation(0, 1)(2, 3)
+    b = Permutation(0, 2)(3, 1)
+    G = PermutationGroup([a, b])
+    assert G.is_elementary(2) is True
+    c = Permutation(4, 5, 6)
+    G = PermutationGroup([a, b, c])
+    assert G.is_elementary(2) is False
+
+    G = SymmetricGroup(4).sylow_subgroup(2)
+    assert G.is_elementary(2) is False
+    H = AlternatingGroup(4).sylow_subgroup(2)
+    assert H.is_elementary(2) is True
+
+
+def test_perfect():
+    G = AlternatingGroup(3)
+    assert G.is_perfect is False
+    G = AlternatingGroup(5)
+    assert G.is_perfect is True
+
+
+def test_index():
+    G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3))
+    H = G.subgroup([Permutation(0,1,3)])
+    assert G.index(H) == 4
+
+
+def test_cyclic():
+    G = SymmetricGroup(2)
+    assert G.is_cyclic
+    G = AbelianGroup(3, 7)
+    assert G.is_cyclic
+    G = AbelianGroup(7, 7)
+    assert not G.is_cyclic
+    G = AlternatingGroup(3)
+    assert G.is_cyclic
+    G = AlternatingGroup(4)
+    assert not G.is_cyclic
+
+    # Order less than 6
+    G = PermutationGroup(Permutation(0, 1, 2), Permutation(0, 2, 1))
+    assert G.is_cyclic
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(0, 2)(1, 3)
+    )
+    assert G.is_cyclic
+    G = PermutationGroup(
+        Permutation(3),
+        Permutation(0, 1)(2, 3),
+        Permutation(0, 2)(1, 3),
+        Permutation(0, 3)(1, 2)
+    )
+    assert G.is_cyclic is False
+
+    # Order 15
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
+        Permutation(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13)
+    )
+    assert G.is_cyclic
+
+    # Distinct prime orders
+    assert PermutationGroup._distinct_primes_lemma([3, 5]) is True
+    assert PermutationGroup._distinct_primes_lemma([5, 7]) is True
+    assert PermutationGroup._distinct_primes_lemma([2, 3]) is None
+    assert PermutationGroup._distinct_primes_lemma([3, 5, 7]) is None
+    assert PermutationGroup._distinct_primes_lemma([5, 7, 13]) is True
+
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(0, 2)(1, 3))
+    assert G.is_cyclic
+    assert G._is_abelian
+
+    # Non-abelian and therefore not cyclic
+    G = PermutationGroup(*SymmetricGroup(3).generators)
+    assert G.is_cyclic is False
+
+    # Abelian and cyclic
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(4, 5, 6)
+    )
+    assert G.is_cyclic
+
+    # Abelian but not cyclic
+    G = PermutationGroup(
+        Permutation(0, 1),
+        Permutation(2, 3),
+        Permutation(4, 5, 6)
+    )
+    assert G.is_cyclic is False
+
+
+def test_dihedral():
+    G = SymmetricGroup(2)
+    assert G.is_dihedral
+    G = SymmetricGroup(3)
+    assert G.is_dihedral
+
+    G = AbelianGroup(2, 2)
+    assert G.is_dihedral
+    G = CyclicGroup(4)
+    assert not G.is_dihedral
+
+    G = AbelianGroup(3, 5)
+    assert not G.is_dihedral
+    G = AbelianGroup(2)
+    assert G.is_dihedral
+    G = AbelianGroup(6)
+    assert not G.is_dihedral
+
+    # D6, generated by two adjacent flips
+    G = PermutationGroup(
+        Permutation(1, 5)(2, 4),
+        Permutation(0, 1)(3, 4)(2, 5))
+    assert G.is_dihedral
+
+    # D7, generated by a flip and a rotation
+    G = PermutationGroup(
+        Permutation(1, 6)(2, 5)(3, 4),
+        Permutation(0, 1, 2, 3, 4, 5, 6))
+    assert G.is_dihedral
+
+    # S4, presented by three generators, fails due to having exactly 9
+    # elements of order 2:
+    G = PermutationGroup(
+        Permutation(0, 1), Permutation(0, 2),
+        Permutation(0, 3))
+    assert not G.is_dihedral
+
+    # D7, given by three generators
+    G = PermutationGroup(
+        Permutation(1, 6)(2, 5)(3, 4),
+        Permutation(2, 0)(3, 6)(4, 5),
+        Permutation(0, 1, 2, 3, 4, 5, 6))
+    assert G.is_dihedral
+
+
+def test_abelian_invariants():
+    G = AbelianGroup(2, 3, 4)
+    assert G.abelian_invariants() == [2, 3, 4]
+    G=PermutationGroup([Permutation(1, 2, 3, 4), Permutation(1, 2), Permutation(5, 6)])
+    assert G.abelian_invariants() == [2, 2]
+    G = AlternatingGroup(7)
+    assert G.abelian_invariants() == []
+    G = AlternatingGroup(4)
+    assert G.abelian_invariants() == [3]
+    G = DihedralGroup(4)
+    assert G.abelian_invariants() == [2, 2]
+
+    G = PermutationGroup([Permutation(1, 2, 3, 4, 5, 6, 7)])
+    assert G.abelian_invariants() == [7]
+    G = DihedralGroup(12)
+    S = G.sylow_subgroup(3)
+    assert S.abelian_invariants() == [3]
+    G = PermutationGroup(Permutation(0, 1, 2), Permutation(0, 2, 3))
+    assert G.abelian_invariants() == [3]
+    G = PermutationGroup([Permutation(0, 1), Permutation(0, 2, 4, 6)(1, 3, 5, 7)])
+    assert G.abelian_invariants() == [2, 4]
+    G = SymmetricGroup(30)
+    S = G.sylow_subgroup(2)
+    assert S.abelian_invariants() == [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+    S = G.sylow_subgroup(3)
+    assert S.abelian_invariants() == [3, 3, 3, 3]
+    S = G.sylow_subgroup(5)
+    assert S.abelian_invariants() == [5, 5, 5]
+
+
+def test_composition_series():
+    a = Permutation(1, 2, 3)
+    b = Permutation(1, 2)
+    G = PermutationGroup([a, b])
+    comp_series = G.composition_series()
+    assert comp_series == G.derived_series()
+    # The first group in the composition series is always the group itself and
+    # the last group in the series is the trivial group.
+    S = SymmetricGroup(4)
+    assert S.composition_series()[0] == S
+    assert len(S.composition_series()) == 5
+    A = AlternatingGroup(4)
+    assert A.composition_series()[0] == A
+    assert len(A.composition_series()) == 4
+
+    # the composition series for C_8 is C_8 > C_4 > C_2 > triv
+    G = CyclicGroup(8)
+    series = G.composition_series()
+    assert is_isomorphic(series[1], CyclicGroup(4))
+    assert is_isomorphic(series[2], CyclicGroup(2))
+    assert series[3].is_trivial
+
+
+def test_is_symmetric():
+    a = Permutation(0, 1, 2)
+    b = Permutation(0, 1, size=3)
+    assert PermutationGroup(a, b).is_symmetric is True
+
+    a = Permutation(0, 2, 1)
+    b = Permutation(1, 2, size=3)
+    assert PermutationGroup(a, b).is_symmetric is True
+
+    a = Permutation(0, 1, 2, 3)
+    b = Permutation(0, 3)(1, 2)
+    assert PermutationGroup(a, b).is_symmetric is False
+
+def test_conjugacy_class():
+    S = SymmetricGroup(4)
+    x = Permutation(1, 2, 3)
+    C = {Permutation(0, 1, 2, size = 4), Permutation(0, 1, 3),
+             Permutation(0, 2, 1, size = 4), Permutation(0, 2, 3),
+             Permutation(0, 3, 1), Permutation(0, 3, 2),
+             Permutation(1, 2, 3), Permutation(1, 3, 2)}
+    assert S.conjugacy_class(x) == C
+
+def test_conjugacy_classes():
+    S = SymmetricGroup(3)
+    expected = [{Permutation(size = 3)},
+         {Permutation(0, 1, size = 3), Permutation(0, 2), Permutation(1, 2)},
+         {Permutation(0, 1, 2), Permutation(0, 2, 1)}]
+    computed = S.conjugacy_classes()
+
+    assert len(expected) == len(computed)
+    assert all(e in computed for e in expected)
+
+def test_coset_class():
+    a = Permutation(1, 2)
+    b = Permutation(0, 1)
+    G = PermutationGroup([a, b])
+    #Creating right coset
+    rht_coset = G*a
+    #Checking whether it is left coset or right coset
+    assert rht_coset.is_right_coset
+    assert not rht_coset.is_left_coset
+    #Creating list representation of coset
+    list_repr = rht_coset.as_list()
+    expected = [Permutation(0, 2), Permutation(0, 2, 1), Permutation(1, 2),
+                Permutation(2), Permutation(2)(0, 1), Permutation(0, 1, 2)]
+    for ele in list_repr:
+        assert ele in expected
+    #Creating left coset
+    left_coset = a*G
+    #Checking whether it is left coset or right coset
+    assert not left_coset.is_right_coset
+    assert left_coset.is_left_coset
+    #Creating list representation of Coset
+    list_repr = left_coset.as_list()
+    expected = [Permutation(2)(0, 1), Permutation(0, 1, 2), Permutation(1, 2),
+    Permutation(2), Permutation(0, 2), Permutation(0, 2, 1)]
+    for ele in list_repr:
+        assert ele in expected
+
+    G = PermutationGroup(Permutation(1, 2, 3, 4), Permutation(2, 3, 4))
+    H = PermutationGroup(Permutation(1, 2, 3, 4))
+    g = Permutation(1, 3)(2, 4)
+    rht_coset = Coset(g, H, G, dir='+')
+    assert rht_coset.is_right_coset
+    list_repr = rht_coset.as_list()
+    expected = [Permutation(1, 2, 3, 4), Permutation(4), Permutation(1, 3)(2, 4),
+    Permutation(1, 4, 3, 2)]
+    for ele in list_repr:
+        assert ele in expected
+
+def test_symmetricpermutationgroup():
+    a = SymmetricPermutationGroup(5)
+    assert a.degree == 5
+    assert a.order() == 120
+    assert a.identity() == Permutation(4)

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_permutations.py

@@ -0,0 +1,564 @@
+from itertools import permutations
+from copy import copy
+
+from sympy.core.expr import unchanged
+from sympy.core.numbers import Integer
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol
+from sympy.core.singleton import S
+from sympy.combinatorics.permutations import \
+    Permutation, _af_parity, _af_rmul, _af_rmuln, AppliedPermutation, Cycle
+from sympy.printing import sstr, srepr, pretty, latex
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+rmul = Permutation.rmul
+a = Symbol('a', integer=True)
+
+
+def test_Permutation():
+    # don't auto fill 0
+    raises(ValueError, lambda: Permutation([1]))
+    p = Permutation([0, 1, 2, 3])
+    # call as bijective
+    assert [p(i) for i in range(p.size)] == list(p)
+    # call as operator
+    assert p(list(range(p.size))) == list(p)
+    # call as function
+    assert list(p(1, 2)) == [0, 2, 1, 3]
+    raises(TypeError, lambda: p(-1))
+    raises(TypeError, lambda: p(5))
+    # conversion to list
+    assert list(p) == list(range(4))
+    assert p.copy() == p
+    assert copy(p) == p
+    assert Permutation(size=4) == Permutation(3)
+    assert Permutation(Permutation(3), size=5) == Permutation(4)
+    # cycle form with size
+    assert Permutation([[1, 2]], size=4) == Permutation([[1, 2], [0], [3]])
+    # random generation
+    assert Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1]))
+
+    p = Permutation([2, 5, 1, 6, 3, 0, 4])
+    q = Permutation([[1], [0, 3, 5, 6, 2, 4]])
+    assert len({p, p}) == 1
+    r = Permutation([1, 3, 2, 0, 4, 6, 5])
+    ans = Permutation(_af_rmuln(*[w.array_form for w in (p, q, r)])).array_form
+    assert rmul(p, q, r).array_form == ans
+    # make sure no other permutation of p, q, r could have given
+    # that answer
+    for a, b, c in permutations((p, q, r)):
+        if (a, b, c) == (p, q, r):
+            continue
+        assert rmul(a, b, c).array_form != ans
+
+    assert p.support() == list(range(7))
+    assert q.support() == [0, 2, 3, 4, 5, 6]
+    assert Permutation(p.cyclic_form).array_form == p.array_form
+    assert p.cardinality == 5040
+    assert q.cardinality == 5040
+    assert q.cycles == 2
+    assert rmul(q, p) == Permutation([4, 6, 1, 2, 5, 3, 0])
+    assert rmul(p, q) == Permutation([6, 5, 3, 0, 2, 4, 1])
+    assert _af_rmul(p.array_form, q.array_form) == \
+        [6, 5, 3, 0, 2, 4, 1]
+
+    assert rmul(Permutation([[1, 2, 3], [0, 4]]),
+                Permutation([[1, 2, 4], [0], [3]])).cyclic_form == \
+        [[0, 4, 2], [1, 3]]
+    assert q.array_form == [3, 1, 4, 5, 0, 6, 2]
+    assert q.cyclic_form == [[0, 3, 5, 6, 2, 4]]
+    assert q.full_cyclic_form == [[0, 3, 5, 6, 2, 4], [1]]
+    assert p.cyclic_form == [[0, 2, 1, 5], [3, 6, 4]]
+    t = p.transpositions()
+    assert t == [(0, 5), (0, 1), (0, 2), (3, 4), (3, 6)]
+    assert Permutation.rmul(*[Permutation(Cycle(*ti)) for ti in (t)])
+    assert Permutation([1, 0]).transpositions() == [(0, 1)]
+
+    assert p**13 == p
+    assert q**0 == Permutation(list(range(q.size)))
+    assert q**-2 == ~q**2
+    assert q**2 == Permutation([5, 1, 0, 6, 3, 2, 4])
+    assert q**3 == q**2*q
+    assert q**4 == q**2*q**2
+
+    a = Permutation(1, 3)
+    b = Permutation(2, 0, 3)
+    I = Permutation(3)
+    assert ~a == a**-1
+    assert a*~a == I
+    assert a*b**-1 == a*~b
+
+    ans = Permutation(0, 5, 3, 1, 6)(2, 4)
+    assert (p + q.rank()).rank() == ans.rank()
+    assert (p + q.rank())._rank == ans.rank()
+    assert (q + p.rank()).rank() == ans.rank()
+    raises(TypeError, lambda: p + Permutation(list(range(10))))
+
+    assert (p - q.rank()).rank() == Permutation(0, 6, 3, 1, 2, 5, 4).rank()
+    assert p.rank() - q.rank() < 0  # for coverage: make sure mod is used
+    assert (q - p.rank()).rank() == Permutation(1, 4, 6, 2)(3, 5).rank()
+
+    assert p*q == Permutation(_af_rmuln(*[list(w) for w in (q, p)]))
+    assert p*Permutation([]) == p
+    assert Permutation([])*p == p
+    assert p*Permutation([[0, 1]]) == Permutation([2, 5, 0, 6, 3, 1, 4])
+    assert Permutation([[0, 1]])*p == Permutation([5, 2, 1, 6, 3, 0, 4])
+
+    pq = p ^ q
+    assert pq == Permutation([5, 6, 0, 4, 1, 2, 3])
+    assert pq == rmul(q, p, ~q)
+    qp = q ^ p
+    assert qp == Permutation([4, 3, 6, 2, 1, 5, 0])
+    assert qp == rmul(p, q, ~p)
+    raises(ValueError, lambda: p ^ Permutation([]))
+
+    assert p.commutator(q) == Permutation(0, 1, 3, 4, 6, 5, 2)
+    assert q.commutator(p) == Permutation(0, 2, 5, 6, 4, 3, 1)
+    assert p.commutator(q) == ~q.commutator(p)
+    raises(ValueError, lambda: p.commutator(Permutation([])))
+
+    assert len(p.atoms()) == 7
+    assert q.atoms() == {0, 1, 2, 3, 4, 5, 6}
+
+    assert p.inversion_vector() == [2, 4, 1, 3, 1, 0]
+    assert q.inversion_vector() == [3, 1, 2, 2, 0, 1]
+
+    assert Permutation.from_inversion_vector(p.inversion_vector()) == p
+    assert Permutation.from_inversion_vector(q.inversion_vector()).array_form\
+        == q.array_form
+    raises(ValueError, lambda: Permutation.from_inversion_vector([0, 2]))
+    assert Permutation(list(range(500, -1, -1))).inversions() == 125250
+
+    s = Permutation([0, 4, 1, 3, 2])
+    assert s.parity() == 0
+    _ = s.cyclic_form  # needed to create a value for _cyclic_form
+    assert len(s._cyclic_form) != s.size and s.parity() == 0
+    assert not s.is_odd
+    assert s.is_even
+    assert Permutation([0, 1, 4, 3, 2]).parity() == 1
+    assert _af_parity([0, 4, 1, 3, 2]) == 0
+    assert _af_parity([0, 1, 4, 3, 2]) == 1
+
+    s = Permutation([0])
+
+    assert s.is_Singleton
+    assert Permutation([]).is_Empty
+
+    r = Permutation([3, 2, 1, 0])
+    assert (r**2).is_Identity
+
+    assert rmul(~p, p).is_Identity
+    assert (~p)**13 == Permutation([5, 2, 0, 4, 6, 1, 3])
+    assert p.max() == 6
+    assert p.min() == 0
+
+    q = Permutation([[6], [5], [0, 1, 2, 3, 4]])
+
+    assert q.max() == 4
+    assert q.min() == 0
+
+    p = Permutation([1, 5, 2, 0, 3, 6, 4])
+    q = Permutation([[1, 2, 3, 5, 6], [0, 4]])
+
+    assert p.ascents() == [0, 3, 4]
+    assert q.ascents() == [1, 2, 4]
+    assert r.ascents() == []
+
+    assert p.descents() == [1, 2, 5]
+    assert q.descents() == [0, 3, 5]
+    assert Permutation(r.descents()).is_Identity
+
+    assert p.inversions() == 7
+    # test the merge-sort with a longer permutation
+    big = list(p) + list(range(p.max() + 1, p.max() + 130))
+    assert Permutation(big).inversions() == 7
+    assert p.signature() == -1
+    assert q.inversions() == 11
+    assert q.signature() == -1
+    assert rmul(p, ~p).inversions() == 0
+    assert rmul(p, ~p).signature() == 1
+
+    assert p.order() == 6
+    assert q.order() == 10
+    assert (p**(p.order())).is_Identity
+
+    assert p.length() == 6
+    assert q.length() == 7
+    assert r.length() == 4
+
+    assert p.runs() == [[1, 5], [2], [0, 3, 6], [4]]
+    assert q.runs() == [[4], [2, 3, 5], [0, 6], [1]]
+    assert r.runs() == [[3], [2], [1], [0]]
+
+    assert p.index() == 8
+    assert q.index() == 8
+    assert r.index() == 3
+
+    assert p.get_precedence_distance(q) == q.get_precedence_distance(p)
+    assert p.get_adjacency_distance(q) == p.get_adjacency_distance(q)
+    assert p.get_positional_distance(q) == p.get_positional_distance(q)
+    p = Permutation([0, 1, 2, 3])
+    q = Permutation([3, 2, 1, 0])
+    assert p.get_precedence_distance(q) == 6
+    assert p.get_adjacency_distance(q) == 3
+    assert p.get_positional_distance(q) == 8
+    p = Permutation([0, 3, 1, 2, 4])
+    q = Permutation.josephus(4, 5, 2)
+    assert p.get_adjacency_distance(q) == 3
+    raises(ValueError, lambda: p.get_adjacency_distance(Permutation([])))
+    raises(ValueError, lambda: p.get_positional_distance(Permutation([])))
+    raises(ValueError, lambda: p.get_precedence_distance(Permutation([])))
+
+    a = [Permutation.unrank_nonlex(4, i) for i in range(5)]
+    iden = Permutation([0, 1, 2, 3])
+    for i in range(5):
+        for j in range(i + 1, 5):
+            assert a[i].commutes_with(a[j]) == \
+                (rmul(a[i], a[j]) == rmul(a[j], a[i]))
+            if a[i].commutes_with(a[j]):
+                assert a[i].commutator(a[j]) == iden
+                assert a[j].commutator(a[i]) == iden
+
+    a = Permutation(3)
+    b = Permutation(0, 6, 3)(1, 2)
+    assert a.cycle_structure == {1: 4}
+    assert b.cycle_structure == {2: 1, 3: 1, 1: 2}
+    # issue 11130
+    raises(ValueError, lambda: Permutation(3, size=3))
+    raises(ValueError, lambda: Permutation([1, 2, 0, 3], size=3))
+
+
+def test_Permutation_subclassing():
+    # Subclass that adds permutation application on iterables
+    class CustomPermutation(Permutation):
+        def __call__(self, *i):
+            try:
+                return super().__call__(*i)
+            except TypeError:
+                pass
+
+            try:
+                perm_obj = i[0]
+                return [self._array_form[j] for j in perm_obj]
+            except TypeError:
+                raise TypeError('unrecognized argument')
+
+        def __eq__(self, other):
+            if isinstance(other, Permutation):
+                return self._hashable_content() == other._hashable_content()
+            else:
+                return super().__eq__(other)
+
+        def __hash__(self):
+            return super().__hash__()
+
+    p = CustomPermutation([1, 2, 3, 0])
+    q = Permutation([1, 2, 3, 0])
+
+    assert p == q
+    raises(TypeError, lambda: q([1, 2]))
+    assert [2, 3] == p([1, 2])
+
+    assert type(p * q) == CustomPermutation
+    assert type(q * p) == Permutation  # True because q.__mul__(p) is called!
+
+    # Run all tests for the Permutation class also on the subclass
+    def wrapped_test_Permutation():
+        # Monkeypatch the class definition in the globals
+        globals()['__Perm'] = globals()['Permutation']
+        globals()['Permutation'] = CustomPermutation
+        test_Permutation()
+        globals()['Permutation'] = globals()['__Perm']  # Restore
+        del globals()['__Perm']
+
+    wrapped_test_Permutation()
+
+
+def test_josephus():
+    assert Permutation.josephus(4, 6, 1) == Permutation([3, 1, 0, 2, 5, 4])
+    assert Permutation.josephus(1, 5, 1).is_Identity
+
+
+def test_ranking():
+    assert Permutation.unrank_lex(5, 10).rank() == 10
+    p = Permutation.unrank_lex(15, 225)
+    assert p.rank() == 225
+    p1 = p.next_lex()
+    assert p1.rank() == 226
+    assert Permutation.unrank_lex(15, 225).rank() == 225
+    assert Permutation.unrank_lex(10, 0).is_Identity
+    p = Permutation.unrank_lex(4, 23)
+    assert p.rank() == 23
+    assert p.array_form == [3, 2, 1, 0]
+    assert p.next_lex() is None
+
+    p = Permutation([1, 5, 2, 0, 3, 6, 4])
+    q = Permutation([[1, 2, 3, 5, 6], [0, 4]])
+    a = [Permutation.unrank_trotterjohnson(4, i).array_form for i in range(5)]
+    assert a == [[0, 1, 2, 3], [0, 1, 3, 2], [0, 3, 1, 2], [3, 0, 1,
+        2], [3, 0, 2, 1] ]
+    assert [Permutation(pa).rank_trotterjohnson() for pa in a] == list(range(5))
+    assert Permutation([0, 1, 2, 3]).next_trotterjohnson() == \
+        Permutation([0, 1, 3, 2])
+
+    assert q.rank_trotterjohnson() == 2283
+    assert p.rank_trotterjohnson() == 3389
+    assert Permutation([1, 0]).rank_trotterjohnson() == 1
+    a = Permutation(list(range(3)))
+    b = a
+    l = []
+    tj = []
+    for i in range(6):
+        l.append(a)
+        tj.append(b)
+        a = a.next_lex()
+        b = b.next_trotterjohnson()
+    assert a == b is None
+    assert {tuple(a) for a in l} == {tuple(a) for a in tj}
+
+    p = Permutation([2, 5, 1, 6, 3, 0, 4])
+    q = Permutation([[6], [5], [0, 1, 2, 3, 4]])
+    assert p.rank() == 1964
+    assert q.rank() == 870
+    assert Permutation([]).rank_nonlex() == 0
+    prank = p.rank_nonlex()
+    assert prank == 1600
+    assert Permutation.unrank_nonlex(7, 1600) == p
+    qrank = q.rank_nonlex()
+    assert qrank == 41
+    assert Permutation.unrank_nonlex(7, 41) == Permutation(q.array_form)
+
+    a = [Permutation.unrank_nonlex(4, i).array_form for i in range(24)]
+    assert a == [
+        [1, 2, 3, 0], [3, 2, 0, 1], [1, 3, 0, 2], [1, 2, 0, 3], [2, 3, 1, 0],
+        [2, 0, 3, 1], [3, 0, 1, 2], [2, 0, 1, 3], [1, 3, 2, 0], [3, 0, 2, 1],
+        [1, 0, 3, 2], [1, 0, 2, 3], [2, 1, 3, 0], [2, 3, 0, 1], [3, 1, 0, 2],
+        [2, 1, 0, 3], [3, 2, 1, 0], [0, 2, 3, 1], [0, 3, 1, 2], [0, 2, 1, 3],
+        [3, 1, 2, 0], [0, 3, 2, 1], [0, 1, 3, 2], [0, 1, 2, 3]]
+
+    N = 10
+    p1 = Permutation(a[0])
+    for i in range(1, N+1):
+        p1 = p1*Permutation(a[i])
+    p2 = Permutation.rmul_with_af(*[Permutation(h) for h in a[N::-1]])
+    assert p1 == p2
+
+    ok = []
+    p = Permutation([1, 0])
+    for i in range(3):
+        ok.append(p.array_form)
+        p = p.next_nonlex()
+        if p is None:
+            ok.append(None)
+            break
+    assert ok == [[1, 0], [0, 1], None]
+    assert Permutation([3, 2, 0, 1]).next_nonlex() == Permutation([1, 3, 0, 2])
+    assert [Permutation(pa).rank_nonlex() for pa in a] == list(range(24))
+
+
+def test_mul():
+    a, b = [0, 2, 1, 3], [0, 1, 3, 2]
+    assert _af_rmul(a, b) == [0, 2, 3, 1]
+    assert _af_rmuln(a, b, list(range(4))) == [0, 2, 3, 1]
+    assert rmul(Permutation(a), Permutation(b)).array_form == [0, 2, 3, 1]
+
+    a = Permutation([0, 2, 1, 3])
+    b = (0, 1, 3, 2)
+    c = (3, 1, 2, 0)
+    assert Permutation.rmul(a, b, c) == Permutation([1, 2, 3, 0])
+    assert Permutation.rmul(a, c) == Permutation([3, 2, 1, 0])
+    raises(TypeError, lambda: Permutation.rmul(b, c))
+
+    n = 6
+    m = 8
+    a = [Permutation.unrank_nonlex(n, i).array_form for i in range(m)]
+    h = list(range(n))
+    for i in range(m):
+        h = _af_rmul(h, a[i])
+        h2 = _af_rmuln(*a[:i + 1])
+        assert h == h2
+
+
+def test_args():
+    p = Permutation([(0, 3, 1, 2), (4, 5)])
+    assert p._cyclic_form is None
+    assert Permutation(p) == p
+    assert p.cyclic_form == [[0, 3, 1, 2], [4, 5]]
+    assert p._array_form == [3, 2, 0, 1, 5, 4]
+    p = Permutation((0, 3, 1, 2))
+    assert p._cyclic_form is None
+    assert p._array_form == [0, 3, 1, 2]
+    assert Permutation([0]) == Permutation((0, ))
+    assert Permutation([[0], [1]]) == Permutation(((0, ), (1, ))) == \
+        Permutation(((0, ), [1]))
+    assert Permutation([[1, 2]]) == Permutation([0, 2, 1])
+    assert Permutation([[1], [4, 2]]) == Permutation([0, 1, 4, 3, 2])
+    assert Permutation([[1], [4, 2]], size=1) == Permutation([0, 1, 4, 3, 2])
+    assert Permutation(
+        [[1], [4, 2]], size=6) == Permutation([0, 1, 4, 3, 2, 5])
+    assert Permutation([[0, 1], [0, 2]]) == Permutation(0, 1, 2)
+    assert Permutation([], size=3) == Permutation([0, 1, 2])
+    assert Permutation(3).list(5) == [0, 1, 2, 3, 4]
+    assert Permutation(3).list(-1) == []
+    assert Permutation(5)(1, 2).list(-1) == [0, 2, 1]
+    assert Permutation(5)(1, 2).list() == [0, 2, 1, 3, 4, 5]
+    raises(ValueError, lambda: Permutation([1, 2], [0]))
+           # enclosing brackets needed
+    raises(ValueError, lambda: Permutation([[1, 2], 0]))
+           # enclosing brackets needed on 0
+    raises(ValueError, lambda: Permutation([1, 1, 0]))
+    raises(ValueError, lambda: Permutation([4, 5], size=10))  # where are 0-3?
+    # but this is ok because cycles imply that only those listed moved
+    assert Permutation(4, 5) == Permutation([0, 1, 2, 3, 5, 4])
+
+
+def test_Cycle():
+    assert str(Cycle()) == '()'
+    assert Cycle(Cycle(1,2)) == Cycle(1, 2)
+    assert Cycle(1,2).copy() == Cycle(1,2)
+    assert list(Cycle(1, 3, 2)) == [0, 3, 1, 2]
+    assert Cycle(1, 2)(2, 3) == Cycle(1, 3, 2)
+    assert Cycle(1, 2)(2, 3)(4, 5) == Cycle(1, 3, 2)(4, 5)
+    assert Permutation(Cycle(1, 2)(2, 1, 0, 3)).cyclic_form, Cycle(0, 2, 1)
+    raises(ValueError, lambda: Cycle().list())
+    assert Cycle(1, 2).list() == [0, 2, 1]
+    assert Cycle(1, 2).list(4) == [0, 2, 1, 3]
+    assert Cycle(3).list(2) == [0, 1]
+    assert Cycle(3).list(6) == [0, 1, 2, 3, 4, 5]
+    assert Permutation(Cycle(1, 2), size=4) == \
+        Permutation([0, 2, 1, 3])
+    assert str(Cycle(1, 2)(4, 5)) == '(1 2)(4 5)'
+    assert str(Cycle(1, 2)) == '(1 2)'
+    assert Cycle(Permutation(list(range(3)))) == Cycle()
+    assert Cycle(1, 2).list() == [0, 2, 1]
+    assert Cycle(1, 2).list(4) == [0, 2, 1, 3]
+    assert Cycle().size == 0
+    raises(ValueError, lambda: Cycle((1, 2)))
+    raises(ValueError, lambda: Cycle(1, 2, 1))
+    raises(TypeError, lambda: Cycle(1, 2)*{})
+    raises(ValueError, lambda: Cycle(4)[a])
+    raises(ValueError, lambda: Cycle(2, -4, 3))
+
+    # check round-trip
+    p = Permutation([[1, 2], [4, 3]], size=5)
+    assert Permutation(Cycle(p)) == p
+
+
+def test_from_sequence():
+    assert Permutation.from_sequence('SymPy') == Permutation(4)(0, 1, 3)
+    assert Permutation.from_sequence('SymPy', key=lambda x: x.lower()) == \
+        Permutation(4)(0, 2)(1, 3)
+
+
+def test_resize():
+    p = Permutation(0, 1, 2)
+    assert p.resize(5) == Permutation(0, 1, 2, size=5)
+    assert p.resize(4) == Permutation(0, 1, 2, size=4)
+    assert p.resize(3) == p
+    raises(ValueError, lambda: p.resize(2))
+
+    p = Permutation(0, 1, 2)(3, 4)(5, 6)
+    assert p.resize(3) == Permutation(0, 1, 2)
+    raises(ValueError, lambda: p.resize(4))
+
+
+def test_printing_cyclic():
+    p1 = Permutation([0, 2, 1])
+    assert repr(p1) == 'Permutation(1, 2)'
+    assert str(p1) == '(1 2)'
+    p2 = Permutation()
+    assert repr(p2) == 'Permutation()'
+    assert str(p2) == '()'
+    p3 = Permutation([1, 2, 0, 3])
+    assert repr(p3) == 'Permutation(3)(0, 1, 2)'
+
+
+def test_printing_non_cyclic():
+    p1 = Permutation([0, 1, 2, 3, 4, 5])
+    assert srepr(p1, perm_cyclic=False) == 'Permutation([], size=6)'
+    assert sstr(p1, perm_cyclic=False) == 'Permutation([], size=6)'
+    p2 = Permutation([0, 1, 2])
+    assert srepr(p2, perm_cyclic=False) == 'Permutation([0, 1, 2])'
+    assert sstr(p2, perm_cyclic=False) == 'Permutation([0, 1, 2])'
+
+    p3 = Permutation([0, 2, 1])
+    assert srepr(p3, perm_cyclic=False) == 'Permutation([0, 2, 1])'
+    assert sstr(p3, perm_cyclic=False) == 'Permutation([0, 2, 1])'
+    p4 = Permutation([0, 1, 3, 2, 4, 5, 6, 7])
+    assert srepr(p4, perm_cyclic=False) == 'Permutation([0, 1, 3, 2], size=8)'
+
+
+def test_deprecated_print_cyclic():
+    p = Permutation(0, 1, 2)
+    try:
+        Permutation.print_cyclic = True
+        with warns_deprecated_sympy():
+            assert sstr(p) == '(0 1 2)'
+        with warns_deprecated_sympy():
+            assert srepr(p) == 'Permutation(0, 1, 2)'
+        with warns_deprecated_sympy():
+            assert pretty(p) == '(0 1 2)'
+        with warns_deprecated_sympy():
+            assert latex(p) == r'\left( 0\; 1\; 2\right)'
+
+        Permutation.print_cyclic = False
+        with warns_deprecated_sympy():
+            assert sstr(p) == 'Permutation([1, 2, 0])'
+        with warns_deprecated_sympy():
+            assert srepr(p) == 'Permutation([1, 2, 0])'
+        with warns_deprecated_sympy():
+            assert pretty(p, use_unicode=False) == '/0 1 2\\\n\\1 2 0/'
+        with warns_deprecated_sympy():
+            assert latex(p) == \
+                r'\begin{pmatrix} 0 & 1 & 2 \\ 1 & 2 & 0 \end{pmatrix}'
+    finally:
+        Permutation.print_cyclic = None
+
+
+def test_permutation_equality():
+    a = Permutation(0, 1, 2)
+    b = Permutation(0, 1, 2)
+    assert Eq(a, b) is S.true
+    c = Permutation(0, 2, 1)
+    assert Eq(a, c) is S.false
+
+    d = Permutation(0, 1, 2, size=4)
+    assert unchanged(Eq, a, d)
+    e = Permutation(0, 2, 1, size=4)
+    assert unchanged(Eq, a, e)
+
+    i = Permutation()
+    assert unchanged(Eq, i, 0)
+    assert unchanged(Eq, 0, i)
+
+
+def test_issue_17661():
+    c1 = Cycle(1,2)
+    c2 = Cycle(1,2)
+    assert c1 == c2
+    assert repr(c1) == 'Cycle(1, 2)'
+    assert c1 == c2
+
+
+def test_permutation_apply():
+    x = Symbol('x')
+    p = Permutation(0, 1, 2)
+    assert p.apply(0) == 1
+    assert isinstance(p.apply(0), Integer)
+    assert p.apply(x) == AppliedPermutation(p, x)
+    assert AppliedPermutation(p, x).subs(x, 0) == 1
+
+    x = Symbol('x', integer=False)
+    raises(NotImplementedError, lambda: p.apply(x))
+    x = Symbol('x', negative=True)
+    raises(NotImplementedError, lambda: p.apply(x))
+
+
+def test_AppliedPermutation():
+    x = Symbol('x')
+    p = Permutation(0, 1, 2)
+    raises(ValueError, lambda: AppliedPermutation((0, 1, 2), x))
+    assert AppliedPermutation(p, 1, evaluate=True) == 2
+    assert AppliedPermutation(p, 1, evaluate=False).__class__ == \
+        AppliedPermutation

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_polyhedron.py

@@ -0,0 +1,105 @@
+from sympy.core.symbol import symbols
+from sympy.sets.sets import FiniteSet
+from sympy.combinatorics.polyhedron import (Polyhedron,
+    tetrahedron, cube as square, octahedron, dodecahedron, icosahedron,
+    cube_faces)
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.testing.pytest import raises
+
+rmul = Permutation.rmul
+
+
+def test_polyhedron():
+    raises(ValueError, lambda: Polyhedron(list('ab'),
+        pgroup=[Permutation([0])]))
+    pgroup = [Permutation([[0, 7, 2, 5], [6, 1, 4, 3]]),
+              Permutation([[0, 7, 1, 6], [5, 2, 4, 3]]),
+              Permutation([[3, 6, 0, 5], [4, 1, 7, 2]]),
+              Permutation([[7, 4, 5], [1, 3, 0], [2], [6]]),
+              Permutation([[1, 3, 2], [7, 6, 5], [4], [0]]),
+              Permutation([[4, 7, 6], [2, 0, 3], [1], [5]]),
+              Permutation([[1, 2, 0], [4, 5, 6], [3], [7]]),
+              Permutation([[4, 2], [0, 6], [3, 7], [1, 5]]),
+              Permutation([[3, 5], [7, 1], [2, 6], [0, 4]]),
+              Permutation([[2, 5], [1, 6], [0, 4], [3, 7]]),
+              Permutation([[4, 3], [7, 0], [5, 1], [6, 2]]),
+              Permutation([[4, 1], [0, 5], [6, 2], [7, 3]]),
+              Permutation([[7, 2], [3, 6], [0, 4], [1, 5]]),
+              Permutation([0, 1, 2, 3, 4, 5, 6, 7])]
+    corners = tuple(symbols('A:H'))
+    faces = cube_faces
+    cube = Polyhedron(corners, faces, pgroup)
+
+    assert cube.edges == FiniteSet(*(
+        (0, 1), (6, 7), (1, 2), (5, 6), (0, 3), (2, 3),
+        (4, 7), (4, 5), (3, 7), (1, 5), (0, 4), (2, 6)))
+
+    for i in range(3):  # add 180 degree face rotations
+        cube.rotate(cube.pgroup[i]**2)
+
+    assert cube.corners == corners
+
+    for i in range(3, 7):  # add 240 degree axial corner rotations
+        cube.rotate(cube.pgroup[i]**2)
+
+    assert cube.corners == corners
+    cube.rotate(1)
+    raises(ValueError, lambda: cube.rotate(Permutation([0, 1])))
+    assert cube.corners != corners
+    assert cube.array_form == [7, 6, 4, 5, 3, 2, 0, 1]
+    assert cube.cyclic_form == [[0, 7, 1, 6], [2, 4, 3, 5]]
+    cube.reset()
+    assert cube.corners == corners
+
+    def check(h, size, rpt, target):
+
+        assert len(h.faces) + len(h.vertices) - len(h.edges) == 2
+        assert h.size == size
+
+        got = set()
+        for p in h.pgroup:
+            # make sure it restores original
+            P = h.copy()
+            hit = P.corners
+            for i in range(rpt):
+                P.rotate(p)
+                if P.corners == hit:
+                    break
+            else:
+                print('error in permutation', p.array_form)
+            for i in range(rpt):
+                P.rotate(p)
+                got.add(tuple(P.corners))
+                c = P.corners
+                f = [[c[i] for i in f] for f in P.faces]
+                assert h.faces == Polyhedron(c, f).faces
+        assert len(got) == target
+        assert PermutationGroup([Permutation(g) for g in got]).is_group
+
+    for h, size, rpt, target in zip(
+        (tetrahedron, square, octahedron, dodecahedron, icosahedron),
+        (4, 8, 6, 20, 12),
+        (3, 4, 4, 5, 5),
+            (12, 24, 24, 60, 60)):
+        check(h, size, rpt, target)
+
+
+def test_pgroups():
+    from sympy.combinatorics.polyhedron import (cube, tetrahedron_faces,
+            octahedron_faces, dodecahedron_faces, icosahedron_faces)
+    from sympy.combinatorics.polyhedron import _pgroup_calcs
+    (tetrahedron2, cube2, octahedron2, dodecahedron2, icosahedron2,
+     tetrahedron_faces2, cube_faces2, octahedron_faces2,
+     dodecahedron_faces2, icosahedron_faces2) = _pgroup_calcs()
+
+    assert tetrahedron == tetrahedron2
+    assert cube == cube2
+    assert octahedron == octahedron2
+    assert dodecahedron == dodecahedron2
+    assert icosahedron == icosahedron2
+    assert sorted(map(sorted, tetrahedron_faces)) == sorted(map(sorted, tetrahedron_faces2))
+    assert sorted(cube_faces) == sorted(cube_faces2)
+    assert sorted(octahedron_faces) == sorted(octahedron_faces2)
+    assert sorted(dodecahedron_faces) == sorted(dodecahedron_faces2)
+    assert sorted(icosahedron_faces) == sorted(icosahedron_faces2)

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_prufer.py

@@ -0,0 +1,74 @@
+from sympy.combinatorics.prufer import Prufer
+from sympy.testing.pytest import raises
+
+
+def test_prufer():
+    # number of nodes is optional
+    assert Prufer([[0, 1], [0, 2], [0, 3], [0, 4]], 5).nodes == 5
+    assert Prufer([[0, 1], [0, 2], [0, 3], [0, 4]]).nodes == 5
+
+    a = Prufer([[0, 1], [0, 2], [0, 3], [0, 4]])
+    assert a.rank == 0
+    assert a.nodes == 5
+    assert a.prufer_repr == [0, 0, 0]
+
+    a = Prufer([[2, 4], [1, 4], [1, 3], [0, 5], [0, 4]])
+    assert a.rank == 924
+    assert a.nodes == 6
+    assert a.tree_repr == [[2, 4], [1, 4], [1, 3], [0, 5], [0, 4]]
+    assert a.prufer_repr == [4, 1, 4, 0]
+
+    assert Prufer.edges([0, 1, 2, 3], [1, 4, 5], [1, 4, 6]) == \
+        ([[0, 1], [1, 2], [1, 4], [2, 3], [4, 5], [4, 6]], 7)
+    assert Prufer([0]*4).size == Prufer([6]*4).size == 1296
+
+    # accept iterables but convert to list of lists
+    tree = [(0, 1), (1, 5), (0, 3), (0, 2), (2, 6), (4, 7), (2, 4)]
+    tree_lists = [list(t) for t in tree]
+    assert Prufer(tree).tree_repr == tree_lists
+    assert sorted(Prufer(set(tree)).tree_repr) == sorted(tree_lists)
+
+    raises(ValueError, lambda: Prufer([[1, 2], [3, 4]]))  # 0 is missing
+    raises(ValueError, lambda: Prufer([[2, 3], [3, 4]]))  # 0, 1 are missing
+    assert Prufer(*Prufer.edges([1, 2], [3, 4])).prufer_repr == [1, 3]
+    raises(ValueError, lambda: Prufer.edges(
+        [1, 3], [3, 4]))  # a broken tree but edges doesn't care
+    raises(ValueError, lambda: Prufer.edges([1, 2], [5, 6]))
+    raises(ValueError, lambda: Prufer([[]]))
+
+    a = Prufer([[0, 1], [0, 2], [0, 3]])
+    b = a.next()
+    assert b.tree_repr == [[0, 2], [0, 1], [1, 3]]
+    assert b.rank == 1
+
+
+def test_round_trip():
+    def doit(t, b):
+        e, n = Prufer.edges(*t)
+        t = Prufer(e, n)
+        a = sorted(t.tree_repr)
+        b = [i - 1 for i in b]
+        assert t.prufer_repr == b
+        assert sorted(Prufer(b).tree_repr) == a
+        assert Prufer.unrank(t.rank, n).prufer_repr == b
+
+    doit([[1, 2]], [])
+    doit([[2, 1, 3]], [1])
+    doit([[1, 3, 2]], [3])
+    doit([[1, 2, 3]], [2])
+    doit([[2, 1, 4], [1, 3]], [1, 1])
+    doit([[3, 2, 1, 4]], [2, 1])
+    doit([[3, 2, 1], [2, 4]], [2, 2])
+    doit([[1, 3, 2, 4]], [3, 2])
+    doit([[1, 4, 2, 3]], [4, 2])
+    doit([[3, 1, 4, 2]], [4, 1])
+    doit([[4, 2, 1, 3]], [1, 2])
+    doit([[1, 2, 4, 3]], [2, 4])
+    doit([[1, 3, 4, 2]], [3, 4])
+    doit([[2, 4, 1], [4, 3]], [4, 4])
+    doit([[1, 2, 3, 4]], [2, 3])
+    doit([[2, 3, 1], [3, 4]], [3, 3])
+    doit([[1, 4, 3, 2]], [4, 3])
+    doit([[2, 1, 4, 3]], [1, 4])
+    doit([[2, 1, 3, 4]], [1, 3])
+    doit([[6, 2, 1, 4], [1, 3, 5, 8], [3, 7]], [1, 2, 1, 3, 3, 5])

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_rewriting.py

@@ -0,0 +1,49 @@
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.free_groups import free_group
+from sympy.testing.pytest import raises
+
+
+def test_rewriting():
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a*b*a**-1*b**-1])
+    a, b = G.generators
+    R = G._rewriting_system
+    assert R.is_confluent
+
+    assert G.reduce(b**-1*a) == a*b**-1
+    assert G.reduce(b**3*a**4*b**-2*a) == a**5*b
+    assert G.equals(b**2*a**-1*b, b**4*a**-1*b**-1)
+
+    assert R.reduce_using_automaton(b*a*a**2*b**-1) == a**3
+    assert R.reduce_using_automaton(b**3*a**4*b**-2*a) == a**5*b
+    assert R.reduce_using_automaton(b**-1*a) == a*b**-1
+
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    R = G._rewriting_system
+    R.make_confluent()
+    # R._is_confluent should be set to True after
+    # a successful run of make_confluent
+    assert R.is_confluent
+    # but also the system should actually be confluent
+    assert R._check_confluence()
+    assert G.reduce(b*a**-1*b**-1*a**3*b**4*a**-1*b**-15) == a**-1*b**-1
+    # check for automaton reduction
+    assert R.reduce_using_automaton(b*a**-1*b**-1*a**3*b**4*a**-1*b**-15) == a**-1*b**-1
+
+    G = FpGroup(F, [a**2, b**3, (a*b)**4])
+    R = G._rewriting_system
+    assert G.reduce(a**2*b**-2*a**2*b) == b**-1
+    assert R.reduce_using_automaton(a**2*b**-2*a**2*b) == b**-1
+    assert G.reduce(a**3*b**-2*a**2*b) == a**-1*b**-1
+    assert R.reduce_using_automaton(a**3*b**-2*a**2*b) == a**-1*b**-1
+    # Check after adding a rule
+    R.add_rule(a**2, b)
+    assert R.reduce_using_automaton(a**2*b**-2*a**2*b) == b**-1
+    assert R.reduce_using_automaton(a**4*b**-2*a**2*b**3) == b
+
+    R.set_max(15)
+    raises(RuntimeError, lambda:  R.add_rule(a**-3, b))
+    R.set_max(20)
+    R.add_rule(a**-3, b)
+
+    assert R.add_rule(a, a) == set()

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_schur_number.py

@@ -0,0 +1,55 @@
+from sympy.core import S, Rational
+from sympy.combinatorics.schur_number import schur_partition, SchurNumber
+from sympy.core.random import _randint
+from sympy.testing.pytest import raises
+from sympy.core.symbol import symbols
+
+
+def _sum_free_test(subset):
+    """
+    Checks if subset is sum-free(There are no x,y,z in the subset such that
+    x + y = z)
+    """
+    for i in subset:
+        for j in subset:
+            assert (i + j in subset) is False
+
+
+def test_schur_partition():
+    raises(ValueError, lambda: schur_partition(S.Infinity))
+    raises(ValueError, lambda: schur_partition(-1))
+    raises(ValueError, lambda: schur_partition(0))
+    assert schur_partition(2) == [[1, 2]]
+
+    random_number_generator = _randint(1000)
+    for _ in range(5):
+        n = random_number_generator(1, 1000)
+        result = schur_partition(n)
+        t = 0
+        numbers = []
+        for item in result:
+            _sum_free_test(item)
+            """
+            Checks if the occurrence of all numbers is exactly one
+            """
+            t += len(item)
+            for l in item:
+                assert (l in numbers) is False
+                numbers.append(l)
+        assert n == t
+
+    x = symbols("x")
+    raises(ValueError, lambda: schur_partition(x))
+
+def test_schur_number():
+    first_known_schur_numbers = {1: 1, 2: 4, 3: 13, 4: 44, 5: 160}
+    for k in first_known_schur_numbers:
+        assert SchurNumber(k) == first_known_schur_numbers[k]
+
+    assert SchurNumber(S.Infinity) == S.Infinity
+    assert SchurNumber(0) == 0
+    raises(ValueError, lambda: SchurNumber(0.5))
+
+    n = symbols("n")
+    assert SchurNumber(n).lower_bound() == 3**n/2 - Rational(1, 2)
+    assert SchurNumber(8).lower_bound() == 5039

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_subsets.py

@@ -0,0 +1,63 @@
+from sympy.combinatorics.subsets import Subset, ksubsets
+from sympy.testing.pytest import raises
+
+
+def test_subset():
+    a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+    assert a.next_binary() == Subset(['b'], ['a', 'b', 'c', 'd'])
+    assert a.prev_binary() == Subset(['c'], ['a', 'b', 'c', 'd'])
+    assert a.next_lexicographic() == Subset(['d'], ['a', 'b', 'c', 'd'])
+    assert a.prev_lexicographic() == Subset(['c'], ['a', 'b', 'c', 'd'])
+    assert a.next_gray() == Subset(['c'], ['a', 'b', 'c', 'd'])
+    assert a.prev_gray() == Subset(['d'], ['a', 'b', 'c', 'd'])
+    assert a.rank_binary == 3
+    assert a.rank_lexicographic == 14
+    assert a.rank_gray == 2
+    assert a.cardinality == 16
+    assert a.size == 2
+    assert Subset.bitlist_from_subset(a, ['a', 'b', 'c', 'd']) == '0011'
+
+    a = Subset([2, 5, 7], [1, 2, 3, 4, 5, 6, 7])
+    assert a.next_binary() == Subset([2, 5, 6], [1, 2, 3, 4, 5, 6, 7])
+    assert a.prev_binary() == Subset([2, 5], [1, 2, 3, 4, 5, 6, 7])
+    assert a.next_lexicographic() == Subset([2, 6], [1, 2, 3, 4, 5, 6, 7])
+    assert a.prev_lexicographic() == Subset([2, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7])
+    assert a.next_gray() == Subset([2, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7])
+    assert a.prev_gray() == Subset([2, 5], [1, 2, 3, 4, 5, 6, 7])
+    assert a.rank_binary == 37
+    assert a.rank_lexicographic == 93
+    assert a.rank_gray == 57
+    assert a.cardinality == 128
+
+    superset = ['a', 'b', 'c', 'd']
+    assert Subset.unrank_binary(4, superset).rank_binary == 4
+    assert Subset.unrank_gray(10, superset).rank_gray == 10
+
+    superset = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    assert Subset.unrank_binary(33, superset).rank_binary == 33
+    assert Subset.unrank_gray(25, superset).rank_gray == 25
+
+    a = Subset([], ['a', 'b', 'c', 'd'])
+    i = 1
+    while a.subset != Subset(['d'], ['a', 'b', 'c', 'd']).subset:
+        a = a.next_lexicographic()
+        i = i + 1
+    assert i == 16
+
+    i = 1
+    while a.subset != Subset([], ['a', 'b', 'c', 'd']).subset:
+        a = a.prev_lexicographic()
+        i = i + 1
+    assert i == 16
+
+    raises(ValueError, lambda: Subset(['a', 'b'], ['a']))
+    raises(ValueError, lambda: Subset(['a'], ['b', 'c']))
+    raises(ValueError, lambda: Subset.subset_from_bitlist(['a', 'b'], '010'))
+
+    assert Subset(['a'], ['a', 'b']) != Subset(['b'], ['a', 'b'])
+    assert Subset(['a'], ['a', 'b']) != Subset(['a'], ['a', 'c'])
+
+def test_ksubsets():
+    assert list(ksubsets([1, 2, 3], 2)) == [(1, 2), (1, 3), (2, 3)]
+    assert list(ksubsets([1, 2, 3, 4, 5], 2)) == [(1, 2), (1, 3), (1, 4),
+               (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_tensor_can.py

@@ -0,0 +1,560 @@
+from sympy.combinatorics.permutations import Permutation, Perm
+from sympy.combinatorics.tensor_can import (perm_af_direct_product, dummy_sgs,
+    riemann_bsgs, get_symmetric_group_sgs, canonicalize, bsgs_direct_product)
+from sympy.combinatorics.testutil import canonicalize_naive, graph_certificate
+from sympy.testing.pytest import skip, XFAIL
+
+def test_perm_af_direct_product():
+    gens1 = [[1,0,2,3], [0,1,3,2]]
+    gens2 = [[1,0]]
+    assert perm_af_direct_product(gens1, gens2, 0) == [[1, 0, 2, 3, 4, 5], [0, 1, 3, 2, 4, 5], [0, 1, 2, 3, 5, 4]]
+    gens1 = [[1,0,2,3,5,4], [0,1,3,2,4,5]]
+    gens2 = [[1,0,2,3]]
+    assert [[1, 0, 2, 3, 4, 5, 7, 6], [0, 1, 3, 2, 4, 5, 6, 7], [0, 1, 2, 3, 5, 4, 6, 7]]
+
+def test_dummy_sgs():
+    a = dummy_sgs([1,2], 0, 4)
+    assert a == [[0,2,1,3,4,5]]
+    a = dummy_sgs([2,3,4,5], 0, 8)
+    assert a == [x._array_form for x in [Perm(9)(2,3), Perm(9)(4,5),
+        Perm(9)(2,4)(3,5)]]
+
+    a = dummy_sgs([2,3,4,5], 1, 8)
+    assert a == [x._array_form for x in [Perm(2,3)(8,9), Perm(4,5)(8,9),
+        Perm(9)(2,4)(3,5)]]
+
+def test_get_symmetric_group_sgs():
+    assert get_symmetric_group_sgs(2) == ([0], [Permutation(3)(0,1)])
+    assert get_symmetric_group_sgs(2, 1) == ([0], [Permutation(0,1)(2,3)])
+    assert get_symmetric_group_sgs(3) == ([0,1], [Permutation(4)(0,1), Permutation(4)(1,2)])
+    assert get_symmetric_group_sgs(3, 1) == ([0,1], [Permutation(0,1)(3,4), Permutation(1,2)(3,4)])
+    assert get_symmetric_group_sgs(4) == ([0,1,2], [Permutation(5)(0,1), Permutation(5)(1,2), Permutation(5)(2,3)])
+    assert get_symmetric_group_sgs(4, 1) == ([0,1,2], [Permutation(0,1)(4,5), Permutation(1,2)(4,5), Permutation(2,3)(4,5)])
+
+
+def test_canonicalize_no_slot_sym():
+    # cases in which there is no slot symmetry after fixing the
+    # free indices; here and in the following if the symmetry of the
+    # metric is not specified, it is assumed to be symmetric.
+    # If it is not specified, tensors are commuting.
+
+    # A_d0 * B^d0; g = [1,0, 2,3]; T_c = A^d0*B_d0; can = [0,1,2,3]
+    base1, gens1 = get_symmetric_group_sgs(1)
+    dummies = [0, 1]
+    g = Permutation([1,0,2,3])
+    can = canonicalize(g, dummies, 0, (base1,gens1,1,0), (base1,gens1,1,0))
+    assert can == [0,1,2,3]
+    # equivalently
+    can = canonicalize(g, dummies, 0, (base1, gens1, 2, None))
+    assert can == [0,1,2,3]
+
+    # with antisymmetric metric; T_c = -A^d0*B_d0; can = [0,1,3,2]
+    can = canonicalize(g, dummies, 1, (base1,gens1,1,0), (base1,gens1,1,0))
+    assert can == [0,1,3,2]
+
+    # A^a * B^b; ord = [a,b]; g = [0,1,2,3]; can = g
+    g = Permutation([0,1,2,3])
+    dummies = []
+    t0 = t1 = (base1, gens1, 1, 0)
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [0,1,2,3]
+    # B^b * A^a
+    g = Permutation([1,0,2,3])
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [1,0,2,3]
+
+    # A symmetric
+    # A^{b}_{d0}*A^{d0, a} order a,b,d0,-d0; T_c = A^{a d0}*A{b}_{d0}
+    # g = [1,3,2,0,4,5]; can = [0,2,1,3,4,5]
+    base2, gens2 = get_symmetric_group_sgs(2)
+    dummies = [2,3]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, dummies, 0, (base2, gens2, 2, 0))
+    assert can == [0, 2, 1, 3, 4, 5]
+    # with antisymmetric metric
+    can = canonicalize(g, dummies, 1, (base2, gens2, 2, 0))
+    assert can == [0, 2, 1, 3, 4, 5]
+    # A^{a}_{d0}*A^{d0, b}
+    g = Permutation([0,3,2,1,4,5])
+    can = canonicalize(g, dummies, 1, (base2, gens2, 2, 0))
+    assert can == [0, 2, 1, 3, 5, 4]
+
+    # A, B symmetric
+    # A^b_d0*B^{d0,a}; g=[1,3,2,0,4,5]
+    # T_c = A^{b,d0}*B_{a,d0}; can = [1,2,0,3,4,5]
+    dummies = [2,3]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, dummies, 0, (base2,gens2,1,0), (base2,gens2,1,0))
+    assert can == [1,2,0,3,4,5]
+    # same with antisymmetric metric
+    can = canonicalize(g, dummies, 1, (base2,gens2,1,0), (base2,gens2,1,0))
+    assert can == [1,2,0,3,5,4]
+
+    # A^{d1}_{d0}*B^d0*C_d1 ord=[d0,-d0,d1,-d1]; g = [2,1,0,3,4,5]
+    # T_c = A^{d0 d1}*B_d0*C_d1; can = [0,2,1,3,4,5]
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    g = Permutation([2,1,0,3,4,5])
+    dummies = [0,1,2,3]
+    t0 = (base2, gens2, 1, 0)
+    t1 = t2 = (base1, gens1, 1, 0)
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [0, 2, 1, 3, 4, 5]
+
+    # A without symmetry
+    # A^{d1}_{d0}*B^d0*C_d1 ord=[d0,-d0,d1,-d1]; g = [2,1,0,3,4,5]
+    # T_c = A^{d0 d1}*B_d1*C_d0; can = [0,2,3,1,4,5]
+    g = Permutation([2,1,0,3,4,5])
+    dummies = [0,1,2,3]
+    t0 = ([], [Permutation(list(range(4)))], 1, 0)
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [0,2,3,1,4,5]
+    # A, B without symmetry
+    # A^{d1}_{d0}*B_{d1}^{d0}; g = [2,1,3,0,4,5]
+    # T_c = A^{d0 d1}*B_{d0 d1}; can = [0,2,1,3,4,5]
+    t0 = t1 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [0,1,2,3]
+    g = Permutation([2,1,3,0,4,5])
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [0, 2, 1, 3, 4, 5]
+    # A_{d0}^{d1}*B_{d1}^{d0}; g = [1,2,3,0,4,5]
+    # T_c = A^{d0 d1}*B_{d1 d0}; can = [0,2,3,1,4,5]
+    g = Permutation([1,2,3,0,4,5])
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [0,2,3,1,4,5]
+
+    # A, B, C without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c=A^{d0 d1}*B_{a d1}*C_{d0 b}; can = [2,4,0,5,3,1,6,7]
+    t0 = t1 = t2 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,5,3,1,6,7]
+
+    # A symmetric, B and C without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c = A^{d0 d1}*B_{a d0}*C_{d1 b}; can = [2,4,0,3,5,1,6,7]
+    t0 = (base2,gens2,1,0)
+    t1 = t2 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,3,5,1,6,7]
+
+    # A and C symmetric, B without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c = A^{d0 d1}*B_{a d0}*C_{b d1}; can = [2,4,0,3,1,5,6,7]
+    t0 = t2 = (base2,gens2,1,0)
+    t1 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,3,1,5,6,7]
+
+    # A symmetric, B without symmetry, C antisymmetric
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c = -A^{d0 d1}*B_{a d0}*C_{b d1}; can = [2,4,0,3,1,5,7,6]
+    t0 = (base2,gens2, 1, 0)
+    t1 = ([], [Permutation(list(range(4)))], 1, 0)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+    t2 = (base2a, gens2a, 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,3,1,5,7,6]
+
+
+def test_canonicalize_no_dummies():
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+
+    # A commuting
+    # A^c A^b A^a; ord = [a,b,c]; g = [2,1,0,3,4]
+    # T_c = A^a A^b A^c; can = list(range(5))
+    g = Permutation([2,1,0,3,4])
+    can = canonicalize(g, [], 0, (base1, gens1, 3, 0))
+    assert can == list(range(5))
+
+    # A anticommuting
+    # A^c A^b A^a; ord = [a,b,c]; g = [2,1,0,3,4]
+    # T_c = -A^a A^b A^c; can = [0,1,2,4,3]
+    g = Permutation([2,1,0,3,4])
+    can = canonicalize(g, [], 0, (base1, gens1, 3, 1))
+    assert can == [0,1,2,4,3]
+
+    # A commuting and symmetric
+    # A^{b,d}*A^{c,a}; ord = [a,b,c,d]; g = [1,3,2,0,4,5]
+    # T_c = A^{a c}*A^{b d}; can = [0,2,1,3,4,5]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, [], 0, (base2, gens2, 2, 0))
+    assert can == [0,2,1,3,4,5]
+
+    # A anticommuting and symmetric
+    # A^{b,d}*A^{c,a}; ord = [a,b,c,d]; g = [1,3,2,0,4,5]
+    # T_c = -A^{a c}*A^{b d}; can = [0,2,1,3,5,4]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, [], 0, (base2, gens2, 2, 1))
+    assert can == [0,2,1,3,5,4]
+    # A^{c,a}*A^{b,d} ; g = [2,0,1,3,4,5]
+    # T_c = A^{a c}*A^{b d}; can = [0,2,1,3,4,5]
+    g = Permutation([2,0,1,3,4,5])
+    can = canonicalize(g, [], 0, (base2, gens2, 2, 1))
+    assert can == [0,2,1,3,4,5]
+
+def test_no_metric_symmetry():
+    # no metric symmetry
+    # A^d1_d0 * A^d0_d1; ord = [d0,-d0,d1,-d1]; g= [2,1,0,3,4,5]
+    # T_c = A^d0_d1 * A^d1_d0; can = [0,3,2,1,4,5]
+    g = Permutation([2,1,0,3,4,5])
+    can = canonicalize(g, list(range(4)), None, [[], [Permutation(list(range(4)))], 2, 0])
+    assert can == [0,3,2,1,4,5]
+
+    # A^d1_d2 * A^d0_d3 * A^d2_d1 * A^d3_d0
+    # ord = [d0,-d0,d1,-d1,d2,-d2,d3,-d3]
+    #        0    1  2  3  4   5   6   7
+    # g = [2,5,0,7,4,3,6,1,8,9]
+    # T_c = A^d0_d1 * A^d1_d0 * A^d2_d3 * A^d3_d2
+    # can = [0,3,2,1,4,7,6,5,8,9]
+    g = Permutation([2,5,0,7,4,3,6,1,8,9])
+    #can = canonicalize(g, list(range(8)), 0, [[], [list(range(4))], 4, 0])
+    #assert can == [0, 2, 3, 1, 4, 6, 7, 5, 8, 9]
+    can = canonicalize(g, list(range(8)), None, [[], [Permutation(list(range(4)))], 4, 0])
+    assert can == [0, 3, 2, 1, 4, 7, 6, 5, 8, 9]
+
+    # A^d0_d2 * A^d1_d3 * A^d3_d0 * A^d2_d1
+    # g = [0,5,2,7,6,1,4,3,8,9]
+    # T_c = A^d0_d1 * A^d1_d2 * A^d2_d3 * A^d3_d0
+    # can = [0,3,2,5,4,7,6,1,8,9]
+    g = Permutation([0,5,2,7,6,1,4,3,8,9])
+    can = canonicalize(g, list(range(8)), None, [[], [Permutation(list(range(4)))], 4, 0])
+    assert can == [0,3,2,5,4,7,6,1,8,9]
+
+    g = Permutation([12,7,10,3,14,13,4,11,6,1,2,9,0,15,8,5,16,17])
+    can = canonicalize(g, list(range(16)), None, [[], [Permutation(list(range(4)))], 8, 0])
+    assert can == [0,3,2,5,4,7,6,1,8,11,10,13,12,15,14,9,16,17]
+
+def test_canonical_free():
+    # t = A^{d0 a1}*A_d0^a0
+    # ord = [a0,a1,d0,-d0];  g = [2,1,3,0,4,5]; dummies = [[2,3]]
+    # t_c = A_d0^a0*A^{d0 a1}
+    # can = [3,0, 2,1, 4,5]
+    g = Permutation([2,1,3,0,4,5])
+    dummies = [[2,3]]
+    can = canonicalize(g, dummies, [None], ([], [Permutation(3)], 2, 0))
+    assert can == [3,0, 2,1, 4,5]
+
+def test_canonicalize1():
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base1a, gens1a = get_symmetric_group_sgs(1, 1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    base3, gens3 = get_symmetric_group_sgs(3)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+    base3a, gens3a = get_symmetric_group_sgs(3, 1)
+
+    # A_d0*A^d0; ord = [d0,-d0]; g = [1,0,2,3]
+    # T_c = A^d0*A_d0; can = [0,1,2,3]
+    g = Permutation([1,0,2,3])
+    can = canonicalize(g, [0, 1], 0, (base1, gens1, 2, 0))
+    assert can == list(range(4))
+
+    # A commuting
+    # A_d0*A_d1*A_d2*A^d2*A^d1*A^d0; ord=[d0,-d0,d1,-d1,d2,-d2]
+    # g = [1,3,5,4,2,0,6,7]
+    # T_c = A^d0*A_d0*A^d1*A_d1*A^d2*A_d2; can = list(range(8))
+    g = Permutation([1,3,5,4,2,0,6,7])
+    can = canonicalize(g, list(range(6)), 0, (base1, gens1, 6, 0))
+    assert can == list(range(8))
+
+    # A anticommuting
+    # A_d0*A_d1*A_d2*A^d2*A^d1*A^d0; ord=[d0,-d0,d1,-d1,d2,-d2]
+    # g = [1,3,5,4,2,0,6,7]
+    # T_c 0;  can = 0
+    g = Permutation([1,3,5,4,2,0,6,7])
+    can = canonicalize(g, list(range(6)), 0, (base1, gens1, 6, 1))
+    assert can == 0
+    can1 = canonicalize_naive(g, list(range(6)), 0, (base1, gens1, 6, 1))
+    assert can1 == 0
+
+    # A commuting symmetric
+    # A^{d0 b}*A^a_d1*A^d1_d0; ord=[a,b,d0,-d0,d1,-d1]
+    # g = [2,1,0,5,4,3,6,7]
+    # T_c = A^{a d0}*A^{b d1}*A_{d0 d1}; can = [0,2,1,4,3,5,6,7]
+    g = Permutation([2,1,0,5,4,3,6,7])
+    can = canonicalize(g, list(range(2,6)), 0, (base2, gens2, 3, 0))
+    assert can == [0,2,1,4,3,5,6,7]
+
+    # A, B commuting symmetric
+    # A^{d0 b}*A^d1_d0*B^a_d1; ord=[a,b,d0,-d0,d1,-d1]
+    # g = [2,1,4,3,0,5,6,7]
+    # T_c = A^{b d0}*A_d0^d1*B^a_d1; can = [1,2,3,4,0,5,6,7]
+    g = Permutation([2,1,4,3,0,5,6,7])
+    can = canonicalize(g, list(range(2,6)), 0, (base2,gens2,2,0), (base2,gens2,1,0))
+    assert can == [1,2,3,4,0,5,6,7]
+
+    # A commuting symmetric
+    # A^{d1 d0 b}*A^{a}_{d1 d0}; ord=[a,b, d0,-d0,d1,-d1]
+    # g = [4,2,1,0,5,3,6,7]
+    # T_c = A^{a d0 d1}*A^{b}_{d0 d1}; can = [0,2,4,1,3,5,6,7]
+    g = Permutation([4,2,1,0,5,3,6,7])
+    can = canonicalize(g, list(range(2,6)), 0, (base3, gens3, 2, 0))
+    assert can == [0,2,4,1,3,5,6,7]
+
+
+    # A^{d3 d0 d2}*A^a0_{d1 d2}*A^d1_d3^a1*A^{a2 a3}_d0
+    # ord = [a0,a1,a2,a3,d0,-d0,d1,-d1,d2,-d2,d3,-d3]
+    #        0   1  2  3  4  5  6   7  8   9  10  11
+    # g = [10,4,8, 0,7,9, 6,11,1, 2,3,5, 12,13]
+    # T_c = A^{a0 d0 d1}*A^a1_d0^d2*A^{a2 a3 d3}*A_{d1 d2 d3}
+    # can = [0,4,6, 1,5,8, 2,3,10, 7,9,11, 12,13]
+    g = Permutation([10,4,8, 0,7,9, 6,11,1, 2,3,5, 12,13])
+    can = canonicalize(g, list(range(4,12)), 0, (base3, gens3, 4, 0))
+    assert can == [0,4,6, 1,5,8, 2,3,10, 7,9,11, 12,13]
+
+    # A commuting symmetric, B antisymmetric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # ord = [d0,-d0,d1,-d1,d2,-d2,d3,-d3]
+    # g = [0,2,4,5,7,3,1,6,8,9]
+    # in this esxample and in the next three,
+    # renaming dummy indices and using symmetry of A,
+    # T = A^{d0 d1 d2} * A_{d0 d1 d3} * B_d2^d3
+    # can = 0
+    g = Permutation([0,2,4,5,7,3,1,6,8,9])
+    can = canonicalize(g, list(range(8)), 0, (base3, gens3,2,0), (base2a,gens2a,1,0))
+    assert can == 0
+    # A anticommuting symmetric, B anticommuting
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = A^{d0 d1 d2} * A_{d0 d1}^d3 * B_{d2 d3}
+    # can = [0,2,4, 1,3,6, 5,7, 8,9]
+    can = canonicalize(g, list(range(8)), 0, (base3, gens3,2,1), (base2a,gens2a,1,0))
+    assert can == [0,2,4, 1,3,6, 5,7, 8,9]
+    # A anticommuting symmetric, B antisymmetric commuting, antisymmetric metric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = -A^{d0 d1 d2} * A_{d0 d1}^d3 * B_{d2 d3}
+    # can = [0,2,4, 1,3,6, 5,7, 9,8]
+    can = canonicalize(g, list(range(8)), 1, (base3, gens3,2,1), (base2a,gens2a,1,0))
+    assert can == [0,2,4, 1,3,6, 5,7, 9,8]
+
+    # A anticommuting symmetric, B anticommuting anticommuting,
+    # no metric symmetry
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = A^{d0 d1 d2} * A_{d0 d1 d3} * B_d2^d3
+    # can = [0,2,4, 1,3,7, 5,6, 8,9]
+    can = canonicalize(g, list(range(8)), None, (base3, gens3,2,1), (base2a,gens2a,1,0))
+    assert can == [0,2,4,1,3,7,5,6,8,9]
+
+    # Gamma anticommuting
+    # Gamma_{mu nu} * gamma^rho * Gamma^{nu mu alpha}
+    # ord = [alpha, rho, mu,-mu,nu,-nu]
+    # g = [3,5,1,4,2,0,6,7]
+    # T_c = -Gamma^{mu nu} * gamma^rho * Gamma_{alpha mu nu}
+    # can = [2,4,1,0,3,5,7,6]]
+    g = Permutation([3,5,1,4,2,0,6,7])
+    t0 = (base2a, gens2a, 1, None)
+    t1 = (base1, gens1, 1, None)
+    t2 = (base3a, gens3a, 1, None)
+    can = canonicalize(g, list(range(2, 6)), 0, t0, t1, t2)
+    assert can == [2,4,1,0,3,5,7,6]
+
+    # Gamma_{mu nu} * Gamma^{gamma beta} * gamma_rho * Gamma^{nu mu alpha}
+    # ord = [alpha, beta, gamma, -rho, mu,-mu,nu,-nu]
+    #         0      1      2     3    4   5   6  7
+    # g = [5,7,2,1,3,6,4,0,8,9]
+    # T_c = Gamma^{mu nu} * Gamma^{beta gamma} * gamma_rho * Gamma^alpha_{mu nu}    # can = [4,6,1,2,3,0,5,7,8,9]
+    t0 = (base2a, gens2a, 2, None)
+    g = Permutation([5,7,2,1,3,6,4,0,8,9])
+    can = canonicalize(g, list(range(4, 8)), 0, t0, t1, t2)
+    assert can == [4,6,1,2,3,0,5,7,8,9]
+
+    # f^a_{b,c} antisymmetric in b,c; A_mu^a no symmetry
+    # f^c_{d a} * f_{c e b} * A_mu^d * A_nu^a * A^{nu e} * A^{mu b}
+    # ord = [mu,-mu,nu,-nu,a,-a,b,-b,c,-c,d,-d, e, -e]
+    #         0  1  2   3  4  5 6  7 8  9 10 11 12 13
+    # g = [8,11,5, 9,13,7, 1,10, 3,4, 2,12, 0,6, 14,15]
+    # T_c = -f^{a b c} * f_a^{d e} * A^mu_b * A_{mu d} * A^nu_c * A_{nu e}
+    # can = [4,6,8,       5,10,12,   0,7,     1,11,       2,9,    3,13, 15,14]
+    g = Permutation([8,11,5, 9,13,7, 1,10, 3,4, 2,12, 0,6, 14,15])
+    base_f, gens_f = bsgs_direct_product(base1, gens1, base2a, gens2a)
+    base_A, gens_A = bsgs_direct_product(base1, gens1, base1, gens1)
+    t0 = (base_f, gens_f, 2, 0)
+    t1 = (base_A, gens_A, 4, 0)
+    can = canonicalize(g, [list(range(4)), list(range(4, 14))], [0, 0], t0, t1)
+    assert can == [4,6,8, 5,10,12, 0,7, 1,11, 2,9, 3,13, 15,14]
+
+
+def test_riemann_invariants():
+    baser, gensr = riemann_bsgs
+    # R^{d0 d1}_{d1 d0}; ord = [d0,-d0,d1,-d1]; g = [0,2,3,1,4,5]
+    # T_c = -R^{d0 d1}_{d0 d1}; can = [0,2,1,3,5,4]
+    g = Permutation([0,2,3,1,4,5])
+    can = canonicalize(g, list(range(2, 4)), 0, (baser, gensr, 1, 0))
+    assert can == [0,2,1,3,5,4]
+    # use a non minimal BSGS
+    can = canonicalize(g, list(range(2, 4)), 0, ([2, 0], [Permutation([1,0,2,3,5,4]), Permutation([2,3,0,1,4,5])], 1, 0))
+    assert can == [0,2,1,3,5,4]
+
+    """
+    The following tests in test_riemann_invariants and in
+    test_riemann_invariants1 have been checked using xperm.c from XPerm in
+    in [1] and with an older version contained in [2]
+
+    [1] xperm.c part of xPerm written by J. M. Martin-Garcia
+        http://www.xact.es/index.html
+    [2] test_xperm.cc in cadabra by Kasper Peeters, http://cadabra.phi-sci.com/
+    """
+    # R_d11^d1_d0^d5 * R^{d6 d4 d0}_d5 * R_{d7 d2 d8 d9} *
+    # R_{d10 d3 d6 d4} * R^{d2 d7 d11}_d1 * R^{d8 d9 d3 d10}
+    # ord: contravariant d_k ->2*k, covariant d_k -> 2*k+1
+    # T_c = R^{d0 d1 d2 d3} * R_{d0 d1}^{d4 d5} * R_{d2 d3}^{d6 d7} *
+    # R_{d4 d5}^{d8 d9} * R_{d6 d7}^{d10 d11} * R_{d8 d9 d10 d11}
+    g = Permutation([23,2,1,10,12,8,0,11,15,5,17,19,21,7,13,9,4,14,22,3,16,18,6,20,24,25])
+    can = canonicalize(g, list(range(24)), 0, (baser, gensr, 6, 0))
+    assert can == [0,2,4,6,1,3,8,10,5,7,12,14,9,11,16,18,13,15,20,22,17,19,21,23,24,25]
+
+    # use a non minimal BSGS
+    can = canonicalize(g, list(range(24)), 0, ([2, 0], [Permutation([1,0,2,3,5,4]), Permutation([2,3,0,1,4,5])], 6, 0))
+    assert can == [0,2,4,6,1,3,8,10,5,7,12,14,9,11,16,18,13,15,20,22,17,19,21,23,24,25]
+
+    g = Permutation([0,2,5,7,4,6,9,11,8,10,13,15,12,14,17,19,16,18,21,23,20,22,25,27,24,26,29,31,28,30,33,35,32,34,37,39,36,38,1,3,40,41])
+    can = canonicalize(g, list(range(40)), 0, (baser, gensr, 10, 0))
+    assert can == [0,2,4,6,1,3,8,10,5,7,12,14,9,11,16,18,13,15,20,22,17,19,24,26,21,23,28,30,25,27,32,34,29,31,36,38,33,35,37,39,40,41]
+
+
+@XFAIL
+def test_riemann_invariants1():
+    skip('takes too much time')
+    baser, gensr = riemann_bsgs
+    g = Permutation([17, 44, 11, 3, 0, 19, 23, 15, 38, 4, 25, 27, 43, 36, 22, 14, 8, 30, 41, 20, 2, 10, 12, 28, 18, 1, 29, 13, 37, 42, 33, 7, 9, 31, 24, 26, 39, 5, 34, 47, 32, 6, 21, 40, 35, 46, 45, 16, 48, 49])
+    can = canonicalize(g, list(range(48)), 0, (baser, gensr, 12, 0))
+    assert can == [0, 2, 4, 6, 1, 3, 8, 10, 5, 7, 12, 14, 9, 11, 16, 18, 13, 15, 20, 22, 17, 19, 24, 26, 21, 23, 28, 30, 25, 27, 32, 34, 29, 31, 36, 38, 33, 35, 40, 42, 37, 39, 44, 46, 41, 43, 45, 47, 48, 49]
+
+    g = Permutation([0,2,4,6, 7,8,10,12, 14,16,18,20, 19,22,24,26, 5,21,28,30, 32,34,36,38, 40,42,44,46, 13,48,50,52, 15,49,54,56, 17,33,41,58, 9,23,60,62, 29,35,63,64, 3,45,66,68, 25,37,47,57, 11,31,69,70, 27,39,53,72, 1,59,73,74, 55,61,67,76, 43,65,75,78, 51,71,77,79, 80,81])
+    can = canonicalize(g, list(range(80)), 0, (baser, gensr, 20, 0))
+    assert can == [0,2,4,6, 1,8,10,12, 3,14,16,18, 5,20,22,24, 7,26,28,30, 9,15,32,34, 11,36,23,38, 13,40,42,44, 17,39,29,46, 19,48,43,50, 21,45,52,54, 25,56,33,58, 27,60,53,62, 31,51,64,66, 35,65,47,68, 37,70,49,72, 41,74,57,76, 55,67,59,78, 61,69,71,75, 63,79,73,77, 80,81]
+
+
+def test_riemann_products():
+    baser, gensr = riemann_bsgs
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+
+    # R^{a b d0}_d0 = 0
+    g = Permutation([0,1,2,3,4,5])
+    can = canonicalize(g, list(range(2,4)), 0, (baser, gensr, 1, 0))
+    assert can == 0
+
+    # R^{d0 b a}_d0 ; ord = [a,b,d0,-d0}; g = [2,1,0,3,4,5]
+    # T_c = -R^{a d0 b}_d0;  can = [0,2,1,3,5,4]
+    g = Permutation([2,1,0,3,4,5])
+    can = canonicalize(g, list(range(2, 4)), 0, (baser, gensr, 1, 0))
+    assert can == [0,2,1,3,5,4]
+
+    # R^d1_d2^b_d0 * R^{d0 a}_d1^d2; ord=[a,b,d0,-d0,d1,-d1,d2,-d2]
+    # g = [4,7,1,3,2,0,5,6,8,9]
+    # T_c = -R^{a d0 d1 d2}* R^b_{d0 d1 d2}
+    # can = [0,2,4,6,1,3,5,7,9,8]
+    g = Permutation([4,7,1,3,2,0,5,6,8,9])
+    can = canonicalize(g, list(range(2,8)), 0, (baser, gensr, 2, 0))
+    assert can == [0,2,4,6,1,3,5,7,9,8]
+    can1 = canonicalize_naive(g, list(range(2,8)), 0, (baser, gensr, 2, 0))
+    assert can == can1
+
+    # A symmetric commuting
+    # R^{d6 d5}_d2^d1 * R^{d4 d0 d2 d3} * A_{d6 d0} A_{d3 d1} * A_{d4 d5}
+    # g = [12,10,5,2, 8,0,4,6, 13,1, 7,3, 9,11,14,15]
+    # T_c = -R^{d0 d1 d2 d3} * R_d0^{d4 d5 d6} * A_{d1 d4}*A_{d2 d5}*A_{d3 d6}
+
+    g = Permutation([12,10,5,2,8,0,4,6,13,1,7,3,9,11,14,15])
+    can = canonicalize(g, list(range(14)), 0, ((baser,gensr,2,0)), (base2,gens2,3,0))
+    assert can == [0, 2, 4, 6, 1, 8, 10, 12, 3, 9, 5, 11, 7, 13, 15, 14]
+
+    # R^{d2 a0 a2 d0} * R^d1_d2^{a1 a3} * R^{a4 a5}_{d0 d1}
+    # ord = [a0,a1,a2,a3,a4,a5,d0,-d0,d1,-d1,d2,-d2]
+    #         0  1  2  3 4  5  6   7  8   9  10  11
+    # can = [0, 6, 2, 8, 1, 3, 7, 10, 4, 5, 9, 11, 12, 13]
+    # T_c = R^{a0 d0 a2 d1}*R^{a1 a3}_d0^d2*R^{a4 a5}_{d1 d2}
+    g = Permutation([10,0,2,6,8,11,1,3,4,5,7,9,12,13])
+    can = canonicalize(g, list(range(6,12)), 0, (baser, gensr, 3, 0))
+    assert can == [0, 6, 2, 8, 1, 3, 7, 10, 4, 5, 9, 11, 12, 13]
+    #can1 = canonicalize_naive(g, list(range(6,12)), 0, (baser, gensr, 3, 0))
+    #assert can == can1
+
+    # A^n_{i, j} antisymmetric in i,j
+    # A_m0^d0_a1 * A_m1^a0_d0; ord = [m0,m1,a0,a1,d0,-d0]
+    # g = [0,4,3,1,2,5,6,7]
+    # T_c = -A_{m a1}^d0 * A_m1^a0_d0
+    # can = [0,3,4,1,2,5,7,6]
+    base, gens = bsgs_direct_product(base1, gens1, base2a, gens2a)
+    dummies = list(range(4, 6))
+    g = Permutation([0,4,3,1,2,5,6,7])
+    can = canonicalize(g, dummies, 0, (base, gens, 2, 0))
+    assert can == [0, 3, 4, 1, 2, 5, 7, 6]
+
+
+    # A^n_{i, j} symmetric in i,j
+    # A^m0_a0^d2 * A^n0_d2^d1 * A^n1_d1^d0 * A_{m0 d0}^a1
+    # ordering: first the free indices; then first n, then d
+    # ord=[n0,n1,a0,a1, m0,-m0,d0,-d0,d1,-d1,d2,-d2]
+    #      0  1   2  3   4  5  6   7  8   9  10  11]
+    # g = [4,2,10, 0,11,8, 1,9,6, 5,7,3, 12,13]
+    # if the dummy indices m_i and d_i were separated,
+    # one gets
+    # T_c = A^{n0 d0 d1} * A^n1_d0^d2 * A^m0^a0_d1 * A_m0^a1_d2
+    # can = [0, 6, 8, 1, 7, 10, 4, 2, 9, 5, 3, 11, 12, 13]
+    # If they are not, so can is
+    # T_c = A^{n0 m0 d0} A^n1_m0^d1 A^{d2 a0}_d0 A_d2^a1_d1
+    # can = [0, 4, 6, 1, 5, 8, 10, 2, 7, 11, 3, 9, 12, 13]
+    # case with single type of indices
+
+    base, gens = bsgs_direct_product(base1, gens1, base2, gens2)
+    dummies = list(range(4, 12))
+    g = Permutation([4,2,10, 0,11,8, 1,9,6, 5,7,3, 12,13])
+    can = canonicalize(g, dummies, 0, (base, gens, 4, 0))
+    assert can == [0, 4, 6, 1, 5, 8, 10, 2, 7, 11, 3, 9, 12, 13]
+    # case with separated indices
+    dummies = [list(range(4, 6)), list(range(6,12))]
+    sym = [0, 0]
+    can = canonicalize(g, dummies, sym, (base, gens, 4, 0))
+    assert can == [0, 6, 8, 1, 7, 10, 4, 2, 9, 5, 3, 11, 12, 13]
+    # case with separated indices with the second type of index
+    # with antisymmetric metric: there is a sign change
+    sym = [0, 1]
+    can = canonicalize(g, dummies, sym, (base, gens, 4, 0))
+    assert can == [0, 6, 8, 1, 7, 10, 4, 2, 9, 5, 3, 11, 13, 12]
+
+def test_graph_certificate():
+    # test tensor invariants constructed from random regular graphs;
+    # checked graph isomorphism with networkx
+    import random
+    def randomize_graph(size, g):
+        p = list(range(size))
+        random.shuffle(p)
+        g1a = {}
+        for k, v in g1.items():
+            g1a[p[k]] = [p[i] for i in v]
+        return g1a
+
+    g1 = {0: [2, 3, 7], 1: [4, 5, 7], 2: [0, 4, 6], 3: [0, 6, 7], 4: [1, 2, 5], 5: [1, 4, 6], 6: [2, 3, 5], 7: [0, 1, 3]}
+    g2 = {0: [2, 3, 7], 1: [2, 4, 5], 2: [0, 1, 5], 3: [0, 6, 7], 4: [1, 5, 6], 5: [1, 2, 4], 6: [3, 4, 7], 7: [0, 3, 6]}
+
+    c1 = graph_certificate(g1)
+    c2 = graph_certificate(g2)
+    assert c1 != c2
+    g1a = randomize_graph(8, g1)
+    c1a = graph_certificate(g1a)
+    assert c1 == c1a
+
+    g1 = {0: [8, 1, 9, 7], 1: [0, 9, 3, 4], 2: [3, 4, 6, 7], 3: [1, 2, 5, 6], 4: [8, 1, 2, 5], 5: [9, 3, 4, 7], 6: [8, 2, 3, 7], 7: [0, 2, 5, 6], 8: [0, 9, 4, 6], 9: [8, 0, 5, 1]}
+    g2 = {0: [1, 2, 5, 6], 1: [0, 9, 5, 7], 2: [0, 4, 6, 7], 3: [8, 9, 6, 7], 4: [8, 2, 6, 7], 5: [0, 9, 8, 1], 6: [0, 2, 3, 4], 7: [1, 2, 3, 4], 8: [9, 3, 4, 5], 9: [8, 1, 3, 5]}
+    c1 = graph_certificate(g1)
+    c2 = graph_certificate(g2)
+    assert c1 != c2
+    g1a = randomize_graph(10, g1)
+    c1a = graph_certificate(g1a)
+    assert c1 == c1a

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_testutil.py

@@ -0,0 +1,55 @@
+from sympy.combinatorics.named_groups import SymmetricGroup, AlternatingGroup,\
+    CyclicGroup
+from sympy.combinatorics.testutil import _verify_bsgs, _cmp_perm_lists,\
+    _naive_list_centralizer, _verify_centralizer,\
+    _verify_normal_closure
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.core.random import shuffle
+
+
+def test_cmp_perm_lists():
+    S = SymmetricGroup(4)
+    els = list(S.generate_dimino())
+    other = els.copy()
+    shuffle(other)
+    assert _cmp_perm_lists(els, other) is True
+
+
+def test_naive_list_centralizer():
+    # verified by GAP
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert _naive_list_centralizer(S, S) == [Permutation([0, 1, 2])]
+    assert PermutationGroup(_naive_list_centralizer(S, A)).is_subgroup(A)
+
+
+def test_verify_bsgs():
+    S = SymmetricGroup(5)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    assert _verify_bsgs(S, base, strong_gens) is True
+    assert _verify_bsgs(S, base[:-1], strong_gens) is False
+    assert _verify_bsgs(S, base, S.generators) is False
+
+
+def test_verify_centralizer():
+    # verified by GAP
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert _verify_centralizer(S, S, centr=triv)
+    assert _verify_centralizer(S, A, centr=A)
+
+
+def test_verify_normal_closure():
+    # verified by GAP
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert _verify_normal_closure(S, A, closure=A)
+    S = SymmetricGroup(5)
+    A = AlternatingGroup(5)
+    C = CyclicGroup(5)
+    assert _verify_normal_closure(S, A, closure=A)
+    assert _verify_normal_closure(S, C, closure=A)

.venv/lib/python3.13/site-packages/sympy/combinatorics/tests/test_util.py

@@ -0,0 +1,120 @@
+from sympy.combinatorics.named_groups import SymmetricGroup, DihedralGroup,\
+    AlternatingGroup
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.util import _check_cycles_alt_sym, _strip,\
+    _distribute_gens_by_base, _strong_gens_from_distr,\
+    _orbits_transversals_from_bsgs, _handle_precomputed_bsgs, _base_ordering,\
+    _remove_gens
+from sympy.combinatorics.testutil import _verify_bsgs
+
+
+def test_check_cycles_alt_sym():
+    perm1 = Permutation([[0, 1, 2, 3, 4, 5, 6], [7], [8], [9]])
+    perm2 = Permutation([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9]])
+    perm3 = Permutation([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
+    assert _check_cycles_alt_sym(perm1) is True
+    assert _check_cycles_alt_sym(perm2) is False
+    assert _check_cycles_alt_sym(perm3) is False
+
+
+def test_strip():
+    D = DihedralGroup(5)
+    D.schreier_sims()
+    member = Permutation([4, 0, 1, 2, 3])
+    not_member1 = Permutation([0, 1, 4, 3, 2])
+    not_member2 = Permutation([3, 1, 4, 2, 0])
+    identity = Permutation([0, 1, 2, 3, 4])
+    res1 = _strip(member, D.base, D.basic_orbits, D.basic_transversals)
+    res2 = _strip(not_member1, D.base, D.basic_orbits, D.basic_transversals)
+    res3 = _strip(not_member2, D.base, D.basic_orbits, D.basic_transversals)
+    assert res1[0] == identity
+    assert res1[1] == len(D.base) + 1
+    assert res2[0] == not_member1
+    assert res2[1] == len(D.base) + 1
+    assert res3[0] != identity
+    assert res3[1] == 2
+
+
+def test_distribute_gens_by_base():
+    base = [0, 1, 2]
+    gens = [Permutation([0, 1, 2, 3]), Permutation([0, 1, 3, 2]),
+           Permutation([0, 2, 3, 1]), Permutation([3, 2, 1, 0])]
+    assert _distribute_gens_by_base(base, gens) == [gens,
+                                                   [Permutation([0, 1, 2, 3]),
+                                                   Permutation([0, 1, 3, 2]),
+                                                   Permutation([0, 2, 3, 1])],
+                                                   [Permutation([0, 1, 2, 3]),
+                                                   Permutation([0, 1, 3, 2])]]
+
+
+def test_strong_gens_from_distr():
+    strong_gens_distr = [[Permutation([0, 2, 1]), Permutation([1, 2, 0]),
+                  Permutation([1, 0, 2])], [Permutation([0, 2, 1])]]
+    assert _strong_gens_from_distr(strong_gens_distr) == \
+        [Permutation([0, 2, 1]),
+         Permutation([1, 2, 0]),
+         Permutation([1, 0, 2])]
+
+
+def test_orbits_transversals_from_bsgs():
+    S = SymmetricGroup(4)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    result = _orbits_transversals_from_bsgs(base, strong_gens_distr)
+    orbits = result[0]
+    transversals = result[1]
+    base_len = len(base)
+    for i in range(base_len):
+        for el in orbits[i]:
+            assert transversals[i][el](base[i]) == el
+            for j in range(i):
+                assert transversals[i][el](base[j]) == base[j]
+    order = 1
+    for i in range(base_len):
+        order *= len(orbits[i])
+    assert S.order() == order
+
+
+def test_handle_precomputed_bsgs():
+    A = AlternatingGroup(5)
+    A.schreier_sims()
+    base = A.base
+    strong_gens = A.strong_gens
+    result = _handle_precomputed_bsgs(base, strong_gens)
+    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    assert strong_gens_distr == result[2]
+    transversals = result[0]
+    orbits = result[1]
+    base_len = len(base)
+    for i in range(base_len):
+        for el in orbits[i]:
+            assert transversals[i][el](base[i]) == el
+            for j in range(i):
+                assert transversals[i][el](base[j]) == base[j]
+    order = 1
+    for i in range(base_len):
+        order *= len(orbits[i])
+    assert A.order() == order
+
+
+def test_base_ordering():
+    base = [2, 4, 5]
+    degree = 7
+    assert _base_ordering(base, degree) == [3, 4, 0, 5, 1, 2, 6]
+
+
+def test_remove_gens():
+    S = SymmetricGroup(10)
+    base, strong_gens = S.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(S, base, new_gens) is True
+    A = AlternatingGroup(7)
+    base, strong_gens = A.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(A, base, new_gens) is True
+    D = DihedralGroup(2)
+    base, strong_gens = D.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(D, base, new_gens) is True

.venv/lib/python3.13/site-packages/sympy/functions/combinatorial/__init__.py

@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.combinatorial

.venv/lib/python3.13/site-packages/sympy/functions/combinatorial/factorials.py

@@ -0,0 +1,1133 @@
+from __future__ import annotations
+from functools import reduce
+
+from sympy.core import S, sympify, Dummy, Mod
+from sympy.core.cache import cacheit
+from sympy.core.function import DefinedFunction, ArgumentIndexError, PoleError
+from sympy.core.logic import fuzzy_and
+from sympy.core.numbers import Integer, pi, I
+from sympy.core.relational import Eq
+from sympy.external.gmpy import gmpy as _gmpy
+from sympy.ntheory import sieve
+from sympy.ntheory.residue_ntheory import binomial_mod
+from sympy.polys.polytools import Poly
+
+from math import factorial as _factorial, prod, sqrt as _sqrt
+
+class CombinatorialFunction(DefinedFunction):
+    """Base class for combinatorial functions. """
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.combsimp import combsimp
+        # combinatorial function with non-integer arguments is
+        # automatically passed to gammasimp
+        expr = combsimp(self)
+        measure = kwargs['measure']
+        if measure(expr) <= kwargs['ratio']*measure(self):
+            return expr
+        return self
+
+
+###############################################################################
+######################## FACTORIAL and MULTI-FACTORIAL ########################
+###############################################################################
+
+
+class factorial(CombinatorialFunction):
+    r"""Implementation of factorial function over nonnegative integers.
+       By convention (consistent with the gamma function and the binomial
+       coefficients), factorial of a negative integer is complex infinity.
+
+       The factorial is very important in combinatorics where it gives
+       the number of ways in which `n` objects can be permuted. It also
+       arises in calculus, probability, number theory, etc.
+
+       There is strict relation of factorial with gamma function. In
+       fact `n! = gamma(n+1)` for nonnegative integers. Rewrite of this
+       kind is very useful in case of combinatorial simplification.
+
+       Computation of the factorial is done using two algorithms. For
+       small arguments a precomputed look up table is used. However for bigger
+       input algorithm Prime-Swing is used. It is the fastest algorithm
+       known and computes `n!` via prime factorization of special class
+       of numbers, called here the 'Swing Numbers'.
+
+       Examples
+       ========
+
+       >>> from sympy import Symbol, factorial, S
+       >>> n = Symbol('n', integer=True)
+
+       >>> factorial(0)
+       1
+
+       >>> factorial(7)
+       5040
+
+       >>> factorial(-2)
+       zoo
+
+       >>> factorial(n)
+       factorial(n)
+
+       >>> factorial(2*n)
+       factorial(2*n)
+
+       >>> factorial(S(1)/2)
+       factorial(1/2)
+
+       See Also
+       ========
+
+       factorial2, RisingFactorial, FallingFactorial
+    """
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.gamma_functions import (gamma, polygamma)
+        if argindex == 1:
+            return gamma(self.args[0] + 1)*polygamma(0, self.args[0] + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    _small_swing = [
+        1, 1, 1, 3, 3, 15, 5, 35, 35, 315, 63, 693, 231, 3003, 429, 6435, 6435, 109395,
+        12155, 230945, 46189, 969969, 88179, 2028117, 676039, 16900975, 1300075,
+        35102025, 5014575, 145422675, 9694845, 300540195, 300540195
+    ]
+
+    _small_factorials: list[int] = []
+
+    @classmethod
+    def _swing(cls, n):
+        if n < 33:
+            return cls._small_swing[n]
+        else:
+            N, primes = int(_sqrt(n)), []
+
+            for prime in sieve.primerange(3, N + 1):
+                p, q = 1, n
+
+                while True:
+                    q //= prime
+
+                    if q > 0:
+                        if q & 1 == 1:
+                            p *= prime
+                    else:
+                        break
+
+                if p > 1:
+                    primes.append(p)
+
+            for prime in sieve.primerange(N + 1, n//3 + 1):
+                if (n // prime) & 1 == 1:
+                    primes.append(prime)
+
+            L_product = prod(sieve.primerange(n//2 + 1, n + 1))
+            R_product = prod(primes)
+
+            return L_product*R_product
+
+    @classmethod
+    def _recursive(cls, n):
+        if n < 2:
+            return 1
+        else:
+            return (cls._recursive(n//2)**2)*cls._swing(n)
+
+    @classmethod
+    def eval(cls, n):
+        n = sympify(n)
+
+        if n.is_Number:
+            if n.is_zero:
+                return S.One
+            elif n is S.Infinity:
+                return S.Infinity
+            elif n.is_Integer:
+                if n.is_negative:
+                    return S.ComplexInfinity
+                else:
+                    n = n.p
+
+                    if n < 20:
+                        if not cls._small_factorials:
+                            result = 1
+                            for i in range(1, 20):
+                                result *= i
+                                cls._small_factorials.append(result)
+                        result = cls._small_factorials[n-1]
+
+                    # GMPY factorial is faster, use it when available
+                    #
+                    # XXX: There is a sympy.external.gmpy.factorial function
+                    # which provides gmpy.fac if available or the flint version
+                    # if flint is used. It could be used here to avoid the
+                    # conditional logic but it needs to be checked whether the
+                    # pure Python fallback used there is as fast as the
+                    # fallback used here (perhaps the fallback here should be
+                    # moved to sympy.external.ntheory).
+                    elif _gmpy is not None:
+                        result = _gmpy.fac(n)
+
+                    else:
+                        bits = bin(n).count('1')
+                        result = cls._recursive(n)*2**(n - bits)
+
+                    return Integer(result)
+
+    def _facmod(self, n, q):
+        res, N = 1, int(_sqrt(n))
+
+        # Exponent of prime p in n! is e_p(n) = [n/p] + [n/p**2] + ...
+        # for p > sqrt(n), e_p(n) < sqrt(n), the primes with [n/p] = m,
+        # occur consecutively and are grouped together in pw[m] for
+        # simultaneous exponentiation at a later stage
+        pw = [1]*N
+
+        m = 2 # to initialize the if condition below
+        for prime in sieve.primerange(2, n + 1):
+            if m > 1:
+                m, y = 0, n // prime
+                while y:
+                    m += y
+                    y //= prime
+            if m < N:
+                pw[m] = pw[m]*prime % q
+            else:
+                res = res*pow(prime, m, q) % q
+
+        for ex, bs in enumerate(pw):
+            if ex == 0 or bs == 1:
+                continue
+            if bs == 0:
+                return 0
+            res = res*pow(bs, ex, q) % q
+
+        return res
+
+    def _eval_Mod(self, q):
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative and q.is_integer:
+            aq = abs(q)
+            d = aq - n
+            if d.is_nonpositive:
+                return S.Zero
+            else:
+                isprime = aq.is_prime
+                if d == 1:
+                    # Apply Wilson's theorem (if a natural number n > 1
+                    # is a prime number, then (n-1)! = -1 mod n) and
+                    # its inverse (if n > 4 is a composite number, then
+                    # (n-1)! = 0 mod n)
+                    if isprime:
+                        return -1 % q
+                    elif isprime is False and (aq - 6).is_nonnegative:
+                        return S.Zero
+                elif n.is_Integer and q.is_Integer:
+                    n, d, aq = map(int, (n, d, aq))
+                    if isprime and (d - 1 < n):
+                        fc = self._facmod(d - 1, aq)
+                        fc = pow(fc, aq - 2, aq)
+                        if d%2:
+                            fc = -fc
+                    else:
+                        fc = self._facmod(n, aq)
+
+                    return fc % q
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return gamma(n + 1)
+
+    def _eval_rewrite_as_Product(self, n, **kwargs):
+        from sympy.concrete.products import Product
+        if n.is_nonnegative and n.is_integer:
+            i = Dummy('i', integer=True)
+            return Product(i, (i, 1, n))
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_even(self):
+        x = self.args[0]
+        if x.is_integer and x.is_nonnegative:
+            return (x - 2).is_nonnegative
+
+    def _eval_is_composite(self):
+        x = self.args[0]
+        if x.is_integer and x.is_nonnegative:
+            return (x - 3).is_nonnegative
+
+    def _eval_is_real(self):
+        x = self.args[0]
+        if x.is_nonnegative or x.is_noninteger:
+            return True
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x)
+        arg0 = arg.subs(x, 0)
+        if arg0.is_zero:
+            return S.One
+        elif not arg0.is_infinite:
+            return self.func(arg)
+        raise PoleError("Cannot expand %s around 0" % (self))
+
+class MultiFactorial(CombinatorialFunction):
+    pass
+
+
+class subfactorial(CombinatorialFunction):
+    r"""The subfactorial counts the derangements of $n$ items and is
+    defined for non-negative integers as:
+
+    .. math:: !n = \begin{cases} 1 & n = 0 \\ 0 & n = 1 \\
+                    (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases}
+
+    It can also be written as ``int(round(n!/exp(1)))`` but the
+    recursive definition with caching is implemented for this function.
+
+    An interesting analytic expression is the following [2]_
+
+    .. math:: !x = \Gamma(x + 1, -1)/e
+
+    which is valid for non-negative integers `x`. The above formula
+    is not very useful in case of non-integers. `\Gamma(x + 1, -1)` is
+    single-valued only for integral arguments `x`, elsewhere on the positive
+    real axis it has an infinite number of branches none of which are real.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Subfactorial
+    .. [2] https://mathworld.wolfram.com/Subfactorial.html
+
+    Examples
+    ========
+
+    >>> from sympy import subfactorial
+    >>> from sympy.abc import n
+    >>> subfactorial(n + 1)
+    subfactorial(n + 1)
+    >>> subfactorial(5)
+    44
+
+    See Also
+    ========
+
+    factorial, uppergamma,
+    sympy.utilities.iterables.generate_derangements
+    """
+
+    @classmethod
+    @cacheit
+    def _eval(self, n):
+        if not n:
+            return S.One
+        elif n == 1:
+            return S.Zero
+        else:
+            z1, z2 = 1, 0
+            for i in range(2, n + 1):
+                z1, z2 = z2, (i - 1)*(z2 + z1)
+            return z2
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg.is_Integer and arg.is_nonnegative:
+                return cls._eval(arg)
+            elif arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+
+    def _eval_is_even(self):
+        if self.args[0].is_odd and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_rewrite_as_factorial(self, arg, **kwargs):
+        from sympy.concrete.summations import summation
+        i = Dummy('i')
+        f = S.NegativeOne**i / factorial(i)
+        return factorial(arg) * summation(f, (i, 0, arg))
+
+    def _eval_rewrite_as_gamma(self, arg, piecewise=True, **kwargs):
+        from sympy.functions.elementary.exponential import exp
+        from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+        return (S.NegativeOne**(arg + 1)*exp(-I*pi*arg)*lowergamma(arg + 1, -1)
+                + gamma(arg + 1))*exp(-1)
+
+    def _eval_rewrite_as_uppergamma(self, arg, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return uppergamma(arg + 1, -1)/S.Exp1
+
+    def _eval_is_nonnegative(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_odd(self):
+        if self.args[0].is_even and self.args[0].is_nonnegative:
+            return True
+
+
+class factorial2(CombinatorialFunction):
+    r"""The double factorial `n!!`, not to be confused with `(n!)!`
+
+    The double factorial is defined for nonnegative integers and for odd
+    negative integers as:
+
+    .. math:: n!! = \begin{cases} 1 & n = 0 \\
+                    n(n-2)(n-4) \cdots 1 & n\ \text{positive odd} \\
+                    n(n-2)(n-4) \cdots 2 & n\ \text{positive even} \\
+                    (n+2)!!/(n+2) & n\ \text{negative odd} \end{cases}
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Double_factorial
+
+    Examples
+    ========
+
+    >>> from sympy import factorial2, var
+    >>> n = var('n')
+    >>> n
+    n
+    >>> factorial2(n + 1)
+    factorial2(n + 1)
+    >>> factorial2(5)
+    15
+    >>> factorial2(-1)
+    1
+    >>> factorial2(-5)
+    1/3
+
+    See Also
+    ========
+
+    factorial, RisingFactorial, FallingFactorial
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        # TODO: extend this to complex numbers?
+
+        if arg.is_Number:
+            if not arg.is_Integer:
+                raise ValueError("argument must be nonnegative integer "
+                                    "or negative odd integer")
+
+            # This implementation is faster than the recursive one
+            # It also avoids "maximum recursion depth exceeded" runtime error
+            if arg.is_nonnegative:
+                if arg.is_even:
+                    k = arg / 2
+                    return 2**k * factorial(k)
+                return factorial(arg) / factorial2(arg - 1)
+
+
+            if arg.is_odd:
+                return arg*(S.NegativeOne)**((1 - arg)/2) / factorial2(-arg)
+            raise ValueError("argument must be nonnegative integer "
+                                "or negative odd integer")
+
+
+    def _eval_is_even(self):
+        # Double factorial is even for every positive even input
+        n = self.args[0]
+        if n.is_integer:
+            if n.is_odd:
+                return False
+            if n.is_even:
+                if n.is_positive:
+                    return True
+                if n.is_zero:
+                    return False
+
+    def _eval_is_integer(self):
+        # Double factorial is an integer for every nonnegative input, and for
+        # -1 and -3
+        n = self.args[0]
+        if n.is_integer:
+            if (n + 1).is_nonnegative:
+                return True
+            if n.is_odd:
+                return (n + 3).is_nonnegative
+
+    def _eval_is_odd(self):
+        # Double factorial is odd for every odd input not smaller than -3, and
+        # for 0
+        n = self.args[0]
+        if n.is_odd:
+            return (n + 3).is_nonnegative
+        if n.is_even:
+            if n.is_positive:
+                return False
+            if n.is_zero:
+                return True
+
+    def _eval_is_positive(self):
+        # Double factorial is positive for every nonnegative input, and for
+        # every odd negative input which is of the form -1-4k for an
+        # nonnegative integer k
+        n = self.args[0]
+        if n.is_integer:
+            if (n + 1).is_nonnegative:
+                return True
+            if n.is_odd:
+                return ((n + 1) / 2).is_even
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        return 2**(n/2)*gamma(n/2 + 1) * Piecewise((1, Eq(Mod(n, 2), 0)),
+                (sqrt(2/pi), Eq(Mod(n, 2), 1)))
+
+
+###############################################################################
+######################## RISING and FALLING FACTORIALS ########################
+###############################################################################
+
+
+class RisingFactorial(CombinatorialFunction):
+    r"""
+    Rising factorial (also called Pochhammer symbol [1]_) is a double valued
+    function arising in concrete mathematics, hypergeometric functions
+    and series expansions. It is defined by:
+
+    .. math:: \texttt{rf(y, k)} = (x)^k = x \cdot (x+1) \cdots (x+k-1)
+
+    where `x` can be arbitrary expression and `k` is an integer. For
+    more information check "Concrete mathematics" by Graham, pp. 66
+    or visit https://mathworld.wolfram.com/RisingFactorial.html page.
+
+    When `x` is a `~.Poly` instance of degree $\ge 1$ with a single variable,
+    `(x)^k = x(y) \cdot x(y+1) \cdots x(y+k-1)`, where `y` is the
+    variable of `x`. This is as described in [2]_.
+
+    Examples
+    ========
+
+    >>> from sympy import rf, Poly
+    >>> from sympy.abc import x
+    >>> rf(x, 0)
+    1
+    >>> rf(1, 5)
+    120
+    >>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x)
+    True
+    >>> rf(Poly(x**3, x), 2)
+    Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ')
+
+    Rewriting is complicated unless the relationship between
+    the arguments is known, but rising factorial can
+    be rewritten in terms of gamma, factorial, binomial,
+    and falling factorial.
+
+    >>> from sympy import Symbol, factorial, ff, binomial, gamma
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> R = rf(n, n + 2)
+    >>> for i in (rf, ff, factorial, binomial, gamma):
+    ...  R.rewrite(i)
+    ...
+    RisingFactorial(n, n + 2)
+    FallingFactorial(2*n + 1, n + 2)
+    factorial(2*n + 1)/factorial(n - 1)
+    binomial(2*n + 1, n + 2)*factorial(n + 2)
+    gamma(2*n + 2)/gamma(n)
+
+    See Also
+    ========
+
+    factorial, factorial2, FallingFactorial
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Pochhammer_symbol
+    .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic
+           Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268,
+           1995.
+
+    """
+
+    @classmethod
+    def eval(cls, x, k):
+        x = sympify(x)
+        k = sympify(k)
+
+        if x is S.NaN or k is S.NaN:
+            return S.NaN
+        elif x is S.One:
+            return factorial(k)
+        elif k.is_Integer:
+            if k.is_zero:
+                return S.One
+            else:
+                if k.is_positive:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        if k.is_odd:
+                            return S.NegativeInfinity
+                        else:
+                            return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return reduce(lambda r, i:
+                                              r*(x.shift(i)),
+                                              range(int(k)), 1)
+                        else:
+                            return reduce(lambda r, i: r*(x + i),
+                                          range(int(k)), 1)
+
+                else:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return 1/reduce(lambda r, i:
+                                                r*(x.shift(-i)),
+                                                range(1, abs(int(k)) + 1), 1)
+                        else:
+                            return 1/reduce(lambda r, i:
+                                            r*(x - i),
+                                            range(1, abs(int(k)) + 1), 1)
+
+        if k.is_integer == False:
+            if x.is_integer and x.is_negative:
+                return S.Zero
+
+    def _eval_rewrite_as_gamma(self, x, k, piecewise=True, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        if not piecewise:
+            if (x <= 0) == True:
+                return S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1)
+            return gamma(x + k) / gamma(x)
+        return Piecewise(
+            (gamma(x + k) / gamma(x), x > 0),
+            (S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1), True))
+
+    def _eval_rewrite_as_FallingFactorial(self, x, k, **kwargs):
+        return FallingFactorial(x + k - 1, k)
+
+    def _eval_rewrite_as_factorial(self, x, k, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        if x.is_integer and k.is_integer:
+            return Piecewise(
+                (factorial(k + x - 1)/factorial(x - 1), x > 0),
+                (S.NegativeOne**k*factorial(-x)/factorial(-k - x), True))
+
+    def _eval_rewrite_as_binomial(self, x, k, **kwargs):
+        if k.is_integer:
+            return factorial(k) * binomial(x + k - 1, k)
+
+    def _eval_rewrite_as_tractable(self, x, k, limitvar=None, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        if limitvar:
+            k_lim = k.subs(limitvar, S.Infinity)
+            if k_lim is S.Infinity:
+                return (gamma(x + k).rewrite('tractable', deep=True) / gamma(x))
+            elif k_lim is S.NegativeInfinity:
+                return (S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1).rewrite('tractable', deep=True))
+        return self.rewrite(gamma).rewrite('tractable', deep=True)
+
+    def _eval_is_integer(self):
+        return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
+                          self.args[1].is_nonnegative))
+
+
+class FallingFactorial(CombinatorialFunction):
+    r"""
+    Falling factorial (related to rising factorial) is a double valued
+    function arising in concrete mathematics, hypergeometric functions
+    and series expansions. It is defined by
+
+    .. math:: \texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1)
+
+    where `x` can be arbitrary expression and `k` is an integer. For
+    more information check "Concrete mathematics" by Graham, pp. 66
+    or [1]_.
+
+    When `x` is a `~.Poly` instance of degree $\ge 1$ with single variable,
+    `(x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1)`, where `y` is the
+    variable of `x`. This is as described in
+
+    >>> from sympy import ff, Poly, Symbol
+    >>> from sympy.abc import x
+    >>> n = Symbol('n', integer=True)
+
+    >>> ff(x, 0)
+    1
+    >>> ff(5, 5)
+    120
+    >>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+    True
+    >>> ff(Poly(x**2, x), 2)
+    Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ')
+    >>> ff(n, n)
+    factorial(n)
+
+    Rewriting is complicated unless the relationship between
+    the arguments is known, but falling factorial can
+    be rewritten in terms of gamma, factorial and binomial
+    and rising factorial.
+
+    >>> from sympy import factorial, rf, gamma, binomial, Symbol
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> F = ff(n, n - 2)
+    >>> for i in (rf, ff, factorial, binomial, gamma):
+    ...  F.rewrite(i)
+    ...
+    RisingFactorial(3, n - 2)
+    FallingFactorial(n, n - 2)
+    factorial(n)/2
+    binomial(n, n - 2)*factorial(n - 2)
+    gamma(n + 1)/2
+
+    See Also
+    ========
+
+    factorial, factorial2, RisingFactorial
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/FallingFactorial.html
+    .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic
+           Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268,
+           1995.
+
+    """
+
+    @classmethod
+    def eval(cls, x, k):
+        x = sympify(x)
+        k = sympify(k)
+
+        if x is S.NaN or k is S.NaN:
+            return S.NaN
+        elif k.is_integer and x == k:
+            return factorial(x)
+        elif k.is_Integer:
+            if k.is_zero:
+                return S.One
+            else:
+                if k.is_positive:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        if k.is_odd:
+                            return S.NegativeInfinity
+                        else:
+                            return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("ff only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return reduce(lambda r, i:
+                                              r*(x.shift(-i)),
+                                              range(int(k)), 1)
+                        else:
+                            return reduce(lambda r, i: r*(x - i),
+                                          range(int(k)), 1)
+                else:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return 1/reduce(lambda r, i:
+                                                r*(x.shift(i)),
+                                                range(1, abs(int(k)) + 1), 1)
+                        else:
+                            return 1/reduce(lambda r, i: r*(x + i),
+                                            range(1, abs(int(k)) + 1), 1)
+
+    def _eval_rewrite_as_gamma(self, x, k, piecewise=True, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        if not piecewise:
+            if (x < 0) == True:
+                return S.NegativeOne**k*gamma(k - x) / gamma(-x)
+            return gamma(x + 1) / gamma(x - k + 1)
+        return Piecewise(
+            (gamma(x + 1) / gamma(x - k + 1), x >= 0),
+            (S.NegativeOne**k*gamma(k - x) / gamma(-x), True))
+
+    def _eval_rewrite_as_RisingFactorial(self, x, k, **kwargs):
+        return rf(x - k + 1, k)
+
+    def _eval_rewrite_as_binomial(self, x, k, **kwargs):
+        if k.is_integer:
+            return factorial(k) * binomial(x, k)
+
+    def _eval_rewrite_as_factorial(self, x, k, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        if x.is_integer and k.is_integer:
+            return Piecewise(
+                (factorial(x)/factorial(-k + x), x >= 0),
+                (S.NegativeOne**k*factorial(k - x - 1)/factorial(-x - 1), True))
+
+    def _eval_rewrite_as_tractable(self, x, k, limitvar=None, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        if limitvar:
+            k_lim = k.subs(limitvar, S.Infinity)
+            if k_lim is S.Infinity:
+                return (S.NegativeOne**k*gamma(k - x).rewrite('tractable', deep=True) / gamma(-x))
+            elif k_lim is S.NegativeInfinity:
+                return (gamma(x + 1) / gamma(x - k + 1).rewrite('tractable', deep=True))
+        return self.rewrite(gamma).rewrite('tractable', deep=True)
+
+    def _eval_is_integer(self):
+        return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
+                          self.args[1].is_nonnegative))
+
+
+rf = RisingFactorial
+ff = FallingFactorial
+
+###############################################################################
+########################### BINOMIAL COEFFICIENTS #############################
+###############################################################################
+
+
+class binomial(CombinatorialFunction):
+    r"""Implementation of the binomial coefficient. It can be defined
+    in two ways depending on its desired interpretation:
+
+    .. math:: \binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{or}\
+                \binom{n}{k} = \frac{(n)_k}{k!}
+
+    First, in a strict combinatorial sense it defines the
+    number of ways we can choose `k` elements from a set of
+    `n` elements. In this case both arguments are nonnegative
+    integers and binomial is computed using an efficient
+    algorithm based on prime factorization.
+
+    The other definition is generalization for arbitrary `n`,
+    however `k` must also be nonnegative. This case is very
+    useful when evaluating summations.
+
+    For the sake of convenience, for negative integer `k` this function
+    will return zero no matter the other argument.
+
+    To expand the binomial when `n` is a symbol, use either
+    ``expand_func()`` or ``expand(func=True)``. The former will keep
+    the polynomial in factored form while the latter will expand the
+    polynomial itself. See examples for details.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Rational, binomial, expand_func
+    >>> n = Symbol('n', integer=True, positive=True)
+
+    >>> binomial(15, 8)
+    6435
+
+    >>> binomial(n, -1)
+    0
+
+    Rows of Pascal's triangle can be generated with the binomial function:
+
+    >>> for N in range(8):
+    ...     print([binomial(N, i) for i in range(N + 1)])
+    ...
+    [1]
+    [1, 1]
+    [1, 2, 1]
+    [1, 3, 3, 1]
+    [1, 4, 6, 4, 1]
+    [1, 5, 10, 10, 5, 1]
+    [1, 6, 15, 20, 15, 6, 1]
+    [1, 7, 21, 35, 35, 21, 7, 1]
+
+    As can a given diagonal, e.g. the 4th diagonal:
+
+    >>> N = -4
+    >>> [binomial(N, i) for i in range(1 - N)]
+    [1, -4, 10, -20, 35]
+
+    >>> binomial(Rational(5, 4), 3)
+    -5/128
+    >>> binomial(Rational(-5, 4), 3)
+    -195/128
+
+    >>> binomial(n, 3)
+    binomial(n, 3)
+
+    >>> binomial(n, 3).expand(func=True)
+    n**3/6 - n**2/2 + n/3
+
+    >>> expand_func(binomial(n, 3))
+    n*(n - 2)*(n - 1)/6
+
+    In many cases, we can also compute binomial coefficients modulo a
+    prime p quickly using Lucas' Theorem [2]_, though we need to include
+    `evaluate=False` to postpone evaluation:
+
+    >>> from sympy import Mod
+    >>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3)
+    28625
+
+    Using a generalisation of Lucas's Theorem given by Granville [3]_,
+    we can extend this to arbitrary n:
+
+    >>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2)
+    3744312326
+
+    References
+    ==========
+
+    .. [1] https://www.johndcook.com/blog/binomial_coefficients/
+    .. [2] https://en.wikipedia.org/wiki/Lucas%27s_theorem
+    .. [3] Binomial coefficients modulo prime powers, Andrew Granville,
+        Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf
+    """
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.gamma_functions import polygamma
+        if argindex == 1:
+            # https://functions.wolfram.com/GammaBetaErf/Binomial/20/01/01/
+            n, k = self.args
+            return binomial(n, k)*(polygamma(0, n + 1) - \
+                polygamma(0, n - k + 1))
+        elif argindex == 2:
+            # https://functions.wolfram.com/GammaBetaErf/Binomial/20/01/02/
+            n, k = self.args
+            return binomial(n, k)*(polygamma(0, n - k + 1) - \
+                polygamma(0, k + 1))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def _eval(self, n, k):
+        # n.is_Number and k.is_Integer and k != 1 and n != k
+
+        if k.is_Integer:
+            if n.is_Integer and n >= 0:
+                n, k = int(n), int(k)
+
+                if k > n:
+                    return S.Zero
+                elif k > n // 2:
+                    k = n - k
+
+                # XXX: This conditional logic should be moved to
+                # sympy.external.gmpy and the pure Python version of bincoef
+                # should be moved to sympy.external.ntheory.
+                if _gmpy is not None:
+                    return Integer(_gmpy.bincoef(n, k))
+
+                d, result = n - k, 1
+                for i in range(1, k + 1):
+                    d += 1
+                    result = result * d // i
+                return Integer(result)
+            else:
+                d, result = n - k, 1
+                for i in range(1, k + 1):
+                    d += 1
+                    result *= d
+                return result / _factorial(k)
+
+    @classmethod
+    def eval(cls, n, k):
+        n, k = map(sympify, (n, k))
+        d = n - k
+        n_nonneg, n_isint = n.is_nonnegative, n.is_integer
+        if k.is_zero or ((n_nonneg or n_isint is False)
+                and d.is_zero):
+            return S.One
+        if (k - 1).is_zero or ((n_nonneg or n_isint is False)
+                and (d - 1).is_zero):
+            return n
+        if k.is_integer:
+            if k.is_negative or (n_nonneg and n_isint and d.is_negative):
+                return S.Zero
+            elif n.is_number:
+                res = cls._eval(n, k)
+                return res.expand(basic=True) if res else res
+        elif n_nonneg is False and n_isint:
+            # a special case when binomial evaluates to complex infinity
+            return S.ComplexInfinity
+        elif k.is_number:
+            from sympy.functions.special.gamma_functions import gamma
+            return gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+
+    def _eval_Mod(self, q):
+        n, k = self.args
+
+        if any(x.is_integer is False for x in (n, k, q)):
+            raise ValueError("Integers expected for binomial Mod")
+
+        if all(x.is_Integer for x in (n, k, q)):
+            n, k = map(int, (n, k))
+            aq, res = abs(q), 1
+
+            # handle negative integers k or n
+            if k < 0:
+                return S.Zero
+            if n < 0:
+                n = -n + k - 1
+                res = -1 if k%2 else 1
+
+            # non negative integers k and n
+            if k > n:
+                return S.Zero
+
+            isprime = aq.is_prime
+            aq = int(aq)
+            if isprime:
+                if aq < n:
+                    # use Lucas Theorem
+                    N, K = n, k
+                    while N or K:
+                        res = res*binomial(N % aq, K % aq) % aq
+                        N, K = N // aq, K // aq
+
+                else:
+                    # use Factorial Modulo
+                    d = n - k
+                    if k > d:
+                        k, d = d, k
+                    kf = 1
+                    for i in range(2, k + 1):
+                        kf = kf*i % aq
+                    df = kf
+                    for i in range(k + 1, d + 1):
+                        df = df*i % aq
+                    res *= df
+                    for i in range(d + 1, n + 1):
+                        res = res*i % aq
+
+                    res *= pow(kf*df % aq, aq - 2, aq)
+                    res %= aq
+
+            elif _sqrt(q) < k and q != 1:
+                res = binomial_mod(n, k, q)
+
+            else:
+                # Binomial Factorization is performed by calculating the
+                # exponents of primes <= n in `n! /(k! (n - k)!)`,
+                # for non-negative integers n and k. As the exponent of
+                # prime in n! is e_p(n) = [n/p] + [n/p**2] + ...
+                # the exponent of prime in binomial(n, k) would be
+                # e_p(n) - e_p(k) - e_p(n - k)
+                M = int(_sqrt(n))
+                for prime in sieve.primerange(2, n + 1):
+                    if prime > n - k:
+                        res = res*prime % aq
+                    elif prime > n // 2:
+                        continue
+                    elif prime > M:
+                        if n % prime < k % prime:
+                            res = res*prime % aq
+                    else:
+                        N, K = n, k
+                        exp = a = 0
+
+                        while N > 0:
+                            a = int((N % prime) < (K % prime + a))
+                            N, K = N // prime, K // prime
+                            exp += a
+
+                        if exp > 0:
+                            res *= pow(prime, exp, aq)
+                            res %= aq
+
+            return S(res % q)
+
+    def _eval_expand_func(self, **hints):
+        """
+        Function to expand binomial(n, k) when m is positive integer
+        Also,
+        n is self.args[0] and k is self.args[1] while using binomial(n, k)
+        """
+        n = self.args[0]
+        if n.is_Number:
+            return binomial(*self.args)
+
+        k = self.args[1]
+        if (n-k).is_Integer:
+            k = n - k
+
+        if k.is_Integer:
+            if k.is_zero:
+                return S.One
+            elif k.is_negative:
+                return S.Zero
+            else:
+                n, result = self.args[0], 1
+                for i in range(1, k + 1):
+                    result *= n - k + i
+                return result / _factorial(k)
+        else:
+            return binomial(*self.args)
+
+    def _eval_rewrite_as_factorial(self, n, k, **kwargs):
+        return factorial(n)/(factorial(k)*factorial(n - k))
+
+    def _eval_rewrite_as_gamma(self, n, k, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+
+    def _eval_rewrite_as_tractable(self, n, k, limitvar=None, **kwargs):
+        return self._eval_rewrite_as_gamma(n, k).rewrite('tractable')
+
+    def _eval_rewrite_as_FallingFactorial(self, n, k, **kwargs):
+        if k.is_integer:
+            return ff(n, k) / factorial(k)
+
+    def _eval_is_integer(self):
+        n, k = self.args
+        if n.is_integer and k.is_integer:
+            return True
+        elif k.is_integer is False:
+            return False
+
+    def _eval_is_nonnegative(self):
+        n, k = self.args
+        if n.is_integer and k.is_integer:
+            if n.is_nonnegative or k.is_negative or k.is_even:
+                return True
+            elif k.is_even is False:
+                return  False
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.functions.special.gamma_functions import gamma
+        return self.rewrite(gamma)._eval_as_leading_term(x, logx=logx, cdir=cdir)

.venv/lib/python3.13/site-packages/sympy/functions/combinatorial/tests/test_comb_factorials.py

@@ -0,0 +1,653 @@
+from sympy.concrete.products import Product
+from sympy.core.function import expand_func
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (ff, rf, binomial, factorial, factorial2)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.gamma_functions import (gamma, polygamma)
+from sympy.polys.polytools import Poly
+from sympy.series.order import O
+from sympy.simplify.simplify import simplify
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.combinatorial.factorials import subfactorial
+from sympy.functions.special.gamma_functions import uppergamma
+from sympy.testing.pytest import XFAIL, raises, slow
+
+#Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+
+def test_rf_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert rf(nan, y) is nan
+    assert rf(x, nan) is nan
+
+    assert unchanged(rf, x, y)
+
+    assert rf(oo, 0) == 1
+    assert rf(-oo, 0) == 1
+
+    assert rf(oo, 6) is oo
+    assert rf(-oo, 7) is -oo
+    assert rf(-oo, 6) is oo
+
+    assert rf(oo, -6) is oo
+    assert rf(-oo, -7) is oo
+
+    assert rf(-1, pi) == 0
+    assert rf(-5, 1 + I) == 0
+
+    assert unchanged(rf, -3, k)
+    assert unchanged(rf, x, Symbol('k', integer=False))
+    assert rf(-3, Symbol('k', integer=False)) == 0
+    assert rf(Symbol('x', negative=True, integer=True), Symbol('k', integer=False)) == 0
+
+    assert rf(x, 0) == 1
+    assert rf(x, 1) == x
+    assert rf(x, 2) == x*(x + 1)
+    assert rf(x, 3) == x*(x + 1)*(x + 2)
+    assert rf(x, 5) == x*(x + 1)*(x + 2)*(x + 3)*(x + 4)
+
+    assert rf(x, -1) == 1/(x - 1)
+    assert rf(x, -2) == 1/((x - 1)*(x - 2))
+    assert rf(x, -3) == 1/((x - 1)*(x - 2)*(x - 3))
+
+    assert rf(1, 100) == factorial(100)
+
+    assert rf(x**2 + 3*x, 2) == (x**2 + 3*x)*(x**2 + 3*x + 1)
+    assert isinstance(rf(x**2 + 3*x, 2), Mul)
+    assert rf(x**3 + x, -2) == 1/((x**3 + x - 1)*(x**3 + x - 2))
+
+    assert rf(Poly(x**2 + 3*x, x), 2) == Poly(x**4 + 8*x**3 + 19*x**2 + 12*x, x)
+    assert isinstance(rf(Poly(x**2 + 3*x, x), 2), Poly)
+    raises(ValueError, lambda: rf(Poly(x**2 + 3*x, x, y), 2))
+    assert rf(Poly(x**3 + x, x), -2) == 1/(x**6 - 9*x**5 + 35*x**4 - 75*x**3 + 94*x**2 - 66*x + 20)
+    raises(ValueError, lambda: rf(Poly(x**3 + x, x, y), -2))
+
+    assert rf(x, m).is_integer is None
+    assert rf(n, k).is_integer is None
+    assert rf(n, m).is_integer is True
+    assert rf(n, k + pi).is_integer is False
+    assert rf(n, m + pi).is_integer is False
+    assert rf(pi, m).is_integer is False
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+            for j in range(-5,5):
+                assert o(i, j) == r(i, j), (o, n, i, j)
+    check(x, k, rf, ff)
+    check(x, k, rf, binomial)
+    check(n, k, rf, factorial)
+    check(x, y, rf, factorial)
+    check(x, y, rf, binomial)
+
+    assert rf(x, k).rewrite(ff) == ff(x + k - 1, k)
+    assert rf(x, k).rewrite(gamma) == Piecewise(
+        (gamma(k + x)/gamma(x), x > 0),
+        ((-1)**k*gamma(1 - x)/gamma(-k - x + 1), True))
+    assert rf(5, k).rewrite(gamma) == gamma(k + 5)/24
+    assert rf(x, k).rewrite(binomial) == factorial(k)*binomial(x + k - 1, k)
+    assert rf(n, k).rewrite(factorial) == Piecewise(
+        (factorial(k + n - 1)/factorial(n - 1), n > 0),
+        ((-1)**k*factorial(-n)/factorial(-k - n), True))
+    assert rf(5, k).rewrite(factorial) == factorial(k + 4)/24
+    assert rf(x, y).rewrite(factorial) == rf(x, y)
+    assert rf(x, y).rewrite(binomial) == rf(x, y)
+
+    import random
+    from mpmath import rf as mpmath_rf
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        assert (abs(mpmath_rf(x, k) - rf(x, k)) < 10**(-15))
+
+
+def test_ff_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert ff(nan, y) is nan
+    assert ff(x, nan) is nan
+
+    assert unchanged(ff, x, y)
+
+    assert ff(oo, 0) == 1
+    assert ff(-oo, 0) == 1
+
+    assert ff(oo, 6) is oo
+    assert ff(-oo, 7) is -oo
+    assert ff(-oo, 6) is oo
+
+    assert ff(oo, -6) is oo
+    assert ff(-oo, -7) is oo
+
+    assert ff(x, 0) == 1
+    assert ff(x, 1) == x
+    assert ff(x, 2) == x*(x - 1)
+    assert ff(x, 3) == x*(x - 1)*(x - 2)
+    assert ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+
+    assert ff(x, -1) == 1/(x + 1)
+    assert ff(x, -2) == 1/((x + 1)*(x + 2))
+    assert ff(x, -3) == 1/((x + 1)*(x + 2)*(x + 3))
+
+    assert ff(100, 100) == factorial(100)
+
+    assert ff(2*x**2 - 5*x, 2) == (2*x**2  - 5*x)*(2*x**2 - 5*x - 1)
+    assert isinstance(ff(2*x**2 - 5*x, 2), Mul)
+    assert ff(x**2 + 3*x, -2) == 1/((x**2 + 3*x + 1)*(x**2 + 3*x + 2))
+
+    assert ff(Poly(2*x**2 - 5*x, x), 2) == Poly(4*x**4 - 28*x**3 + 59*x**2 - 35*x, x)
+    assert isinstance(ff(Poly(2*x**2 - 5*x, x), 2), Poly)
+    raises(ValueError, lambda: ff(Poly(2*x**2 - 5*x, x, y), 2))
+    assert ff(Poly(x**2 + 3*x, x), -2) == 1/(x**4 + 12*x**3 + 49*x**2 + 78*x + 40)
+    raises(ValueError, lambda: ff(Poly(x**2 + 3*x, x, y), -2))
+
+
+    assert ff(x, m).is_integer is None
+    assert ff(n, k).is_integer is None
+    assert ff(n, m).is_integer is True
+    assert ff(n, k + pi).is_integer is False
+    assert ff(n, m + pi).is_integer is False
+    assert ff(pi, m).is_integer is False
+
+    assert isinstance(ff(x, x), ff)
+    assert ff(n, n) == factorial(n)
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+            for j in range(-5,5):
+                assert o(i, j) == r(i, j), (o, n)
+    check(x, k, ff, rf)
+    check(x, k, ff, gamma)
+    check(n, k, ff, factorial)
+    check(x, k, ff, binomial)
+    check(x, y, ff, factorial)
+    check(x, y, ff, binomial)
+
+    assert ff(x, k).rewrite(rf) == rf(x - k + 1, k)
+    assert ff(x, k).rewrite(gamma) == Piecewise(
+        (gamma(x + 1)/gamma(-k + x + 1), x >= 0),
+        ((-1)**k*gamma(k - x)/gamma(-x), True))
+    assert ff(5, k).rewrite(gamma) == 120/gamma(6 - k)
+    assert ff(n, k).rewrite(factorial) == Piecewise(
+        (factorial(n)/factorial(-k + n), n >= 0),
+        ((-1)**k*factorial(k - n - 1)/factorial(-n - 1), True))
+    assert ff(5, k).rewrite(factorial) == 120/factorial(5 - k)
+    assert ff(x, k).rewrite(binomial) == factorial(k) * binomial(x, k)
+    assert ff(x, y).rewrite(factorial) == ff(x, y)
+    assert ff(x, y).rewrite(binomial) == ff(x, y)
+
+    import random
+    from mpmath import ff as mpmath_ff
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        a = mpmath_ff(x, k)
+        b = ff(x, k)
+        assert (abs(a - b) < abs(a) * 10**(-15))
+
+
+def test_rf_ff_eval_hiprec():
+    maple = Float('6.9109401292234329956525265438452')
+    us = ff(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('6.8261540131125511557924466355367')
+    us = rf(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('34.007346127440197150854651814225')
+    us = rf(Float('4.4', 32), Float('2.2', 32))
+    assert abs(us - maple)/us < 1e-31
+
+
+def test_rf_lambdify_mpmath():
+    from sympy.utilities.lambdify import lambdify
+    x, y = symbols('x,y')
+    f = lambdify((x,y), rf(x, y), 'mpmath')
+    maple = Float('34.007346127440197')
+    us = f(4.4, 2.2)
+    assert abs(us - maple)/us < 1e-15
+
+
+def test_factorial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    r = Symbol('r', integer=False)
+    s = Symbol('s', integer=False, negative=True)
+    t = Symbol('t', nonnegative=True)
+    u = Symbol('u', noninteger=True)
+
+    assert factorial(-2) is zoo
+    assert factorial(0) == 1
+    assert factorial(7) == 5040
+    assert factorial(19) == 121645100408832000
+    assert factorial(31) == 8222838654177922817725562880000000
+    assert factorial(n).func == factorial
+    assert factorial(2*n).func == factorial
+
+    assert factorial(x).is_integer is None
+    assert factorial(n).is_integer is None
+    assert factorial(k).is_integer
+    assert factorial(r).is_integer is None
+
+    assert factorial(n).is_positive is None
+    assert factorial(k).is_positive
+
+    assert factorial(x).is_real is None
+    assert factorial(n).is_real is None
+    assert factorial(k).is_real is True
+    assert factorial(r).is_real is None
+    assert factorial(s).is_real is True
+    assert factorial(t).is_real is True
+    assert factorial(u).is_real is True
+
+    assert factorial(x).is_composite is None
+    assert factorial(n).is_composite is None
+    assert factorial(k).is_composite is None
+    assert factorial(k + 3).is_composite is True
+    assert factorial(r).is_composite is None
+    assert factorial(s).is_composite is None
+    assert factorial(t).is_composite is None
+    assert factorial(u).is_composite is None
+
+    assert factorial(oo) is oo
+
+
+def test_factorial_Mod():
+    pr = Symbol('pr', prime=True)
+    p, q = 10**9 + 9, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+    assert Mod(factorial(pr - 1), pr) == pr - 1
+    assert Mod(factorial(pr - 1), -pr) == -1
+    assert Mod(factorial(r - 1, evaluate=False), r) == 0
+    assert Mod(factorial(s - 1, evaluate=False), s) == 0
+    assert Mod(factorial(p - 1, evaluate=False), p) == p - 1
+    assert Mod(factorial(q - 1, evaluate=False), q) == q - 1
+    assert Mod(factorial(p - 50, evaluate=False), p) == 854928834
+    assert Mod(factorial(q - 1800, evaluate=False), q) == 905504050
+    assert Mod(factorial(153, evaluate=False), r) == Mod(factorial(153), r)
+    assert Mod(factorial(255, evaluate=False), s) == Mod(factorial(255), s)
+    assert Mod(factorial(4, evaluate=False), 3) == S.Zero
+    assert Mod(factorial(5, evaluate=False), 6) == S.Zero
+
+
+def test_factorial_diff():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).diff(n) == \
+        gamma(1 + n)*polygamma(0, 1 + n)
+    assert factorial(n**2).diff(n) == \
+        2*n*gamma(1 + n**2)*polygamma(0, 1 + n**2)
+    raises(ArgumentIndexError, lambda: factorial(n**2).fdiff(2))
+
+
+def test_factorial_series():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).series(n, 0, 3) == \
+        1 - n*EulerGamma + n**2*(EulerGamma**2/2 + pi**2/12) + O(n**3)
+
+
+def test_factorial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+
+    assert factorial(n).rewrite(gamma) == gamma(n + 1)
+    _i = Dummy('i')
+    assert factorial(k).rewrite(Product).dummy_eq(Product(_i, (_i, 1, k)))
+    assert factorial(n).rewrite(Product) == factorial(n)
+
+
+def test_factorial2():
+    n = Symbol('n', integer=True)
+
+    assert factorial2(-1) == 1
+    assert factorial2(0) == 1
+    assert factorial2(7) == 105
+    assert factorial2(8) == 384
+
+    # The following is exhaustive
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tte = Symbol('tte', even=True, nonnegative=True)
+    tpe = Symbol('tpe', even=True, positive=True)
+    tto = Symbol('tto', odd=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tfe = Symbol('tfe', even=True, nonnegative=False)
+    tfo = Symbol('tfo', odd=True, nonnegative=False)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('fn', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nn')
+    z = Symbol('z', zero=True)
+    #Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+    raises(ValueError, lambda: factorial2(oo))
+    raises(ValueError, lambda: factorial2(Rational(5, 2)))
+    raises(ValueError, lambda: factorial2(-4))
+    assert factorial2(n).is_integer is None
+    assert factorial2(tt - 1).is_integer
+    assert factorial2(tte - 1).is_integer
+    assert factorial2(tpe - 3).is_integer
+    assert factorial2(tto - 4).is_integer
+    assert factorial2(tto - 2).is_integer
+    assert factorial2(tf).is_integer is None
+    assert factorial2(tfe).is_integer is None
+    assert factorial2(tfo).is_integer is None
+    assert factorial2(ft).is_integer is None
+    assert factorial2(ff).is_integer is None
+    assert factorial2(fn).is_integer is None
+    assert factorial2(nt).is_integer is None
+    assert factorial2(nf).is_integer is None
+    assert factorial2(nn).is_integer is None
+
+    assert factorial2(n).is_positive is None
+    assert factorial2(tt - 1).is_positive is True
+    assert factorial2(tte - 1).is_positive is True
+    assert factorial2(tpe - 3).is_positive is True
+    assert factorial2(tpe - 1).is_positive is True
+    assert factorial2(tto - 2).is_positive is True
+    assert factorial2(tto - 1).is_positive is True
+    assert factorial2(tf).is_positive is None
+    assert factorial2(tfe).is_positive is None
+    assert factorial2(tfo).is_positive is None
+    assert factorial2(ft).is_positive is None
+    assert factorial2(ff).is_positive is None
+    assert factorial2(fn).is_positive is None
+    assert factorial2(nt).is_positive is None
+    assert factorial2(nf).is_positive is None
+    assert factorial2(nn).is_positive is None
+
+    assert factorial2(tt).is_even is None
+    assert factorial2(tt).is_odd is None
+    assert factorial2(tte).is_even is None
+    assert factorial2(tte).is_odd is None
+    assert factorial2(tte + 2).is_even is True
+    assert factorial2(tpe).is_even is True
+    assert factorial2(tpe).is_odd is False
+    assert factorial2(tto).is_odd is True
+    assert factorial2(tf).is_even is None
+    assert factorial2(tf).is_odd is None
+    assert factorial2(tfe).is_even is None
+    assert factorial2(tfe).is_odd is None
+    assert factorial2(tfo).is_even is False
+    assert factorial2(tfo).is_odd is None
+    assert factorial2(z).is_even is False
+    assert factorial2(z).is_odd is True
+
+
+def test_factorial2_rewrite():
+    n = Symbol('n', integer=True)
+    assert factorial2(n).rewrite(gamma) == \
+        2**(n/2)*Piecewise((1, Eq(Mod(n, 2), 0)), (sqrt(2)/sqrt(pi), Eq(Mod(n, 2), 1)))*gamma(n/2 + 1)
+    assert factorial2(2*n).rewrite(gamma) == 2**n*gamma(n + 1)
+    assert factorial2(2*n + 1).rewrite(gamma) == \
+        sqrt(2)*2**(n + S.Half)*gamma(n + Rational(3, 2))/sqrt(pi)
+
+
+def test_binomial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    nz = Symbol('nz', integer=True, nonzero=True)
+    k = Symbol('k', integer=True)
+    kp = Symbol('kp', integer=True, positive=True)
+    kn = Symbol('kn', integer=True, negative=True)
+    u = Symbol('u', negative=True)
+    v = Symbol('v', nonnegative=True)
+    p = Symbol('p', positive=True)
+    z = Symbol('z', zero=True)
+    nt = Symbol('nt', integer=False)
+    kt = Symbol('kt', integer=False)
+    a = Symbol('a', integer=True, nonnegative=True)
+    b = Symbol('b', integer=True, nonnegative=True)
+
+    assert binomial(0, 0) == 1
+    assert binomial(1, 1) == 1
+    assert binomial(10, 10) == 1
+    assert binomial(n, z) == 1
+    assert binomial(1, 2) == 0
+    assert binomial(-1, 2) == 1
+    assert binomial(1, -1) == 0
+    assert binomial(-1, 1) == -1
+    assert binomial(-1, -1) == 0
+    assert binomial(S.Half, S.Half) == 1
+    assert binomial(-10, 1) == -10
+    assert binomial(-10, 7) == -11440
+    assert binomial(n, -1) == 0 # holds for all integers (negative, zero, positive)
+    assert binomial(kp, -1) == 0
+    assert binomial(nz, 0) == 1
+    assert expand_func(binomial(n, 1)) == n
+    assert expand_func(binomial(n, 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 1)) == n
+    assert binomial(n, 3).func == binomial
+    assert binomial(n, 3).expand(func=True) ==  n**3/6 - n**2/2 + n/3
+    assert expand_func(binomial(n, 3)) ==  n*(n - 2)*(n - 1)/6
+    assert binomial(n, n).func == binomial # e.g. (-1, -1) == 0, (2, 2) == 1
+    assert binomial(n, n + 1).func == binomial  # e.g. (-1, 0) == 1
+    assert binomial(kp, kp + 1) == 0
+    assert binomial(kn, kn) == 0 # issue #14529
+    assert binomial(n, u).func == binomial
+    assert binomial(kp, u).func == binomial
+    assert binomial(n, p).func == binomial
+    assert binomial(n, k).func == binomial
+    assert binomial(n, n + p).func == binomial
+    assert binomial(kp, kp + p).func == binomial
+
+    assert expand_func(binomial(n, n - 3)) == n*(n - 2)*(n - 1)/6
+
+    assert binomial(n, k).is_integer
+    assert binomial(nt, k).is_integer is None
+    assert binomial(x, nt).is_integer is False
+
+    assert binomial(gamma(25), 6) == 79232165267303928292058750056084441948572511312165380965440075720159859792344339983120618959044048198214221915637090855535036339620413440000
+    assert binomial(1324, 47) == 906266255662694632984994480774946083064699457235920708992926525848438478406790323869952
+    assert binomial(1735, 43) == 190910140420204130794758005450919715396159959034348676124678207874195064798202216379800
+    assert binomial(2512, 53) == 213894469313832631145798303740098720367984955243020898718979538096223399813295457822575338958939834177325304000
+    assert binomial(3383, 52) == 27922807788818096863529701501764372757272890613101645521813434902890007725667814813832027795881839396839287659777235
+    assert binomial(4321, 51) == 124595639629264868916081001263541480185227731958274383287107643816863897851139048158022599533438936036467601690983780576
+
+    assert binomial(a, b).is_nonnegative is True
+    assert binomial(-1, 2, evaluate=False).is_nonnegative is True
+    assert binomial(10, 5, evaluate=False).is_nonnegative is True
+    assert binomial(10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 2, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 1, evaluate=False).is_nonnegative is False
+    assert binomial(-10, 7, evaluate=False).is_nonnegative is False
+
+    # issue #14625
+    for _ in (pi, -pi, nt, v, a):
+        assert binomial(_, _) == 1
+        assert binomial(_, _ - 1) == _
+    assert isinstance(binomial(u, u), binomial)
+    assert isinstance(binomial(u, u - 1), binomial)
+    assert isinstance(binomial(x, x), binomial)
+    assert isinstance(binomial(x, x - 1), binomial)
+
+    #issue #18802
+    assert expand_func(binomial(x + 1, x)) == x + 1
+    assert expand_func(binomial(x, x - 1)) == x
+    assert expand_func(binomial(x + 1, x - 1)) == x*(x + 1)/2
+    assert expand_func(binomial(x**2 + 1, x**2)) == x**2 + 1
+
+    # issue #13980 and #13981
+    assert binomial(-7, -5) == 0
+    assert binomial(-23, -12) == 0
+    assert binomial(Rational(13, 2), -10) == 0
+    assert binomial(-49, -51) == 0
+
+    assert binomial(19, Rational(-7, 2)) == S(-68719476736)/(911337863661225*pi)
+    assert binomial(0, Rational(3, 2)) == S(-2)/(3*pi)
+    assert binomial(-3, Rational(-7, 2)) is zoo
+    assert binomial(kn, kt) is zoo
+
+    assert binomial(nt, kt).func == binomial
+    assert binomial(nt, Rational(15, 6)) == 8*gamma(nt + 1)/(15*sqrt(pi)*gamma(nt - Rational(3, 2)))
+    assert binomial(Rational(20, 3), Rational(-10, 8)) == gamma(Rational(23, 3))/(gamma(Rational(-1, 4))*gamma(Rational(107, 12)))
+    assert binomial(Rational(19, 2), Rational(-7, 2)) == Rational(-1615, 8388608)
+    assert binomial(Rational(-13, 5), Rational(-7, 8)) == gamma(Rational(-8, 5))/(gamma(Rational(-29, 40))*gamma(Rational(1, 8)))
+    assert binomial(Rational(-19, 8), Rational(-13, 5)) == gamma(Rational(-11, 8))/(gamma(Rational(-8, 5))*gamma(Rational(49, 40)))
+
+    # binomial for complexes
+    assert binomial(I, Rational(-89, 8)) == gamma(1 + I)/(gamma(Rational(-81, 8))*gamma(Rational(97, 8) + I))
+    assert binomial(I, 2*I) == gamma(1 + I)/(gamma(1 - I)*gamma(1 + 2*I))
+    assert binomial(-7, I) is zoo
+    assert binomial(Rational(-7, 6), I) == gamma(Rational(-1, 6))/(gamma(Rational(-1, 6) - I)*gamma(1 + I))
+    assert binomial((1+2*I), (1+3*I)) == gamma(2 + 2*I)/(gamma(1 - I)*gamma(2 + 3*I))
+    assert binomial(I, 5) == Rational(1, 3) - I/S(12)
+    assert binomial((2*I + 3), 7) == -13*I/S(63)
+    assert isinstance(binomial(I, n), binomial)
+    assert expand_func(binomial(3, 2, evaluate=False)) == 3
+    assert expand_func(binomial(n, 0, evaluate=False)) == 1
+    assert expand_func(binomial(n, -2, evaluate=False)) == 0
+    assert expand_func(binomial(n, k)) == binomial(n, k)
+
+
+def test_binomial_Mod():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r = 10**7 + 5 # composite modulo
+
+    # A few tests to get coverage
+    # Lucas Theorem
+    assert Mod(binomial(156675, 4433, evaluate=False), p) == Mod(binomial(156675, 4433), p)
+
+    # factorial Mod
+    assert Mod(binomial(1234, 432, evaluate=False), q) == Mod(binomial(1234, 432), q)
+
+    # binomial factorize
+    assert Mod(binomial(253, 113, evaluate=False), r) == Mod(binomial(253, 113), r)
+
+    # using Granville's generalisation of Lucas' Theorem
+    assert Mod(binomial(10**18, 10**12, evaluate=False), p*p) == 3744312326
+
+
+@slow
+def test_binomial_Mod_slow():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+
+    n, k, m = symbols('n k m')
+    assert (binomial(n, k) % q).subs({n: s, k: p}) == Mod(binomial(s, p), q)
+    assert (binomial(n, k) % m).subs({n: 8, k: 5, m: 13}) == 4
+    assert (binomial(9, k) % 7).subs(k, 2) == 1
+
+    # Lucas Theorem
+    assert Mod(binomial(123456, 43253, evaluate=False), p) == Mod(binomial(123456, 43253), p)
+    assert Mod(binomial(-178911, 237, evaluate=False), p) == Mod(-binomial(178911 + 237 - 1, 237), p)
+    assert Mod(binomial(-178911, 238, evaluate=False), p) == Mod(binomial(178911 + 238 - 1, 238), p)
+
+    # factorial Mod
+    assert Mod(binomial(9734, 451, evaluate=False), q) == Mod(binomial(9734, 451), q)
+    assert Mod(binomial(-10733, 4459, evaluate=False), q) == Mod(binomial(-10733, 4459), q)
+    assert Mod(binomial(-15733, 4458, evaluate=False), q) == Mod(binomial(-15733, 4458), q)
+    assert Mod(binomial(23, -38, evaluate=False), q) is S.Zero
+    assert Mod(binomial(23, 38, evaluate=False), q) is S.Zero
+
+    # binomial factorize
+    assert Mod(binomial(753, 119, evaluate=False), r) == Mod(binomial(753, 119), r)
+    assert Mod(binomial(3781, 948, evaluate=False), s) == Mod(binomial(3781, 948), s)
+    assert Mod(binomial(25773, 1793, evaluate=False), s) == Mod(binomial(25773, 1793), s)
+    assert Mod(binomial(-753, 118, evaluate=False), r) == Mod(binomial(-753, 118), r)
+    assert Mod(binomial(-25773, 1793, evaluate=False), s) == Mod(binomial(-25773, 1793), s)
+
+
+def test_binomial_diff():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+
+    assert binomial(n, k).diff(n) == \
+        (-polygamma(0, 1 + n - k) + polygamma(0, 1 + n))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(n) == \
+        2*n*(-polygamma(
+            0, 1 + n**2 - k**3) + polygamma(0, 1 + n**2))*binomial(n**2, k**3)
+
+    assert binomial(n, k).diff(k) == \
+        (-polygamma(0, 1 + k) + polygamma(0, 1 + n - k))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(k) == \
+        3*k**2*(-polygamma(
+            0, 1 + k**3) + polygamma(0, 1 + n**2 - k**3))*binomial(n**2, k**3)
+    raises(ArgumentIndexError, lambda: binomial(n, k).fdiff(3))
+
+
+def test_binomial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+    x = Symbol('x')
+
+    assert binomial(n, k).rewrite(
+        factorial) == factorial(n)/(factorial(k)*factorial(n - k))
+    assert binomial(
+        n, k).rewrite(gamma) == gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+    assert binomial(n, k).rewrite(ff) == ff(n, k) / factorial(k)
+    assert binomial(n, x).rewrite(ff) == binomial(n, x)
+
+
+@XFAIL
+def test_factorial_simplify_fail():
+    # simplify(factorial(x + 1).diff(x) - ((x + 1)*factorial(x)).diff(x))) == 0
+    from sympy.abc import x
+    assert simplify(x*polygamma(0, x + 1) - x*polygamma(0, x + 2) +
+                    polygamma(0, x + 1) - polygamma(0, x + 2) + 1) == 0
+
+
+def test_subfactorial():
+    assert all(subfactorial(i) == ans for i, ans in enumerate(
+        [1, 0, 1, 2, 9, 44, 265, 1854, 14833, 133496]))
+    assert subfactorial(oo) is oo
+    assert subfactorial(nan) is nan
+    assert subfactorial(23) == 9510425471055777937262
+    assert unchanged(subfactorial, 2.2)
+
+    x = Symbol('x')
+    assert subfactorial(x).rewrite(uppergamma) == uppergamma(x + 1, -1)/S.Exp1
+
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tn = Symbol('tf', integer=True)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('ff', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nf')
+    te = Symbol('te', even=True, nonnegative=True)
+    to = Symbol('to', odd=True, nonnegative=True)
+    assert subfactorial(tt).is_integer
+    assert subfactorial(tf).is_integer is None
+    assert subfactorial(tn).is_integer is None
+    assert subfactorial(ft).is_integer is None
+    assert subfactorial(ff).is_integer is None
+    assert subfactorial(fn).is_integer is None
+    assert subfactorial(nt).is_integer is None
+    assert subfactorial(nf).is_integer is None
+    assert subfactorial(nn).is_integer is None
+    assert subfactorial(tt).is_nonnegative
+    assert subfactorial(tf).is_nonnegative is None
+    assert subfactorial(tn).is_nonnegative is None
+    assert subfactorial(ft).is_nonnegative is None
+    assert subfactorial(ff).is_nonnegative is None
+    assert subfactorial(fn).is_nonnegative is None
+    assert subfactorial(nt).is_nonnegative is None
+    assert subfactorial(nf).is_nonnegative is None
+    assert subfactorial(nn).is_nonnegative is None
+    assert subfactorial(tt).is_even is None
+    assert subfactorial(tt).is_odd is None
+    assert subfactorial(te).is_odd is True
+    assert subfactorial(to).is_even is True

.venv/lib/python3.13/site-packages/sympy/functions/combinatorial/tests/test_comb_numbers.py

@@ -0,0 +1,1250 @@
+import string
+
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.function import (diff, expand_func)
+from sympy.core import (EulerGamma, TribonacciConstant)
+from sympy.core.numbers import (Float, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.numbers import carmichael
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.integers import floor
+from sympy.polys.polytools import cancel
+from sympy.series.limits import limit, Limit
+from sympy.series.order import O
+from sympy.functions import (
+    bernoulli, harmonic, bell, fibonacci, tribonacci, lucas, euler, catalan,
+    genocchi, andre, partition, divisor_sigma, udivisor_sigma, legendre_symbol,
+    jacobi_symbol, kronecker_symbol, mobius,
+    primenu, primeomega, totient, reduced_totient, primepi,
+    motzkin, binomial, gamma, sqrt, cbrt, hyper, log, digamma,
+    trigamma, polygamma, factorial, sin, cos, cot, polylog, zeta, dirichlet_eta)
+from sympy.functions.combinatorial.numbers import _nT
+from sympy.ntheory.factor_ import factorint
+
+from sympy.core.expr import unchanged
+from sympy.core.numbers import GoldenRatio, Integer
+
+from sympy.testing.pytest import raises, nocache_fail, warns_deprecated_sympy
+from sympy.abc import x
+
+
+def test_carmichael():
+    with warns_deprecated_sympy():
+        assert carmichael.is_prime(2821) == False
+
+
+def test_bernoulli():
+    assert bernoulli(0) == 1
+    assert bernoulli(1) == Rational(1, 2)
+    assert bernoulli(2) == Rational(1, 6)
+    assert bernoulli(3) == 0
+    assert bernoulli(4) == Rational(-1, 30)
+    assert bernoulli(5) == 0
+    assert bernoulli(6) == Rational(1, 42)
+    assert bernoulli(7) == 0
+    assert bernoulli(8) == Rational(-1, 30)
+    assert bernoulli(10) == Rational(5, 66)
+    assert bernoulli(1000001) == 0
+
+    assert bernoulli(0, x) == 1
+    assert bernoulli(1, x) == x - S.Half
+    assert bernoulli(2, x) == x**2 - x + Rational(1, 6)
+    assert bernoulli(3, x) == x**3 - (3*x**2)/2 + x/2
+
+    # Should be fast; computed with mpmath
+    b = bernoulli(1000)
+    assert b.p % 10**10 == 7950421099
+    assert b.q == 342999030
+
+    b = bernoulli(10**6, evaluate=False).evalf()
+    assert str(b) == '-2.23799235765713e+4767529'
+
+    # Issue #8527
+    l = Symbol('l', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert isinstance(bernoulli(2 * l + 1), bernoulli)
+    assert isinstance(bernoulli(2 * m + 1), bernoulli)
+    assert bernoulli(2 * n + 1) == 0
+
+    assert bernoulli(x, 1) == bernoulli(x)
+
+    assert str(bernoulli(0.0, 2.3).evalf(n=10)) == '1.000000000'
+    assert str(bernoulli(1.0).evalf(n=10)) == '0.5000000000'
+    assert str(bernoulli(1.2).evalf(n=10)) == '0.4195995367'
+    assert str(bernoulli(1.2, 0.8).evalf(n=10)) == '0.2144830348'
+    assert str(bernoulli(1.2, -0.8).evalf(n=10)) == '-1.158865646 - 0.6745558744*I'
+    assert str(bernoulli(3.0, 1j).evalf(n=10)) == '1.5 - 0.5*I'
+    assert str(bernoulli(I).evalf(n=10)) == '0.9268485643 - 0.5821580598*I'
+    assert str(bernoulli(I, I).evalf(n=10)) == '0.1267792071 + 0.01947413152*I'
+    assert bernoulli(x).evalf() == bernoulli(x)
+
+
+def test_bernoulli_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol('n', integer=True, nonnegative=True)
+
+    assert bernoulli(-1).rewrite(zeta) == pi**2/6
+    assert bernoulli(-2).rewrite(zeta) == 2*zeta(3)
+    assert not bernoulli(n, -3).rewrite(zeta).has(harmonic)
+    assert bernoulli(-4, x).rewrite(zeta) == 4*zeta(5, x)
+    assert isinstance(bernoulli(n, x).rewrite(zeta), Piecewise)
+    assert bernoulli(n+1, x).rewrite(zeta) == -(n+1) * zeta(-n, x)
+
+
+def test_fibonacci():
+    assert [fibonacci(n) for n in range(-3, 5)] == [2, -1, 1, 0, 1, 1, 2, 3]
+    assert fibonacci(100) == 354224848179261915075
+    assert [lucas(n) for n in range(-3, 5)] == [-4, 3, -1, 2, 1, 3, 4, 7]
+    assert lucas(100) == 792070839848372253127
+
+    assert fibonacci(1, x) == 1
+    assert fibonacci(2, x) == x
+    assert fibonacci(3, x) == x**2 + 1
+    assert fibonacci(4, x) == x**3 + 2*x
+
+    # issue #8800
+    n = Dummy('n')
+    assert fibonacci(n).limit(n, S.Infinity) is S.Infinity
+    assert lucas(n).limit(n, S.Infinity) is S.Infinity
+
+    assert fibonacci(n).rewrite(sqrt) == \
+        2**(-n)*sqrt(5)*((1 + sqrt(5))**n - (-sqrt(5) + 1)**n) / 5
+    assert fibonacci(n).rewrite(sqrt).subs(n, 10).expand() == fibonacci(10)
+    assert fibonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(fibonacci(10))
+    assert lucas(n).rewrite(sqrt) == \
+        (fibonacci(n-1).rewrite(sqrt) + fibonacci(n+1).rewrite(sqrt)).simplify()
+    assert lucas(n).rewrite(sqrt).subs(n, 10).expand() == lucas(10)
+    raises(ValueError, lambda: fibonacci(-3, x))
+
+
+def test_tribonacci():
+    assert [tribonacci(n) for n in range(8)] == [0, 1, 1, 2, 4, 7, 13, 24]
+    assert tribonacci(100) == 98079530178586034536500564
+
+    assert tribonacci(0, x) == 0
+    assert tribonacci(1, x) == 1
+    assert tribonacci(2, x) == x**2
+    assert tribonacci(3, x) == x**4 + x
+    assert tribonacci(4, x) == x**6 + 2*x**3 + 1
+    assert tribonacci(5, x) == x**8 + 3*x**5 + 3*x**2
+
+    n = Dummy('n')
+    assert tribonacci(n).limit(n, S.Infinity) is S.Infinity
+
+    w = (-1 + S.ImaginaryUnit * sqrt(3)) / 2
+    a = (1 + cbrt(19 + 3*sqrt(33)) + cbrt(19 - 3*sqrt(33))) / 3
+    b = (1 + w*cbrt(19 + 3*sqrt(33)) + w**2*cbrt(19 - 3*sqrt(33))) / 3
+    c = (1 + w**2*cbrt(19 + 3*sqrt(33)) + w*cbrt(19 - 3*sqrt(33))) / 3
+    assert tribonacci(n).rewrite(sqrt) == \
+      (a**(n + 1)/((a - b)*(a - c))
+      + b**(n + 1)/((b - a)*(b - c))
+      + c**(n + 1)/((c - a)*(c - b)))
+    assert tribonacci(n).rewrite(sqrt).subs(n, 4).simplify() == tribonacci(4)
+    assert tribonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(tribonacci(10))
+    assert tribonacci(n).rewrite(TribonacciConstant) == floor(
+            3*TribonacciConstant**n*(102*sqrt(33) + 586)**Rational(1, 3)/
+            (-2*(102*sqrt(33) + 586)**Rational(1, 3) + 4 + (102*sqrt(33)
+            + 586)**Rational(2, 3)) + S.Half)
+    raises(ValueError, lambda: tribonacci(-1, x))
+
+
+@nocache_fail
+def test_bell():
+    assert [bell(n) for n in range(8)] == [1, 1, 2, 5, 15, 52, 203, 877]
+
+    assert bell(0, x) == 1
+    assert bell(1, x) == x
+    assert bell(2, x) == x**2 + x
+    assert bell(5, x) == x**5 + 10*x**4 + 25*x**3 + 15*x**2 + x
+    assert bell(oo) is S.Infinity
+    raises(ValueError, lambda: bell(oo, x))
+
+    raises(ValueError, lambda: bell(-1))
+    raises(ValueError, lambda: bell(S.Half))
+
+    X = symbols('x:6')
+    # X = (x0, x1, .. x5)
+    # at the same time: X[1] = x1, X[2] = x2 for standard readablity.
+    # but we must supply zero-based indexed object X[1:] = (x1, .. x5)
+
+    assert bell(6, 2, X[1:]) == 6*X[5]*X[1] + 15*X[4]*X[2] + 10*X[3]**2
+    assert bell(
+        6, 3, X[1:]) == 15*X[4]*X[1]**2 + 60*X[3]*X[2]*X[1] + 15*X[2]**3
+
+    X = (1, 10, 100, 1000, 10000)
+    assert bell(6, 2, X) == (6 + 15 + 10)*10000
+
+    X = (1, 2, 3, 3, 5)
+    assert bell(6, 2, X) == 6*5 + 15*3*2 + 10*3**2
+
+    X = (1, 2, 3, 5)
+    assert bell(6, 3, X) == 15*5 + 60*3*2 + 15*2**3
+
+    # Dobinski's formula
+    n = Symbol('n', integer=True, nonnegative=True)
+    # For large numbers, this is too slow
+    # For nonintegers, there are significant precision errors
+    for i in [0, 2, 3, 7, 13, 42, 55]:
+        # Running without the cache this is either very slow or goes into an
+        # infinite loop.
+        assert bell(i).evalf() == bell(n).rewrite(Sum).evalf(subs={n: i})
+
+    m = Symbol("m")
+    assert bell(m).rewrite(Sum) == bell(m)
+    assert bell(n, m).rewrite(Sum) == bell(n, m)
+    # issue 9184
+    n = Dummy('n')
+    assert bell(n).limit(n, S.Infinity) is S.Infinity
+
+
+def test_harmonic():
+    n = Symbol("n")
+    m = Symbol("m")
+
+    assert harmonic(n, 0) == n
+    assert harmonic(n).evalf() == harmonic(n)
+    assert harmonic(n, 1) == harmonic(n)
+    assert harmonic(1, n) == 1
+
+    assert harmonic(0, 1) == 0
+    assert harmonic(1, 1) == 1
+    assert harmonic(2, 1) == Rational(3, 2)
+    assert harmonic(3, 1) == Rational(11, 6)
+    assert harmonic(4, 1) == Rational(25, 12)
+    assert harmonic(0, 2) == 0
+    assert harmonic(1, 2) == 1
+    assert harmonic(2, 2) == Rational(5, 4)
+    assert harmonic(3, 2) == Rational(49, 36)
+    assert harmonic(4, 2) == Rational(205, 144)
+    assert harmonic(0, 3) == 0
+    assert harmonic(1, 3) == 1
+    assert harmonic(2, 3) == Rational(9, 8)
+    assert harmonic(3, 3) == Rational(251, 216)
+    assert harmonic(4, 3) == Rational(2035, 1728)
+
+    assert harmonic(oo, -1) is S.NaN
+    assert harmonic(oo, 0) is oo
+    assert harmonic(oo, S.Half) is oo
+    assert harmonic(oo, 1) is oo
+    assert harmonic(oo, 2) == (pi**2)/6
+    assert harmonic(oo, 3) == zeta(3)
+    assert harmonic(oo, Dummy(negative=True)) is S.NaN
+    ip = Dummy(integer=True, positive=True)
+    if (1/ip <= 1) is True:  #---------------------------------+
+        assert None, 'delete this if-block and the next line' #|
+    ip = Dummy(even=True, positive=True)  #--------------------+
+    assert harmonic(oo, 1/ip) is oo
+    assert harmonic(oo, 1 + ip) is zeta(1 + ip)
+
+    assert harmonic(0, m) == 0
+    assert harmonic(-1, -1) == 0
+    assert harmonic(-1, 0) == -1
+    assert harmonic(-1, 1) is S.ComplexInfinity
+    assert harmonic(-1, 2) is S.NaN
+    assert harmonic(-3, -2) == -5
+    assert harmonic(-3, -3) == 9
+
+
+def test_harmonic_rational():
+    ne = S(6)
+    no = S(5)
+    pe = S(8)
+    po = S(9)
+    qe = S(10)
+    qo = S(13)
+
+    Heee = harmonic(ne + pe/qe)
+    Aeee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(13944145, 4720968))
+
+    Heeo = harmonic(ne + pe/qo)
+    Aeeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2 - 2*log(sin(pi/13))*cos(pi*Rational(3, 13))
+             + Rational(2422020029, 702257080))
+
+    Heoe = harmonic(ne + po/qe)
+    Aeoe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(11818877030, 4286604231) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Heoo = harmonic(ne + po/qo)
+    Aeoo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(3, 13)) + Rational(11669332571, 3628714320))
+
+    Hoee = harmonic(no + pe/qe)
+    Aoee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(779405, 277704))
+
+    Hoeo = harmonic(no + pe/qo)
+    Aoeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2
+             - 2*log(sin(pi/13))*cos(pi*Rational(3, 13)) + Rational(53857323, 16331560))
+
+    Hooe = harmonic(no + po/qe)
+    Aooe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(486853480, 186374097) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Hooo = harmonic(no + po/qo)
+    Aooo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(3*pi/13) + Rational(383693479, 125128080))
+
+    H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
+    A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
+    for h, a in zip(H, A):
+        e = expand_func(h).doit()
+        assert cancel(e/a) == 1
+        assert abs(h.n() - a.n()) < 1e-12
+
+
+def test_harmonic_evalf():
+    assert str(harmonic(1.5).evalf(n=10)) == '1.280372306'
+    assert str(harmonic(1.5, 2).evalf(n=10)) == '1.154576311'  # issue 7443
+    assert str(harmonic(4.0, -3).evalf(n=10)) == '100.0000000'
+    assert str(harmonic(7.0, 1.0).evalf(n=10)) == '2.592857143'
+    assert str(harmonic(1, pi).evalf(n=10)) == '1.000000000'
+    assert str(harmonic(2, pi).evalf(n=10)) == '1.113314732'
+    assert str(harmonic(1000.0, pi).evalf(n=10)) == '1.176241563'
+    assert str(harmonic(I).evalf(n=10)) == '0.6718659855 + 1.076674047*I'
+    assert str(harmonic(I, I).evalf(n=10)) == '-0.3970915266 + 1.9629689*I'
+
+    assert harmonic(-1.0, 1).evalf() is S.NaN
+    assert harmonic(-2.0, 2.0).evalf() is S.NaN
+
+def test_harmonic_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol("n")
+    m = Symbol("m", integer=True, positive=True)
+    x1 = Symbol("x1", positive=True)
+    x2 = Symbol("x2", negative=True)
+
+    assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(trigamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(polygamma) == polygamma(0, n + 1) + EulerGamma
+
+    assert harmonic(n,3).rewrite(polygamma) == polygamma(2, n + 1)/2 - polygamma(2, 1)/2
+    assert isinstance(harmonic(n,m).rewrite(polygamma), Piecewise)
+
+    assert expand_func(harmonic(n+4)) == harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
+    assert expand_func(harmonic(n-4)) == harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
+
+    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma)
+    assert harmonic(n, x1).rewrite("tractable") == harmonic(n, x1)
+    assert harmonic(n, x1 + 1).rewrite("tractable") == zeta(x1 + 1) - zeta(x1 + 1, n + 1)
+    assert harmonic(n, x2).rewrite("tractable") == zeta(x2) - zeta(x2, n + 1)
+
+    _k = Dummy("k")
+    assert harmonic(n).rewrite(Sum).dummy_eq(Sum(1/_k, (_k, 1, n)))
+    assert harmonic(n, m).rewrite(Sum).dummy_eq(Sum(_k**(-m), (_k, 1, n)))
+
+
+def test_harmonic_calculus():
+    y = Symbol("y", positive=True)
+    z = Symbol("z", negative=True)
+    assert harmonic(x, 1).limit(x, 0) == 0
+    assert harmonic(x, y).limit(x, 0) == 0
+    assert harmonic(x, 1).series(x, y, 2) == \
+            harmonic(y) + (x - y)*zeta(2, y + 1) + O((x - y)**2, (x, y))
+    assert limit(harmonic(x, y), x, oo) == harmonic(oo, y)
+    assert limit(harmonic(x, y + 1), x, oo) == zeta(y + 1)
+    assert limit(harmonic(x, y - 1), x, oo) == harmonic(oo, y - 1)
+    assert limit(harmonic(x, z), x, oo) == Limit(harmonic(x, z), x, oo, dir='-')
+    assert limit(harmonic(x, z + 1), x, oo) == oo
+    assert limit(harmonic(x, z + 2), x, oo) == harmonic(oo, z + 2)
+    assert limit(harmonic(x, z - 1), x, oo) == Limit(harmonic(x, z - 1), x, oo, dir='-')
+
+
+def test_euler():
+    assert euler(0) == 1
+    assert euler(1) == 0
+    assert euler(2) == -1
+    assert euler(3) == 0
+    assert euler(4) == 5
+    assert euler(6) == -61
+    assert euler(8) == 1385
+
+    assert euler(20, evaluate=False) != 370371188237525
+
+    n = Symbol('n', integer=True)
+    assert euler(n) != -1
+    assert euler(n).subs(n, 2) == -1
+
+    assert euler(-1) == S.Pi / 2
+    assert euler(-1, 1) == 2*log(2)
+    assert euler(-2).evalf() == (2*S.Catalan).evalf()
+    assert euler(-3).evalf() == (S.Pi**3 / 16).evalf()
+    assert str(euler(2.3).evalf(n=10)) == '-1.052850274'
+    assert str(euler(1.2, 3.4).evalf(n=10)) == '3.575613489'
+    assert str(euler(I).evalf(n=10)) == '1.248446443 - 0.7675445124*I'
+    assert str(euler(I, I).evalf(n=10)) == '0.04812930469 + 0.01052411008*I'
+
+    assert euler(20).evalf() == 370371188237525.0
+    assert euler(20, evaluate=False).evalf() == 370371188237525.0
+
+    assert euler(n).rewrite(Sum) == euler(n)
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert euler(2*n + 1).rewrite(Sum) == 0
+    _j = Dummy('j')
+    _k = Dummy('k')
+    assert euler(2*n).rewrite(Sum).dummy_eq(
+            I*Sum((-1)**_j*2**(-_k)*I**(-_k)*(-2*_j + _k)**(2*n + 1)*
+                  binomial(_k, _j)/_k, (_j, 0, _k), (_k, 1, 2*n + 1)))
+
+
+def test_euler_odd():
+    n = Symbol('n', odd=True, positive=True)
+    assert euler(n) == 0
+    n = Symbol('n', odd=True)
+    assert euler(n) != 0
+
+
+def test_euler_polynomials():
+    assert euler(0, x) == 1
+    assert euler(1, x) == x - S.Half
+    assert euler(2, x) == x**2 - x
+    assert euler(3, x) == x**3 - (3*x**2)/2 + Rational(1, 4)
+    m = Symbol('m')
+    assert isinstance(euler(m, x), euler)
+    from sympy.core.numbers import Float
+    A = Float('-0.46237208575048694923364757452876131e8')  # from Maple
+    B = euler(19, S.Pi).evalf(32)
+    assert abs((A - B)/A) < 1e-31
+    z = Float(0.1) + Float(0.2)*I
+    expected = Float(-3126.54721663773 ) + Float(565.736261497056) * I
+    assert abs(euler(13, z) - expected) < 1e-10
+
+
+def test_euler_polynomial_rewrite():
+    m = Symbol('m')
+    A = euler(m, x).rewrite('Sum')
+    assert A.subs({m:3, x:5}).doit() == euler(3, 5)
+
+
+def test_catalan():
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    p = Symbol('p', nonnegative=True)
+
+    catalans = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786]
+    for i, c in enumerate(catalans):
+        assert catalan(i) == c
+        assert catalan(n).rewrite(factorial).subs(n, i) == c
+        assert catalan(n).rewrite(Product).subs(n, i).doit() == c
+
+    assert unchanged(catalan, x)
+    assert catalan(2*x).rewrite(binomial) == binomial(4*x, 2*x)/(2*x + 1)
+    assert catalan(S.Half).rewrite(gamma) == 8/(3*pi)
+    assert catalan(S.Half).rewrite(factorial).rewrite(gamma) ==\
+        8 / (3 * pi)
+    assert catalan(3*x).rewrite(gamma) == 4**(
+        3*x)*gamma(3*x + S.Half)/(sqrt(pi)*gamma(3*x + 2))
+    assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2,), 1)
+
+    assert catalan(n).rewrite(factorial) == factorial(2*n) / (factorial(n + 1)
+                                                              * factorial(n))
+    assert isinstance(catalan(n).rewrite(Product), catalan)
+    assert isinstance(catalan(m).rewrite(Product), Product)
+
+    assert diff(catalan(x), x) == (polygamma(
+        0, x + S.Half) - polygamma(0, x + 2) + log(4))*catalan(x)
+
+    assert catalan(x).evalf() == catalan(x)
+    c = catalan(S.Half).evalf()
+    assert str(c) == '0.848826363156775'
+    c = catalan(I).evalf(3)
+    assert str((re(c), im(c))) == '(0.398, -0.0209)'
+
+    # Assumptions
+    assert catalan(p).is_positive is True
+    assert catalan(k).is_integer is True
+    assert catalan(m+3).is_composite is True
+
+
+def test_genocchi():
+    genocchis = [0, -1, -1, 0, 1, 0, -3, 0, 17]
+    for n, g in enumerate(genocchis):
+        assert genocchi(n) == g
+
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert unchanged(genocchi, m)
+    assert genocchi(2*n + 1) == 0
+    gn = 2 * (1 - 2**n) * bernoulli(n)
+    assert genocchi(n).rewrite(bernoulli).factor() == gn.factor()
+    gnx = 2 * (bernoulli(n, x) - 2**n * bernoulli(n, (x+1) / 2))
+    assert genocchi(n, x).rewrite(bernoulli).factor() == gnx.factor()
+    assert genocchi(2 * n).is_odd
+    assert genocchi(2 * n).is_even is False
+    assert genocchi(2 * n + 1).is_even
+    assert genocchi(n).is_integer
+    assert genocchi(4 * n).is_positive
+    # these are the only 2 prime Genocchi numbers
+    assert genocchi(6, evaluate=False).is_prime == S(-3).is_prime
+    assert genocchi(8, evaluate=False).is_prime
+    assert genocchi(4 * n + 2).is_negative
+    assert genocchi(4 * n + 1).is_negative is False
+    assert genocchi(4 * n - 2).is_negative
+
+    g0 = genocchi(0, evaluate=False)
+    assert g0.is_positive is False
+    assert g0.is_negative is False
+    assert g0.is_even is True
+    assert g0.is_odd is False
+
+    assert genocchi(0, x) == 0
+    assert genocchi(1, x) == -1
+    assert genocchi(2, x) == 1 - 2*x
+    assert genocchi(3, x) == 3*x - 3*x**2
+    assert genocchi(4, x) == -1 + 6*x**2 - 4*x**3
+    y = Symbol("y")
+    assert genocchi(5, (x+y)**100) == -5*(x+y)**400 + 10*(x+y)**300 - 5*(x+y)**100
+
+    assert str(genocchi(5.0, 4.0).evalf(n=10)) == '-660.0000000'
+    assert str(genocchi(Rational(5, 4)).evalf(n=10)) == '-1.104286457'
+    assert str(genocchi(-2).evalf(n=10)) == '3.606170709'
+    assert str(genocchi(1.3, 3.7).evalf(n=10)) == '-1.847375373'
+    assert str(genocchi(I, 1.0).evalf(n=10)) == '-0.3161917278 - 1.45311955*I'
+
+    n = Symbol('n')
+    assert genocchi(n, x).rewrite(dirichlet_eta) == -2*n * dirichlet_eta(1-n, x)
+
+
+def test_andre():
+    nums = [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+    for n, a in enumerate(nums):
+        assert andre(n) == a
+    assert andre(S.Infinity) == S.Infinity
+    assert andre(-1) == -log(2)
+    assert andre(-2) == -2*S.Catalan
+    assert andre(-3) == 3*zeta(3)/16
+    assert andre(-5) == -15*zeta(5)/256
+    # In fact andre(-2*n) is related to the Dirichlet *beta* function
+    # at 2*n, but SymPy doesn't implement that (or general L-functions)
+    assert unchanged(andre, -4)
+
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert unchanged(andre, n)
+    assert andre(n).is_integer is True
+    assert andre(n).is_positive is True
+
+    assert str(andre(10, evaluate=False).evalf(n=10)) == '50521.00000'
+    assert str(andre(-1, evaluate=False).evalf(n=10)) == '-0.6931471806'
+    assert str(andre(-2, evaluate=False).evalf(n=10)) == '-1.831931188'
+    assert str(andre(-4, evaluate=False).evalf(n=10)) == '1.977889103'
+    assert str(andre(I, evaluate=False).evalf(n=10)) == '2.378417833 + 0.6343322845*I'
+
+    assert andre(x).rewrite(polylog) == \
+            (-I)**(x+1) * polylog(-x, I) + I**(x+1) * polylog(-x, -I)
+    assert andre(x).rewrite(zeta) == \
+            2 * gamma(x+1) / (2*pi)**(x+1) * \
+            (zeta(x+1, Rational(1,4)) - cos(pi*x) * zeta(x+1, Rational(3,4)))
+
+
+@nocache_fail
+def test_partition():
+    partition_nums = [1, 1, 2, 3, 5, 7, 11, 15, 22]
+    for n, p in enumerate(partition_nums):
+        assert partition(n) == p
+
+    x = Symbol('x')
+    y = Symbol('y', real=True)
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, negative=True)
+    p = Symbol('p', integer=True, nonnegative=True)
+    assert partition(m).is_integer
+    assert not partition(m).is_negative
+    assert partition(m).is_nonnegative
+    assert partition(n).is_zero
+    assert partition(p).is_positive
+    assert partition(x).subs(x, 7) == 15
+    assert partition(y).subs(y, 8) == 22
+    raises(TypeError, lambda: partition(Rational(5, 4)))
+    assert partition(9, evaluate=False) % 5 == 0
+    assert partition(5*m + 4) % 5 == 0
+    assert partition(47, evaluate=False) % 7 == 0
+    assert partition(7*m + 5) % 7 == 0
+    assert partition(50, evaluate=False) % 11 == 0
+    assert partition(11*m + 6) % 11 == 0
+
+
+def test_divisor_sigma():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: divisor_sigma(m))
+    raises(TypeError, lambda: divisor_sigma(4.5))
+    raises(TypeError, lambda: divisor_sigma(1, m))
+    raises(TypeError, lambda: divisor_sigma(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: divisor_sigma(m))
+    raises(ValueError, lambda: divisor_sigma(0))
+    m = Symbol('m', negative=True)
+    raises(ValueError, lambda: divisor_sigma(1, m))
+    raises(ValueError, lambda: divisor_sigma(1, -1))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert divisor_sigma(p, 1) == p + 1
+    assert divisor_sigma(p, k) == p**k + 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert divisor_sigma(n).is_integer is True
+    assert divisor_sigma(n).is_positive is True
+
+    # symbolic
+    k = Symbol('k', integer=True, zero=False)
+    assert divisor_sigma(4, k) == 2**(2*k) + 2**k + 1
+    assert divisor_sigma(6, k) == (2**k + 1) * (3**k + 1)
+
+    # Integer
+    assert divisor_sigma(23450) == 50592
+    assert divisor_sigma(23450, 0) == 24
+    assert divisor_sigma(23450, 1) == 50592
+    assert divisor_sigma(23450, 2) == 730747500
+    assert divisor_sigma(23450, 3) == 14666785333344
+
+
+def test_udivisor_sigma():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: udivisor_sigma(m))
+    raises(TypeError, lambda: udivisor_sigma(4.5))
+    raises(TypeError, lambda: udivisor_sigma(1, m))
+    raises(TypeError, lambda: udivisor_sigma(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: udivisor_sigma(m))
+    raises(ValueError, lambda: udivisor_sigma(0))
+    m = Symbol('m', negative=True)
+    raises(ValueError, lambda: udivisor_sigma(1, m))
+    raises(ValueError, lambda: udivisor_sigma(1, -1))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert udivisor_sigma(p, 1) == p + 1
+    assert udivisor_sigma(p, k) == p**k + 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert udivisor_sigma(n).is_integer is True
+    assert udivisor_sigma(n).is_positive is True
+
+    # Integer
+    A034444 = [1, 2, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4, 2, 4, 4, 2, 2, 4, 2, 4,
+               4, 4, 2, 4, 2, 4, 2, 4, 2, 8, 2, 2, 4, 4, 4, 4, 2, 4, 4, 4,
+               2, 8, 2, 4, 4, 4, 2, 4, 2, 4, 4, 4, 2, 4, 4, 4, 4, 4, 2, 8]
+    for n, val in enumerate(A034444, 1):
+        assert udivisor_sigma(n, 0) == val
+    A034448 = [1, 3, 4, 5, 6, 12, 8, 9, 10, 18, 12, 20, 14, 24, 24, 17, 18,
+               30, 20, 30, 32, 36, 24, 36, 26, 42, 28, 40, 30, 72, 32, 33,
+               48, 54, 48, 50, 38, 60, 56, 54, 42, 96, 44, 60, 60, 72, 48]
+    for n, val in enumerate(A034448, 1):
+        assert udivisor_sigma(n, 1) == val
+    A034676 = [1, 5, 10, 17, 26, 50, 50, 65, 82, 130, 122, 170, 170, 250,
+               260, 257, 290, 410, 362, 442, 500, 610, 530, 650, 626, 850,
+               730, 850, 842, 1300, 962, 1025, 1220, 1450, 1300, 1394, 1370]
+    for n, val in enumerate(A034676, 1):
+        assert udivisor_sigma(n, 2) == val
+
+
+def test_legendre_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: legendre_symbol(m, 3))
+    raises(TypeError, lambda: legendre_symbol(4.5, 3))
+    raises(TypeError, lambda: legendre_symbol(1, m))
+    raises(TypeError, lambda: legendre_symbol(1, 4.5))
+    m = Symbol('m', prime=False)
+    raises(ValueError, lambda: legendre_symbol(1, m))
+    raises(ValueError, lambda: legendre_symbol(1, 6))
+    m = Symbol('m', odd=False)
+    raises(ValueError, lambda: legendre_symbol(1, m))
+    raises(ValueError, lambda: legendre_symbol(1, 2))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert legendre_symbol(p*k, p) == 0
+    assert legendre_symbol(1, p) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert legendre_symbol(m, n).is_integer is True
+    assert legendre_symbol(m, n).is_prime is False
+
+    # Integer
+    assert legendre_symbol(5, 11) == 1
+    assert legendre_symbol(25, 41) == 1
+    assert legendre_symbol(67, 101) == -1
+    assert legendre_symbol(0, 13) == 0
+    assert legendre_symbol(9, 3) == 0
+
+
+def test_jacobi_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: jacobi_symbol(m, 3))
+    raises(TypeError, lambda: jacobi_symbol(4.5, 3))
+    raises(TypeError, lambda: jacobi_symbol(1, m))
+    raises(TypeError, lambda: jacobi_symbol(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: jacobi_symbol(1, m))
+    raises(ValueError, lambda: jacobi_symbol(1, -6))
+    m = Symbol('m', odd=False)
+    raises(ValueError, lambda: jacobi_symbol(1, m))
+    raises(ValueError, lambda: jacobi_symbol(1, 2))
+
+    # special case
+    p = Symbol('p', integer=True)
+    k = Symbol('k', integer=True)
+    assert jacobi_symbol(p*k, p) == 0
+    assert jacobi_symbol(1, p) == 1
+    assert jacobi_symbol(1, 1) == 1
+    assert jacobi_symbol(0, 1) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert jacobi_symbol(m, n).is_integer is True
+    assert jacobi_symbol(m, n).is_prime is False
+
+    # Integer
+    assert jacobi_symbol(25, 41) == 1
+    assert jacobi_symbol(-23, 83) == -1
+    assert jacobi_symbol(3, 9) == 0
+    assert jacobi_symbol(42, 97) == -1
+    assert jacobi_symbol(3, 5) == -1
+    assert jacobi_symbol(7, 9) == 1
+    assert jacobi_symbol(0, 3) == 0
+    assert jacobi_symbol(0, 1) == 1
+    assert jacobi_symbol(2, 1) == 1
+    assert jacobi_symbol(1, 3) == 1
+
+
+def test_kronecker_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: kronecker_symbol(m, 3))
+    raises(TypeError, lambda: kronecker_symbol(4.5, 3))
+    raises(TypeError, lambda: kronecker_symbol(1, m))
+    raises(TypeError, lambda: kronecker_symbol(1, 4.5))
+
+    # special case
+    p = Symbol('p', integer=True)
+    assert kronecker_symbol(1, p) == 1
+    assert kronecker_symbol(1, 1) == 1
+    assert kronecker_symbol(0, 1) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert kronecker_symbol(m, n).is_integer is True
+    assert kronecker_symbol(m, n).is_prime is False
+
+    # Integer
+    for n in range(3, 10, 2):
+        for a in range(-n, n):
+            val = kronecker_symbol(a, n)
+            assert val == jacobi_symbol(a, n)
+            minus = kronecker_symbol(a, -n)
+            if a < 0:
+                assert -minus == val
+            else:
+                assert minus == val
+            even = kronecker_symbol(a, 2 * n)
+            if a % 2 == 0:
+                assert even == 0
+            elif a % 8 in [1, 7]:
+                assert even == val
+            else:
+                assert -even == val
+    assert kronecker_symbol(1, 0) == kronecker_symbol(-1, 0) == 1
+    assert kronecker_symbol(0, 0) == 0
+
+
+def test_mobius():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: mobius(m))
+    raises(TypeError, lambda: mobius(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: mobius(m))
+    raises(ValueError, lambda: mobius(-3))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert mobius(p) == -1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert mobius(n).is_integer is True
+    assert mobius(n).is_prime is False
+
+    # symbolic
+    n = Symbol('n', integer=True, positive=True)
+    k = Symbol('k', integer=True, positive=True)
+    assert mobius(n**2) == 0
+    assert mobius(4*n) == 0
+    assert isinstance(mobius(n**k), mobius)
+    assert mobius(n**(k+1)) == 0
+    assert isinstance(mobius(3**k), mobius)
+    assert mobius(3**(k+1)) == 0
+    m = Symbol('m')
+    assert isinstance(mobius(4*m), mobius)
+
+    # Integer
+    assert mobius(13*7) == 1
+    assert mobius(1) == 1
+    assert mobius(13*7*5) == -1
+    assert mobius(13**2) == 0
+    A008683 = [1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0,
+               -1, 0, 1, 1, -1, 0, 0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1,
+               1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0, 0, 1, 0, -1, 0, 1, 0]
+    for n, val in enumerate(A008683, 1):
+        assert mobius(n) == val
+
+
+def test_primenu():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: primenu(m))
+    raises(TypeError, lambda: primenu(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: primenu(m))
+    raises(ValueError, lambda: primenu(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert primenu(p) == 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primenu(n).is_integer is True
+    assert primenu(n).is_nonnegative is True
+
+    # Integer
+    assert primenu(7*13) == 2
+    assert primenu(2*17*19) == 3
+    assert primenu(2**3 * 17 * 19**2) == 3
+    A001221 = [0, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2,
+               1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 1, 2, 2, 2, 2]
+    for n, val in enumerate(A001221, 1):
+        assert primenu(n) == val
+
+
+def test_primeomega():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: primeomega(m))
+    raises(TypeError, lambda: primeomega(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: primeomega(m))
+    raises(ValueError, lambda: primeomega(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert primeomega(p) == 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primeomega(n).is_integer is True
+    assert primeomega(n).is_nonnegative is True
+
+    # Integer
+    assert primeomega(7*13) == 2
+    assert primeomega(2*17*19) == 3
+    assert primeomega(2**3 * 17 * 19**2) == 6
+    A001222 = [0, 1, 1, 2, 1, 2, 1, 3, 2, 2, 1, 3, 1, 2, 2, 4, 1, 3,
+               1, 3, 2, 2, 1, 4, 2, 2, 3, 3, 1, 3, 1, 5, 2, 2, 2, 4]
+    for n, val in enumerate(A001222, 1):
+        assert primeomega(n) == val
+
+
+def test_totient():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: totient(m))
+    raises(TypeError, lambda: totient(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: totient(m))
+    raises(ValueError, lambda: totient(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert totient(p) == p - 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert totient(n).is_integer is True
+    assert totient(n).is_positive is True
+
+    # Integer
+    assert totient(7*13) == totient(factorint(7*13)) == (7-1)*(13-1)
+    assert totient(2*17*19) == totient(factorint(2*17*19)) == (17-1)*(19-1)
+    assert totient(2**3 * 17 * 19**2) == totient({2: 3, 17: 1, 19: 2}) == 2**2 * (17-1) * 19*(19-1)
+    A000010 = [1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16,
+               6, 18, 8, 12, 10, 22, 8, 20, 12, 18, 12, 28, 8, 30, 16,
+               20, 16, 24, 12, 36, 18, 24, 16, 40, 12, 42, 20, 24, 22]
+    for n, val in enumerate(A000010, 1):
+        assert totient(n) == val
+
+
+def test_reduced_totient():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: reduced_totient(m))
+    raises(TypeError, lambda: reduced_totient(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: reduced_totient(m))
+    raises(ValueError, lambda: reduced_totient(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert reduced_totient(p) == p - 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert reduced_totient(n).is_integer is True
+    assert reduced_totient(n).is_positive is True
+
+    # Integer
+    assert reduced_totient(7*13) == reduced_totient(factorint(7*13)) == 12
+    assert reduced_totient(2*17*19) == reduced_totient(factorint(2*17*19)) == 144
+    assert reduced_totient(2**2 * 11) == reduced_totient({2: 2, 11: 1}) == 10
+    assert reduced_totient(2**3 * 17 * 19**2) == reduced_totient({2: 3, 17: 1, 19: 2}) == 2736
+    A002322 = [1, 1, 2, 2, 4, 2, 6, 2, 6, 4, 10, 2, 12, 6, 4, 4, 16, 6,
+               18, 4, 6, 10, 22, 2, 20, 12, 18, 6, 28, 4, 30, 8, 10, 16,
+               12, 6, 36, 18, 12, 4, 40, 6, 42, 10, 12, 22, 46, 4, 42]
+    for n, val in enumerate(A002322, 1):
+        assert reduced_totient(n) == val
+
+
+def test_primepi():
+    # error
+    z = Symbol('z', real=False)
+    raises(TypeError, lambda: primepi(z))
+    raises(TypeError, lambda: primepi(I))
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primepi(n).is_integer is True
+    assert primepi(n).is_nonnegative is True
+
+    # infinity
+    assert primepi(oo) == oo
+    assert primepi(-oo) == 0
+
+    # symbol
+    x = Symbol('x')
+    assert isinstance(primepi(x), primepi)
+
+    # Integer
+    assert primepi(0) == 0
+    A000720 = [0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8,
+               8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 11, 11, 11, 11, 11, 11,
+               12, 12, 12, 12, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15]
+    for n, val in enumerate(A000720, 1):
+        assert primepi(n) == primepi(n + 0.5) == val
+
+
+def test__nT():
+    assert [_nT(i, j) for i in range(5) for j in range(i + 2)] == [
+            1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 2, 1, 1, 0]
+    check = [_nT(10, i) for i in range(11)]
+    assert check == [0, 1, 5, 8, 9, 7, 5, 3, 2, 1, 1]
+    assert all(type(i) is int for i in check)
+    assert _nT(10, 5) == 7
+    assert _nT(100, 98) == 2
+    assert _nT(100, 100) == 1
+    assert _nT(10, 3) == 8
+
+
+def test_nC_nP_nT():
+    from sympy.utilities.iterables import (
+        multiset_permutations, multiset_combinations, multiset_partitions,
+        partitions, subsets, permutations)
+    from sympy.functions.combinatorial.numbers import (
+        nP, nC, nT, stirling, _stirling1, _stirling2, _multiset_histogram, _AOP_product)
+
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.core.random import choice
+
+    c = string.ascii_lowercase
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nP(s, i)
+                tot += check
+                assert len(list(multiset_permutations(s, i))) == check
+                if u:
+                    assert nP(len(s), i) == check
+            assert nP(s) == tot
+        except AssertionError:
+            print(s, i, 'failed perm test')
+            raise ValueError()
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nC(s, i)
+                tot += check
+                assert len(list(multiset_combinations(s, i))) == check
+                if u:
+                    assert nC(len(s), i) == check
+            assert nC(s) == tot
+            if u:
+                assert nC(len(s)) == tot
+        except AssertionError:
+            print(s, i, 'failed combo test')
+            raise ValueError()
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(i, j)
+            assert check.is_Integer
+            tot += check
+            assert sum(1 for p in partitions(i, j, size=True) if p[0] == j) == check
+        assert nT(i) == tot
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(range(i), j)
+            tot += check
+            assert len(list(multiset_partitions(list(range(i)), j))) == check
+        assert nT(range(i)) == tot
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(1, 8):
+                check = nT(s, i)
+                tot += check
+                assert len(list(multiset_partitions(s, i))) == check
+                if u:
+                    assert nT(range(len(s)), i) == check
+            if u:
+                assert nT(range(len(s))) == tot
+            assert nT(s) == tot
+        except AssertionError:
+            print(s, i, 'failed partition test')
+            raise ValueError()
+
+    # tests for Stirling numbers of the first kind that are not tested in the
+    # above
+    assert [stirling(9, i, kind=1) for i in range(11)] == [
+        0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
+    perms = list(permutations(range(4)))
+    assert [sum(1 for p in perms if Permutation(p).cycles == i)
+            for i in range(5)] == [0, 6, 11, 6, 1] == [
+            stirling(4, i, kind=1) for i in range(5)]
+    # http://oeis.org/A008275
+    assert [stirling(n, k, signed=1)
+        for n in range(10) for k in range(1, n + 1)] == [
+            1, -1,
+            1, 2, -3,
+            1, -6, 11, -6,
+            1, 24, -50, 35, -10,
+            1, -120, 274, -225, 85, -15,
+            1, 720, -1764, 1624, -735, 175, -21,
+            1, -5040, 13068, -13132, 6769, -1960, 322, -28,
+            1, 40320, -109584, 118124, -67284, 22449, -4536, 546, -36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
+    assert  [stirling(n, k, kind=1)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 2, 3, 1,
+            0, 6, 11, 6, 1,
+            0, 24, 50, 35, 10, 1,
+            0, 120, 274, 225, 85, 15, 1,
+            0, 720, 1764, 1624, 735, 175, 21, 1,
+            0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1,
+            0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
+    assert [stirling(n, k, kind=2)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 1, 3, 1,
+            0, 1, 7, 6, 1,
+            0, 1, 15, 25, 10, 1,
+            0, 1, 31, 90, 65, 15, 1,
+            0, 1, 63, 301, 350, 140, 21, 1,
+            0, 1, 127, 966, 1701, 1050, 266, 28, 1,
+            0, 1, 255, 3025, 7770, 6951, 2646, 462, 36, 1]
+    assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
+    raises(ValueError, lambda: stirling(-2, 2))
+
+    # Assertion that the return type is SymPy Integer.
+    assert isinstance(_stirling1(6, 3), Integer)
+    assert isinstance(_stirling2(6, 3), Integer)
+
+    def delta(p):
+        if len(p) == 1:
+            return oo
+        return min(abs(i[0] - i[1]) for i in subsets(p, 2))
+    parts = multiset_partitions(range(5), 3)
+    d = 2
+    assert (sum(1 for p in parts if all(delta(i) >= d for i in p)) ==
+            stirling(5, 3, d=d) == 7)
+
+    # other coverage tests
+    assert nC('abb', 2) == nC('aab', 2) == 2
+    assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
+    assert nP(3, 4) == 0
+    assert nP('aabc', 5) == 0
+    assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
+        len(list(multiset_combinations('aabbccdd', 2))) == 10
+    assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
+    assert nC(list('abcdd'), 4) == 4
+    assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
+    assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
+    assert nC('aabb'*3, 3) == 4  # aaa, bbb, abb, baa
+    assert dict(_AOP_product((4,1,1,1))) == {
+        0: 1, 1: 4, 2: 7, 3: 8, 4: 8, 5: 7, 6: 4, 7: 1}
+    # the following was the first t that showed a problem in a previous form of
+    # the function, so it's not as random as it may appear
+    t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
+    assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
+    raises(ValueError, lambda: _multiset_histogram({1:'a'}))
+
+
+def test_PR_14617():
+    from sympy.functions.combinatorial.numbers import nT
+    for n in (0, []):
+        for k in (-1, 0, 1):
+            if k == 0:
+                assert nT(n, k) == 1
+            else:
+                assert nT(n, k) == 0
+
+
+def test_issue_8496():
+    n = Symbol("n")
+    k = Symbol("k")
+
+    raises(TypeError, lambda: catalan(n, k))
+
+
+def test_issue_8601():
+    n = Symbol('n', integer=True, negative=True)
+
+    assert catalan(n - 1) is S.Zero
+    assert catalan(Rational(-1, 2)) is S.ComplexInfinity
+    assert catalan(-S.One) == Rational(-1, 2)
+    c1 = catalan(-5.6).evalf()
+    assert str(c1) == '6.93334070531408e-5'
+    c2 = catalan(-35.4).evalf()
+    assert str(c2) == '-4.14189164517449e-24'
+
+
+def test_motzkin():
+    assert motzkin.is_motzkin(4) == True
+    assert motzkin.is_motzkin(9) == True
+    assert motzkin.is_motzkin(10) == False
+    assert motzkin.find_motzkin_numbers_in_range(10,200) == [21, 51, 127]
+    assert motzkin.find_motzkin_numbers_in_range(10,400) == [21, 51, 127, 323]
+    assert motzkin.find_motzkin_numbers_in_range(10,1600) == [21, 51, 127, 323, 835]
+    assert motzkin.find_first_n_motzkins(5) == [1, 1, 2, 4, 9]
+    assert motzkin.find_first_n_motzkins(7) == [1, 1, 2, 4, 9, 21, 51]
+    assert motzkin.find_first_n_motzkins(10) == [1, 1, 2, 4, 9, 21, 51, 127, 323, 835]
+    raises(ValueError, lambda: motzkin.eval(77.58))
+    raises(ValueError, lambda: motzkin.eval(-8))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(-2,7))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(13,7))
+    raises(ValueError, lambda: motzkin.find_first_n_motzkins(112.8))
+
+
+def test_nD_derangements():
+    from sympy.utilities.iterables import (partitions, multiset,
+        multiset_derangements, multiset_permutations)
+    from sympy.functions.combinatorial.numbers import nD
+
+    got = []
+    for i in partitions(8, k=4):
+        s = []
+        it = 0
+        for k, v in i.items():
+            for i in range(v):
+                s.extend([it]*k)
+                it += 1
+        ms = multiset(s)
+        c1 = sum(1 for i in multiset_permutations(s) if
+            all(i != j for i, j in zip(i, s)))
+        assert c1 == nD(ms) == nD(ms, 0) == nD(ms, 1)
+        v = [tuple(i) for i in multiset_derangements(s)]
+        c2 = len(v)
+        assert c2 == len(set(v))
+        assert c1 == c2
+        got.append(c1)
+    assert got == [1, 4, 6, 12, 24, 24, 61, 126, 315, 780, 297, 772,
+        2033, 5430, 14833]
+
+    assert nD('1112233456', brute=True) == nD('1112233456') == 16356
+    assert nD('') == nD([]) == nD({}) == 0
+    assert nD({1: 0}) == 0
+    raises(ValueError, lambda: nD({1: -1}))
+    assert nD('112') == 0
+    assert nD(i='112') == 0
+    assert [nD(n=i) for i in range(6)] == [0, 0, 1, 2, 9, 44]
+    assert nD((i for i in range(4))) == nD('0123') == 9
+    assert nD(m=(i for i in range(4))) == 3
+    assert nD(m={0: 1, 1: 1, 2: 1, 3: 1}) == 3
+    assert nD(m=[0, 1, 2, 3]) == 3
+    raises(TypeError, lambda: nD(m=0))
+    raises(TypeError, lambda: nD(-1))
+    assert nD({-1: 1, -2: 1}) == 1
+    assert nD(m={0: 3}) == 0
+    raises(ValueError, lambda: nD(i='123', n=3))
+    raises(ValueError, lambda: nD(i='123', m=(1,2)))
+    raises(ValueError, lambda: nD(n=0, m=(1,2)))
+    raises(ValueError, lambda: nD({1: -1}))
+    raises(ValueError, lambda: nD(m={-1: 1, 2: 1}))
+    raises(ValueError, lambda: nD(m={1: -1, 2: 1}))
+    raises(ValueError, lambda: nD(m=[-1, 2]))
+    raises(TypeError, lambda: nD({1: x}))
+    raises(TypeError, lambda: nD(m={1: x}))
+    raises(TypeError, lambda: nD(m={x: 1}))
+
+
+def test_deprecated_ntheory_symbolic_functions():
+    from sympy.testing.pytest import warns_deprecated_sympy
+
+    with warns_deprecated_sympy():
+        assert not carmichael.is_carmichael(3)
+    with warns_deprecated_sympy():
+        assert carmichael.find_carmichael_numbers_in_range(10, 20) == []
+    with warns_deprecated_sympy():
+        assert carmichael.find_first_n_carmichaels(1)

.venv/lib/python3.13/site-packages/sympy/functions/elementary/__init__.py

@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.elementary

.venv/lib/python3.13/site-packages/sympy/functions/elementary/_trigonometric_special.py

@@ -0,0 +1,261 @@
+r"""A module for special angle formulas for trigonometric functions
+
+TODO
+====
+
+This module should be developed in the future to contain direct square root
+representation of
+
+.. math
+    F(\frac{n}{m} \pi)
+
+for every
+
+- $m \in \{ 3, 5, 17, 257, 65537 \}$
+- $n \in \mathbb{N}$, $0 \le n < m$
+- $F \in \{\sin, \cos, \tan, \csc, \sec, \cot\}$
+
+Without multi-step rewrites
+(e.g. $\tan \to \cos/\sin \to \cos/\sqrt \to \ sqrt$)
+or using chebyshev identities
+(e.g. $\cos \to \cos + \cos^2 + \cdots \to \sqrt{} + \sqrt{}^2 + \cdots $),
+which are trivial to implement in sympy,
+and had used to give overly complicated expressions.
+
+The reference can be found below, if anyone may need help implementing them.
+
+References
+==========
+
+.. [*] Gottlieb, Christian. (1999). The Simple and straightforward construction
+   of the regular 257-gon. The Mathematical Intelligencer. 21. 31-37.
+   10.1007/BF03024829.
+.. [*] https://resources.wolframcloud.com/FunctionRepository/resources/Cos2PiOverFermatPrime
+"""
+from __future__ import annotations
+from typing import Callable
+from functools import reduce
+from sympy.core.expr import Expr
+from sympy.core.singleton import S
+from sympy.core.intfunc import igcdex
+from sympy.core.numbers import Integer
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core.cache import cacheit
+
+
+def migcdex(*x: int) -> tuple[tuple[int, ...], int]:
+    r"""Compute extended gcd for multiple integers.
+
+    Explanation
+    ===========
+
+    Given the integers $x_1, \cdots, x_n$ and
+    an extended gcd for multiple arguments are defined as a solution
+    $(y_1, \cdots, y_n), g$ for the diophantine equation
+    $x_1 y_1 + \cdots + x_n y_n = g$ such that
+    $g = \gcd(x_1, \cdots, x_n)$.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary._trigonometric_special import migcdex
+    >>> migcdex()
+    ((), 0)
+    >>> migcdex(4)
+    ((1,), 4)
+    >>> migcdex(4, 6)
+    ((-1, 1), 2)
+    >>> migcdex(6, 10, 15)
+    ((1, 1, -1), 1)
+    """
+    if not x:
+        return (), 0
+
+    if len(x) == 1:
+        return (1,), x[0]
+
+    if len(x) == 2:
+        u, v, h = igcdex(x[0], x[1])
+        return (u, v), h
+
+    y, g = migcdex(*x[1:])
+    u, v, h = igcdex(x[0], g)
+    return (u, *(v * i for i in y)), h
+
+
+def ipartfrac(*denoms: int) -> tuple[int, ...]:
+    r"""Compute the partial fraction decomposition.
+
+    Explanation
+    ===========
+
+    Given a rational number $\frac{1}{q_1 \cdots q_n}$ where all
+    $q_1, \cdots, q_n$ are pairwise coprime,
+
+    A partial fraction decomposition is defined as
+
+    .. math::
+        \frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}
+
+    And it can be derived from solving the following diophantine equation for
+    the $p_1, \cdots, p_n$
+
+    .. math::
+        1 = p_1 \prod_{i \ne 1}q_i + \cdots + p_n \prod_{i \ne n}q_i
+
+    Where $q_1, \cdots, q_n$ being pairwise coprime implies
+    $\gcd(\prod_{i \ne 1}q_i, \cdots, \prod_{i \ne n}q_i) = 1$,
+    which guarantees the existence of the solution.
+
+    It is sufficient to compute partial fraction decomposition only
+    for numerator $1$ because partial fraction decomposition for any
+    $\frac{n}{q_1 \cdots q_n}$ can be easily computed by multiplying
+    the result by $n$ afterwards.
+
+    Parameters
+    ==========
+
+    denoms : int
+        The pairwise coprime integer denominators $q_i$ which defines the
+        rational number $\frac{1}{q_1 \cdots q_n}$
+
+    Returns
+    =======
+
+    tuple[int, ...]
+        The list of numerators which semantically corresponds to $p_i$ of the
+        partial fraction decomposition
+        $\frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}$
+
+    Examples
+    ========
+
+    >>> from sympy import Rational, Mul
+    >>> from sympy.functions.elementary._trigonometric_special import ipartfrac
+
+    >>> denoms = 2, 3, 5
+    >>> numers = ipartfrac(2, 3, 5)
+    >>> numers
+    (1, 7, -14)
+
+    >>> Rational(1, Mul(*denoms))
+    1/30
+    >>> out = 0
+    >>> for n, d in zip(numers, denoms):
+    ...    out += Rational(n, d)
+    >>> out
+    1/30
+    """
+    if not denoms:
+        return ()
+
+    def mul(x: int, y: int) -> int:
+        return x * y
+
+    denom = reduce(mul, denoms)
+    a = [denom // x for x in denoms]
+    h, _ = migcdex(*a)
+    return h
+
+
+def fermat_coords(n: int) -> list[int] | None:
+    """If n can be factored in terms of Fermat primes with
+    multiplicity of each being 1, return those primes, else
+    None
+    """
+    primes = []
+    for p in [3, 5, 17, 257, 65537]:
+        quotient, remainder = divmod(n, p)
+        if remainder == 0:
+            n = quotient
+            primes.append(p)
+            if n == 1:
+                return primes
+    return None
+
+
+@cacheit
+def cos_3() -> Expr:
+    r"""Computes $\cos \frac{\pi}{3}$ in square roots"""
+    return S.Half
+
+
+@cacheit
+def cos_5() -> Expr:
+    r"""Computes $\cos \frac{\pi}{5}$ in square roots"""
+    return (sqrt(5) + 1) / 4
+
+
+@cacheit
+def cos_17() -> Expr:
+    r"""Computes $\cos \frac{\pi}{17}$ in square roots"""
+    return sqrt(
+        (15 + sqrt(17)) / 32 + sqrt(2) * (sqrt(17 - sqrt(17)) +
+        sqrt(sqrt(2) * (-8 * sqrt(17 + sqrt(17)) - (1 - sqrt(17))
+        * sqrt(17 - sqrt(17))) + 6 * sqrt(17) + 34)) / 32)
+
+
+@cacheit
+def cos_257() -> Expr:
+    r"""Computes $\cos \frac{\pi}{257}$ in square roots
+
+    References
+    ==========
+
+    .. [*] https://math.stackexchange.com/questions/516142/how-does-cos2-pi-257-look-like-in-real-radicals
+    .. [*] https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    def f1(a: Expr, b: Expr) -> tuple[Expr, Expr]:
+        return (a + sqrt(a**2 + b)) / 2, (a - sqrt(a**2 + b)) / 2
+
+    def f2(a: Expr, b: Expr) -> Expr:
+        return (a - sqrt(a**2 + b))/2
+
+    t1, t2 = f1(S.NegativeOne, Integer(256))
+    z1, z3 = f1(t1, Integer(64))
+    z2, z4 = f1(t2, Integer(64))
+    y1, y5 = f1(z1, 4*(5 + t1 + 2*z1))
+    y6, y2 = f1(z2, 4*(5 + t2 + 2*z2))
+    y3, y7 = f1(z3, 4*(5 + t1 + 2*z3))
+    y8, y4 = f1(z4, 4*(5 + t2 + 2*z4))
+    x1, x9 = f1(y1, -4*(t1 + y1 + y3 + 2*y6))
+    x2, x10 = f1(y2, -4*(t2 + y2 + y4 + 2*y7))
+    x3, x11 = f1(y3, -4*(t1 + y3 + y5 + 2*y8))
+    x4, x12 = f1(y4, -4*(t2 + y4 + y6 + 2*y1))
+    x5, x13 = f1(y5, -4*(t1 + y5 + y7 + 2*y2))
+    x6, x14 = f1(y6, -4*(t2 + y6 + y8 + 2*y3))
+    x15, x7 = f1(y7, -4*(t1 + y7 + y1 + 2*y4))
+    x8, x16 = f1(y8, -4*(t2 + y8 + y2 + 2*y5))
+    v1 = f2(x1, -4*(x1 + x2 + x3 + x6))
+    v2 = f2(x2, -4*(x2 + x3 + x4 + x7))
+    v3 = f2(x8, -4*(x8 + x9 + x10 + x13))
+    v4 = f2(x9, -4*(x9 + x10 + x11 + x14))
+    v5 = f2(x10, -4*(x10 + x11 + x12 + x15))
+    v6 = f2(x16, -4*(x16 + x1 + x2 + x5))
+    u1 = -f2(-v1, -4*(v2 + v3))
+    u2 = -f2(-v4, -4*(v5 + v6))
+    w1 = -2*f2(-u1, -4*u2)
+    return sqrt(sqrt(2)*sqrt(w1 + 4)/8 + S.Half)
+
+
+def cos_table() -> dict[int, Callable[[], Expr]]:
+    r"""Lazily evaluated table for $\cos \frac{\pi}{n}$ in square roots for
+    $n \in \{3, 5, 17, 257, 65537\}$.
+
+    Notes
+    =====
+
+    65537 is the only other known Fermat prime and it is nearly impossible to
+    build in the current SymPy due to performance issues.
+
+    References
+    ==========
+
+    https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    return {
+        3: cos_3,
+        5: cos_5,
+        17: cos_17,
+        257: cos_257
+    }